32 files changed, 3916 insertions, 0 deletions

diff --git a/Libraries/avrmidi/.gitignore b/Libraries/avrmidi/.gitignore
new file mode 100644
index 0000000..e53a2a5
--- /dev/null
+++ b/Libraries/avrmidi/.gitignore
@@ -0,0 +1,6 @@
+*.o
+*.hex
+*.out
+*.map
+*.swp
+*.gz
diff --git a/Libraries/avrmidi/COPYING b/Libraries/avrmidi/COPYING
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/Libraries/avrmidi/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Libraries/avrmidi/Makefile b/Libraries/avrmidi/Makefile
new file mode 100644
index 0000000..e292826
--- /dev/null
+++ b/Libraries/avrmidi/Makefile
@@ -0,0 +1,41 @@
+MCU=atmega8
+CC=avr-gcc
+OBJCOPY=avr-objcopy
+# optimize for size:
+CFLAGS=-g -mmcu=$(MCU) -Wall -Wstrict-prototypes -Os -mcall-prologues
+PORT=/dev/ttyUSB0
+PART=ATmega8
+UISP = uisp -dprog=stk500 -dserial=/dev/ttyUSB0 -dpart=$(PART)
+
+VERSION = 0.2.develop
+DISTDIR = avr-midi.${VERSION}
+
+#-------------------
+current: examples
+#-------------------
+
+examples:
+	cd examples && make
+
+.c.o:
+	@echo CC $<
+	@$(CC) -c $(CFLAGS) -Os -o $*.o $<
+
+dist: clean
+	mkdir -p ${DISTDIR}
+	cp -R COPYING Makefile *.c *.h README examples/ test/ bytequeue/ ${DISTDIR}
+	tar -czf ${DISTDIR}.tar.gz ${DISTDIR}
+	rm -rf ${DISTDIR}
+
+post: dist
+	scp ${DISTDIR}.tar.gz x37v.info:x37v.info/projects/microcontroller/avr-midi/files/
+	scp basic.c x37v.info:x37v.info/projects/microcontroller/avr-midi/
+
+clean:
+	rm -f *.o *.map *.out *.hex *.tar.gz */*.o
+	cd examples/ && make clean
+	cd test/ && make clean
+
+.PHONY: examples
+
+all: examples
diff --git a/Libraries/avrmidi/README b/Libraries/avrmidi/README
new file mode 100644
index 0000000..d253a94
--- /dev/null
+++ b/Libraries/avrmidi/README
@@ -0,0 +1,15 @@
+embedded midi is a library written by Alex Norman.
+
+This project used to be called avr-midi but it should be useful for other C
+projects, thought it is intended for embedded work, so that is why it has been
+renamed.
+
+It is licenced with the GPL v3 licence, see the file "COPYING" for more info.
+
+Please send me bug info, bug fixes, general improvements, etc.  alex@x37v.info
+
+This is the development version which has only been tested on a atmega32u2.
+
+my website is here:
+http://www.x37v.info
+
diff --git a/Libraries/avrmidi/bytequeue.c b/Libraries/avrmidi/bytequeue.c
new file mode 100644
index 0000000..e434956
--- /dev/null
+++ b/Libraries/avrmidi/bytequeue.c
@@ -0,0 +1,65 @@
+//this is a single reader [maybe multiple writer?] byte queue
+//Copyright 2008 Alex Norman
+//writen by Alex Norman 
+//
+//This file is part of avr-bytequeue.
+//
+//avr-bytequeue is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-bytequeue is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-bytequeue.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "bytequeue.h"
+#include "interrupt_setting.h"
+
+void bytequeue_init(byteQueue_t * queue, uint8_t * dataArray, byteQueueIndex_t arrayLen){
+   queue->length = arrayLen;
+   queue->data = dataArray;
+   queue->start = queue->end = 0;
+}
+
+bool bytequeue_enqueue(byteQueue_t * queue, uint8_t item){
+   interrupt_setting_t setting = store_and_clear_interrupt();
+   //full
+   if(((queue->end + 1) % queue->length) == queue->start){
+      restore_interrupt_setting(setting);
+      return false;
+   } else {
+      queue->data[queue->end] = item;
+      queue->end = (queue->end + 1) % queue->length;
+      restore_interrupt_setting(setting);
+      return true;
+   }
+}
+
+byteQueueIndex_t bytequeue_length(byteQueue_t * queue){
+   byteQueueIndex_t len;
+   interrupt_setting_t setting = store_and_clear_interrupt();
+   if(queue->end >= queue->start)
+      len = queue->end - queue->start;
+   else
+      len = (queue->length - queue->start) + queue->end;
+   restore_interrupt_setting(setting);
+   return len;
+}
+
+//we don't need to avoid interrupts if there is only one reader
+uint8_t bytequeue_get(byteQueue_t * queue, byteQueueIndex_t index){
+   return queue->data[(queue->start + index) % queue->length];
+}
+
+//we just update the start index to remove elements
+void bytequeue_remove(byteQueue_t * queue, byteQueueIndex_t numToRemove){
+   interrupt_setting_t setting = store_and_clear_interrupt();
+   queue->start = (queue->start + numToRemove) % queue->length;
+   restore_interrupt_setting(setting);
+}
+
diff --git a/Libraries/avrmidi/bytequeue.h b/Libraries/avrmidi/bytequeue.h
new file mode 100644
index 0000000..d12df50
--- /dev/null
+++ b/Libraries/avrmidi/bytequeue.h
@@ -0,0 +1,49 @@
+//this is a single reader [maybe multiple writer?] byte queue
+//Copyright 2008 Alex Norman
+//writen by Alex Norman 
+//
+//This file is part of avr-bytequeue.
+//
+//avr-bytequeue is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-bytequeue is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-bytequeue.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef BYTEQUEUE_H
+#define BYTEQUEUE_H
+#include <inttypes.h>
+#include <stdbool.h>
+
+typedef uint8_t byteQueueIndex_t;
+
+typedef struct {
+	byteQueueIndex_t start;
+	byteQueueIndex_t end;
+	byteQueueIndex_t length;
+	uint8_t * data;
+} byteQueue_t;
+
+//you must have a queue, an array of data which the queue will use, and the length of that array
+void bytequeue_init(byteQueue_t * queue, uint8_t * dataArray, byteQueueIndex_t arrayLen);
+
+//add an item to the queue, returns false if the queue is full
+bool bytequeue_enqueue(byteQueue_t * queue, uint8_t item);
+
+//get the length of the queue
+byteQueueIndex_t bytequeue_length(byteQueue_t * queue);
+
+//this grabs data at the index given [starting at queue->start]
+uint8_t bytequeue_get(byteQueue_t * queue, byteQueueIndex_t index);
+
+//update the index in the queue to reflect data that has been dealt with 
+void bytequeue_remove(byteQueue_t * queue, byteQueueIndex_t numToRemove);
+
+#endif
+
diff --git a/Libraries/avrmidi/examples/Makefile b/Libraries/avrmidi/examples/Makefile
new file mode 100644
index 0000000..00470da
--- /dev/null
+++ b/Libraries/avrmidi/examples/Makefile
@@ -0,0 +1,68 @@
+MCU=atmega8
+CC=avr-gcc
+OBJCOPY=avr-objcopy
+# optimize for size:
+CFLAGS=-g -mmcu=$(MCU) -Wall -Wstrict-prototypes -Os -mcall-prologues -I../
+PORT=/dev/ttyUSB0
+PART=ATmega8
+UISP = uisp -dprog=stk500 -dserial=/dev/ttyUSB0 -dpart=$(PART)
+
+#-------------------
+current: basic.hex
+#-------------------
+
+BASICSRC = basic.c ../midi.c ../midi_device.c ../bytequeue.c ../interrupt_setting.c serial_midi.c
+SPITSRC  = spit.c ../midi.c serial_midi.c
+
+BASICOBJ = ${BASICSRC:.c=.o}
+SPITOBJ  = ${SPITSRC:.c=.o}
+
+.c.o:
+	@echo CC $<
+	@$(CC) -c $(CFLAGS) -Os -o $*.o $<
+
+
+basic.bin : basic.out
+	$(OBJCOPY) -R .eeprom -O binary basic.out basic.bin
+
+basic.hex : basic.out
+	$(OBJCOPY) -R .eeprom -O ihex basic.out basic.hex
+
+basic.out : $(BASICOBJ)
+	$(CC) $(CFLAGS) -o basic.out -Wl,-Map,basic.map $(BASICOBJ)
+
+# load (program) the software
+load_basic: basic.hex
+	$(UISP) --erase
+	$(UISP) --upload --verify if=basic.hex -v=3 --hash=32
+
+
+spit.bin : spit.out
+	$(OBJCOPY) -R .eeprom -O binary spit.out spit.bin
+
+spit.hex : spit.out
+	$(OBJCOPY) -R .eeprom -O ihex spit.out spit.hex
+
+spit.out : $(SPITOBJ)
+	$(CC) $(CFLAGS) -o spit.out -Wl,-Map,spit.map $(SPITOBJ)
+
+load_spit: spit.hex
+	$(UISP) --erase
+	$(UISP) --upload --verify if=spit.hex -v=3 --hash=32
+
+
+fuse_mega16:
+	$(UISP) --wr_fuse_l=0x9f --wr_fuse_h=0xd0
+
+fuse_mega8:
+	$(UISP) --wr_fuse_l=0xef --wr_fuse_h=0xc9
+
+check_fuse:
+	$(UISP) --rd_fuses
+
+#-------------------
+clean:
+	rm -f *.o *.map *.out *.hex *.tar.gz
+#-------------------
+
+all: spit.hex basic.hex
diff --git a/Libraries/avrmidi/examples/basic.c b/Libraries/avrmidi/examples/basic.c
new file mode 100644
index 0000000..a4a844c
--- /dev/null
+++ b/Libraries/avrmidi/examples/basic.c
@@ -0,0 +1,127 @@
+/*
+ 
+	Here is an example of how to use avr-midi
+	this was written for an atmega16 using a 12Mhz clock in an stk500
+	the switch inputs of the STK500 are connected to PORTC
+
+	switch 0 and 1 increment and decrement [respectively] a midi program and
+	send the appropriate midi program change
+
+	switch 2 sends a note on message when the button is pushed and a note off
+	when the button is released
+
+	the rest of the switches send CC messages, a 1 when the button is down and a
+	0 when the button is released
+
+*/
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <inttypes.h>
+#include "serial_midi.h"
+
+#define MIDI_CLOCK_12MHZ_OSC 23
+#define MIDI_CLOCK_RATE MIDI_CLOCK_12MHZ_OSC
+
+//how many times to we read the buttons before we say they're valid
+#define INPUT_HISTORY 4
+
+//this is the midi channel we'll be sending on.. 0 is midi channel 1
+#define MIDI_CHAN 0
+
+int main(void) {
+	//index for looping
+	uint8_t i, j;
+	bool consistent;
+	//is the button up
+	bool up;
+	//midi program 
+	uint8_t program = 0;
+	//button inputs, for debouncing
+	uint8_t inputs[INPUT_HISTORY];
+	uint8_t curInput = 0;
+	uint8_t lastInput = 0;
+	uint8_t historyIndex = 0;
+
+	//PORTC is in input with internal pullups
+	DDRC = 0x00;
+	PORTC = 0xFF;
+
+	//init the button history
+	for(i = 0; i < INPUT_HISTORY; i++)
+		inputs[i] = 0;
+
+	//init midi, give the clock rate setting, indicate that we want only output
+	MidiDevice * midi_device = serial_midi_init(MIDI_CLOCK_RATE, true, false);
+
+	while(1){
+
+		//grab the inputs
+		inputs[historyIndex] = PINC;
+		curInput = lastInput;
+
+		//debounce inputs
+		//for each input
+		for(i = 0; i < 8; i++){
+			consistent = true;
+			//the STK500 has 1 for up and 0 for down if you're using the on board buttons
+			up = (bool)(0x1 & (inputs[0] >> i));
+			//check the history to make sure we have the same value for this input
+			//for the whole history
+			for(j = 1; j < INPUT_HISTORY; j++){
+				if(up != (bool)(0x1 & (inputs[j] >> i))){
+					consistent = false;
+					break;
+				}
+			}
+			//if we have the same value for the whole history then store it in
+			//curInput
+			if(consistent){
+				if(up) {
+					//store the current input state
+					curInput |= (1 << i);
+					//if the last input was a 0 and the current is a 1
+					if(((lastInput >> i) & 0x1) == 0){
+						//we don't do anything on up for the first two buttons
+						//send the appropriate midi data
+						if(i == 2){
+							midi_send_noteoff(midi_device, MIDI_CHAN, 64, 30);
+						} else if(i > 1)
+							midi_send_cc(midi_device, MIDI_CHAN, i - 3, 0);
+					}
+				} else {
+					//store the current input state
+					curInput &= ~(1 << i);
+					//if the last input was a 1 and the current is a 0
+					if(((lastInput >> i) & 0x1) == 1){
+						//send the appropriate midi data
+						switch(i){
+							case 0:
+								program = (program + 1) % 128;
+								midi_send_programchange(midi_device, MIDI_CHAN, program);
+								break;
+							case 1:
+								program = (program - 1) % 128;
+								midi_send_programchange(midi_device, MIDI_CHAN, program);
+								break;
+							case 2:
+								midi_send_noteon(midi_device, MIDI_CHAN, 64, 127);
+								break;
+							default:
+								midi_send_cc(midi_device, MIDI_CHAN, i - 3, 1);
+								break;
+						}
+					}
+				}
+			}
+		}
+
+		//update the history index
+		historyIndex = (historyIndex + 1) % INPUT_HISTORY;
+		//store the curInput as lastInput for the next loop
+		lastInput = curInput;
+	}
+
+	return 0;
+}
+
diff --git a/Libraries/avrmidi/examples/lufa_midi/Descriptors.c b/Libraries/avrmidi/examples/lufa_midi/Descriptors.c
new file mode 100644
index 0000000..8405b55
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/Descriptors.c
@@ -0,0 +1,329 @@
+/*

+             LUFA Library

+     Copyright (C) Dean Camera, 2010.

+

+  dean [at] fourwalledcubicle [dot] com

+           www.lufa-lib.org

+*/

