moving things around and adding examples for mic hat code

mic_hat_examples/.gitignore

@@ -0,0 +1,139 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+

mic_hat_examples/LICENSE

@@ -0,0 +1,340 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  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.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+                     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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    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.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This 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.
+

mic_hat_examples/README.md

@@ -0,0 +1,29 @@
+MIC HAT for Raspberry Pi
+========================
+
+To build voice enabled projects with Google Assistant, Amazon Alexa Voice service and etc. 
+
+[![](https://github.com/SeeedDocument/MIC_HATv1.0_for_raspberrypi/blob/master/img/mic_hatv1.0.png?raw=true)](https://www.seeedstudio.com/ReSpeaker-2-Mics-Pi-HAT-p-2874.html)
+
+
+## Requirements
++ [seeed-voicecard](https://github.com/respeaker/seeed-voicecard), the kernel driver for on-board WM8960 codec
++ [spidev](https://pypi.python.org/pypi/spidev) for on-board SPI interface APA102 LEDs
++ [google-assistant-library](https://github.com/googlesamples/assistant-sdk-python/tree/master/google-assistant-sdk/googlesamples/assistant/library)
++ [avs](https://github.com/respeaker/avs), Alexa Voice Service client python library
++ [voice-engine](https://github.com/voice-engine/voice-engine)
+
+## Setup
+1. Go to [seeed-voicecard](https://github.com/respeaker/seeed-voicecard) and install it
+2. Use `raspi-config` to enable SPI.
+3. Install `spidev` (`pip install spidev`).
+4. Run `python pixels.py` to test the pixels.
+
+## Build a Google Home like device with Google Assistant SDK
+1. Setup [google-assistant-library](https://github.com/googlesamples/assistant-sdk-python/tree/master/google-assistant-sdk/googlesamples/assistant/library)
+2. Run `python google_assistant.py --device_model_id 'respeaker-xyz'`
+
+## Build an Echo like device with Alexa Voice Service
+1. `pip install avs voice-engine`
+2. Go to [snowboy](https://github.com/Kitt-AI/snowboy) and install its python binding.
+3. `python alexa.py`

mic_hat_examples/interfaces/apa102.py

@@ -0,0 +1,246 @@
+"""
+The code is based on https://github.com/tinue/APA102_Pi
+This is the main driver module for APA102 LEDs
+
+License: GPL V2
+"""
+
+import spidev
+from math import ceil
+
+RGB_MAP = { 'rgb': [3, 2, 1], 'rbg': [3, 1, 2], 'grb': [2, 3, 1],
+            'gbr': [2, 1, 3], 'brg': [1, 3, 2], 'bgr': [1, 2, 3] }
+
+class APA102:
+    """
+    Driver for APA102 LEDS (aka "DotStar").
+
+    (c) Martin Erzberger 2016-2017
+
+    My very first Python code, so I am sure there is a lot to be optimized ;)
+
+    Public methods are:
+     - set_pixel
+     - set_pixel_rgb
+     - show
+     - clear_strip
+     - cleanup
+
+    Helper methods for color manipulation are:
+     - combine_color
+     - wheel
+
+    The rest of the methods are used internally and should not be used by the
+    user of the library.
+
+    Very brief overview of APA102: An APA102 LED is addressed with SPI. The bits
+    are shifted in one by one, starting with the least significant bit.
+
+    An LED usually just forwards everything that is sent to its data-in to
+    data-out. While doing this, it remembers its own color and keeps glowing
+    with that color as long as there is power.
+
+    An LED can be switched to not forward the data, but instead use the data
+    to change it's own color. This is done by sending (at least) 32 bits of
+    zeroes to data-in. The LED then accepts the next correct 32 bit LED
+    frame (with color information) as its new color setting.
+
+    After having received the 32 bit color frame, the LED changes color,
+    and then resumes to just copying data-in to data-out.
+
+    The really clever bit is this: While receiving the 32 bit LED frame,
+    the LED sends zeroes on its data-out line. Because a color frame is
+    32 bits, the LED sends 32 bits of zeroes to the next LED.
+    As we have seen above, this means that the next LED is now ready
+    to accept a color frame and update its color.
+
+    So that's really the entire protocol:
+    - Start by sending 32 bits of zeroes. This prepares LED 1 to update
+      its color.
+    - Send color information one by one, starting with the color for LED 1,
+      then LED 2 etc.
+    - Finish off by cycling the clock line a few times to get all data
+      to the very last LED on the strip
+
+    The last step is necessary, because each LED delays forwarding the data
+    a bit. Imagine ten people in a row. When you yell the last color
+    information, i.e. the one for person ten, to the first person in
+    the line, then you are not finished yet. Person one has to turn around
+    and yell it to person 2, and so on. So it takes ten additional "dummy"
+    cycles until person ten knows the color. When you look closer,
+    you will see that not even person 9 knows its own color yet. This
+    information is still with person 2. Essentially the driver sends additional
+    zeroes to LED 1 as long as it takes for the last color frame to make it
+    down the line to the last LED.
+    """
+    # Constants
+    MAX_BRIGHTNESS = 0b11111 # Safeguard: Set to a value appropriate for your setup
+    LED_START = 0b11100000 # Three "1" bits, followed by 5 brightness bits
+
+    def __init__(self, num_led, global_brightness=MAX_BRIGHTNESS,
+                 order='rgb', bus=0, device=1, max_speed_hz=8000000):
+        self.num_led = num_led  # The number of LEDs in the Strip
+        order = order.lower()
+        self.rgb = RGB_MAP.get(order, RGB_MAP['rgb'])
+        # Limit the brightness to the maximum if it's set higher
+        if global_brightness > self.MAX_BRIGHTNESS:
+            self.global_brightness = self.MAX_BRIGHTNESS
+        else:
+            self.global_brightness = global_brightness
+
+        self.leds = [self.LED_START,0,0,0] * self.num_led # Pixel buffer
+        self.spi = spidev.SpiDev()  # Init the SPI device
+        self.spi.open(bus, device)  # Open SPI port 0, slave device (CS) 1
+        # Up the speed a bit, so that the LEDs are painted faster
+        if max_speed_hz:
+            self.spi.max_speed_hz = max_speed_hz
+
+    def clock_start_frame(self):
+        """Sends a start frame to the LED strip.
+
+        This method clocks out a start frame, telling the receiving LED
+        that it must update its own color now.
+        """
+        self.spi.xfer2([0] * 4)  # Start frame, 32 zero bits
+
+
+    def clock_end_frame(self):
+        """Sends an end frame to the LED strip.
+
+        As explained above, dummy data must be sent after the last real colour
+        information so that all of the data can reach its destination down the line.
+        The delay is not as bad as with the human example above.
+        It is only 1/2 bit per LED. This is because the SPI clock line
+        needs to be inverted.
+
+        Say a bit is ready on the SPI data line. The sender communicates
+        this by toggling the clock line. The bit is read by the LED
+        and immediately forwarded to the output data line. When the clock goes
+        down again on the input side, the LED will toggle the clock up
+        on the output to tell the next LED that the bit is ready.
+
+        After one LED the clock is inverted, and after two LEDs it is in sync
+        again, but one cycle behind. Therefore, for every two LEDs, one bit
+        of delay gets accumulated. For 300 LEDs, 150 additional bits must be fed to
+        the input of LED one so that the data can reach the last LED.
+
+        Ultimately, we need to send additional numLEDs/2 arbitrary data bits,
+        in order to trigger numLEDs/2 additional clock changes. This driver
+        sends zeroes, which has the benefit of getting LED one partially or
+        fully ready for the next update to the strip. An optimized version
+        of the driver could omit the "clockStartFrame" method if enough zeroes have
+        been sent as part of "clockEndFrame".
+        """
+
+        self.spi.xfer2([0xFF] * 4)
+
+        # Round up num_led/2 bits (or num_led/16 bytes)
+        #for _ in range((self.num_led + 15) // 16):
+        #    self.spi.xfer2([0x00])
+
+
+    def clear_strip(self):
+        """ Turns off the strip and shows the result right away."""
+
+        for led in range(self.num_led):
+            self.set_pixel(led, 0, 0, 0)
+        self.show()
+
+
+    def set_pixel(self, led_num, red, green, blue, bright_percent=100):
+        """Sets the color of one pixel in the LED stripe.
+
+        The changed pixel is not shown yet on the Stripe, it is only
+        written to the pixel buffer. Colors are passed individually.
+        If brightness is not set the global brightness setting is used.
+        """
+        if led_num < 0:
+            return  # Pixel is invisible, so ignore
+        if led_num >= self.num_led:
+            return  # again, invisible
+
+        # Calculate pixel brightness as a percentage of the
+        # defined global_brightness. Round up to nearest integer
+        # as we expect some brightness unless set to 0
+        brightness = int(ceil(bright_percent*self.global_brightness/100.0))
+
+        # LED startframe is three "1" bits, followed by 5 brightness bits
+        ledstart = (brightness & 0b00011111) | self.LED_START
+
+        start_index = 4 * led_num
+        self.leds[start_index] = ledstart
+        self.leds[start_index + self.rgb[0]] = red
+        self.leds[start_index + self.rgb[1]] = green
+        self.leds[start_index + self.rgb[2]] = blue
+
+
+    def set_pixel_rgb(self, led_num, rgb_color, bright_percent=100):
+        """Sets the color of one pixel in the LED stripe.
+
+        The changed pixel is not shown yet on the Stripe, it is only
+        written to the pixel buffer.
+        Colors are passed combined (3 bytes concatenated)
+        If brightness is not set the global brightness setting is used.
+        """
+        self.set_pixel(led_num, (rgb_color & 0xFF0000) >> 16,
+                       (rgb_color & 0x00FF00) >> 8, rgb_color & 0x0000FF,
+                        bright_percent)
+
+
+    def rotate(self, positions=1):
+        """ Rotate the LEDs by the specified number of positions.
+
+        Treating the internal LED array as a circular buffer, rotate it by
+        the specified number of positions. The number could be negative,
+        which means rotating in the opposite direction.
+        """
+        cutoff = 4 * (positions % self.num_led)
+        self.leds = self.leds[cutoff:] + self.leds[:cutoff]
+
+
+    def show(self):
+        """Sends the content of the pixel buffer to the strip.
+
+        Todo: More than 1024 LEDs requires more than one xfer operation.
+        """
+        self.clock_start_frame()
+        # xfer2 kills the list, unfortunately. So it must be copied first
+        # SPI takes up to 4096 Integers. So we are fine for up to 1024 LEDs.
+        data = list(self.leds)
+        while data:
+            self.spi.xfer2(data[:32])
+            data = data[32:]
+        self.clock_end_frame()
+
+
+    def cleanup(self):
+        """Release the SPI device; Call this method at the end"""
+
+        self.spi.close()  # Close SPI port
+
+    @staticmethod
+    def combine_color(red, green, blue):
+        """Make one 3*8 byte color value."""
+
+        return (red << 16) + (green << 8) + blue
+
+
+    def wheel(self, wheel_pos):
+        """Get a color from a color wheel; Green -> Red -> Blue -> Green"""
+
+        if wheel_pos > 255:
+            wheel_pos = 255 # Safeguard
+        if wheel_pos < 85:  # Green -> Red
+            return self.combine_color(wheel_pos * 3, 255 - wheel_pos * 3, 0)
+        if wheel_pos < 170:  # Red -> Blue
+            wheel_pos -= 85
+            return self.combine_color(255 - wheel_pos * 3, 0, wheel_pos * 3)
+        # Blue -> Green
+        wheel_pos -= 170
+        return self.combine_color(0, wheel_pos * 3, 255 - wheel_pos * 3)
+
+
+    def dump_array(self):
+        """For debug purposes: Dump the LED array onto the console."""
+
+        print(self.leds)

mic_hat_examples/interfaces/button.py

@@ -0,0 +1,15 @@
+import RPi.GPIO as GPIO
+import time
+
+BUTTON = 17
+
+GPIO.setmode(GPIO.BCM)
+GPIO.setup(BUTTON, GPIO.IN)
+
+while True:
+    state = GPIO.input(BUTTON)
+    if state:
+        print("off")
+    else:
+        print("on")
+    time.sleep(1)

mic_hat_examples/interfaces/pixels.py

@@ -0,0 +1,150 @@
+"""
+LED light pattern like Google Home
+"""
+
+import apa102
+import time
+import threading
+try:
+    import queue as Queue
+except ImportError:
+    import Queue as Queue
+
+
+class Pixels:
+    PIXELS_N = 3
+
+    def __init__(self):
+        self.basis = [0] * 3 * self.PIXELS_N
+        self.basis[0] = 2
+        self.basis[3] = 1
+        self.basis[4] = 1
+        self.basis[7] = 2
+
+        self.colors = [0] * 3 * self.PIXELS_N
+        self.dev = apa102.APA102(num_led=self.PIXELS_N)
+
+        self.next = threading.Event()
+        self.queue = Queue.Queue()
+        self.thread = threading.Thread(target=self._run)
+        self.thread.daemon = True
+        self.thread.start()
+
+    def wakeup(self, direction=0):
+        def f():
+            self._wakeup(direction)
+
+        self.next.set()
+        self.queue.put(f)
+
+    def listen(self):
+        self.next.set()
+        self.queue.put(self._listen)
+
+    def think(self):
+        self.next.set()
+        self.queue.put(self._think)
+
+    def speak(self):
+        self.next.set()
+        self.queue.put(self._speak)
+
+    def off(self):
+        self.next.set()
+        self.queue.put(self._off)
+
+    def _run(self):
+        while True:
+            func = self.queue.get()
+            func()
+
+    def _wakeup(self, direction=0):
+        for i in range(1, 25):
+            colors = [i * v for v in self.basis]
+            self.write(colors)
+            time.sleep(0.01)
+
+        self.colors = colors
+
+    def _listen(self):
+        for i in range(1, 25):
+            colors = [i * v for v in self.basis]
+            self.write(colors)
+            time.sleep(0.01)
+
+        self.colors = colors
+
+    def _think(self):
+        colors = self.colors
+
+        self.next.clear()
+        while not self.next.is_set():
+            colors = colors[3:] + colors[:3]
+            self.write(colors)
+            time.sleep(0.2)
+
+        t = 0.1
+        for i in range(0, 5):
+            colors = colors[3:] + colors[:3]
+            self.write([(v * (4 - i) / 4) for v in colors])
+            time.sleep(t)
+            t /= 2
+
+        # time.sleep(0.5)
+
+        self.colors = colors
+
+    def _speak(self):
+        colors = self.colors
+        gradient = -1
+        position = 24
+
+        self.next.clear()
+        while not self.next.is_set():
+            position += gradient
+            self.write([(v * position / 24) for v in colors])
+
+            if position == 24 or position == 4:
+                gradient = -gradient
+                time.sleep(0.2)
+            else:
+                time.sleep(0.01)
+
+        while position > 0:
+            position -= 1
+            self.write([(v * position / 24) for v in colors])
+            time.sleep(0.01)
+
+        # self._off()
+
+    def _off(self):
+        self.write([0] * 3 * self.PIXELS_N)
+
+    def write(self, colors):
+        for i in range(self.PIXELS_N):
+            self.dev.set_pixel(i, int(colors[3*i]), int(colors[3*i + 1]), int(colors[3*i + 2]))
+
+        self.dev.show()
+
+
+pixels = Pixels()
+
+
+if __name__ == '__main__':
+    while True:
+
+        try:
+            pixels.wakeup()
+            time.sleep(3)
+            pixels.think()
+            time.sleep(3)
+            pixels.speak()
+            time.sleep(3)
+            pixels.off()
+            time.sleep(3)
+        except KeyboardInterrupt:
+            break
+
+
+    pixels.off()
+    time.sleep(1)

mic_hat_examples/online_service_demos/alexa.py

@@ -0,0 +1,53 @@
+"""
+Hands-free Voice Assistant with Snowboy and Alexa Voice Service. The wake-up keyword is "alexa"
+
+Requirement:
+    pip install avs
+    pip install voice-engine
+"""
+
+
+import time
+import logging
+from voice_engine.source import Source
+from voice_engine.kws import KWS
+from avs.alexa import Alexa
+from pixels import pixels
+
+
+def main():
+    logging.basicConfig(level=logging.DEBUG)
+
+    src = Source(rate=16000, frames_size=320)
+    kws = KWS(model='alexa', sensitivity=0.8)
+    alexa = Alexa()
+
+
+    alexa.state_listener.on_listening = pixels.listen
+    alexa.state_listener.on_thinking = pixels.think
+    alexa.state_listener.on_speaking = pixels.speak
+    alexa.state_listener.on_finished = pixels.off
+
+
+    src.link(kws)
+    kws.link(alexa)
+
+    def on_detected(keyword):
+        logging.info('detected {}'.format(keyword))
+        alexa.listen()
+
+    kws.set_callback(on_detected)
+
+    src.recursive_start()
+
+    while True:
+        try:
+            time.sleep(1)
+        except KeyboardInterrupt:
+            break
+
+    src.recursive_stop()
+
+
+if __name__ == '__main__':
+    main()

mic_hat_examples/online_service_demos/google_assistant.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+
+# The code is based on google-assistant-sdk's hotword.py
+# LED light is added to notify its status.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from __future__ import print_function
+
+import argparse
+import os.path
+import json
+
+import google.auth.transport.requests
+import google.oauth2.credentials
+
+from google.assistant.library import Assistant
+from google.assistant.library.event import EventType
+from google.assistant.library.file_helpers import existing_file
+
+from pixels import pixels
+
+
+DEVICE_API_URL = 'https://embeddedassistant.googleapis.com/v1alpha2'
+
+
+def process_device_actions(event, device_id):
+    if 'inputs' in event.args:
+        for i in event.args['inputs']:
+            if i['intent'] == 'action.devices.EXECUTE':
+                for c in i['payload']['commands']:
+                    for device in c['devices']:
+                        if device['id'] == device_id:
+                            if 'execution' in c:
+                                for e in c['execution']:
+                                    if 'params' in e:
+                                        yield e['command'], e['params']
+                                    else:
+                                        yield e['command'], None
+
+
+def process_event(event, device_id):
+    """Pretty prints events.
+
+    Prints all events that occur with two spaces between each new
+    conversation and a single space between turns of a conversation.
+
+    Args:
+        event(event.Event): The current event to process.
+        device_id(str): The device ID of the new instance.
+    """
+    if event.type == EventType.ON_CONVERSATION_TURN_STARTED:
+        print()
+        pixels.wakeup()
+
+    print(event)
+
+    if event.type == EventType.ON_END_OF_UTTERANCE:
+        pixels.think()
+
+    if event.type == EventType.ON_RESPONDING_STARTED:
+        pixels.speak()
+
+    if event.type == EventType.ON_CONVERSATION_TURN_FINISHED:
+        if event.args and event.args['with_follow_on_turn']:
+            pixels.listen()
+        else:
+            pixels.off()
+            print()
+
+    if event.type == EventType.ON_DEVICE_ACTION:
+        for command, params in process_device_actions(event, device_id):
+            print('Do command', command, 'with params', str(params))
+
+
+def register_device(project_id, credentials, device_model_id, device_id):
+    """Register the device if needed.
+
+    Registers a new assistant device if an instance with the given id
+    does not already exists for this model.
+
+    Args:
+       project_id(str): The project ID used to register device instance.
+       credentials(google.oauth2.credentials.Credentials): The Google
+                OAuth2 credentials of the user to associate the device
+                instance with.
+       device_model_id(str): The registered device model ID.
+       device_id(str): The device ID of the new instance.
+    """
+    base_url = '/'.join([DEVICE_API_URL, 'projects', project_id, 'devices'])
+    device_url = '/'.join([base_url, device_id])
+    session = google.auth.transport.requests.AuthorizedSession(credentials)
+    r = session.get(device_url)
+    print(device_url, r.status_code)
+    if r.status_code == 404:
+        print('Registering....')
+        r = session.post(base_url, data=json.dumps({
+            'id': device_id,
+            'model_id': device_model_id,
+            'client_type': 'SDK_LIBRARY'
+        }))
+        if r.status_code != 200:
+            raise Exception('failed to register device: ' + r.text)
+        print('\rDevice registered.')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument('--credentials', type=existing_file,
+                        metavar='OAUTH2_CREDENTIALS_FILE',
+                        default=os.path.join(
+                            os.path.expanduser('~/.config'),
+                            'google-oauthlib-tool',
+                            'credentials.json'
+                        ),
+                        help='Path to store and read OAuth2 credentials')
+    parser.add_argument('--device_model_id', type=str,
+                        metavar='DEVICE_MODEL_ID', required=True,
+                        help='The device model ID registered with Google')
+    parser.add_argument(
+        '--project_id',
+        type=str,
+        metavar='PROJECT_ID',
+        required=False,
+        help='The project ID used to register device instances.')
+    parser.add_argument(
+        '-v',
+        '--version',
+        action='version',
+        version='%(prog)s ' +
+        Assistant.__version_str__())
+
+    args = parser.parse_args()
+    with open(args.credentials, 'r') as f:
+        credentials = google.oauth2.credentials.Credentials(token=None,
+                                                            **json.load(f))
+
+    with Assistant(credentials, args.device_model_id) as assistant:
+        events = assistant.start()
+
+        print('device_model_id:', args.device_model_id + '\n' +
+              'device_id:', assistant.device_id + '\n')
+
+        if args.project_id:
+            register_device(args.project_id, credentials,
+                            args.device_model_id, assistant.device_id)
+
+        for event in events:
+            process_event(event, assistant.device_id)
+
+
+if __name__ == '__main__':
+    main()

mic_hat_examples/recording_examples/get_device_index.py

@@ -0,0 +1,11 @@
+import pyaudio
+
+p = pyaudio.PyAudio()
+info = p.get_host_api_info_by_index(0)
+numdevices = info.get('deviceCount')
+
+for i in range(0, numdevices):
+    if (p.get_device_info_by_host_api_device_index(0, i).get('maxInputChannels')) > 0:
+        print("Input Device id ", i, " - ", p.get_device_info_by_host_api_device_index(0, i).get('name'))
+    else:
+        print("Output Device id ", i, " - ", p.get_device_info_by_host_api_device_index(0, i).get('name'))

mic_hat_examples/recording_examples/play.py

@@ -0,0 +1,36 @@
+import pyaudio
+import wave
+import sys
+
+# length of data to read.
+chunk = 1024
+RESPEAKER_INDEX = 1
+# validation. If a wave file hasn't been specified, exit.
+if len(sys.argv) < 2:
+    print("Plays a wave file.\n\n" + "Usage: %s filename.wav" % sys.argv[0])
+    sys.exit(-1)
+
+# open the file for reading.
+wf = wave.open(sys.argv[1], 'rb')
+
+# create an audio object
+p = pyaudio.PyAudio()
+
+# open stream based on the wave object which has been input.
+stream = p.open(format = p.get_format_from_width(wf.getsampwidth()),
+                channels = wf.getnchannels(),
+                rate = wf.getframerate(),
+                output = True,
+                output_device_index = RESPEAKER_INDEX)
+
+# read data (based on the chunk size)
+data = wf.readframes(chunk)
+# play stream (looping from beginning of file to the end)
+while data:
+    # writing to the stream is what *actually* plays the sound.
+    stream.write(data)
+    data = wf.readframes(chunk)
+
+# cleanup stuff.
+stream.close()    
+p.terminate()

mic_hat_examples/recording_examples/record.py

@@ -0,0 +1,41 @@
+import pyaudio
+import wave
+
+RESPEAKER_RATE = 16000
+RESPEAKER_CHANNELS = 2 
+RESPEAKER_WIDTH = 2
+# run getDeviceInfo.py to get index
+RESPEAKER_INDEX = 1  # refer to input device id
+CHUNK = 1024
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "output.wav"
+
+p = pyaudio.PyAudio()
+
+stream = p.open(
+            rate=RESPEAKER_RATE,
+            format=p.get_format_from_width(RESPEAKER_WIDTH),
+            channels=RESPEAKER_CHANNELS,
+            input=True,
+            input_device_index=RESPEAKER_INDEX,)
+
+print("* recording")
+
+frames = []
+
+for i in range(0, int(RESPEAKER_RATE / CHUNK * RECORD_SECONDS)):
+    data = stream.read(CHUNK)
+    frames.append(data)
+
+print("* done recording")
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+
+wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+wf.setnchannels(RESPEAKER_CHANNELS)
+wf.setsampwidth(p.get_sample_size(p.get_format_from_width(RESPEAKER_WIDTH)))
+wf.setframerate(RESPEAKER_RATE)
+wf.writeframes(b''.join(frames))
+wf.close()

mic_hat_examples/recording_examples/record_one_channel.py

@@ -0,0 +1,45 @@
+import pyaudio
+import wave
+import numpy as np
+
+RESPEAKER_RATE = 16000
+RESPEAKER_CHANNELS = 2
+RESPEAKER_WIDTH = 2
+# run getDeviceInfo.py to get index
+RESPEAKER_INDEX = 1  # refer to input device id
+CHUNK = 1024
+RECORD_SECONDS = 3
+WAVE_OUTPUT_FILENAME = "output_one_channel.wav"
+
+p = pyaudio.PyAudio()
+
+stream = p.open(
+            rate=RESPEAKER_RATE,
+            format=p.get_format_from_width(RESPEAKER_WIDTH),
+            channels=RESPEAKER_CHANNELS,
+            input=True,
+            input_device_index=RESPEAKER_INDEX,)
+
+print("* recording")
+
+frames = [] 
+
+for i in range(0, int(RESPEAKER_RATE / CHUNK * RECORD_SECONDS)):
+    data = stream.read(CHUNK)
+    # extract channel 0 data from 2 channels, if you want to extract channel 1, please change to [1::2]
+    a = np.fromstring(data,dtype=np.int16)[0::2]
+    frames.append(a.tostring())
+
+print("* done recording")
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+
+wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+wf.setnchannels(1)
+wf.setsampwidth(p.get_sample_size(p.get_format_from_width(RESPEAKER_WIDTH)))
+wf.setframerate(RESPEAKER_RATE)
+wf.writeframes(b''.join(frames))
+wf.close()
+

mic_hat_examples/requirements.txt

@@ -0,0 +1,3 @@
+spidev
+rpi.gpio
+pyaudio