Since my last post, there have been many great improvements to Micah’s Fadecandy project and the “fcserver” application I ported for Atheros-based OpenWRT devices. I didn’t really keep up with things and only just released builds with the newer versions. They’re at the same download URLs, just in release2. https://github.com/nemik/fadecandy-openwrt/releases/tag/release2

To keep this from happening again, it seems like a good idea to show people how to make their own OpenWRT builds with “fcserver” and other things they might want. The buildroot for OpenWRT is simple but can still be a challenge sometimes.
That’s why the Vagrant http://www.vagrantup.com/ virtual machine helper is so awesome. It makes using virtual machines very easy on just about every platform. Unfortunately the complete Vagrant box with OpenWRT buid-root is over 2.7GB and is too much for me to host here for download. If anyone wants to help with this, please get in touch.
But in the meantime, I’ll show you how to do the same thing yourself.

1. Download and install Vagrant for your OS from http://www.vagrantup.com/
2. Set up a Debian-Wheezy-based Vagrant box. Download “Debian Wheezy 7.2 amd64 (VirtualBox Guest Additions 4.3.0) (2013/10/19)” from http://www.vagrantbox.es/
3. Save this to some directory for this project, call it “openwrt_vagrant”
4. Run vagrant box add fadecandy-openwrt debian-7.2.0.box to add the box
5. Download my Vagrantfile from http://nemik.net/x/Vagrantfile into the directory. This is the config for it, it will make the virtual machine run on IP “192.168.44.10”
6. Run vagrant init fadecandy-openwrt to initialize the box
7. At this point it should be all set up, so let’s start the virtual machine with vagrant up
8. The box should come up successfully, and when it does, SSH into it with vagrant ssh. You can also do this by doing: ssh -i ~/.vangrant.d/insecure_private_key vagrant@192.168.44.10
9. Now we’re inside the Debian system! We should update it with sudo apt-get update and then sudo apt-get upgrade
10. The upgrades will require a restart of the box. Exit from it with Ctrl+d or the exit and then shut down the vagrant machine with vagrant halt. Then start it up again with vagrant up and SSH back in like in step 8
11. When SSH’d back into the box, let’s install the build dependencies needed for building OpenWRT. sudo apt-get install subversion build-essential git-core libncurses5-dev zlib1g-dev gawk
12. Now let’s get OpenWRT source with git clone git://git.openwrt.org/openwrt.git
13. Go into the new source directory with cd openwrt
14. Add my package to the feeds. Edit the “feeds.conf.default” file with vim or nano and add the line “src-git fadecandy git://github.com/nemik/fadecandy-openwrt.git” to the file
15. Update and install the packages from the feeds by running ./scripts/feeds update -a followed by ./scripts/feeds install -a
16. It’s now time to set up the OpenWRT build configuration. Run make menuconfig
17. In the menu, change your “Target Profile” to the device you’re targeting, like say a TP-Link TL-MR3040
18. Turn off the firewall too so we don’t have to open more ports. Go to “Base System” and press space until “firewall” isn’t selected anymore.
19. Go to “Utilities” and scroll down to “fcserver”. Press space on the option until it’s a star “*” and then exit from the menu and save it.
20. Download some static files to go into the OpenWRT OS from http://nemik.net/x/openwrt-fc-files.tar.gz. Run wget http://nemik.net/x/openwrt-fc-files.tar.gz and then tar xzvf openwrt-fc-files.tar.gz These file set up the default root password, wifi access point, and things like that.
21. Now to finally do the build. For this, just run make
22. That should be it! If this finished successfully, you’ll have a build in “bin/ar71xx/” with the name “openwrt-ar71xx-generic-tl-mr3040-v2-squashfs-sysupgrade.bin” just like the ones I’ve been releasing.

I recently discovered Micah’s awesome Fadecandy USB controller for WS281x LED pixels. One of the things that I like the most about it is its “fcserver” to control LED pixels using Websockets. That is fantastic, but all implementations I’ve seen have people running it on a RaspberryPi or regular PC.

