Since it was possible I spent an hour or two writing a quick shell script which can convert ducky script payloads into a sketch suitable for uploading to the LeoStick (or any arduino that has USB-HID capability)   The end result is a small bash script which can be downloaded from compile_payload.sh

Usage is fairly simple – you run the script with two options – the first being the payload file, and the second being the arduino script output.

ie: compile_payload lock_prank.txt lock_prank.ino

Various payloads can be found linked from the USB-Rubber-Ducky wiki

As a bit of fun I changed the lock_prank payload to work on Gnome/Linux and it also plays the mission impossible theme once done
Grab it from lock_prank.ino

Also note that to get this working you need to edit the arduino libraries so that the sendReport function is marked as public.

To to this edit the USBAPI.h file which can be found in ${ARDUINO_DIR}/hardware/arduino/cores/arduino directory.
This may be /usr/share/arduino/hardware/arduino/cores/arduino/USBAPI.h or similar
If you installed the LeoStick board stuff from their website then it will be under your sketches directory as hardware/LeoStick/cores/arduino/USBAPI.h

Open that file and find

private:
    KeyMap* _keyMap;
    void sendReport(KeyReport* keys);
    void setKeyMap(KeyMap* keyMap);
public:
    Keyboard_();
    virtual size_t write(uint8_t);

Then change that to

private:
    KeyMap* _keyMap;
    void setKeyMap(KeyMap* keyMap);
public:
    void sendReport(KeyReport* keys);
    Keyboard_();
    virtual size_t write(uint8_t);

Then everything should work fine.

Watch this video on YouTube.

For the hardware I mounted the displays on a wooden frame (hold on by hot-glue) and then routed power down each side and signal was daisy-chained from bottom-right (bottom-left in photo) to each display.

Source code below:

/*---------------------------------------------------------------
 Includes
 ----------------------------------------------------------------*/
#include <SPI.h>        //SPI.h must be included as DMD is written by SPI (the IDE complains otherwise)
#include <DMD.h>        //
#include <TimerOne.h>   //
#include "Arial_black_16.h"
//Fire up the DMD library as dmd
DMD dmd(2,3,1);

long mDelay=30;
long timer=-1;
long oldtimer=-1;
int centreX=32;
int centreY=24;
int trans=0;
int i=0;

/*--------------------------------------------------------------------------------------
 Interrupt handler for Timer1 (TimerOne) driven DMD refresh scanning, this gets
 called at the period set in Timer1.initialize();
 --------------------------------------------------------------------------------------*/
void ScanDMD()
{
  dmd.scanDisplayBySPI();
}

/*--------------------------------------------------------------------------------------
 setup
 Called by the Arduino architecture before the main loop begins
 --------------------------------------------------------------------------------------*/
void setup(void)
{
  randomSeed(analogRead(0));
  //initialize TimerOne's interrupt/CPU usage used to scan and refresh the display
  Timer1.initialize( 5000 );           //period in microseconds to call ScanDMD. Anything longer than 5000 (5ms) and you can see flicker.
  Timer1.attachInterrupt( ScanDMD );   //attach the Timer1 interrupt to ScanDMD which goes to dmd.scanDisplayBySPI()
  //clear/init the DMD pixels held in RAM
  dmd.clearScreen( 0 );   //true is normal (all pixels off), false is negative (all pixels on)
  dmd.selectFont(Arial_Black_16);
  dmd.setupBuffer(3);
}

/*--------------------------------------------------------------------------------------
 loop
 Arduino architecture main loop
 --------------------------------------------------------------------------------------*/
void loop(void)
{
  lookaround();
  dmd.setBufferEdit(0);
  smile();
  dmd.setBufferDisplay(0);
  delay(1000);
  wink();
  delay(300);
  dmd.copyBuffer(2,0);
  dmd.setBufferEdit(0);
  dmd.setBufferDisplay(0);
  char stringa[]="Happy Birthday Lucas";

  dmd.drawMarquee(stringa,strlen(stringa),64,16,0xFF,0);
  while (!dmd.stepMarquee(-1,0)){delay(30);}

  dmd.setBufferEdit(1);
  dmd.clearScreen(0);
  dmd.drawString(8,0,"Happy",5,1,0);
  dmd.drawString(0,16,"Birthday",8,1,0);
  dmd.drawString(6,32,"Lucas!",6,1,0);

  dmd.copyBuffer(0,2);
  dmd.setBufferDisplay(2);  
  transition(0,1);
  delay(1000);
 
  dmd.setBufferEdit(0);
  smile();
  transition(1,0);
  delay(500);
 
  dmd.setBufferEdit(1);
  dmd.clearScreen(0);
  dmd.drawString(8,0,"Lucas",5,1,0);
  dmd.drawString(26,16,"is",2,1,0);
  dmd.drawString(16,32,"One!",4,1,0);
  dmd.copyBuffer(0,2);
  dmd.setBufferDisplay(2);

  transition(0,1);
  delay(1000);

  dmd.setBufferEdit(0);
  dmd.clearScreen(0);
  dmd.drawString(16,0,"Born",4,1,0);
  dmd.drawString(0,16,"28 April",8,1,0);
  dmd.drawString(16,32,"2011",4,1,0);

  transition(1,0);
  delay(1000);
 
  dmd.copyBuffer(1,0);
}

