Tag Archives: UNO

Maze Game using an 8×8 addressable LED panel

Introducing the Maze Game

(Updated: 3 February 2016)

This is a conceptually simple maze game that requires the player to make a light “ball” follow the path of a maze by tilting the panel in both x and y axis. As play progress, the colour of the ball reflects the number of times the player has come off the path and restarts if too many miss steps have been made. Once the path has been completed, the player advances to the next level with a more complex maze. At this point there are 10 levels with 10 different mazes.

Maze Game: level 3 maze showing hazards (red) and health (green) spots

Maze Game: level 3 maze showing hazards (red) and health (green) spots

Continue reading

WEATHERMAN: Web Weather Forecaster

How many times have you asked yourself “What’s the weather going to be like today and over the next couple of days?” Then you have to turn on your computer, pull up a web page with a weather forecast, and wade through all the ads.  Yep, I know. Pretty tiring and time-consuming.

So now, the wait is over!

Introducing “Weatherman: Web Weather Forecaster“, the web-based three-day weather forecaster that provides all you ever wanted to know, right at your fingertips… literally!

Weatherman

Weatherman: Web Weather Forecaster showing today’s weather conditions. A low of 15 to a high of 19.6 degrees C, 53% humidity and a pressure of 1000mb, with overcast clouds and winds from the SSW at 1.9kph.

Weatherman: Web Weather Forecaster showing

Weatherman: Web Weather Forecaster showing tomorrow’s weather

Weatherman: Web Weather Forecaster showing

Weatherman: Web Weather Forecaster showing Monday’s weather

Continue reading

Two-Four Timepiece – 24 hour clock

Introducing the latest clock from WoodUino – The Two-Four Timepiece 24 hour analogue clock. The Two-Four Timepiece shows a complete day at a time, and marks out time with an hour hand, minute circles and a gently pulsing seconds marker. Sunrise and sunset times are displayed and the display’s colour scheme changes between daytime and nighttime.

TwoFourTimepiece

Two-Four Timepiece at 10:29PM showing the nighttime colour scheme

TwoFourTimepiece

Two-Four Timepiece at 8:37AM showing (not very clearly) the daylight colour scheme

The Two-Four Timepiece display is built using a total of 89 addressable LEDs arranged in strips that radiate from a central point. The strips are adhered to a perforated PCB substrate cut into a squared-base circle shape. The LED strip is controlled by a discrete Arduino UNO and a battery-backed up real-time clock that keeps accurate local time. Sunrise and sunset times are determined using the user’s location (longitude and latitude) and GMT offset (using the DST algorithms previously described) using the sundata.h library, as used in the Graphic LCD Analogue Clock and SolarTracer.

Continue reading

Web-based Weather Station

This Arduino project displays information on a 4-line LCD of local weather conditions. Using an Ethernet shield on an Arduino UNO, the unit requests data from openweathermap.org (using their api) and parses the information to obtain temperature (current, min and max), humidity, pressure, wind speed and direction, and textual description of current conditions. It is intended that this project will migrate from using the current Ethernet shield / UNO combination to an Nano and ESP8266 WiFi module for simple WiFi connectivity, However, I thought that this current version – naked and unhoused – may be on interest to some of you.

Web Weather Station

Web Weather Station

Continue reading

Artist’s Installation: Escalators

Over the past ten years or so, I’ve been fortunate enough to have worked with several artists to create systems for them to display their artwork. You can see some of these here. Most of these pieces have been built out of wood, copper and more recently, welded steel. So when Lise, my poet partner, was invited to participate in an installation at the Blink Gallery, entitled “Something Leads to Something Else“, curated by a wonderful Ottawa artist, Deborah Margo, my creative juices started to flow!

Here is a picture of the final result and a close-up of one of the two escalators used in the installation.

Lise's Art Installation

Lise’s Art Installation

Escalator-p1

One of a pair of escalators for the installation

 

 

 

 

 

 

Read more…

 

LED Matrix Clocks

I developed a couple of clocks using a couple of red 8×8 LED Matrix Modules – the 2D MATRIX CLOCK and the TIME & TEMP MATRIX CLOCK

The 2D MATRIX CLOCK, time is displayed by scrolling from left to right, or, under software control, from top to bottom. Each digit of the time successively slides in from the right side and when centered, stops momentarily and brightens slightly. It then scrolls to the left while the next digit in the display scrolls into view. The cycle repeats with a short delay between successive displays.

 