I wanted to create a sort of “stand-alone” and embedded version of this using less expensive TP-Link routers, running OpenWRT. My current favourite of these is the TP-LINK TL-MR3040 but it would work just as well with the infamous WR703n or others; so long as they have USB support.

To do this, I created an OpenWRT package of the fcserver code: https://github.com/nemik/fadecandy-openwrt
You can add this to your own OpenWRT build by adding the line src-git fadecandy git://github.com/nemik/fadecandy-openwrt.git to your “feeds.conf.default”. Then run ./scripts/feeds update -a, then ./scripts/feeds install -a. Then run make menuconfig. Select “fcserver” from “Utilities” and your target architecture/device. Then run make

The defaults are:
* root password is “root”
* Open wifi access point called “Fadecandy” is broadcast. You can connect to it and get an IP
* The ethernet port is configured to accept DHCP leases, so if you plug it into your local router, it can give it an IP and you can get to it remotely then

That’s it. Then just plug in the Fadecandy USB device into your OpenWRT device’s USB port. It should detect it. Then you can connect to its “Fadecandy” access point over Wifi and visit “fadecandy:7890″ to get to the Fadecandy server interface.
Unfortunately, my WS2812 LEDs and Fadecandy controller have not yet arrived, but I do have a Teensy3. When I flashed it with the Fadecandy firmware version 1.07 (using TeensyLoader) it worked and blinked to identify itself from the web UI!
So I think that means it is working? If anyone could try it out with their pixels, please let me know how it works out for you. I hope performance is alright. Otherwise, I’ll be reporting back on it once my equipment arrives.

I like this approach because the OpenWRT units are very cheap, small, low power, and provide great connectivity. They also use a 5V source like many LED pixel strings, so they can be more easily integrated and embedded into art pieces and installations.

I had a problem recently where I wanted to whitelist a set of IPs (and that set may change anytime) to allow them to use a reverse-proxy on Apache in an RHEL (Red Hat Enterprise Linux) environment. Here’s some instructions on how to do this yourself.

1. So the first step is to edit your Apache config. I was doing this in an SSL context so I edited the /etc/httpd/conf.d/ssl/conf file and put this in the VirtualHost part:RewriteEngine On

The first line turns on Apache’s Rewrite module, this is required for this setup to work. Then it creates a RewriteMap called ‘ipslist’ located at /var/www/whitelist.txt. I advise putting this in /var/www because if done in some other /home directory, it won’t work with SELinux enabled as it won’t allow Apache to access files there. Chmod’ing the whitelist.txt to 664 is a decent permission.

2. Create your whitelist. This is the “/var/www/whitelist.txt” file. For this, just put in the IP you want whitelisted followed by a space then “white”. Then the next IP on the next line.
So a sample one could be:192.168.1.1 white
55.44.33.22 white
and so on.

3. Restart Apache, just do “sudo /etc/init.d/httpd restart”

4. That should be it! All the rest of your config can be as it is, including proxying functionality or whatever because the URL rewriting happens before all that.

The nice thing about the “RewriteMap” function is that you can change the whitelist.txt anytime you want and you don’t have to restart or reload Apache! It’ll automatically pick up on the change from the file’s changed date and update it.

I used the awesome miranda-upnp Python library to explore the device. Its URL for listing services is at http://10.22.22.1:49152/setup.xml

There are ones for “rules”, “remoteaccess”, “metainfo”, “WiFiSetup”, “firmwareupdate”, “timesync” and “basicevent”.

The most interesting one, I’m guessing, is “basicevent” because it contains an action called “SetBinaryState” and “GetBinaryState” on top of others like “GetSerialNo”, “GetMacAddr” etc. But the BinaryState thing looks cool because I’m guessing it is what is used to control the switch.

Unfortunately, sending commands/actions to this service always returns a 500 error, with error code -111 is “Invalid Service” although from all indications I am sending the SOAP request to the proper URL and service. I tried it manually and through miranda-upnp, same results.
At this point I think it is a header I might be missing, perhaps the “User-Agent”? And without the one the device is expecting, it will reject with a 500?

