On the train back from NYC to Pittsburgh, I got the idea to hook up the LoL Shield directly to my computer, so that I could develop animations for it using a desktop graphics program. Using Jay Clegg’s Video Peggy project as a starting point, I wrote up a little framebuffer sketch for the Arduino, along with some Processing code to grab a region of the computer screen, scale it, and send it over to the LoL Shield for display. Pretty simple, but could be useful. Source code is after the break. A version of this project might be included with the next LoL Shield library release.

import processing.serial.*;
 
LolShieldBuffer lolShield;
PFont fontA;
 
void setup()
{
  size(14, 9);
 
  // Load the font. Fonts must be placed within the data 
  // directory of your sketch. A font must first be created
  // using the 'Create Font...' option in the Tools menu.
  fontA = loadFont("LucidaSans-9.vlw");
 
  // Set the font and its size (in units of pixels)
  textFont(fontA, 9);
 
  // I know that the first port in the serial list on my mac
  // is always my  FTDI adaptor, so I open Serial.list()[0].
  // On Windows machines, this generally opens COM1.
  // Open whatever port is the one you're using.
  String portName = Serial.list()[0];
  print(portName);
  lolShield = new LolShieldBuffer(this, portName);
}
 
int i = 0;
 
void draw()
{
  background(0);
 
  fill(255);
 
  text("The time is now " + hour() + ":" + minute(), i, 8);
 
//  lolShield.sendWindow(mouseX,mouseY, 14, 9);
  lolShield.sendWindow(0,0, 14, 9);
 
  i--;
  if (i < -130) {i = 14;}
  delay(50);
}

You want to put this code on your Arduino:

#include "Charliplexing.h"
#include "Font.h"
#include "WProgram.h"
 
// Inspired by Video Peggy:
// http://www.planetclegg.com/projects/QC-Peggy.html
 
void setup()                    // run once, when the sketch starts
{
  Serial.begin(115200);
 
  LedSign::Init(DOUBLE_BUFFER);
//  LedSign::Init();
}
 
int state = 0; 
int counter = 0;
const uint8_t DISP_BUFFER_SIZE = 9*2;
 
void loop()                     // run over and over again
{ 
  while( !Serial.available()) {}
  uint8_t c = Serial.read();
 
  // very simple state machine to look for 6 byte start of frame
  // marker and copy bytes that follow into buffer
  if (state < 6) 
  {
 
    // must wait for 0xdeadbeef to start frame.
    // note, I look for two more bytes after that, but
    // they are reserved for future use. 
 
    if (state == 0 && c == 0x12) state++;
    else if (state ==1 && c == 0x34) state++;
    else if (state ==2 && c == 0x56) state++;
    else if (state ==3 && c == 0x78) state++;
    else if (state ==4 && c == 0x1) state++;
    else if (state ==5)  // dont care what 6th byte is 
    {
      state++;
      counter = 0;
    }
    else state = 0; // error: reset to look for start of frame
  }
  else 
  {
    // inside of a frame, so write to the buffer
    uint8_t row = counter / 2;
    uint8_t col = (counter % 2)*8;
    uint8_t length = (col==0?8:6);
    for (uint8_t colOffset = 0;  colOffset < length ; colOffset++ ) {
      LedSign::Set(col+colOffset, row, c >> (7 - colOffset) & 1);
    }
 
    counter++;
    if (counter >= DISP_BUFFER_SIZE)
    {
      // buffer filled, so reset everything to wait for next frame
      state = 0;
      LedSign::Flip();
    }
  }
}

Put this code in a new tab in your Processing project, called LolShieldBuffer:

import processing.serial.*;
 
class LolShieldBuffer
{
  Serial serial;
 
  int ledWidth = 14;
  int ledHeight = 9;
  int ledFrameSize = 9*2;
 
 
  LolShieldBuffer(PApplet parent, String portName) {
    serial = new Serial(parent, portName, 115200);
  }
 
  void sendWindow(int x, int y, int w, int h) {
 
    PImage img = get(x, y, w, h);
//    img.resize(ledWidth, ledHeight);
 
    char[] frame = new char[ledFrameSize];
 
    // Grab a 14x9 window
    for (int row = 0; row < ledHeight; row++) {
      char buf = 0;
      for (int col = 0; col < 8; col++) {
        buf = (char)(buf << 1);
        buf |= (brightness(img.pixels[row*ledWidth+col])>127) ? 1:0;
      }
      frame[row*2] = buf;
 
      for (int col = 0; col < 6; col++) {
        buf = (char)(buf << 1);
        buf |= (brightness(img.pixels[row*ledWidth+8+col])>127) ? 1:0;
      }
      buf = (char)(buf << 2);
 
      frame[row*2+1] = buf;
    }
 
    sendFrame(frame);
  }
 
 
  void sendFrame(char[] frame) {
    byte[] magicNumber = {0x12, 0x34, 0x56, 0x78, 0x1, 0x0};
 
    serial.write(magicNumber);
 
    // TODO: Drop 9*2 magic number
    for(int index = 0; index < ledFrameSize; index++) {
      serial.write(frame[index]);
    }
  }
}