[codesyntax lang=”php” title=”2D Matrix Clock – Arduino Source Code” blockstate=”collapsed”]

//*****************************************************************************************//
//                                      MATRIX CLOCK
//                                 Adrian Jones, March 2014
//
//    - allows left-to-right and top-to-bottom scrolling
//
//*****************************************************************************************//
#include "ascii.h"
#include <Wire.h>             // I2C-WIRE library
#include <RTClib.h>           // RTC-Library

// define max7219 registers and control pins
#define max7219_reg_noop        0x00
#define max7219_reg_digit0      0x01
#define max7219_reg_digit1      0x02
#define max7219_reg_digit2      0x03
#define max7219_reg_digit3      0x04
#define max7219_reg_digit4      0x05
#define max7219_reg_digit5      0x06
#define max7219_reg_digit6      0x07
#define max7219_reg_digit7      0x08
#define max7219_reg_decodeMode  0x09
#define max7219_reg_intensity   0x0a
#define max7219_reg_scanLimit   0x0b
#define max7219_reg_shutdown    0x0c
#define max7219_reg_displayTest 0x0f
#define dataIn  5             // DIN
#define load    6             // CS 
#define clock   7             // CLK

// define RTC operation
RTC_DS1307 RTC;               // Tiny RTC (DS1307) module (SDA - A4, SCL - A5)

// rotary encoder, switch and LED control
#define enc_PinA   2          // encoder A to pin 2  (interrupt 0)
#define enc_PinB   4          // encoder B to pin 4
#define enc_Switch 3          // encoder switch to pin 3 (interrupt 1)
#define mode_Pin   8          // mode LED pin
#define min_Pin    9          // minute LED pin

unsigned char enc_A, enc_B, enc_A_prev=0;

static boolean rotating  = false;
static boolean clockwise = false;
static boolean updateFlag= false;
static int mode = 0;          // 0 - nothing, 1 - hour set, 2 - min set

// define display strings
#define max_array_size 100
char ac[max_array_size] = {};
byte rc[8] = {};
String display_message = "";
int arraylen;


// operational parameters
#define delay_line 100       // ms between line shifts
#define delay_char 400       // ms between characters
#define delay_mess 500       // ms between messages
#define cblanks 1            // number of blank lines between characters
#define eblanks 0            // number of additional blank lines (above 8) at the end of the message

// display features
static boolean top2bottom  = false;      // display direction (top to bottom, or right to left
static boolean hour24      = false;      // 24 hour display?
static boolean charHI      = true;       // highlight whole character

static boolean doSerial = true;           // serial output?


//*****************************************************************************************//
//                                      Initial Setup
//*****************************************************************************************//

void setup () {
  Wire.begin();
  
  Serial.begin(57600);
  if(doSerial) Serial.print("MATRIX Clock - Adrian Jones, Mar. 2014");
  
  // 8x8 LED matrix control pins
  pinMode(dataIn, OUTPUT);
  pinMode(clock,  OUTPUT);
  pinMode(load,   OUTPUT);
  initMatrix();                            // initialize LED matrix

  // LED pins
  pinMode(mode_Pin, OUTPUT);               // mode pin
  digitalWrite(mode_Pin, 1);
  pinMode(min_Pin, OUTPUT);                // minute pin
  digitalWrite(min_Pin, 1);
  
  // encoder control
  pinMode(enc_PinA, INPUT_PULLUP);  digitalWrite(enc_PinA,   HIGH);      // rotary encoder pin A
  pinMode(enc_PinB, INPUT_PULLUP);  digitalWrite(enc_PinB,   HIGH);      // rotary encoder pin B
  pinMode(enc_Switch, INPUT_PULLUP);digitalWrite(enc_Switch, HIGH);      // encoder switch
  
  attachInterrupt(0, rotEncoder, CHANGE);    // time setting
  attachInterrupt(1, swEncoder,  CHANGE);    // mins / hours

  // RTC  
  RTC.begin();
  if (! RTC.isrunning()) {   
    RTC.adjust(DateTime(__DATE__, __TIME__));
    if(doSerial) Serial.println("  (RTC reset)");
  } else {
    if(doSerial) Serial.println("  (RTC running)");
  }
  
}  

//*****************************************************************************************//
//                                      Main Loop
//*****************************************************************************************//

