Marc's Public Blog - Arduino Hacking


All | Aquariums | Arduino | Btrfs | Cars | Cats | Clubbing | Dining | Diving | Electronics | Exercising | Flying | Hiking | Linux | Linuxha | Museums | Public | Rc | Sciencemuseums | Snow | Solar | Trips



Table of Content for arduino:

More pages: May 2018 April 2018 January 2018 June 2017 April 2017 January 2017 February 2016 January 2015 September 2013 January 2012 December 2011 May 2011 January 2011




2018/05/29 EDM Party Shirt powered with FastLED::NeoMatrix and Adafruit::GFX, plus 160Wh (10Ah/4S) worth of lipos
π 2018-05-29 01:01 in Arduino, Clubbing, Electronics



After I figured that my previous shirt was getting a bit stale, I wanted to design EDM Party Shirt v2, which both had to be easier to wash (the previous one had LED strips all over it that were too much work to remove, making the shirt not really washable), and I also wanted it to be more special.
I had been playing with Adafruit::NeoMatrix and figured it would be cool to have a NeoMatrix on my shirt (also it would be easier to remove a whole panel to wash the shirt).

So, in the great tradition of yak shaving, I first decided that I should be able to use FastLED instead of Adafruit::Neopixel. This was mainly at the time because FastLED allows parallel output and therefore allows updating a screen by segmenting it in smaller pieces that are updated in parallel. With Adafruit::NeoMatrix, my 768 pixel panel would have taken about 30ms to refresh, or only 33 frames per second, which is not a lot. With FastLED, I was able to trivially segment it in 3 and get 10ms/100fps, which is a whole lot better for animations.
Turns out, switching to FastLED also gave me access to LEDMatrix, an alternate library which while lacking Adafruit::GFX primitives, offers another nice API including better text and basic sprite support.

So, I started a port of Adafruit::NeoMatrix to FastLED and wrote FastLED::NeoMatrix. It was actually a non trivial port, which took much longer than I thought, but I got it working in the end:


by then I was already able to display with 3 data lines, one for each 32x8 panel
by then I was already able to display with 3 data lines, one for each 32x8 panel

In the process, I managed to plug the wrong power into the panel and blew a pixel. Thankfully I was able to borrow another pixel from a strip and soldering it in place to fix it:


Once the port was done, came time to get the panels together. Wiring was a bit challenging because I had to ensure that power was injected at a mostly equal value in 9 different points (3 per panel) due to voltage sag at higher amps. I then quickly found out that with 3 data lines at high frequency, there is cross talk between the wires, so I switched to a CAT-5e cable where each data line is twisted with its ground and the remaining 2 wires are used to bring VCC (5V). Technically my 3 panels can use up to 60A at 5V at full power. Obviously many things will melt before that, and I'm using a power converter that tops out at 10A. Even 10A is too much for the wiring, but thankfully my displays don't use that much brightness (it would be blinding to people):


two 5Ah 16V lipos give about 160Wh, just enough to run 2 panels 10 to 12H
two 5Ah 16V lipos give about 160Wh, just enough to run 2 panels 10 to 12H

the fancy energy meter keeps track of how much time I used and how many Ah came out of the batteries. Useful to know how much time I have left. The blue meter is amps at 5V (after the power converter) and the red one amps at 16V (straight from the battery)
the fancy energy meter keeps track of how much time I used and how many Ah came out of the batteries. Useful to know how much time I have left. The blue meter is amps at 5V (after the power converter) and the red one amps at 16V (straight from the battery)

on the right, I have a backup ESP8266 if the main one fails, a backup BEC (5V converter) that's technically 10A capaable but not meant to do more than 5A continous, and bottom right is my older 3A BEC with in line amp meter
on the right, I have a backup ESP8266 if the main one fails, a backup BEC (5V converter) that's technically 10A capaable but not meant to do more than 5A continous, and bottom right is my older 3A BEC with in line amp meter

the new tobsun 5V converter is bulky but does 10A without issues
the new tobsun 5V converter is bulky but does 10A without issues

For the back of the shirt, I got some fabric and created an inside pocket to hold the panel:




it then mirrors the front
it then mirrors the front

All this crap goes into a fanny pack, and gets wired to my shirt, pants, and glasses:



the cool part is that my back also has a panel inside the shirt that uses the shirt as a diffuser
the cool part is that my back also has a panel inside the shirt that uses the shirt as a diffuser