void transition(byte from, byte to)
{
  int i=0;
  trans=random(8);
  dmd.copyBuffer(from,2);
  while (dmd.transition(from,to,2,trans,i)) {i=i+1;}
}

void wink()
{
  dmd.setBufferEdit(0);
  dmd.clearScreen(0);
  dmd.setBufferDisplay(2);  
  head();
  eyes();
  mouth_smile();
  dmd.drawFilledBox(centreX-8,centreY-7,centreX-6,centreY-5,1);
  dmd.copyBuffer(0,2);

  int winkspeed=100;  

  dmd.setBufferEdit(1);
  for (int i=0;i<=8;i++) {
    dmd.copyBuffer(0,1);
    if (i<=4) {
      dmd.drawFilledBox(centreX+6,centreY-7,centreX+8,centreY-5,1);
    } else if(i==5) {
      dmd.drawFilledBox(centreX+6,centreY-6,centreX+8,centreY-5,1);
    }
    int width=0;
    if (i==0 || i==8) {
      dmd.drawLine(centreX+7-1,centreY-11+i,centreX+7+1,centreY-11+i,1);
    } else if(i<=2 || i>=6) {
      dmd.drawLine(centreX+7-3,centreY-11+i,centreX+7+3,centreY-11+i,1);
    } else {
      dmd.drawLine(centreX+7-4,centreY-11+i,centreX+7+4,centreY-11+i,1);
    }
    dmd.copyBuffer(1,2);
    delay(50);
  }
  for (int i=8;i>=0;i--) {
    dmd.copyBuffer(0,1);
    if (i<=4) {
      dmd.drawFilledBox(centreX+6,centreY-7,centreX+8,centreY-5,1);
    } else if(i==5) {
      dmd.drawFilledBox(centreX+6,centreY-6,centreX+8,centreY-5,1);
    }
    int width=0;
    if (i==0 || i==8) {
      dmd.drawLine(centreX+7-1,centreY-11+i,centreX+7+1,centreY-11+i,1);
    } else if(i<=2 || i>=6) {
      dmd.drawLine(centreX+7-3,centreY-11+i,centreX+7+3,centreY-11+i,1);
    } else {
      dmd.drawLine(centreX+7-4,centreY-11+i,centreX+7+4,centreY-11+i,1);
    }
    dmd.copyBuffer(1,2);
    delay(50);
  }
  dmd.setBufferEdit(2);
}

void lookaround()
{
  //head
  dmd.setBufferEdit(0);
  dmd.clearScreen(0);
  dmd.setBufferDisplay(2);  
  head();
  eyes();
  mouth_flat();
  dmd.copyBuffer(0,2);
 
  // eyelids
  dmd.drawLine(centreX-5,centreY-10,centreX-10,centreY-10,1);
  dmd.drawLine(centreX+5,centreY-10,centreX+10,centreY-10,1);

  dmd.setBufferEdit(1);
  for (int i=0;i<=2;i++) {
    dmd.copyBuffer(0,1);
    dmd.drawFilledBox(centreX-8+i,centreY-7,centreX-6+i,centreY-5,1);
    dmd.drawFilledBox(centreX+6+i,centreY-7,centreX+8+i,centreY-5,1);
    dmd.copyBuffer(1,2);
    delay(100);
  }
  for (int i=2;i>=-2;i--) {
    dmd.copyBuffer(0,1);
    dmd.drawFilledBox(centreX-8+i,centreY-7,centreX-6+i,centreY-5,1);
    dmd.drawFilledBox(centreX+6+i,centreY-7,centreX+8+i,centreY-5,1);
    dmd.copyBuffer(1,2);
    delay(100);
  }
  for (int i=-2;i<=0;i++) {
    dmd.copyBuffer(0,1);
    dmd.drawFilledBox(centreX-8+i,centreY-7,centreX-6+i,centreY-5,1);
    dmd.drawFilledBox(centreX+6+i,centreY-7,centreX+8+i,centreY-5,1);
    dmd.copyBuffer(1,2);
    delay(100);
  }
  dmd.setBufferEdit(2);
}