I unfortunately don’t have an iOS device to test with. Has anyone with an iOS device and Belkin Wemo sniffed the traffic between them? If I can get my hands on one, next step would be use Ettercap and Wireshark on that same wifi AP to see what the iOS app is sending that I’m not.

Interesting that it runs Linux though! I’d like to open it up to see the type of chips used inside but I do not have the triangular screwdriver for Belkin’s weird security screws on the device. If/when I order some and get it opened, I’ll post pics.

The next step is to borrow an iOS device and see if I can sniff the traffic for initializing the device. If anyone has done something similar or has any tips, please let me know.

With more debugging, it turns out the “mmc_read_switch” function in the “drivers/mmc/core/sd.c” file was returning an error -145 with that SD card. Not sure why, either the CARD doesn’t support it? I can’t even find that error code anywhere so not really sure what the root reason is.
BUT when just doing a “return 0;” there, the SD card ends up mounting perfectly and working quite well.

This same SD worked in kernel 2.6.30 but its “mmc_read_switch” function was simpler and probably didn’t try to read all the extra info that the 3.3+ one is and erroring out on. Not getting this info didn’t seem to impact anything much.

I hope this helps someone if they’re looking for a fix for a similar issue.

I also wanted to get the KillerBee framework working. Contrary to what the KillerBee documentation says, you don’t really need an AVR JTAG ICE whatever $300 programmer. It works just fine the Atmel AVR Dragon which is only $50 USD.

What’s cool about them is that with the OpenWRT (https://openwrt.org/) Linux operating system, you can make this router do whatever you want, including broadcast a Wifi access-point, run Linux applications, etc. The REALLY cool thing is that it has a fully working USB port too! This means you can connect various devices to it such as USB storage, Arduinos, Launchpads, etc and even multiples of them on hubs.

It is designed to make the TL-WR703N talk directly to Arduino’s and MSP430 Launchpad microcontroller kits by simply plugging in the kits into the USB port. Older Arduino’s will use FTDI drivers and make a /dev/USB0, new Arduino UNO’s make a /dev/ttyACM0, and TI’s MSP430 Launchpads make a /dev/ttyACM0 device. You can talk serial to them all directly then!
Just set the baud rate by doing something like:

stty -F /dev/ttyUSB0 raw speed 9600

and replace /dev/ttyUSB0 with /dev/ttyACM0 for Arduino UNO’s and TI Launchpad kits and 9600 with the baud rate you programmed your kit/sketch to.

This is not bad to use if you know your way around Linux. I disabled wireless on it and by default it listens for telnet until you set a root password for SSH with ‘passwd’.
Its subnet is 192.168.3.1 and if you plug a computer into its LAN port, it should issue an IP by DHCP on the 192.168.3.x subnet.

I hope it is useful for someone.

For an example, I used it to help a friend with an interactive art installation. It’s an art installation in Chicago called “Hatchery”. The website for it is here: http://www.popupartloop.com/active.php?id=123
It’s a sculpture inside a glass building with two photosensors on the outside measuring light. When a person places their hand on one of the sensors, it detects it because the difference between them is greater than some threshold (ADC’s are needed for this part) and then as the hand is held there, it starts a cool LED light sequence. If we make a video for it, I’ll post it here later.
Anyway, what also happens is that when the hand is placed there, the Arduino sends a serial string with something like “Touched!”. A program running on the WR703n (to which the Arduino is hooked up with over USB) listens for this and when it gets it, logs it to an SQLite database that resides on a large USB stick. The router also broadcasts a wireless access point that I can connect to from my Android phone and hit a certain URL to download that SQLite DB whenever I walk by. It’d be nicer to make it available direct on the internet but there are no public access points in the area for it to connect to.
Then I take the SQLite DB and do some queries on it to do a few simple analytics such as how many people touched it at what times, hours, days, etc. The analytics page is available here: http://nemik.net/hatchery/

I hope it’s some inspiration make your own networked devices using Launchpads and these unbelievably cheap yet powerful Linux machines.