void loop () {

    DateTime now = RTC.now();   // 
    show_time_and_date(now);                    // display time
    display_message = createMessage(now);
    arraylen = initDisplayString(display_message);
    
    if(updateFlag) {
      show_time_and_date(now);
      updateFlag = false;  
    }

    while(rotating) {
      delay(1);                                   // debounce
      adjTime(now, clockwise); 
      show_time_and_date( RTC.now() );
      display_message = createMessage(now);
      arraylen = initDisplayString(display_message);
      delay(1);
      rotating = false;       // Reset the interrupt flag back to false
    }
    delay(5);

    for (int i = 0; i < (arraylen-7); i++) {                       // loops through message array, advancing one byte at a time
      for (int j = 1; j < 9; j++) { maxSingle(j,ac[i+8-j]);  }     // row 1 gets ac[i+8], row 2 gets ac[i+7] etc... row 8 gets ac[i+0]
      if(i%(8+cblanks) == 0) {                                     // when there is a complete character on the display...
          if(charHI) maxSingle(max7219_reg_intensity, 0x01);       // ... increase brightness and temporary halt
          newDelay(delay_char);
      } else {                                                     // normal brightness
          maxSingle(max7219_reg_intensity, 0x00);
          newDelay(delay_line);
      }
    }
    if(mode == 0) newDelay(delay_mess);
}

// ********************************************************************************** //
//                                      INTERRUPT ROUTINES
// ********************************************************************************** //

// function rotEncoder(): ISR called when encoder rotated
void rotEncoder(){
  delay(1);
  enc_A = digitalRead(enc_PinA); 
  enc_B = digitalRead(enc_PinB);
  if(!enc_A && enc_A_prev){      // change of state
    clockwise = (!enc_A && enc_B)? true : false;
    if(mode != 0) rotating = true;
  } 
  enc_A_prev = enc_A;     // Store value of A for next time    
}

// function swEncoder(): ISR called when encoder button pushed
void swEncoder(){
  delay(1);
  if(digitalRead (enc_Switch) != LOW) return;  // if switch depressed
  delay(1);                                    // debounce  
  if(digitalRead (enc_Switch) != LOW) return;  // if switch still depressed
  mode++; mode = mode % 3;                     // increment mode
  digitalWrite(mode_Pin, !(mode == 1));        // hour adjust LED
  digitalWrite(min_Pin,  !(mode == 2));        // minute adjust LED
  updateFlag = true;
}

// ********************************************************************************** //
//                                      OPERATION ROUTINES
// ********************************************************************************** //

// function newDelay
void newDelay (int dly) {
  for (int z=1; z< dly; z++) {
    delay(1);
    if(rotating || updateFlag) break;
  }
}



// function initMatrix()  :   initialization of the MAX7219 registers
void initMatrix() {
      maxSingle(max7219_reg_scanLimit, 0x07);       // all 8 columns being used
      maxSingle(max7219_reg_decodeMode, 0x00);      // set to LED matrix (not 7 seg. digit)
      maxSingle(max7219_reg_shutdown, 0x01);        // not in shutdown mode
      maxSingle(max7219_reg_displayTest, 0x00);     // not in display test
      for (int e=1; e<=8; e++) {maxSingle(e,0); }   // clear LED registers (turn all LEDs off)
      maxSingle(max7219_reg_intensity, 0x00);       // set intensity. Range: 0x00 to 0x0f 
}

// function adjTime(): increments/decrements (based encoder direction) hours/mins (depending on mode)
void adjTime(DateTime now, boolean dir) {
  if(mode == 1) {    // adjust hours
    int adj_hrs = now.hour();
    if(dir) {        // increment
       if(++adj_hrs >= 25) adj_hrs = 1;
    } else {         // decrement
      if(adj_hrs == 0) adj_hrs = 24;
      if(--adj_hrs <= 0) adj_hrs = 24;
    }
    RTC.adjust(DateTime(now.year(), now.month(), now.day(), adj_hrs, now.minute(), now.second() ));
  } 
  
  if(mode == 2) {    // adjust minutes
    int adj_mins = now.minute();
    if(dir) {   
      if(++adj_mins >= 60) adj_mins = 0; 
    } else {
      if(--adj_mins < 0) adj_mins = 59; 
    }
    RTC.adjust(DateTime(now.year(), now.month(), now.day(), now.hour(), adj_mins, now.second() ));
  }
}


// function rotChar(char): for character char, transposes bits 90 deg. (top - bottom ==> left - right)
// and stores results in rc[0] - rc[7].
byte rotChar(char inLetter) {
   int ind = int(inLetter) - 0x20;
   for (int col = 0; col < 8; col++) {
     byte mask = 0x01 << (7-col);
     for (int row = 0; row < 8 ; row++) { bitWrite(rc[col], 7-row,(alphanum[ind][row] & mask)); }
   }
}  


