Johan_Ha
Created May 10, 2021

Joyboy

An Arduboy with a Leonardo and an analog joystick

145

Things used in this project

Hardware components

Arduino Leonardo
Arduino Leonardo
×1
1.3 inch OLED display 128x64
×1
PTS 645 Series Switch
C&K Switches PTS 645 Series Switch
×2
Buzzer, Piezo
Buzzer, Piezo
×1
Generic set of resistors
What I used: 4 x 10k for the joystick 1 x 100R for the red LED 2 x 180R for the green and blue LED 1 x 150R for the piezo buzzer
×1
LED, RGB
LED, RGB
×1
Arduboy Compatible
Arduboy Compatible
×1

Software apps and online services

Generic PCB service
ardu-imconvert
For converting images to C code

Hand tools and fabrication machines

3D Printer (generic)
3D Printer (generic)

Story

Read more

Custom parts and enclosures

Joyboy PCB

This is a zipped archive of the needed files to reproduce the PCB. But even easier is to order it from this shared project:

https://oshpark.com/shared_projects/FKEgLBdS

However, one needs to make the same changes I did, if one wants this PCB to work with the Arduboy. As it is, it works nicely with the U8g2 graphics in the Arduino example sketches.

The 3D printable parts

The case and the joystick button

Schematics

Image of the PCB circuit

The circuit diagram was designed straight in the PCB designing software. This image, together with the previous image showing the PCB from both sides, gives a pretty good picture of the circuit.

Code

AsteroMiner main file

C/C++
The main .ino file.
/*
 *    AsteroMiner
 *    - a demo game made for JoyBoy,
 *    a Arduboy version with an analog joystick.
 *    
 *    JoyBoy participated in the DIY Arduboy contest,
 *    arranged by Hackster.com in 2021.
 *    
 */

#include <Arduboy2.h>
#include "miner_flames.h"

Arduboy2 arduboy;

// map structure of the asteroid belt,
// max tile size 128*64
unsigned char const *scene[3][2];

// there are 5 sizes of flames, 4 directions and 3 frames of each
unsigned char const *flames[5][4][3] =
{
  {
    {  flame00,  flame01,  flame02 },
    { rflame00, rflame01, rflame02 },
    { dflame00, dflame01, dflame02 },
    { lflame00, lflame01, lflame02 }
  },
  {
    {  flame10,  flame11,  flame12 },
    { rflame10, rflame11, rflame12 },
    { dflame10, dflame11, dflame12 },
    { lflame10, lflame11, lflame12 }
  },
  {
    {  flame20,  flame21,  flame22 },
    { rflame20, rflame21, rflame22 },
    { dflame20, dflame21, dflame22 },
    { lflame20, lflame21, lflame22 }
  },
  {
    {  flame30,  flame31,  flame32 },
    { rflame30, rflame31, rflame32 },
    { dflame30, dflame31, dflame32 },
    { lflame30, lflame31, lflame32 }
  },
  {
    {  flame40,  flame41,  flame42 },
    { rflame40, rflame41, rflame42 },
    { dflame40, dflame41, dflame42 },
    { lflame40, lflame41, lflame42 }
  }
};

// for the 5 flames, the horizontal ones have one dimension and the vertical ones have swapped dimesion,
// so only 5*2 is needed
uint8_t bmp_wh[5][2] =
{
  {3,  8},
  {4,  8},
  {5,  16},
  {6,  16},
  {8,  16}
};

// for each flame size and direction, define the coordinates where to blit
uint8_t flame_coords[4][5][2] = 
{
  {
    { 63, 20 }, // up
    { 63, 20 },
    { 62, 12 },
    { 61, 12 },
    { 61, 12 }
  },
  {
    { 67, 30 }, // right
    { 67, 30 },
    { 67, 30 },
    { 67, 29 },
    { 67, 29 }
  },
  {
    { 63, 35 }, // down
    { 63, 35 },
    { 63, 35 },
    { 62, 35 },
    { 61, 35 }
  },
  {
    { 54, 30 }, // left
    { 54, 29 },
    { 46, 29 },
    { 46, 29 },
    { 46, 27 }
  }
};

// for the 5 flames and for each direction, define the drawBitmap() coordinate
// relative to the asterolander center coordinate
int8_t bmp_dxy[5][2] =
{
  { 1,  7},
  { 2,  7},
  { 2,  15},
  { 2,  15},
  { 4,  15}
};

// The pixel where flame starts
int8_t flameroot_xy[4][2] =
{
  {  0, -4 },
  {  3, -1 },
  { -3, -1 },
  {  0,  3 }
};

// The coordinates of the platforms on the asteroids
//  x, y, width
uint16_t platforms[23][3] =
{
  {    11,  96,  12 },  
  {    20,  41,  15 },  
  {    20, 165, 12 },  
  {    37, 133, 9 },  
  {    60,  88,  7 },  
  {    65,  29,  10 },  
  {    71,  58,  11 },  
  {    86, 104, 12 },  
  {   106,  77,  9 },  
  {   107, 155, 10 },  
  {   112, 129, 13 },  
  {   134,  29,  15 },  
  {   134,  77,  8 },  
  {   141, 109, 10 },  
  {   167,  87,  12 },  
  {   170,  62,  8 },  
  {   176,   2, 15 },  
  {   182, 129, 17 },  
  {   191, 105, 13 },  
  {   205,  44,  9 },  
  {   219,  88,  13 },  
  {   228, 160, 12 },  
  {   233, 129, 9 }  
};

// coords and status of the rocket
float rx, ry, ax, ay;
bool landed;

uint8_t flame_count;

void setup() {
  // initiate arduboy instance
  arduboy.begin();
  rx = 93;
  ry = 100;
  ax = 0;
  ay = 0;
  
  landed = true;
  
  arduboy.setFrameRate(60);
  power_adc_enable();
  pinMode(A0, INPUT_PULLUP); //11
  pinMode(A1, INPUT_PULLUP);        //10
  pinMode(A2, INPUT_PULLUP);       //01
  pinMode(A3, INPUT_PULLUP);       //01

  scene[0][0] = scene0;
  scene[0][1] = scene1;
  scene[1][0] = scene2;
  scene[1][1] = scene3;
  scene[2][0] = scene4;
  scene[2][1] = scene5;

  arduboy.clear();
  arduboy.drawCompressed(0, 0, logo1, WHITE);
  arduboy.display();
  arduboy.delayShort(3000);
}

// For calibrating the joystick
int lo0 = 1024;
int lo1 = 1024;
int lo2 = 1024;
int lo3 = 1024;
int hi0 = 0;
int hi1 = 0;
int hi2 = 0;
int hi3 = 0;


/*   2
 *  3 1
 *   0
 */
 
int z0 = 1004,
    z1 = 1000,
    z2 = 947,
    z3 = 970,
    m0 = 737, // down    threshold 850
    m1 = 547, // right             700
    m2 = 529, // up                700 
    m3 = 552; // left              700
    