+

+/*

+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

+

+  Permission to use, copy, modify, distribute, and sell this

+  software and its documentation for any purpose is hereby granted

+  without fee, provided that the above copyright notice appear in

+  all copies and that both that the copyright notice and this

+  permission notice and warranty disclaimer appear in supporting

+  documentation, and that the name of the author not be used in

+  advertising or publicity pertaining to distribution of the

+  software without specific, written prior permission.

+

+  The author disclaim all warranties with regard to this

+  software, including all implied warranties of merchantability

+  and fitness.  In no event shall the author be liable for any

+  special, indirect or consequential damages or any damages

+  whatsoever resulting from loss of use, data or profits, whether

+  in an action of contract, negligence or other tortious action,

+  arising out of or in connection with the use or performance of

+  this software.

+*/

+

+/** \file

+ *

+ *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special

+ *  computer-readable structures which the host requests upon device enumeration, to determine

+ *  the device's capabilities and functions.

+ */

+

+#include "Descriptors.h"

+

+/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall

+ *  device characteristics, including the supported USB version, control endpoint size and the

+ *  number of device configurations. The descriptor is read out by the USB host when the enumeration

+ *  process begins.

+ */

+USB_Descriptor_Device_t PROGMEM DeviceDescriptor =

+{

+	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},

+

+	.USBSpecification       = VERSION_BCD(01.10),

+	.Class                  = USB_CSCP_NoDeviceClass,

+	.SubClass               = USB_CSCP_NoDeviceSubclass,

+	.Protocol               = USB_CSCP_NoDeviceProtocol,

+

+	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,

+

+	.VendorID               = 0x03EB,

+	.ProductID              = 0x2048,

+	.ReleaseNumber          = VERSION_BCD(00.01),

+

+	.ManufacturerStrIndex   = 0x01,

+	.ProductStrIndex        = 0x02,

+	.SerialNumStrIndex      = NO_DESCRIPTOR,

+

+	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS

+};

+

+/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage

+ *  of the device in one of its supported configurations, including information about any device interfaces

+ *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting

+ *  a configuration so that the host may correctly communicate with the USB device.

+ */

+USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =

+{

+	.Config =

+		{

+			.Header                   = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},

+

+			.TotalConfigurationSize   = sizeof(USB_Descriptor_Configuration_t),

+			.TotalInterfaces          = 2,

+

+			.ConfigurationNumber      = 1,

+			.ConfigurationStrIndex    = NO_DESCRIPTOR,

+

+			.ConfigAttributes         = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),

+

+			.MaxPowerConsumption      = USB_CONFIG_POWER_MA(100)

+		},

+

+	.Audio_ControlInterface =

+		{

+			.Header                   = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

+

+			.InterfaceNumber          = 0,

+			.AlternateSetting         = 0,

+

+			.TotalEndpoints           = 0,

+

+			.Class                    = AUDIO_CSCP_AudioClass,

+			.SubClass                 = AUDIO_CSCP_ControlSubclass,

+			.Protocol                 = AUDIO_CSCP_ControlProtocol,

+

+			.InterfaceStrIndex        = NO_DESCRIPTOR

+		},

+

+	.Audio_ControlInterface_SPC =

+		{

+			.Header                   = {.Size = sizeof(USB_Audio_Descriptor_Interface_AC_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_Header,

+

+			.ACSpecification          = VERSION_BCD(01.00),

+			.TotalLength              = sizeof(USB_Audio_Descriptor_Interface_AC_t),

+

+			.InCollection             = 1,

+			.InterfaceNumber          = 1,

+		},

+

+	.Audio_StreamInterface =

+		{

+			.Header                   = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

+

+			.InterfaceNumber          = 1,

+			.AlternateSetting         = 0,

+

+			.TotalEndpoints           = 2,

+

+			.Class                    = AUDIO_CSCP_AudioClass,

+			.SubClass                 = AUDIO_CSCP_MIDIStreamingSubclass,

+			.Protocol                 = AUDIO_CSCP_StreamingProtocol,

+

+			.InterfaceStrIndex        = NO_DESCRIPTOR

+		},

+

+	.Audio_StreamInterface_SPC =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_AudioInterface_AS_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_General,

+

+			.AudioSpecification       = VERSION_BCD(01.00),

+

+			.TotalLength              = (sizeof(USB_Descriptor_Configuration_t) -

+			                             offsetof(USB_Descriptor_Configuration_t, Audio_StreamInterface_SPC))

+		},

+

+	.MIDI_In_Jack_Emb =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_InputJack_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_InputTerminal,

+

+			.JackType                 = MIDI_JACKTYPE_Embedded,

+			.JackID                   = 0x01,

+

+			.JackStrIndex             = NO_DESCRIPTOR

+		},

+

+	.MIDI_In_Jack_Ext =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_InputJack_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_InputTerminal,

+

+			.JackType                 = MIDI_JACKTYPE_External,

+			.JackID                   = 0x02,

+

+			.JackStrIndex             = NO_DESCRIPTOR

+		},

+

+	.MIDI_Out_Jack_Emb =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_OutputJack_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_OutputTerminal,

+

+			.JackType                 = MIDI_JACKTYPE_Embedded,

+			.JackID                   = 0x03,

+

+			.NumberOfPins             = 1,

+			.SourceJackID             = {0x02},

+			.SourcePinID              = {0x01},

+

+			.JackStrIndex             = NO_DESCRIPTOR

+		},

+

+	.MIDI_Out_Jack_Ext =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_OutputJack_t), .Type = DTYPE_CSInterface},

+			.Subtype                  = AUDIO_DSUBTYPE_CSInterface_OutputTerminal,

+

+			.JackType                 = MIDI_JACKTYPE_External,

+			.JackID                   = 0x04,

+

+			.NumberOfPins             = 1,

+			.SourceJackID             = {0x01},

+			.SourcePinID              = {0x01},

+

+			.JackStrIndex             = NO_DESCRIPTOR

+		},

+

+	.MIDI_In_Jack_Endpoint =

+		{

+			.Endpoint =

+				{

+					.Header              = {.Size = sizeof(USB_Audio_Descriptor_StreamEndpoint_Std_t), .Type = DTYPE_Endpoint},

+

+					.EndpointAddress     = (ENDPOINT_DESCRIPTOR_DIR_OUT | MIDI_STREAM_OUT_EPNUM),

+					.Attributes          = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),

+					.EndpointSize        = MIDI_STREAM_EPSIZE,

+					.PollingIntervalMS   = 0

+				},

+

+			.Refresh                  = 0,

+			.SyncEndpointNumber       = 0

+		},

+

+	.MIDI_In_Jack_Endpoint_SPC =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_Jack_Endpoint_t), .Type = DTYPE_CSEndpoint},

+			.Subtype                  = AUDIO_DSUBTYPE_CSEndpoint_General,

+

+			.TotalEmbeddedJacks       = 0x01,

+			.AssociatedJackID         = {0x01}

+		},

+

+	.MIDI_Out_Jack_Endpoint =

+		{

+			.Endpoint =

+				{

+					.Header              = {.Size = sizeof(USB_Audio_Descriptor_StreamEndpoint_Std_t), .Type = DTYPE_Endpoint},

+

+					.EndpointAddress     = (ENDPOINT_DESCRIPTOR_DIR_IN | MIDI_STREAM_IN_EPNUM),

+					.Attributes          = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),

+					.EndpointSize        = MIDI_STREAM_EPSIZE,

+					.PollingIntervalMS   = 0

+				},

+

+			.Refresh                  = 0,

+			.SyncEndpointNumber       = 0

+		},

+

+	.MIDI_Out_Jack_Endpoint_SPC =

+		{

+			.Header                   = {.Size = sizeof(USB_MIDI_Descriptor_Jack_Endpoint_t), .Type = DTYPE_CSEndpoint},

+			.Subtype                  = AUDIO_DSUBTYPE_CSEndpoint_General,

+

+			.TotalEmbeddedJacks       = 0x01,

+			.AssociatedJackID         = {0x03}

+		}

+};

+

+/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests

+ *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate

+ *  via the language ID table available at USB.org what languages the device supports for its string descriptors.

+ */

+USB_Descriptor_String_t PROGMEM LanguageString =

+{

+	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},

+

+	.UnicodeString          = {LANGUAGE_ID_ENG}

+};

+

+/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable

+ *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device

+ *  Descriptor.

+ */

+USB_Descriptor_String_t PROGMEM ManufacturerString =

+{

+	.Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},

+

+	.UnicodeString          = L"Dean Camera"

+};

+

+/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,

+ *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device

+ *  Descriptor.

+ */

+USB_Descriptor_String_t PROGMEM ProductString =

+{

+	.Header                 = {.Size = USB_STRING_LEN(17), .Type = DTYPE_String},

+

+	.UnicodeString          = L"embedded usb midi"

+};

+

+/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"

+ *  documentation) by the application code so that the address and size of a requested descriptor can be given

+ *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function

+ *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the

+ *  USB host.

+ */

+uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,

+                                    const uint8_t wIndex,

+                                    const void** const DescriptorAddress)

+{

+	const uint8_t  DescriptorType   = (wValue >> 8);

+	const uint8_t  DescriptorNumber = (wValue & 0xFF);

+

+	const void* Address = NULL;

+	uint16_t    Size    = NO_DESCRIPTOR;

+

+	switch (DescriptorType)

+	{

+		case DTYPE_Device:

+			Address = &DeviceDescriptor;

+			Size    = sizeof(USB_Descriptor_Device_t);

+			break;

+		case DTYPE_Configuration:

+			Address = &ConfigurationDescriptor;

+			Size    = sizeof(USB_Descriptor_Configuration_t);

+			break;

+		case DTYPE_String:

+			switch (DescriptorNumber)

+			{

+				case 0x00:

+					Address = &LanguageString;

+					Size    = pgm_read_byte(&LanguageString.Header.Size);

+					break;

+				case 0x01:

+					Address = &ManufacturerString;

+					Size    = pgm_read_byte(&ManufacturerString.Header.Size);

+					break;

+				case 0x02:

+					Address = &ProductString;

+					Size    = pgm_read_byte(&ProductString.Header.Size);

+					break;

+			}

+

+			break;

+	}

+

+	*DescriptorAddress = Address;

+	return Size;

+}

+

diff --git a/Libraries/avrmidi/examples/lufa_midi/Descriptors.h b/Libraries/avrmidi/examples/lufa_midi/Descriptors.h
new file mode 100644
index 0000000..b56fb6f
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/Descriptors.h
@@ -0,0 +1,83 @@
+/*

+             LUFA Library

+     Copyright (C) Dean Camera, 2010.

+

+  dean [at] fourwalledcubicle [dot] com

+           www.lufa-lib.org

+*/

+

+/*

+  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

+

+  Permission to use, copy, modify, distribute, and sell this

+  software and its documentation for any purpose is hereby granted

+  without fee, provided that the above copyright notice appear in

+  all copies and that both that the copyright notice and this

+  permission notice and warranty disclaimer appear in supporting

+  documentation, and that the name of the author not be used in

+  advertising or publicity pertaining to distribution of the

+  software without specific, written prior permission.

+

+  The author disclaim all warranties with regard to this

+  software, including all implied warranties of merchantability

+  and fitness.  In no event shall the author be liable for any

+  special, indirect or consequential damages or any damages

+  whatsoever resulting from loss of use, data or profits, whether

+  in an action of contract, negligence or other tortious action,

+  arising out of or in connection with the use or performance of

+  this software.

+*/

+

+/** \file

+ *

+ *  Header file for Descriptors.c.

+ */

+

+#ifndef _DESCRIPTORS_H_

+#define _DESCRIPTORS_H_

+

+	/* Includes: */

+		#include <LUFA/Drivers/USB/USB.h>

+

+		#include <avr/pgmspace.h>

+

+	/* Macros: */

+		/** Endpoint number of the MIDI streaming data IN endpoint, for device-to-host data transfers. */

+		#define MIDI_STREAM_IN_EPNUM        2

+

+		/** Endpoint number of the MIDI streaming data OUT endpoint, for host-to-device data transfers. */

+		#define MIDI_STREAM_OUT_EPNUM       1

+

+		/** Endpoint size in bytes of the Audio isochronous streaming data IN and OUT endpoints. */

+		#define MIDI_STREAM_EPSIZE          64

+

+	/* Type Defines: */

+		/** Type define for the device configuration descriptor structure. This must be defined in the

+		 *  application code, as the configuration descriptor contains several sub-descriptors which

+		 *  vary between devices, and which describe the device's usage to the host.

+		 */

+		typedef struct