void smile()
{
  dmd.clearScreen(0);
  head();
  eyes();
  mouth_smile();
  dmd.drawFilledBox(centreX-8,centreY-7,centreX-6,centreY-5,1);
  dmd.drawFilledBox(centreX+6,centreY-7,centreX+8,centreY-5,1);
}

void head()
{
  dmd.drawCircle(centreX,centreY,20,1);
}

void eyes()
{
  dmd.drawCircle(centreX-7,centreY-7,5,1);
  dmd.drawCircle(centreX+7,centreY-7,5,1);
}

void mouth_flat()
{
  dmd.drawLine(centreX-12,centreY+8,centreX+12,centreY+8,1);
}

void mouth_smile()
{
  dmd.drawLine(centreX-12,centreY+6,centreX-4,centreY+11,1);
  dmd.drawLine(centreX-4,centreY+11,centreX,centreY+11,1);
  dmd.drawLine(centreX+4,centreY+11,centreX,centreY+11,1);
  dmd.drawLine(centreX+12,centreY+6,centreX+4,centreY+11,1);
}

The biggest change was to add support for multiple storage areas.  Now when you mount a MTP device which has internal storage and a MicroSD card (or similar) it shows up as two separate directories which you can access.

The download is available from mtpfs page

Playing is fairly straight-forward.  Only thing to remember is that the ‘z-button’ on the nunchuck is used to select and the ‘c-button’ is used to exit back to the menu

Have a look at the video below to see them in action.

Watch this video on YouTube.

The library can be downloaded from github.com/cjd/DMD
See freetronics forum for my DMD library

Watch this video on YouTube.

Since then a bunch of small fixes have been added to the script to better handle ‘odd’ rss feeds and also to clean up the output.

The configuration of the script now sits in the file ~/.bashpodder  Inside this file you can specify where the logs go to and where the files download to (makes it easier to run the script automatically)

Thanks to Mobilediesel it now also doesn’t create the temporary xslt file and there is the option to use ‘-a feedurl [items]‘ to add a feed to the config file.  The [items] parameter is optional and when used will cause bashpodder to mark all items in the feed as already downloaded except the last [items] items.  This is useful when added a new feed so that it doesn’t try to download every item in the feed since day one

The updated script can be downloaded as bashpodder.sh and an example config file as .bashpodder

For more details on the script see the original post here

Being that I am not musically talented in any way I figured the best way to do this was to generate the music from a midi file.

To help with this I wrote a converter that would take a MusicXML file and output an include file.

It simply reads the XML and outputs an array where each note is stored in two uint16 values – the first is the note name as a defined in pitches.h (ie NOTE_C4), the second is the duration in milliseconds.  The entire array is stored in PROGMEM so as to not use up too much ram on the AVR.

The script is as follows (or download from here)

#!/usr/bin/perl
# Convert a single-channel musicxml file to include file for arduino
# Pass the xml filename on the commandline and a .h file will be generated
# with the same name (replacing .xml with .h)

# Needs XML::Mini perlmodule (libxml-mini-perl package in debian/ubuntu)
use XML::Mini::Document;
my $size = 0;

my $name = $ARGV[0];
$name =~ s/\.xml$//;
open(OUT, ">".$name.".h");
print OUT "PROGMEM prog_uint16_t ".$name."Tune[] = {\n";

my $xmldoc = XML::Mini::Document->new();
$xmldoc->fromFile($ARGV[0]);
my $xmlHash = $xmldoc->toHash();
my $measures = $xmlHash->{'score-partwise'}->{'part'}->{'measure'};
foreach my $measure (@$measures) {
  my $notes=$measure->{'note'};
  foreach (@$notes) {
    my $note = "";
    if ($_->{'pitch'}) {
      if (defined $_->{'accidental'}) {
        if ($_->{'accidental'} eq "sharp") {
          $_->{'pitch'}->{'step'}=$_->{'pitch'}->{'step'}."S";
        } elsif ($_->{'accidental'} eq "flat") {
          $_->{'pitch'}->{'step'} =~ tr/A-F/FA-E/;
          $_->{'pitch'}->{'step'}=$_->{'pitch'}->{'step'}."S";
        }
      }
      $note = "NOTE_".$_->{'pitch'}->{'step'}.$_->{'pitch'}->{'octave'};
    } else {
      $note = "NOTE_00";
    }
    my $duration = $_->{'duration'};
    print OUT $note.", ".$duration.", ";
    $size++;
  }
  print OUT "\n";
}
print OUT "};\n";
print OUT "byte ".$name."TuneSteps = ".$size.";\n";
print "total memory usage:".(($size*4)+1)." bytes\n";
close OUT;