// our main game loop, this runs once every cycle/frame.
// this is where our game logic goes.
void loop() {
  int a0, a1, a2, a3;           // reading directly from analog pins
  int r0x, r0y;                 // top left screen pixel in the world map
  float f0, f1, f2, f3, fx, fy; // forces on each joystick pad, forces in two dimensions
  uint8_t flame_index;                  // flame sprite index
  bool collision, landed;
  
  // pause render until it's time for the next frame
  if (!(arduboy.nextFrame()))
    return;

  // first we clear our screen to black
  arduboy.clear();

  analogRead(A0);
  a0 = analogRead(A0);
  analogRead(A1);
  a1 = analogRead(A1);
  analogRead(A2);
  a2 = analogRead(A2);
  analogRead(A3);
  a3 = analogRead(A3);
  f0 = map(a0, z0, m0, 0, 10);
  f1 = map(a1, z1, m1, 0, 10);
  f2 = map(a2, z2, m2, 0, 10);
  f3 = map(a3, z3, m3, 0, 10);
    if (f0 < 0)  f0 = 0;
    if (f0 > 10) f0 = 10;
    if (f1 < 0)  f1 = 0;
    if (f1 > 10) f1 = 10;
    if (f2 < 0)  f2 = 0;
    if (f2 > 10) f2 = 10;
    if (f3 < 0)  f3 = 0;
    if (f3 > 10) f3 = 10;

  // Compute acceleration
  if (f0 > 2 || f2 > 2)
    fy = f0 - f2;
  else 
    fy = 0;
  if (f1 > 2 || f3 > 2)
    fx = f1 - f3;
  else
    fx = 0;
  ax += fx / 200.;
  ay += fy / 200.;
  rx += ax;
  ry += ay;

  // Reset button
  if (arduboy.buttonsState() & A_BUTTON)
  {
    rx = 93;
    ry = 100;
    ax = 0;
    ay = 0;
  
  }


  // Draw asteroids
  r0x = int(rx) - 64;
  r0y = int(ry) - 32;
  for (int i = 0; i < 3; i++)
  {
    for (int j = 0; j < 2; j++)
    {
      if (((128*j - r0x) > -128) && ((128*j - r0x) < 128) &&
          ((64*i - r0y) > -64) && ((64*i - r0y) < 64))
        arduboy.drawCompressed(-r0x + 128*j, -r0y + 64*i, scene[i][j], WHITE);
    }
  }
  //arduboy.drawCompressed(r0x, r0y, *scene[0][0], WHITE);
  
  // Draw fix stars
  arduboy.drawPixel(8, 14, WHITE);
  arduboy.drawPixel(17, 45, WHITE);
  arduboy.drawPixel(30, 22, WHITE);
  arduboy.drawPixel(34, 48, WHITE);
  arduboy.drawPixel(63, 43, WHITE);
  arduboy.drawPixel(67, 21, WHITE);
  arduboy.drawPixel(85, 6, WHITE);
  arduboy.drawPixel(107, 52, WHITE);
  arduboy.drawPixel(120, 25, WHITE);
  
  // Check for collision before drawing rocket
  collision = false;
  if (arduboy.getPixel(61, 35) == WHITE ||
      arduboy.getPixel(67, 35) == WHITE ||
      arduboy.getPixel(64, 28) == WHITE ||
      arduboy.getPixel(61, 33) == WHITE ||
      arduboy.getPixel(64, 33) == WHITE ||
      arduboy.getPixel(62, 30) == WHITE ||
      arduboy.getPixel(66, 30) == WHITE)
     collision = true; 

  // Check if collision was actually a successful landing
  landed = false;
  if (collision)
  {
    for (int i = 0; i < 23 && !landed; i++)
    {
      if (int(ry) + 3 == platforms[i][1])
      {
        if (int(rx) > platforms[i][0] + 2 &&
            int(rx) < platforms[i][0] + platforms[i][2] - 2)
        {
          collision = false;
          landed = true;
        }
      }
    }
  }
      
  // Draw rocket
  arduboy.drawBitmap(61, 28, rocket, 7, 8, WHITE);

  // Draw flames
  flame_count++;
  flame_count %= 3;
  if (fx >= 1)
  {
    flame_index = fx / 2;
    if (flame_index > 4) flame_index = 4;
    arduboy.drawBitmap(flame_coords[3][flame_index][0], 
                       flame_coords[3][flame_index][1], 
                       flames[flame_index][3][flame_count], 
                       bmp_wh[flame_index][1], 
                       8, 
                       WHITE);
                       
  }
  else
  if (fx <= -1)
  {
    flame_index = -fx / 2;
    if (flame_index > 4) flame_index = 4;
    arduboy.drawBitmap(flame_coords[1][flame_index][0], 
                       flame_coords[1][flame_index][1], 
                       flames[flame_index][1][flame_count], 
                       bmp_wh[flame_index][1], 
                       8, 
                       WHITE);
                       
  }

  if (fy >= 1)
  {
    flame_index = fy / 2;
    if (flame_index > 4) flame_index = 4;
    arduboy.drawBitmap(flame_coords[0][flame_index][0], 
                       flame_coords[0][flame_index][1], 
                       flames[flame_index][0][flame_count], 
                       bmp_wh[flame_index][0], // CHECK THIS!!!
                       bmp_wh[flame_index][1], 
                       WHITE);
                       
  }
  else
  if (fy <= -1)
  {
    flame_index = -fy / 2;
    if (flame_index > 4) flame_index = 4;
    arduboy.drawBitmap(flame_coords[2][flame_index][0], 
                       flame_coords[2][flame_index][1], 
                       flames[flame_index][2][flame_count], 
                       bmp_wh[flame_index][0], 
                       bmp_wh[flame_index][1], 
                       WHITE);
                       
  }
  
/*
  // CALIBRATION
  if (lo0 > a0) lo0 = a0;
  if (lo1 > a1) lo1 = a1;
  if (lo2 > a2) lo2 = a2;
  if (lo3 > a3) lo3 = a3;
  if (hi0 < a0) hi0 = a0;   /// 2.35 7.5
  if (hi1 < a1) hi1 = a1;
  if (hi2 < a2) hi2 = a2;
  if (hi3 < a3) hi3 = a3;
  
  arduboy.setCursor(0, 0);
  arduboy.print(a0);
  arduboy.print(" - ");
  arduboy.print(lo0);
  arduboy.print(" - ");
  arduboy.print(hi0);
  arduboy.println("  ");
  arduboy.print(a1);
  arduboy.print(" - ");
  arduboy.print(lo1);
  arduboy.print(" - ");
  arduboy.print(hi1);
  arduboy.println("  ");
  arduboy.print(a2);
  arduboy.print(" - ");
  arduboy.print(lo2);
  arduboy.print(" - ");
  arduboy.print(hi2);
  arduboy.println("  ");
  arduboy.print(a3);
  arduboy.print(" - ");
  arduboy.print(lo3);
  arduboy.print(" - ");
  arduboy.print(hi3);
  arduboy.println("  ");
  // CALIBRATION END
*/
  
  /*
   * If you’re using analog inputs with the Arduboy2 library, note that it leaves 
   * the ADC disabled after you initialise the hardware (by calling begin() or boot()), 
   * to save power. You might have to add a call to power_adc_enable() after init 
   * and also after calling initRandomSeed() (or generateRandomSeed() in the future).

      Alternatively, you could modify or extend the library 
      so that the ADC remains enabled.
   */
  /* 
  int x = map(a1, z1, m1, 0, 100) - map(a3, z3, m3, 0, 100);
  int y = map(a0, z0, m0, 0, 100) - map(a2, z2, m2, 0, 100);
  arduboy.setCursor(x + 61, y + 28);
  arduboy.print("*");
  arduboy.drawBitmap(10, 10, flames[4][2][(millis() / 100) % 3], 8, 16, WHITE);
  */
  
  
  arduboy.display();
  if (collision)
  {
    for (int i = 0; i < 8; i++)
    {
      arduboy.invert(true);
      arduboy.delayShort(100);
      arduboy.invert(false);
      arduboy.delayShort(100);
    }
    arduboy.clear();
    arduboy.setTextSize(2);
    arduboy.setCursor(10, 12);
    arduboy.print("GAME OVER");
    arduboy.display();
    arduboy.delayShort(3000);
    rx = 93;
    ry = 100;
    ax = 0;
    ay = 0;
      
  }
  if (landed)
  {
    ax = 0;
    ay = 0;
    ry -= 1;
    arduboy.clear();
    arduboy.setTextSize(2);
    arduboy.setCursor(10, 30);
    arduboy.print("LANDED");
    arduboy.display();
    arduboy.delayShort(3000);
    

  }
}