+		{

+			USB_Descriptor_Configuration_Header_t     Config;

+			USB_Descriptor_Interface_t                Audio_ControlInterface;

+			USB_Audio_Descriptor_Interface_AC_t       Audio_ControlInterface_SPC;

+			USB_Descriptor_Interface_t                Audio_StreamInterface;

+			USB_MIDI_Descriptor_AudioInterface_AS_t   Audio_StreamInterface_SPC;

+			USB_MIDI_Descriptor_InputJack_t           MIDI_In_Jack_Emb;

+			USB_MIDI_Descriptor_InputJack_t           MIDI_In_Jack_Ext;

+			USB_MIDI_Descriptor_OutputJack_t          MIDI_Out_Jack_Emb;

+			USB_MIDI_Descriptor_OutputJack_t          MIDI_Out_Jack_Ext;

+			USB_Audio_Descriptor_StreamEndpoint_Std_t MIDI_In_Jack_Endpoint;

+			USB_MIDI_Descriptor_Jack_Endpoint_t       MIDI_In_Jack_Endpoint_SPC;

+			USB_Audio_Descriptor_StreamEndpoint_Std_t MIDI_Out_Jack_Endpoint;

+			USB_MIDI_Descriptor_Jack_Endpoint_t       MIDI_Out_Jack_Endpoint_SPC;

+		} USB_Descriptor_Configuration_t;

+

+	/* Function Prototypes: */

+		uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,

+		                                    const uint8_t wIndex,

+		                                    const void** const DescriptorAddress)

+		                                    ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);

+

+#endif

+

diff --git a/Libraries/avrmidi/examples/lufa_midi/main.c b/Libraries/avrmidi/examples/lufa_midi/main.c
new file mode 100644
index 0000000..09732e6
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/main.c
@@ -0,0 +1,20 @@
+#include "midi_usb.h"
+
+//this example simply echos midi back, for now
+
+void fallthrough_callback(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   midi_send_data(device, cnt, byte0, byte1, byte2);
+}
+
+int main(void) {
+   MidiDevice usb_midi;
+
+   midi_usb_init(&usb_midi);
+   midi_register_fallthrough_callback(&usb_midi, fallthrough_callback);
+
+   while(1){
+      midi_device_process(&usb_midi);
+   }
+
+   return 0;
+}
diff --git a/Libraries/avrmidi/examples/lufa_midi/makefile b/Libraries/avrmidi/examples/lufa_midi/makefile
new file mode 100644
index 0000000..954c8fd
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/makefile
@@ -0,0 +1,719 @@
+# Hey Emacs, this is a -*- makefile -*-

+#----------------------------------------------------------------------------

+# WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al.

+#  >> Modified for use with the LUFA project. <<

+#

+# Released to the Public Domain

+#

+# Additional material for this makefile was written by:

+# Peter Fleury

+# Tim Henigan

+# Colin O'Flynn

+# Reiner Patommel

+# Markus Pfaff

+# Sander Pool

+# Frederik Rouleau

+# Carlos Lamas

+# Dean Camera

+# Opendous Inc.

+# Denver Gingerich

+#

+#----------------------------------------------------------------------------

+# On command line:

+#

+# make all = Make software.

+#

+# make clean = Clean out built project files.

+#

+# make coff = Convert ELF to AVR COFF.

+#

+# make extcoff = Convert ELF to AVR Extended COFF.

+#

+# make program = Download the hex file to the device, using avrdude.

+#                Please customize the avrdude settings below first!

+#

+# make dfu = Download the hex file to the device, using dfu-programmer (must

+#            have dfu-programmer installed).

+#

+# make flip = Download the hex file to the device, using Atmel FLIP (must

+#             have Atmel FLIP installed).

+#

+# make dfu-ee = Download the eeprom file to the device, using dfu-programmer

+#               (must have dfu-programmer installed).

+#

+# make flip-ee = Download the eeprom file to the device, using Atmel FLIP

+#                (must have Atmel FLIP installed).

+#

+# make doxygen = Generate DoxyGen documentation for the project (must have

+#                DoxyGen installed)

+#

+# make debug = Start either simulavr or avarice as specified for debugging,

+#              with avr-gdb or avr-insight as the front end for debugging.

+#

+# make filename.s = Just compile filename.c into the assembler code only.

+#

+# make filename.i = Create a preprocessed source file for use in submitting

+#                   bug reports to the GCC project.

+#

+# To rebuild project do "make clean" then "make all".

+#----------------------------------------------------------------------------

+

+

+# MCU name

+MCU = atmega32u2

+

+

+# Target board (see library "Board Types" documentation, NONE for projects not requiring

+# LUFA board drivers). If USER is selected, put custom board drivers in a directory called

+# "Board" inside the application directory.

+BOARD = NONE

+

+

+# Processor frequency.

+#     This will define a symbol, F_CPU, in all source code files equal to the

+#     processor frequency in Hz. You can then use this symbol in your source code to

+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done

+#     automatically to create a 32-bit value in your source code.

+#

+#     This will be an integer division of F_CLOCK below, as it is sourced by

+#     F_CLOCK after it has run through any CPU prescalers. Note that this value

+#     does not *change* the processor frequency - it should merely be updated to

+#     reflect the processor speed set externally so that the code can use accurate

+#     software delays.

+F_CPU = 16000000

+

+

+# Input clock frequency.

+#     This will define a symbol, F_CLOCK, in all source code files equal to the

+#     input clock frequency (before any prescaling is performed) in Hz. This value may

+#     differ from F_CPU if prescaling is used on the latter, and is required as the

+#     raw input clock is fed directly to the PLL sections of the AVR for high speed

+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'

+#     at the end, this will be done automatically to create a 32-bit value in your

+#     source code.

+#

+#     If no clock division is performed on the input clock inside the AVR (via the

+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.

+F_CLOCK = $(F_CPU)

+

+

+# Output format. (can be srec, ihex, binary)

+FORMAT = ihex

+

+

+# Target file name (without extension).

+TARGET = MIDI

+

+

+# Object files directory

+#     To put object files in current directory, use a dot (.), do NOT make

+#     this an empty or blank macro!

+OBJDIR = .

+

+

+# Path to the LUFA library

+LUFA_PATH = ../../../lufa_101122_beta3/

+

+

+# LUFA library compile-time options and predefined tokens

+LUFA_OPTS  = -D USB_DEVICE_ONLY

+LUFA_OPTS += -D FIXED_CONTROL_ENDPOINT_SIZE=8

+LUFA_OPTS += -D FIXED_NUM_CONFIGURATIONS=1

+LUFA_OPTS += -D USE_FLASH_DESCRIPTORS

+LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"

+

+

+# Create the LUFA source path variables by including the LUFA root makefile

+include $(LUFA_PATH)/LUFA/makefile

+

+

+# List C source files here. (C dependencies are automatically generated.)

+SRC = midi_usb.c   \

+	  Descriptors.c \

+	  main.c \

+	  ../../midi.c \

+	  ../../midi_device.c \

+	  ../../bytequeue/bytequeue.c \

+	  ../../bytequeue/interrupt_setting.c \

+	  $(LUFA_SRC_USB)                     \

+	  $(LUFA_SRC_USBCLASS)

+

+

+# List C++ source files here. (C dependencies are automatically generated.)

+CPPSRC =

+

+

+# List Assembler source files here.

+#     Make them always end in a capital .S.  Files ending in a lowercase .s

+#     will not be considered source files but generated files (assembler

+#     output from the compiler), and will be deleted upon "make clean"!

+#     Even though the DOS/Win* filesystem matches both .s and .S the same,

+#     it will preserve the spelling of the filenames, and gcc itself does

+#     care about how the name is spelled on its command-line.

+ASRC =

+

+

+# Optimization level, can be [0, 1, 2, 3, s].

+#     0 = turn off optimization. s = optimize for size.

+#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)

+OPT = s

+

+

+# Debugging format.

+#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.

+#     AVR Studio 4.10 requires dwarf-2.

+#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.

+DEBUG = dwarf-2

+

+

+# List any extra directories to look for include files here.

+#     Each directory must be seperated by a space.

+#     Use forward slashes for directory separators.

+#     For a directory that has spaces, enclose it in quotes.

+EXTRAINCDIRS = $(LUFA_PATH)/ ../../

+

+

+# Compiler flag to set the C Standard level.

+#     c89   = "ANSI" C

+#     gnu89 = c89 plus GCC extensions

+#     c99   = ISO C99 standard (not yet fully implemented)

+#     gnu99 = c99 plus GCC extensions

+CSTANDARD = -std=c99

+

+

+# Place -D or -U options here for C sources

+CDEFS  = -DF_CPU=$(F_CPU)UL

+CDEFS += -DF_CLOCK=$(F_CLOCK)UL

+CDEFS += -DBOARD=BOARD_$(BOARD)

+CDEFS += $(LUFA_OPTS)

+

+

+# Place -D or -U options here for ASM sources

+ADEFS  = -DF_CPU=$(F_CPU)

+ADEFS += -DF_CLOCK=$(F_CLOCK)UL

+ADEFS += -DBOARD=BOARD_$(BOARD)

+ADEFS += $(LUFA_OPTS)

+

+# Place -D or -U options here for C++ sources

+CPPDEFS  = -DF_CPU=$(F_CPU)UL

+CPPDEFS += -DF_CLOCK=$(F_CLOCK)UL

+CPPDEFS += -DBOARD=BOARD_$(BOARD)

+CPPDEFS += $(LUFA_OPTS)

+#CPPDEFS += -D__STDC_LIMIT_MACROS

+#CPPDEFS += -D__STDC_CONSTANT_MACROS

+

+

+

+#---------------- Compiler Options C ----------------

+#  -g*:          generate debugging information

+#  -O*:          optimization level

+#  -f...:        tuning, see GCC manual and avr-libc documentation

+#  -Wall...:     warning level

+#  -Wa,...:      tell GCC to pass this to the assembler.

+#    -adhlns...: create assembler listing

+CFLAGS = -g$(DEBUG)

+CFLAGS += $(CDEFS)

+CFLAGS += -O$(OPT)

+CFLAGS += -funsigned-char

+CFLAGS += -funsigned-bitfields

+CFLAGS += -ffunction-sections

+CFLAGS += -fno-inline-small-functions

+CFLAGS += -fpack-struct

+CFLAGS += -fshort-enums

+CFLAGS += -fno-strict-aliasing

+CFLAGS += -Wall

+CFLAGS += -Wstrict-prototypes

+#CFLAGS += -mshort-calls

+#CFLAGS += -fno-unit-at-a-time

+#CFLAGS += -Wundef

+#CFLAGS += -Wunreachable-code

+#CFLAGS += -Wsign-compare

+CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)

+CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))

+CFLAGS += $(CSTANDARD)

+

+

+#---------------- Compiler Options C++ ----------------

+#  -g*:          generate debugging information

+#  -O*:          optimization level

+#  -f...:        tuning, see GCC manual and avr-libc documentation

+#  -Wall...:     warning level

+#  -Wa,...:      tell GCC to pass this to the assembler.

+#    -adhlns...: create assembler listing

+CPPFLAGS = -g$(DEBUG)

+CPPFLAGS += $(CPPDEFS)

+CPPFLAGS += -O$(OPT)

+CPPFLAGS += -funsigned-char

+CPPFLAGS += -funsigned-bitfields

+CPPFLAGS += -fpack-struct

+CPPFLAGS += -fshort-enums

+CPPFLAGS += -fno-exceptions

+CPPFLAGS += -Wall

+CPPFLAGS += -Wundef

+#CPPFLAGS += -mshort-calls

+#CPPFLAGS += -fno-unit-at-a-time

+#CPPFLAGS += -Wstrict-prototypes

+#CPPFLAGS += -Wunreachable-code

+#CPPFLAGS += -Wsign-compare

+CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)

+CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))

+#CPPFLAGS += $(CSTANDARD)

+

+

+#---------------- Assembler Options ----------------

+#  -Wa,...:   tell GCC to pass this to the assembler.

+#  -adhlns:   create listing

+#  -gstabs:   have the assembler create line number information; note that

+#             for use in COFF files, additional information about filenames

+#             and function names needs to be present in the assembler source

+#             files -- see avr-libc docs [FIXME: not yet described there]

+#  -listing-cont-lines: Sets the maximum number of continuation lines of hex

+#       dump that will be displayed for a given single line of source input.

+ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100

+

+

+#---------------- Library Options ----------------

+# Minimalistic printf version

+PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

+

+# Floating point printf version (requires MATH_LIB = -lm below)

+PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

+

+# If this is left blank, then it will use the Standard printf version.

+PRINTF_LIB =

+#PRINTF_LIB = $(PRINTF_LIB_MIN)

+#PRINTF_LIB = $(PRINTF_LIB_FLOAT)

+

+

+# Minimalistic scanf version

+SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

+

+# Floating point + %[ scanf version (requires MATH_LIB = -lm below)

+SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

+

+# If this is left blank, then it will use the Standard scanf version.

+SCANF_LIB =

+#SCANF_LIB = $(SCANF_LIB_MIN)

+#SCANF_LIB = $(SCANF_LIB_FLOAT)

+

+

+MATH_LIB = -lm

+

+

+# List any extra directories to look for libraries here.

+#     Each directory must be seperated by a space.

+#     Use forward slashes for directory separators.

+#     For a directory that has spaces, enclose it in quotes.

+EXTRALIBDIRS =

+

+

+

+#---------------- External Memory Options ----------------

+

+# 64 KB of external RAM, starting after internal RAM (ATmega128!),

+# used for variables (.data/.bss) and heap (malloc()).

+#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

+

+# 64 KB of external RAM, starting after internal RAM (ATmega128!),

+# only used for heap (malloc()).

+#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff

+

+EXTMEMOPTS =

+

+

+

+#---------------- Linker Options ----------------

+#  -Wl,...:     tell GCC to pass this to linker.

+#    -Map:      create map file

+#    --cref:    add cross reference to  map file

+LDFLAGS  = -Wl,-Map=$(TARGET).map,--cref

+LDFLAGS += -Wl,--relax

+LDFLAGS += -Wl,--gc-sections

+LDFLAGS += $(EXTMEMOPTS)

+LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))

+LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)

+#LDFLAGS += -T linker_script.x

+