To actually use this generated include file I created a function ‘playMelody’ which is called regularly during the running of a sketch.

Each time it runs it checks if it is time to play the next note, if so then it reads the next note from the array,calls ‘tone’ to play it and then sets a variable to say when the next note should be played.  If it is not yet time to play the next note then it quickly returns (there is not much latency added by calling the function so it’s okay to call too often)

boolean playMelody()
{
  boolean retVal=true;
  if (millis() > time) {
    int toneVal = 0;
    int duration = 0;
    if (tuneStep >= SmoothCriminalTuneSteps) {
      retVal=false;
      tuneStep=0;
    }
    toneVal=pgm_read_word_near(SmoothCriminalTune+(tuneStep*2));
    duration = pgm_read_word_near(SmoothCriminalTune+(tuneStep*2)+1);
    tuneStep++;
    if (toneVal) tone(speakerPin,toneVal,duration*2);
    time=millis()+(duration*2)+5;
  }
  return retVal;
}

I have a sample sketch which uses this to play a short melody loop as music.zip

See the original post here for more details on what is included

At the moment there is Snake, Breakout, Pong and Race.

You can download the sketch as peggy2_games_0.1.zip

When compiled it takes up 11432 bytes (it includes the ‘Tone’ library as I have started adding sound to the sketch – connect speaker to ADC5 to hear it)

Starting peggy2_game

When you turn on the peggy2 a menu is presented displaying the available games – you can select from them using the up/down buttons and select with the ‘select’ or ‘any’ button on the left of the peggy2.  Only three game names fit on the screen at once so the entire display scrolls up/down when changing game (and highlights the current selection)  To change games press the reset button.

Playing the games

Snake

When the game first starts you can choose which level to start at.  There are four different boards available – these boards are re-used in a loop just at a higher speed for later levels.

Eat the ‘apples’ to get points, don’t hit yourself or walls

Arrow buttons control movement of the snake.

Pong

Hit the ball back, get a point if the AI misses, AI gets the point if you miss

Left/right buttons control movement of the bottom paddle (one player only for the moment)

Break

Not much here yet, just displays a bouncing ball + blocks to hit

Left/right buttons control movement of the paddle

Race

Avoid the walls.  One point every 25 blocks driven past, walls get narrower every 25 points

Left/right buttons control movement of the car.

peggy2_games.zip

Each character is stored as a 24-bit number (held in a 32bit uint32) where each 4 bits indicates the on/off status for a row of 4 pixels. This results in allowing for a 4×6 pixel character

For example the character for the number ’0′ is stored as 0×699996 which when spread out looks like:

0110
1001
1001
1001
1001
0110

By doing this I can store 0-9 and A-Z in only 144bytes.
To save RAM I put this in program memory using: PROGMEM prog_uint32_t chars[37] 

To write a character to the display I use a function “show_char” (note I use a special function ‘setPixel’ to set the individual pixels to a certain brightness level – but if you are not using grayscale then the call can be replaced by standard frame.SetPixel calls)

void show_char(char Character, byte x, byte y)
{
  byte charNum = 36;
  if ((Character >= '0') && (Character <= '9')) {
    charNum=Character-48;
  }
  if ((Character >= 'A') && (Character <= 'Z')) {
    charNum=Character-55;
  }
  unsigned long w;
  w = pgm_read_dword_near(chars + charNum);
  for (byte i=0; i<6; i++) {
    byte offset = 4*(5-i);
    byte b = w >> offset; // get four bits
    b=b & 0xF;
    if (b & B1000) setPixel(x,y+i,7);
    if (b & B0100) setPixel(x+1,y+i,7);
    if (b & B0010) setPixel(x+2,y+i,7);
    if (b & B0001) setPixel(x+3,y+i,7);
  }
}

To make things a bit easier to display a string I also created a quick wrapper function ‘write_string’

void write_string(char string[], byte x, byte y)
{
  byte i=0;
  while (string[i] != '\0') {
    show_char(string[i], x+(5*i), y);
    i++;
  }
}

Full usage/source can be found in the peggy 2 snake code