miner_flames.h

C/C++
Includes graphics for the game
unsigned char const flame00[] PROGMEM =
{
  // 3, 8    origin 
  0x10, 0x80, 0x40, 
};
///////////////////////////
unsigned char const flame01[] PROGMEM =
{
  // 3, 8
  0x20, 0x90, 0x00, 
};

///////////////////////////
unsigned char const flame02[] PROGMEM =
{
  // 3, 8
  0x40, 0xa0, 0x00, 
};

///////////////////////////
unsigned char const flame10[] PROGMEM =
{
  // 4, 8
  0x00, 0x88, 0x40, 0x02, 
};

///////////////////////////
unsigned char const flame11[] PROGMEM =
{
  // 4, 8
  0x02, 0x90, 0x08, 0x00, 
};

///////////////////////////
unsigned char const flame12[] PROGMEM =
{
  // 4, 8
  0x20, 0x84, 0x10, 0x00, 
};

///////////////////////////
unsigned char const flame20[] PROGMEM =
{
  // 5, 16
  0x00, 0x00, 0x40, 0x00, 0x80, 0x03, 0x30, 0xce, 
  0x02, 0x19, 
};

///////////////////////////
unsigned char const flame21[] PROGMEM =
{
  // 5, 16
  0x00, 0x00, 0x40, 0x00, 0x00, 0x02, 0x30, 0xc4, 
  0x02, 0x11, 
};

///////////////////////////
unsigned char const flame22[] PROGMEM =
{
  // 5, 16
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xc9, 
  0x26, 0x00, 
};

///////////////////////////
unsigned char const flame30[] PROGMEM =
{
  // 6, 16
  0x00, 0x40, 0x00, 0x50, 0x00, 0x80, 0x02, 0x00, 
  0x11, 0x84, 0x40, 0x0c, 
};

///////////////////////////
unsigned char const flame31[] PROGMEM =
{
  // 6, 16
  0x00, 0x80, 0x00, 0x20, 0x80, 0x00, 0x08, 0x04, 
  0x20, 0x8a, 0x08, 0x15, 
};

///////////////////////////
unsigned char const flame32[] PROGMEM =
{
  // 6, 16
  0x00, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x0c, 
  0x41, 0x84, 0x31, 0x02, 
};

///////////////////////////
unsigned char const flame40[] PROGMEM =
{
  // 8, 16
  0x04, 0x40, 0x30, 0x80, 0x04, 0x20, 0x00, 0x02, 
  0x00, 0x02, 0x08, 0xc4, 0x02, 0x10, 0x01, 0x00, 
};

///////////////////////////
unsigned char const flame41[] PROGMEM =
{
  // 8, 16
  0x02, 0xd0, 0x20, 0x00, 0x09, 0x00, 0x48, 0x00, 
  0x04, 0x10, 0x01, 0x8c, 0x01, 0x12, 0x00, 0x00, 
};