+

+

+#---------------- Programming Options (avrdude) ----------------

+

+# Programming hardware

+# Type: avrdude -c ?

+# to get a full listing.

+#

+AVRDUDE_PROGRAMMER = jtagmkII

+

+# com1 = serial port. Use lpt1 to connect to parallel port.

+AVRDUDE_PORT = usb

+

+AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex

+#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

+

+

+# Uncomment the following if you want avrdude's erase cycle counter.

+# Note that this counter needs to be initialized first using -Yn,

+# see avrdude manual.

+#AVRDUDE_ERASE_COUNTER = -y

+

+# Uncomment the following if you do /not/ wish a verification to be

+# performed after programming the device.

+#AVRDUDE_NO_VERIFY = -V

+

+# Increase verbosity level.  Please use this when submitting bug

+# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>

+# to submit bug reports.

+#AVRDUDE_VERBOSE = -v -v

+

+AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)

+AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)

+AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)

+AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)

+

+

+

+#---------------- Debugging Options ----------------

+

+# For simulavr only - target MCU frequency.

+DEBUG_MFREQ = $(F_CPU)

+

+# Set the DEBUG_UI to either gdb or insight.

+# DEBUG_UI = gdb

+DEBUG_UI = insight

+

+# Set the debugging back-end to either avarice, simulavr.

+DEBUG_BACKEND = avarice

+#DEBUG_BACKEND = simulavr

+

+# GDB Init Filename.

+GDBINIT_FILE = __avr_gdbinit

+

+# When using avarice settings for the JTAG

+JTAG_DEV = /dev/com1

+

+# Debugging port used to communicate between GDB / avarice / simulavr.

+DEBUG_PORT = 4242

+

+# Debugging host used to communicate between GDB / avarice / simulavr, normally

+#     just set to localhost unless doing some sort of crazy debugging when

+#     avarice is running on a different computer.

+DEBUG_HOST = localhost

+

+

+

+#============================================================================

+

+

+# Define programs and commands.

+SHELL = sh

+CC = avr-gcc

+OBJCOPY = avr-objcopy

+OBJDUMP = avr-objdump

+SIZE = avr-size

+AR = avr-ar rcs

+NM = avr-nm

+AVRDUDE = avrdude

+REMOVE = rm -f

+REMOVEDIR = rm -rf

+COPY = cp

+WINSHELL = cmd

+

+

+# Define Messages

+# English

+MSG_ERRORS_NONE = Errors: none

+MSG_BEGIN = -------- begin --------

+MSG_END = --------  end  --------

+MSG_SIZE_BEFORE = Size before:

+MSG_SIZE_AFTER = Size after:

+MSG_COFF = Converting to AVR COFF:

+MSG_EXTENDED_COFF = Converting to AVR Extended COFF:

+MSG_FLASH = Creating load file for Flash:

+MSG_EEPROM = Creating load file for EEPROM:

+MSG_EXTENDED_LISTING = Creating Extended Listing:

+MSG_SYMBOL_TABLE = Creating Symbol Table:

+MSG_LINKING = Linking:

+MSG_COMPILING = Compiling C:

+MSG_COMPILING_CPP = Compiling C++:

+MSG_ASSEMBLING = Assembling:

+MSG_CLEANING = Cleaning project:

+MSG_CREATING_LIBRARY = Creating library:

+

+

+

+

+# Define all object files.

+OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)

+

+# Define all listing files.

+LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)

+

+

+# Compiler flags to generate dependency files.

+GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d

+

+

+# Combine all necessary flags and optional flags.

+# Add target processor to flags.

+ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)

+ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)

+ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)

+

+

+

+

+

+# Default target.

+all: begin gccversion sizebefore build sizeafter end

+

+# Change the build target to build a HEX file or a library.

+build: elf hex eep lss sym

+#build: lib

+

+

+elf: $(TARGET).elf

+hex: $(TARGET).hex

+eep: $(TARGET).eep

+lss: $(TARGET).lss

+sym: $(TARGET).sym

+LIBNAME=lib$(TARGET).a

+lib: $(LIBNAME)

+

+

+

+# Eye candy.

+# AVR Studio 3.x does not check make's exit code but relies on

+# the following magic strings to be generated by the compile job.

+begin:

+	@echo

+	@echo $(MSG_BEGIN)

+

+end:

+	@echo $(MSG_END)

+	@echo

+

+

+# Display size of file.

+HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex

+ELFSIZE = $(SIZE) $(MCU_FLAG) $(FORMAT_FLAG) $(TARGET).elf

+MCU_FLAG = $(shell $(SIZE) --help | grep -- --mcu > /dev/null && echo --mcu=$(MCU) )

+FORMAT_FLAG = $(shell $(SIZE) --help | grep -- --format=.*avr > /dev/null && echo --format=avr )

+

+

+sizebefore:

+	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \

+	2>/dev/null; echo; fi

+

+sizeafter:

+	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \

+	2>/dev/null; echo; fi

+

+

+

+# Display compiler version information.

+gccversion :

+	@$(CC) --version

+

+

+# Program the device.

+program: $(TARGET).hex $(TARGET).eep

+	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)

+

+flip: $(TARGET).hex

+	batchisp -hardware usb -device $(MCU) -operation erase f

+	batchisp -hardware usb -device $(MCU) -operation loadbuffer $(TARGET).hex program

+	batchisp -hardware usb -device $(MCU) -operation start reset 0

+

+dfu: $(TARGET).hex

+	dfu-programmer $(MCU) erase

+	dfu-programmer $(MCU) flash $(TARGET).hex

+	dfu-programmer $(MCU) reset

+

+flip-ee: $(TARGET).hex $(TARGET).eep

+	$(COPY) $(TARGET).eep $(TARGET)eep.hex

+	batchisp -hardware usb -device $(MCU) -operation memory EEPROM erase

+	batchisp -hardware usb -device $(MCU) -operation memory EEPROM loadbuffer $(TARGET)eep.hex program

+	batchisp -hardware usb -device $(MCU) -operation start reset 0

+	$(REMOVE) $(TARGET)eep.hex

+

+dfu-ee: $(TARGET).hex $(TARGET).eep

+	dfu-programmer $(MCU) eeprom-flash $(TARGET).eep

+	dfu-programmer $(MCU) reset

+

+

+# Generate avr-gdb config/init file which does the following:

+#     define the reset signal, load the target file, connect to target, and set

+#     a breakpoint at main().

+gdb-config:

+	@$(REMOVE) $(GDBINIT_FILE)

+	@echo define reset >> $(GDBINIT_FILE)

+	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)

+	@echo end >> $(GDBINIT_FILE)

+	@echo file $(TARGET).elf >> $(GDBINIT_FILE)

+	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)

+ifeq ($(DEBUG_BACKEND),simulavr)

+	@echo load  >> $(GDBINIT_FILE)

+endif

+	@echo break main >> $(GDBINIT_FILE)

+

+debug: gdb-config $(TARGET).elf

+ifeq ($(DEBUG_BACKEND), avarice)

+	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.

+	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \

+	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)

+	@$(WINSHELL) /c pause

+

+else

+	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \

+	$(DEBUG_MFREQ) --port $(DEBUG_PORT)

+endif

+	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)

+

+

+

+

+# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.

+COFFCONVERT = $(OBJCOPY) --debugging

+COFFCONVERT += --change-section-address .data-0x800000

+COFFCONVERT += --change-section-address .bss-0x800000

+COFFCONVERT += --change-section-address .noinit-0x800000

+COFFCONVERT += --change-section-address .eeprom-0x810000

+

+

+

+coff: $(TARGET).elf

+	@echo

+	@echo $(MSG_COFF) $(TARGET).cof

+	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof

+

+

+extcoff: $(TARGET).elf

+	@echo

+	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof

+	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof

+

+

+

+# Create final output files (.hex, .eep) from ELF output file.

+%.hex: %.elf

+	@echo

+	@echo $(MSG_FLASH) $@

+	$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock $< $@

+

+%.eep: %.elf

+	@echo

+	@echo $(MSG_EEPROM) $@

+	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \

+	--change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0

+

+# Create extended listing file from ELF output file.

+%.lss: %.elf

+	@echo

+	@echo $(MSG_EXTENDED_LISTING) $@

+	$(OBJDUMP) -h -S -z $< > $@

+

+# Create a symbol table from ELF output file.

+%.sym: %.elf

+	@echo

+	@echo $(MSG_SYMBOL_TABLE) $@

+	$(NM) -n $< > $@

+

+

+

+# Create library from object files.

+.SECONDARY : $(TARGET).a

+.PRECIOUS : $(OBJ)

+%.a: $(OBJ)

+	@echo

+	@echo $(MSG_CREATING_LIBRARY) $@

+	$(AR) $@ $(OBJ)

+

+

+# Link: create ELF output file from object files.

+.SECONDARY : $(TARGET).elf

+.PRECIOUS : $(OBJ)

+%.elf: $(OBJ)

+	@echo

+	@echo $(MSG_LINKING) $@

+	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)

+

+

+# Compile: create object files from C source files.

+$(OBJDIR)/%.o : %.c

+	@echo

+	@echo $(MSG_COMPILING) $<

+	$(CC) -c $(ALL_CFLAGS) $< -o $@

+

+

+# Compile: create object files from C++ source files.

+$(OBJDIR)/%.o : %.cpp

+	@echo

+	@echo $(MSG_COMPILING_CPP) $<

+	$(CC) -c $(ALL_CPPFLAGS) $< -o $@

+

+

+# Compile: create assembler files from C source files.

+%.s : %.c

+	$(CC) -S $(ALL_CFLAGS) $< -o $@

+

+

+# Compile: create assembler files from C++ source files.

+%.s : %.cpp

+	$(CC) -S $(ALL_CPPFLAGS) $< -o $@

+

+

+# Assemble: create object files from assembler source files.

+$(OBJDIR)/%.o : %.S

+	@echo

+	@echo $(MSG_ASSEMBLING) $<

+	$(CC) -c $(ALL_ASFLAGS) $< -o $@

+

+

+# Create preprocessed source for use in sending a bug report.

+%.i : %.c

+	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@

+

+

+# Target: clean project.

+clean: begin clean_list end

+

+clean_list :

+	@echo

+	@echo $(MSG_CLEANING)

+	$(REMOVE) $(TARGET).hex

+	$(REMOVE) $(TARGET).eep

+	$(REMOVE) $(TARGET).cof

+	$(REMOVE) $(TARGET).elf

+	$(REMOVE) $(TARGET).map

+	$(REMOVE) $(TARGET).sym

+	$(REMOVE) $(TARGET).lss

+	$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)

+	$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)

+	$(REMOVE) $(SRC:.c=.s)

+	$(REMOVE) $(SRC:.c=.d)

+	$(REMOVE) $(SRC:.c=.i)

+	$(REMOVEDIR) .dep

+	$(REMOVE) main

+

+doxygen:

+	@echo Generating Project Documentation...

+	@doxygen Doxygen.conf

+	@echo Documentation Generation Complete.

+

+clean_doxygen:

+	rm -rf Documentation

+

+# Create object files directory

+$(shell mkdir $(OBJDIR) 2>/dev/null)

+

+

+# Include the dependency files.

+-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)

+

+

+# Listing of phony targets.

+.PHONY : all begin finish end sizebefore sizeafter gccversion \

+build elf hex eep lss sym coff extcoff doxygen clean          \

+clean_list clean_doxygen program dfu flip flip-ee dfu-ee      \

+debug gdb-config

+

diff --git a/Libraries/avrmidi/examples/lufa_midi/midi_usb.c b/Libraries/avrmidi/examples/lufa_midi/midi_usb.c
new file mode 100644
index 0000000..4a045c8
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/midi_usb.c
@@ -0,0 +1,161 @@
+/*

+ * Modified by Alex Norman (x37v.info) from Dean Camera's MIDI LUFA demo

+ * Original Copyright below

+ */

+

+/*

+   LUFA Library

+   Copyright (C) Dean Camera, 2010.

+

+   dean [at] fourwalledcubicle [dot] com

+   www.lufa-lib.org

+   */

+

+/*

+   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

+

+   Permission to use, copy, modify, distribute, and sell this

+   software and its documentation for any purpose is hereby granted

+   without fee, provided that the above copyright notice appear in

+   all copies and that both that the copyright notice and this

+   permission notice and warranty disclaimer appear in supporting

+   documentation, and that the name of the author not be used in

+   advertising or publicity pertaining to distribution of the

+   software without specific, written prior permission.

+

+   The author disclaim all warranties with regard to this

+   software, including all implied warranties of merchantability

+   and fitness.  In no event shall the author be liable for any

+   special, indirect or consequential damages or any damages

+   whatsoever resulting from loss of use, data or profits, whether

+   in an action of contract, negligence or other tortious action,

+   arising out of or in connection with the use or performance of

+   this software.

+   */

+

+#include "midi_usb.h"

+

+#include <avr/io.h>

+#include <avr/wdt.h>

+#include <avr/power.h>

+#include <avr/interrupt.h>

+#include <stdbool.h>

+

+#include "Descriptors.h"

+

+#include <LUFA/Version.h>

+#include <LUFA/Drivers/USB/USB.h>

+

+/* Function Prototypes: */

+void SetupHardware(void);

+

+void EVENT_USB_Device_Connect(void);

+void EVENT_USB_Device_Disconnect(void);

+void EVENT_USB_Device_ConfigurationChanged(void);

+void EVENT_USB_Device_ControlRequest(void);

+

+/** LUFA MIDI Class driver interface configuration and state information. This structure is

+ *  passed to all MIDI Class driver functions, so that multiple instances of the same class

+ *  within a device can be differentiated from one another.

+ */

+

+USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface =

