Light Marquee

[Jim McGaw]

I spoke to the Michaels last Saturday, they are working on a light marquee comprised of 8x8 modules of (what might be) LED lights. They asked me to post a thread on here to discuss: there is some Python code that needs tweaking to map bitmap images to the modules. Can you guys debrief me on the task at hand regarding the software portion?

Cheers,

Jim

[Michael Kapuscik]

Righto. The overarching goal is to get some of that newfangled computer magic that you code monkeys possess to break down an image into an array of pixels. Now ideally we could just take the image and convert it to 2 bit color and be done with it, but due to some hardware restrictions (we only have 2KB of RAM on the sign driver and we need to control 6400 LEDs) that won't work. The way the controller is setup now is it has 2 arrays that it stores in RAM containing the values for the red and green LEDs separately. These arrays are 16x25 bytes, 16 being the number of rows and 25 being the number of 8x8 LED panels, or columns. The columns are grouped together in groups of 8 so we can represent 8 LEDs with a single byte (an LED can only be on or off on this display so it saves a ton of space). This is done by bitmasking the byte to an LED panel, meaning the binary form of a byte represents which LEDs are on based on the bits logical value and position. So decimal value of 1 or 0b00000001 would only light up the rightmost LED on that particular 8x8 module, where 129 or 0b10000001 would light up the left most LED and the rightmost. Right now I have no provision for transferring data to the sign driver other than rebuilding the source with the static array included, but this will change as we figure out the best way to feed the sign. Because I am just using firmware uploads to transfer image data, the python should be able to kick out C formatted 2D array initalizer. The output would be something like this:

 { {col1row1Byte, col2row1Byte, ... col25row1Byte }, {col1row2Byte, col2row2Byte, ... col25row2Byte }, ... { col1row16Byte, col2row16Byte, ... col25row16Byte} }

I know this is really a dirty way of going about this, but considering a few weeks ago that sign was sitting in the back of space broken and smelling like a fish monger, it's a pretty good start.

If you have any more questions or ideas just let me know.

[Eric Terry]

hmmm.....

do you have any examples of images you've displayed on it? I'd like to
get an idea of how the colors map and how intensity is handled when
going from a general image to the display


et

[John Gomm]

How the colors are handled?...badly, I'd guess. :) Sounds like a decent start tho.
Dr John

[Chad]

With two bits per LED, a bitmap should work as only 1600 bytes of RAM
are required.

[Michael Kapuscik]

Eric: All of the test images we have made, I mentally broke down the
image and converted them to the proper format and typed them in, so
unfortunately I don't have any examples prepared. I can make a
graphical guide on what I am doing if that will help.

John: There are only 2 LEDs per pixel, and they are non-dimmable
currently so the display is 2 bit color (red, green, orange, and
black). It should be possible to expand the color space by seriously
overdriving the clock to move data in super fast and rely on
persistence of vision to dim the available colors by inserting off
states between successive on states to produce a less intense color
that can be mixed, but that is something that will require a bit more
reverse engineering of the hardware. Somewhere there is a time
sensitive component, most likely a capacitor, that needs to discharge
to issue a screen blank pulse, and this is currently limiting our
maximum clock speed.

Chad: How did you arrive at 1.6K? I know we can compress the data a
bit more by combining the arrays, but I get 800B (16*200*(1/4 Byte)).

[Chad]

I keyed in on 6400 LED's, not realizing that was both colors.

[Michael Kapuscik]

This may make it clearer on how the colors map. Each of the binary representations at the bottom of the display represents the color for LEDs on one row of one module as they are 8x8 displays. To create this on our current display, the output would need to be 

red = {{232, 220 }, {0, 0}, {0, 0}, ... {0, 0}}

green = {{170, 189}, {0, 0}, {0,0}, ... {0,0}}