///////////////////////////
unsigned char const flame42[] PROGMEM =
{
  // 8, 16
  0x00, 0x88, 0x20, 0x44, 0x00, 0xa8, 0x00, 0x00, 
  0x00, 0x28, 0x03, 0x98, 0x22, 0x04, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame00[] PROGMEM =
{
  // 8, 3
  0x02, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame01[] PROGMEM =
{
  // 8, 3
  0x02, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame02[] PROGMEM =
{
  // 8, 3
  0x02, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame10[] PROGMEM =
{
  // 8, 4
  0x02, 0x04, 0x00, 0x00, 0x02, 0x00, 0x08, 0x00, 
};

///////////////////////////
unsigned char const rflame11[] PROGMEM =
{
  // 8, 4
  0x02, 0x00, 0x00, 0x02, 0x04, 0x00, 0x01, 0x00, 
};

///////////////////////////
unsigned char const rflame12[] PROGMEM =
{
  // 8, 4
  0x02, 0x00, 0x01, 0x04, 0x00, 0x02, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame20[] PROGMEM =
{
  // 16, 5
  0x04, 0x04, 0x02, 0x12, 0x14, 0x04, 0x0d, 0x11, 
  0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame21[] PROGMEM =
{
  // 16, 5
  0x04, 0x04, 0x02, 0x12, 0x00, 0x04, 0x09, 0x10, 
  0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame22[] PROGMEM =
{
  // 16, 5
  0x04, 0x06, 0x0a, 0x00, 0x04, 0x0a, 0x08, 0x04, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame30[] PROGMEM =
{
  // 16, 6
  0x08, 0x10, 0x00, 0x04, 0x20, 0x28, 0x01, 0x04, 
  0x20, 0x0a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame31[] PROGMEM =
{
  // 16, 6
  0x08, 0x00, 0x04, 0x20, 0x19, 0x22, 0x08, 0x20, 
  0x12, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame32[] PROGMEM =
{
  // 16, 6
  0x08, 0x04, 0x10, 0x10, 0x02, 0x0a, 0x20, 0x14, 
  0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const rflame40[] PROGMEM =
{
  // 16, 8
  0x08, 0x08, 0x00, 0x20, 0x04, 0x08, 0x12, 0x40, 
  0x08, 0x02, 0x24, 0x04, 0x00, 0x11, 0x80, 0x00, 
};

///////////////////////////
unsigned char const rflame41[] PROGMEM =
{
  // 16, 8
  0x08, 0x00, 0x00, 0x22, 0x08, 0x09, 0x20, 0x14, 
  0x02, 0x42, 0x04, 0x02, 0x50, 0x00, 0x01, 0x10, 
};

///////////////////////////
unsigned char const rflame42[] PROGMEM =
{
  // 16, 8
  0x08, 0x00, 0x12, 0x08, 0x0a, 0x20, 0x14, 0x04, 
  0x22, 0x08, 0x24, 0x00, 0x22, 0x08, 0x00, 0x00, 
};

unsigned char const dflame00[] PROGMEM =
{
  // 3, 8
  0x02, 0x01, 0x08, 
};

///////////////////////////
unsigned char const dflame01[] PROGMEM =
{
  // 3, 8
  0x00, 0x09, 0x04, 
};

///////////////////////////
unsigned char const dflame02[] PROGMEM =
{
  // 3, 8
  0x00, 0x05, 0x02, 
};

///////////////////////////
unsigned char const dflame10[] PROGMEM =
{
  // 4, 8
  0x40, 0x02, 0x11, 0x00, 
};

///////////////////////////
unsigned char const dflame11[] PROGMEM =
{
  // 4, 8
  0x00, 0x10, 0x09, 0x40, 
};

///////////////////////////
unsigned char const dflame12[] PROGMEM =
{
  // 4, 8
  0x00, 0x08, 0x21, 0x04, 
};

///////////////////////////
unsigned char const dflame20[] PROGMEM =
{
  // 5, 16
  0x98, 0x40, 0x73, 0x0c, 0xc0, 0x01, 0x00, 0x02, 
  0x00, 0x00, 
};

///////////////////////////
unsigned char const dflame21[] PROGMEM =
{
  // 5, 16
  0x88, 0x40, 0x23, 0x0c, 0x40, 0x00, 0x00, 0x02, 
  0x00, 0x00, 
};

///////////////////////////
unsigned char const dflame22[] PROGMEM =
{
  // 5, 16
  0x00, 0x64, 0x93, 0x26, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 
};

///////////////////////////
unsigned char const dflame30[] PROGMEM =
{
  // 6, 16
  0x30, 0x02, 0x21, 0x88, 0x00, 0x40, 0x01, 0x00, 
  0x0a, 0x00, 0x02, 0x00, 
};

///////////////////////////
unsigned char const dflame31[] PROGMEM =
{
  // 6, 16
  0xa8, 0x10, 0x51, 0x04, 0x20, 0x10, 0x00, 0x01, 
  0x04, 0x00, 0x01, 0x00, 
};

///////////////////////////
unsigned char const dflame32[] PROGMEM =
{
  // 6, 16
  0x40, 0x8c, 0x21, 0x82, 0x30, 0x00, 0x00, 0x10, 
  0x02, 0x00, 0x00, 0x00, 
};

///////////////////////////
unsigned char const dflame40[] PROGMEM =
{
  // 8, 16
  0x00, 0x80, 0x08, 0x40, 0x23, 0x10, 0x40, 0x00, 
  0x40, 0x00, 0x04, 0x20, 0x01, 0x0c, 0x02, 0x20, 
};

///////////////////////////
unsigned char const dflame41[] PROGMEM =
{
  // 8, 16
  0x00, 0x00, 0x48, 0x80, 0x31, 0x80, 0x08, 0x20, 
  0x00, 0x12, 0x00, 0x90, 0x00, 0x04, 0x0b, 0x40, 
};

///////////////////////////
unsigned char const dflame42[] PROGMEM =
{
  // 16, 8
  0x00, 0x00, 0x10, 0x44, 0x00, 0x24, 0x10, 0x44, 
  0x20, 0x28, 0x04, 0x50, 0x10, 0x48, 0x00, 0x10, 
};

///////////////////////////
unsigned char const lflame00[] PROGMEM =
{
  // 8, 3
  0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 
};

///////////////////////////
unsigned char const lflame01[] PROGMEM =
{
  // 8, 3
  0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x02, 
};

///////////////////////////
unsigned char const lflame02[] PROGMEM =
{
  // 8, 3
  0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x02, 
};

///////////////////////////
unsigned char const lflame10[] PROGMEM =
{
  // 8, 4
  0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x02, 0x04, 
};

///////////////////////////
unsigned char const lflame11[] PROGMEM =
{
  // 8, 4
  0x00, 0x08, 0x00, 0x02, 0x04, 0x00, 0x00, 0x04, 
};

///////////////////////////
unsigned char const lflame12[] PROGMEM =
{
  // 8, 4
  0x00, 0x00, 0x04, 0x00, 0x02, 0x08, 0x00, 0x04, 
};

///////////////////////////
unsigned char const lflame20[] PROGMEM =
{
  // 16, 5
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 
  0x11, 0x16, 0x04, 0x05, 0x09, 0x08, 0x04, 0x04, 
};

///////////////////////////
unsigned char const lflame21[] PROGMEM =
{
  // 16, 5
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 
  0x01, 0x12, 0x04, 0x00, 0x09, 0x08, 0x04, 0x04, 
};

///////////////////////////
unsigned char const lflame22[] PROGMEM =
{
  // 16, 5
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x04, 0x02, 0x0a, 0x04, 0x00, 0x0a, 0x0c, 0x04, 
};

///////////////////////////
unsigned char const lflame30[] PROGMEM =
{
  // 16, 6
  0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x14, 0x01, 
  0x08, 0x20, 0x05, 0x01, 0x08, 0x00, 0x02, 0x04, 
};

///////////////////////////
unsigned char const lflame31[] PROGMEM =
{
  // 16, 6
  0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x12, 
  0x01, 0x04, 0x11, 0x26, 0x01, 0x08, 0x00, 0x04, 
};

///////////////////////////
unsigned char const lflame32[] PROGMEM =
{
  // 16, 6
  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x04, 0x00, 
  0x0a, 0x01, 0x14, 0x10, 0x02, 0x02, 0x08, 0x04, 
};

///////////////////////////
unsigned char const lflame40[] PROGMEM =
{
  // 16, 8
  0x00, 0x01, 0x88, 0x00, 0x20, 0x24, 0x40, 0x10, 
  0x02, 0x48, 0x10, 0x20, 0x04, 0x00, 0x10, 0x10, 
};
  
///////////////////////////
unsigned char const lflame41[] PROGMEM =
{
  // 16, 8    origin 
  0x08, 0x80, 0x00, 0x0a, 0x40, 0x20, 0x42, 0x40, 
  0x28, 0x04, 0x90, 0x10, 0x44, 0x00, 0x00, 0x10, 
};

///////////////////////////
unsigned char const lflame42[] PROGMEM =
{
  // 16, 8
  0x00, 0x00, 0x10, 0x44, 0x00, 0x24, 0x10, 0x44, 
  0x20, 0x28, 0x04, 0x50, 0x10, 0x48, 0x00, 0x10, 
};

unsigned char const rocket[] PROGMEM =
{
  // 7, 8    origin 3, 4
  0xe0, 0x7c, 0x6e, 0x67, 0x6e, 0x7c, 0xe0, 
};

unsigned char const logo1[] PROGMEM =
{
  127, 63,
  0xb0, 0x15, 0x1e, 0xd3, 0xe9, 0xd0, 0x9c, 0x5d, 
  0x2a, 0xa9, 0xa4, 0x92, 0x4a, 0x2a, 0xa9, 0xec, 
  0x76, 0xbb, 0x8e, 0x3e, 0xbb, 0xdd, 0x6e, 0xd7, 
  0xe9, 0x74, 0x3a, 0x9d, 0x4e, 0xa7, 0xd3, 0xe9, 
  0xce, 0x85, 0xc6, 0x74, 0x3a, 0x9d, 0x4e, 0xa7, 
  0x43, 0x63, 0x3a, 0x9d, 0xce, 0x6e, 0xb7, 0xdb, 
  0xed, 0x3a, 0x1d, 0xa4, 0xaa, 0x94, 0x8c, 0x39, 
  0xa6, 0xed, 0x7c, 0xe9, 0xad, 0x73, 0x52, 0xe9, 
  0x30, 0xc5, 0x1d, 0x51, 0x4c, 0x4a, 0x2a, 0xa9, 
  0xec, 0x56, 0x49, 0xe5, 0xc8, 0xb7, 0x4a, 0x3a, 
  0xe7, 0x9c, 0x73, 0x44, 0x71, 0x45, 0xbb, 0x73, 
  0xb5, 0x93, 0x4a, 0x2a, 0xa9, 0x1c, 0xbb, 0xcd, 
  0x45, 0x9f, 0xce, 0xae, 0x7a, 0xab, 0xa4, 0x53, 
  0x28, 0x63, 0x8d, 0xd6, 0x39, 0xe7, 0xd4, 0x3d, 
  0x86, 0xd2, 0x5b, 0xfa, 0x9c, 0x53, 0x72, 0x9b, 
  0x4e, 0x57, 0x6e, 0xa9, 0xa4, 0x92, 0x4a, 0x2a, 
  0xa9, 0xec, 0xaa, 0xd7, 0xdb, 0xad, 0xba, 0x9d, 
  0xc3, 0x6d, 0xf4, 0x2e, 0xb6, 0x7c, 0x64, 0x3b, 
  0x1c, 0xa5, 0xa5, 0x62, 0x4e, 0x6e, 0xf1, 0x94, 
  0x74, 0xca, 0x6e, 0xb7, 0xe9, 0x18, 0x3b, 0xf2, 
  0x25, 0xc6, 0xec, 0x3a, 0x9d, 0xac, 0xec, 0x0a, 
  0x67, 0xf1, 0x3b, 0x67, 0xd7, 0xf1, 0x26, 0x73, 
  0xd9, 0xed, 0xce, 0x39, 0x25, 0x95, 0x74, 0x8a, 
  0xd8, 0xae, 0xd3, 0xa9, 0x54, 0xf6, 0xe8, 0x9c, 
  0xb3, 0xeb, 0xf4, 0x2e, 0xca, 0x1d, 0x82, 0xa4, 
  0xd2, 0xb9, 0xa8, 0x95, 0x74, 0xce, 0x39, 0xa7, 
  0xa4, 0x53, 0x52, 0xc9, 0xc9, 0x73, 0xb5, 0xc4, 
  0x5d, 0xd8, 0x4b, 0x6f, 0xb7, 0xdb, 0xd8, 0xc3, 
  0x57, 0x3a, 0x1d, 0xda, 0xd2, 0xdb, 0xed, 0x76, 
  0xbb, 0xdd, 0xa6, 0xd3, 0xe1, 0x4e, 0x39, 0xe7, 
  0x9c, 0x73, 0xce, 0x39, 0x27, 0x15, 0x64, 0x18, 
  0x8c, 0x94, 0x4e, 0xa7, 0xd3, 0xe9, 0x74, 0x3a, 
  0x9d, 0x0e, 0xb6, 0xcb, 0x2e, 0x95, 0x53, 0xd2, 
  0x39, 0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 0x9c, 
  0xdc, 0x2a, 0xbb, 0x5d, 0x2a, 0xa9, 0xa4, 0x92, 
  0xca, 0x39, 0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 
  0xa4, 0x92, 0xca, 0x4e, 0x99, 0x73, 0xae, 0x72, 
  0x4e, 0xa9, 0x52, 0x52, 0xa9, 0x72, 0x52, 0x07, 
  0x35, 0xa5, 0xd3, 0xd1, 0x27, 0x95, 0x73, 0x4a, 
  0x2a, 0x55, 0x4a, 0x2a, 0xa9, 0xa4, 0x92, 0x4a, 
  0xaa, 0x52, 0x4a, 0x3a, 0x85, 0xa7, 0xa4, 0x72, 
  0x4e, 0x49, 0x25, 0xb7, 0xab, 0xde, 0x2e, 0x95, 
  0xfc, 0xd4, 0x76, 0xab, 0xec, 0x76, 0xab, 0xa4, 
  0x92, 0xce, 0x49, 0x85, 0xd8, 0x60, 0x21, 0x4c, 
  0xd9, 0x74, 0x7a, 0xbb, 0x55, 0x52, 0x2a, 0xbb, 
  0xdd, 0x6e, 0x97, 0x4a, 0xc9, 0xed, 0x3a, 0xbb, 
  0x73, 0x13, 0x47, 0x88, 0x20, 0xbe, 0xb8, 0x62, 
  0x22, 0x57, 0x4a, 0x6e, 0x3b, 0xe6, 0xf9, 0xd2, 
  0x5b, 0x25, 0xa5, 0xd2, 0xe9, 0xa6, 0x8b, 0x29, 
  0x3e, 0x4a, 0xa6, 0xd8, 0xbb, 0x95, 0x74, 0x0a, 
  0x89, 0x84, 0x91, 0x33, 0x3b, 0x25, 0xd5, 0xad, 
  0xe4, 0x76, 0xf2, 0xe5, 0x52, 0x39, 0x08, 0x28, 
  0x0c, 0x3b, 0x57, 0x4a, 0xd9, 0xed, 0x56, 0x39, 
  0x19, 0xb2, 0xa5, 0xb2, 0xdb, 0xed, 0x52, 0x29, 
  0x19, 0xba, 0xa4, 0xb2, 0x9f, 0xda, 0x2e, 0xa9, 
  0x75, 0x3e, 0x56, 0xe2, 0xad, 0x54, 0x25, 0xe3, 
  0x8c, 0x39, 0xbb, 0x73, 0xb3, 0xdb, 0x75, 0x25, 
  0xd3, 0x69, 0x25, 0x95, 0x54, 0x72, 0xbb, 0xab, 
  0xad, 0x72, 0x18, 0x4a, 0x2b, 0xe9, 0x9c, 0xee, 
  0x48, 0x97, 0x44, 0xe9, 0xad, 0x92, 0x4a, 0x3a, 
  0x27, 0x95, 0x54, 0xaa, 0x94, 0x54, 0x76, 0xbb, 
  0x55, 0x0e, 0x91, 0x21, 0x3f, 0xd8, 0x2a, 0x68, 
  0x34, 0xb8, 0x1a, 
};


unsigned char const scene0[] PROGMEM =
{
  127, 63,
  0xc0, 0x36, 0x2d, 0x95, 0x54, 0x52, 0x49, 0x25, 
  0x95, 0x54, 0x76, 0xbb, 0x4e, 0x07, 0x9e, 0x4e, 
  0x49, 0xe7, 0x9c, 0x73, 0x0e, 0x41, 0xb1, 0xa6, 
  0xb7, 0x4a, 0x4a, 0x25, 0x95, 0xdd, 0xae, 0xd3, 
  0xe9, 0x74, 0xe0, 0xd9, 0x9c, 0x93, 0xca, 0xae, 
  0xa3, 0x0e, 0x95, 0xf1, 0xa6, 0xc1, 0x6a, 0x6d, 
  0x97, 0x4a, 0x2a, 0xa9, 0xa4, 0x92, 0x4a, 0x2a, 
  0xa9, 0xa4, 0x92, 0x4a, 0x2a, 0xa9, 0xec, 0x76, 
  0xbb, 0x5d, 0x2a, 0xa9, 0xa4, 0x72, 0x8c, 0xa1, 
  0x71, 0xa9, 0xa4, 0x92, 0xca, 0x39, 0xe7, 0x1c, 
  0xb8, 0x2c, 0xe7, 0xa4, 0xb2, 0xdb, 0xed, 0x3a, 
  0x9d, 0x4e, 0x47, 0x15, 0x54, 0x94, 0xce, 0xee, 
  0x5c, 0x50, 0xad, 0x53, 0xb7, 0x92, 0xdb, 0x5c, 
  0x87, 0xa6, 0x74, 0x3a, 0x59, 0xe9, 0x74, 0x3a, 
  0x9d, 0x4e, 0xe7, 0x3a, 0x9d, 0x4e, 0xa7, 0x53, 
  0xa9, 0xf4, 0x76, 0xbb, 0xdd, 0x6e, 0xb7, 0x4a, 
  0x2a, 0xe9, 0x1c, 0x3c, 0x97, 0x4e, 0xa7, 0xd3, 
  0xdb, 0xed, 0x76, 0xbb, 0xdd, 0xa6, 0xd3, 0xe9, 
  0xa0, 0xe5, 0xad, 0x92, 0xce, 0x39, 0xe7, 0x9c, 
  0x73, 0xce, 0x39, 0xe7, 0x9c, 0x92, 0x4a, 0x2a, 
  0xa9, 0xa4, 0x92, 0x4a, 0x2a, 0xa9, 0xa4, 0x92, 
  0x4a, 0x3a, 0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 
  0x9c, 0x73, 0xce, 0x5d, 0xce, 0x39, 0xe7, 0x9c, 
  0x53, 0x52, 0xc9, 0x6d, 0xa0, 0x32, 0x95, 0x93, 
  0xdb, 0xed, 0xa7, 0xb6, 0xdb, 0xed, 0x76, 0x57, 
  0xdb, 0xed, 0x76, 0xd5, 0xe9, 0x28, 0x53, 0xad, 
  0xd6, 0xc1, 0x9b, 
};
unsigned char const scene1[] PROGMEM =
{
  127, 63,
  0x60, 0xd7, 0xa5, 0x72, 0x4e, 0x49, 0x25, 0xb7, 
  0xdb, 0xed, 0xae, 0xb6, 0xdb, 0xed, 0x76, 0xbb, 
  0xdd, 0x6e, 0xb7, 0x9f, 0xda, 0x6e, 0x95, 0x54, 
  0x52, 0x49, 0x25, 0x95, 0x74, 0xce, 0x39, 0xe7, 
  0xa4, 0x02, 0x1f, 0xb6, 0x55, 0x52, 0x49, 0x25, 
  0x95, 0x5d, 0x2a, 0xa9, 0xa4, 0x92, 0x4a, 0x2a, 
  0xb9, 0xdd, 0x6e, 0xb7, 0xdb, 0xed, 0x76, 0xab, 
  0xa4, 0x92, 0x4a, 0x2a, 0xbb, 0x54, 0x52, 0x49, 
  0x25, 0x95, 0x54, 0x72, 0xe0, 0x78, 0x5a, 0x2a, 
  0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 0x5c, 0xed, 
  0x9c, 0x73, 0xce, 0x39, 0xe7, 0x9c, 0x73, 0xce, 
  0x39, 0xe7, 0x9c, 0x73, 0x4a, 0x2a, 0xa9, 0x9c, 
  0x93, 0x4a, 0x2a, 0xe9, 0x1c, 0x78, 0xb3, 0xf4, 
  0x76, 0xab, 0xa4, 0x92, 0x4a, 0x2a, 0xa9, 0xa4, 
  0x92, 0x4a, 0x2a, 0xa9, 0xa4, 0xb2, 0x4b, 0x25, 
  0x95, 0x54, 0x52, 0x49, 0x25, 0x95, 0x54, 0x72, 
  0xbb, 0xdd, 0x06, 0x07, 0x2b, 0xe7, 0x9c, 0x73, 
  0xce, 0x39, 0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 
  0x9c, 0x93, 0xca, 0x0e, 0x5e, 0x6e, 0x47, 0x19, 
  0x86, 0xc2, 0x17, 0x44, 0xb4, 0x54, 0xce, 0x39, 
  0xa7, 0xa4, 0x92, 0xdb, 0xed, 0x76, 0xbb, 0x5d, 
  0x3a, 0xa9, 0xa4, 0x73, 0xce, 0x49, 0x65, 0x87, 
  0x6e, 0xb3, 0xdb, 0xed, 0x76, 0x9b, 0xde, 0x6e, 
  0xb7, 0xeb, 0xe0, 0x2a, 0x17, 0xae, 0x42, 0x59, 
  0x6e, 0x05, 0x1b, 0x11, 0x87, 0xb7, 0x50, 0x94, 
  0xce, 0x2e, 0x95, 0x44, 0x11, 
};
unsigned char const scene2[] PROGMEM =
{
  127, 63,
  0xc0, 0x1f, 0xa5, 0xb7, 0xdb, 0x74, 0x3a, 0x9d, 
  0x4e, 0xa7, 0xb7, 0x4a, 0x2a, 0xe9, 0x9c, 0x73, 
  0xb5, 0x73, 0x4e, 0x81, 0x73, 0x4c, 0x67, 0xb7, 
  0x4b, 0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 0x2b, 
  0xa9, 0xa4, 0x92, 0x4a, 0x2a, 0xbb, 0x5d, 0x07, 
  0x5d, 0xe7, 0x9c, 0x92, 0x4a, 0x6e, 0x53, 0xa9, 
  0x74, 0x3a, 0x9d, 0x4e, 0x6f, 0x95, 0x83, 0x60, 
  0xb7, 0x4a, 0x2a, 0xa9, 0xa4, 0x93, 0xca, 0x39, 
  0xe7, 0x9c, 0x92, 0x4a, 0x2a, 0xa9, 0xa4, 0x92, 
  0x4a, 0x3a, 0x27, 0x95, 0x5d, 0xe7, 0x9d, 0x73, 
  0xca, 0x0e, 0xdf, 0xa5, 0xd3, 0xe9, 0x74, 0x3a, 
  0x1d, 0x9e, 0x9d, 0x23, 0x0c, 0x63, 0x51, 0xef, 
  0x6a, 0x1b, 0xd6, 0x3a, 0xb5, 0x55, 0x52, 0x49, 
  0xa7, 0x60, 0x7d, 0xa7, 0xec, 0x36, 0x9d, 0x4a, 
  0x85, 0xb1, 0x70, 0x19, 0x5b, 0xf4, 0x4b, 0x4c, 
  0xa7, 0xd3, 0xeb, 0xec, 0x76, 0xbb, 0xdd, 0x6e, 
  0xd3, 0xe9, 0x74, 0x3a, 0x9d, 0x0e, 0x74, 0x52, 
  0x3a, 0x9d, 0x4e, 0xa7, 0x43, 0x63, 0x3a, 0x9d, 
  0x4e, 0xa7, 0xd3, 0xe9, 0x74, 0x30, 0xb4, 0x72, 
  0x52, 0xd9, 0x74, 0x7c, 0x51, 0x85, 0xa0, 0x74, 
  0x3a, 0x9d, 0x4e, 0xa7, 0x77, 0x9d, 0xde, 0x6e, 
  0xb7, 0x4b, 0xa7, 0xc0, 0xac, 0xa5, 0xd3, 0xdb, 
  0x6d, 0xa0, 0x4d, 0x01, 
};
unsigned char const scene3[] PROGMEM =
{
  127, 63,
  0xe0, 0x52, 0x55, 0x13, 0x46, 0xb8, 0x54, 0xce, 
  0x55, 0x52, 0x49, 0x25, 0x95, 0x54, 0x90, 0x93, 
  0x92, 0x3a, 0xba, 0x30, 0x14, 0x92, 0xe0, 0x25, 
  0x54, 0xc5, 0xae, 0x1c, 0x1c, 0xa4, 0x9c, 0x73, 
  0x4e, 0x2a, 0xb9, 0x55, 0x52, 0x49, 0x25, 0x95, 
  0x54, 0x52, 0x49, 0xe5, 0x2e, 0xe7, 0xec, 0xf0, 
  0x58, 0x3a, 0x68, 0x2f, 0xbd, 0x55, 0x52, 0x49, 
  0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 0x87, 0xad, 
  0xa4, 0x42, 0x55, 0x9c, 0x69, 0x25, 0xa5, 0xb2, 
  0xe3, 0x39, 0x9d, 0x4e, 0x6f, 0xd7, 0xd9, 0xed, 
  0x76, 0xbb, 0x4d, 0xa7, 0x83, 0xbd, 0xd2, 0xe9, 
  0x74, 0x3a, 0x9d, 0x4e, 0xa7, 0xd3, 0xe9, 0x74, 
  0x3a, 0xe8, 0x3a, 0xbd, 0x22, 0x0e, 0x89, 0xb9, 
  0xb4, 0x92, 0x52, 0xc1, 0x9c, 0x4b, 0xe7, 0xa4, 
  0x52, 0xb5, 0x5d, 0x2a, 0xe7, 0x94, 0x54, 0x52, 
  0x49, 0x25, 0x95, 0x74, 0x52, 0x39, 0xe7, 0x9c, 
  0x73, 0xce, 0x39, 0x65, 0x83, 0xf8, 0xe4, 0x36, 
  0x9d, 0x4a, 0xa5, 0xd3, 0xa1, 0x2e, 0x2c, 0x86, 
  0xcc, 0xa8, 0x23, 0x4c, 0x82, 0xca, 0x4a, 0x6f, 
  0xb7, 0x4a, 0x2a, 0xe9, 0xa4, 0x72, 0xce, 0x39, 
  0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 0x9c, 0x73, 
  0xce, 0x29, 0xbb, 0x54, 0x52, 0x49, 0x25, 0x95, 
  0x54, 0x52, 0x49, 0x25, 0x95, 0x54, 0x72, 0xbb, 
  0xdd, 0x6e, 0xb7, 0xe9, 0x74, 0x90, 0x50, 0xd2, 
  0x29, 0xa9, 0xa4, 0x92, 0x4a, 0x95, 0x73, 0x52, 
  0x49, 0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 0x95, 
  0x54, 0x52, 0x49, 0x25, 0x95, 0xdd, 0x6e, 0xb7, 
  0xeb, 0xd0, 0x96, 0xce, 0x2e, 0x95, 0x54, 0x52, 
  0xd9, 0x75, 0x50, 0xd2, 0xd2, 0x29, 0xa9, 0xa4, 
  0x92, 0x4a, 0x2a, 0x55, 0x4a, 0x2a, 0xa9, 0xa4, 
  0x92, 0xaa, 0x94, 0x92, 0xca, 0x6e, 0xb7, 0x31, 
  0x77, 0x44, 0x5b, 0xa5, 0xa0, 0xe4, 0xad, 0x92, 
  0xce, 0xd9, 0x75, 0x2a, 0x9c, 0xc5, 0x1c, 0xaa, 
  0xb2, 0xab, 0xde, 0x6e, 0xb7, 0xdb, 0x75, 0x44, 
  0x31, 0xc5, 0x94, 0xce, 0x2e, 0x95, 0x73, 0x83, 
  0x0d, 0x4b, 0xa7, 0xb7, 0xdb, 0xed, 0x36, 0x9d, 
  0x4e, 0xa7, 0x03, 0x9d, 0x06, 
};
unsigned char const scene4[] PROGMEM =
{
  127, 63,
  0x60, 0xb3, 0xa5, 0x92, 0xca, 0x39, 0x77, 0x39, 
  0xe7, 0x9c, 0x92, 0x4a, 0x2a, 0xa9, 0x9c, 0x74, 
  0x52, 0x49, 0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 
  0x95, 0x54, 0x52, 0x49, 0xe5, 0x9c, 0x73, 0xce, 
  0xb9, 0xcb, 0x39, 0xe7, 0xa4, 0xb2, 0xc3, 0xc1, 
  0x4e, 0xc9, 0xed, 0x52, 0xd9, 0xed, 0x76, 0xbb, 
  0xcd, 0x75, 0xba, 0x92, 0xe9, 0x74, 0x3a, 0x9d, 
  0x4e, 0xa7, 0xd3, 0xc9, 0x4a, 0x67, 0x95, 0x74, 
  0x0a, 0x26, 0x53, 0xd2, 0x39, 0xa9, 0xec, 0x76, 
  0xbb, 0x54, 0x52, 0x49, 0xe5, 0x9c, 0x73, 0xce, 
  0x39, 0xe7, 0x9c, 0x73, 0xce, 0x5d, 0x4e, 0x2a, 
  0xa9, 0xa4, 0x92, 0x4a, 0x2a, 0xa9, 0xa4, 0x72, 
  0xce, 0x39, 0x25, 0x95, 0x1c, 0x56, 0x4e, 0xa7, 
  0xd3, 0xdb, 0xed, 0x76, 0xbb, 0x4d, 0x07, 0x72, 
  0x7c, 0xa9, 0x9c, 0x73, 0xce, 0x5d, 0xce, 0x39, 
  0xe7, 0x9c, 0x54, 0x52, 0x49, 0x65, 0xd7, 0xe9, 
  0xd0, 0x96, 0x54, 0xce, 0x29, 0xa9, 0xa4, 0x92, 
  0x4a, 0x95, 0x92, 0x4a, 0x2a, 0xa9, 0xa4, 0x92, 
  0x4a, 0x2a, 0xe9, 0x9c, 0x1d, 0x6d, 0x39, 0x87, 
  0xa6, 0xa4, 0x72, 0xce, 0x39, 0xe7, 0x94, 0x54, 
  0xce, 0x49, 0x25, 0x9d, 0x73, 0xce, 0x39, 0xe7, 
  0x9c, 0x73, 0xce, 0x39, 0xa9, 0xa4, 0x92, 0x4a, 
  0x2a, 0xa9, 0xe4, 0x56, 0x49, 0x25, 0x95, 0x54, 
  0x52, 0x49, 0x25, 0x95, 0xdd, 0xae, 0x83, 0x7f, 
  0xb7, 0x4a, 0x3a, 0xa7, 0x43, 0x56, 0x98, 0x4a, 
  0xa7, 0xd3, 0xe9, 0xc8, 0xc2, 0x5b, 0x3a, 0x1d, 
  0x65, 0x38, 0x0b, 0x4d, 0x78, 0xda, 0x6e, 0x95, 
  0x54, 0x52, 0x49, 0x25, 0x95, 0x54, 0x52, 0x49, 
  0x25, 0x95, 0x54, 0xd2, 0x39, 0xe7, 0xa4, 0x92, 
  0xea, 0xd4, 0x76, 0xbb, 0xdd, 0x6e, 0xb7, 0x4b, 
  0x65, 0xb7, 0xdb, 0xed, 0xe5, 0xb6, 0x4b, 0xa5, 
  0x20, 0xeb, 0xf4, 0x56, 0x49, 0x25, 0x9d, 0x73, 
  0xce, 0x39, 0xe7, 0x9c, 0x73, 0xce, 0x39, 0xe7, 
  0x9c, 0x73, 0xce, 0x39, 0xe7, 0x94, 0x54, 0x72, 
  0xac, 0xa5, 0xb7, 0x4a, 0x3a, 0xe7, 0x9c, 0x73, 
  0x52, 0x49, 0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 
  0x81, 0x02, 0x08, 
};
unsigned char const scene5[] PROGMEM =
{
  127, 63,
  0xa0, 0xd9, 0xec, 0x52, 0x39, 0xa7, 0xa4, 0x92, 
  0x4a, 0x2a, 0xb9, 0xdd, 0xa6, 0xd3, 0xa9, 0x54, 
  0x3a, 0xbb, 0x4e, 0xa7, 0xd3, 0x95, 0x4c, 0xa7, 
  0xd3, 0xb9, 0x4e, 0xa7, 0xd3, 0x59, 0xe5, 0x20, 
  0xaa, 0xec, 0x52, 0x49, 0x25, 0x95, 0x54, 0xce, 
  0x39, 0xa7, 0xa4, 0x92, 0x4b, 0x65, 0xd3, 0xe9, 
  0x74, 0x3a, 0xdd, 0xb9, 0x74, 0x3a, 0x9d, 0xde, 
  0x2a, 0xe9, 0x9c, 0x54, 0x76, 0x88, 0x99, 0x36, 
  0xb2, 0xd0, 0xb4, 0x73, 0x4a, 0x2a, 0xb9, 0xdd, 
  0x6e, 0xb7, 0xdb, 0x6d, 0x3a, 0x9d, 0x4e, 0xa7, 
  0xd3, 0x41, 0x63, 0x5b, 0x25, 0x95, 0x54, 0x52, 
  0x49, 0x25, 0x95, 0x54, 0x52, 0x49, 0x25, 0x95, 
  0x54, 0x52, 0xc9, 0x6d, 0x7a, 0xbb, 0xdd, 0x6e, 
  0x95, 0x74, 0xce, 0x2a, 0x2c, 0xe5, 0xb7, 0xce, 
  0xd9, 0xd1, 0x99, 0x0e, 0x7e, 0x54, 0x52, 0x87, 
  0xad, 0x08, 0xb7, 0xdb, 0x5d, 0x6d, 0xd3, 0xe9, 
  0x4a, 0xa6, 0xd3, 0xdb, 0x5d, 0x6d, 0xb7, 0xdb, 
  0xed, 0x76, 0x9b, 0x4e, 0xa7, 0xd3, 0x9d, 0x5a, 
  0x3a, 0x05, 0x65, 0x6e, 0xb1, 0x16, 0x11, 0x86, 
  0x6c, 0x64, 0x21, 0x2a, 0xad, 0x24, 0x7c, 0x99, 
  0x4e, 0xa7, 0xb7, 0xdb, 0xed, 0x76, 0xbb, 0xdd, 
  0x6e, 0xb7, 0xdb, 0xed, 0x76, 0xbb, 0xdd, 0xa6, 
  0xd3, 0xe9, 0x74, 0x70, 0x96, 0x72, 0xce, 0x39, 
  0xa7, 0xa4, 0x73, 0x4e, 0x2a, 0x1d, 0xba, 0xb3, 
  0x3b, 0xce, 0xd0, 0xc5, 0x8f, 0xa4, 0x79, 0xb3, 
  0x2b, 0x90, 0x52, 0x69, 0x25, 0x9d, 0x73, 0x4e, 
  0x2a, 0xa9, 0xec, 0x76, 0xbb, 0x8e, 0x32, 0x94, 
  0xa6, 0xd3, 0xe9, 0xec, 0xf6, 0x52, 0xca, 0x39, 
  0x25, 0x43, 0x93, 0x54, 0x52, 0x39, 0xe7, 0x9c, 
  0x92, 0xdb, 0x40, 0x93, 0xa5, 0xd3, 0xe9, 0x80, 
  0x8e, 0x08, 
};

Credits

Johan_Ha

Johan_Ha

13 projects • 21 followers
Music teacher Composer Coding for fun
Thanks to evgenykzz2 .

Comments