This time I am definitely sure it works with 3.7

So everytime I think I have my Smartnet Recorder working with GnuRadio 3.7, I find another bug. This time it had to do with having the control channel to the far edge of the sample range. The control channel was around 854.86MHz, the center was at 858MHz and the sample rate was 8Msps. This put the control channel at the edge of sample but still in range. It worked for a bit, but it would not consistently receive trunking messages. Switch the center to 856MHz fixed it!

Anyhow…. now it will definitely work with 3.7! For Sure!

Pi + Node = Interactive, Internet Connected LED Message Board

While it is great to have the latest headlines up on your message board, it is even better being able to add in a message about how thankful you are that it is Friday. The final touch for my LED Message Board project was to add in a web page that made it easy to update messages. Of course, giving your friends a way to post Star War jokes on your message board only makes it more fun, so I added a Wifi and used HostAP to make the Raspberry Pi look like an access point. To make it even easier to post, I made the Message Board web page a captive portal. So now all one of my co-workers has to do is try and join the “Message Board” Access Point with their iPhone and they are brought to the webpage that lets them add and delete messages. Finally, since it is all Node based and I wanted to play with Socket.Io, I made the message list update in realtime. Now when new messages are added or the ESPN Headline is updated, everyone viewing the webpage gets to see it change.

The Code for this is up here.

Check out how I wired/coded everything and created a Node module to write to it.

I have the LED Modules mounted in a wooden case that is held in my office door frame using magnets. It is positioned so that it shows through the frosted glass next to my door. These picture probably explain it better:

IMG_7794

IMG_7796

Let me know if you do anything cool with signs like this or any HT1632 LED Matrix!

 

 

C++ Node JS Module for SPI Bus LED Signs

In the past couple of posts, I have documented how I built a LED Message board using some modules from Sure Electronics and then wrote a C program to scroll messages across it. This of course cool, but to really make it insteresting you need interesting messages to scroll. To get interesting messages you have to get connected. Since the Raspberry Pi is Unix based, you could easily start piping programs togther. I wanted someting a little more complicated though so I decided to write a Node JS program. In order to write to hardware devices like the Message Board you need to put together a Module and most of the time it will have to have some C++ code to do it, and that is a exactly what I did.

Node JS is an Ascrynous Programming langauge. This means that there is generally only one thing happening at a time and you wait for it to finish before doing the next. If you need to something that might take a long time, (Blocking in Comp Sci terms), you pass it a function to call when it is done and then go onto the next item.

For my module I started with the C program I had written and converted it into a C++ class. Node JS is based on the Google V8 Javascript engine, which is written in C++. Once I the C++ class written, I wrapped it so that it could be used in Node. This was actually pretty tricky to do. The V8 engine has a lot of specialized Macros and structure to help with memory management. My module also had to support running in background so that it could scroll a message without stopping the other things the main program needed to do. Again, this was a bit tricky because you had to make sure you working with only items that would be available in the background context. I don’t have any advice to offer other than Google around a bit.

The final tid-bit is that I wanted to add in support for Events. For me Events made it easier to write a program around instead of using Call Back functions. However for this to work, I couldn’t create a pure C++ module because the Node JS events are Javascript based. In order to get this I had to create a small Javascript wrapper around my custom C++ code that inherited the Event Emitter class.

The basic structure for the overall program is:

  1. Create an array of message you wish to display
  2. Create a function that is tied to the Scrolling Complete event from your Message Board, and will start scrolling the next message in the array. Also update the Array with any new messages.
  3. Start scrolling the First message.

Of course the whole point of doing this was to scroll interesting messages from the Internet. To get those “interesting messages”, I built a couple of tiny Node Module to pull NPR and ESPN Headlines.

So there you have it! A simple way to scroll messages off the Internet and impress (annoy) your co-workers.

Here is the code:

  1. Pi-Led: GithubNPM
  2. espn-headlines: GithubNPM
  3. npr-news: GithubNPM

Raspberry Pi to LED Message Board via SPI

While hooking up my Sure LED Matrix up to my Raspberry Pi using USB worked… it could work better. Using the Driver board from Sure, you can only scroll character by character which doesn’t look that smooth. So instead of using the driver board to interface with the matrixes, I directly connected it to the Raspberry PI so I can control things at the pixel level.

The Sure Electronics LED boards use the HT1632C driver chip. You communicate with the chip using SPI. The RPi natively supports SPI right out of its GPIO port. SPI simply defines the low level electronic communication, in order to talk to the HT1632, you need to use specifically crafted messages, and this takes some programming.