and get some code ready for the LoLing:

uint16_t ripple[][9] PROGMEM = {
 { 520 , 1028 , 2050 , 2050 , 2114 , 2050 , 2050 , 1028 , 520 , },
 { 2050 , 4097 , 4097 , 8256 , 8352 , 8256 , 4097 , 4097 , 2050 , },
 { 8192 , 8192 , 224 , 272 , 272 , 272 , 224 , 8192 , 8192 , },
 { 0 , 224 , 272 , 520 , 520 , 520 , 272 , 224 , 0 , },
 { 224 , 272 , 520 , 1028 , 1028 , 1028 , 520 , 272 , 224 , },
};

Here’s the python source, have fun! It requires Python and the Python Imaging Library (PIL):

#!/usr/bin/python
# Python script to convert a 14x9 pixel animated gif into a format that can
# be displayed on the LoLShield.
#
# Requires Python and the Python Imaging Library (PIL)
# It would be nice if this was available using a more common language.
 
import sys, os, Image
 
class ImageSequence:
    def __init__(self, im):
        self.im = im
    def __getitem__(self, ix):
        try:
            if ix:
                self.im.seek(ix)
            return self.im
        except EOFError:
            raise IndexError # end of sequence
 
# Open image
filename = sys.argv[1]
filenameBase = os.path.splitext(os.path.split(filename)[1])[0]
im = Image.open(filename)
 
# Print the variable declaration
print "uint16_t " + filenameBase + "[][9] PROGMEM = {"
 
# For each frame in the image, convert it to black & white, then into the
# LoLShield format
for frame in ImageSequence(im):
    # Convert to black and white
    converted = frame.convert("1")
 
    print " {",
    frameString = converted.tostring()
 
    # For each row in the image
    for row in range (0, 9):
        charA = ord(frameString[row*2])
        charB = ord(frameString[row*2 + 1])
 
        rowTotal = 0
        # Handle the first 8 bits
        for col in range (0, 8):
            shiftAmount = 7-col
            rowTotal += ((charA >> shiftAmount) & 1) * 2**col
        # Then the next 6
        for col in range (0, 6):
            shiftAmount = 7-col
            rowTotal += ((charB >> shiftAmount) & 1) * 2**(col+8)
        # And output the total for this row
        print rowTotal, ",",
    print "},"
print "};"

Over the past few days, I’ve been working on completing a project thats been on my mind for a while. The idea was to build a giant version of a MeggyJr RGB pixel game kit by Evil Mad Scientists, like what a big box store might use as a display unit in an alternate future where they sell cool electronics kits. The project has morphed a bit over time- originally, it was to be just a scaled up version of the handheld, complete with giant buttons and buzzer. I may still attempt that in the future, but for now the project consists of a large LED grid that works as a drop-in replacement for the regular-sized screen.

There’ still a reasonable amount of work to do on the project, but it’s getting closer, and this morning I was finally able to play the MeggyBrite program on a large grid . I still have to finish the enclosure and add a diffuser screen, however this seems like a good time to put up some documentation, so here goes:

There are three main components to the project: the RGB pixels, the laser cut enclosure, and the Meggy adapter board. Here’s an archive of all of the design material needed to make the board, and a short description of each component of the project.

RGB pixels

For whatever reason, I envisioned the display as being made up of a bunch of discrete pixel units, which would then be wired in a grid. Looking back, this is a pretty foolish way to build it (better would be to use larger breadboards, or pre-made modules like the ShiftBrite). Anyway, I had a whole bunch of 10mm LEDs, so I decided to design up a board to fix 3 each of the red, green and blue LEDs, forming a single RGB pixel. You need 64 of these for the whole array. I made them by hand using pre-sensitized PCBs, as explained in Collin Cunningham’s Circuit Board Etching tutorial. Thanks to Issac for helping me solder them together!

Adaptor Board

The adapter board is designed to plug into an unmodified MeggyJr, so that you can use it in portable mode with the regular screen, or go for the large screen edition at home. It has pass-through connections for each of the 24 column connectors, and a step-up driver on each of the 8 row drivers, allowing the Meggy drive hardware to control the higher voltage required to run the sign. Finally, it has an LM7805 chip to provide power to the Meggy. I didn’t draw up a schematic though, so you are on your own for this one .

Enclosure