You can get the code I wrote for the shirt here: https://github.com/marcmerlin/NeoMatrix-FastLED-IR

This video shows an early version of the code working on a desk:

This video shows the animations:

While this video shows the tech a bit more:

2018/04/23 FastLED::NeoMatrix library
π 2018-04-23 01:01 in Arduino
I've been a fan of Neopixels and Adafruit's Neomatrix library since last year. Why is Neomatrix special? It allows you to create Neopixel displays and treat them like a panel display on which you can apply Adafruit::GFX primitives.

The problem is that https://github.com/adafruit/Adafruit_NeoMatrix only supports the https://github.com/adafruit/Adafruit_Neopixel backend which in turn only supports neopixels, and only in a serialized fashion. Serialized means that if you have 1024 pixels (32x32 matrix), it takes about 35 to 40ms to send a single frame, which means you can only update at a 25fps rate, which is not that good.

https://github.com/FastLED/FastLED fixes this by offering support for a lot of different kinds of LEDs, but also for offering parallel output on multiple MCUs, allowing you to get up to 16x faster updates by segumenting the strip to update sequentially. It also offers much nicer primitives like automatic fading, and the ability to have multiple independent strips of different lengths that can display different patterns.

Neomatrix is aweseome since it offers access to the GFX library primitives (circles, lines, rectangles, and fonts), but since it didn't work with a FastLED backend, I ported it to FastLED.

You can get the code here: https://github.com/marcmerlin/FastLED_NeoMatrix
You can also see my NeoMatrix Shirt on this page


Hello world
Hello world

Thanks to Adafruit::GFX, it's easy to display fonts and bitmaps
Thanks to Adafruit::GFX, it's easy to display fonts and bitmaps

32x32 is slightly better to display bitmaps
32x32 is slightly better to display bitmaps


This will be the display on my shirt
This will be the display on my shirt

GFX allows drawing lines, circles and all
GFX allows drawing lines, circles and all

Fonts can be of any size
Fonts can be of any size

