From 05259a14bb56c599ca101caf696713d40bafdcb7 Mon Sep 17 00:00:00 2001 From: marcusw Date: Mon, 23 Aug 2010 20:33:21 +0000 Subject: [PATCH] freeze: Branched the v2 code to create a new trunk. --- CHANGELOG | 5 + LICENSE | 674 ++++++++++++++++++++++++++++++++++++++ MANIFEST.in | 3 + README | 49 +++ build_dists.bat | 3 + docs/seealso.url | 13 + examples/latency.py | 23 ++ examples/mary.py | 45 +++ examples/message_test.py | 15 + examples/spin.py | 14 + examples/test_sensors.py | 11 + install.bat | 11 + nxt-python.bmp | Bin 0 -> 158742 bytes nxt/__init__.py | 13 + nxt/bluesock.py | 78 +++++ nxt/brick.py | 220 +++++++++++++ nxt/direct.py | 216 ++++++++++++ nxt/error.py | 87 +++++ nxt/lightblueglue.py | 53 +++ nxt/locator.py | 56 ++++ nxt/motor.py | 431 ++++++++++++++++++++++++ nxt/sensor/__init__.py | 36 ++ nxt/sensor/analog.py | 41 +++ nxt/sensor/common.py | 67 ++++ nxt/sensor/digital.py | 223 +++++++++++++ nxt/sensor/generic.py | 141 ++++++++ nxt/sensor/hitechnic.py | 141 ++++++++ nxt/sensor/mindsensors.py | 147 +++++++++ nxt/system.py | 297 +++++++++++++++++ nxt/telegram.py | 118 +++++++ nxt/usbsock.py | 82 +++++ scripts/nxt_filer | 136 ++++++++ scripts/nxt_push | 42 +++ scripts/nxt_sensor_report | 107 ++++++ scripts/nxt_test | 33 ++ setup.py | 23 ++ 36 files changed, 3654 insertions(+) create mode 100644 CHANGELOG create mode 100644 LICENSE create mode 100644 MANIFEST.in create mode 100644 README create mode 100644 build_dists.bat create mode 100644 docs/seealso.url create mode 100644 examples/latency.py create mode 100644 examples/mary.py create mode 100644 examples/message_test.py create mode 100644 examples/spin.py create mode 100644 examples/test_sensors.py create mode 100644 install.bat create mode 100644 nxt-python.bmp create mode 100644 nxt/__init__.py create mode 100644 nxt/bluesock.py create mode 100644 nxt/brick.py create mode 100644 nxt/direct.py create mode 100644 nxt/error.py create mode 100644 nxt/lightblueglue.py create mode 100644 nxt/locator.py create mode 100644 nxt/motor.py create mode 100644 nxt/sensor/__init__.py create mode 100644 nxt/sensor/analog.py create mode 100644 nxt/sensor/common.py create mode 100644 nxt/sensor/digital.py create mode 100644 nxt/sensor/generic.py create mode 100644 nxt/sensor/hitechnic.py create mode 100644 nxt/sensor/mindsensors.py create mode 100644 nxt/system.py create mode 100644 nxt/telegram.py create mode 100644 nxt/usbsock.py create mode 100644 scripts/nxt_filer create mode 100644 scripts/nxt_push create mode 100644 scripts/nxt_sensor_report create mode 100644 scripts/nxt_test create mode 100644 setup.py diff --git a/CHANGELOG b/CHANGELOG new file mode 100644 index 0000000..a618c01 --- /dev/null +++ b/CHANGELOG @@ -0,0 +1,5 @@ +Wed, 18 Nov 2009 19:05:49 +0100 by rhn: +* Created this changelog +* Changed set_input_mode behaviour to take parameters. TODO: Make it remember last mode for analog sensors +* Made get_input_values() return RawReading, and added get_reading() returning named values. +* Changed the way digital sensors work, partially getting rid of metaclasses and breaking everything in the process (no access to hardware) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..818433e --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + 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. + + + Copyright (C) + + 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 . + +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: + + Copyright (C) + 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 +. + + 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 +. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..26af8c0 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,3 @@ +include docs/*.html *.url *.css *.txt +include README LICENSE +include examples/*.py diff --git a/README b/README new file mode 100644 index 0000000..98fe51d --- /dev/null +++ b/README @@ -0,0 +1,49 @@ +NXT-Python is a package for controlling a LEGO NXT robot using the Python +programming language. It can communicate using either USB or Bluetooth. It is +available under the Free Software Foundation's GPL license. It is based on +NXT_Python, where releases halted in May 2007. + +This version is part of the 2.x series of releases. Programs designed for +NXT_Python or for the 1.x series will not work with this version. If you are +trying to get an old program to work, it most likely needs a 1.x series release, +which can be downloaded from the nxt-python googlecode downloads page. + +Once your installation is working, I would really appreciate it if you could run +the nxt_sensor_report script and follow the instructions there to help improve +the digital sensor type checking system. It takes maybe 5-10 minutes and is a +way to really help out even if you have no technical skill or don't want to mess +with the code. Thanks! + +For support, you can ask the friendly mailing list at: +http://groups.google.com/group/nxt-python +You can report bugs or suggest new features using the bug tracker here: +http://code.google.com/p/nxt-python/issues/list + +Note: NXT-Python has not been tested and may not work with custom nxt firmware +versions (if you don't know what that means, you don't need to worry about it). +However, if the custom firmware uses the standard communcations protocol, +everything should more or less work. NXT-Python was primarily developed with +bricks using firmware version 1.5 and is compatible with bricks using protocol +version 1.124. + +Requirements: + + * Python 2.6 (http://www.python.org) + * PyBluez (Bluetooth library) (http://org.csail.mit.edu/pybluez/) + and / or + * PyUSB (USB library) (http://sourceforge.net/projects/pyusb/) + +Installation: + + * Untar/unzip source package + * In package directory, run "python setup.py install" (as root), or if + under windows, double-click install.bat. + * For USB on Linux, at a root terminal type: + groupadd lego + usermod -a -G lego [username] + echo 'BUS=="usb", SYSFS{idVendor}=="0694", GROUP="lego", MODE="0660"' > \ + /etc/udev/rules.d/70-lego.rules + +Contact: + NXT-Python's Head Developer: + Marcus Wanner (marcusw@cox.net) diff --git a/build_dists.bat b/build_dists.bat new file mode 100644 index 0000000..28d7c87 --- /dev/null +++ b/build_dists.bat @@ -0,0 +1,3 @@ +@call setup.py sdist +@call setup.py bdist_wininst --bitmap=nxt-python.bmp +@call setup.py bdist_wininst --bitmap=nxt-python.bmp --plat-name=win-amd64 \ No newline at end of file diff --git a/docs/seealso.url b/docs/seealso.url new file mode 100644 index 0000000..e8dd8e4 --- /dev/null +++ b/docs/seealso.url @@ -0,0 +1,13 @@ +[InternetShortcut] +URL=http://code.google.com/p/nxt-python/w/list +WorkingDirectory=C:\WINDOWS\ +ShowCommand=7 +IconIndex=1 +IconFile=http://code.google.com/favicon.ico +Modified=20F06BA06D07BD014D +HotKey=1601 +IDList= +[{000214A0-0000-0000-C000-000000000046}] +Prop3=19,2 +[DEFAULT] +BASEURL=http://code.google.com/p/nxt-python/w/list diff --git a/examples/latency.py b/examples/latency.py new file mode 100644 index 0000000..b4b1f26 --- /dev/null +++ b/examples/latency.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python + +import time +import nxt.locator +from nxt.sensor import * + +b = nxt.locator.find_one_brick() + +#Touch sensor latency test +touch = Touch(b, PORT_1) +start = time.time() +for i in range(100): + touch.get_sample() +stop = time.time() +print 'touch latency: %s ms' % (1000 * (stop - start) / 100.0) + +#Ultrasonic sensor latency test +ultrasonic = Ultrasonic(b, PORT_4) +start = time.time() +for i in range(100): + ultrasonic.get_sample() +stop = time.time() +print 'ultrasonic latency: %s ms' % (1000 * (stop - start) / 100.0) diff --git a/examples/mary.py b/examples/mary.py new file mode 100644 index 0000000..907cc23 --- /dev/null +++ b/examples/mary.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +# +# Converted from mary.rb found in ruby_nxt package +# Plays "Mary Had A Little Lamb" +# Author: Christopher Continanza + +from time import sleep +import nxt.locator + +FREQ_C = 523 +FREQ_D = 587 +FREQ_E = 659 +FREQ_G = 784 + +b = nxt.locator.find_one_brick() + +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_C, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_E, 500) +sleep(0.5) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_D, 500) +sleep(0.5) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_G, 500) +b.play_tone_and_wait(FREQ_G, 500) +sleep(0.5) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_C, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_E, 500) +b.play_tone_and_wait(FREQ_D, 500) +b.play_tone_and_wait(FREQ_C, 750) diff --git a/examples/message_test.py b/examples/message_test.py new file mode 100644 index 0000000..c2fbda7 --- /dev/null +++ b/examples/message_test.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python + +#During this test you need to run any program on the brick +#which doesn't use the messaging system. Most programs fit +#this requirement. + +import nxt.locator + +b = nxt.locator.find_one_brick() +for box in range(10): + b.message_write(box, 'message test %d' % box) +for box in range(10): + local_box, message = b.message_read(box, box, True) + print local_box, message +print 'Test succeeded!' diff --git a/examples/spin.py b/examples/spin.py new file mode 100644 index 0000000..fc7cb2c --- /dev/null +++ b/examples/spin.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +import nxt.locator +from nxt.motor import * + +def spin_around(b): + m_left = Motor(b, PORT_B) + m_left.turn(100, 360) + m_right = Motor(b, PORT_C) + m_right.turn(-100, 360) + +b = nxt.locator.find_one_brick() +spin_around(b) + diff --git a/examples/test_sensors.py b/examples/test_sensors.py new file mode 100644 index 0000000..4c8d249 --- /dev/null +++ b/examples/test_sensors.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import nxt.locator +from nxt.sensor import * + +b = nxt.locator.find_one_brick() + +print 'Touch:', Touch(b, PORT_1).get_sample() +print 'Sound:', Sound(b, PORT_2).get_sample() +print 'Light:', Light(b, PORT_3).get_sample() +print 'Ultrasonic:', Ultrasonic(b, PORT_4).get_sample() diff --git a/install.bat b/install.bat new file mode 100644 index 0000000..d3e4948 --- /dev/null +++ b/install.bat @@ -0,0 +1,11 @@ +@echo off +@call setup.py install +if errorlevel 1 goto error +goto end +:error +echo -=-=-=-=-=-=-=-=-=-=- +echo There was an error during the installation. Please check the above text +echo for more information before you +pause +:end +@echo on \ No newline at end of file diff --git a/nxt-python.bmp b/nxt-python.bmp new file mode 100644 index 0000000000000000000000000000000000000000..756356c69837421b410e3f0cf7092a9838fdf1b5 GIT binary patch literal 158742 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ð#_$%<9BV)YtZ zzPij-XbrP;#mjAu zT)`gn{s>3nVa8PEKXJ&akW+yhutUCx6VHVkaLK&Q@qwur8~HoWp#obW2Wd0Y5!&D~ z_A-`OC(thO5yyGS#)L1{(#*SZ?ah?w&Ud+Zy>{(7tH4R_RIRJFWmUQ#&VG$twemI# zM|^8=Z4tg!OZTzX!UkDcS>+gO&{`aPRjQsf!qpm`L6%DwmdmC>elnEI@_nkb< z74bOr4@_l@`IzXNcnXe)4?pWd(i8{J$%BvXB~Eza*=3m4k$EqJba3M9OD_}kyUv4# zN#<=*pF$2MnW#FwZ>b+nL#GjY$J%cekNKu2@AmNhw>7fg%PPub)0fGP(w%1QFSFJ| z9`OzWdspDAs(fXU{1Uztw@xPOi4U{3INCoam45_I=6=?}^KJLkD_2j5j;yo9fncmQ9X5$CC01 z)1C36C2d0A)JD{;dR-TXZSQLjJ(K1(Bv>I`*z)fl$d7MqP!9bN{fu(-F>qO^+uI6x zL)+vl@DTnYSA>C#H~JfTi!}AsWm@1PWJ|&t_EW+`mU)3I<#pUe8S21!S?H45@_2t% zoP1yNq`dS8S?2Q+9;naFk{QSizAINJY^((f!a$kUl4ZJ|Q&Fw`1+WJOrTdUaHOj|5 z*L4-E3iw(r`=0k2tF@Q7LUM3TrS9V>PlNJTsIE1VTWfU2?f8v{%^A^L|I)<1Too{4HQd{Xn;840|8JRO$yji#Ykd22neT z3q6NC0c*%ET*8w0?RapxLmtJ;xeQBq3Hb(oLhkXt6t;WFx3o{IGG3=+JnEs2tPg41 z-(68$?x)A8T$Ai^zE9aCdkWlCu>YXFgf)6sb&d2|rOu@5u*H!@(tq{rFDHEI-J$}% z)@UCCS+%0P(iWDL>pVnvRUMBtt{*FeS?VlPeP9gCf>-JWUuBibFI~OWycTVFrqA#* z8@7PLpcs}|nUOGJ#pLkr@6GQ%ZT?tnS zGhn0eo}FV39T*sNd}7xld*tGL2&}3tuTQvhT&2Ex9ARXY^68oS8AAd8PIINH|9m?T z8;E@c^xi6Aqf+(}w$d8uMsQK9XY^x}&I}upPGkMJwqkVwU+g)Mhxhna=xhUgQE#I# zw^leU*Y~-ovrP3>NS3j$g^r|6)|X{^pMi5XbdJw`^^N}G*dOw}a!(U~oL{6Bh2b6J zLROH^^C%tKIBz;-L*74SJxUsF#5XK6FB4v!PSFmu0y8cz6Hbs?t|M08V@! zf(v95X<$b770+2tb?QXr^L|rSZBmb1#+{Ex<Q}tWM%t#2YS;H|I2R?K zXyp1)_-dB!=e=6KZBwTGgG%vz4QoB&YmMwE_7A`oYk`n;vhUf4sOYr6z*n?MHGS+VAD?fA`xD?6Xflw9g2C`fK~$CrbC{58VIlXDQ#O5l@*VavPo$fFRn)& z-^52*#}RGo*=3y49lMJ2_T5*1pqKi^Iar*HVdIO(?9qcS*eaSH@~c|q;~i$L1E`C2BQg=aE6lFreKpx$=*Md9wN^=f zVS|;+(I1ytNoF`d)o<_=-`q)96FyvKDWC7XVpBVAz((i#%yB}zkGZo<+;xR6q^S;J zCh!(mig<-p&anulBp;Eleh#HRfq~x&Q@{WC7xvo^-nGwu^PYY7(R=pEhws|QzusgY z{BpB>_{)uY?}PU{Hpy+Y58Q3GkKW&?Jnz`2a=-m>i+%RN7W|uY=H|m2Y*#|G&mEqnJI*ae-R!F8GYeL?{8KSQrbw8|LI*|7m zI0IT&B)=-F^t%nxg^RT3^Y*F=trg;~DtW84U%~zt>xD9xUm@SHsjauf7HI_E8&nw`hKbKRVQ5WJ-Kqp6qhr#*!N+7VV}ADl8x{9LVi^i$uH?Z zzKt_y#R_}7O!xNDk6@AgFRdTTRaaS(U#pc?tu+GYPR+tLcPTh;s}kPW)8HO~ zf58G+3Or>jI3B=+#visf>5^NnyMzgsHGvs$l5MCw_P`gspp9sUcD+9066OMz!j)|P zz%@8+iM@E813@!>TWN@XgR*3lejj{zsSPR7?+6dpZ%dX8mp{}757TdR>h~uHDm-AI zeur|%5dDt!ApIVme%r2}e)n>~5Krr;-_GklXo%tl*@I8Nt3%tB77EH*%1D;D&MV>M(~{yss-v_u=y!J5nYXfv=!TgXjtOS;}^lpVfG@9r&G zyukYO=x*aDjQ8K?9;5GG^INd~o3io=$8RC?yRakt{RMv8nBR%zH?+s&tS3totLR!gndlNAovb_;I(|P&}nli9o&%5WfZa~ za1wq|y6B5;jQt7KBn`#8v9?!FYr|c zzGTzUCcjNn>(~Qh(vLMdLr?h1GR$e0umZkZo;e0Wj==w{FP-;}5#&|iD9az0M~Vv{ z{wNRp^0>sCB=dZ)pdjayK2B+_gGEE|K7Z~Udu8@4`{79^+08dzFU$xlU`xN_I#R#m z>c2Oy-*qNDmfw0EGfH^lw}|AAC}$5J+g=!BF9G=l7O>ISFRRyDlkbD+H}wkg ztF^IKuTM(1NxyL)6P*|P8QRAHtBx<(bkr-%vX6ls50{6WWN+FwErpb4??D+#%%$>kU##4$1Q>2MjaSurJBV53k=;mS7t$Z#ccvjf^ z<9^_obJTbkLCSU-oO)ObItUgC)mPX_i+*B-i9hhuV1Q%(2RY{JKW?8aHyJ&766cEn4)p-_;2nA3Sxr zA^swtkim{IaOPN(?^w!s;yqi9M{$A6z)oNbe94iP@d$>zyvFS~CO`Tv>Ib{IY|PWB z!?CZltWVfyVo$yfI|$h%e1U~>#~0_(?5}G5sQrp&oka(};@fGwXSTMyQ$Oli<}?^o zeX`TJt4f%Cjdhi(OTX>JA(#O=Yr-EclMAXg_Eav~s!T{SlqOA+k>N;ob|s-MLP9Xx5o4_^OcJ3;6}U zBx`t2P5WZV8ox8HJPrDtN$wi1D>~nH`31g|&Rs#ytg*lNZA)yiay^G`)S49eCH%#j zRPs*GE444XSaw^!e-`!>JPrqj2t(tp){#DElB~&l6E25@C-*g0@?>m!y>3qhud)r6 z^|H@P%A__O=U_JLN#gbV%BwHii;`a_Nk86l(^MO$?+lNXY{HF09)Tg*S7V49sW?v? zB7dml6!{3tUUOSavP*f!>vwLhzjmTsqi++>yz6dTq~FesyM{669QR<%@e-IpSGlbP ze%SAl@8<_Dw;~Ui%QlnS`<^G2a||Y3s&MF6)ghXNT@`hNy%ur|8RpKh6?BAdnRm>0 z?j>_}jb6eQTkDt#EUe;OdYx<~VF6jgJ!*W;xWVPxiq7?;?o)Kc9ar74kPTKNoyXoi zcktO4S|gm6OCHAls=jNXwIu6RzjL9yD|H9R&xoX_13w|FJPa+t6|P8rg#OC$X}#z; zQds%iP7xmRczxeYWA=K$tMGvggg34m71z0Uqqs~futa{amGBDQxV!fHYtoO;KBeFJ z{=VIM^Yu1i%t+y;#Ky~I42{$8YmFri?0_-hZi28iUcYrSVT@#!WEye{yKMX@{qEAZ zF?Rhm6K#rqtLx`Kzgv4BZ~M1cV=aRG5P#_tbV)MFeK3M8C47M&-oJDt%W^LSoL9ZIi~50%DN0wy!VlQ$wBve!=rCL=}scL6#I^Q7u=sJ$ePSYc%S(Tz9ggQcVLEb=vnchBQ<8ylI@>m zUB)JLha3!>%I_k2-3fEhgy$mqcsrhlH3#}Qt5}DEb+Un;NA70{NOV@eT6f2TyACi zE5&#AA@b$tpkLV0jk0-aCBu+i*h1i|0$nCO>GqfG@fyh<UlQK7(u>OHICLM|lzQM#jN88@l4P6jkvUG4j*Nn5q9wYLa+K-RkA$Ot+!LSk z#vA(9?2C5P5l0xm+dFaGD4QtkOq7nBARL7&6>h*2PVvIeL^WO}UG4MD4tvB`EsyTN2p$F+(F1Oj$6UPfu&B zG(%oR=}*>&l1bo^^Xp1I``)UswK|;%R4JWvCiZsy``xnH3il?|FSnK4 z4<2*&=KEdnTw?h*TR_1D`};brP| z*V)wTue0l~pJF%gto>MhV?k-eU28X7H$~~!s{B;D|K~HMM@QRA*%1}GPrO<9g74lR ze3u)=_)@>nkKn9G{^WB(*NG|v&KzIlDRRChKu3By^?;#-LD9i61pP=?d^qw1_FQ&B zH_DKYu;_+uUoRc$=QzSy-dp7?dbMnDzcVlW$ejwe$At;*ZSgLLejB5(zpCHH7QW)F zyh)hy{RecZFvhnY{Z1@(BD=I-%lnVq&1PM}cfC1xgnwYbWe7ZU7x)M{rn4jZ?-&bw z#U3kp!2spS&z^+x@vJ()A-{QgGV6&Ztry+KS0CUv*n;2A zL&DH8JqO;Dr%3LE91}hqOO(T@OnL?rj>m){uLHWvWqIgzcw4D$$EfO5+mw$!ktQb$ zQh&%b;frq_h)(?W&9bG7?e^Plvq_UCOaD!f9-JUsYn+Xd8#jKuZ2Ac{a^zT@FOIcR z*;=E9kJP?vsm_pe20nC%l@1+l!-i^KUwK}dJzKVh-h0t^k!xi;@H>y(f95;WU<=;* z`4IF0JC2LMTe18K-K9Q*2gxgN78vTxo7b7X&q_UN$L~EVOgqqu`a3a1d_0qu^&>Kk zu-j_TNDljpJyz^{?#p0vV{?H8zXRs`6qD?qySBU&U(F3-sm>c!kG~79 zJyY<-eOK0pynn>LZH4ORy;|;Dqifl-MRwH*=jiRgQ1&Ftl)eo9ZvFk9Zt=tE^3Z4Jsb+Eu2*=bss=? z0bNF5CP$l}XqFQ~3-E zI%Szg{k|sxZ#-VUu;_TihhCyJxB>&Md`nNVr&>5dhJ}64zNqYb$(*p2;*JjcU%aEX zHNLd}C0z@R8#Uk7=`0buihT{r)=H;x|E5xL*k|ZvWEba;=*fDOK`s^K7C4X#eHC~q z=&_8UBwI2r9E+aDyNX~g$u8w{-6oniR>-6AZ|wrpp>IVy+IE-ndN`K{^YE%e@=N&A zJ`1wFS>y2cl7%gQPtNz)ixD?`Jp$!Ia7u@EDkM?0TKlOL_34 zuwxet6~z(nxKfu(rM^NY^}QL zPWdH!Ea5BO0l~iKTYcQAN2h`{?mpKESLj9B0$VtKmjE4!eIGI`cnZE8JC23SlVYEI z;37F_Oc}=l@=bZuewnWUJU*34So3`f>L)Fg4{Rmb>AEn|(YdaBRo3-XTZgSKtF$WZ z>9HrnT;&^mt>6a-uH^VGVT41s=QMv;S#*sw<^&j2|COKl&b#l`djGVcQFfB>g}m%& zk8jSou5@`6xNv(+GKu)S=Ma0X2~Wa_>om8UgdfLY;H9u9k!-iEWghh>CmLmW=CVxm za?E)-$vMY-V3Bm@D*BQAcJ{V>|5UPuZ%1H*qtCbtfvv=zs-G7ME8K(T{%YO2ih_P@ zYpT_>4Evt<)WA#FU+k;Jo`0=q$zF)-W3}5NT5@lL@2c_MuJ0*G2cerBXGz~VW(cd# z@m&!5PB`Hrmr413{)0L2;N=pg9EVZIRyLXAg*FqWR5xw$%sK&{gFn7Y;y7ggqn-OQ z>ut?y{l=W|)u26@7IeJE(3NE5Bn1S}QJOROn1UYx260X(7+>ne*<8-u#wqh1QAaEN~R>(4xl_ zuls)NNg%s$jdJJ!WE}S?>T1>$@TK2ONc;C`4T+qRyuvo+n`+gf755|RsH-8~xrD|s zSDDxF6FC%q;Te1=K4c2%;s?3~*+72zv3HQ}=I1&*J@GJ&8QUr9rw#Cej3X{N(JJg3 z?C1#d{Yzhq^6Y&fFXf5fApKb3_rGhQ9kL5-Ii8e9cyY{tt7g9YyNy$QZThW+Hhpik z4Q%0iocN+T_}){s?k&|dh@TtvyA8Zwq<;83kni7dMRp+5lotE<%A;^GUi=#-2^;X; z^&4`Gu;N`_Wjvt|v#g_x+KDnDyWQ>rYtX~xT3|A;tNKJs&o3YTU@I-vH{VvR(rC46BQVMF=*wH_aPTKoowelxTaUj_Mve&DQ9zH~0{F8iEzdqeXWeTH0d zoJ2U*gV8s~i_-i%Sn$(%sx0KSjGvo z5?yp3b(6k1vRS{i!M8^?=sV%i5gH>a95136=!SdbdS%YDxHN0ZVfD zosMq-@omF4xmL|%!ueSkQ#{}G1%oZ}o13^7r+2TaWS`V)-(Um#tCE@C7vxIlLi)_R zaM=HwHf<6P^;k7Gq?(M`KWx{4)eI@!iHsv!P zMK8w}^(x+VFMU#&xr;plUwMaTwZ7%Ga;1JFTWb}th5qvI1_)z3V^?rTtX{g2dx7kY zaz97kXf5C?_9yt3QnGQ8O^yMz1Ku;Pi|2&LE1mV0^7_6NGR4b9dGM3%De#5NiFy?; z+=Lwu4jGT?kZvh1pXDI76ZPc2fK%$mp6Tf5ur2TEeV-g| z4T(Mzem3bhZ$J3;uk5qWKDIyn)2H_P-+y8s|K>OL?k~1DCS9&!w_H`TGZKc2g z&&cF_x5BXk&a!+0hfXWv(mD}LWn8Je%R)VaFSk#eAKL%Yoa4KpV2gJyu)k~S{K}zH>~14`Bz{Bn%;Ukb{idZ7%iK?SJn#aj9&Ui^7%TPUY5!Kef^?)a|+xnMoMC z0H3nZ8~a53`S_FH*uRQ5zx(9Z_QCt_>UV?QvyVP_-#+>17xquT{nUP~cN;q-tJb%Q zr*e)j*+K2C>uu4JHMVSdg)LjT*4|oBWly|NZnxgM#3s*JU}JB2%f{R?-^NUvZzHF@ zsqkDIb2I*%Hu|>tHetrwcJ<7KcI}-D?Z%%kvRm$7Vs|~h(w>^N+FpCBLf_h{uqDg2 z4_Sr%wMn$a_CiL4&9!OMM*H1oAK4%D4keB;{L4RnV*m2HkL{oT`5*0*k3VvGj6B<@ z{yT3HCR_)4SU7Q;A9}#QBS zfA~xBa7+9)nA)TM{OvB6FODNHMmvGE*auDXf;eF)?>`h|894KJ-X+L-G0QsT2UFMt z$b8L#jnXCWtDnFB{m1s(-@Na8j(h{?@#kLD_l$3`kz*#?BTqiBwa!{$?U(x2?gr;A z<=eql8{Ze-Xm8A0ZS&@>ve#Z)rFYJrv}3y6XM3J~zwLI~UAEhq580Q$Kg0gv`*+wb zC*NUTIeCVC_4~Kmf#=+3d!KQ$?Q+~S+vS9*wyWayJaL-sdeY6d-w$rI@0@d&T{-M| zd+_nM?bSDy+mf>XkGc1N^6EI#ylq8Gw(N13Z+30Zc*Y)kECh6joauPW;Ip-uKLL-!g1c)Fcka+j^ymfDb_p`8PX7`-^pHru9sQ_Z?tf@5kWm1pKDC zy5Q62h)CxbPQYo54RL}vir_w0;m*$$>t1M&jy?G?xToVV|0BYlo~8dtc1HMejCtEe zf21wH%erXVm;7DUIty{MKRMUReBCteiGx^A`!M^pvX^?fd_4c{`FGBp|JuI%I)rn? z9?qYSV$Qk$^@a1yFFnHl!*^cpUl5*xt}YoAVHwN>Oh?y*JKYn;rQ10k0~Q0nfiGnG zKKw4_81(;;M&*KD^4`&R?KHSL`Pm2de%XGXe^NZQ#5#4p+q(4XV=pkKum2l^tVgfj zHfYE&+lu|8{n=eEi8~^Ey|wQhn>uHm&6&5+?*0>adhC#Wugj-)Ro74L2i+7tu^)8( z#C}A$vCAj+vo0Un4Uc|k*FXH8-SEi!_QOYy+D`~KJ$l4`^vJvRlgHjAKEky!yXld) zt?F6HN==phW#j9y(9Y(9+RH+?$I)A%#G}eKFeC<<=A}>KWvY6d&2Hx9#c=| zQ!ZjHv3KCE--JK? zS2)uBD2>Zg=U1+KdsdrP8vHA~^Mj*D?D(;dD0k+wD{y?`(~s=)W18dsshxmtPjLPC z=O3GR>Ak}gaP+%y{`foRzWK(!`sO_0f_-&?^*;<+E36I!8bNE#WQbNpHiK8p9oQtLUDm7v5sbMSLe8f#Z^MzD>`Q4lKR>vt!7S)1TPK?;h~+ zkJIM7Y2AACv-=);*oKT8V`ImSv#}E<*u;`a9FMkMPxiIa<;xt$s$c0~l9O-Y``QP8 zO`W;H#!ud4H8OkIHP4;5YkQuwYrCJc>wBCa5OaJj@zuK4jcbpeupc~r(rzHW{_*2> zW7iXQ-J{3tdcx1U9k-jha@_rd{k+d-R-^Ah*6?QSxyAJ9fG6Qf_>wMo5Z~@jbePqv zS6Fv&)w^#$)`u^#(G$ko*oh_9{mG{+zo4}ZDIQOnjqt+(JNw0PJ5C)QIda(7R&;qO z?gBH8A>l@CQ2Z8SM&~+Kta1b|mt*TM>;XN8bgEaki&Q`Uf3V7X%4plCPMrh?-~R1z z@f-W((~rvWb^iF#m0x{x`r`RBAKUq}pE9@on0*;CmF^|^2(ALJaSpEun`)Pu}~e8#igU&8qz>fZ=p>!I3@X_`3M*H}8FYiZv6y_|PtV@v&Vv1lIOWU z6YPdH5UCS%kdM*LzxwhEJBD7kADOwNbcOXFTx_{5+A_9%kc}QY#>R~wM;K!h#*ZZ) zOZ|)oTa!I>?eT;yTC@NkC+n^_uToyFk7`YT!!~jH78^2pqgBaz-fnuwCuj(Cer@1HNW0 z!9Ehc;7rFj-GnTD5Fx_dM7Q zE?n&G`@|=d%ehm?%y-c(@oBhjrsoEH1%FnkA7Leyg)x?NU-jeHWBKVAhCn(V&l zSh|knX9(bgO-Sxl&Hh$7Xmw)3Z z|M7%z%+VMR#wJb}?f9BJrNpLFU){U+X8z6s?~mUv`AB8$t4&5)1{ydoD9{;-zd|d~=u7B!FyQS|@ z_Sz}6S&Oj!4jy*-D7(UW3?A69VS_DMve54T(>+!^e3(s{HW|4--X^fea0z3!r%VQG zU~HV)5ZAji{_O619=2y*=x?jnu6KR=+!x2}#L15%-Hd&j-DehY7?^O5l8(mvV!ce) zB>#NPe(GQ^c-l*>_4|Dde{_27bs6*<>eBHC)~GxA1k_LMa~a`;&)z>|U!8bA;-Zhh z)rWq5_R}MFa5ozt|8KvQiznNL(s{Of%WC{%j7emC$#%y2?4o~Q_f9Z|Usm%(gfG|q zlrQePU*uxAouAHddrbg#Gf zA?NqA_uk$zE19v4XKt{B=C9aQPn%r>zODl+SAm&pg&lE}xT@;~yH=PY*7?;OUq!fq zG*@|0dg1G9`|%UttIt>V`zJrJXJ1-wGZ*0JfxjHzvRhr|u!r)7^|oOCT)XG)yKKaW z5jJhwRBsy-!ITHdd;d1tjxYx=4;eAkxTjvHGsgG*1y(% z@RDNzTZ)71lOE>wCHI}*#8-~N_`YO!;4H=3%XcsJs#rRi>U^K{X!%s>W7M7qyIC86 zzD4`s;BL6-fPL}tAv^KGezNz`AM7vhJ-QMd~QPuKYl&%s`95aL1znTTwV%){7>Ig2ItBrdhA26&wAlYmn}zs z8RT~15XxUNW4vS_db@KL_)_@`Qxn8r;x2Fd;~iU5C!>Eo(bEL%Mj;e7payJFR%cFq=Ak zlFLSYhj^>Rzh`u4Gip0=TjJhmbb_qxe0#WSFZN?u?DFe#*6KNP>J#j1`T^iE$CvN} zo^%{!XT)XY*wX#Lb8d^0FXb(^3CitMuE~!c@P!YRaTB}fFWSkR>urpi-?9-tTD#mf ztXN=cmdvuLBL|(i98;GcPZ%}w^sZ1u_|zP8MkO>3A-6!zcVgWq5CZXI9ZBgf4p zZgQS-u8Oe)cHrNj|AR5-vyfi=?EJ<3gV|k>!I{EE@bxV?;Ehvj5%iuYw+0%ue^+n^PoM^yD#6kgEd>;vSaut z58(s%aXgM4*?$3FaV&Wm`kufZWgg=w##M-=w+Wl#HO7MBqxU^JkYVC3jmcz;1oP0= z*v2(0Y)$DRTReBVm5dpN%)j&1%Q1EN@wib#PcNK1%T_O2Y#aFB7IdE-j91j2A3;7! zS7!X3uueGzU$5{aol5nmqIFoMpNM)xLyN9oGbT|UBJi{UTIKFk{t z#)5xhH}Y`;{55FAI!nqLV%LMO@Adiy4uhYb07t|ggfGHXJxnCf#q{Izt^0=xh2J8VSp zaN30Q`|&=Xyaa4b0%IlOX1-6cA3LW7j7^$^97RtXgFoh}XP>dw?K{HQMT>xKHybr1wZS636TY3p?Pit;|*2 zw2n2wRxY*DCG+s*O|o$#-mo`bd-<>K?=GB;8!`0s{5dmh<+6pgZVfV$@#)*Zs`ix( z_=@LpL>%RO72yeNc^?i~lALt=QpXYATt;#|*89VFK%T=lY^J=|uUcw-x;f$x+H=Gv&D`$zs@!~lU4#AjeQtyk~fUT0dD@$zvM!gJs# zdFN+33`djT>qJYJ=V2H@8JKU-!;fZxXb0_JFHuaem@ia zYuGxg)n>5$;(4=c!N?DLqUSrd#Ajwd1W)3#?~BJcz8XAzpESbW51-V3NYguD?7H6H z+K-9pMW(BYaCfQr~N7Px75SbpM0c!ehf)1^Pa|XQH?Z ze$v_nZchqR!dQeY`7qRuro!(tXH8*0ycxD^$z0|E+-r-`H#PoD7;+iNd&NuA78flg{k{@s{`@oV$)A-x1@wgs+|AFZ$j#(?-^zr>|PR*cQ*9WizKt zu#tmbvjMNY@SXS?Ib!hXd9$a&ck^wn@Fo5NtMUHsv3~EE;r#(40aL=bkHry=9REQ! zdj2>M`j%pXq*q{NgGj|Z)rEScleNLHz{!5t#|4@(- z6Tp|+c;GJTq=a@47R6uF(7}52dXoA1m-tJv@g3~P{rmAxARi}TKMs<9-(sj;gMNP_ z__zwJTod8uYH;*p@N-oZzQ?&Rryz{!{QDdWV=;&QsL!`{(=*@Lf8hUe{eF?g+{k{E z{w4Vw{H)sFZt=o-taI$@?zc!_$uL=u1}^Or=zdUo;wx$ zWiB#mIelRR?CGbUvFS6WW9vz;itytyQ93-Ba*Qd~eeswu7ab!*ToyW}F5yae^Rafw zUG-Z#z8Jf@jk!ac(4E$Uua($?i|2u_$<*KA{x-1xOW%#J;oxf)_*y(K@Ynj)&V@VS zuX6u{eE8rZ=ZPXyT~~TPxI(VD%#h!RHa%nJRMy6s%$&rh zSYHJHJ^Fpj9paDBKZO2;fA#gDYb+^uuw94#C45~2zOL$h2}h10&aVMOS4Eh*AvzYu zuH*O`?mLI^-<$e;V?TfP8@svJVelpSDF1}`OSl$?1^&`n%!?MyW&NG|Y*aD+3G!Pq zd7|s};am77*(-#Jj;nDtnfjYLb)wDW`{vD^!Pu6ug1g?^gB4EmStQ=cG ze#dxozKSsCJcfTl_|n|CEt}S|*X}Uu_w0){@Qp$C1|dH$3!hI->CHNc;d~RB!WIOV43;O+<)hnr&MYa(BnubqU^F#*? z_-=fS7zV!JujNaEeB2Cw1^Focl7Hfo|K9a?aONBZW`f*{c`K5CY6Bj`UmPSWmmHeMjrU*n(Z#*Wve`?>epgsN%DUl)td$ zzE$L?*2S5IKdF1qK75D#69He|_a4bd_kW>(4a9z|*{0ZT1YbYwgB}G&gstlc!j*I^ z$wT2t*Z-08pFd^xFNEv4{-Y?(Pr%oWeawFS)VKDl7r(VX^f-wBe#IqxiMyyj>G>K9 zwh{R_e*xpjSdVTzHt+OlQ;~Zm+E*BiDc~pO+gyJKSF`6#N7lcIKXRp&j2mt*zVN&a z7)V{xclpw518h2d{qh^AtOI^Rf1&UZ_$uH^`h6UNjuy^cHj2YYANn$>8$aKVPwj{u z!+)gl6Q6yI@0&4N?;kxtA1Lx3onN~C8f?ggZ%()I%r7n;Ht0L$V=?%eBYYtrUH_7g z75!d&XYEF}^ZjkXf^;W+i*r>Z=YlMZ_y#;^CKQS2os@AgDevJM23-EO#;fLVldf^J} zNIptl3ST#HO}g0)-2X{Gv)`k${fzS;MCpG*{8RAti|4+vKR*7pJ^eEMLyNVSWMn^r zFO`}6OB=m^XaV}y12zUdemXL5GI*K<2TbBS)ITr2nvL$hQ2xkOix_LW#QOH_O@H`s z8-~y9dDcf9Id&Z5OE=Lcy$fu}*A?_G_u;!7jAS3UiRGjGukku5vFwyS7BEJ=@*Hpb z$fKi--IxH@yY=j4&ph`mKDX!L%Gd1K7oN7K`}MMZ&-b*~UV7RFzV?jufBET)eY)Rm zPj-83lzqo<)bIiD*A(oLpnq+2{$h@^>tE{Uj{OrscMtQv$dml=jw!_tU>2-jGr+3 z2mGZ!0$(?Qnd{-P>xi!gSHjs(!OqVJ*C=rPABcZM_*GwQ0M4%^{DlAhwC}g}kI#Q& z={?`J7hXee1Yczb!}y6X22JwuE${^oFI~vGhxglPzHg@Ie+v2)?E_rRnmx@HE_jpq zzsqg;!i6@hc$hu?!V5MOK7Z+z{@(AsymYC(1LtcFx63y$5_6L4S1t>K&gHlhcfp-X zBYi){RN%XS`?zmhdW`D&y>|~=R?|lIZ@>JR{oC*U)qeN8-`Fjc{%F7c#Xs6FfBp|1 z7ZqgLy|;I=K94_m;lmF;C?7ZR*B~}x*kJUpDe%{P_KaVKZjJ9BTS5EJXw5n8zpSw| z;w0fG_$R=Zj-9Ilj^cC4Q1z|qo{zaGPbd9N{~>^}1K=~ps?S*!*2I(GY&YZZO0j`8 zZt&^nUhwfOgN6*T_U+rS2FY{ukFK+&OXu6X`Lk{Ayf@*sx%8XNU`?F<%uQJ4bJwL; zhyGCM+3J5}{MYPFHgeP&`$NG9`zQG8AJENzgq-^^;YZ-*dg5!q*3}$K@A|%Cg81qO z#FC-cb1WHp6KQ{j%)ANyy6L$KR^`b<_R4^j_U01C1RiAk*E{OlCJ*8f;cMeMTgI9M zTI0NU)ENAIGr`mhn?=6o&7Z^i%Zu<|uCPG^->|;V^kb~ZD0}s_*X`v2gKQz3ynoMD z%6ym0Iz2DoN&YR4S=V2fiG5uMdG}x1kMTX>4P3=|ll}r$gAbEfbw(X*CadXMng22Gui+}bRy<_j={J#&%NEZAU-&1a z-_s8u{?eRx^`CqHHhAzc*l=jTg>)drT#}~)sJ;+JrJ)~6}r_p!04kz2x z?M%`OW8yUA{LZbLkQp=VmHq>1!^j5o+Q(TFsWrOUaQqsZkmc*wmD1*y!D+Ke_lB(~ zUE=eDg8y9kl6-uNxtsfK+|;$mrnT0f(+KSf#GpZ1||P$VciBeED1y>0i{RzFGc>QuN{{x;}<1 zoQf}Ii7li}uP9w;8&)s3spw$O!B+#o*BI>TR|gKU$lG>Uw;{QO;YA zt)OQ~1_mzEdC=<*fxB{DEW&y4Q-o&)`55x&I*Z$I@>d4?OTLLc@Ql_Um+zi6R`D?` zvz1HcyY4j;J9o^`*SEx2`fIW4_sE!Xe63sM{IwIG#~$R>KITEj<0qVdcy}!00#2yI zn5$^7y5{{^Y8RJb%5f$<3UlSSj5y7osbhk$sThn&H+zdbu=ks=Hg@Q*rBtJkDfYXrq8Dmcj`Sp4h)R#+r8I{C*pIPvd-Gv^@cSWcE&0V zHcKK@8faGGb+d~7&HkO9wEuX`?4Jq0AYA_nxFY?GEx1k?nfstYu2o>*|e1x`}M<*(hE7qScIL7Iiy`b+M_4^ z?%2q%Q}lbVg$*m{Y61A&q+oeM8IKS1R3pIzHji!v?PZYq*N9 zjUM!d^Vjkv==azJ>=VhHt64;eO`@q_u6SJcVwyz3tJJ9-R#b2NUyH~6*@ zwrtf3_O_Q^8tUBjEN~jzfIb%jOdU9&YYM^`?*Mmx%==vDQXJh2vG5eQ&HWeLSN>vt zRhyQ-$vH#i#W+9Nc6-2pWZBkD_`hi9vH@43M=pGGhWo!p55F?L#9wd1Uus9*2629W&xSxXW z6#qGfX}iK9-><&h-Smks!VmuPz`^!#mnZCj2OqNsAAQ2Q_IZY}V{>Q=VV+!&-Qr8~ zM7}lOdI$6OhE14now|&){0GNc)&nJ$_0SB<`txkdf87Y~{-xHj*FtOAWv&&FHv7*rEa!pgmV5tX%Xz58+CM(k?&>wwCe2>w{ldbR zp^wzZ9SfP&R#;tnuks=dtLJy-NthtRlq~g z%XLgS5e^*)^FDmM^koZV>-UsTj4#cz_Ayt&mpDxL zl7AJQT=-hIs+7J&@P&VM`s8so>Tlqyco_C0{#D6GVN?3O{9jt{*Yz*=fALQ0SC|MK zBYddN15R9~k?-I?QNE)n%n344BsQg?Y6B>KHp^2WwBvpI2&qU!P_VJ~P?w=`+>t z?mgY^dUA%{N$B{*EW54O9P2-NrOlkXl758M_WX#2*0$R$>(Fzyb?7zI+IOFB9eYf* z+j>m4J9|#Cr(U0Di&ktzXQWJ&U+UcD7;@6~t~feaj4$Ue#zHK@?>hs3@aW-hTv0xb7#jSm%a&k2vUiU7%k4+u zOa4{q_q4s>_Y$Up{w3e#CAk>NRrm_L1a_kK;W9JASMcM7?+o?8_fsFTSzKpRS&-Ik zAC;5iP3OX{o~ir13p~d2Z+%}#@+5v!x%mGblgbO}g|8@IdZ)${>3iIcppEXAe#tlb zdZGCJcQQ6{-G*&8Z}D2NyPPo(%xPSyb!1p`hjlqLE=qe#XnmBRo9+y4PF$-x1Y7Pa zcZ`L7ZZ+S_>s;SJ9s`#6X0@3p1o;_Um>T>>C=lmt?O8;{I1m!0lkS|{Kq!8=%u8%2?%CE=LYvXgZ zU8Rr5ScZGD@0^=S@7NLsyuFc@*lnfgTHN-$-gs7AFODZ+iacFfUq%>IeFmI5CV5A^ zCQZz(!kyz?^)24;JgS_PPtC{Jj!zI9ov`;U&BsP(_y4F4h1-C8A4BDNQohwD^zMki zh#gz-%sYgb%gWo3zLRiCk5YPq^etrIVg3JL#8Y}^bRIu5PIHhnm!2KouQBz)Sj>f9 z9^O9n9F#Kw*qdPRJV z9Qua)zk>aU{)K$hezw7W)cE^&d`{58gfU^u`;F0Q-0!P%U8k&K?72+h8~nOr=ba#@ z0v84h2@9@k>3jXVL%pjEE)TH|5_6l%K;;+XD83*5Ba8$d34OYx^EOV|M)mJ9%-<2} zGhC1A1OI~h#g;ICXX%pVJ~#HTbRPUl&IQCSr&Q-WH*l6P5rX4@ircWv9qSjfdo(6boN!kWm-7A>&SMe}S0V>cGlZzbDtKK*f1#~0hE!LOFY zw&GulM-CZs`c3z*&UN3pY*6V4uHQ>Ox_%$zqi`3pwj0>@$C zJ@-rS-2qPlhoKFH@6>f~H~dH6u5waYcuYBY`EX6=A@DyPgCobK()hg~lLDRs2gLu8 z-$3tBJ?OtG`?!4vS;IZmH**blqlYZVueogbGJEg6qhVbR)n|kU#llf+#~qCD7jz@l zJ5g?B_))Bhbur1Lbw68YsgJS*TQVCWJ)J&j}R@@wIn4)Z+@~_7Fz2>Jy`&faim`5F7Hu=4stmjLRpD#oP&6l z>RJB_ydj)L*Dl8ooZ~jUP>;V|>%%D~s#$b@A}(K8k;vk%|bx)F@4 zS9-9b{T;;{u2Yx4D?Cqpq~``a1q?VwbWQ)|y#Y@lO&QmHO&Px*;Y4Y8zCVXPWywgL zJ9qiJl@H-hx*6#lQ%X;|^8AR4z#DB!ZP0!DG3H4B7v)b~xXwkr36lc{yk_^(k98Mg zxjVFL#eS?s)&|TK7Uo;af^aVY{v*uj z`-DN~29BM3920@dy!>>ZYnRurV~w)CRK9WDQocM#&sE#^x|MvpJgw?e=fuKJ8S}nm zb1X$ZE=ERtApQbhhxuR3F(G}ZXUWa*j)0$lb3IR(3UQ3d@D5=^Q%(Ng-1)TcOU+$bA1@Rjpd!qxPN!Nc1e^Z#B8TrbEnMik+9^mtM$oJcPlds93ZzGNLVtu=> z=NFZS>-FCLE-Rm?%%o=pUJ95y9JfiwMc}wl=aji$6Q(G4>fU*W=fpS&Z68diUK}&j z5zo`H)<@F3Lap_$aZbyZ2Yi*WCeI}~#~f|1U;e|~9o6{(>fWF0?-oYHCwiXVue!g4 zn}D&f9@Zs{@hqh+$4_`h`8)MKg1*7i#j&2Nvf&+NDl5uV&kr&{=gJ2mE-zx0W!OJ5 zYV*{o))>_IcF7X=M}sZd)Y{i&=T`h*^53&}`8tg;UcAs2%)$SK|9&Ln3$OGWHFQuI zKY@H)OW$ztPprp&q<l!D|Mh(RmuEP}Bx}V*F`o5a zg@7s5tii|SL0Xp~YX31`AdghXnmZ(X$$u|j=+;fFT?_ZD0VAc1`&@wkemedMjbFXe zPva-%!F9_Ph4B-5hWdx}%w3FORv&@)Kg!0Ceg)3Np}|)oUlIYl1i7jEv5!LeXWa+2 z2jySiLps^{@v(Eaf4|B=WkTTlz0NuIcIo$3CbHvIUTS|zr#g%3IjTREYp}=k4DJ!a zc}VB&*y}yu$k){Kx>H?67*hzS-L> z&+v8_m6>d6*XfD9om1Aajv`x3btPHpT!PG!Z)!JdW|sT!!G`>+EAX$%e=q-P@z4QR zf|rdLhJ0kKoBQvj-wR)ney{yJ#E<3u+ro+WQAv*y&fqh}Zr@7(57&b}Pg?TqzD#hX z<5wNO$g^Vc8eFUN!Vq|IeO^2U&pB7CEkzu4 zNft)sOL~`?l$+vUd#nBePX%0wA7ZXh-M|46hEz|17gYA*4c${cN1UU2Ql0sEs6+jy z?C?AE<*;S}b48Xg-sgk&%D~ZO_~IGPS*rWE{-fu69=RXnw%&7j-s1N~|JQpRCwxQs zvve(dzuR<_pW`OFA21m5ANWnr3c>kYc_X;5*WVpsOJza1smz0J66(a;e1tLah0epe zTv}^H{(H@T#DCA2X00Eg`Dx;>Me^S>_IBhD2A*8uH)`!7KjxeG)>tkIPnUe70XxE$bGrQJUJjH8 zWfAwANXH8N9`F_FEgZY<5!ItG=bS`+m%W256V@CLDqq!0R3F?scp&&3F7Xogd8fGQ zt-bi~(Z8hMzyBWmCH+g!*8knkQyh++zog&C&*nJDK=SAR(LEh24m!W{PmC#lPJ~q* zlV7!G^>Ygo>bnW=4fyo;>bcSX%g_D&@~u+#)I-42C0se?d7jG+$p-2{b#Y0z3Fn$m z8L%BNru~7oqc3UirgiA}tCll%jj^3Gr<7bAIsA<)pvyG>7JNxQO8;WbipW2q^-V(m zkjAf~;|pKPw}%K{@M+M=z?fqVzCwO0Xb&{4-4wTvcPI;C%H@5GC4C>y3wY9Z%TGZa z=-Vmda?A;DUM}I9mlNp%w+UmRPF&ZBvE*fa2~S?Hj;~O^w3ujN-*JnOw?PS)){PaEhgn1qZ&>glj4|^r^BBn9#`AWZ0^51Lx{o=XqUv>G2 ze!o4&7yKojjD1>l*Z|9ouBR@y1 zhXuZ(EJ+t1%NMQk6_&hTPO-|%>oJsNj4RcZm$h(Ijx(;wx4=EshvQ83;#d3+bN z^BeywbN%2v<74 z^j|QhZ}U6`|EX~7`1iGR1HR=Cag6$VR3-tVjw6*VK{&gd!^+E?{7CM2`KwKXVl zh5YvqJ@|nA@eh^lw>Kx)um16W+CTsDSN5;J{#X0sZ+>Tg`28QOWqu30yK^VTdf#*I zO4!mp>G$%LdH>^T^*;vxz5J`%2g>(Nlm9Eikg(&rJ=k)cO!;z5!B^x{I8-0L@-MCn zJ}@vx8m(<6yahQZE{=}*#^C#++-YBqFSR{F@SBoObs}z2*$ZP)-FmrF#tDpN-QjEDaep6W z@A^ISS;IIH;U|2LV^QCOJaSG0dun5v@2S}RG~z9NyRhVSrgD+*l6ob`-x1f*LHbQR zjp~B*v3&D5!jjhw&vBk8#~1Yi4>;D!@fP9J>p^_UdKLKnmMvM}`j^_Y^IViC9ebTQ zw+0>&M&r6ypJd>);dfp-FiozJz0!E4T9Gwe0o-U-9ULSP8 z2xpXQtnYdI;l9>X(H^9MvqHHBzJl|m%ep>GeehrJgH%09x54)%-ALo@H)?)^eD>%~ znzOxxah>z=OU%aKFoikwBS#Fi0RvuHekF_*yfepPeDHjWh(4QHpJYdvJQPB zYPb~3`Fk;c#7UfK0-SX)q?@K(lq zLr_`7fpoM1<=6Sk+aq~bxpGZq9Q(Dr{G)OYTqYb{x*s2lD_rJKcj^z+{Q5okr}oHy zul}LUYkhvl8rF%^S|tmaPc(h<*o(z~%YMAfKe3jvuc3cvy|2mR_9J$>_c2Ny3SSD5 z?2{iZ%nOkGyM(hK1HqN#qc}_7Lm7D6^|q?^8skW9FqB&;Q_h_W@~Fz0PI=pvV{ z;eYfx+0Qz4N+W;dTXux{RDCF&-xmfv=z6GM-3u~EF&wJvhmHi^* z#Ierh*Tiw?fXHvhVf38=XDU;1WRQmeR{=+=H=PIDD#(;DPE&O${!$$2I~>cWB>#+j z2l9Vv?HsLJC~UZYmAQdF{$Ar(|Av3n`-d1Gy?in21E_z<{j1u;F7i+C9-rUg?~m=p zz+G-jf-&)yY{jrXlkDlBd-=Fg@h|vLABy&&(t7Sk72Z9}T+T9k|1ZK3pWk_uYe(UX zknW&gd-n+YNbsMd#D1)E4?MGsz_Z^iJK*=;l(XvDK-jR38kB^c@*OWFK zhxiD3hwoWYcG&lvIm-BVtuwrdwIGij`;a{FKL3x>@jOo-j&&Xa@8`G-{wq@&f-ND3FGgBd<^R|h4J^7#z#Aj)IUW&G^bE`kvx=q+zaMoIq74=^gZHb zzPF6JK6ZkAcTTgf)0Zdh?75Tn(|*Ah_oU7=k^uP{^UdYxEbTG_4oC>bEl8{|Md-LPm%Tup7{muU=39LPwzOx z`p#$cE@ICU_fL~A+4iT{dq`{Ye!;avi^ty!Up{|G^E>e0kNg|{`_aSjPt0cg#FA+JFZ^HI@ztu&N&1&~ z(%13D$LDq*;VkTyc^z{ED@#&wTctojd-%uW5bi<1)Lz zy6NY2e*CC?eVlurzemhk@1GO6uJbb-pY`yrojLZNeaW>iKjYeG?}l(J#HT+!Y9~G- ze607pYhQeFg!Jq!L)tT+66=_7>evzYpvIHeTppF=e&3B z3)a%*y{E{>8SW`Q9R;21-Wl?JmhaQC?w#bhCq6Cn^Rs@9{kQn0(tC_|z&Xl9Wu>6~3A6_I*QYpV{rRu7M?oC4HwJ6ZUpVs#>(X;fJG#KN3$()% zpRykVd?$G>oh;bik&X|S1sSS(0%O9Q>NDaA=P~M1{v`L`3ty6vn>YH}aL!-!Z@d3~ z%0wGA?8^N^#jIbb^>a$Gm85@Z{6xT4v_2-|Z(`qs=OejkvDcQae^}=6M>_xTh#zYYt`N#d zM_ST#yy>X z^d7Pco$Tn5x5;;z=l#SdW$X{czB~jS`#CuFYos~O@d?6byyN5d+24k|>6s@KfATK- z?eN{~m7w^z!ZF$dIQ(2~gK(UCC-7k&=UDr}>H2Xnf1Gx8!qbA=V;^wL`DgFj7wpM& zl9>I<*c0e|`1?a|Lnp!cr|ebX{yy*}yU~4y;K}WCVz;?mZbtYLrofoXPF)v|AgiQ< z$xpSNIkuY_1GaAU3i^i@+oE~&5B)v(Djov9(7z&l`5NW$m)5^mzoYwBd5^Fp3t8CNO)y%CRWf zoBehie1Gt+_Fcsm5Px}~uSq@$>BHbnI0`yH^@8oF@j23=-DgC-Nmq{lulX$MBh+|6 z&5d1$&tln58j)-pTW3bHb+uvt?p%xY!@%`&YZvx((rHnRLC#LXIW-pulwX7C?fYaE4e zzlizV1$sVl%jQk3C_Bqq=jK>pPPP^0$ZR{SxLwDb4k34X<-PfU= zJpk zZ)-Vswy`$%-$mTsa_=DA-o^?zF1VwuwY;;f72e*?iaai|R(EpDe_D4evcjSQYtgFE zn&)R(c1}~v%gVG?4eHo!IeF;btj`X|Xdjk?_(q(&gef>nx_oR)O3vt9wwQB;<7+SW z=|SsExmWn-U)z8D_FwFezx`+CcKoxYB_-KUufNWI@`G!wE$!_7yE}vPhivk=;&E5P z*O+4IU#yS0WWKN6s`c-se>uLeoz#~uU2iY*d3{|#^!##v378YFxlfGzhV~(QCFEJY zcg^S5oJ@W5>?vcdEBNZ1+1PR$Hn#=^1y+xCUcXH%YuK)pV@Nn^3=SG~XwP|D%T(P{ zrp-E1Kex5ErgyXi5BZkUImfc7x7<#7mVaBW6?D$Eyv})+b9;d`zrBbwZMfIk@;bD& zf==zMkn_9_MOM(hrR7rZ`5jwWE*Q%reL?3!&Rba?^`6(M75{5v`TVDVytLpyEx}qL zxN8Zv3&~3>Fy8{qwj{Lb+?IOh9{6f`o9-#JvR0h82GgxNx3gAYx2SV#YfUI3jncO! zwBa2}Q^fn)@Z2`!w>971mg~CLj(hDD^9}8(^Y)ZSTk_PNbZvNU=Q}%Fr`vC{e7;FM z-j*<9(pYp4bPd*e4tZ;Ck$a?VH!wo0CUb*Zc0W+bD;u zy7erzd9GDv-xGyO1$kD9`6(4?mx;8`szv!$y(rsi7B#n8tun1fQ8TO4Hp_19kZrei zYHqi7&a~RMHMP1OGptU>hE}^%6T6k;8l9S1tq!?%Yr9-)0G~Bz4ga*xvwB5bYng4e zTQ#>DEt~P&COor=Rc~3}su$d9weD<{Yk5>VaZCXKXtv;D_L!I$1SnC zuZ^)+nCVAs3m0(_Su$7NKt?j(_3d*74lZKkmnZWSe3$DOKU|S->FHes~(!e$)IDtL*ya+w%(ESHU!$wZxdy+!pXectUxe9PKX zTl==}0SD4;cES%^c;>oQOQZEoX4*8?XDS}{x;^~h-IKnH!$yx7diKrP;xFMV+P?!^ zL1W7Hz+W-Gln=KTg)uOt{%Y}-^OxsYV{71Fd|u)&*Y)9K`A+2X-ND@QIg`iO;}6_r zog3D%topUBN|Q`W$!u;3+0CsIdQT;EoP>fbtJ*TtZY=~qEt*)Z78&3y!)mt5u)5%( zUK=pgzNy{XzM0kTK)Q~^9l;8rCdYN!H@AB2vf)KA)mm|m)knV7Y6YeWnp*Wj>bzwm zFxJGXQs?zv9%z{>$}DS-S@V4a;>_J<%?M3)g^)qqSb=MewtZ{$mcDB>pLohrcz$YO z2AF7K$*me%N~=beQq+KR;+Dik;H*t!OK#oJs7J@>snsaNrr_s1Z!G%jBKH(EnU>ql#iChZNg4zAE% z982c2KHk&`Hg4pQi}!c#_+9X_Q6oltJ#Wr*_sL3*`Tj7-?w#oO@~>TvuNdoE*VM5V zV~)HAKOMMIn-Sjl4h7kUTJv(-rqwoQ68K{7T&Ils)~rE&tJ18IC1f>WKeG(0+`NfZ z%xP}PV4wzdR=2Q`H7sak^$QwU1L~>)Jky}4u{9(#ZrvDe%CLGJGp$aCW?&4wbs~Vb z+TgAZJW#(?mNkN38iLb$Ex=)nt=xK61HGxifMUzuddhO%Hp>>S_7Zkq4A=ro<@nlZ zmO*H|gRt|WH6m`vc>}Okuk<6U_WS@#0{@j-)Ul+(y5Op=CAF$=NiFMHG9jgPeXv&_ zPHF((f$3IF;Xt@Zcq(cNFTr_)sx2B>I^Ue$vY}PyesW<$OQwCLlJ^waT$L7ZoZ~5n zGRm>a;42Zkqe_0BrR6a%F&lmM)*3by{@T0&o}n&XFOFnN@Y6?pC9Ek#^{4)1jjP(r zoMLg9`|rV+_(k~I4HkBwlWUIJdUW(v%UM%~@r4n-?EX7DeJ8#~jvW5={Mj>oE|%60 z+5*pn{f7d7$-k=g1YO4hN9qIexr=aDz#G@1w&1wpdMrN`Z{NmR!^~;gia%mDeEQhE zf3o)V>sWqc@xUOZu2TkCJ z4C=E{Yq+d^CR_%dIySdDoxl-zYsh&<8v=Ed(Xy#ECNwMnuVA%Ci-uO`p?fWN%W=!y zd(m>iRW^K;z2~CyR&y}p-1VLK0$bZJ27H0D2HU~dwu^S_n|m#}T?TotW0ebUwZs+# zVU0Yew613fE$e`x`rxM_7(=#__f*b$dS(1ke;xOVc zr#|r4KKUoWn7B+bNo(nNA2(xH)mONay%UA6b!$s)HDfN9&S!s^=@V=`cI18Nf#3Bj zE*|>z{5b(%zP}aE*g=2!F63@Gf4Tolx?jLnuos2@2wUVw`=*BeD{)y!tMps9ux2{_ z#9P*buSui9*PYg;Zf(oJ-l>(<+^QiPt7T&qx^3!OqqcRh z3G0Ob=9(5Yw2W4b;ig7luBkOZzp3AWxP6v2=+GQ{GSiy1ZEBfqnpiV*p(es4by%+u z%pwn)FWPOnZ`ohsOWY;-ctw0&gulSls$*8Y?@Lzw$>*%rM07N8Ru4SZp1Og0uR;E6 zTjhe9#I?Z4t%O=uv8X0ksg3*tM{rtI_$-~{bmEkPTftWy!mV%~acg0+4ziWB;4`%l z4y0|Q<~6b^dC1~Cu$I>hog&i`n`g3DSB52`3uZU2Z+SJU+O%;aZ7XHH24BQUDf6XaJ_oq88L%^A~vux_$7A#XRQt zBmaKxdEbLxzrn{LNGA}!9>wQVRJ(>XZcxvXnl-SBnf0t84sio;*0@bW$5sZir4by}06aAiZ*@c-5`?dec1^)p6OO?ax=#i&svh;* zfPK~Tk%zha;4Uy#&R>5IzQ9(aZRah$OE*hF#wO)~h1?oe=gmD<4<4(t&8*5pe}a#| z71&B_Q60PpW3}L<8gLMypcc9ldS@Yld#S>kaLBb}{+H5NZ3z9KySXaZ3cRN6XYX$7@Q=MQ(^d}-s|&uW4H$1p1+^^!ym;Ia z9&1(8DiPAbPdfOjnqSi~l@4DCZ&h-^A96LNC0y4Ue8F8wZ8!#BRay&k`Y*@uT-E%# zRxJ;#Wm8_cjR_5{at?Z40d1*aZTPF2O&vGFWrcL!{rFfNORA?x=aQVcWJkuw!kcWh zz+2n>?za*ant`uvnfPg(8cc{GSd&FO)+k$*t4ZgN+ z6uw5=BjBs3RyD_0Vix5CzA9wZu}V4UER=mp0c{sqmWocFiVRExU$XtHBI~LXYG6m! zfV-+=M^-z)Q3GF+Me=)S zf4&8CX4vZk2U(A9-K;&f`v3mRYK|W{1D|Ae3v1D$lRezyDOArAT8uosgY<7GL@&}~j14_Y1lt4(qN0uzV z5pi|-wp!=n&uGSR7RO)@9jylXbXs-|%UZbOzm6|BO8Qs5dHbx&J-1mBKDMeod!ye= z$B+2y^>Of4P4HFQ+e#AOkqB-Qz=^mkEgzi0Z&krc3dc$(JuM0DO2n2)Y<;U$0$T}f zYgy$sq$xs%qPr!5uT=iy@|FLj=7Pig`fz@ItE^-6|7P`SA|I;+{T_U+Ub&q533geG zv3Si#@l?zK;tbsvw)S(~IYby!UBfLJpQL?)q~Gs^D>kBkEm$^ezXIXh|EjPan{S6(hZHGVEgI)Tt|H^FUgsXoW{$dRVU-KS(Y2Jp` zlGu+8tF`K-|0z#CpTqGNbg@g{67s!u(?-|rgs+(si@{fWE3A=jjnKbRa~fHN?1pwr zPF<^*hh9vXCn3j@@@coK1KM?33-nvpKj5?iWF|Upl82`F%QD?gPrz1BY6;eaxBN`_ zp}G4$tAe+xE${^tq7!G=vdsBA|C{*2KLN%XAzKx@k3#s`dNIhymq)-YU7$dEIf$7ty+N0f`w1UF+R@9QdiI%OcAg{M@z&vQMGMD`Ykvo zB*IyV=w8BB3fz_4l5!}l#&^JF*a#``U;?b#Cw> ztdM+^ZbNXHLS4a2vKd{saXCpH`n`y^RHvSX82*rNY9AQz`5ySxMih^-JMaB7`&-;@ zE#Rbrq7IhVs=c*rcPITvPfU&R_4Es`o$CACEB4fLubSegpX+Z=Ki}V;d1-(>_v#>f zq5n{uIAsR=C~a{4E?%G9G39GwiqC|*fUyv(osf6wVvfCFlWbWJe<81BGtYv*9=fBW z71cRJ95<_OnRB=Nr|^}r;iT1{zt0*hI$-q(b?3iD ze8}p|-D`Cgykm71A9ml@tqTrXtwm*4t>4Sol=u{=d*Ms=VKV;KWMp3&IE#H0X>gGI z5=rQqDPXU%WFy>_;J5;FU@N(ZZ-=`Q;VtQE!j{Sm<;!PhGI>n-Gu>%=inxvmUn5eMBS;A=nkT@HEuQIB9O=w6Kd+OoyRd-WeU z)E@5sls(ktNqd0x;O~E=hu!;U!o%>=qdly5zZc5!HEIIm4#$kQQDd<$6~>jYCrOEo z9zV&(VoQ!MnPL;BOt%^H7TJc4jGrpP~_cw!w3c>?roj|!&rfmvmsp!VSRx%iq4KLk4m9kC6 zW=qY&&(s|Gkxjj1g*c%(b(RhGkQa$ra3P^Gc0&@}m_R*LZkz^x{U_ujGO*sOL!DPE z6@XcMv&rI4{J+w#6R|-O@uMWkp2Pp1f}WQqy`Fa^V-qG4lF74t6-jVTvc3hrD))8C z&O}yLgx3LwLESvpxV{-(5?YTkyE zu?JG%v1IhBM9MiO`&RmbYFpd3HLP>{>g*p`jd`FotW*0MmV*s;OGc_SpTGU@=dV4; z!WkPZz2A%Q(u-ET&$Av^!>^j&_Z6#(k2U>?K346iS3FJC9(^pm&kL5;=S8dX?CX~L zmZD{I!pVLN*)?Qvgg7?Zu9z5}h< z6!%pLSH3?L`IOG6JZj%P<#`MHI;{X-o3LqSU_0M`X9p{)mT2|r!dK{CH{)9szHSCD zl_3T{8c4KF>M^~N`S{Q@fp2vUv(SzXu8dKJk4fw zsbbR!(+E=^t76aJlLmh!S=OSxmcKvvz5b^EYu80<3dWkkV@(K+IaX-28{8@E3i^G0 z;(F-%b&2bum(?NMiodlsp%$SgdRh$ybhPU0zOwX*t1Y2Z4n9$Iba*HUj0sZ-gjBF5 zT%{4*UPKQ~g%hj5?NuVXAXzq${wujiNQ7I{@vk_#u3Bv?R;^;c^p)(XMkp<1A2@i2b&pGzvzH(k z)V^?xnJ&lIp56FP@jvVaGwK7-TtE5Ic43Qd+QN96jhk#0`}wX~zsXjw-DE4*u~!CR zHDT@gZH!yqZX37mu+7`H+m2mfZHkz)#A%K-;SB%FCh(=Xzgst~u<7)TJ;=DF!s=D5 zeuG+8fqut7G_Py_(Yz*l7+jA`5${)~ttJpEfwLsZ8p^a1cuIo1Qo&eC7I@2{4v>=# zz}}=T*iFLIV`(;}3xRktVUoh5Y4+4z=~g)-*_tib`Cs?1f*biK8iJXI-=W{vVJERV z;HdUy0>?FpYi^HvqgB9V{^ zXURTI26GkA@hYL;%XUf0YhqdWtP5*U2FS;a$j6n`zs4Sy&xdy13w$|u1)eJBGVvGv zG<(Du1kKmq#kybGPe*$z?9du>jI-KFEMD8ru{dW3e*GQzEi`6&`^I(U_}Y)(RM?V# zOY&|nYxVg$`t%2E0=Jua?v9)b+hKp7eKCAN5aBnZNjgt%22Ps@h?*~78xAge50`)_IHQHV> z{To%lm-83Am4N@NB0j>(*vnPWzna~eZuvD+DdUlh&4E{t8Jc6}?Vb7%uB6wO+mg;z zp}tgCJD6*+m3rT@4c^$g%{Fe1cx00}XFKyFwjs~9+gA41*$(zJc1LR{#A7V>Zr@an zFYVhc-+b_&(!Utv3k+{#f0P~SGvBp`xfXlurHM!F-yZ+mZt3=k{f{o6TFE^0zMbsj zvwI&H+f6#~E*ltmsQGh}o#pZz4%3_ytz)`n-Ey1GKGOHWU#+SpS%bRhsPqrrj1FD_ zIadLFyaMHzK)b9Ab}A8W!M|ORxFThJ3z({mk2Dd^O3Vgp&8t~0xJ>eJ`s2vKE8y$t zyVI>A_-el7KOrCgZ{iCsOI!R2Iu~O`up`wcCcCo=yyQ3%o+3Lm1^rU^lI>CjT&3dA zP#FndH=}=50$&NajjS2^eL*ex??*YlO0lVY?gV{Az88-3mgFJ&mhdKgMaQbY?d*B8 zi@Mwe@9dz@apUHlwtoF~`gC?+qX}a>7%RHdwt=h7U~D~j+rfW!GY(O*aNo|&<@nOL zh&{+d>FoO=Y-v1(&UYg3b_q9d)5fj)z}I{Bn@3OB&5wO*|KFp>ZOkm$6^sqq!+a0I zHh50lr#7JecjqngF1(3rH?Lc3%NdWhc|Ch*jvZ!qw{L5CRT8ZZ{=f>Eb?o1p*RlT) zzG$BnDZ>iF6IiN%47>$A-I866>)?z~i6D$6fv*ZpYua=7RkPV$rE6W8za$@>zvgcJ ze}KQ>u#FcjeciWK1$$rpml=!2q_$=U<(UZDR8@A!&Vi>67#XQ`A@|H z{4(fXsf;gdRy&RUAvk<|kdI-X)u1=4uERboU`=weTt-Iqh1?NVRPT~Y+u)A{%l25E zz8_iLzVBP^%SY{*@rU6m;ZOXs%hthZyZDc|YL~cd=azDO`M3+-sq~Vyl99r~9)r;&i|SlRK_ z%(7~NFZ$gkql0W*z07T@y{wTJxAT4QSil(j7e*NKF$>h0_+gv4$mE&u0qRAtz>m;!%cA4&0y<~*nkz#@r9=ZFm_9Xsfu9kX8MrDUCw3Tt3q>e zTXn|h)UcUwm&-@-7jja1*#942RqVCA>Y!`p%U=} zrsOlu5S|j|WK3@&Vu#GeZ@>K-Z2gMx^T)oh zo@3s_4~kwy*a)+{kF8u(Ps4f@xxxV`#UqQ zCnd>hF_!lh3;I|b*Y|@Rsl6mr?|bmyOD1jHy4Oa|JcPVDiR?OV{{VjtnQ@qUM+XCk(z&;8 zN9KYX1<7C5Kq;4xvF;`PUt`F8EG+oiLwSS(c3M*3i!f5Q3>DI zABC|@>H5gV=I9wwNPkX6xGF)|A{OQ<%a0*lEwj4yx{I>xN|1hkMgD@*@KHQ` z2hZTY^@mId_}V8qc`=NS#=rHq$FKgM@K0QhuZxz3FC(qji+m&F;KW~GCJ}#pqU0l3 zNHFqNTBV)ZD z9UFYT1igGSPTG&b*OWyE@ma9XGy9nD zln%B-z6Xt|4m`DQ*Y?Zs6|L8h zW%xWKhl70Fft~5{Q5+b{M;%A}wUPdzQuu2V_?kIkggwHXASs_0)8ng)DT z%tZfkoZ<;Ndo=UNz9i@L9a@Hr;`6ybMN8iRgvxe{ss4a&ikHoX4DzS zF@kiWbD*IKB3W|I4IOB5lR-sM!K^4v&QTO42L%-+)8veK444H3$28-*pYN)@o1UcS zc<+7g`8`iPwfFwjuBu)2t?yd3D$z&G)Vx)VmrG8{Nj3_H9-g%^8ozHXd}Ue3eC*5c z*B3YIfrFe49 zdsajEq7V6d(i^+*ee7=ZBaSg&hkU6|t9(iC5|24|k*41hr}~eMFXZEz74vQU&;iyl zJJT|6D?q=mZ#A2WkC>Ojbqe!XlbWMzARANRsx+{qamL#4S8Xtrif*Q{MfKMo8kA$t zSL3gr#}^nIk!kaXWmyZxjAgscEbe2C7Ob@vJ3jKYX)TX@XDtqWXUz{@w&wWF4*zIP z5B%9(lS4n+?FWCb#{2(ljSu`_4flL)jViyl+rXRVM#uAW{@eJ%)|$3-H@0GIrRY*A ztQ|@QKbde=ZS;7zTVTJC?IKP6OmP~{F$NCPm=l*IIoSsL7xJ+q<3rE025|3=ZRq#H zm&T0)zP!)K99G#)W&3p9oBGz?A+8sJ8R=g~(W?)Guf9)xivA^hU9{`Qe{H*VpT;I7 z{Y>~mPnTVtI(O_iPhH_JVJXH{=s!wVQhzY;moVe{{h?E~aNVCQ5snnTu0_uqKL0)B zF#SjAU*Pf(wpQ_^_ZPv{DUD5%uK4gYZDb$#(tiBnuNO2wXF!p)%w)e<=EEg4Wo)P^ zI(&2bipa@ibg)FQCH_hihe5(%9ppga5nu%ChBPZ25>RE9;wY z^%xsapYm45B@^JyT5x5p=8RJ|&*oV!&!p?+@;ul3wW*qG1?E#+cIRLNMjt94W_1>A zwSt`&tN}Qyf8eKIu;2e3e}S*`1+QQyMK@p`Wo_nBYW+|eYdX@fyJ{?4_6q4?vWKOE zy$sfRq+*vyW}am-SW7{krlGerXH29$^9G)OW(oLG|1rqNF!l(>+$N#<(BV3s@2-gfOjgYL$9Rxl==Tl`a{7omThuEt;D%_@w6 z$I#aU6QpqvyP4h>4;}zti`Kno8RITk4Y=!%W52eNIUg`qfPPO}0bi28fxD{gV2&-t zi=9OJ7xw%8*jHCA#XixCy(ZEVEVC~1u1S3`hJN2nvXL@H*O!b;Zoz-J+F&hN@(?Fn z$qtkTcWI9BW4{7l%gVECnJ|VwduX;z!R}h#FV995*SGPd1va9n9(r0m8(mz$IDCPX z_pfJTOX}O0(uOv&xPgr-s!x~(xcb(mN50izPD3qlm%*4sy{#Vvj4{{nUyl#{9lnr{ zwP&n@kH8Rf!Bd#aQ=4^cnZlRP=OJ$9ywwJO>B!0;Gqs)wc?#CtwgG=-GXJe5V?!PC zGi~+CrN~F=_b++*yB@5*qwD#SkwK>qo7XjVeIPplg_(s;&)>% zTK42GZFl7DlEa4%gRc$m zSq}L6Bl_3%aAp5FK|UT4z6htZ#F0K<$n`F8t@wm7?zJC}>|d4O>pARS{d-{lN=vai z=nKh>v3uQ)oNV5}5?V0-35;n@O)~OQeM#x#nj0a`aJwq)IF<5FXPo3QY!3f*{Y&yu z*a~jx@GM(eo@q;lXWCMn{Kdn9TZF%GXmAULAXDWAXWBg6T)9D+HU}qv_P|UV1{db~ zxL{+eyOB9zKK=;C{^|JR-{A}X%9^(k-HSHFx;xE7tgZQC8qXGg;iqX#i0@99jh}WE z+b5FXuvGMX^#wGaw-tTI&W#Fe^>g$e86OgVY5uXxN95{ET<8Dm4$>=VDNfBh}KmcU_4z}e!+EgYI<3(?OO;Ljg|!=E=e%jR-DSN@%W4ppS=H=K4GHIT}{$jT=1337-W*> zRcPD@Y~_HhOmLM2f5~b7ZU%m;`aN+5Oka_Ynp3%Q(JbrR1sha$iWTJLSTgPH)+Y2Ln;;*X>qr7>>T>A3|6FonR`wSnOqo(BIf_*=5T-e_N+{FBa{q*3G)Ar1kcbPkJ!ES*ouOqE?Pk)H5HuPhar$fvG(|ny+ zCWgMG_)8c&hJE!l-`hg=`xswsv(v0jF8wm;U+7-7T7nzKMpB}A^C`@oPr-(r1g;V& z-y~#05|~P0EG`+{HVM099ol;J@uB~>`Rl)fuNmNLI{50%{P}e3?*)6m{V(AwXT@Ij zUkbXs)^+DFZ_qIWj zd}!Bp=I1a+x%#U*Z(iqnySSrQc6|_I>*ewtI~YT|=FZTk;`x z0@?OuV~}nh>N~bYoj$?&jn()|dpr5q5OHfheQaNlo-Qsr0XCGL@b%p0x2@K=^Y({P zU)r_kUoD;l%h>hRj}VqC8Asm_CWWt92Rq|Bm^c*v;ykxk=|9H!DnY+*2fiBCM`wq( zG>4)VGBAaCCRx}Dlh9d{WamL|6`m5oSc>e`^wW~iJA^sm?N;Q(oZ;DyG1>3`C*Z5F zC$``gxt726+%MuQd(Tgn@x%h>EnlAvU*&?YT=**+9Wx7iUnYJwV~@GCu^cd$BfA|o z<}CDwOk`yyb4{`dmxHWqRWH*z*Udry3i46oh+HJO2L!e3kTO42!X=I-B0Idh{dzwf^;!&(FyoHvxGFAHl_$ z%va3%HaHCbiO;|vJXXNE(6;q+tTS^AUwCc_doxA$ zFYiCbeaBcXUeW7?G3i{#;DcjFnX5-#?%Q|3il={wZ2XG8<5za|g!A_FTE=X!-8;VE zl!NpmV@~ousO(>VGe0NHEey8TSpO22i61pj!^-3 zAALw%cKJ}3d3o4Ua~xmnl_Pru7;>yJUg7dj90i|cai7iFmK<>!X{0e{DT6t2Il>nl z)`s;%omu0tX4Nw6_ncuY`6#(1ect|##Yi7WOm?R}`Z{L=q?PCqyZ$Ec{h>?=liB`Q8BF%5ld3zFv)amfBY%kG^)Ry4lt> zzrL-LeDwKWtna`+5$5FxTM^FSu{V*6>N`po(>RUB`cA?TO&>Y$bCj>5zU6)+`8eh) zO9O8$AO6%{+I7aUDBVfAkou)Av#9e^C#&HL{yORUm#`3_l^i^KeAbU65M-=4QD zZNeqHk+g)d>*Zs^?=tO6x3?XkFME(RM6$64n?%s}f=mwh)p?~l?_vM$mt8)VVV~&2 zSlMmJ#}vjLHAg2=eMk0BOJ+Y4U$e^ogel-E$$5*uBzyg(GJcZGzH+JHPV&>o>m)DH z`%^SFhwFxXnp~F4e8OyW|6H40o^LaU<=JemXAH~7b*fT6#gA1(WRsDJ6;aojbUT~4QamOOBQD9u{XYIE z{$hRFlG!$}H+y{3mu`%HpT^jBGB#B88GSA}_)25H!BqBPs?C15DeM!O1h!JT2xB;S zEE$)=8tOzamLOS*4yOIMwB{jQwjkGGs5|6}Y?RrN%*mF%A{~Z$lHBn+;(yr#atNz^ zx$4N~Bwpbi>CXLo=9;+dU)t~g4qv6L>D653Z1^>cde=U}+3;>U`xMqeuIFJd&7*X8>Ji4)_=%C<&Ed!upD%>OxC(&u!bsIm}G3SNnv~TY-F!s+E@;4t4+OZ z>ju8GXXPIB``2H6nK}slNAE+zUvEaXuW*l^555jD&qnrD$*jGVXRW~l7wjta8>Qca zG0o4(df+1K_|L*UvUe&xxWY#2@{u^TPWH-8AN+-7@YQYx3xq$YPBZ1bc}1>yW3X{$r5G8kcYmBVE}iv>&YO6E85n zE&14m{c{?@U+K)DPi9P8_AZU3rJ}q0I(+aWo)VrkE|(0(YU7f{X>gciW`ZzAJ!&4F z@AXE1()WJAPo=zNf7HB-FfI;Pa^1FDzIE%KYkgSX-JN}Ex_7T*Jz4MF1-~1vM-QHN z&$FKJU}wg!?<&gi@yDOV7vn^-;miKjkM-i>8eujQnVpTxVcx9PH0FVkJnrj&zkrtl z^et?rj4|edyE+~gJFDwiU>qE&uPBUV``R_y3;oPATsk^i0ehO)VGlIzi=Bs_(5@l< zN5&u>U(C<({U=nnk^bfKP&QRC6?A>^7rHuJbX0vvxM}Z!Q+EIIk9}UwwP5RNaQ2_$ zFWI!UA7UdogYAnk9oer4@A#6gE&ft{pS+^qOCJk!{UsM8&WZGLtqD2Fwf3sk7|{{1 z^yG@q>}uvtTr>91w&At7FCjbIF_({;-yywTx}Mu~oyQb6{YS>Pg)gmt)cWnx9-KSC zJ}*rgQRhtpzLK4PLZ4A<7PRNB<`Xz~!Dq?rC!Z)EjOkgj{zDH_f52@Oj2WfCV=4Hx z>5FPEO$zvOJEZ#h*od?rh2);=Vd!4*xVCgKjcLbDI+*KU(b)DpjXlc!EBROrU!~wy zdX-$BV+@@ge8{e)dpTjs^?Am+azvED6ivuQ0wX*@?Y_`PkyHQ^>*w_kCxbrk{sL!#Mi!lZ;0Z<^c8#@ul8Xe%)^G zzMj#4+`BvCukFlV1z+%2ckIlK8!->(c5JNJD3ai?1jcAnz)Kosl@34EmL89v%wFUv z$V%~75`HrKVhU#o^Z{zgW`V6W1zTBd*qss96~(dExG7we+k zaQ7wd&tm7)TxD=TeQOP*xJ0^__e-&Th*!>5)9-^$FZ*Y}MUZ8|rl9p{;v=Oe9`o^X zWb<0~A6ov(yPlTxE{zdr4y3{#l)fi?Rbecoc^cb@*4Ju(lY@I+VSeE}&VQ1ApJlh* z2ELfPn!?zIbbO6Drht)DbgJ5tdvKWS5z^}=6H^>#>@$yUmc(^3Pqwhy z*kd)WC{^ieD>6kya->K1D0v`l;m-)RIWWdu#PQ(w}dg_O7kav4Ziv# zU)A3Wx_Qv`V*CXDl70vNz*L6hD0vf4rAyzF4Ae9DPWuC-flGIqufzUL+D~8mmS?fQ zaR&R+N>9zEo#oOV>!C}ur$6raS{?Xn2V+FRHX+Umaxuo2_a(uX>P+(r#UD))q z^Ovvx(0)Je8|-oozRL#%vvq`~r(8FSkiNC-My1L6p z;yO;+$I!=QA5ow5IQrco){QvFfkDkNJIY#Jt;ZBreSaq5+W9Ns^}t@{7e@PkY5x5H z)<5>hufzU1%(($y$;>TGYRMcO@Ku{}BCY#N1~0XJjUO0Ozfm#~m&lnb!dEhOe)T02 zkfj;4T@SBuCB~E-qhQR}cM)GY;{#f!nhd@kA6%!3zwT#W0qOg)Ev3S3cY!rw?EeYA z#9y*4NN>+2ZgE&H_{qfvkqbxF;dvg|%EQ-KqU`a~)nw1o{!7x?GUx}SBSU=;I?dP7 zydCysPX$xy=%PAvCW~*+qjNacfPI`00)6 z_Al8dz(>6QgmiqpBaBF=^0jM((OPloW5SX1mGJKOTI;Jh+~A7$P7=TCU8EO$JrB?J zNj_@-uYKB|X+Hebnf>Lmt>AX%-@skTtnWx=jji_Sl04J8{ZCtCp}Pe1Sb*V@f$oMy7x-?dPgF!zq%HiW6+5f!$iI3T*1ox>fkKDphk%7*YivFG@JqzB-09%>J!*q0mEHI`$wX^u{Oxl&^PiQ~s`i!Y{K%ed2xQ=aD z^NjZ&cfR&2?fuGHTHz_iM3}o8bQ#UJk*sozxvzd5&*;B7=Bn@&@Taj#)p6J_Npb3) zenhqYqvl9x9o%v0cHl_7kJZvxoTy1ztlsCnqMaY^l2Yl?j~Np>{G%C&x8dl+gDT0jNu zgDdct3AQrGhwxQ>e&IirkHXf^;Hwk+S!(P#3l0``#f`E#$R?VPZdgZS(a6Uf;Y@N; zScJPY&r32@eaTF8{cJFm!=Bff$ir+nD-)N4T+9JmI{zbA_7CJ@4&Ro8ZM7b@>CVhE z@6MW;4eOAPyTo6@SF}D&y11M$2H%9Wwz}6?B=}HWOCLMKd}(a1(z{QwcI~8`@CSE^ z!{YfijxW66n$EA_&V9dEUWHrrbLGeB z#Q2Neb^en5i~Y%wj|bTQOZ#IE>e&tbE5iz!vStRoD*@d;iF)?FA6(;m;7f-B6RuBT zJ4^#hwZK>+dRGFNN`S)>xUU7SQdmcmj7va1`hMN;p07OxYsuJcwMV?{A4zanQLlQo zawPV9@b$#NTx$%sq>zU^>U$D%P&G&T*YQ`TJpzD~>PezgIXbs>`U}q>F|9nItpAf5J<^ps*ME0oudd?HOLrq0f26 zP5^IF&%RIMiE8@SG3{-y`4h-U{ST%bTZ+RuNSF@s3gh7%k&w1@c;PDM*jRUr)AV>0 zhioEnr}hWX{=UN33+%lyh_gF8u@74P=Gs?|{c|L{1VRv zhdl`i4{vEsq1LTvf1I%Qe~^ip@KrY0@-wjD^DO!^+Mh!6c+=tJ9QeP0Z*9*!&93m* zM$RJE{$D#@+fIK=_!2juA30v|sT=16=Z2_`sp~4v&^2M>vtxuWKlcL;b58O1bsgeS z9eX;*uZ$15ycEB{h2ee9qLXcJNWOsg_F-2Bf^<;tT3*)l?TsD*zYIc zQuqv5^?R;$p0~~u5x$;Ziv6CmMB6j>zFu?f&2+on0>{*#%xa-C)e`qmZtCl$$nGlH z3HH(`zXUK-i}moeXsfl_H;21g1fTmP{;vhLZpE+3I_L!Ukxl_qi8{}y4LH;I6ZVf} z=3e*gSzrsWLud?AHi~!*vbud@!O!&{Bl)O#_i|4U$YxG1`Z>B|7WvM0AKe{ax|m~0 z+y&nBpXQ;;-mbaM8Q3wjb|aPlYlA_p3zF?rcCQR@m4)p;3tcmdc9BKdWWiP9s~k8v z15Q?&ImA()Z|%sLhdrA%woU6+!C&m}%bAGY#)XTBGh&~6&4g2uDx9kJlM}K_VukA+YPN7+f9^L4fF|}e@WGOzVnP zfHSv)4b%8G>pU3S*7&xs8^X?7Wdn=W5y}2K2b@i24M1afD1-U88E{D^vQ~4I(`g&2 z;K}n52ta4+VFJ>Sd*Pj<5;!vQ^1(-3#~pRI(!E9zjS0`Ci+zlZ7Wl4 zjW(A?TJkeVL;ZyU@Ya_7Y`d{%@}_mq`}~~O;4jyWs0Z!;<=o?SCOH&1O1}3c!Pc9? zm*f)etv62DyKlXLJBxdhbK^Pho%?s*JnLs(za{^Tz(sGtOK7re}{Iy-WeA&MF=CWP>^EdX*x8K^I|NJffpK;&t|2OvWxeuJv0;ZJLST=?>puJea z-b@i+3Rh|``1(GruZ{WZ*@d&Lux(pwo}O%Z^$P5!dJXJ4{Oju1vp=Fc+|aO&-Pj<{ zZmgeeH#6383v2prW?b#2`us=#=z947I>wc*YgEs!Yh2H+r_J6#KlFOaR{!0^^-Z@o zvKzU-sc}QQk@@{M5$2{w1$GPX)Zomcn(`afC!M->OGCzG&;z@5F0et}a_q4IdGhR8Qd8FArr(xNT#bVWuVbCq^Gf*I!&;ixWuHLr3H>`b$uSny zop{KxR1IhTEa+T1SNVhY-n38Qm`^`?-#$Ah_nv+7(R*-CX-_+lFdW*jy+nR_DUGverEm*>)N83-JXyw0?wr4yotl zhOEbKkYlOfHv?QIG1nluAj=Z#r(4Z}OsiQh!*0aYV2<%ktdpowkYOneGcBVLdqd&Z zte0xH^1NnU!qma%I+4BR6YHi~LOw1p)e`el{64WBetxRe%CBv;>eaTC`l(itB*%G)!w%|`Ko%uyH4Y2&byUA$-j49~ zr+418uP>g5Z{V8m;2m*~^A5i5ao_qguD|)(K05c_=@?&MoO|1Txb%tr@XhD;{hx8) zd}-f*8@n&~?^FByIqf-nvQt~^Px5uHHQ_pNPB!;BoDZ9;XPh@vuX6{>@7SJkz&4!K+>W^s zZE@{5->9wScao3ezr0Rute(z5(wWTNbq;tt%g3+Zy}cE1R&%``Z8+DG|9UWP$oa_i znFCQz|8ZZ?gE7Tk?W{rH4pz{+9sjlC>^RO0=N#rboZIbjF>fM|v%9lXK6e2;x&9@-LXNrP`c3Q-Z}|Q>K?jpgB|RscM~W_v{CgMu z`}@Cq59fRrx%fKv^&Fi2(;-(xv=Yn@`+r~QLxA*_rSo>CY zSeuqDt<4=c-npYi3xBU2_wBfEk89nA|Jt{sJ_<}El&usLT` z;4HP@|4_m0+gSliC+twp;w*0y5@Yt^Q;HE+flz6}~$!-9I& zs1CNul3zUnUGFzrd zBL5*}TDC+W4F`t-}~yQlh2Z@CQr3`8vDxcUM{Bwbxk9-~YSSxavRb z)@$&u{!hF0xBuH}UiE*h=5PMZYF_hiR^yug?e3>ObuUp5I8gTe!ak|K{KF zjO&}P`VH85H9_XS6hwie{Z#}yT)p9opL?lh(Gb#-&^fJ{N57( zc%7wO_eV>-PX4t#yVg?3N9rGcZ>cx@(Q04+M@zrqI;%~%tQ)Se>>4*%?kzPer)Gk^ zxN)t${NiTYy5%M8@8AnLBDtb^aV`K;F|L9RCjBSi%k_TxioUlY^(y(JKALpt_uf70 zIQb4v`VJlvFMaoQxc=tz_kKEkWXFjZU-I8Sv+tGnPFH^X?y1V3-Z{CSv;B74AgMV5&DeEqw*ST9|32MH_{ir+^(W9IPsqLvD=G$oIY!|&0DY# zoIS(-jf-vgkP<5{>~8((OZMy5(Rv|Q`rx`DTe`Q0bC74& z=+G_Dt6HE_HEWb*&C#h^G~~VkI(LIQoH0XC_+R^qN*DtELsCCt7}XvgK#hvbq@w+$UK5v|5&rYm`^pax-qU z?9^J8Q~MUnO1Z_-Yu&_s4a?>_CnbS+&?i%BSYGX0`JZ}Dxyf=o-WWocgt_ zamGz{ThcAoDETI28R?|oY!#MUdYLJfo0iCT;IfkJ_BzbhWPi;2@4ef$ZCP(CR#46_tcD}PK3~FEs58kx z>e6MU^k`%wvZ~6SFa1mSQlCxw^RXk?;n^EnTm$c%K5^L2y?fd&eDW^b1TTI19@lT$ zg%3~t_1nuAw^YYhe7$-7v)`zHr*r)dFxTPmfxVnB%K6A}nD(94Uen$WQ9BTBz*>-r zv;%J!dLI2pzQepTjkk-#v~S{G&N^Cb!#D$J_~?6V0_UsT&zV{eJ~q`J;~bkOr_Qjc z(`Is3# z^A_5?`3r2peD3Ehvib8D*}{bjZQ=ZdJX>H3!SsR!Ji}kK2%mf`T)4;SsH zvt>(`*wUp-Z7KfZC5vs@vL&`;8TYtl@|P~L<@nDmUt%ksS#B%j6J{xH#j?eIy@WFj z;^!-tE++gEdj@~ml0~+R{48I*z?LpvWJ{JT#4RE%?ibCo#S7+zYo0G%tn2ys^T{j! zEu3qM*zZwp;ryBI7R;T&ch9u>bEi`VGi}c788&<7bemo=&1TJ>ZF3haw#T2Wu=^i+ z)Yh!u2tR-g+IiTYT>4DF)>$y6et&GI2zE^A)fz9-^S~pT2f@CCjCUVoPHCkb=iHaW z)aP;B>7#q??IU}BI|+JoAG@&cE7`|$ipZU-4JJFaBp;mTb$n|dx9SkAd_h1R}PZ(J|*l3sR4 zhaT3d9e(?s)*2`Oj&?n*Rr_Ang8y2!>tQY0v!_$r9@Z4symb$2)~>rXZNqh&?$%t- z@tbikr|0ezhX0zi>FIt`;%VB3I2A|RUe=Q9W~9}u9dQ$X^NxM3dHcSk*~eOTEVMQq z`&lde7F`Oh6?tymxybJ5Qe>@!ONLvol5*=?T5i1u zlv^QwpVE=mOMb}+>pNfs&v9J$Rv5zeE|wc+z4{Nau7#w*`JG+*46q`?O`WxXeIyQ| zKZo;&)%TLFta|b>NBQD0@s*t9BlqGB$x1o#$SJr*7?92+nRXQUc8K$5_cNBf=k;xz zeYJ)$zr{QM9#hrtpIyG_(zea(Z0GiE*s5Ol^J{fJ(J}Jp@(~?hGT3D!={vTZw<1jO zEQ~>fZwNZ1+DCZqb_%}pYWp>!h+c-~a(?(mjb}eU_zF;q`=A5=wt2npvd3z3j z)vD+4anC)AJmu^p{FUf$E1p~FVV1904zDb8ei831hIe8Ek3DV=KMEf|BKMd*^zdUg`Qb-w@_uF0g@%6-e z@3)DZ^L;nZC*Jn};U1`Z{{h8GT8}>Qgw38e-!^aAj4V6g*zk2@k&Fp=QrnN}Cc=@p z!1XVlyPe$Y4J=0Zk{&KucI+VB1@}~9Z_@a{j+Zyvmi5%vvN=1d7`9; zm}B}9#qw*C-`O>{~#Ndt}hP!DG@{bYzxX$v$ z$v<(3XMWE&dAr%i9J+9Q)cw6K!;ixG#}4nN9QXS7>)xI2xju4m5C7}E=(&8J9p(S( z{t?~tUx)`;aBw$HdadG+LkGbrz9XF5a}<5V!{8s|x$c9{Ip~~6EO!`pgy)A3@LttD z&xymG($n`+E~lh3ORh0D+SgrBKYxQM;RyLCxfAv%*EpXr2d0EA)gw;4pnY(34vg@1 zRI(BMX+QRWU9WAkS6|v-8(vst3+GP%;qNh3{eJo4d6! zl~&}=P)?^+R-DDxNw_{q*f5wOHPxAeJ!t^UZoL7d?{>s9mZ8-j})Q!$!Qap}J)tRuMxZ}F!+VLm6 zd79E~g)2Re>R<0DUjJYDi_+y@X~yyYE%w7ZC!)3?y(Y91wT*D?&x8|?Pwgu7*R%%P z^(cKe{Ux8LM>)y16?6|_DJsXR_Dgwt{ZI##z3NCdvtAfxq5*0K8j2D zQn|W)g0zG!&5@Pfr*)aiv+Iq@Klpb(i~1zuTkrSkUe|n=_Yd?A_kOMSs&Sh4aU@46 zJK;w>7RnXuP}aJRv8eKt3$_z+9(Bw+evSms{aW>=_RhPi>k}#~#}Sy}{y2SafA0SW zY&e!B5BP4^KOJWwd}zx$k5HJ1;#B`#m{HtS_zsxy=h&znNBpmM^bH}Ox{lgO^c^lI zJTAo-;ylTB1x)E1#rc%I%E-$}*I}GjZMUl3d%1?PRXMBduV5+SvB;hp+aerugp;lx z_$}B8^j#;hQyoP=k=zzGcCj{G`{}-foo&r?OKst-pU2noh4TWw(AP9C&G{>mkIos) zL-e`zd`rBygzNfXMfzC4Rlt1Q&-MI*!5|xhA9P2s6}=a1enDmiY+d0r*l;i7XD5Y=2w#o`@sH$P^gPI;z-8jKQ{pLc zmcoIJE8HlokcP%LgqbM4Dn24zVapx=i8D_L|LzNiA%8kMJ+zV7=bQY$z*`{>;VQVe z48$w0dwbgqZPn*sMeWx060es~*6}$on!_cWy`?rUeEEGe2Zy>64xKZ^0bDzes2z#F z&}$FVcND&Mv$uutC7o*Zv&(G$tf#8e)jwQggSoVM-3xHuCbv;k?%NUZSI`;M-h8eN z-=p(60v1R=!j^NY=TB{hZy=2D6}KJ7m9Qq83;($e8F6I$@ZVl{`#8grIkda?*iPQt zy>~Br5bfc=J@|y#yBoKMeXe)2R+DQFLtH%5`+N5AAJ>Y1Kll5Ie_y5Ceot#3Y3cqz zWhHsp@A=uUeDEyfWuH~Ij-^L4jkm1&4ZP!#|dWzSF(r40S~jEJ&68}6)+@S%Q-E2?mCR{7PWhqJ-Vj+ou}C^ zU%I&Z7?s$sb}_F^`_*jOv>JSIhWo6k|A49L50);Pb7_Pl!V>2p;yggQ z2gr}wgz}{{_Tvk)2Y6rYR+tKMj=JDFZuffTj`r@m$6i`0t6wY^wg7_Oxw&ag(>_ zBh>rWts86xV-1yH^a$-ySdg858sRo!@%p%u`;0zcyj} zTFqXGOKjfEr>oP|KU^nMBFqOpEXKa_ z7xF1t7;G>4?+WjQYuXsRB)o<>+`30jI)??UN#8nshHJ1VUFDFzm3n*)jvhB=jIG|Z z0Xyn!yYudQd=1>BdnaK>UBKD(J8k0KcVa`G={Dm>9-6`!(*m%y%h&sk8#|Kml{x5} zui1lBuvgwY(H_MP`pCl%*w}Gn7)Rm^SZvL+rcbknAAZmtd2ljz(fjPqapP>+^5uaW z!G*?$?!4=6+rE7}d?q=z#~yg#KD%rD1om-$#->ku%Epfy#n{CH+qiDE-8F73_T_EV zS2)vJ=T}$m-vOp(+hpvlufDp)?jheRR<30HXugdZGup>*w}7=N4?bWIlh=pI$GsEp zvT@@_gH8CFGqHm_ls!J;uBfcF)-mYt!d=k6!kDA3!5U{=1$m?QVwohLdZArQUp+=1 zkBGCKzg~BIX}{(z@R#-yp7#s-*OCQuE^QRPkdM2mxBbXRjdLFXv&Y0=ZkLh{7Vsti z3ja|5Rr!+LLONpLsUQpWjPQCEeRBveED3YMS9MvaK9TOjv%q2DUifmE0yQJs{SLacpot0p!k_^6m0wA zCE+Sy$@|a36#W9nlz2)w;{7ld&NaGTjIA@I<$Xx?4GF8hvfBFrbRw;NzjMM^d*S(2 z$i(T+A=@^sbqvg!Hy52}2mB>`&El-h*WjiHT{i7x&hTrmzHAfj4E(hlTh2q^VJ2Lr z`Dxn6bIj;bjK|O89Q*Bz<4m$i6DNX~`w4fyJ^tv!wr1^Wmxsc|VmRjRJIC9L=ob62 z8)`3v$;9{IgO6C#Deu^`E4SI?`zOMwb6MB33jP~oYu2q}?((a)<;5-J>j~xoZiNG; z6YhTc{Lho`@jiCG7)~2MVVs}!vi5~%Z0zWfcHjN?*pvq*+7$Bg@WYR?cZB+2^f#-p zC47Jv$~15p_d16U`6wQX`;7rxfxEo_Po2pR{kXs%Zf7Izz+a5df9Lq3|0vli87nRnC+e&%xBIBx$#c99oy#+@A}(@l2xG#WV<*Tvf9}up zT)0%eg{5#G>+^2Yarqa^LE#E{2&R2Z$^TQ@;0w93AC7np{bb@@6Ku-;k`;H`1mxBf zFfd{Kc&U(-Hjy|Unli;6 zgsaAl6@PJt^`7lE8Sc5~9{xi%DcqCjX~Ng5?3ef8npMx*IPmod`A|AfJ^7?fn=#Y%mt)vhRMwIQ@!EgqGRi*aV(3`N54WwV zpXfLXeCF3KTf}3kpP=`sepUXmF>4&d$A%(&?WS$$yq_3f^Je}6f6br!{RZ0BE3`q` z&h{feq<PS?Vn9RF2uQ-mqslU45t zGyWde#OZ5$iBr!d_hVa6z?keuvPGf`(=V5kj9UOF%$!l-I+FAxzh;bj13H;>v?b`q zYuBzr7u#p6*>i0sbvPTIn2oP_Et@v3qd&LDo?E`u=7Pf+#5H5ulQtfVE?Be>o5c=W z!Caa-JfA&ds?C{IVRMnUFEM^B9+YmSbZ2`WrX#1(#nFdWqLYPZPuWc63;p*+WTMtv z%tIfXiM}7)lQtKfeb4Tl?D@RHW<2$T&3O7Ln~wk3BM;ltQ=hP@Pdv`|?xydx$(~@W z{3-ewPe1t>_zGdw_d1Gv6wmwkwaZ7iD6&n*;}rY31{${%g(@EuFp_U zl0ROr)Pv)T{*>lx$^NCi0(YXDyyE3cNPoG>oCL8=Q+Sf6S^C34i7B8-qyzu^+u4x+@*HJ%3_2A*T_iOHt z&^D#Ni2r4a&{_0zW>05s$McRA;Z%K2^`DN>){bDu-luTjQaY6Sc4~{7lPMdwIA1nf z<-x}WD34&Hj>eeC?*Z^~hwXE;Xv%0}R0 zPsHtZeeBChr}E%IFEjB^Y+DHYCHW_tM5J@Q5&DzjES>jrYQYu{*0gJuLa<1J!^hnd1)i#;x9*YbSOXUNJlAu>3D8S z1_yqwauxRo6XZqsh%hEBXx{;0B#dRiZ~Pyx^-$kXT;;M|?%#qo!Kg1Xljk>d*-?Z$2z zY^~V398y(oo!fj;E&;VV!))E_aZ! zJwkZd({^L8s3h&!mbPanb0o-*^5r%R>Ogi#Z}0e?Z_4Hb`odxKmp#~<&(OyXHpn0& z<2Blnmu~w)e~108Ms^2dCM)eqc>WsZf)Gpn2Py0E)@qi_e{Sn=a=<(GVfu}<=;Ykwx}A?x{$N^rZEKEWQ^%nrsCb})AEI%5qQ zPmo^a`Er~Q7w;%-`8p?EXU^(<;qwjpk7vM=%Q)AgxQ=|+^TkoZllV&dzjIgUI|^sg z-6V%(f0E6}<&pAB8N2NsPF3G{AG+X9_N{xBzM$~6>X{`rcg8Qs$9aLjwt=r5%rV?c z9I|Q4F0Qs3=Ceo#(-|V#CrbM=QLp$xwncisFd(jS+{h30>HHO4hy9=eSBalux#%*G z_XB5X95LoE;Y{3xPhG~C3w);Zg}Z>?_}cgM_q+toi@DG9M5pWjbGkdf868X zTIDL-MBf|h31OZ@Xp1U$f9`k)IM6&V*Ug0=;+O8_wjk#s*(?IKGj~Nc_Ze=~`|Nbw9!w*P;K;|KKdP5rwe2SGe%LFs1K{^niT@x{B*8_9HH%oP?>k zZgm~%PxU4JE2?Ap;z8s_@Z)P?DLnJ}2F@+g1NDDgXVv56S+zKY8OM^!P2rV>=OMfk z+JfSV{wFQP>saF5c)o=G4{}xSM`4|x!@Zt4R@MHZ`VVb~ZxojFtqSk$4t%IC-HFSD z7kvG%cO63kOIPlt7xBO3pZ+JTY^mO-0yl9VJ+}44_DCQ1h~pDS2}|w*?gAd;c&?(rk<9mVWw=(kNM5RZkE`xfPSV}=-T00v_f>{^F1<(Lqke+w-Cg`F=tzz$uVd9+ zxNK6`=sx5{@d;mnE3e2}eFOgq z8=g+M*E`}A$B4e4|3mu^*YW=E`rjRO9%IdIGG11^A7Mcl^XoV~Sn@rfqqv317$-iK z7I9GE!oWu{cd9S$cp;4#cU65c<%2qLeV+frcc}aV)_l({+Dt4T)xVYgwFldR)@exp z+8D{lUmAa0&UoyLo7evI8g^vaA`ha=9iwmNZJD;?>y_xwzHyebLD)0;>{%T96P!GK z#!j7KzdN3vIeV7p?6LC(?oHPI^1p{8?3u`&euF*ni0AZ~GjS+-nf|A2yj=#JLi(-$r}x~}D|=zs6V2yDdU)bi z98r2cXVR}j8&@3*f8OU+*%ME&BZu@tUZb>yk0`I6cZHAg6z9$B-s1@IoJ8+Yy(+wa zi+{7eDN3LBL%l1!`0C1Y=brPw;Zc^CTHmdN#Nr*@KyzHjZ<2?*@=JO1^Ttgm| zXYJ`6+Ni!cYES9|)0fe_6zSyqcCi-{cDz@%Zn4elG`=nQ`1A7%S3Ns_;ppwxv%X9U4MVse)#Td_Qk+`cL{gV ze)#qh`S{wtlaKrM&vIYex8LC0zsNOva$Ls0EdNW~SL_vZ-Y$Rr748e%mv;HmS9S?M zxX{ISP`}iaKq=JqdPc=(d}b6N8`-);OWmoBoEtgC%?8E(Z=Tcx=?%zaq1Y6Whkt;Okn-Sf|~ckXkx z{sr9X=WN637fkb-H1}jP^J`w*u-0DM#M=BV>ljDGalLiRM(jQtc($H()f;X5*3Gyr zK0dtl#f|pLi<>zc^F?2~r9DJB9bDVrLyNOP?;XZ|3zm4nQ0JEUvuAqN?sJtSKS_Xjke0o#_IA4hhb zIJC!3furNtjgMpJJ-kP29bdMcTQ}JD&1>z&)z8@am5YDa^4zj_Ha)xO;M(PLrvEEE z{j=vix^%GOe%--VUmHBA#D)z4TcZZssPf>(j09)pLv8ekA>eAb>3+<}p^U$l+Ze)( z_Wy^0L&A?5MmYQtL%Am$@01Vc-OE8$tXd$g|!V$#<3WT)x7T^MCm;+)(mDd?Wa8jKXnUULL)x zaNLhl9LgK%mwTBEB2PRg+!*qu_(l=$NR?5P$B{~#IEN2aIpMfhISv_AM)*PGgK~4n z`yN-w$4Jr|&GRuTOVS)RRB4m0bArO?TLyc5jpEwti1+oL@~(W1)wgU&ggak&h# zp#zI-K>t40uXh*rdue5@S~RNKi|LRX@46uu$b=)I2$&! zjJ+cUlJ9{w)UOBFuwiAC_dpvqxXiIQYzX(%!O&q~h4L9Pq||X!9@me`kN<{)C)J(a z9l|?<2bbEA!2>+(@N&f=d=2q*hLWbz9!6NjJDl*tNMjh+!kgk#T*9Zvt^AO$;lct= z;fLxOZAJO>=U`)#1$j>&)bypC&xDo9jtOwIgtmhhf@wi zsQ3#?+_{Bh5<+KT6av<4#gg;!xI z#LM?lrfLtdPB19?HhsI^bDZ)mgL!{g^i8UVVM7MdK9oj&I@|M0(*H2Sn|fJo8*(74J~uQ+bE{k*=q& zw8aYn|H8i7PC4nyDgSz3zF#XpDtpy~$_;-oWi)6&KXB073OQG?d#BdyGt<86a-SVFq*U_0G2p zEahHd$dAIv4I#f}_~JFyoy$zPM&GYCqWac1gtp4Pr>(Xb@;)faQwjB1T0(i_l;(hv zzF?7Z6xI}nmr+PtZAuu@H+nlEE@4`2dN97;ao!dV#jlRX&;~*qSNRs%Pt1CoTT>Ytnbj@So>T&xH-b7xym&yKsT{MD?OPdU^^Q!YfX-34e$G^sR%{ zcD(+nU;Q7wSH^SIdx(R2P@eS6>w|066?G_CG;mOn^)KpcrQ}CEu6Cm~;cYX@gMTZ} z2YdRw&+`)MRNvukfbeCdv~S{7{{5TvjCQFw%SVK^GlaCt(JKS4N{K@pSOf-_S->=9D4dsJ7(a=JnSXy{oqs_337Py0&MJy_VLBa~vAiOaImQYQf&P zortG*_jc9~e2E)Nivx$1m8fhBozL7?nHN*mDsTL<_?qX%C4Fqv*wJ?981zi|yQqk7 zP<<*6)xFABam6_GZxf~@e~}Ty8OmPYizD0s;fS&><3GQS!U$Ws7oPOL!i#r{soQ~r z!AGe$0zE?S(>~+(2hfL+{Fn25=^KO>9RpUHu>Oq;SHb=YhBtpMO8Tus1;Q@J*$Zxwj{UQ5rl8+)3VqQI!XIC{r8c|2}GY4t}J@7Ak_b%%HQ^PkJ;vO??IvxoH|?!sQ(z5Nc7>~L8e;?%p!L*NFk zDZi4!Ue-^#SJ!sntA({-FXP7fX}=m@&2Ovc@$~B6!F9T#e!bwZK2}0qcv(>g`rcCa z3u&8_f$GQWiT@&B{m(-3RocI=^`or44ydyMUWakrsr>j3%0{^IHcOdF_w=%+dgP6gZM@13lnPdGczdg!AM)t<^0E$Pr27)- zC@P2O8$vq*bI8j6g~%_`Qoo{KpPs~DLOzh4v{Chi`}FSW<)`l}23zX0mJ(k2j@qyI zd=U8(rb^*Fub-$)6;A!UzP-9yZ}yk%)VhT=Z&biOeJQ^hU(I;GbKBrfT}&k=`^H|Z_Xfl5fTkh1UAy*uIiQpP1#LOkM|Qssm9 zmDhpXhdcy7d`I|C?Kl1|`Qls86L~K6d@Jt}9u>E~$+@LJ_CwmFzEk=3|CDBUzchMY zs_*dsLL32u!U69JQ~saYHhczV2ShT=@lU#vpM`yT(U#E9&_jf;V!nU4`WwRPfD&}_ zF5z31Pri8=Wz!E{Q+>qWKA18P&QwoTN)g3OBHD$vy4TUcStNyV4u7zv|skhr$uhh%bBt-@?5xsy6Mu(o=Xn^Ed+ToxcdH@2zSpq}9JKdIf3g zdxeWqZyNzmj!EvrH;3=@ZzNvjtEeAxj=Zbws?C+aJL>OT$**`$a<~Lc^|C_JQopw! zGEwOim-e+D-8)zkM7QUYS%q`a&{g4w*KHy`mOR&#mP~528^kU3n@c%uf9Ey zr{IhIusgPH3V+qJ26?|8Url(w{T$uV%_&$|uz@+Lpj#KgW2{_>$mAS`D+A3qmmcE~~y)FAQ zJy-pU_tERo8P$fz(0^223rGGg|Ht1UJt(f%0pLi_6^FQ^7^igOv}3&KJ9X{(CalXo z>N@7w;Pynrv2O=t_?m3T@> zQ}Gt6e8IuMA;r#1DyRO0FM_*e%aR>Lx~Jlo%pNzEJrJ=qNZ(U==sR53RGtVE%2{Q= zJ>iR7K6bI5o$tW5+RU0XtZNN&f4zKc(x9%jZQaazbZv|5?oOWJU-Iw#q;K>*1&rz2 z^*q!ETuPlPe{ylVZ`8O6XW?l)fNzP~q}QR^jyRwAgi~)Xs#nU!<3qlPpLOkeru!jX z;lR_-yGqL)@sozPNy@)x*N)cm4)oDGT3g4C9X*WnG3Oipm#lRseo|Rdulkm_EfpjC zONg)7|L2;rj`8n4X_twU;3}8b`kv@oT-J%b^1F8JZe6?gAf70kWU+W0Yy>=q`i;v> zZC81aPOkj8e4sp}V@dxF=}3-+_sY;Sd-Ui8Ub?|YW!9y0JMUK%_UmaK_; zRgQhoqx2oUdvv89gYKpLct6YWg={8$y;p|s{1xG=N9Q)k$0qEj%vqVazh1v@!Z|H% z;lUnVJ0KssJARdpf1m1+e7G#pHF+)pQvn|VCyqCLKmRMQWs+}{jl#zK5b&V#3ixn5 z@!g8cbq}spF2$6s!WKynkUpb(;`I8B@)Fv=%3FM(x(oSp*+{zT|0o}U=OmLtyNz`{ zeT#4&z9ULkWvh4b#n0lDaDC;u@}T^C{ZM~#e1T)g2Y6F`_NH&|co0_$*SsTN9INNT zRxxFy?{qx#?UH##*oB09FB`r=smCND+Epu%39Ioyf3?r3U_8`iV> zIlo>$-UffQg9m$e>*Rfp{^VERs(MwKhcXeCgfE`a&Vw9L{wO=u33+u4MA!OX{g;3Z z;V5v1zENf7oZR7ZN|_z_Q1{=!heb-;FURKMZ7)m}n-@bvU;ydPw|a1%Sl8?J>l$D60gb9k)8 z(+$t1`*@vFKH`404SjPVm@I;WB%k_|H}RSB=bRRmt-fEnmVYDH9xwM^FN)8f#pOU5 zkSDhxDKB0g*lq~p?H@nLebVRM(6(sTq$wL{-^g~~z7_c5EU5a~slQskzrA5T=T@NK zGtMpkk`7huWgqw_*29zs=_oD}g*Cpr%IVv<5BXHtUBRaKqk1@(31C$9DqN|*>U9jB zgejG)(sxIC&LdG;svBX}|MT>Oanb?@js?{v*WUN!TJ<4p3s+vo)W7hj{K%f6y76|a zxcpk*sJyF9RBJa1>+uAf1RRBURo}v|ILiBnkxZ7p6u7^7n&|S%zvnrWpLCIaDtF2u zd^>!`b&;2K2ou_Ph)3ld%M))eLG4ZNl&CER-tx9c9+Ve3uUoJ! zxuyE=L%%?06SQr0yWLihZw)gO5B=O2|RCB?;& zulvFZ?Ccf&aPSpzl2&ma(&L_Yi;Da5Za?=avkKZO???AVq(PqOm-9dWDNUZqNADrM zzJ%{zfv)Un7nc@QfPo6?zoOKy^_=)h`}zNV&HvP)rxDU3zl7Jd@?Tm)9Nc5quR#Cu zYwY^O7o46eP2HDxSjDe6@RgR*mrwqR{X59N=UZjmrvkfS1vslf&Q+B3?^n^UFW3AJ z4!xYK@}@j`Jc_HI=OdJh;=7X9kT3n;uL5~kK_7_kEA;YL*@I8NSNW-KJr42#zAM02 Z1#-Tkd*`+l?OHXR)~KM)3qOaS{~KWuYm5K@ literal 0 HcmV?d00001 diff --git a/nxt/__init__.py b/nxt/__init__.py new file mode 100644 index 0000000..dfe6b60 --- /dev/null +++ b/nxt/__init__.py @@ -0,0 +1,13 @@ +# nxt.__init__ module -- LEGO Mindstorms NXT python package +# Copyright (C) 2006 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. diff --git a/nxt/bluesock.py b/nxt/bluesock.py new file mode 100644 index 0000000..c57894d --- /dev/null +++ b/nxt/bluesock.py @@ -0,0 +1,78 @@ +# nxt.bluesock module -- Bluetooth socket communication with LEGO Minstorms NXT +# Copyright (C) 2006, 2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. + +try: + import bluetooth +except ImportError: + import lightblueglue as bluetooth +import os +from .brick import Brick + +class BlueSock(object): + + bsize = 118 # Bluetooth socket block size + PORT = 1 # Standard NXT rfcomm port + + def __init__(self, host): + self.host = host + self.sock = None + self.debug = False + + def __str__(self): + return 'Bluetooth (%s)' % self.host + + def connect(self): + if self.debug: + print 'Connecting via Bluetooth...' + sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) + sock.connect((self.host, BlueSock.PORT)) + self.sock = sock + if self.debug: + print 'Connected.' + return Brick(self) + + def close(self): + if self.debug: + print 'Closing Bluetooth connection...' + self.sock.close() + if self.debug: + print 'Bluetooth connection closed.' + + def send(self, data): + if self.debug: + print 'Send:', + print ':'.join('%02x' % ord(c) for c in data) + l0 = len(data) & 0xFF + l1 = (len(data) >> 8) & 0xFF + d = chr(l0) + chr(l1) + data + self.sock.send(d) + + def recv(self): + data = self.sock.recv(2) + l0 = ord(data[0]) + l1 = ord(data[1]) + plen = l0 + (l1 << 8) + data = self.sock.recv(plen) + if self.debug: + print 'Recv:', + print ':'.join('%02x' % ord(c) for c in data) + return data + +def _check_brick(arg, value): + return arg is None or arg == value + +def find_bricks(host=None, name=None): + for h, n in bluetooth.discover_devices(lookup_names=True): + if _check_brick(host, h) and _check_brick(name, n): + yield BlueSock(h) diff --git a/nxt/brick.py b/nxt/brick.py new file mode 100644 index 0000000..43ea458 --- /dev/null +++ b/nxt/brick.py @@ -0,0 +1,220 @@ +# nxt.brick module -- Classes to represent LEGO Mindstorms NXT bricks +# Copyright (C) 2006 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, rhn +# Copyright (C) 2010 rhn +# +# 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. + +from time import sleep +from .error import FileNotFound, ModuleNotFound +from .telegram import OPCODES, Telegram +from .sensor import get_sensor + +def _make_poller(opcode, poll_func, parse_func): + def poll(self, *args, **kwargs): + ogram = poll_func(opcode, *args, **kwargs) + self.sock.send(str(ogram)) + igram = Telegram(opcode=opcode, pkt=self.sock.recv()) + return parse_func(igram) + return poll + +class _Meta(type): + 'Metaclass which adds one method for each telegram opcode' + + def __init__(cls, name, bases, dict): + super(_Meta, cls).__init__(name, bases, dict) + for opcode in OPCODES: + poll_func, parse_func = OPCODES[opcode] + m = _make_poller(opcode, poll_func, parse_func) + setattr(cls, poll_func.__name__, m) + + +class FileFinder(object): + 'A generator to find files on a NXT brick.' + + def __init__(self, brick, pattern): + self.brick = brick + self.pattern = pattern + self.handle = None + + def _close(self): + if self.handle is not None: + self.brick.close(self.handle) + self.handle = None + + def __del__(self): + self._close() + + def __iter__(self): + results = [] + self.handle, fname, size = self.brick.find_first(self.pattern) + results.append((fname, size)) + while True: + try: + handle, fname, size = self.brick.find_next(self.handle) + results.append((fname, size)) + except FileNotFound: + self._close() + break + for result in results: + yield result + + +def File(brick, name, mode='r', size=None): + """Opens a file for reading/writing. Mode is 'r' or 'w'. If mode is 'w', + size must be provided. + """ + if mode == 'w': + if size is not None: + return FileWriter(brick, name, size) + else: + return ValueError('Size not specified') + elif mode == 'r': + return FileReader(brick, name) + else: + return ValueError('Mode ' + str(mode) + ' not supported') + + +class FileReader(object): + """Context manager to read a file on a NXT brick. Do use the iterator or + the read() method, but not both at the same time! + The iterator returns strings of an arbitrary (short) length. + """ + + def __init__(self, brick, fname): + self.brick = brick + self.handle, self.size = brick.open_read(fname) + + def read(self, bytes=None): + if bytes is not None: + remaining = bytes + else: + remaining = self.size + bsize = self.brick.sock.bsize + data = [] + while remaining > 0: + handle, bsize, buffer_ = self.brick.read(self.handle, + min(bsize, remaining)) + remaining -= len(buffer_) + data.append(buffer_) + return ''.join(data) + + def close(self): + if self.handle is not None: + self.brick.close(self.handle) + self.handle = None + + def __del__(self): + self.close() + + def __enter__(self): + return self + + def __exit__(self, etp, value, tb): + self.close() + + def __iter__(self): + rem = self.size + bsize = self.brick.sock.bsize + while rem > 0: + handle, bsize, data = self.brick.read(self.handle, + min(bsize, rem)) + yield data + rem -= len(data) + + +class FileWriter(object): + "Object to write to a file on a NXT brick" + + def __init__(self, brick, fname, size): + self.brick = brick + self.handle = self.brick.open_write(fname, size) + self._position = 0 + self.size = size + + def __del__(self): + self.close() + + def close(self): + if self.handle is not None: + self.brick.close(self.handle) + self.handle = None + + def tell(self): + return self._position + + def write(self, data): + remaining = len(data) + if remaining > self.size - self._position: + raise ValueError('Data will not fit into remaining space') + bsize = self.brick.sock.bsize + data_position = 0 + + while remaining > 0: + batch_size = min(bsize, remaining) + next_data_position = data_position + batch_size + buffer_ = data[data_position:next_data_position] + + handle, size = self.brick.write(self.handle, buffer_) + + self._position += batch_size + data_position = next_data_position + remaining -= batch_size + + +class ModuleFinder(object): + 'Iterator to lookup modules on a NXT brick' + + def __init__(self, brick, pattern): + self.brick = brick + self.pattern = pattern + self.handle = None + + def _close(self): + if self.handle: + self.brick.close(self.handle) + self.handle = None + + def __del__(self): + self._close() + + def __iter__(self): + self.handle, mname, mid, msize, miomap_size = \ + self.brick.request_first_module(self.pattern) + yield (mname, mid, msize, miomap_size) + while True: + try: + handle, mname, mid, msize, miomap_size = \ + self.brick.request_next_module( + self.handle) + yield (mname, mid, msize, miomap_size) + except ModuleNotFound: + self._close() + break + + +class Brick(object): #TODO: this begs to have explicit methods + 'Main object for NXT Control' + + __metaclass__ = _Meta + + def __init__(self, sock): + self.sock = sock + + def play_tone_and_wait(self, frequency, duration): + self.play_tone(frequency, duration) + sleep(duration / 1000.0) + + + find_files = FileFinder + find_modules = ModuleFinder + open_file = File + get_sensor = get_sensor diff --git a/nxt/direct.py b/nxt/direct.py new file mode 100644 index 0000000..50b7f2a --- /dev/null +++ b/nxt/direct.py @@ -0,0 +1,216 @@ +# nxt.direct module -- LEGO Mindstorms NXT direct telegrams +# Copyright (C) 2006, 2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. + +'Use for direct communication with the NXT ***EXTREMELY ADVANCED USERS ONLY***' + +def _create(opcode): + 'Create a simple direct telegram' + from telegram import Telegram + return Telegram(True, opcode) + +def start_program(opcode, fname): + tgram = _create(opcode) + tgram.add_filename(fname) + return tgram + +def _parse_simple(tgram): + tgram.check_status() + +def stop_program(opcode): + return _create(opcode) + +def play_sound_file(opcode, loop, fname): + tgram = _create(opcode) + tgram.add_u8(loop) + tgram.add_filename(fname) + return tgram + +def play_tone(opcode, frequency, duration): + 'Play a tone at frequency (Hz) for duration (ms)' + tgram = _create(opcode) + tgram.add_u16(frequency) + tgram.add_u16(duration) + return tgram + +def set_output_state(opcode, port, power, mode, regulation, turn_ratio, + run_state, tacho_limit): + tgram = _create(opcode) + tgram.add_u8(port) + tgram.add_s8(power) + tgram.add_u8(mode) + tgram.add_u8(regulation) + tgram.add_s8(turn_ratio) + tgram.add_u8(run_state) + tgram.add_u32(tacho_limit) + return tgram + +def set_input_mode(opcode, port, sensor_type, sensor_mode): + tgram = _create(opcode) + tgram.add_u8(port) + tgram.add_u8(sensor_type) + tgram.add_u8(sensor_mode) + return tgram + +def get_output_state(opcode, port): + tgram = _create(opcode) + tgram.add_u8(port) + return tgram + +def _parse_get_output_state(tgram): + tgram.check_status() + port = tgram.parse_u8() + power = tgram.parse_s8() + mode = tgram.parse_u8() + regulation = tgram.parse_u8() + turn_ratio = tgram.parse_s8() + run_state = tgram.parse_u8() + tacho_limit = tgram.parse_u32() + tacho_count = tgram.parse_s32() + block_tacho_count = tgram.parse_s32() + rotation_count = tgram.parse_s32() + return (port, power, mode, regulation, turn_ratio, run_state, + tacho_limit, tacho_count, block_tacho_count, rotation_count) + +def get_input_values(opcode, port): + tgram = _create(opcode) + tgram.add_u8(port) + return tgram + +def _parse_get_input_values(tgram): + tgram.check_status() + port = tgram.parse_u8() + valid = tgram.parse_u8() + calibrated = tgram.parse_u8() + sensor_type = tgram.parse_u8() + sensor_mode = tgram.parse_u8() + raw_ad_value = tgram.parse_u16() + normalized_ad_value = tgram.parse_u16() + scaled_value = tgram.parse_s16() + calibrated_value = tgram.parse_s16() + return (port, valid, calibrated, sensor_type, sensor_mode, raw_ad_value, + normalized_ad_value, scaled_value, calibrated_value) + +def reset_input_scaled_value(opcode, port): + tgram = _create(opcode) + tgram.add_u8(port) + return tgram + +def message_write(opcode, inbox, message): + tgram = _create(opcode) + tgram.add_u8(inbox) + tgram.add_u8(len(message) + 1) + tgram.add_string(len(message), message) + tgram.add_u8(0) + return tgram + +def reset_motor_position(opcode, port, relative): + tgram = _create(opcode) + tgram.add_u8(port) + tgram.add_u8(relative) + return tgram + +def get_battery_level(opcode): + return _create(opcode) + +def _parse_get_battery_level(tgram): + tgram.check_status() + millivolts = tgram.parse_u16() + return millivolts + +def stop_sound_playback(opcode): + return _create(opcode) + +def keep_alive(opcode): + return _create(opcode) + +def _parse_keep_alive(tgram): + tgram.check_status() + sleep_time = tgram.parse_u32() + return sleep_time + +def ls_get_status(opcode, port): + 'Get status of low-speed sensor (ultrasonic)' + tgram = _create(opcode) + tgram.add_u8(port) + return tgram + +def _parse_ls_get_status(tgram): + tgram.check_status() + n_bytes = tgram.parse_u8() + return n_bytes + +def ls_write(opcode, port, tx_data, rx_bytes): + 'Write a low-speed command to a sensor (ultrasonic)' + tgram = _create(opcode) + tgram.add_u8(port) + tgram.add_u8(len(tx_data)) + tgram.add_u8(rx_bytes) + tgram.add_string(len(tx_data), tx_data) + return tgram + +def ls_read(opcode, port): + 'Read a low-speed sensor value (ultrasonic)' + tgram = _create(opcode) + tgram.add_u8(port) + return tgram + +def _parse_ls_read(tgram): + tgram.check_status() + n_bytes = tgram.parse_u8() + contents = tgram.parse_string() + return contents[:n_bytes] + +def get_current_program_name(opcode): + return _create(opcode) + +def _parse_get_current_program_name(tgram): + tgram.check_status() + fname = tgram.parse_string() + return fname + +def message_read(opcode, remote_inbox, local_inbox, remove): + tgram = _create(opcode) + tgram.add_u8(remote_inbox) + tgram.add_u8(local_inbox) + tgram.add_u8(remove) + return tgram + +def _parse_message_read(tgram): + tgram.check_status() + local_inbox = tgram.parse_u8() + n_bytes = tgram.parse_u8() + message = tgram.parse_string() + return (local_inbox, message[:n_bytes]) + +OPCODES = { + 0x00: (start_program, _parse_simple), + 0x01: (stop_program, _parse_simple), + 0x02: (play_sound_file, _parse_simple), + 0x03: (play_tone, _parse_simple), + 0x04: (set_output_state, _parse_simple), + 0x05: (set_input_mode, _parse_simple), + 0x06: (get_output_state, _parse_get_output_state), + 0x07: (get_input_values, _parse_get_input_values), + 0x08: (reset_input_scaled_value, _parse_simple), + 0x09: (message_write, _parse_simple), + 0x0A: (reset_motor_position, _parse_simple), + 0x0B: (get_battery_level, _parse_get_battery_level), + 0x0C: (stop_sound_playback, _parse_simple), + 0x0D: (keep_alive, _parse_keep_alive), + 0x0E: (ls_get_status, _parse_ls_get_status), + 0x0F: (ls_write, _parse_simple), + 0x10: (ls_read, _parse_ls_read), + 0x11: (get_current_program_name, _parse_get_current_program_name), + 0x13: (message_read, _parse_message_read), +} diff --git a/nxt/error.py b/nxt/error.py new file mode 100644 index 0000000..3d14497 --- /dev/null +++ b/nxt/error.py @@ -0,0 +1,87 @@ +# nxt.error module -- LEGO Mindstorms NXT error handling +# Copyright (C) 2006, 2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. + +'Declarations for the errors' + +class ProtocolError(Exception): + pass + +class SysProtError(ProtocolError): + pass + +class FileExistsError(SysProtError): + pass + +class FileNotFound(SysProtError): + pass + +class ModuleNotFound(SysProtError): + pass + +class DirProtError(ProtocolError): + pass + +class I2CError(DirProtError): + pass + +class I2CPendingError(I2CError): + pass + +CODES = { + 0x00: None, + 0x20: I2CPendingError('Pending communication transaction in progress'), + 0x40: DirProtError('Specified mailbox queue is empty'), + 0x81: SysProtError('No more handles'), + 0x82: SysProtError('No space'), + 0x83: SysProtError('No more files'), + 0x84: SysProtError('End of file expected'), + 0x85: SysProtError('End of file'), + 0x86: SysProtError('Not a linear file'), + 0x87: FileNotFound('File not found'), + 0x88: SysProtError('Handle already closed'), + 0x89: SysProtError('No linear space'), + 0x8A: SysProtError('Undefined error'), + 0x8B: SysProtError('File is busy'), + 0x8C: SysProtError('No write buffers'), + 0x8D: SysProtError('Append not possible'), + 0x8E: SysProtError('File is full'), + 0x8F: FileExistsError('File exists'), + 0x90: ModuleNotFound('Module not found'), + 0x91: SysProtError('Out of bounds'), + 0x92: SysProtError('Illegal file name'), + 0x93: SysProtError('Illegal handle'), + 0xBD: DirProtError('Request failed (i.e. specified file not found)'), + 0xBE: DirProtError('Unknown command opcode'), + 0xBF: DirProtError('Insane packet'), + 0xC0: DirProtError('Data contains out-of-range values'), + 0xDD: DirProtError('Communication bus error'), + 0xDE: DirProtError('No free memory in communication buffer'), + 0xDF: DirProtError('Specified channel/connection is not valid'), + 0xE0: I2CError('Specified channel/connection not configured or busy'), + 0xEC: DirProtError('No active program'), + 0xED: DirProtError('Illegal size specified'), + 0xEE: DirProtError('Illegal mailbox queue ID specified'), + 0xEF: DirProtError('Attempted to access invalid field of a structure'), + 0xF0: DirProtError('Bad input or output specified'), + 0xFB: DirProtError('Insufficient memory available'), + 0xFF: DirProtError('Bad arguments'), +} + +def check_status(status): + if status: + ex = CODES.get(status) + if ex: + raise ex + else: + raise ProtocolError, status diff --git a/nxt/lightblueglue.py b/nxt/lightblueglue.py new file mode 100644 index 0000000..3309348 --- /dev/null +++ b/nxt/lightblueglue.py @@ -0,0 +1,53 @@ +# bluetooth.py module -- Glue code from NXT_Python to Lightblue, allowing +# NXT_Python to run on Mac without modification. Supports subset of +# PyBluez/bluetooth.py used by NXT_Python. +# +# Copyright (C) 2007 Simon D. Levy +# +# 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 2 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. + +import lightblue + +RFCOMM=11 + +def discover_devices(lookup_names=False): # parameter is ignored + pairs = [] + d = lightblue.finddevices() + for p in d: + h = p[0] + n = p[1] + pairs.append((h, n)) + return pairs + +class BluetoothSocket: + + def __init__(self, proto = RFCOMM, _sock=None): + if _sock is None: + _sock = lightblue.socket(proto) + self._sock = _sock + self._proto = proto + + def connect(self, addrport): + addr, port = addrport + self._sock.connect( (addr, port )) + + def send(self, data): + return self._sock.send( data ) + + def recv(self, numbytes): + return self._sock.recv( numbytes ) + + def close(self): + return self._sock.close() + +class BluetoothError(IOError): + pass + diff --git a/nxt/locator.py b/nxt/locator.py new file mode 100644 index 0000000..54a9018 --- /dev/null +++ b/nxt/locator.py @@ -0,0 +1,56 @@ +# nxt.locator module -- Locate LEGO Minstorms NXT bricks via USB or Bluetooth +# Copyright (C) 2006, 2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. + +class BrickNotFoundError(Exception): + pass + +class NoBackendError(Exception): + pass + +def find_bricks(host=None, name=None): + """Used by find_one_brick to look for bricks ***ADVANCED USERS ONLY***""" + + try: + import usbsock + usb_available = True + socks = usbsock.find_bricks(host, name) + for s in socks: + yield s + except ImportError: + usb_available = False + import sys + print >>sys.stderr, "USB unavailable, not searching there" + + try: + from bluetooth import BluetoothError + try: + import bluesock + socks = bluesock.find_bricks(host, name) + for s in socks: + yield s + except (BluetoothError, IOError): #for cases such as no adapter, bluetooth throws IOError, not BluetoothError + pass + except ImportError: + import sys + print >>sys.stderr, "Bluetooth unavailable, not searching there" + if not usb_available: + raise NoBackendError("Neither USB nor Bluetooth could be used!") + + +def find_one_brick(host=None, name=None): + """Use to find one brick. After it returns a usbsock object or a bluesock + object, it automatically connects to it.""" + for s in find_bricks(host, name): + return s.connect() + raise BrickNotFoundError diff --git a/nxt/motor.py b/nxt/motor.py new file mode 100644 index 0000000..f29a5a5 --- /dev/null +++ b/nxt/motor.py @@ -0,0 +1,431 @@ +# nxt.motor module -- Class to control LEGO Mindstorms NXT motors +# Copyright (C) 2006 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, rhn +# Copyright (C) 2010 rhn +# +# 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. + +"""Use for motor control""" + +import time +import warnings + +PORT_A = 0x00 +PORT_B = 0x01 +PORT_C = 0x02 +PORT_ALL = 0xFF + +MODE_IDLE = 0x00 +MODE_MOTOR_ON = 0x01 +MODE_BRAKE = 0x02 +MODE_REGULATED = 0x04 + +REGULATION_IDLE = 0x00 +REGULATION_MOTOR_SPEED = 0x01 +REGULATION_MOTOR_SYNC = 0x02 + +RUN_STATE_IDLE = 0x00 +RUN_STATE_RAMP_UP = 0x10 +RUN_STATE_RUNNING = 0x20 +RUN_STATE_RAMP_DOWN = 0x40 + +LIMIT_RUN_FOREVER = 0 + +class BlockedException(Exception): + pass + +class OutputState(object): + """An object holding the internal state of a motor, not including rotation + counters. + """ + def __init__(self, values): + (self.power, self.mode, self.regulation, + self.turn_ratio, self.run_state, self.tacho_limit) = values + + def to_list(self): + """Returns a list of properties that can be used with set_output_state. + """ + return [self.power, self.mode, self.regulation, + self.turn_ratio, self.run_state, self.tacho_limit] + + def __str__(self): + modes = [] + if self.mode & MODE_MOTOR_ON: + modes.append('on') + if self.mode & MODE_BRAKE: + modes.append('brake') + if self.mode & MODE_REGULATED: + modes.append('regulated') + if not modes: + modes.append('idle') + mode = '&'.join(modes) + regulation = 'regulation: ' + \ + ['idle', 'speed', 'sync'][self.regulation] + run_state = 'run state: ' + {0: 'idle', 0x10: 'ramp_up', + 0x20: 'running', 0x40: 'ramp_down'}[self.run_state] + return ', '.join([mode, regulation, str(self.turn_ratio), run_state] + [str(self.tacho_limit)]) + + +class TachoInfo: + """An object containing the information about the rotation of a motor""" + def __init__(self, values): + self.tacho_count, self.block_tacho_count, self.rotation_count = values + + def get_target(self, tacho_limit, direction): + """Returns a TachoInfo object which corresponds to tacho state after + moving for tacho_limit ticks. Direction can be 1 (add) or -1 (subtract) + """ + # TODO: adjust other fields + if abs(direction) != 1: + raise ValueError('Invalid direction') + new_tacho = self.tacho_count + direction * tacho_limit + return TachoInfo([new_tacho, None, None]) + + def is_greater(self, target, direction): + return direction * (self.tacho_count - target.tacho_count) > 0 + + def is_near(self, target, threshold): + difference = abs(target.tacho_count - self.tacho_count) + return difference < threshold + + def __str__(self): + return str((self.tacho_count, self.block_tacho_count, + self.rotation_count)) + + +class SynchronizedTacho(object): + def __init__(self, leader_tacho, follower_tacho): + self.leader_tacho = leader_tacho + self.follower_tacho = follower_tacho + + def get_target(self, tacho_limit, direction): + """This method will leave follower's target as None""" + leader_tacho = self.leader_tacho.get_target(tacho_limit, direction) + return SynchronizedTacho(leader_tacho, None) + + def is_greater(self, other, direction): + return self.leader_tacho.is_greater(other.leader_tacho, direction) + + def is_near(self, other, threshold): + return self.leader_tacho.is_near(other.leader_tacho, threshold) + + def __str__(self): + if self.follower_tacho is not None: + t2 = str(self.follower_tacho.tacho_count) + else: + t2 = 'None' + t1 = str(self.leader_tacho.tacho_count) + return 'tacho: ' + t1 + ' ' + t2 + + +def get_tacho_and_state(values): + """A convenience function. values is the list of values from + get_output_state. Returns both OutputState and TachoInfo. + """ + return OutputState(values[1:7]), TachoInfo(values[7:]) + + +class BaseMotor(object): + """Base class for motors""" + debug = 0 + def _debug_out(self, message): + if self.debug: + print message + + def turn(self, power, tacho_units, brake=True, timeout=1, emulate=True): + """Use this to turn a motor. The motor will not stop until it turns the + desired distance. Accuracy is much better over a USB connection than + with bluetooth... + power is a value between -127 and 128 (an absolute value greater than + 64 is recommended) + tacho_units is the number of degrees to turn the motor. values smaller + than 50 are not recommended and may have strange results. + brake is whether or not to hold the motor after the function exits + (either by reaching the distance or throwing an exception). + timeout is the number of seconds after which a BlockedException is + raised if the motor doesn't turn + emulate is a boolean value. If set to False, the motor is aware of the + tacho limit. If True, a run() function equivalent is used. + Warning: motors remember their positions and not using emulate + may lead to strange behavior, especially with synced motors + """ + + tacho_limit = tacho_units + + if tacho_limit < 0: + raise ValueError, "tacho_units must be greater than 0!" + + if self.method == 'bluetooth': + threshold = 70 + elif self.method == 'usb': + threshold = 5 + else: + threshold = 30 #compromise + + tacho = self.get_tacho() + state = self._get_new_state() + + # Update modifiers even if they aren't used, might have been changed + state.power = power + if not emulate: + state.tacho_limit = tacho_limit + + self._debug_out('Updating motor information...') + self._set_state(state) + + direction = 1 if power > 0 else -1 + self._debug_out('tachocount: ' + str(tacho)) + current_time = time.time() + tacho_target = tacho.get_target(tacho_limit, direction) + + blocked = False + try: + while True: + time.sleep(self._eta(tacho, tacho_target, power) / 2) + + if not blocked: # if still blocked, don't reset the counter + last_tacho = tacho + last_time = current_time + + tacho = self.get_tacho() + current_time = time.time() + blocked = self._is_blocked(tacho, last_tacho, direction) + if blocked: + self._debug_out(('not advancing', last_tacho, tacho)) + # the motor can be up to 80+ degrees in either direction from target when using bluetooth + if current_time - last_time > timeout: + if tacho.is_near(tacho_target, threshold): + break + else: + raise BlockedException("Blocked!") + else: + self._debug_out(('advancing', last_tacho, tacho)) + if tacho.is_near(tacho_target, threshold) or tacho.is_greater(tacho_target, direction): + break + finally: + if brake: + self.brake() + else: + self.idle() + + +class Motor(BaseMotor): + def __init__(self, brick, port): + self.brick = brick + self.port = port + self._read_state() + self.sync = 0 + self.turn_ratio = 0 + if str(type(self.brick.sock)) == "": + self.method = 'bluetooth' + elif str(type(self.brick.sock)) == "": + self.method = 'usb' + else: + print "Warning: Socket object does not of a known type." + print "The name is: " + str(type(self.brick.sock)) + print "Please report this problem to the developers!" + print "For now, turn() accuracy will not be optimal." + print "Continuing happily..." + self.method = None + + def _set_state(self, state): + self._debug_out('Setting brick output state...') + list_state = [self.port] + state.to_list() + self.brick.set_output_state(*list_state) + self._debug_out(state) + self._state = state + self._debug_out('State set.') + + def _read_state(self): + self._debug_out('Getting brick output state...') + values = self.brick.get_output_state(self.port) + self._debug_out('State got.') + self._state, tacho = get_tacho_and_state(values) + return self._state, tacho + + #def get_tacho_and_state here would allow tacho manipulation + + def _get_state(self): + """Returns a copy of the current motor state for manipulation.""" + return OutputState(self._state.to_list()) + + def _get_new_state(self): + state = self._get_state() + if self.sync: + state.mode = MODE_MOTOR_ON | MODE_REGULATED + state.regulation = REGULATION_MOTOR_SYNC + state.turn_ratio = self.turn_ratio + else: + state.mode = MODE_MOTOR_ON | MODE_REGULATED + state.regulation = REGULATION_MOTOR_SPEED + state.run_state = RUN_STATE_RUNNING + state.tacho_limit = LIMIT_RUN_FOREVER + return state + + def get_tacho(self): + return self._read_state()[1] + + def reset_position(self, relative): + """Resets the counters. Relative can be True or False""" + self.brick.reset_motor_position(self.port, relative) + + def run(self, power=100, regulated=False): + '''Tells the motor to run continuously. If regulated is True, then the + synchronization starts working. + ''' + state = self._get_new_state() + state.power = power + if not regulated: + state.mode = MODE_MOTOR_ON + self._set_state(state) + + def brake(self): + """Holds the motor in place""" + state = self._get_new_state() + state.power = 0 + state.mode = MODE_MOTOR_ON | MODE_BRAKE | MODE_REGULATED + self._set_state(state) + + def idle(self): + '''Tells the motor to stop whatever it's doing. It also desyncs it''' + state = self._get_new_state() + state.power = 0 + state.mode = MODE_IDLE + state.regulation = REGULATION_IDLE + state.run_state = RUN_STATE_IDLE + self._set_state(state) + + def weak_turn(self, power, tacho_units): + """Tries to turn a motor for the specified distance. This function + returns immediately, and it's not guaranteed that the motor turns that + distance. This is an interface to use tacho_limit without + REGULATION_MODE_SPEED + """ + tacho_limit = tacho_units + tacho = self.get_tacho() + state = self._get_new_state() + + # Update modifiers even if they aren't used, might have been changed + state.mode = MODE_MOTOR_ON + state.regulation = REGULATION_IDLE + state.power = power + state.tacho_limit = tacho_limit + + self._debug_out('Updating motor information...') + self._set_state(state) + + def _eta(self, current, target, power): + """Returns time in seconds. Do not trust it too much""" + tacho = abs(current.tacho_count - target.tacho_count) + return (float(tacho) / abs(power)) / 5 + + def _is_blocked(self, tacho, last_tacho, direction): + """Returns if any of the engines is blocked""" + return direction * (last_tacho.tacho_count - tacho.tacho_count) >= 0 + + +class SynchronizedMotors(BaseMotor): + """The object used to make two motors run in sync. Many objects may be + present at the same time but they can't be used at the same time. + Warning! Movement methods reset tacho counter. + THIS CODE IS EXPERIMENTAL!!! + """ + def __init__(self, leader, follower, turn_ratio): + """Turn ratio can be >= 0 only! If you want to have it reversed, + change motor order. + """ + if follower.brick != leader.brick: + raise ValueError('motors belong to different bricks') + self.leader = leader + self.follower = follower + self.method = self.leader.method #being from the same brick, they both have the same com method. + + if turn_ratio < 0: + raise ValueError('Turn ratio <0. Change motor order instead!') + + if self.leader.port == self.follower.port: + raise ValueError("The same motor passed twice") + elif self.leader.port > self.follower.port: + self.turn_ratio = turn_ratio + else: + self._debug_out('reversed') + self.turn_ratio = -turn_ratio + + def _get_new_state(self): + return self.leader._get_new_state() + + def _set_state(self, state): + self.leader._set_state(state) + self.follower._set_state(state) + + def get_tacho(self): + leadertacho = self.leader.get_tacho() + followertacho = self.follower.get_tacho() + return SynchronizedTacho(leadertacho, followertacho) + + def reset_position(self, relative): + """Resets the counters. Relative can be True or False""" + self.leader.reset_position(relative) + self.follower.reset_position(relative) + + def _enable(self): # This works as expected. I'm not sure why. + #self._disable() + self.reset_position(True) + self.leader.sync = True + self.follower.sync = True + self.leader.turn_ratio = self.turn_ratio + self.follower.turn_ratio = self.turn_ratio + + def _disable(self): # This works as expected. (tacho is reset ok) + self.leader.sync = False + self.follower.sync = False + #self.reset_position(True) + self.leader.idle() + self.follower.idle() + #self.reset_position(True) + + def run(self, power=100): + """Warning! After calling this method, make sure to call idle. The + motors are reported to behave wildly otherwise. + """ + self._enable() + self.leader.run(power, True) + self.follower.run(power, True) + + def brake(self): + self._disable() # reset the counters + self._enable() + self.leader.brake() # brake both motors at the same time + self.follower.brake() + self._disable() # now brake as usual + self.leader.brake() + self.follower.brake() + + def idle(self): + self._disable() + + def turn(self, power, tacho_units, brake=True, timeout=1): + self._enable() + # non-emulation is a nightmare, tacho is being counted differently + try: + if power < 0: + self.leader, self.follower = self.follower, self.leader + BaseMotor.turn(self, power, tacho_units, brake, timeout, emulate=True) + finally: + if power < 0: + self.leader, self.follower = self.follower, self.leader + + def _eta(self, tacho, target, power): + return self.leader._eta(tacho.leader_tacho, target.leader_tacho, power) + + def _is_blocked(self, tacho, last_tacho, direction): + # no need to check both, they're synced + return self.leader._is_blocked(tacho.leader_tacho, last_tacho.leader_tacho, direction) diff --git a/nxt/sensor/__init__.py b/nxt/sensor/__init__.py new file mode 100644 index 0000000..a3c1a0c --- /dev/null +++ b/nxt/sensor/__init__.py @@ -0,0 +1,36 @@ +# nxt.sensor module -- Classes to read LEGO Mindstorms NXT sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# Copyright (C) 2010 Marcus Wanner +# +# 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. + +from .common import * +from .analog import BaseAnalogSensor +from .digital import BaseDigitalSensor +from .generic import Touch, Light, Sound, Ultrasonic, Color20 +import mindsensors +MSSumoEyes = mindsensors.SumoEyes +MSCompass = mindsensors.Compass +MSIRLong = mindsensors.IRLong +import hitechnic +HTCompass = hitechnic.Compass +HTAccelerometer = hitechnic.Accelerometer +HTGyro = hitechnic.Gyro + + +def get_sensor(brick, port): + """Tries to detect the sensor type and return the correct sensor + object. + """ + base_sensor = BaseDigitalSensor(brick, port, False) + info = base_sensor.get_sensor_info() + return find_class(info)(brick, port, check_compatible=False) diff --git a/nxt/sensor/analog.py b/nxt/sensor/analog.py new file mode 100644 index 0000000..e8d9b7b --- /dev/null +++ b/nxt/sensor/analog.py @@ -0,0 +1,41 @@ +# nxt.sensor.analog module -- submodule for use with analog sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# +# 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. + +from common import * + + +class RawReading: # can be converted to the old version + """A pseudo-structure holding the raw sensor values as returned by the NXT + brick. + """ + def __init__(self, values): + (self.port, self.valid, self.calibrated, self.sensor_type, self.mode, + self.raw_ad_value, self.normalized_ad_value, self.scaled_value, + self.calibrated_value) = values + + def __repr__(self): + return str((self.port, self.valid, self.calibrated, self.sensor_type, self.mode, + self.raw_ad_value, self.normalized_ad_value, self.scaled_value, + self.calibrated_value)) + + +class BaseAnalogSensor(Sensor): + """Object for analog sensors.""" + def get_input_values(self): + """Returns the raw sensor values as returned by the NXT brick.""" + return RawReading(self.brick.get_input_values(self.port)) + + def reset_input_scaled_value(self): + self.brick.reset_input_scaled_value() + diff --git a/nxt/sensor/common.py b/nxt/sensor/common.py new file mode 100644 index 0000000..5afd6c8 --- /dev/null +++ b/nxt/sensor/common.py @@ -0,0 +1,67 @@ +# nxt.sensor.common module -- submodule with stuff useful in all sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# +# 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. + +PORT_1 = 0x00 +PORT_2 = 0x01 +PORT_3 = 0x02 +PORT_4 = 0x03 + +class Type(object): + 'Namespace for enumeration of the type of sensor' + # NOTE: just a namespace (enumeration) + NO_SENSOR = 0x00 + SWITCH = 0x01 # Touch sensor + TEMPERATURE = 0x02 + REFLECTION = 0x03 + ANGLE = 0x04 + LIGHT_ACTIVE = 0x05 # Light sensor (illuminated) + LIGHT_INACTIVE = 0x06 # Light sensor (ambient) + SOUND_DB = 0x07 # Sound sensor (unadjusted) + SOUND_DBA = 0x08 # Sound sensor (adjusted) + CUSTOM = 0x09 + LOW_SPEED = 0x0A + LOW_SPEED_9V = 0x0B # Low-speed I2C (Ultrasonic sensor) + HIGH_SPEED = 0x0C #Possibly other mode for I2C; may be used by future sensors. + COLORFULL = 0x0D #NXT 2.0 color sensor in full color mode (color sensor mode) + COLORRED = 0x0E #NXT 2.0 color sensor with red light on (light sensor mode) + COLORGREEN = 0x0F #NXT 2.0 color sensor with green light on (light sensor mode) + COLORBLUE = 0x10 #NXT 2.0 color sensor in with blue light on (light sensor mode) + COLORNONE = 0x11 #NXT 2.0 color sensor in with light off (light sensor mode) + COLOREXIT = 0x12 #NXT 2.0 color sensor internal state (not sure what this is for yet) + + +class Mode(object): + 'Namespace for enumeration of the mode of sensor' + # NOTE: just a namespace (enumeration) + RAW = 0x00 + BOOLEAN = 0x20 + TRANSITION_CNT = 0x40 + PERIOD_COUNTER = 0x60 + PCT_FULL_SCALE = 0x80 + CELSIUS = 0xA0 + FAHRENHEIT = 0xC0 + ANGLE_STEPS = 0xE0 + MASK = 0xE0 + MASK_SLOPE = 0x1F # Why isn't this slope thing documented? + + +class Sensor(object): + 'Main sensor object' + + def __init__(self, brick, port): + self.brick = brick + self.port = port + + def set_input_mode(self, type_, mode): + self.brick.set_input_mode(self.port, type_, mode) diff --git a/nxt/sensor/digital.py b/nxt/sensor/digital.py new file mode 100644 index 0000000..2ddb045 --- /dev/null +++ b/nxt/sensor/digital.py @@ -0,0 +1,223 @@ +# nxt.sensor module -- Classes to read LEGO Mindstorms NXT sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# Copyright (C) 2010 Marcus Wanner +# +# 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. + +from nxt.error import I2CError, I2CPendingError + +from common import * +from time import sleep, time +import struct + + +class SensorInfo: + def __init__(self, version, product_id, sensor_type): + self.version = version + self.product_id = product_id + self.sensor_type = sensor_type + + def clarifybinary(self, instr, label): + outstr = '' + outstr += (label + ': `' + instr + '`\n') + for char in instr: + outstr += (hex(ord(char))+', ') + outstr += ('\n') + return outstr + + def __str__(self): + outstr = '' + outstr += (self.clarifybinary(self.version, 'Version')) + outstr += (self.clarifybinary(self.product_id, 'Product ID')) + outstr += (self.clarifybinary(self.sensor_type, 'Type')) + return outstr + +class BaseDigitalSensor(Sensor): + """Object for digital sensors. I2C_ADDRESS is the dictionary storing name + to i2c address mappings. It should be updated in every subclass. When + subclassing this class, make sure to call add_compatible_sensor to add + compatible sensor data. + """ + I2C_DEV = 0x02 + I2C_ADDRESS = {'version': (0x00, '8s'), + 'product_id': (0x08, '8s'), + 'sensor_type': (0x10, '8s'), +# 'factory_zero': (0x11, 1), # is this really correct? + 'factory_scale_factor': (0x12, 'B'), + 'factory_scale_divisor': (0x13, 'B'), + } + + def __init__(self, brick, port, check_compatible=False): + """Creates a BaseDigitalSensor. If check_compatible is True, queries + the sensor for its name, and if a wrong sensor class was used, raises a + TypeError. + """ + super(BaseDigitalSensor, self).__init__(brick, port) + self.set_input_mode(Type.LOW_SPEED_9V, Mode.RAW) + self.lastpoll = None + sleep(0.1) # Give I2C time to initialize + if check_compatible: + sensor = self.get_sensor_info() + if not sensor in self.compatible_sensors: + raise TypeError('Wrong sensor class chosen for sensor ' + + str(sensor) + '. In rare cases, writing the wrong' + 'vales to the I2C bus can damage the sensor. If you' + 'are using the correct sensor object for the sensor,' + 'this message is likely in error and you should go' + 'ahead and call the function with "check_compatible=' + 'False" and file a bug report, including the output' + 'of printing get_sensor_info()') + + def _ls_read(self): + for n in range(3): + try: + return self.brick.ls_read(self.port) + except I2CError: + pass + raise I2CError, 'ls_read timeout' + + + def _i2c_command(self, address, value, format): + """Writes an i2c value to the given address. value must be a string. value is + a tuple of values corresponding to the given format. + """ + value = struct.pack(format, *value) + msg = chr(self.I2C_DEV) + chr(address) + value + self.brick.ls_write(self.port, msg, 0) + + def _i2c_query(self, address, format): + """Reads an i2c value from given address, and returns a value unpacked + according to the given format. Format is the same as in the struct + module. + """ + n_bytes = struct.calcsize(format) + msg = chr(self.I2C_DEV) + chr(address) + if not self.lastpoll: self.lastpoll = time() + if self.lastpoll+0.02 > time(): + diff = time() - self.lastpoll + sleep(0.02 - diff) + self.brick.ls_write(self.port, msg, n_bytes) + #self._ls_get_status(n_bytes) + #data = self.brick.ls_read(self.port) + data = self._ls_read() + self.lastpoll = time() + if len(data) < n_bytes: + raise I2CError, 'Read failure' + return struct.unpack(format, data[-n_bytes:]) # TODO: why could there be more than n_bytes? + + def read_value(self, name): + """Reads an value from the sensor. Name must be a string found in + self.I2C_ADDRESS dictionary. Entries in self.I2C_ADDRESS are in the + name: (address, format) form, with format as in the struct module. + Be careful on unpacking single variables - struct module puts them in + tuples containing only one element. + """ + address, fmt = self.I2C_ADDRESS[name] + return self._i2c_query(address, fmt) + + def write_value(self, name, value): + """Writes value to the sensor. Name must be a string found in + self.I2C_ADDRESS dictionary. Entries in self.I2C_ADDRESS are in the + name: (address, format) form, with format as in the struct module. + value is a tuple of values corresponding to the format from + self.I2C_ADDRESS dictionary. + """ + address, fmt = self.I2C_ADDRESS[name] + self._i2c_command(address, value, fmt) + + def get_sensor_info(self): + version = self.read_value('version')[0].split('\0')[0] + product_id = self.read_value('product_id')[0].split('\0')[0] + sensor_type = self.read_value('sensor_type')[0].split('\0')[0] + return SensorInfo(version, product_id, sensor_type) + + @classmethod + def add_compatible_sensor(cls, version, product_id, sensor_type): + """Adds an entry in the compatibility table for the sensor. If version + is None, then it's the default class for this model. If sensor_type is + None, then this is the default class for this vendor. + """ + try: + cls.compatible_sensors + except AttributeError: + cls.compatible_sensors = [] + finally: + cls.compatible_sensors.append(SCompatibility(version, product_id, + sensor_type)) + add_mapping(cls, version, product_id, sensor_type) + + +class CommandState(object): + 'Namespace for enumeration of the command state of sensors' + # NOTE: just a namespace (enumeration) + OFF = 0x00 + SINGLE_SHOT = 0x01 + CONTINUOUS_MEASUREMENT = 0x02 + EVENT_CAPTURE = 0x03 # Check for ultrasonic interference + REQUEST_WARM_RESET = 0x04 + + +class SCompatibility(SensorInfo): + """An object that helps manage the sensor mappings""" + def __eq__(self, other): + if self.product_id is None: + return self.product_id == other.product_id + elif self.version is None: + return (self.product_id == other.product_id and + self.sensor_type == other.sensor_type) + else: + return (self.version == other.version and + self.product_id == other.product_id and + self.sensor_type == other.sensor_type) + + +sensor_mappings = {} + + +def add_mapping(cls, version, product_id, sensor_type): + "None means any other value" + if product_id not in sensor_mappings: + sensor_mappings[product_id] = {} + models = sensor_mappings[product_id] + + if sensor_type is None: + if sensor_type in models: + raise ValueError('Already registered!') + models[sensor_type] = cls + return + + if sensor_type not in models: + models[sensor_type] = {} + versions = models[sensor_type] + + if version in versions: + raise ValueError('Already registered!') + else: + versions[version] = cls + + +class SearchError(Exception): + pass + + +def find_class(info): + """Returns an appropriate class for the given SensorInfo""" + dic = sensor_mappings + for val, msg in zip((info.product_id, info.sensor_type, info.version), + ('Vendor', 'Model', 'Version')): + if val in dic: + dic = dic[val] + elif None in dic: + dic = dic[None] + else: + raise SearchError(msg + ' not found') + return dic diff --git a/nxt/sensor/generic.py b/nxt/sensor/generic.py new file mode 100644 index 0000000..b106ee1 --- /dev/null +++ b/nxt/sensor/generic.py @@ -0,0 +1,141 @@ +# nxt.sensor.generic module -- Classes to read LEGO Mindstorms NXT sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# Copyright (C) 2010 melducky, Marcus Wanner +# +# 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. + +from .common import * +from .digital import BaseDigitalSensor +from .analog import BaseAnalogSensor + + +class Touch(BaseAnalogSensor): + """The LEGO touch sensor""" + + def __init__(self, brick, port): + super(Touch, self).__init__(brick, port) + self.set_input_mode(Type.SWITCH, Mode.BOOLEAN) + + def is_pressed(self): + return bool(self.get_input_values().scaled_value) + + get_sample = is_pressed + + +class Light(BaseAnalogSensor): + """Object for light sensors. It automatically turns off light when it's not + used. + """ + # TODO: A program may be running in the background. Leave the turning off to the user? + def __init__(self, brick, port, illuminated=True): + super(Light, self).__init__(brick, port) + self.set_illuminated(illuminated) + + def set_illuminated(self, active): + if active: + type_ = Type.LIGHT_ACTIVE + else: + type_ = Type.LIGHT_INACTIVE + self.set_input_mode(type_, Mode.RAW) + + def get_lightness(self): + return self.get_input_values().scaled_value + + get_sample = get_lightness + + def __del__(self): + self.set_illuminated(False) + + +class Sound(BaseAnalogSensor): + 'Object for sound sensors' + + def __init__(self, brick, port, adjusted=True): + super(Sound, self).__init__(brick, port) + self.set_adjusted(adjusted) + + def set_adjusted(self, active): + if active: + type_ = Type.SOUND_DBA + else: + type_ = Type.SOUND_DB + self.set_input_mode(type_, Mode.RAW) + + def get_loudness(self): + return self.get_input_values().scaled_value + + get_sample = get_loudness + + +class Ultrasonic(BaseDigitalSensor): + """Object for ultrasonic sensors""" + + # I2C addresses for an Ultrasonic sensor + I2C_ADDRESS = BaseDigitalSensor.I2C_ADDRESS.copy() + I2C_ADDRESS.update({'measurement_units': (0x14, '7s'), + 'continuous_measurement_interval': (0x40, 'B'), + 'command_state': (0x41, 'B'), + 'measurement_byte_0': (0x42, 'B'), + 'measurements': (0x42, 'B' * 8), + 'actual_scale_factor': (0x51, 'B'), + 'actual_scale_divisor': (0x52, 'B'), + }) + + def __init__(self, brick, port, check_compatible=False): + super(Ultrasonic, self).__init__(brick, port, check_compatible) + self.set_input_mode(Type.LOW_SPEED_9V, Mode.RAW) + + def get_distance(self): + 'Function to get data from the ultrasonic sensor' + return self.read_value('measurement_byte_0')[0] + + get_sample = get_distance + + def get_measurement_units(self): + return self.read_value('measurement_units')[0].split('\0')[0] + + def get_all_measurements(self): + "Returns all the past readings in measurement_byte_0 through 7" + return self.read_value('measurements') + + def get_measurement_no(self, number): + "Returns measurement_byte_number" + if not 0 <= number < 8: + raise ValueError('Measurements are numbered 0 to 7, not ' + str(number)) + base_address, format = self.I2C_ADDRESS['measurement_byte_0'] + return self._i2c_query(base_address + number, format)[0] + +Ultrasonic.add_compatible_sensor('V1.0', 'LEGO', 'Sonar') + + +class Color20(BaseAnalogSensor): + def __init__(self, brick, port): + super(Color20, self).__init__(brick, port) + self.set_light_color(Type.COLORFULL) + + def set_light_color(self, color): + """color should be one of the COLOR* Type namespace values, e.g. Type.COLORBLUE""" + self.set_input_mode(color, Mode.RAW) + + def get_light_color(self): + """Returns one of the COLOR* Type namespace values, e.g. Type.COLORRED""" + return self.get_input_values().sensor_type + + def get_reflected_light(self, color): + self.set_light_color(color) + return self.get_input_values().scaled_value + + def get_color(self): + self.get_reflected_light(Type.COLORFULL) + return self.get_input_values().scaled_value + + get_sample = get_color diff --git a/nxt/sensor/hitechnic.py b/nxt/sensor/hitechnic.py new file mode 100644 index 0000000..c7406cf --- /dev/null +++ b/nxt/sensor/hitechnic.py @@ -0,0 +1,141 @@ +# nxt.sensor.hitechnic module -- Classes to read HiTechnic sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# Copyright (C) 2010 rhn, Marcus Wanner, melducky, Samuel Leeman-Munk +# +# 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. + +from .common import * +from .digital import BaseDigitalSensor +from .analog import BaseAnalogSensor + +class CompassMode: + MEASUREMENT = 0x00 + CALIBRATION = 0x43 + CALIBRATION_FAILED = 0x02 + + +class Compass(BaseDigitalSensor): + """Hitechnic compass sensor.""" + + I2C_ADDRESS = BaseDigitalSensor.I2C_ADDRESS.copy() + I2C_ADDRESS.update({'heading': (0x44, ' 180: + rheading -= 360 + elif rheading < -180: + rheading += 360 + return rheading + + #this deserves a little explanation: + #if max > min, it's straightforward, but + #if min > max, it switches the values of max and min + #and returns true if heading is NOT between the new max and min + def is_in_range(self,min,max): + """This function is untested but should work. + If it does work, please post a message to the mailing list + or email marcusw@cox.net. If it doesn't work, please file + an issue in the bug tracker. + """ + reversed = False + if min > max: + (max,min) = (min,max) + reversed = True + heading = self.get_sample() + in_range = (heading > min) and (heading < max) + #an xor handles the reversal + #a faster, more compact way of saying + #if !reversed return in_range + #if reversed return !in_range + return bool(reversed) ^ bool(in_range) + + def get_mode(self): + return self.read_value('mode')[0] + + def set_mode(self, mode): + if mode != CompassMode.MEASUREMENT and \ + mode != CompassMode.CALIBRATION: + raise ValueError('Invalid mode specified: ' + str(mode)) + self.write_value('mode', (mode, )) + +Compass.add_compatible_sensor('\xfdV1.23 ', 'HiTechnc', 'Compass ') +Compass.add_compatible_sensor('\xfdV2.1 ', 'HITECHNC', 'Compass ') + + +class Acceleration: + def __init__(self, x, y, z): + self.x, self.y, self.z =x, y, z + +class Accelerometer(BaseDigitalSensor): + 'Object for Accelerometer sensors. Thanks to Paulo Vieira.' + I2C_ADDRESS = BaseDigitalSensor.I2C_ADDRESS.copy() + I2C_ADDRESS.update({'x_axis_high': (0x42, 'b'), + 'y_axis_high': (0x43, 'b'), + 'z_axis_high': (0x44, 'b'), + 'xyz_short': (0x42, '3b'), + 'all_data': (0x42, '3b3B') + }) + + def __init__(self, brick, port, check_compatible=False): + super(Accelerometer, self).__init__(brick, port, check_compatible) + + def get_acceleration(self): + """"Returns the acceleration along x, y, z axes. Units are unknown to + me. + """ + xh, yh, zh, xl, yl, zl = self.read_value('all_data') + x = xh << 2 + xl + y = yh << 2 + yl + z = zh << 2 + yl + return Acceleration(x, y, z) + + get_sample = get_acceleration + +Accelerometer.add_compatible_sensor('\xfdV1.1 ', 'HITECHNC', 'Accel. ') + + +class Gyro(BaseAnalogSensor): + 'Object for gyro sensors' +#This class is for the hitechnic gryo sensor. When the gryo is not +#moving there will be a constant offset that will change with +#temperature and other ambient factors. The calibrate() function +#takes the currect value and uses it to offset subsequesnt ones. + + def __init__(self, brick, port): + super(Gyro, self).__init__(brick, port) + self.set_input_mode(Type.ANGLE, Mode.RAW) + self.offset = 0 + + def get_rotation_speed(self): + return self.get_input_values().scaled_value - self.offset + + def set_zero(self, value): + self.offset = value + + def calibrate(self): + self.set_zero(self.get_rotation_speed()) + + get_sample = get_rotation_speed diff --git a/nxt/sensor/mindsensors.py b/nxt/sensor/mindsensors.py new file mode 100644 index 0000000..1264ea0 --- /dev/null +++ b/nxt/sensor/mindsensors.py @@ -0,0 +1,147 @@ +# nxt.sensor.mindsensors module -- Classes implementing Mindsensors sensors +# Copyright (C) 2006,2007 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner, Paulo Vieira, rhn +# Copyright (C) 2010 Marcus Wanner +# +# 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. + + +from .common import * +from .digital import BaseDigitalSensor, SensorInfo +from .analog import BaseAnalogSensor + + +class SumoEyesReading: + """Contains the reading of SumoEyes sensor. left and right can be True or + False. If True, then there is something there, if False, then it's empty + there. + """ + def __init__(self, raw_reading): + self.raw = raw_reading + val = raw_reading.normalized_ad_value # FIXME: make it rely on raw_ad_value + right = 600 < val < 700 + both = 700 <= val < 900 + left = 300 < val < 400 + self.left = left or both + self.right = right or both + + def __str__(self): + return '(left: ' + str(self.left) + ', right: ' + str(self.right) + ')' + + +class SumoEyes(BaseAnalogSensor): + """The class to control Mindsensors Sumo sensor. Warning: long range not + working for my sensor. + """ + #range: 5-10cm + def __init__(self, brick, port, long_range=False): + super(SumoEyes, self).__init__(brick, port) + self.set_long_range(long_range) + + def set_long_range(self, val): + """Sets if the sensor should operate in long range mode (12 inches) or + the short range mode (6 in). val should be True or False. + """ + if val: + type_ = Type.LIGHT_INACTIVE + else: + type_ = Type.LIGHT_ACTIVE + self.set_input_mode(type_, Mode.RAW) + + def get_sample(self): + """Returns the processed meaningful values of the sensor""" + return SumoEyesReading(self.get_input_values()) + + + +class CompassCommand(object): + 'Namespace for enumeration compass sensor commands' + # NOTE: just a namespace (enumeration) + AUTO_TRIG_ON = (0x41, 0x02) + AUTO_TRIG_OFF = (0x53, 0x01) + MAP_HEADING_BYTE = 0x42 # map heading to 0-255 range + MAP_HEADING_INTEGER = 0x49 # map heading to 0-36000 range + SAMPLING_50_HZ = 0x45 # set sampling frequency to 50 Hz + SAMPLING_60_HZ = 0x55 # set sampling frequency to 60 Hz + SET_ADPA_MODE_ON = 0x4E # set ADPA mode on + SET_ADPA_MODE_OFF = 0x4F # set ADPA mode off + BEGIN_CALIBRATION = 0x43 # begin calibration + DONE_CALIBRATION = 0x44 # done with calibration + LOAD_USER_CALIBRATION = 0x4C # load user calibration value + + +class Compass(BaseDigitalSensor): + """Warning! Likely to be broken because of no access to the hardware. + If it doesn't work, contact me at nxpygoac.rhn@porcupinefactory.org + """ + # TODO: ADPA, calibration + I2C_ADDRESS = BaseDigitalSensor.I2C_ADDRESS.copy() + I2C_ADDRESS.update({'command': (0x41, 'B'), + 'heading': (0x42, ' 15: + print "Warning! Brick name %s will be truncated to %s!" % (bname, bname[0:15]) + bname = bname[0:15] + elif len(bname) < 15: + bname += '\x00' * (15-len(bname)) #fill the extra chars with nulls + tgram.add_string(len(bname), bname) + return tgram + +def _parse_set_brick_name(tgram): + tgram.check_status() + +def get_device_info(opcode): + return _create(opcode) + +def _parse_get_device_info(tgram): + tgram.check_status() + name = tgram.parse_string(15) + a0 = tgram.parse_u8() + a1 = tgram.parse_u8() + a2 = tgram.parse_u8() + a3 = tgram.parse_u8() + a4 = tgram.parse_u8() + a5 = tgram.parse_u8() + a6 = tgram.parse_u8() + # FIXME: what is a6 for? + address = '%02X:%02X:%02X:%02X:%02X:%02X' % (a0, a1, a2, a3, a4, a5) + signal_strength = tgram.parse_u32() + user_flash = tgram.parse_u32() + return (name, address, signal_strength, user_flash) + +def delete_user_flash(opcode): + return _create(opcode) + +def _parse_delete_user_flash(tgram): + tgram.check_status() + +def poll_command_length(opcode, buf_num): + tgram = _create(opcode) + tgram.add_u8(buf_num) + return tgram + +def _parse_poll_command_length(tgram): + buf_num = tgram.parse_u8() + tgram.check_status() + n_bytes = tgram.parse_u8() + return (buf_num, n_bytes) + +def poll_command(opcode, buf_num, n_bytes): + tgram = _create(opcode) + tgram.add_u8(buf_num) + tgram.add_u8(n_bytes) + return tgram + +def _parse_poll_command(tgram): + buf_num = tgram.parse_u8() + tgram.check_status() + n_bytes = tgram.parse_u8() + command = tgram.parse_string() + return (buf_num, n_bytes, command) + +def bluetooth_factory_reset(opcode): + # Note: this command is USB only (no Bluetooth) + return _create(opcode) + +def _parse_bluetooth_factory_reset(tgram): + tgram.check_status() + +OPCODES = { + 0x80: (open_read, _parse_open_read), + 0x81: (open_write, _parse_open_write), + 0x82: (read, _parse_read), + 0x83: (write, _parse_write), + 0x84: (close, _parse_close), + 0x85: (delete, _parse_delete), + 0x86: (find_first, _parse_find), + 0x87: (find_next, _parse_find), + 0x88: (get_firmware_version, _parse_get_firmware_version), + 0x89: (open_write_linear, _parse_open_write), + 0x8A: (open_read_linear, _parse_open_read_linear), + 0x8B: (open_write_data, _parse_open_write), + 0x8C: (open_append_data, _parse_open_append_data), + 0x90: (request_first_module, _parse_request_module), + 0x91: (request_next_module, _parse_request_module), + 0x92: (close_module_handle, _parse_close), + 0x94: (read_io_map, _parse_read_io_map), + 0x95: (write_io_map, _parse_write_io_map), + 0x97: (boot, _parse_boot), + 0x98: (set_brick_name, _parse_set_brick_name), + 0x9B: (get_device_info, _parse_get_device_info), + 0xA0: (delete_user_flash, _parse_delete_user_flash), + 0xA1: (poll_command_length, _parse_poll_command_length), + 0xA2: (poll_command, _parse_poll_command), + 0xA4: (bluetooth_factory_reset, _parse_bluetooth_factory_reset), +} diff --git a/nxt/telegram.py b/nxt/telegram.py new file mode 100644 index 0000000..1fc5b3e --- /dev/null +++ b/nxt/telegram.py @@ -0,0 +1,118 @@ +# nxt.telegram module -- LEGO Mindstorms NXT telegram formatting and parsing +# Copyright (C) 2006 Douglas P Lau +# Copyright (C) 2009 Marcus Wanner +# +# 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. + +'Used by nxt.system for sending telegrams to the NXT' + +from cStringIO import StringIO +from struct import pack, unpack +import nxt.error + +class InvalidReplyError(Exception): + pass + +class InvalidOpcodeError(Exception): + pass + +class Telegram(object): + + TYPE = 0 # type byte offset + CODE = 1 # code byte offset + DATA = 2 # data byte offset + + TYPE_NOT_DIRECT = 0x01 # system vs. direct type + TYPE_REPLY = 0x02 # reply type (from NXT brick) + TYPE_REPLY_NOT_REQUIRED = 0x80 # reply not required flag + + def __init__(self, direct=False, opcode=0, reply_req=True, pkt=None): + if pkt: + self.pkt = StringIO(pkt) + self.typ = self.parse_u8() + self.opcode = self.parse_u8() + if not self.is_reply(): + raise InvalidReplyError + if self.opcode != opcode: + raise InvalidOpcodeError, self.opcode + else: + self.pkt = StringIO() + typ = 0 + if not direct: + typ |= Telegram.TYPE_NOT_DIRECT + if not reply_req: + typ |= Telegram.TYPE_REPLY_NOT_REQUIRED + self.add_u8(typ) + self.add_u8(opcode) + + def __str__(self): + return self.pkt.getvalue() + + def is_reply(self): + return self.typ == Telegram.TYPE_REPLY + + def add_string(self, n_bytes, v): + self.pkt.write(pack('%ds' % n_bytes, v)) + + def add_filename(self, fname): + self.pkt.write(pack('20s', fname)) + + def add_s8(self, v): + self.pkt.write(pack('