// function show_time_and_date:  print out time string & bytes
void show_time_and_date(DateTime datetime){
  if(doSerial) {
    int minutes = datetime.minute();
    int hours   = datetime.hour(); if(hours==0) hours=24;
    int seconds = datetime.second();
    char delim = '/'; char dend = ' ';
    String te = "Current date/time: ";
    te = te + datetime.year() + delim + datetime.month() + delim + datetime.day() + dend;

    Serial.print(te);
    if(hours<10) Serial.print(0); Serial.print(hours,DEC);
    Serial.print(":");
    if(minutes<10) Serial.print(0); Serial.print(minutes,DEC);
    Serial.print(":");
    if(seconds < 10) Serial.print(0); Serial.print(seconds,DEC);
    Serial.println("");
  } 
}


String createMessage(DateTime datetime) {
  String new_mess = " ";
  int hr = datetime.hour()%24;    if(hr == 0) hr = 24;
  int mn = datetime.minute();
  if(mode == 0) {                  // Normal mode
    if(hour24) { 
      new_mess += hr;
    } else {
      new_mess += (hr > 12)? hr - 12 : hr;
    }
    new_mess += ':';
    if(mn < 10) new_mess += '0'; new_mess += mn;
    if(!hour24) new_mess += (hr > 12)? "~" : "^";
  }
  
  if(mode == 1) {                  // Adjusting hours
    new_mess += hr;
  }  
  
  if(mode == 2) {                 // Adjusting minutes
    if(mn < 10) new_mess += '0'; new_mess += mn;
  }
  return new_mess;
}


// function initDisplayString()  :   creates array of message string with blanks between characters and at end
int initDisplayString(String message) {
  int x = 0;
  for (int y = 0; y < message.length(); y++ ){
    char thisCh = message.charAt(y);
    int ind = int(thisCh) - 0x20;
    if(!top2bottom) rotChar(thisCh);
    for (int row = 0; row < 8 + cblanks; row++) {
      if (row <= 7) {
        ac[x] = (top2bottom)? alphanum[ind][7-row] : rc[row];
      } else {
         ac[x] = 0;
      }
      x++;
    }
  }

  for(int y = 0; y < 7+eblanks; y++) {ac[x] = 0; x++; }    // end blanks
  return x;
}


// function maxSingle()  :   loads data into register 
void maxSingle(byte reg, byte col) {      
  digitalWrite(load, LOW);       // begin    
  putByte(reg);                    // specify register
  putByte(col);                    // ((data & 0x01) * 256) + data >> 1); // put data  
  digitalWrite(load,HIGH);
}


// function putByte()  :   loads data to matrix, MSB to LSB 
void putByte(byte data) {
  byte i = 8;
  byte mask;
  while(i > 0) {                 // MSB to LSB
    mask = 0x01 << (i - 1);      // create bitmask
    digitalWrite(clock, LOW);   // tick
    if (data & mask){            // choose bit
      digitalWrite(dataIn, HIGH);// send 1
    } else {
      digitalWrite(dataIn, LOW); // send 0
    }
    digitalWrite(clock, HIGH);   // tock
    --i;                         // move to lesser bit
   }
}
     

      
     

[/codesyntax]

[codesyntax lang=”php” title=”2D Matric Clock – Arduino Include File (ascii.h)” blockstate=”collapsed”]