The enclosure is meant to look like a large version of the 8×8 RGB display. I drew up a design in Inkscape, and my friend Brandon Barber laser cut it for me in hardboard. The basic form is right, but I had to make a bunch of modifications, so I’d suggest using the design files as inspiration only.

I’m planning to have the display set up at our Hack Pittsburgh table at Maker Faire Detroit, so you should stop by and check it out!

Bam! High-def version of the video is available here. The system looks like this:

So this is what we’ve been working towards this past week. The above video is a nonsense trajectory with all four axis moving at the same time, just to show that they work. The system itself seems to be functional, there are just a few more tasks- repeatability testing, retrofitting some optical end-stops, and putting the electronics in a nice box.

I think I might build another one of the xy tables to do machining with .

This is what I’ve been up to for the past few days. Making some stepper motor mounts to retrofit a manual xy table into a stepper motor version. It’s basically just some machined aluminum standoffs, with an aluminum mounting plate to mate the unit to the table, and a shaft coupler made of (guess!) more aluminum! Unfortunately, the motors that I had weren’t up to the task, so we put in an express order with Phidgets to get some steppers The project is stating to come together! More photos to come after I get my battery recharged.

Update: The timelapse video was captured at a rate of 1 frame per 3 seconds, and plays back at 30 FPS, so the ~1 minute video represents about 2 hours of work. Whew!

I’m building a RepRap Mendel 3d printer, using parts printed for me by my friend Marty on Makerbot 131, and hardware from ultimachine. Tonight’s project was to assemble all of the pieces that I could. I was able to get the X and Z stages built, mounted together, and roughly calibrated. The next steps are to get a build platform laser cut so that I can complete the Y stage, finish up the electronics so that I can control the machine, and decide on an extruder design so that I can actually use it to print. It’s starting to get exciting!

I made this little video to test the performance of the stepper drivers and rotary stage. The results are encouraging, except that I probably need attach the sample to the stage (it looked like it was vibrating around), and my flash ran out of batteries at the end (that’s why it gets darker). On the positive side, it was pretty easy to do- I just set the stepper to rotate at a constant speed on one direction, then put the camera into time lapse mode. I’ll try again tomorrow after recharging the flash batteries. The bit of glitchiness at the end is because the flash couldn’t recycle fast enough to fire on a few frames, so I showed the previous image twice to keep the motion constant.

I’m working on a project which involves mechanizing some machining tables. I decided to use some surplus stepper motors and A4983 stepper motor breakout boards from Pololu to control them. Getting them to work on a protoboard was no problem, so I decided to see if I could design and build a PCB to connect them in a more organized and robust fashion. Well, some hours and some chemical sniffing later, I had a board!

It has space to populate up to 4 of the Pololu stepper carriers, with a few pins left over. It’s in need of some bypass caps and input filtering, but there should be ample room between the power and ground circuit rails to add them.

Want to make one yourself? Grab the board artwork and design files, and the software from after the break.

Arduino board layout thanks to Garrett at Macetech.

UPDATE: Fixed a small bug in the code (can’t call delay() from an initialization function)

class stepper {
  uint8_t resetPin;
  uint8_t stepPin;
  uint8_t directionPin;

  long position;

 public:
  stepper(uint8_t resetPin_, uint8_t stepPin_, uint8_t directionPin_)
    {
      resetPin = resetPin_;
      stepPin = stepPin_;
      directionPin = directionPin_;

      pinMode(resetPin, OUTPUT);
      pinMode(stepPin, OUTPUT);
      pinMode(directionPin, OUTPUT);

      doReset();
    }

    void doReset() {
      position = 0;

      digitalWrite(directionPin, LOW);
      digitalWrite(stepPin, LOW);

      digitalWrite(resetPin, LOW);
      digitalWrite(resetPin, HIGH);
    }

    void moveAbsolute(long newPosition) {
      moveRelative(newPosition - position);
    }

    void moveRelative(long counts) {
      if ( counts > 0) {
        digitalWrite(directionPin, HIGH);
      }
      else {
        digitalWrite(directionPin, LOW);
      }

      unsigned long absCounts = abs(counts);

      for ( unsigned long absCounts = abs(counts); absCounts > 0; absCounts--) {
        digitalWrite(stepPin, HIGH);
        digitalWrite(stepPin, LOW);
        delayMicroseconds(1000);
      }

      position += counts;
    }

    long getPosition() {return position;}
};

stepper stepperA(10, 11, 12);
stepper stepperB(14, 15, 16);
stepper stepperC(7, 8, 9);
stepper stepperD(17, 18, 19);

void setup() {
}

void loop() {
  // Move one whole rotation and back
  stepperA.moveRelative((long)-200*16*36);
  delay(200);
  stepperA.moveRelative((long)200*16*36);
  delay(200);
}