Before we get to that, lets talk about how to wire the LED Matrices together and connect them to the RPi. The Matrices are connected together with 16 wire ribbon cable. All of the boards are connected together serially and then the first board is connected to a bread board you have connected to your RPi. Each LED Matrix has a dip switch on the back that lets you set its ID, (1-4). In the Ribbon cable there are 6 important wires for communicating. There are 4 chip select wires, a clock wire and a data wire. Each of the chip select wires corresponds to one of the Matrix IDs. When you set a chip select wire high, you are communicating to that board. The Data and Clock wires are used to do the communicating.

The only problem is that the RPi only has 2 SPI chip select lines and you have 4 Matrices you need to communicate with. Ugh! I had no idea what to do, so I posted the question on the RPi forum and got a couple of good solutions. It turns out the way you get around this is by using a multiplexer that is controlled separately by some of the other GPIO pins. The simplest approach is to use the 74HC139. It uses 2 lines to select between 4 different output lines, with only 1 being high at a time. The chip actually contains 2 multiplexers, so with one chip and 4 lines, you can have 8 output lines. If you are going to be outputting to more lines, it looks like the 74HC595 is the way to go. It is a little more complex to interface with, but if you chain them together, you can have tons of output lines. Here is how I wired everything up:

Message_Board

I got a couple of parts from AdaFruit to make it easier to put everything together:

With all of this, it was really easy to wire things together. The Pi Cobbler took a little soldering, which was fun. I order the IC and the parts to make a ribbon cable from Mouser:

There is one thing I am still not sure of… how long can the ribbon cable can be. I originally went with a 12′ cable. It was being a little glitchy though, so I now have it down to 6′ and it seems to be working good. You will also need a good 5v power supply to power the LED Matrices. If all four are going, it could pull about 1200MA. I borrowed one from a USB hub. The Female DC Socket from Adafruit, makes it easy to attach a salvaged power supply. Once you have this wired up, it is time to start programming. To keep things simple you could just start with 2 displays and use the 2 chip select lines built into the RPi. The programming is pretty simple. The WiringPi project helps get you start using GPIO lines and SPI.

Once you have everything wired up, it is time to start programming. In order to make the LED Matrices do aynthing you need to send message over SPI. The messages are a series of different patterns of bits. To send a Command to a matrix, you start a message out with the bits: 1-0-0 followed by a number that represents command you want to send (in binary) followed by the setting for that command. To Write data to a matrix, you start a message with the bits: 101 followed by the matrix’s memory address you would like to and then the pixel data you would like to write.

The matrix’s addresses start in the upper left hand corner at 0. Each memory address covers 4 pixels. The 0 address covers the top 4 pixels in the first column. Address 1 covers the bottom 4 pixels of the first column. Address 2 covers the top 4 pixels of the second column from the left, and so on.

Of course having to specify all these addresses would slow things down if you are trying to fill an entire screen. Instead, you can also specify an address you wish to start writing from and then continue to write pixel data to fill in sequential sets of pixels after the one you have addressed. So if you want to write the data for an entire matrix, you start at address 0 and write out all the data.

There are of course a few wrinkles. The first is Endian stuff. Endian determines the order in which the bytes in multibyte variables get stored. When you are constructing Messages in memory using memcopy and then passing the address to the SPI function, Endianess doesn’t seem to be a problem. However when you are construct individual message inside a Word, (which is 2 bytes) and then passing a pointer to the variable’s memory, Endianess becomes a problem. In order to make this work right you have to first write to the variable and then swap the order of the 2 Bytes which make up the Word. Confusing. Long story short, if things are not working, it could be this endian stuff.

The other thing that comes up is that some of the message don’t easily fall across 8-bit boundaries. This generally isn’t a problem and you just end up sending some extra 0s padded on the end of your message. However, when you are trying to write the long blocks of pixel data to a matrix, this is a problem. To construct this message, you have to first write to the message the bits: 1-0-1, followed by the bits: 0-0-0-0-0-0-0 to signal that you want to write to the first address. Now you can just copy your pixel data from where it is cached in memory to the spot in memory where you are constructing this message. The problem is that with the standard functions in C, you can only specify memory copies based upon 8-bits, and with this message you are starting 10-bits in. The solution is to find a way to do bit-level offsets when copying. Doing this is a pain and tricky to do efficiently. Luckily I found a bit of code that explains this.

I have all the code for this up online here: https://github.com/robotastic/SPI-LED-Print It is not pretty, but it should give you a general idea for how to write to an LED Matrix using SPI and using the GPIO pins to multiplex the output. I used this code as the basis for building a C++ NodeJs module that does this. I will post more on that next.

20130213-225418.jpg

20130213-225508.jpg

20130213-225545.jpg

Using Node.JS behind a proxy

I have my Raspberry Pi setup at work and it is stuck behind a proxy. Here are some helpful tips I have found from across the web:

 

Requests from Node

var http = require("http");