See more images for FastLED::NeoMatrix library
2018/01/22 Lolibot, FPGA Primer, MicroPython for ESP8266/ESP32 and Protocol Analysis at Open Hardware Miniconf at Linux.Conf.au 2018
π 2018-01-22 01:01 in Arduino, Linux
Got to play with a lot of hardware at LCA 2018:
  • ESP32 micropython programmed robot
  • Learned the very basics (and pains) of how to program an FPGA
  • MicroPython programming and handling
  • Protocol Analysis (1wire) with a USB protocol sniffer.
  • Definitely worth the time I spent, even if some miniconfs made me miss a bunch of talks, but it was worth it :)

    Lolibot:







    our fearless team was honest about how they do the work every year :)
    our fearless team was honest about how they do the work every year :)

    The next day, I went to the FPGA training/miniconf:


    Bunnie Huang was one of the attendees
    Bunnie Huang was one of the attendees

    FPGAs are definitely 'interesting', you can use some of the gates to emulate a CPU, and others to run bare metal code
    FPGAs are definitely 'interesting', you can use some of the gates to emulate a CPU, and others to run bare metal code

    It was useful to learn more about MicroPython the next day, definitely a faster way to work on ESP8266/ESP32 SOCs:


    ESP32
    ESP32


    Tim nicely setup a hardware rig to flash the little TOMU boards that fit in your USB slot:


    The last day, we learned how to use a USB logic analyser to debug 1wire timing issues:


    protocol analysis is what Tridge eats for breakfast ;)
    protocol analysis is what Tridge eats for breakfast ;)

    2017/06/02 LED Pants and Shirt Programmed With Arduino on ESP8266
    π 2017-06-02 01:01 in Arduino, Clubbing, Electronics
    So, this all started with some LED shoes I hacked to last 12H instead of 4, and it ended with me learning how to program arduino like microcontrollers to control neopixels (aka WS2811/WS2812/WS2812B) while being able to receive Infrared/IR commands. The latter is actually difficult but you go read that page to learn why

    Since I've met plenty of people who complimented for my neopixel shirt and pants combo, and some who asked questions about them, I thought I'd write some quick page to explain how it all works and how you can do similar things, since it's more fun if I'm not the only one lit up at Dreamstate (which has been less of a problem at burning man).

    Here is a video summary:

    Show me the code!

    Sure, it's here: https://github.com/marcmerlin/Neopixel-IR (but go to the end of this page for more details).

    So, I have 3 versions of the shirt, let's go through them depending on how complex you'd like to go:

    Multi Color LED strip, non controllable



    It used a 12V controllable dimmer: https://www.amazon.com/gp/product/B00MHKCTLE which can simply change the brightness of the LEDs, which are of a set color. I bought the LED strip in Akihabara Japan, but I'm guessing something similar can be found elsewhere.

    Tri Color Controllable LED strip



    This version is better in that the LED strip has 3 channels, one for reach of Red, Green, and Blue. I uses a tri color controller like this one: https://www.amazon.com/gp/product/B01410R4KS or remote controlled: https://www.amazon.com/gp/product/B00PBOJNZS
    Those controllers can create any color and flash it at any interval, however:

  • they are a flat trip that doesn't really like being bent
  • all the LEDs are in series, so if the chain fails somewhere, nothing lights up beyond the point of failure (which is why I have extra wires soldered on to make redundant paths and get around breakage
  • I have had some sections of 3 LEDs where one color died
  • All of the controllers I tried have a dimming function, but it fails to work when I use the fade dimming patterns, which means they are full bright, suck battery and blind others. I've therefore had to add a 2nd voltage regulator where I can just dim the voltage sufficiently so that the current is then also capped by each color string and therefore the brightness is controlled (you cannot limit the global current fed to the LED controller because you don't know whether it's all fed into a single color, or shared amongst 3).
  • Of course the last thing is that all the LEDs for a color are in series in a single circuit, so you light up all the reds, or all the blues or greens, or none. You can't turn on one LED individuallly. This is where the next solution comes in.
  • ESP8266/Arduino Controlled Neopixels



    To fix the issue of not being able to have custom multi color LED patterns, where each LED/pixel can be controlled separately, the solution is neopixels (aka WS2811/WS2812/WS2812B). Each LED/pixel is controllable separately, which is done by a computer, in this case the ESP8266 can run my own programs to control all the LEDs.
    The ESP8266 is a 3.3V based microcontroller for low power use (good when battery powered) while the neopixels are 5V powered, but thankfully the neopixels can use 3.3V signalling from the ESP8266 while being 5V powered to light up properly. The one thing to keep in mind is that neopixels use some power even if they are not lit. In my case 200 neopixels, take about 120mA when they are off, and 4.5A when they are all lit in white on full brightness.

    Neopixels are almost infinitely versatile, instead of having them in single line strips like on my shirt and pants, you can also make display matrices out of them:


    I've then written code that receive the IR commands from the remote and execute different code that creates different light patterns, which is explained in more details and available on this page and you can get the code from github.

    Here is a video that shows all 3 modes, jump to 3:50 for the neopixel bit:

    2017/04/24 Adafruit GFX on NeoMatrix and RGB Matrix Panel Demo
    π 2017-04-24 01:01 in Arduino
    Give me code:
  • https://github.com/marcmerlin/Adafruit_NeoMatrix/tree/master/examples/MatrixGFXDemo
  • https://github.com/marcmerlin/RGB-matrix-Panel/tree/master/examples/PanelGFXDemo
  • FastLED Version https://github.com/marcmerlin/FastLED_NeoMatrix/blob/master/examples/MatrixGFXDemo/MatrixGFXDemo.ino
  • Note that the last link uses my https://github.com/marcmerlin/FastLED_NeoMatrix library which ports NeoMatrix to the better FastLED backend. The nice thing though is that all your code keeps working just the same, no changes required outside of matrix initialization. I wrote a different page for my FastLED::NeoMatrix library.

    All the displays, 4 made with neopixels and soldered by hand
    All the displays, 4 made with neopixels and soldered by hand

    Yeah, the 24x24 one took forever to lay out, glue and solder (6H+)
    Yeah, the 24x24 one took forever to lay out, glue and solder (6H+)

    More than 2 years ago, I spent many hours writing an interrupt written driver for LED matrices that require fast line scanning while you setup the right rows, and even faster per color refreshes where you turn the color on and off depending on how bright you want each color component to be to yield different color mixes. This is explained in more details on my page on Driver for direct driving single to 3 color LED Matrices with software PWM.

    Then came in Neopixels which can be individually addressed without fast row scanning, and the Adadfruit Neomatrix library. Those made creating color matrices much more trivial (except for the part where you have to actually build and solder that matrix):

    2 row scanned matrices on the upper left, 7x7 neomatrix, another row scanned 32x16 Adafruit panel.
    2 row scanned matrices on the upper left, 7x7 neomatrix, another row scanned 32x16 Adafruit panel.

    on the bottom row, self built 16x8 neomatrix, and another 12x12 neomatrix
    on the bottom row, self built 16x8 neomatrix, and another 12x12 neomatrix

    I ended up taking my old Adafruit GFX demo I wrote fro my interrupt driven scan matrices, porting it to Neomatrix (which was trivial) and then extending it. You can find my MatrixGFXDemo code here,
    Soon afer, I dug up my Adafruit 16X32 RGB LED Matrix Panel, setup an old Arduino Mega to control it and have enough RAM left to run some fun code (on an Uno memory would have been too tight), it turns out that thanks to Adafruit GFX support, it took very little time to get my same demo working on the RGB Panel.

    Here is a video of the demo I wrote on all those different displays:

    Here are some things the demo does:

  • Init displays the same 8x8 pattern as many times as it will fit

  • The code will then draw lines, rectangles and circles that match the size of the display:


  • If the display is at least 16x8, it will display the resolution in various ways appropriate to the display size:




  • another part of the demo displays an 8x8 color pixmap with drawRGBBitmap I added in Adafruit-GFX-Library and bounces it around on any display bigger than 10x10:


  • then, it will display a 24x24 bitmap which on most displays will be panned around to show the whole picture:


  • Hope you enjoy the demo, it should work pretty trivially on any display that supports Adafruit::GFX, see https://github.com/marcmerlin/RGB-matrix-Panel/blob/master/examples/PanelGFXDemo/PanelGFXDemo.ino#L21 on how some backend specific code can be #define'd to work on other backends.

    2017/04/16 IoTuz Driver ported to Expressif ESP32 WROVER board
    π 2017-04-16 01:01 in Arduino
    As explained on this page, I wrote a pretty extensive driver-set for an ESP32 based board with lots of IO, but hardly anyone has that board (fewer than 100 made), so I ported what I could of the code to the WROVER.


    Sadly the WROVER lacks a touch screen, so you'll have to wire at least a rotary encoder or a joystick. In the demo above I also wired 2 neopixels and an IR receiver to mirror the hardware on the IoTuz.

    Source code: https://github.com/marcmerlin/IoTuz

    See this video for a demo:

    You'll definitely want to read https://github.com/marcmerlin/IoTuz/blob/master/README.md carefully, especially the WROVER section.

    On an ILI3941 based WROVER, you should also be able to play tetris and breakout:

    Enjoy!

    2017/04/03 Arduino 328P Uno Teensy3.1 ESP8266 ESP32 IR and Neopixels
    π 2017-04-03 01:01 in Arduino, Clubbing, Electronics
  • Why my pants needed IR controlled neopixels :)
  • Why IR and Neopixels at the same time, is hard
  • Concurrent IR + Neopixels solution #1: be fast (Teensy 3.1)
  • Concurrent IR + Neopixels solution #2: don't use the CPU for neopixels (ESP8266 (I2S) and ESP32 (RMT))
  • Software and Libraries
  • Video with the whole story and details
  • Show me the code!

    Sure, it's here: https://github.com/marcmerlin/Neopixel-IR (but go to the end of this page for more details).

    Why my pants needed IR controlled neopixels :)

    I mean, don't everyone's pants need neopixels? :)

    I started with a silver shirt, I added a few LEDs, and then more I got from a swap meet, and later added some LED shoes I hacked to last 12H instead of 4



    The end goal was adding neopixel strips on my shirt sleeves and pant legs:


    Here is a 6mn clip showing the shoes and shirt if you'd like the details:

    The problem with my shirt, though, is that the colors you see on the picture are actually due to broken traces, causing the colors you see. It's better than nothing, but not what I was trying to do, and no way to create streaming effects. This is of course where neopixels come in.

    I'm not going to repeat the excellent Adafruit Neopixel Uberguide here, but I have a 3mn video clip showing a standard IR RGB LED controller, compared to a neopixel strip. It also shows how I use standard remote control servo cables to wire neopixels, and how to watch out for:

  • signal wire being in the center, so you must not feed 5V on the middle wire like you would with RC and servos
  • how if you have a neopixel strip that doesn't work right, you can only connect to the first LED, and you have to start cutting off LEDs from the strip one by one until you get to the first one that works
  • before you start cutting, make very sure you aren't connecting to the last LED (DO vs DI)
  • Why IR and Neopixels at the same time, is hard

    So, the main point of this page is however to look into the issues of controlling Neopixels and receiving IR signals at the same time.

    It's easy to listen for IR, and then change neopixels, leave them alone, and listen for IR again. It's hard (or near impossible on some chips) to actively update neopixel strips for animations and listen for IR commands at the same time.

    Why? This video explains the issue:

    What's going on is on low end arduino chips (328p, leonardo, or even AT mega and all other 16 bit AVRs), neopixels are controlled by stopping chip interrupts and sending a very precisely timed signal to the neopixels. If the timing is off just a little bit, the wrong colors get sent, or nothing works at all. This is why interrupts must be disabled


    Now, there are actually many other addressable multicolor LED types. The nice ones are 4 wire and work via SPI, which allows the CPU to control the timing and the clock, removing this exact bit banging timing issue. The cheaper 3 wire ones have a set clock and require that the CPU sends a very precisely timed signal, usually done while disabling interrupts. See https://github.com/FastLED/FastLED/wiki/Overview

    But since neopixel strips (aka WS2811/WS2812/WS2812B) is what I already had, I now had to deal with this precise timing issue. As you can guess, disabling interrupts causes issues with the IRRemote library because it has its on interrupt handler timer that also requires being run at a special timing, or it doesn't capture proper IR signals.
    The end result is that you cannot disable interrupts and receive IR signals, and if you don't disable interrupts, the neopixel signal is unstable and the colors flicker (demonstrated int the video above).

    So, unless you use some special hardware to drive neopixels strips on an AVR chip, concurrent IR + neopixels is just not going to work.

    an arduino nano v3 running neopixel strips
    an arduino nano v3 running neopixel strips

    my 328p arduiny chip (equivalent to arduino nano) and anti plug backwards toothpicks :)
    my 328p arduiny chip (equivalent to arduino nano) and anti plug backwards toothpicks :)

    because my 328p chip was unprogrammed, I had to figure out direct ISP programming pinout for it and I flashed a bootloader on it
    because my 328p chip was unprogrammed, I had to figure out direct ISP programming pinout for it and I flashed a bootloader on it

    Concurrent IR + Neopixels solution #1: be fast (Teensy 3.1)

    a few chips for comparison (uno, leostick, nano v3, arduiny, and Teensy 3.1 in green)
    a few chips for comparison (uno, leostick, nano v3, arduiny, and Teensy 3.1 in green)

    Thanks to better FastLED hardware support, when I moved my code to a Teensy 3.1 32 bit ARM CPU, the CPU was fast enough that it had time to re-enable interrupts in the middle of updating neopixels. This in turns allowed the IR Remote interrupt handler to just barely run in between pixel updates, and capture IR codes. Success!

    See this video for details:

    The magic code that makes this work, is here: https://github.com/FastLED/FastLED/blob/master/platforms/arm/k20/clockless_arm_k20.h#L34
    sei(); delayMicroseconds(WAIT_TIME); cli();

    Thanks to this re-enabling of interrupts, things work.

    So at this point, someone sensible would have declared victory. However, I felt bad wasting a Teensy 3.1 on something as simple as driving a single neopixel strip (it can drive 8 in parallel) and reading from an IR receiver, when it has around 32 I/O ports. This is why I checked if I could get this to work on ESP8266 chips which are even cheaper and have much fewer I/O pins (but add Wifi)

    Concurrent IR + Neopixels solution #2: don't use the CPU for neopixels (ESP8266 (I2S) and ESP32 (RMT))

    I had more 32bit chips, so I thought I would give them a try. I tried the ESP8266 and ESP32:


    First, the ESP8266 mostly worked with FastLED + IRRemote, but not quite. The FastLed code, just like on Teensy, is nice enough to re-enable interrupts for a short while: https://github.com/FastLED/FastLED/blob/master/platforms/esp/8266/clockless_esp8266.h#L45

    os_intr_unlock();
    delayMicroseconds(WAIT_TIME);
    os_intr_lock();

    However in my tests, the IRremoteESP8266 library was maybe a little bit too slow and caused occasional visible neopixel glitching. This is where I found this interesting library: https://github.com/JoDaNl/esp8266_ws2812_i2s/ which manages to drive the neopixels without doing bit banging with interrupts disabled ((ab)-using the I2S hardware support). It's not a very fancy library in what it offers, but it works perfectly with interrupts enabled.

    Same thing for ESP32. Actually ESP32 is even more difficult to get a perfect timing out of using bit-banging given that it's a dual core CPU running on top of an RTOS, and no matter how precise your code is, you just cannot guarantee that it'll run perfectly at the timing you need all the time. I did add ESP32 support to the Adafruit Neopixel library, but it only works most of the time, which isn't really good enough.
    This where its built in RMT support comes in. It can generate 8 precise signal waves, which are perfect for neopixels, so this is the way to go to animate neopixels without disabling interrupts (making IR receiving trivial). IRremote was missing ESP32 receive support, but I added it recently, so it's all working.

    Here's a video summary of ESP8266 and ESP32:

    Software and Libraries

    So, here's a summary of all the libraries I went through, 2 for IR, and 4 for Neopixels:
  • To receive IR signals, we'll use the excellent IRremote lib: https://github.com/z3t0/Arduino-IRremote
  • ESP8266 currently uses a fork of IRRemote, IRremoteESP8266 which may soon be in the process of being merged in the main Arduino-IRremote. See https://github.com/markszabo/IRremoteESP8266/issues/148 and https://github.com/z3t0/Arduino-IRremote/issues/400#issuecomment-294446261 .
  • For neopixels, most people use the adafruit lib: https://github.com/adafruit/Adafruit_NeoPixel . It works ok, but it requires disabling interrupts (and is therefore incompatible with IRRemote for concurrent operation)
  • FastLED is a more complete library with better hardware support (both in pixels and CPUs): https://github.com/FastLED/FastLED . The big plus of this lib is that it support re-enabling interrupts on 32bit chips, allowing the IRremote ISR to run.
  • Instead of FastLED (which does work), on ESP8266 you can use https://github.com/JoDaNl/esp8266_ws2812_i2s/ . The support is bare, but uses an inventive (ab)use of the I2S subsystem (I2C for audio) to generate neopixel signals using an onboard co-processor unit without tying up the main CPU or requiring the disabling of interrupts.
  • On ESP32, FastLED isn't supported yet (I added support in Adafruit-Neopixel) but both require disabling interrupts at least temporarily and it's hard to do anything real time on a dual core ESP32 running on top of an RTOS. The good news however is that it has 8 RMT channels which are designed to handle precise signals like this without tying up the CPU. See this code that supports Neopixels with exact timing: https://github.com/MartyMacGyver/ESP32-Digital-RGB-LED-Drivers
  • And here is my code again: https://github.com/marcmerlin/Neopixel-IR

    The big plus from that example code is that it supports 4 different Neopixel backends and abstracts them so that the adafruit (and other) demos can run on all 4 libs. See how it does it here: https://github.com/marcmerlin/Neopixel-IR/blob/v1.0/Neopixel-IR.ino#L275

    Video with the whole story and details

    This is a 25mn mashup of all the video clips, including a section on flashing the arduiny via ISP (AVR 328p):

    I also have a video showing the evolution of lights on my shirt from v1 (single non controllable color) to v2 (tri color, but not pixel addressable), to neopixels with cool patterns (jump to 3:50 if you'd like that):

    2017/01/16 IoTuz Driver for our ESP32 board built at Open Hardware Miniconf at Linux.Conf.au 2017
    π 2017-01-16 01:01 in Arduino, Linux
    I went to meet the Open Hardware Miniconf team to hang out the previous day and see them at work finishing the last boards:


    last minute hardware patching
    last minute hardware patching


    The IoTuz board was a challenge compared to previous years. It was based on the still new ESP32 and had very little example code. Most of the hardware had never been exercised since the board had been designed, and with a few other people I took the task to heart. Within the week, I was able to get the SPI touch screen working at the same time than the LCD (which required cable select switching via I/O expander lines. It took longer to get the two APA106 (neopixel-like) LEDs to work:

    I had the first etch-a-sketch working :)
    I had the first etch-a-sketch working :)

    So, that all in January. But IoTuz was the gift that kept on giving. It had all those I/O bits that didn't work at all and no one had ever used. Hell, some of them had no existing drivers at all (Neopixel no support under arduino IDE, IO expander needed some access functions, No support for the IR receiver, touch screen needed a few hacks, joystick needed some code to support the huge dead zone in the center), while some other hardware worked out of the box with existing drivers (temp/humidity and accelerometer). The rotary encoder also needed custom ESP32 interrupt code to work properly (nothing too fancy, but there was no existing driver to use).

    So, I embarqued into a mega library/object to support most of the hardware and ended up with almost 1000 lines of code for my IoTuz library, and another thousand lines or so for the main example code (examples/fulldemo) and that does not include 3rd party code of existing demos I was able to re-use and port to IoTuz.

    In the end, that took about 100 hours of work since I had to write/port drivers as I went along, and learn how some of that hardware was even supposed to work :) (ok, non trivial time was also spent finding and chasing platform bugs which have now been fixed, as well as merging driver code with upstream maintainers).

    Here is a quick video summary (longer videos at the bottom):

    And here is the result (thanks to https://github.com/marcmerlin/IoTuz 's examples/fulldemo)

    I made an adjustable touch menu system
    I made an adjustable touch menu system


    drawing circles with the accelerometer by rotating the board
    drawing circles with the accelerometer by rotating the board

    touch color selector
    touch color selector

    hardware scroll of bitmap using the rotary encoder
    hardware scroll of bitmap using the rotary encoder



    Just like the joystick not being very precise or centered right, the touchscreen isn't quite the same for everyone, but especially in my case I broke my touchscreen, had to buy another one and that one was wired reversed, so I designed a screen touch screen calibrator which auto adjusts and supports touch screens that are inversed like mine:


    Enough bla-blah, show me the code: https://github.com/marcmerlin/IoTuz

    And here are some video clips:

    Hardware Intro

    IoTuz Controls

    IoTuz Infrared Support

    IoTuz Demos

    IoTuz Breakout and Tetris

    Again, here's the code: https://github.com/marcmerlin/IoTuz

    2016/02/01 ESPlant, Arduino Miniconf at Linux.Conf.AU 2016
    π 2016-02-01 01:01 in Arduino, Linux
    Another year, another arduino miniconf, this year, the LCA open hardware folks brought us the ESPlant, a new board meant to monitor plants, and based off the ESP8266, the super cheap wifi chip that can now be used with the arduino IDE and libraries thanks to a compat layer.

    Jon, opening the miniconf
    Jon, opening the miniconf

    The Melbourne Hardware Hacking team who worked on this
    The Melbourne Hardware Hacking team who worked on this





    Jon gave a cool talk on the hardware assembly machine he built to put those boards together, impressive:



    Short of having a plant nearby, I concentrated on making pretty lights on the LED strip :)


    blinkie achieved :)
    blinkie achieved :)

    I added my blinky code here: https://github.com/marcmerlin/ESPlant

    Demo:

    2015/01/06 Driver for direct driving single to 3 color LED Matrices with software PWM
    π 2015-01-06 01:01 in Arduino
    Code download: Multi Color PWM LED Matrix Driver.

    Many LED matrices come with a MAX7219 driver chip or equivalent. Those are great since you program the columns and rows, and they do the line by line scan and refresh for you. Unfortunately, you can't do color mixes with different intensities for each color. For instance the Adafruit LED backpack is super easy to use, but you cannot control each color to mix different shades between them.

    Then, I also happened to have some raw LED matrices a dual color one and a triple color one ordered from china, equivalent to these two: https://www.sparkfun.com/products/682 and https://www.sparkfun.com/products/683 . Those didn't come with any driver chip, so that gave me an excuse to program my own code to do line scanning and refresh like many examples you find on the net.

    My bycolor matrix has common cathode, green and red on the 2 anodes. Like other matrices you have to disable all the lines, set the rows you'd like for each color, and then turn on the common ground to illuminate those pixels for a little while. Then, you go to the next line, and continue. Many examples do this in the main arduino loop, but I wanted to use Adafruit's excellent Adafruit-GFX library. As a result, I wrote an ISR (interrupt routine) to rrefresh the lines, like an old cathodic raw tube, in the background, while leaving the main loop for programming what you want to do and display. This soon allowed me to display the smiley face bitmap from the Adafruit LED Backpack library.

    from here
    from here

    to here
    to here

    This was pretty major accomplishment for me since I wrote a generic C++ library that could allocate an array of any size (it supports anything, not just 8x8), and do all the work in the background in an ISR. I then got busy with other projects and hobbies.

    Later, I came back to this and added code to support more than one color, and especially support programming an LED array of 1 to 3 separate colors wired either directly or via shift registers, or a combination of the 2 (shift registers save pins, but also make IO 50% slower). By then I was hitting issues where I had to refresh the lines very quickly (200 microseconds) to allow for 16 shades per color and still offer a 40-50Hz refresh rate for the whole array. If my refresh became slower than 200 microseconds, I could not support 16 shades (4 bits per color) without getting too slow and creating an array that would visibly flicker. I fixed this by doing the following:

  • Fast Digital IO to make digitalwrite 3x faster and my ISR routine 2.5x faster
  • Instead of having 16 interruptions for 16 levels per color, I switched to binary code modulation where I could do the same 16 levels of shading with only 4 interrupts instead of 16. This also leaves more time for code in the main loop.
  • I've published my resulting code here: Multi Color PWM LED Matrix Driver. While it uses more resources than the adafruit backpacks, it's cheaper in hardware and ends up giving more flexibility (many more colors).

    Before you ask me for help, READ THIS PLEASE :)

  • If you don't know the basics of LED matrices and shift registers, go read the links at the bottom of this page which show wiring for direct wiring and shift registers.
  • Or if you want shift registers in a nutshell, go here: https://www.youtube.com/watch?v=bqfPZXEuyuc
  • Shift registers + LED matrix, see: https://www.youtube.com/watch?v=2m3PbCvcqkY
  • For a wiring diagram see: http://learnpic32.blogspot.co.nz/2014/06/controlling-rgb-led-matrix-with-shift.html
  • But basically you should get the basics working before trying my library, make sure you can turn on LEDs one by one, understand the basics, and then you can use my library which will give you much faster access to your matrix while offering a GFX graphical library on top.

    You can look at the results here:




    The original Adafruit::GFX library doesn't support multi color bitmaps, but I added support for it here: https://github.com/adafruit/Adafruit-GFX-Library/pull/39

    After doing the above, I went to add support for Tricolor Matrices, which was not much work, except for adding those 2 bits:

  • allowing shift registers to be wired to rows in reverse order when it makes wiring easier
  • 3 colors at 16pwm values and 40Hz runs against the speed limits of an arduino nano v3
  • My tricolor matrix had a common anode which was opposite from the bicolor with a common cathode.
  • This was all added to my LED-Matrix library here: https://github.com/marcmerlin/LED-Matrix
    If you'd like to buy the tricolor matrix I used, here are some links:

  • specs: http://www.seeedstudio.com/depot/datasheet/2088RGBMatrix.pdf (sold here: http://www.seeedstudio.com/depot/8x8-RGB-LED-Dot-Matrix-Compatible-with-Rainbowduino-p-113.html)
  • http://www.seeedstudio.com/depot/8x8-RGB-LED-Matrix-Square-LED-Dot-p-1730.html seems to be common cathode (the opposite)
  • This is the same matrix I used, sold by sparkfun: https://www.sparkfun.com/products/683
  • only $5 from hobbyking
  • Again, the pictures don't do a good job showing the PWM values because of the CCD trying to capture a consistent amount of light. Also, anything close to white uses all 3 LEDs, this draws too much current from my arduino on the common anode. Before I add FETs or ways to improve current per line, it's still good enogh for demos. This setup uses 2 shift registers for 16 pins (blue and red), while green is connected directly to 8 pins, and 8 pins for common anode (which is where the current for 3 LEDs at once is lacking):



    generating circles with the Adafruit::GFX library
    generating circles with the Adafruit::GFX library


    Here's a video demo:

    Links to other pages about this topic:

  • http://learnpic32.blogspot.co.nz/2014/06/controlling-rgb-led-matrix-with-shift.html
  • http://francisshanahan.com/index.php/2009/how-to-build-a-8x8x3-led-matrix-with-pwm-using-an-arduino
  • http://www.instructables.com/id/64-pixel-RGB-LED-Display-Another-Arduino-Clone
  • http://www.seeedstudio.com/wiki/60mm_square_8*8_LED_matrix_-_super_bright_RGB
  • https://www.sparkfun.com/tutorials/201
  • Sparkfun offers a hardware backpack: https://www.sparkfun.com/products/760 with code here: https://github.com/fornellas/SFRGBLEDMatrix
  • http://playground.arduino.cc/Main/LEDMatrix

  • More pages: May 2018 April 2018 January 2018 June 2017 April 2017 January 2017 February 2016 January 2015 September 2013 January 2012 December 2011 May 2011 January 2011