"Remember, what we are trying to do in this life is to shatter time and bring back the dead." - Winter's Tale, Mark Helprin

(1/3 of Tensor with operators)
Above: 1/3 of Tensor with operators

This page is about a program I wrote to control the Tensor LED Wall. It is dedicated to the engineer who constructed it, Kevin 'Frostbyte' McCormick, who is currently outside of the light cone. For more information on Tensor, see also the Artisan's Asylum wiki.

I'll be brief just to get it out there, but maybe I'll come back later and elaborate.

The program screams out a bunch of UDP packets across the local 10.something ethertube, which Tensor picks up and converts into light. It (the program) runs at ~15 fps on my machine, which is a 751MHz AMD thing with 1.2GB of RAM named "octopamine". A real monster. The frame rate is somewhat adjustable using the Frame Delay parameter, but is probably limited to ~20 fps max by the UDP communication. Tensor itself gets angry if you send packets at it too quickly (and goes blank if you send them too slowly), but I haven't set about truly characterizing this behavior.

This software was developed under an Ubuntu or derivative operating system. Most of what is required to compile / run it can be found by apt-getting. The cmake build process should let you know what you are missing.

I've placed a git repository of my dev tree up on GitHub. For those of you who like to download things, you'll find that here. The stuff below will make more sense if you know whats in there. Careful though, most files you get off the internet are probably a virus.

I have not distributed the project in binary form. If you'd like to run it, you'll have to compile it yourself. The process isn't too difficult if you're running some sort of Ubuntu. I've included instructions that should get you there in that environment.


I recommend starting out by making sure the following packages are installed on your system: 

sudo apt-get install build-essential cmake git pkgconfig
sudo apt-get install libsdl2-dev libsdl2-ttf-dev libsdl2-gfx-dev libsdl2-image-dev

Next, fetch a clone of the repository from github: 

git clone https://github.com/argyle77/tensorPattern.git

Set up your build and compile it in an out-of-tree build directory: 

cd tensorPattern
mkdir build
cd build
cmake ..
make

Run the binary from within the build directory. 

./tensorSDL

If you try and fail and want it really bad, or you just want to say hi or something, send an email to the address at the bottom of the page. Vitriol and spam will be relegated to /dev/null.


The source tree looks like this (but without the purple): 

      

        
tensorPattern/ - Root directory

        
  README.txt - Build instructions.

        
  Versions.txt - Version notes.

        
  CMakeLists.txt - cmake build control file.

        
  NOTICE - Component licensing.

        
  fonts/ - Font directory.

        
    DroidSansMono.ttf - Font used in the gui.

        
    DroidSansMono - LICENSE.txt - Font License.

        
  media/ - Images, maps, and default save files.

        
    Fbyte-01.jpg - Picture of FB.

        
    tensor-dawn-2003c.jpg - Picture of Tensor at burning man.

        
    tensorIP.map.default - Default ip addresses.

        
    tensorPixel.map.default - Default pixel map.

        
    *.now - Saved pattern sets to be auto-loaded at startup.

        
  src/ - C source directory.

        
    CMakeLists.txt - cmake build control file.

        
    kinet.h - Bayard gave me this. Lots of cool magic numbers.

        
    drv-tensor.h - Bayard gave me this. Part of the UDP driver.

        
    drv-tensor.c - Bayard gave me this. Part of the UDP driver.

        
    my_font.h - A bitmap font for scrolling across Tensor.

        
    tensorSDL.c - The pattern generators. Source of main().

        
    version.h.in - Version include file used by cmake.

The code was written on and off over the course of seven years to serve a function. I haven't gotten around to cleaning it all up for an audience, so there may still be some disturbing bits floating around in there. I am willing to talk about it, if that would help.


Screenshot:
(Screenshot of running program)

Control is achieved by clicking on, spinning the mouse wheel over, or pressing the keys associated (as illustrated in the screenshot) with a particular command. Simple array manipulation mode flags can be turned on or off. They combine with each other (some better than others) to form a set of adjustments that are made to each frame of the animation to produce the next frame. Coefficients for some of those manipulations can be adjusted. It is not so much an automated pattern generator as a means by which to combine simple functions into more complex patterns. However, for less interactive input, it can be made to cycle through the 10 pattern sets in memory at a specified interval. The text buffer is manipulated by typing without modifier keys, erased off the end with backspace, or erased entirely with delete. To scroll text on the display, both the Text seed and the Scroller must be set to YES. If you get confused, CTRL-L is handy for turning all the mode flags off. The display can also be drawn on directly by clicking on the previews with the mouse.

As of this writing, I've only ever seen this code run on 1 of the 3 panels (the center one as seen in the photo at the top). To produce coherent output on the panels, it may be necessary to edit tensorIP.map or tensorPixel.map to adjust for the fact that Tensor is never assembled the same way twice.