+{

+   .Config =

+   {

+      .StreamingInterfaceNumber = 1,

+

+      .DataINEndpointNumber      = MIDI_STREAM_IN_EPNUM,

+      .DataINEndpointSize        = MIDI_STREAM_EPSIZE,

+      .DataINEndpointDoubleBank  = false,

+

+      .DataOUTEndpointNumber     = MIDI_STREAM_OUT_EPNUM,

+      .DataOUTEndpointSize       = MIDI_STREAM_EPSIZE,

+      .DataOUTEndpointDoubleBank = false,

+   },

+	};

+

+//we disregard cnt because we assume all other bytes are zero and we always send 4 bytes

+void usb_send_func(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {

+   MIDI_EventPacket_t event;

+   event.CableNumber = 0;

+   event.Command = byte0 >> 4;

+   event.Data1 = byte0;

+   event.Data2 = byte1;

+   event.Data3 = byte2;

+

+   MIDI_Device_SendEventPacket(&USB_MIDI_Interface, &event);

+   MIDI_Device_Flush(&USB_MIDI_Interface);

+   MIDI_Device_USBTask(&USB_MIDI_Interface);

+   USB_USBTask();

+}

+

+void usb_get_midi(MidiDevice * device) {

+   /* Select the MIDI OUT stream */

+   Endpoint_SelectEndpoint(MIDI_STREAM_OUT_EPNUM);

+

+   MIDI_EventPacket_t event;

+   while (MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, &event)) {

+

+      midi_packet_length_t length = midi_packet_length(event.Data1);

+

+      //pass the data to the device input function

+      //not dealing with sysex yet

+      if (length != UNDEFINED)

+         midi_device_input(device, length, event.Data1, event.Data2, event.Data3);

+

+   }

+   MIDI_Device_USBTask(&USB_MIDI_Interface);

+   USB_USBTask();

+}

+

+void midi_usb_init(MidiDevice * device){

+   midi_device_init(device);

+   midi_device_set_send_func(device, usb_send_func);

+   midi_device_set_pre_input_process_func(device, usb_get_midi);

+

+   SetupHardware();

+   sei();

+}

+

+/** Configures the board hardware and chip peripherals for the demo's functionality. */

+void SetupHardware(void)

+{

+   /* Disable watchdog if enabled by bootloader/fuses */

+   MCUSR &= ~(1 << WDRF);

+   wdt_disable();

+

+   /* Disable clock division */

+   clock_prescale_set(clock_div_1);

+

+   /* Hardware Initialization */

+   USB_Init();

+}

+

+/** Event handler for the library USB Connection event. */

+void EVENT_USB_Device_Connect(void)

+{

+   //set some LED?

+}

+

+/** Event handler for the library USB Disconnection event. */

+void EVENT_USB_Device_Disconnect(void)

+{

+   //set some LED?

+}

+

+/** Event handler for the library USB Configuration Changed event. */

+void EVENT_USB_Device_ConfigurationChanged(void)

+{

+	bool ConfigSuccess = true;

+

+	ConfigSuccess &= MIDI_Device_ConfigureEndpoints(&USB_MIDI_Interface);

+   //set some LED?

+}

+

+/** Event handler for the library USB Control Request reception event. */

+void EVENT_USB_Device_ControlRequest(void)

+{

+	MIDI_Device_ProcessControlRequest(&USB_MIDI_Interface);

+}

+

diff --git a/Libraries/avrmidi/examples/lufa_midi/midi_usb.h b/Libraries/avrmidi/examples/lufa_midi/midi_usb.h
new file mode 100644
index 0000000..551c8e0
--- /dev/null
+++ b/Libraries/avrmidi/examples/lufa_midi/midi_usb.h
@@ -0,0 +1,8 @@
+#ifndef MIDI_USB_H

+#define MIDI_USB_H

+

+#include "midi.h"

+

+void midi_usb_init(MidiDevice * device);

+

+#endif