char alphanum[][8] ={{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},    // blank  Hex 20  Dec 32
                     {0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x10},    // ! 33
                     {0x00,0x28,0x28,0x28,0x00,0x00,0x00,0x00},    // " 34
                     {0x00,0x28,0x7C,0x28,0x7C,0x28,0x00,0x00},    // # 35
                     {0x10,0x38,0x50,0x38,0x14,0x54,0x38,0x10},    // $
                     {0x41,0xA2,0x44,0x08,0x10,0x22,0x45,0x82},    // %
                     {0x38,0x44,0x44,0x38,0x50,0x4A,0x44,0x3A},    // &
                     {0x08,0x08,0x00,0x00,0x00,0x00,0x00,0x00},    // '
                     {0x30,0x40,0x80,0x80,0x80,0x80,0x40,0x30},    // (  40
                     {0xC0,0x20,0x10,0x10,0x10,0x10,0x20,0xC0},    // )
                     {0x28,0x10,0xAA,0x54,0xAA,0x10,0x28,0x00},    // *
                     {0x00,0x10,0x10,0x10,0xFE,0x10,0x10,0x10},    // +
                     {0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x10},    // ,
                     {0x00,0x00,0x00,0x00,0x7E,0x00,0x00,0x00},    // -
                     {0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18},    // .
                     {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80},    // /
                     {0x7E,0xC1,0xA1,0x91,0x89,0x85,0x83,0x7E},    // 0
                     {0x10,0x30,0x10,0x10,0x10,0x10,0x10,0x7C},    // 1
                     {0x38,0x44,0x82,0x04,0x18,0x20,0x40,0xFE},    // 2   50
                     {0x7C,0x82,0x02,0x3C,0x02,0x02,0x82,0x7C},    // 3
                     {0x08,0x18,0x28,0x48,0xFE,0x08,0x08,0x08},    // 4
                     {0xFE,0x80,0xF8,0x04,0x02,0x82,0x44,0x38},    // 5
                     {0x38,0x44,0x80,0xB8,0xC4,0x82,0x44,0x38},    // 6
                     {0xFE,0x02,0x04,0x08,0x10,0x20,0x20,0x20},    // 7
                     {0x7C,0x82,0x82,0x7C,0x82,0x82,0x82,0x7C},    // 8
                     {0x7C,0x82,0x82,0x7E,0x02,0x82,0x44,0x38},    // 9
                     {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00},    // :
                     {0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30},    // ;
                     {0x00,0x10,0x20,0x40,0x80,0x40,0x20,0x10},    // <  60
                     {0x00,0x00,0x00,0x7E,0x00,0x7E,0x00,0x00},    // =
                     {0x00,0x80,0x40,0x20,0x10,0x20,0x40,0x80},    // >
                     {0x70,0x88,0x88,0x10,0x20,0x20,0x00,0x20},    // ?
                     {0x7E,0x81,0x99,0xA1,0xA1,0x9E,0x80,0x7E},    // @
                     {0x3C,0x42,0x81,0x81,0xFF,0x81,0x81,0x81},    // A
                     {0xFC,0x82,0x81,0xFE,0x81,0x81,0x82,0xFC},    // B
                     {0x3C,0x42,0x81,0x80,0x80,0x81,0x42,0x3C},    // C
                     {0xFC,0x82,0x81,0x81,0x81,0x81,0x82,0xFC},    // D
                     {0xFE,0x80,0x80,0xFC,0x80,0x80,0x80,0xFE},    // E
                     {0xFE,0x80,0x80,0xFC,0x80,0x80,0x80,0x80},    // F  70
                     {0x3C,0x42,0x81,0x80,0x87,0x81,0x42,0x3C},    // G
                     {0x81,0x81,0x81,0xFF,0x81,0x81,0x81,0x81},    // H
                     {0xFE,0x10,0x10,0x10,0x10,0x10,0x10,0xFE},    // I
                     {0xFF,0x08,0x08,0x08,0x08,0x88,0x88,0x70},    // J
                     {0x88,0x90,0xA0,0xC0,0xA0,0x90,0x88,0x84},    // K
                     {0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xFE},    // L
                     {0x81,0xC3,0xA5,0x99,0x81,0x81,0x81,0x81},    // M
                     {0x81,0xC1,0xA1,0x91,0x89,0x85,0x83,0x81},    // N
                     {0x3C,0x42,0x81,0x81,0x81,0x81,0x42,0x3C},    // O
                     {0xFC,0x82,0x81,0x82,0xFC,0x80,0x80,0x80},    // P  80
                     {0x3C,0x42,0x81,0x81,0x81,0x85,0x42,0x3D},    // Q
                     {0xFC,0x82,0x81,0x82,0xFC,0x84,0x82,0x81},    // R
                     {0x3C,0x42,0x81,0x40,0x3E,0x81,0x42,0x3C},    // S
                     {0xFE,0x10,0x10,0x10,0x10,0x10,0x10,0x10},    // T
                     {0x82,0x82,0x82,0x82,0x82,0x82,0x44,0x38},    // U
                     {0x82,0x82,0x82,0x82,0x82,0x44,0x28,0x10},    // V
                     {0x81,0x81,0x81,0x81,0x99,0xA5,0xC3,0x81},    // W
                     {0x81,0x42,0x24,0x18,0x18,0x24,0x42,0x81},    // X
                     {0x82,0x44,0x28,0x10,0x10,0x10,0x10,0x10},    // Y
                     {0xFF,0x02,0x04,0x08,0x10,0x20,0x40,0xFF},    // Z  90
                     {0xE0,0x80,0x80,0x80,0x80,0x80,0x80,0xE0},    // [ 
                     {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01},    // 
                     {0x07,0x01,0x01,0x01,0x01,0x01,0x01,0x07},    // ]
                     {0xE0,0xA0,0xE0,0xA0,0xAA,0x15,0x15,0x11},    // am (coded as '^'
                     {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7E},    // _
                     {0x10,0x08,0x00,0x00,0x00,0x00,0x00,0x00},    // '
                     {0x00,0x00,0x38,0x04,0x3C,0x44,0x48,0x34},    // a
                     {0x00,0x40,0x40,0x40,0x78,0x44,0x44,0x38},    // b
                     {0x00,0x00,0x18,0x24,0x40,0x40,0x24,0x18},    // c
                     {0x00,0x04,0x04,0x04,0x3C,0x44,0x44,0x38},    // d  100
                     {0x00,0x00,0x38,0x44,0x7C,0x40,0x44,0x38},    // e
                     {0x00,0x18,0x20,0x20,0x78,0x20,0x20,0x20},    // f
                     {0x00,0x38,0x44,0x44,0x38,0x04,0x44,0x38},    // g
                     {0x00,0x40,0x40,0x40,0x78,0x44,0x44,0x44},    // h
                     {0x00,0x00,0x40,0x00,0x40,0x40,0x40,0x40},    // i
                     {0x00,0x08,0x00,0x08,0x08,0x08,0x48,0x30},    // j
                     {0x00,0x40,0x40,0x48,0x50,0x60,0x50,0x48},    // k 
                     {0x00,0x40,0x40,0x40,0x40,0x40,0x40,0x20},    // l
                     {0x00,0x00,0x00,0x28,0x54,0x44,0x44,0x44},    // m
                     {0x00,0x00,0x00,0x38,0x44,0x44,0x44,0x44},    // n  110
                     {0x00,0x00,0x00,0x38,0x44,0x44,0x44,0x38},    // o 
                     {0x00,0x00,0x70,0x48,0x48,0x70,0x40,0x40},    // p
                     {0x00,0x00,0x30,0x48,0x48,0x38,0x08,0x08},    // q
                     {0x00,0x00,0x00,0x30,0x48,0x40,0x40,0x40},    // r
                     {0x00,0x30,0x48,0x40,0x30,0x08,0x48,0x30},    // s
                     {0x00,0x20,0x70,0x20,0x20,0x20,0x28,0x10},    // t
                     {0x00,0x00,0x44,0x44,0x44,0x44,0x44,0x38},    // u
                     {0x00,0x00,0x44,0x44,0x44,0x44,0x28,0x10},    // v
                     {0x00,0x00,0x82,0x82,0x82,0x92,0x54,0x28},    // w
                     {0x00,0x00,0x84,0x48,0x30,0x30,0x48,0x84},    // x  120
                     {0x00,0x48,0x48,0x48,0x38,0x08,0x48,0x30},    // y 
                     {0x00,0x00,0x00,0x7C,0x08,0x10,0x20,0x7C},    // z
                     {0x00,0x30,0x40,0x40,0x80,0x40,0x40,0x30},    // {
                     {0x00,0x20,0x20,0x20,0x20,0x20,0x20,0x20},    // |
                     {0x00,0x60,0x10,0x10,0x08,0x10,0x10,0x60},    // }
                     {0xE0,0xA0,0xE0,0x80,0x8A,0x15,0x15,0x11}     // pm codes as '~'  Hex 7E, Dec 126
                   };

[/codesyntax]

 

The TIME & TEMP MATRIX CLOCK is a display unit that shows time, date and temperature on a LED matrix display. The time and temperature are displayed successively on the matrix display and immediately after a new minute, the day of the week, date, month and time are displayed.

 

Read more…

MIDI Foot Controller

The MIDI FOOT CONTROLLER is a simple foot pedal interface to allows keyboard players to rapidly change between preset MIDI settings.

MidiFootBoard-p16-switch MIDI Foot Controller

The unit provides 6 stomp switches, 4 of which are used to cycle through 3 sets (S1, S2, S3) of three MIDI presets. Each preset controls the program for up to 4 MIDI channels (MIDI channel 1 – 4). The remaining two switches allow the user to increment and decrement programs, from the current set and preset (MIDI channel 1) to allow for finer granularity of sound control.

Read more…