var options = {
  host: "proxy",
  port: 8080,
  path: "http://www.google.com",
  headers: {
    Host: "www.google.com"
  }
};
http.get(options, function(res) {
  console.log(res);
  res.pipe(process.stdout);
});

For HTTPS, Try this:


var http = require('http');

http.get ({
    host: '127.0.0.1',
    port: 8888,
    path: 'https://www.google.com/accounts/OAuthGetRequestToken'
}, function (response) {
    console.log (response);
});


In order to use NPM, try something like this:

  1. I run this command: npm config set strict-ssl false
  2. Then set npm to run with http, instead of https: npm config set registry "http://registry.npmjs.org/"
  3. Then I install packages using this syntax: npm --proxy http://username:password@cacheaddress.com.br:80 install packagename

Skip the username:password part if proxy doesn’t require you to authenticate

or this:

npm config set proxy http://proxy_host:port

or this:

npm --proxy http://proxy-server:8080/ install {package-name}

 

 

Approving Eye-Fi Facebook Uploads

I got a Eye-Fi Wifi SD Card for Christmas. It works great on my Canon 5d3 and gives me the wifi uploading that Canon should have baked in from the start (they added it into the cheaper 6d, ugh!). It can upload to a number of online services, including Facebook. I set it up and had it working for the first few uploads, but after that it stopped posting to Facebook. Everything showed up fine in the online Eye-Fi gallery, but nothing went to Facebook.

They are a couple of things you might have to check to get it working. First, make sure the privacy/sharing for the album you are uploading to is set to atleast Friends. Also check the Album, I had a bunch of photos I had to “Approve” because they were uploaded by an App. Hopefully that goes away after I approve it a couple of times. Then goto your settings, then Apps, and then the Eye-Fi App and make sure its privacy/sharing is set to atleast Friends.

It is working flawlessly and it is so cool to be able to hit one button on my DSLR and have it automatically post to Facebook. It is even easier that on the iPhone. I remapped the Rating button to be Protect in order it make it super easy.

Raspberry Pi

I recently got a Raspberry Pi. It is awesome. I am going to use this post to keep track of everything I have done to get it setup.

Config program:

  • Expand filesystem to size of SD card
  • Set locale to EN(us) UTF8
  • Enable SSH

Add proxy to apt-get:

  • sudo su
  • echo 'Acquire::http::Proxy "http://yourproxyaddress:proxyport";' > /etc/apt/apt.conf.d/10proxy

Update & upgrade:

  • apt-get update
  • apt-get upgrade

Emacs:

  • apt-get install emac

Enable system proxy

  • emacs /etc/environment
  • export http_proxy=”http://username:password@host:port/”

I was having trouble SSHing from my Mac and kept getting this error: “Host key verification failed.”

Doing this helped: ssh pi@<ip-address> -o StrictHostKeyChecking=no

WP_List_Table and an Extra Nonce

I am working on a WordPress plugin. For part of it I am adding a Metabox onto the Post Edit screen in the admin section. However things stop working if I add a WP_List_Table. That is because by default the list table adds a _wpnonce field, even though there is already one there for the Edit page.

This of course messes things up and prevents you from saving or updating. Not awesome. The field is output in the display_tablenav() function in the base list_table class. It looks like there has been a fix submitted, lets hope it gets into an upcoming version.

Until then, you can simply override the display_tablenav() function with a blank function or one that provides similar functionality.

Tilestream: Fixing interaction

When I upgrade to a new version of Tilestream / Wax, apparently the method for adding interactivity change. Before I think it pulled some of the info from a JSON file. It can still do this, but my files seemed to include localhost versions of the server. Anyhow, long story short, you need to make sure you specify a template in your TileJSON. To find this, request the TileJSON Tilestream serves up for your made:

http://server/v2/layer_name.json

Now look for the template variable and add it into the TileJSON you define in your javascript file. Mine is:

template: ‘{{#__location__}}{{/__location__}}{{#__teaser__}}{{{name}}} </br>\n{{{address}}}{{/__teaser__}}{{#__full__}}{{{permit_id}}}{{/__full__}}’,

Tilestream: Tiles not found

I just upgraded to a newer version of Tilestream. Unfortunately after doing that, all my maps stopped working. When I went to my Tilestream UI, I was able to see that it was up and it was finding the MBTILE files. When I clicked on info, it became clear that the URL had changed. Instead of having it be server/1.0.0/map it was now server/v2/map.

However after fixing my URLs, it still wasn’t working. Turns out I also needed to switch the mapping scheme from TMS to XYZ in the tilejson. Definitely not a seamless upgrade and I didn’t really see this change documented anywhere. I am still trying to figure out what I need to change to make interactivity work.

http://support.mapbox.com/discussions/tilestream/59-tiles-not-displaying-on-map

In your tilejson object, try changing the scheme to xyz instead of tms and let me know if that fixes the problem.