diff --git a/Libraries/avrmidi/examples/serial_midi.c b/Libraries/avrmidi/examples/serial_midi.c
new file mode 100644
index 0000000..49c57a6
--- /dev/null
+++ b/Libraries/avrmidi/examples/serial_midi.c
@@ -0,0 +1,49 @@
+#include "serial_midi.h"
+#include <avr/interrupt.h>
+#include "stdlib.h"
+
+static MidiDevice midi_device;
+
+void serial_midi_send(MidiDevice * device, uint8_t cnt, uint8_t inByte0, uint8_t inByte1, uint8_t inByte2){
+   //we always send the first byte
+	while ( !(UCSRA & _BV(UDRE)) ); // Wait for empty transmit buffer
+	UDR = inByte0;
+   //if cnt == 2 or 3 we send the send byte
+   if(cnt > 1) {
+      while ( !(UCSRA & _BV(UDRE)) ); // Wait for empty transmit buffer
+      UDR = inByte1;
+   }
+   //if cnt == 3 we send the third byte
+   if(cnt == 3) {
+      while ( !(UCSRA & _BV(UDRE)) ); // Wait for empty transmit buffer
+      UDR = inByte2;
+   }
+}
+
+MidiDevice * serial_midi_device(void) {
+   return &midi_device;
+}
+
+MidiDevice* serial_midi_init(uint16_t clockScale, bool out, bool in){
+   //send up the device
+   midi_device_init(&midi_device);
+   midi_device_set_send_func(&midi_device, serial_midi_send);
+
+	// Set baud rate
+	UBRRH = (uint8_t)(clockScale >> 8);
+	UBRRL = (uint8_t)(clockScale & 0xFF);
+	// Enable transmitter
+	if(out)
+		UCSRB |= _BV(TXEN);
+	if(in) {
+		//Enable receiver
+		//RX Complete Interrupt Enable  (user must provide routine)
+		UCSRB |= _BV(RXEN) | _BV(RXCIE);
+	}
+	//Set frame format: Async, 8data, 1 stop bit, 1 start bit, no parity
+	//needs to have URSEL set in order to write into this reg
+	UCSRC = _BV(URSEL) | _BV(UCSZ1) | _BV(UCSZ0);
+
+   return serial_midi_device();
+}
+
diff --git a/Libraries/avrmidi/examples/serial_midi.h b/Libraries/avrmidi/examples/serial_midi.h
new file mode 100644
index 0000000..38abd4e
--- /dev/null
+++ b/Libraries/avrmidi/examples/serial_midi.h
@@ -0,0 +1,10 @@
+#ifndef SERIAL_MIDI_H
+#define SERIAL_MIDI_H
+
+#include <inttypes.h>
+#include "midi.h"
+
+//initialize serial midi and return the device pointer
+MidiDevice* serial_midi_init(uint16_t clockScale, bool out, bool in);
+
+#endif
diff --git a/Libraries/avrmidi/examples/spit.c b/Libraries/avrmidi/examples/spit.c
new file mode 100644
index 0000000..d8c989b
--- /dev/null
+++ b/Libraries/avrmidi/examples/spit.c
@@ -0,0 +1,18 @@
+#include <inttypes.h>
+#include "serial_midi.h"
+
+#define MIDI_CLOCK_12MHZ_OSC 23
+#define MIDI_CLOCK_RATE MIDI_CLOCK_12MHZ_OSC
+
+int main(void){
+	//init midi, give the clock rate setting, indicate that we want only output
+	MidiDevice * midi_device = serial_midi_init(MIDI_CLOCK_RATE, true, false);
+
+   uint8_t cnt = 0;
+   
+   while (1) {
+      midi_send_cc(midi_device, 0, 0, cnt);
+      cnt = (cnt + 1) & 0x7F;
+   }
+   return 0;
+}
diff --git a/Libraries/avrmidi/interrupt_setting.c b/Libraries/avrmidi/interrupt_setting.c
new file mode 100644
index 0000000..eafef52
--- /dev/null
+++ b/Libraries/avrmidi/interrupt_setting.c
@@ -0,0 +1,36 @@
+//Copyright 20010 Alex Norman
+//writen by Alex Norman 
+//
+//This file is part of avr-bytequeue.
+//
+//avr-bytequeue is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-bytequeue is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-bytequeue.  If not, see <http://www.gnu.org/licenses/>.
+
+
+//AVR specific code
+//should be able to port to other systems by simply providing chip specific
+//implementations of the typedef and these functions
+
+#include "interrupt_setting.h"
+#include <avr/interrupt.h>
+
+interrupt_setting_t store_and_clear_interrupt(void) {
+   uint8_t sreg = SREG;
+   cli();
+   return sreg;
+}
+
+void restore_interrupt_setting(interrupt_setting_t setting) {
+   SREG = setting;
+}
+
diff --git a/Libraries/avrmidi/interrupt_setting.h b/Libraries/avrmidi/interrupt_setting.h
new file mode 100644
index 0000000..3d2a163
--- /dev/null
+++ b/Libraries/avrmidi/interrupt_setting.h
@@ -0,0 +1,31 @@
+//Copyright 20010 Alex Norman
+//writen by Alex Norman 
+//
+//This file is part of avr-bytequeue.
+//
+//avr-bytequeue is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-bytequeue is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-bytequeue.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef INTERRUPT_SETTING_H
+#define INTERRUPT_SETTING_H
+
+#include <inttypes.h>
+
+//AVR specific typedef
+typedef uint8_t interrupt_setting_t;
+
+interrupt_setting_t store_and_clear_interrupt(void);
+void restore_interrupt_setting(interrupt_setting_t setting);
+
+#endif
+
diff --git a/Libraries/avrmidi/midi.c b/Libraries/avrmidi/midi.c
new file mode 100644
index 0000000..e58fb19
--- /dev/null
+++ b/Libraries/avrmidi/midi.c
@@ -0,0 +1,252 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "midi.h"
+#define MIN(x,y) (((x) < (y)) ? (x) : (y))
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+bool midi_is_statusbyte(uint8_t theByte){
+   return (bool)(theByte & MIDI_STATUSMASK);
+}
+
+bool midi_is_realtime(uint8_t theByte){
+   return (theByte >= MIDI_CLOCK);
+}
+
+midi_packet_length_t midi_packet_length(uint8_t status){
+   // Filter out low bit for status bytes that contain channel number, keep it for
+   // status bytes which use all 8 bits. (0xF0-0xF7)
+   switch(status < 0xF0 ? status & 0xF0 : status){
+      case MIDI_CC:
+      case MIDI_NOTEON:
+      case MIDI_NOTEOFF:
+      case MIDI_AFTERTOUCH:
+      case MIDI_PITCHBEND:
+      case MIDI_SONGPOSITION:
+         return THREE;
+      case MIDI_PROGCHANGE:
+      case MIDI_CHANPRESSURE:
+      case MIDI_SONGSELECT:
+      case MIDI_TC_QUATERFRAME:
+         return TWO;
+      case MIDI_CLOCK:
+      case MIDI_TICK:
+      case MIDI_START:
+      case MIDI_CONTINUE:
+      case MIDI_STOP:
+      case MIDI_ACTIVESENSE:
+      case MIDI_RESET:
+      case MIDI_TUNEREQUEST:
+         return ONE;
+      case SYSEX_END:
+      case SYSEX_BEGIN:
+      default:
+         return UNDEFINED;
+   }
+}
+
+void midi_send_cc(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t val){
+   //CC Status: 0xB0 to 0xBF where the low nibble is the MIDI channel.
+   //CC Data: Controller Num, Controller Val
+   device->send_func(device, 3,
+         MIDI_CC | (chan & MIDI_CHANMASK),
+         num & 0x7F,
+         val & 0x7F);
+}
+
+void midi_send_noteon(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel){
+   //Note Data: Note Num, Note Velocity
+   device->send_func(device, 3,
+         MIDI_NOTEON | (chan & MIDI_CHANMASK),
+         num & 0x7F,
+         vel & 0x7F);
+}
+
+void midi_send_noteoff(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel){
+   //Note Data: Note Num, Note Velocity
+   device->send_func(device, 3,
+         MIDI_NOTEOFF | (chan & MIDI_CHANMASK),
+         num & 0x7F,
+         vel & 0x7F);
+}
+
+void midi_send_aftertouch(MidiDevice * device, uint8_t chan, uint8_t note_num, uint8_t amt){
+   device->send_func(device, 3,
+         MIDI_AFTERTOUCH | (chan & MIDI_CHANMASK),
+         note_num & 0x7F,
+         amt & 0x7F);
+}
+
+//XXX does this work right?
+//amt in range -0x2000, 0x1fff
+//uAmt should be in range..
+//0x0000 to 0x3FFF
+void midi_send_pitchbend(MidiDevice * device, uint8_t chan, int16_t amt){
+   uint16_t uAmt;
+   //check range
+   if(amt > 0x1fff){
+      uAmt = 0x3FFF;
+   } else if(amt < -0x2000){
+      uAmt = 0;
+   } else {
+      uAmt = amt + 0x2000;
+   }
+   device->send_func(device, 3,
+         MIDI_PITCHBEND | (chan & MIDI_CHANMASK),
+         uAmt & 0x7F,
+         (uAmt >> 7) & 0x7F);
+}
+
+void midi_send_programchange(MidiDevice * device, uint8_t chan, uint8_t num){
+   device->send_func(device, 2,
+         MIDI_PROGCHANGE | (chan & MIDI_CHANMASK),
+         num & 0x7F,
+         0);
+}
+
+void midi_send_channelpressure(MidiDevice * device, uint8_t chan, uint8_t amt){
+   device->send_func(device, 2,
+         MIDI_CHANPRESSURE | (chan & MIDI_CHANMASK),
+         amt & 0x7F,
+         0);
+}
+
+void midi_send_clock(MidiDevice * device){
+   device->send_func(device, 1, MIDI_CLOCK, 0, 0);
+}
+
+void midi_send_tick(MidiDevice * device){
+   device->send_func(device, 1, MIDI_TICK, 0, 0);
+}
+
+void midi_send_start(MidiDevice * device){
+   device->send_func(device, 1, MIDI_START, 0, 0);
+}
+
+void midi_send_continue(MidiDevice * device){
+   device->send_func(device, 1, MIDI_CONTINUE, 0, 0);
+}
+
+void midi_send_stop(MidiDevice * device){
+   device->send_func(device, 1, MIDI_STOP, 0, 0);
+}
+
+void midi_send_activesense(MidiDevice * device){
+   device->send_func(device, 1, MIDI_ACTIVESENSE, 0, 0);
+}
+
+void midi_send_reset(MidiDevice * device){
+   device->send_func(device, 1, MIDI_RESET, 0, 0);
+}
+
+void midi_send_tcquaterframe(MidiDevice * device, uint8_t time){
+   device->send_func(device, 2,
+         MIDI_TC_QUATERFRAME,
+         time & 0x7F,
+         0);
+}
+
+//XXX is this right?
+void midi_send_songposition(MidiDevice * device, uint16_t pos){
+   device->send_func(device, 3,
+         MIDI_SONGPOSITION,
+         pos & 0x7F,
+         (pos >> 7) & 0x7F);
+}
+
+void midi_send_songselect(MidiDevice * device, uint8_t song){
+   device->send_func(device, 2,
+         MIDI_SONGSELECT,
+         song & 0x7F,
+         0);
+}
+
+void midi_send_tunerequest(MidiDevice * device){
+   device->send_func(device, 1, MIDI_TUNEREQUEST, 0, 0);
+}
+
+void midi_send_byte(MidiDevice * device, uint8_t b){
+   device->send_func(device, 1, b, 0, 0);
+}
+
+   void midi_send_data(MidiDevice * device, uint8_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+      if (count > 3)
+         count = 3;
+      device->send_func(device, count, byte0, byte1, byte2);
+   }
+
+
+void midi_register_cc_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_cc_callback = func;
+}
+
+void midi_register_noteon_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_noteon_callback = func;
+}
+
+void midi_register_noteoff_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_noteoff_callback = func;
+}
+
+void midi_register_aftertouch_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_aftertouch_callback = func;
+}
+
+void midi_register_pitchbend_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_pitchbend_callback = func;
+}
+
+void midi_register_songposition_callback(MidiDevice * device, midi_three_byte_func_t func){
+   device->input_songposition_callback = func;
+}
+
+void midi_register_progchange_callback(MidiDevice * device, midi_two_byte_func_t func) {
+   device->input_progchange_callback = func;
+}
+
+void midi_register_chanpressure_callback(MidiDevice * device, midi_two_byte_func_t func) {
+   device->input_chanpressure_callback = func;
+}
+
+void midi_register_songselect_callback(MidiDevice * device, midi_two_byte_func_t func) {
+   device->input_songselect_callback = func;
+}
+
+void midi_register_tc_quarterframe_callback(MidiDevice * device, midi_two_byte_func_t func) {
+   device->input_tc_quaterframe_callback = func;
+}
+
+void midi_register_realtime_callback(MidiDevice * device, midi_one_byte_func_t func){
+   device->input_realtime_callback = func;
+}
+
+void midi_register_tunerequest_callback(MidiDevice * device, midi_one_byte_func_t func){
+   device->input_tunerequest_callback = func;
+}
+
+void midi_register_fallthrough_callback(MidiDevice * device, midi_var_byte_func_t func){
+   device->input_fallthrough_callback = func;
+}
+
+void midi_register_catchall_callback(MidiDevice * device, midi_var_byte_func_t func){
+   device->input_catchall_callback = func;
+}
+
diff --git a/Libraries/avrmidi/midi.h b/Libraries/avrmidi/midi.h
new file mode 100644
index 0000000..292cf68
--- /dev/null
+++ b/Libraries/avrmidi/midi.h
@@ -0,0 +1,135 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef AVR_MIDI_H
+#define AVR_MIDI_H
+
+#include "midi_device.h"
+#include "midi_function_types.h"
+
+typedef enum {
+   UNDEFINED = 0,
+   ONE = 1,
+   TWO = 2,
+   THREE = 3} midi_packet_length_t;
+
+//general information [device independent] ****************
+//returns true if the byte given is a midi status byte
+bool midi_is_statusbyte(uint8_t theByte);
+//returns true if the byte given is a realtime status byte
+bool midi_is_realtime(uint8_t theByte);
+//returns the length of the packet associated with the status byte given
+midi_packet_length_t midi_packet_length(uint8_t status);
+
+
+//initialize midi device
+void midi_device_init(MidiDevice * device); // [implementation in midi_device.c]
+
+//process input data
+//you need to call this if you expect your input callbacks to be called
+void midi_device_process(MidiDevice * device); // [implementation in midi_device.c]
+
+
+//send functions **********************
+void midi_send_cc(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t val);
+void midi_send_noteon(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel);
+void midi_send_noteoff(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel);
+void midi_send_aftertouch(MidiDevice * device, uint8_t chan, uint8_t note_num, uint8_t amt);
+void midi_send_pitchbend(MidiDevice * device, uint8_t chan, int16_t amt); //range -8192, 8191
+void midi_send_programchange(MidiDevice * device, uint8_t chan, uint8_t num);
+void midi_send_channelpressure(MidiDevice * device, uint8_t chan, uint8_t amt);
+
+//realtime
+void midi_send_clock(MidiDevice * device);
+void midi_send_tick(MidiDevice * device);
+void midi_send_start(MidiDevice * device);
+void midi_send_continue(MidiDevice * device);
+void midi_send_stop(MidiDevice * device);
+void midi_send_activesense(MidiDevice * device);
+void midi_send_reset(MidiDevice * device);
+
+//more obscure
+void midi_send_tcquaterframe(MidiDevice * device, uint8_t time); //range 0..16383
+void midi_send_songposition(MidiDevice * device, uint16_t pos);
+void midi_send_songselect(MidiDevice * device, uint8_t song);
+void midi_send_tunerequest(MidiDevice * device);
+void midi_send_byte(MidiDevice * device, uint8_t b);
+void midi_send_data(MidiDevice * device, uint8_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+
+
+//input callback registration ***********************
+
+//three byte funcs
+void midi_register_cc_callback(MidiDevice * device, midi_three_byte_func_t func);
+void midi_register_noteon_callback(MidiDevice * device, midi_three_byte_func_t func);
+void midi_register_noteoff_callback(MidiDevice * device, midi_three_byte_func_t func);
+void midi_register_aftertouch_callback(MidiDevice * device, midi_three_byte_func_t func);
+void midi_register_pitchbend_callback(MidiDevice * device, midi_three_byte_func_t func);
+void midi_register_songposition_callback(MidiDevice * device, midi_three_byte_func_t func);
+
+//two byte funcs
+void midi_register_progchange_callback(MidiDevice * device, midi_two_byte_func_t func);
+void midi_register_chanpressure_callback(MidiDevice * device, midi_two_byte_func_t func);
+void midi_register_songselect_callback(MidiDevice * device, midi_two_byte_func_t func);
+void midi_register_tc_quarterframe_callback(MidiDevice * device, midi_two_byte_func_t func);
+
+//one byte funcs
+void midi_register_realtime_callback(MidiDevice * device, midi_one_byte_func_t func);
+void midi_register_tunerequest_callback(MidiDevice * device, midi_one_byte_func_t func);
+
+//fall through, only called if a more specific callback isn't matched and called
+void midi_register_fallthrough_callback(MidiDevice * device, midi_var_byte_func_t func);
+//catch all, always called if registered, independent of a more specific or fallthrough call
+void midi_register_catchall_callback(MidiDevice * device, midi_var_byte_func_t func);
+
+#define SYSEX_BEGIN 0xF0
+#define SYSEX_END 0xF7
+//if you and this with a byte and you get anything non-zero
+//it is a status message
+#define MIDI_STATUSMASK 0x80
+//if you and this with a status message that contains channel info,
+//you'll get the channel
+#define MIDI_CHANMASK 0x0F
+
+#define MIDI_CC 0xB0
+#define MIDI_NOTEON 0x90
+#define MIDI_NOTEOFF 0x80
+#define MIDI_AFTERTOUCH 0xA0
+#define MIDI_PITCHBEND 0xE0
+#define MIDI_PROGCHANGE 0xC0
+#define MIDI_CHANPRESSURE 0xD0
+
+//midi realtime
+#define MIDI_CLOCK 0xF8
+#define MIDI_TICK 0xF9
+#define MIDI_START 0xFA
+#define MIDI_CONTINUE 0xFB
+#define MIDI_STOP 0xFC
+#define MIDI_ACTIVESENSE 0xFE
+#define MIDI_RESET 0xFF
+
+#define MIDI_TC_QUATERFRAME 0xF1
+#define MIDI_SONGPOSITION 0xF2
+#define MIDI_SONGSELECT 0xF3
+#define MIDI_TUNEREQUEST 0xF6
+
+//This ID is for educational or development use only
+#define SYSEX_EDUMANUFID 0x7D
+
+#endif
+
diff --git a/Libraries/avrmidi/midi_device.c b/Libraries/avrmidi/midi_device.c
new file mode 100644
index 0000000..ec49eb3
--- /dev/null
+++ b/Libraries/avrmidi/midi_device.c
@@ -0,0 +1,299 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "midi_device.h"
+#include "midi.h"
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define DEBUG
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+//forward declarations, internally used to call the callbacks
+void midi_input_callbacks(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+void midi_process_byte(MidiDevice * device, uint8_t input);
+
+void midi_device_init(MidiDevice * device){
+   device->input_state = IDLE;
+   device->input_count = 0;
+   bytequeue_init(&device->input_queue, device->input_queue_data, MIDI_INPUT_QUEUE_LENGTH);
+
+   //three byte funcs
+   device->input_cc_callback = NULL;
+   device->input_noteon_callback = NULL;
+   device->input_noteoff_callback = NULL;
+   device->input_aftertouch_callback = NULL;
+   device->input_pitchbend_callback = NULL;
+   device->input_songposition_callback = NULL;
+
+   //two byte funcs
+   device->input_progchange_callback = NULL;
+   device->input_chanpressure_callback = NULL;
+   device->input_songselect_callback = NULL;
+   device->input_tc_quaterframe_callback = NULL;
+
+   //one byte funcs
+   device->input_realtime_callback = NULL;
+   device->input_tunerequest_callback = NULL;
+
+   device->input_fallthrough_callback = NULL;
+   device->input_catchall_callback = NULL;
+
+   device->pre_input_process_callback = NULL;
+}
+
+void midi_device_input(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
+   //temp storage so we can loop over the bytes
+   uint8_t input[3];
+   input[0] = byte0;
+   input[1] = byte1;
+   input[2] = byte2;
+
+   //clamp range
+   if (cnt > 3)
+      cnt = 3;
+
+   uint8_t i;
+   for (i = 0; i < cnt; i++) {
+#ifdef DEBUG
+      printf("queueing %x\n", input[i]);
+#endif
+      bytequeue_enqueue(&device->input_queue, input[i]);
+   }
+}
+
+void midi_device_set_send_func(MidiDevice * device, midi_var_byte_func_t send_func){
+   device->send_func = send_func;
+}
+
+void midi_device_set_pre_input_process_func(MidiDevice * device, midi_no_byte_func_t pre_process_func){
+   device->pre_input_process_callback = pre_process_func;
+}
+
+void midi_device_process(MidiDevice * device) {
+   //call the pre_input_process_callback if there is one
+   if(device->pre_input_process_callback)
+      device->pre_input_process_callback(device);
+
+   //pull stuff off the queue and process
+   byteQueueIndex_t len = bytequeue_length(&device->input_queue);
+   uint16_t i;
+   //TODO limit number of bytes processed?
+   for(i = 0; i < len; i++) {
+      uint8_t val = bytequeue_get(&device->input_queue, 0);
+#ifdef DEBUG
+      printf("processing %x\n", val);
+#endif
+      midi_process_byte(device, val);
+      bytequeue_remove(&device->input_queue, 1);
+   }
+}
+
+void midi_process_byte(MidiDevice * device, uint8_t input) {
+   if (midi_is_realtime(input)) {
+      //call callback, don't change any state
+      midi_input_callbacks(device, 1, input, 0, 0);
+   } else if (midi_is_statusbyte(input)) {
+      //store the byte
+      if (device->input_state != SYSEX_MESSAGE) {
+         device->input_buffer[0] = input;
+         device->input_count = 1;
+      }
+      switch (midi_packet_length(input)) {
+         case ONE:
+            device->input_state = IDLE;
+            midi_input_callbacks(device, 1, input, 0, 0);
+            break;
+         case TWO:
+            device->input_state = TWO_BYTE_MESSAGE;
+            break;
+         case THREE:
+            device->input_state = THREE_BYTE_MESSAGE;
+            break;
+         case UNDEFINED:
+            switch(input) {
+               case SYSEX_BEGIN:
+                  device->input_state = SYSEX_MESSAGE;
+                  device->input_buffer[0] = input;
+                  device->input_count = 1;
+                  break;
+               case SYSEX_END:
+                  //failsafe, should never happen
+                  if(device->input_count > 2) {
+                     device->input_state = IDLE;
+                     device->input_count = 2;
+                  }
+                  //send what is left in the input buffer, set idle
+                  device->input_buffer[device->input_count] = input;
+                  device->input_state = IDLE;
+                  device->input_count += 1;
+                  //call the callback
+                  midi_input_callbacks(device, device->input_count,
+                        device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
+                  break;
+               default:
+                  device->input_state = IDLE;
+                  device->input_count = 0;
+            }
+
+            break;
+         default:
+            device->input_state = IDLE;
+            device->input_count = 0;
+            break;
+      }
+   } else {
+      //failsafe, should never happen
+//      if(device->input_count > 2)
+//      {
+//         device->input_state = IDLE;
+//      }
+      if (device->input_state != IDLE) {
+         //store the byte
+         device->input_buffer[device->input_count] = input;
+         //increment count
+         device->input_count += 1;
+         switch(device->input_count%4) {
+            case 3:
+//               if (device->input_state != SYSEX_MESSAGE)
+//                  device->input_state = IDLE;
+               device->input_count = 1;
+               //call callback
+               midi_input_callbacks(device, 3,
+                     device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
+               break;
+            case 2:
+               if (device->input_state == TWO_BYTE_MESSAGE) {
+                  device->input_count = 1;
+                  //device->input_state = IDLE;
+                  //call callback
+                  midi_input_callbacks(device, 2, device->input_buffer[0], device->input_buffer[1], 0);
+               }
+               break;
+            case 1:
+            default:
+               if (device->input_state == SYSEX_MESSAGE)
+               {
+                  //call callback
+                  midi_input_callbacks(device, 1, device->input_buffer[0], 0, 0);
+                  device->input_count = 1;
+               } else {
+                  //shouldn't happen
+                  //device->input_state = IDLE;
+               }
+               break;
+         }
+      }
+   }
+}
+
+void midi_input_callbacks(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
+#ifdef DEBUG
+   printf("callback func %d %x %x %x\n", cnt, byte0, byte1, byte2);
+#endif
+   //did we end up calling a callback?
+   bool called = false;
+   switch (cnt) {
+      case 3:
+         {
+            midi_three_byte_func_t func = NULL;
+            switch (byte0 & 0xF0) {
+               case MIDI_CC:
+                  func = device->input_cc_callback;
+                  break;
+               case MIDI_NOTEON:
+                  func = device->input_noteon_callback;
+                  break;
+               case MIDI_NOTEOFF:
+                  func = device->input_noteoff_callback;
+                  break;
+               case MIDI_AFTERTOUCH:
+                  func = device->input_aftertouch_callback;
+                  break;
+               case MIDI_PITCHBEND:
+                  func = device->input_pitchbend_callback;
+                  break;
+               case MIDI_SONGPOSITION:
+                  func = device->input_songposition_callback;
+                  break;
+               default:
+                  break;
+            }
+            if(func) {
+               func(device, byte0, byte1, byte2);
+               called = true;
+            }
+         }
+         break;
+      case 2:
+         {
+            midi_two_byte_func_t func = NULL;
+            switch (byte0 & 0xF0) {
+               case MIDI_PROGCHANGE:
+                  func = device->input_progchange_callback;
+                  break;
+               case MIDI_CHANPRESSURE:
+                  func = device->input_chanpressure_callback;
+                  break;
+               case MIDI_SONGSELECT:
+                  func = device->input_songselect_callback;
+                  break;
+               case MIDI_TC_QUATERFRAME:
+                  func = device->input_tc_quaterframe_callback;
+                  break;
+               default:
+                  break;
+            }
+            if(func) {
+               func(device, byte0, byte1);
+               called = true;
+            }
+         }
+         break;
+      case 1:
+         {
+            midi_one_byte_func_t func = NULL;
+            if (midi_is_realtime(byte0))
+               func = device->input_realtime_callback;
+            else if (byte0 == MIDI_TUNEREQUEST)
+               func = device->input_tunerequest_callback;
+            if (func) {
+               func(device, byte0);
+               called = true;
+            }
+         }
+         break;
+      default:
+         //just in case
+         if (cnt > 3)
+            cnt = 0;
+         break;
+   }
+
+   //if there is fallthrough default callback and we haven't called a more specific one,
+   //call the fallthrough
+   if (!called && device->input_fallthrough_callback)
+      device->input_fallthrough_callback(device, cnt, byte0, byte1, byte2);
+   //always call the catch all if it exists
+   if (device->input_catchall_callback)
+      device->input_catchall_callback(device, cnt, byte0, byte1, byte2);
+}
diff --git a/Libraries/avrmidi/midi_device.h b/Libraries/avrmidi/midi_device.h
new file mode 100644
index 0000000..d34e7b1
--- /dev/null
+++ b/Libraries/avrmidi/midi_device.h
@@ -0,0 +1,90 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef MIDI_DEVICE_H
+#define MIDI_DEVICE_H
+
+#include "midi_function_types.h"
+#include "bytequeue.h"
+
+#define MIDI_INPUT_QUEUE_LENGTH 16
+
+typedef enum {
+   IDLE, 
+   TWO_BYTE_MESSAGE = 2, 
+   THREE_BYTE_MESSAGE = 3,
+   SYSEX_MESSAGE} input_state_t;
+
+typedef void (* midi_no_byte_func_t)(MidiDevice * device);
+
+//this structure represents the input and output functions and processing data
+//for a midi device.
+//A device can represent an actual physical device [serial port, usb port] or
+//something virtual.
+//You should not need to modify this structure directly.
+struct _midi_device {
+   //output send function
+   midi_var_byte_func_t send_func;
+
+   //********input callbacks
+   //three byte funcs
+   midi_three_byte_func_t input_cc_callback;
+   midi_three_byte_func_t input_noteon_callback;
+   midi_three_byte_func_t input_noteoff_callback;
+   midi_three_byte_func_t input_aftertouch_callback;
+   midi_three_byte_func_t input_pitchbend_callback;
+   midi_three_byte_func_t input_songposition_callback;
+   //two byte funcs
+   midi_two_byte_func_t input_progchange_callback;
+   midi_two_byte_func_t input_chanpressure_callback;
+   midi_two_byte_func_t input_songselect_callback;
+   midi_two_byte_func_t input_tc_quaterframe_callback;
+   //one byte funcs
+   midi_one_byte_func_t input_realtime_callback;
+   midi_one_byte_func_t input_tunerequest_callback;
+
+   //only called if more specific callback is not matched
+   midi_var_byte_func_t input_fallthrough_callback;
+   //called if registered, independent of other callbacks
+   midi_var_byte_func_t input_catchall_callback;
+
+   //pre input processing function
+   midi_no_byte_func_t pre_input_process_callback;
+
+   //for internal input processing
+   uint8_t input_buffer[3];
+   input_state_t input_state;
+   uint8_t input_count;
+
+   //for queueing data between the input and the processing functions
+   uint8_t input_queue_data[MIDI_INPUT_QUEUE_LENGTH];
+   byteQueue_t input_queue;
+};
+
+//input processing, only used if you're creating a custom device
+void midi_device_input(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+//set send function, only used if you're creating a custom device
+//you'll most likely want the function that this calls to disable interrupts so
+//that you can call the various midi send functions without worrying about
+//locking.
+void midi_device_set_send_func(MidiDevice * device, midi_var_byte_func_t send_func);
+
+//if you need to run a function to grab input before you pass it to midi_device_input, set it here.
+void midi_device_set_pre_input_process_func(MidiDevice * device, midi_no_byte_func_t pre_process_func);
+
+#endif
diff --git a/Libraries/avrmidi/midi_function_types.h b/Libraries/avrmidi/midi_function_types.h
new file mode 100644
index 0000000..4645239
--- /dev/null
+++ b/Libraries/avrmidi/midi_function_types.h
@@ -0,0 +1,34 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef MIDI_FUNCTION_TYPES_H
+#define MIDI_FUNCTION_TYPES_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+//forward declaration
+typedef struct _midi_device MidiDevice;
+
+typedef void (* midi_one_byte_func_t)(MidiDevice * device, uint8_t byte);
+typedef void (* midi_two_byte_func_t)(MidiDevice * device, uint8_t byte0, uint8_t byte1);
+typedef void (* midi_three_byte_func_t)(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+//all bytes after count bytes should be ignored
+typedef void (* midi_var_byte_func_t)(MidiDevice * device, uint8_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
+
+#endif
diff --git a/Libraries/avrmidi/sysex_tools.c b/Libraries/avrmidi/sysex_tools.c
new file mode 100644
index 0000000..2ff8052
--- /dev/null
+++ b/Libraries/avrmidi/sysex_tools.c
@@ -0,0 +1,99 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "sysex_tools.h"
+
+uint16_t sysex_bit_packed_length(uint16_t unpacked_length){
+   uint8_t remainder = unpacked_length % 7;
+   if (remainder)
+      return (unpacked_length / 7) * 8 + remainder + 1;
+   else
+      return (unpacked_length / 7) * 8;
+}
+
+uint16_t sysex_bit_unpacked_length(uint16_t packed_length){
+   uint8_t remainder = packed_length % 8;
+   if (remainder)
+      return (packed_length / 8) * 7 + remainder - 1;
+   else
+      return (packed_length / 8) * 7;
+}
+
+uint16_t sysex_bit_pack(uint8_t *packed, const uint8_t *source, const uint16_t length){
+   uint16_t packed_full = length / 7; //number of full 8 byte sections from 7 bytes of input
+   uint16_t i,j;
+
+   //fill out the fully packed sections
+   for(i = 0; i < packed_full; i++) {
+      uint16_t packed_msb_idx = i * 8;
+      uint16_t input_start_idx = i * 7;
+      packed[packed_msb_idx] = 0;
+      for(j = 0; j < 7; j++){
+         uint8_t current = source[input_start_idx + j];
+         packed[packed_msb_idx] |= (0x80 & current) >> (1 + j);
+         packed[packed_msb_idx + 1 + j] = 0x7F & current;
+      }
+   }
+
+   //fill out the rest if there is any more
+   uint8_t remainder = length % 7;
+   if (remainder) {
+      uint16_t packed_msb_idx = packed_full * 8;
+      uint16_t input_start_idx = packed_full * 7;
+      packed[packed_msb_idx] = 0;
+      for(j = 0; j < remainder; j++){
+         uint8_t current = source[input_start_idx + j];
+         packed[packed_msb_idx] |= (0x80 & current) >> (1 + j);
+         packed[packed_msb_idx + 1 + j] = 0x7F & current;
+      }
+      return packed_msb_idx + remainder + 1;
+   } else {
+      return packed_full * 8;
+   }
+}
+
+uint16_t sysex_bit_unpack(uint8_t *unpacked, const uint8_t *source, const uint16_t length){
+   uint16_t unpacked_full = length / 8;
+   uint16_t i,j;
+
+   if (length < 2)
+      return 0;
+
+   //fill out the fully packed sections
+   for(i = 0; i < unpacked_full; i++) {
+      uint16_t packed_msb_idx = i * 8;
+      uint16_t output_start_index = i * 7;
+      for(j = 0; j < 7; j++){
+         unpacked[output_start_index + j] = 0x7F & source[packed_msb_idx + j + 1];
+         unpacked[output_start_index + j] |= (0x80 & (source[packed_msb_idx] << (1 + j)));
+      }
+   }
+   uint8_t remainder = length % 8;
+   if (remainder) {
+      uint16_t packed_msb_idx = unpacked_full * 8;
+      uint16_t output_start_index = unpacked_full * 7;
+      for(j = 0; j < (remainder - 1); j++) {
+         unpacked[output_start_index + j] = 0x7F & source[packed_msb_idx + j + 1];
+         unpacked[output_start_index + j] |= (0x80 & (source[packed_msb_idx] << (1 + j)));
+      }
+      return unpacked_full * 7 + remainder - 1;
+   } else {
+      return unpacked_full * 7;
+   }
+}
+
diff --git a/Libraries/avrmidi/sysex_tools.h b/Libraries/avrmidi/sysex_tools.h
new file mode 100644
index 0000000..df86974
--- /dev/null
+++ b/Libraries/avrmidi/sysex_tools.h
@@ -0,0 +1,78 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef SYSEX_TOOLS_H
+#define SYSEX_TOOLS_H
+
+#include <inttypes.h>
+
+/**
+ * These functions are for converting data to and from a "midi-safe" format,
+ * which can be use to send data with sysex messages.  Sysex messages may only
+ * contain data where the to bit is not set. 
+ *
+ * A bit "packed" midi message is one that contains all of the data from its
+ * original state, but does not have any of the top bits set.
+ *
+ * Every 7 bytes of unpacked data is converted into 8 bytes of packed data and
+ * visa-versa.  If you'd like to operate on small segments, make sure that you
+ * pack in 7 byte increments and unpack in 8 byte increments.
+ *
+ */
+
+/**
+ * Compute the length of a message after it is packed.
+ *
+ * @param unpacked_length The length, in bytes, of the message to pack.
+ *
+ * @return The length, in bytes, of the message after packing.
+ */
+uint16_t sysex_bit_packed_length(uint16_t unpacked_length);
+
+/**
+ * Compute the length of a message after it is unpacked.
+ *
+ * @param packed_length The length, in bytes, of the packed message.
+ *
+ * @return The length, in bytes, of the message after it is unpacked.
+ */
+uint16_t sysex_bit_unpacked_length(uint16_t packed_length);
+
+/**
+ * Pack data so that it can be transmitted safely in a sysex message.
+ *
+ * @param packed The output data buffer, must be at least sysex_bit_packed_length(length) bytes long.
+ * @param source The input buffer of data to be packed.
+ * @param length The number of bytes from the input buffer to pack.
+ * 
+ * @return number of bytes packed.
+ */
+uint16_t sysex_bit_pack(uint8_t *packed, const uint8_t *source, uint16_t length);
+
+/**
+ * Unpack packed data.
+ *
+ * @param unpacked The output data buffer, must be at least sysex_bit_unpacked_length(length) bytes long.
+ * @param source The input buffer of data to be unpacked.
+ * @param length The number of bytes from the input buffer to unpack.
+ * 
+ * @return number of bytes unpacked.
+ */
+uint16_t sysex_bit_unpack(uint8_t *unpacked, const uint8_t *source, uint16_t length);
+
+#endif
diff --git a/Libraries/avrmidi/test/.gitignore b/Libraries/avrmidi/test/.gitignore
new file mode 100644
index 0000000..9d58ef3
--- /dev/null
+++ b/Libraries/avrmidi/test/.gitignore
@@ -0,0 +1,3 @@
+test
+sysex_test
+dummy_test
diff --git a/Libraries/avrmidi/test/Makefile b/Libraries/avrmidi/test/Makefile
new file mode 100644
index 0000000..d0bcd48
--- /dev/null
+++ b/Libraries/avrmidi/test/Makefile
@@ -0,0 +1,28 @@
+CFLAGS += -I. -I../ -g -Wall -DDEBUG 
+DUMMY_SRC = dummy_device.c ../midi.c ../midi_device.c ../bytequeue.c ../interrupt_setting.c
+DUMMY_OBJ = ${DUMMY_SRC:.c=.o}
+
+SYSEX_SRC = sysex_test.c ../sysex_tools.c
+SYSEX_OBJ = ${SYSEX_SRC:.c=.o}
+
+.c.o:
+	@echo CC $<
+	@$(CC) -c $(CFLAGS) -o $*.o $<
+
+dummy_test: clean $(DUMMY_OBJ)
+	@$(CC) -o dummy_test $(DUMMY_OBJ)
+
+sysex_test: clean $(SYSEX_OBJ)
+	@$(CC) -o sysex_test $(SYSEX_OBJ)
+
+run_tests: sysex_test dummy_test
+	./dummy_test
+	./sysex_test
+
+all: run_tests
+
+#-------------------
+clean:
+	rm -f *.o *.map *.out *.hex *.tar.gz ../*.o ../bytequeue/*.o dummy_test sysex_test
+#-------------------
+
diff --git a/Libraries/avrmidi/test/avr/interrupt.h b/Libraries/avrmidi/test/avr/interrupt.h
new file mode 100644
index 0000000..8770647
--- /dev/null
+++ b/Libraries/avrmidi/test/avr/interrupt.h
@@ -0,0 +1,27 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef FAKE_AVR_INTERRUPTS_H
+#define FAKE_AVR_INTERRUPTS_H
+
+static uint8_t SREG = 0;
+
+void cli(void) {
+}
+
+#endif
diff --git a/Libraries/avrmidi/test/dummy_device.c b/Libraries/avrmidi/test/dummy_device.c
new file mode 100644
index 0000000..b76439b
--- /dev/null
+++ b/Libraries/avrmidi/test/dummy_device.c
@@ -0,0 +1,283 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "midi_device.h"
+#include "midi.h"
+#include <stdio.h>
+#include <assert.h>
+#include "bytequeue.h"
+
+#define Q_BUFLEN 8
+uint8_t buf[Q_BUFLEN];
+byteQueue_t queue;
+
+MidiDevice test_device;
+
+uint8_t sent[3];
+uint8_t got[16];
+
+bool cc_called;
+bool noteon_called;
+bool noteoff_called;
+bool aftertouch_called;
+bool pitchbend_called;
+bool songposition_called;
+bool progchange_called;
+bool chanpressure_called;
+bool songselect_called;
+bool tc_quarterframe_called;
+bool realtime_called;
+bool tunerequest_called;
+bool fallthrough_called;
+
+
+void send_func(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
+   sent[0] = byte0;
+   sent[1] = byte1;
+   sent[2] = byte0;
+   printf("sent: ");
+   uint8_t i;
+   for (i = 0; i < cnt; i++) {
+      printf("%02x ", sent[i]);
+   }
+   printf("\n");
+}
+
+void cc_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   cc_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+void noteon_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   noteon_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+void noteoff_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   noteoff_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+void aftertouch_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   aftertouch_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+void pitchbend_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   pitchbend_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+void songposition_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   songposition_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+
+void progchange_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1){
+   progchange_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+}
+void chanpressure_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1){
+   chanpressure_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+}
+void songselect_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1){
+   songselect_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+}
+void tc_quarterframe_callback(MidiDevice * device, uint8_t byte0, uint8_t byte1){
+   tc_quarterframe_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+}
+
+void realtime_callback(MidiDevice * device, uint8_t byte){
+   realtime_called = true;
+   got[0] = byte;
+}
+void tunerequest_callback(MidiDevice * device, uint8_t byte){
+   tunerequest_called = true;
+   got[0] = byte;
+}
+
+void fallthrough_callback(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   fallthrough_called = true;
+   got[0] = byte0;
+   got[1] = byte1;
+   got[2] = byte2;
+}
+
+void sysex_callback(MidiDevice * device, uint8_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2){
+   fallthrough_called = true;
+   static int index = 0;
+   fallthrough_called = true;
+   switch (cnt)
+   {
+   case 3 :
+      got[index+2] = byte2;
+   case 2:
+      got[index+1] = byte1;
+   case 1:
+      got[index+0] = byte0;
+   }
+   index += cnt;
+}
+
+void reset() {
+   uint8_t i;
+   for(i = 0; i < 3; i++)
+      got[i] = sent[i] = 0;
+   cc_called = false;
+   noteon_called = false;
+   noteoff_called = false;
+   aftertouch_called = false;
+   pitchbend_called = false;
+   songposition_called = false;
+   progchange_called = false;
+   chanpressure_called = false;
+   songselect_called = false;
+   tc_quarterframe_called = false;
+   realtime_called = false;
+   tunerequest_called = false;
+   fallthrough_called = false;
+}
+
+bool anything_called() {
+   return cc_called ||
+      noteon_called ||
+      noteoff_called ||
+      aftertouch_called ||
+      pitchbend_called ||
+      songposition_called ||
+      progchange_called ||
+      chanpressure_called ||
+      songselect_called ||
+      tc_quarterframe_called ||
+      realtime_called ||
+      tunerequest_called ||
+      fallthrough_called;
+}
+
+int main(void) {
+   bytequeue_init(&queue, buf, Q_BUFLEN);
+   uint8_t i;
+   for (i = 0; i < Q_BUFLEN - 1; i++)
+   {
+      assert(bytequeue_enqueue(&queue, i));
+      assert(bytequeue_length(&queue) == i+1);
+   }
+   assert(!bytequeue_enqueue(&queue, 0));
+   bytequeue_remove(&queue, bytequeue_length(&queue));
+   assert(bytequeue_length(&queue) == 0);
+   for (i = 0; i < Q_BUFLEN - 1; i++)
+   {
+      assert(bytequeue_enqueue(&queue, i));
+      assert(bytequeue_length(&queue) == i+1);
+   }
+   for (i = 0; i < Q_BUFLEN - 1; i++)
+   {
+      bytequeue_remove(&queue, 1);
+   }
+   assert(bytequeue_length(&queue) == 0);
+
+   midi_device_init(&test_device);
+   midi_device_set_send_func(&test_device, send_func);
+
+   midi_send_cc(&test_device, 0, 0, 1);
+   midi_send_cc(&test_device, 15, 1, 1);
+
+   midi_register_fallthrough_callback(&test_device, fallthrough_callback);
+   midi_register_realtime_callback(&test_device, realtime_callback);
+
+   assert(!fallthrough_called);
+   assert(!realtime_called);
+   midi_device_input(&test_device, 3, 0xB0, 0, 1);
+   midi_device_input(&test_device, 1, MIDI_CLOCK, 0, 0);
+   midi_device_process(&test_device);
+   assert(fallthrough_called);
+   assert(realtime_called);
+
+   reset();
+   assert(!fallthrough_called);
+   assert(!realtime_called);
+   //interspersed
+   midi_device_input(&test_device, 1, 0xB0, 0, 0);
+   midi_device_input(&test_device, 1, MIDI_CLOCK, 0, 0);
+   midi_device_input(&test_device, 1, 0, 0, 0);
+   midi_device_input(&test_device, 1, MIDI_START, 0, 0);
+   midi_device_input(&test_device, 1, 1, 0, 0);
+   midi_device_process(&test_device);
+   assert(fallthrough_called);
+   assert(realtime_called);
+
+   midi_register_cc_callback(&test_device, cc_callback);
+   assert(!cc_called);
+   midi_device_input(&test_device, 3, 0xB0, 0, 1);
+   midi_device_process(&test_device);
+   assert(cc_called);
+
+   reset();
+   assert(!cc_called);
+   assert(!realtime_called);
+   midi_device_input(&test_device, 1, 0xB0, 0, 0);
+   midi_device_input(&test_device, 1, MIDI_CLOCK, 0, 0);
+   midi_device_input(&test_device, 1, 0, 0, 0);
+   midi_device_input(&test_device, 1, MIDI_START, 0, 0);
+   midi_device_input(&test_device, 1, 1, 0, 0);
+   midi_device_process(&test_device);
+   assert(cc_called);
+   assert(realtime_called);
+
+   reset();
+   assert(!anything_called());
+   midi_device_input(&test_device, 1, 0xB0, 0, 0);
+   midi_device_input(&test_device, 1, 0, 0, 0);
+   midi_device_process(&test_device);
+   assert(!anything_called());
+
+   midi_register_fallthrough_callback(&test_device, sysex_callback);
+   midi_device_input(&test_device, 3, SYSEX_BEGIN, 0, 1);
+   midi_device_input(&test_device, 3, 2, 3, 4);
+   midi_device_input(&test_device, 2, 5, 6, 0);
+   midi_device_input(&test_device, 1, 7, 0, 0);
+   midi_device_input(&test_device, 1, SYSEX_END, 0, 0);
+   midi_device_process(&test_device);
+
+   assert(fallthrough_called);
+   assert(got[0] == SYSEX_BEGIN);
+//   uint8_t i;
+   for (i = 0; i < 8; i++)
+      assert(got[i+1] == i);
+   assert(got[9] == SYSEX_END);
+
+   assert(midi_packet_length(MIDI_NOTEON) == 3);
+   assert(midi_packet_length(MIDI_CLOCK) == 1);
+
+   printf("\n\nTEST PASSED!\n\n");
+   return 0;
+}
diff --git a/Libraries/avrmidi/test/dummy_device.h b/Libraries/avrmidi/test/dummy_device.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/Libraries/avrmidi/test/dummy_device.h
diff --git a/Libraries/avrmidi/test/sysex_test.c b/Libraries/avrmidi/test/sysex_test.c
new file mode 100644
index 0000000..73a1915
--- /dev/null
+++ b/Libraries/avrmidi/test/sysex_test.c
@@ -0,0 +1,79 @@
+//midi for embedded chips,
+//Copyright 2010 Alex Norman
+//
+//This file is part of avr-midi.
+//
+//avr-midi is free software: you can redistribute it and/or modify
+//it under the terms of the GNU General Public License as published by
+//the Free Software Foundation, either version 3 of the License, or
+//(at your option) any later version.
+//
+//avr-midi is distributed in the hope that it will be useful,
+//but WITHOUT ANY WARRANTY; without even the implied warranty of
+//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//GNU General Public License for more details.
+//
+//You should have received a copy of the GNU General Public License
+//along with avr-midi.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "sysex_tools.h"
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#define SIZE 1028
+
+int main(int argc, char * argv[]) {
+   unsigned int i, j;
+   uint8_t orig[SIZE];
+   uint8_t unpacked[SIZE];
+   uint8_t * packed = malloc(sizeof(uint8_t) * sysex_bit_packed_length(SIZE));
+   uint8_t * packed2 = malloc(sizeof(uint8_t) * sysex_bit_packed_length(SIZE));
+
+   for(i = 0; i < SIZE; i++)
+      orig[i] = rand() & 0xFF;
+
+   for (i = 1; i < 512; i++) {
+      assert(i == sysex_bit_unpacked_length(sysex_bit_packed_length(i)));
+   }
+
+   //test byte packing
+   for (i = 1; i < SIZE; i++) {
+      uint16_t res_size0 = sysex_bit_pack(packed, orig, i);
+      uint16_t res_size1 = sysex_bit_packed_length(i);
+      //printf("packed %d == %d\n", res_size0, res_size1);
+      assert(res_size0 == res_size1);
+      //make sure that the top bit isn't set
+      for (j = 0; j < res_size0; j++)
+         assert( (packed[i] & 0x80) == 0);
+      //just in case, zero out unpacked..
+      memset(unpacked, SIZE, 0);
+      res_size1 = sysex_bit_unpack(unpacked, packed, res_size0);
+      assert(i == sysex_bit_unpacked_length(res_size0));
+      //printf("unpacked %d == %d\n", res_size1, i);
+      assert(res_size1 == i);
+      res_size0 = memcmp(orig, unpacked, i);
+      assert(0 == res_size0);
+   }
+
+   for (i = 0, j = 0; i < (SIZE - 7); i += 7, j +=8) {
+      //pack in segments
+      assert(8 == sysex_bit_pack(packed2 + j, orig + i, 7));
+   }
+
+   for (i = 0, j = 0; i < (SIZE - 7); i += 7, j +=8) {
+      //pack in segments
+      assert(7 == sysex_bit_unpack(unpacked + i, packed2 + j, 8));
+   }
+   //make sure the unpacked contents are the same length
+   assert(0 == memcmp(unpacked, orig, SIZE - 7));
+   //make sure that packing in 7 byte segments is the same as packing all at once
+   assert(0 == memcmp(packed2, packed, sysex_bit_packed_length(SIZE - 7)));
+
+   free(packed);
+
+   printf("\n%s passed!\n\n", argv[0]);
+   return 0;
+}