Revision 0:b3e0f5bb3b87, committed 2012-11-08

Comitter:

SomeRandomBloke

Date:

Thu Nov 08 21:41:33 2012 +0000

Child:

1:96695118ee13

Child:

7:b761bf1362ac

Commit message:

Initial commit after converting from Arduino to mbed

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/HT1632_LedMatrix.cpp	Thu Nov 08 21:41:33 2012 +0000
@@ -0,0 +1,655 @@
+/***********************************************************************
+ * HT1632_LedMatrix.cpp - Arduino library for Holtek HT1632 LED driver chip,
+ *     As implemented on the Sure Electronics DE-DP10X display board
+ *       (8 x 32 dot matrix LED module.)
+ *
+ * Original code by:
+ * Nov, 2008 by Bill Westfield ("WestfW")
+ *   Copyrighted and distributed under the terms of the Berkely license
+ *   (copy freely, but include this notice of original author.)
+ *
+ * Adapted for 8x32 display by FlorinC.
+ *
+ * Library Created and updated by Andrew Lindsay October/November 2009
+ ***********************************************************************/
+
+#include "mbed.h"
+#include "HT1632_LedMatrix.h"
+#include "font_5x7_p.h"
+
+// Use this define to select Direct port writes for speed or regular arduino digitalWrite functions
+#undef DIRECTIO
+
+#define HIGH 1
+#define LOW 0
+/*
+ * Set these constants to the values of the pins connected to the SureElectronics Module
+ * NOTE - these are different from the original demo code by westfw
+ *
+ * Use Pin Mappings 8-11 for CS1 to 4, 12 for Data and 13 for Clock
+ * Use mixture of #define and variables.
+ * Pin numbers are for setup and port identifiers are for direct port writes.
+ */
+
+// For mbed, use WR=p7, DATA=p5, cs1=p17, cs2=p18, cs3=p19, cs4=p20
+
+//#define LOWPINS
+//#define LOWPINS1
+//#define HIGHPINS
+
+//#ifdef LOWPINS
+DigitalOut ht1632_wrclk(p7); // For Test : Led1 is Clock
+DigitalOut ht1632_data(p5); //            Led2 is Data ....
+DigitalOut ht1632_cs1(p17);
+DigitalOut ht1632_cs2(p18);
+DigitalOut ht1632_cs3(p19);
+DigitalOut ht1632_cs4(p20);
+
+// Port D defines for 2-7
+// If using Nuelectronics ethernet shield, need to cut unused interrupt track to PD2
+//uint8_t ht1632_cs[4] = {ht1632_cs1, ht1632_cs2, ht1632_cs3, ht1632_cs4};    // Chip Select (1, 2, 3, or 4)
+DigitalOut  ht1632_cs[4] = {p17, p18, p19, p20};    // Chip Select (1, 2, 3, or 4)
+//volatile uint8_t* ht1632_cs_Port[4] = {&PORTD, &PORTD, &PORTD, &PORTD};    // Chip Select (1, 2, 3, or 4)
+//volatile uint8_t* ht1632_cs_DDR[4] = {&DDRD, &DDRD, &DDRD, &DDRD};    // Chip Select (1, 2, 3, or 4)
+//#define HT1632_DATA       6      // Data pin
+//#define HT1632_DATA_PORT  PORTD  // Data port
+//#define HT1632_DATA_DDR   DDRD   // Data port
+//#define HT1632_WRCLK      7      // Write clock pin
+//#define HT1632_WRCLK_PORT PORTD  // Write clock port
+//#define HT1632_WRCLK_DDR  DDRD   // Write clock port
+//#endif
+
+
+// helper macros
+//#define output_low(port,pin) port &= ~(1<<pin)
+//#define output_high(port,pin) port |= (1<<pin)
+#define chip_number(x,y) (x >> 5) + (y >> 3)*numYDevices
+#define chip_nibble_address(x,y) ((x%32)<<1) + ((y%8)>>2);  
+#define chip_byte_address(x,y) ((x%32)<<1);
+#define max(a, b)  (((a) > (b)) ? (a) : (b))
+
+
+// Display size and configuration, defaul is for a single 8x32 display
+uint8_t numDevices = 1;    // Total number of devices
+uint8_t numXDevices = 1;   // Number of horizontal devices
+uint8_t numYDevices = 1;   // Number of vertical devices
+uint8_t xMax = 32 * numXDevices-1;
+uint8_t yMax = 8 * numYDevices-1;
+
+// Variables used to keep track of cursor position
+int cursorX = 0;
+int cursorY = 0;
+
+/*
+ * we keep a copy of the display controller contents so that we can
+ * know which bits are on without having to (slowly) read the device.
+ */
+// 4 boards at 32 bytes per board + 1 byte means we don't need to check overwrite in putChar
+uint8_t shadowram[129];  // our copy of the display's RAM
+
+
+
+// Custom character buffers - 8 characters available
+// 6 cols * 8 rows - first byte of each char is the number of columns used
+// Bits are aranged in columns with LSB at top
+uint8_t cgram [8][7] = { 
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+    { 0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
+
+
+// Default constructor
+HT1632_LedMatrix::HT1632_LedMatrix( void ) {
+}
+
+
+void HT1632_LedMatrix::init( uint8_t xDevices, uint8_t yDevices ) {
+  // Set up the display size based on number of devices both horizontal and vertical
+  numXDevices = xDevices;
+  xMax = 32 * numXDevices-1;
+  numYDevices = yDevices;
+  yMax = 8 * numYDevices-1;
+
+  numDevices = numXDevices * numYDevices;
+
+//  HT1632_WRCLK_DDR |= _BV( HT1632_WRCLK );      // set pins to output
+//  HT1632_DATA_DDR |= _BV( HT1632_DATA );
+
+  for (uint8_t chipno=0; chipno<numDevices; chipno++){
+ //     *ht1632_cs_DDR[chipno] |= _BV( ht1632_cs[chipno] );   // output pin
+      chipfree(chipno);     // unselect it 
+      sendcmd(chipno, HT1632_CMD_SYSDIS);  // Disable system
+      sendcmd(chipno, HT1632_CMD_COMS10);  // 08*32, PMOS drivers
+      sendcmd(chipno, HT1632_CMD_MSTMD);    // Master Mode 
+      sendcmd(chipno, HT1632_CMD_SYSON);    // System on 
+      sendcmd(chipno, HT1632_CMD_LEDON);    // LEDs on 
+      sendcmd(chipno, HT1632_CMD_PWM | 0x0c);   // PWM Duty 
+      for (uint8_t i=0; i<96; i++)
+        senddata(chipno, i, 0);  // clear the display
+      wait(0.1);
+  }
+  cursorX = 0;
+  cursorY = 0;
+}
+ 
+/***********************************************************************
+ * chipselect / chipfree
+ * Select or de-select a particular ht1632 chip.
+ * De-selecting a chip ends the commands being sent to a chip.
+ * CD pins are active-low; writing 0 to the pin selects the chip.
+ ***********************************************************************/
+void HT1632_LedMatrix::chipselect(uint8_t chipno)
+{
+#ifdef DIRECTIO
+//  output_low(*ht1632_cs_Port[chipno], ht1632_cs[chipno]);
+#else
+//  digitalWrite( ht1632_cs[chipno], LOW );
+  
+#endif
+//ht1632_cs4 = LOW;
+    ht1632_cs[chipno] = LOW;
+}
+
+void HT1632_LedMatrix::chipfree(uint8_t chipno)
+{
+#ifdef DIRECTIO
+//  output_high(*ht1632_cs_Port[chipno], ht1632_cs[chipno]);
+#else
+//  digitalWrite( ht1632_cs[chipno], HIGH );
+#endif
+    ht1632_cs[chipno] = HIGH;
+//ht1632_cs4 = HIGH;
+}
+
+/*
+ * writebits
+ * Write bits to h1632 on pins HT1632_DATA, HT1632_WRCLK
+ * Chip is assumed to already be chip-selected
+ * Bits are shifted out from MSB to LSB, with the first bit sent
+ * being (bits & firstbit), shifted till firsbit is zero.
+ */
+void HT1632_LedMatrix::writebits (uint8_t bits, uint8_t firstbit)
+{
+  while (firstbit) {
+#ifdef DIRECTIO
+//    output_low(HT1632_WRCLK_PORT, HT1632_WRCLK);
+#else
+//    digitalWrite( HT1632_WRCLK, LOW );
+#endif
+    ht1632_wrclk = LOW;
+    if (bits & firstbit) {
+#ifdef DIRECTIO
+//      output_high(HT1632_DATA_PORT,HT1632_DATA);
+#else
+//    digitalWrite( HT1632_DATA, HIGH);
+#endif
+        ht1632_data = HIGH;
+    } else {
+#ifdef DIRECTIO
+//      output_low(HT1632_DATA_PORT, HT1632_DATA);
+#else
+//    digitalWrite( HT1632_DATA, LOW);
+#endif
+        ht1632_data = LOW;
+    }
+#ifdef DIRECTIO
+//    output_high(HT1632_WRCLK_PORT, HT1632_WRCLK);
+#else
+//    digitalWrite( HT1632_WRCLK, HIGH);
+#endif
+    ht1632_wrclk = HIGH;
+    firstbit >>= 1;
+  }
+}
+
+/*
+ * writedatabits
+ * Write databits to h1632 on pins HT1632_DATA, HT1632_WRCLK
+ * Chip is assumed to already be chip-selected
+ * Bits are shifted out from LSB to MSB
+ */
+void HT1632_LedMatrix::writedatabits (uint8_t bits, uint8_t count)
+{
+  while (count) {
+//    output_low(HT1632_WRCLK_PORT, HT1632_WRCLK);
+    ht1632_wrclk = LOW;
+    if (bits & 1) {
+//      output_high(HT1632_DATA_PORT,HT1632_DATA);
+        ht1632_data = HIGH;
+    } else {
+//      output_low(HT1632_DATA_PORT, HT1632_DATA);
+        ht1632_data = LOW;
+    }
+//    output_high(HT1632_WRCLK_PORT, HT1632_WRCLK);
+    ht1632_wrclk = HIGH;
+    count--;
+    bits >>= 1;
+  }
+}
+
+/*
+ * sendcmd
+ * Send a command to the ht1632 chip.
+ * A command consists of a 3-bit "CMD" ID, an 8bit command, and
+ * one "don't care bit".
+ *   Select 1 0 0 c7 c6 c5 c4 c3 c2 c1 c0 xx Free
+ */
+void HT1632_LedMatrix::sendcmd (uint8_t chipno, uint8_t command)
+{
+  chipselect(chipno);  // Select chip
+  writebits(HT1632_ID_CMD, 0x04);   //1<<2);  // send 3 bits of id: COMMMAND
+  writebits(command, 0x80); //1<<7);  // send the actual command
+  writebits(0, 1);  /* one extra dont-care bit in commands. */
+  chipfree(chipno); //done
+}
+
+/*
+ * clear
+ * clear the display, and the shadow memory, and the snapshot
+ * memory.  This uses the "write multiple words" capability of
+ * the chipset by writing all 96 words of memory without raising
+ * the chipselect signal.
+ */
+void HT1632_LedMatrix::clear()
+{
+  char i;
+
+  for (uint8_t chipno=0; chipno<numDevices; chipno++){
+    chipselect(chipno);  // Select chip
+    writebits(HT1632_ID_WR, 0x04);  //1<<2);  // send ID: WRITE to RAM
+    writebits(0, 0x40);     //1<<6); // Send address
+    for (i = 0; i < 32; i++) // Clear entire display
+      writedatabits(0, 8);  //1<<7); // send 8 bits of data
+    chipfree(chipno); // done
+    for (i=0; i < 64; i++)
+      shadowram[i+64*chipno] = 0;
+  }
+  cursorX = 0;
+  cursorY = 0;
+}
+
+
+// Brighness is from 0 to 15
+void HT1632_LedMatrix::setBrightness( unsigned char brightness ) {
+  for (uint8_t chipno=0; chipno<numDevices; chipno++) {
+    sendcmd(chipno, HT1632_CMD_PWM | (brightness & 0x0F ));
+  }
+}
+
+
+/*
+ * senddata
+ * send a nibble (4 bits) of data to a particular memory location of the
+ * ht1632.  The command has 3 bit ID, 7 bits of address, and 4 bits of data.
+ *    Select 1 0 1 A6 A5 A4 A3 A2 A1 A0 D0 D1 D2 D3 Free
+ * Note that the address is sent MSB first, while the data is sent LSB first!
+ * This means that somewhere a bit reversal will have to be done to get
+ * zero-based addressing of words and dots within words.
+ */
+void HT1632_LedMatrix::senddata (uint8_t chipno, uint8_t address, uint8_t data)
+{
+  chipselect(chipno);  // Select chip
+  writebits(HT1632_ID_WR, 0x04);    //1<<2);  // send ID: WRITE to RAM
+  writebits(address, 0x40);     //1<<6); // Send address
+  writedatabits(data, 4);       //1<<3); // send 4 bits of data
+  chipfree(chipno); // done
+}
+
+/*
+ * sendcol
+ * send a byte of data to a particular memory location of the
+ * ht1632.  The command has 3 bit ID, 7 bits of address, and 8 bits of data.
+ *    Select 1 0 1 A6 A5 A4 A3 A2 A1 A0 D0 D1 D2 D3 D4 D5 D6 D7 D8 Free
+ * Note that the address is sent MSB first, while the data is sent LSB first!
+ * This means that somewhere a bit reversal will have to be done to get
+ * zero-based addressing of words and dots within words.
+ */
+void HT1632_LedMatrix::sendcol (uint8_t chipno, uint8_t address, uint8_t data)
+{
+  chipselect(chipno);  // Select chip
+  writebits(HT1632_ID_WR, 0x04);    //1<<2);  // send ID: WRITE to RAM
+  writebits(address, 0x40);     //1<<6); // Send address
+  writedatabits(data, 8);       // send 8 bits of data
+  chipfree(chipno); // done
+}
+
+// Write a string at the position specified
+void HT1632_LedMatrix::putString(int x, int y, char *str) {
+    cursorX = x;
+    cursorY = y;
+    while( *str ) {
+        putChar( cursorX, y, *str++ );
+        cursorX += 6;
+    }
+}
+
+/*
+ * Copy a character glyph from the smallFont data structure to
+ * display memory, with its upper left at the given coordinate
+ * This is unoptimized and simply uses plot() to draw each dot.
+ */
+void HT1632_LedMatrix::write( uint8_t c) {
+    putChar( cursorX, cursorY, (char)c );   
+}
+
+/*
+ * Copy a character glyph from the myfont data structure to
+ * display memory, with its upper left at the given coordinate
+ * This is unoptimized and simply uses plot() to draw each dot.
+ * returns number of columns that didn't fit
+ */
+uint8_t HT1632_LedMatrix::putChar(int x, int y, char c) {
+  // fonts defined for ascii 32 and beyond (index 0 in font array is ascii 32);
+  // CGRAM characters are in range 0 to 15 with 8-15 being repeat of 0-7
+  // note we force y to be modulo 8 - we do not support writing character to partial y values.
+
+  uint8_t charIndex;
+  uint8_t colData;
+  uint8_t numCols;
+  uint8_t chipno;
+  uint8_t addr;
+  uint8_t colsLeft = 0;        // cols that didn't fit
+
+  if( c > 15 ) {
+    // Regular characters
+    // replace undisplayable characters with blank;
+    if (c < 32 || c > 126) {
+            charIndex = 0;
+    } else {
+            charIndex = c - 32;
+    }
+
+    // move character definition, pixel by pixel, onto the display;
+    // fonts are defined as one byte per col;
+    numCols=smallFont[charIndex][6];   // get the number of columns this character uses
+    for (uint8_t col=0; col<numCols; col++) {
+            colData = smallFont[charIndex][col];
+        chipno = chip_number(x,y);
+        addr = chip_byte_address(x,y); // compute which memory byte this is in
+        if (x <= xMax && y <= yMax) {
+            shadowram[(addr>>1)+32*chipno] = colData;
+            sendcol(chipno,addr,colData);
+            x++;
+        } else {
+            colsLeft++;
+        }
+    }
+  } else {
+    // CGRAM Characters
+    charIndex = c & 0x07;       // Only low 3 bits count
+    numCols=cgram[charIndex][0];    // get the number of columns this character uses
+    // fonts are defined as one byte per col;
+        for (uint8_t col=1; col<=numCols; col++) {
+            colData = cgram[charIndex][col];
+        chipno = chip_number(x,y);
+        addr = chip_byte_address(x,y); // compute which memory byte this is in
+        if (x <= xMax && y <= yMax) {
+            shadowram[(addr>>1)+32*chipno] = colData;
+            sendcol(chipno,addr,colData);
+            x++;
+        } else {
+            colsLeft++;
+        }
+    }
+  }
+
+  cursorX = x;
+  cursorY = y;
+
+  return colsLeft;
+}
+
+// Set position of cursor for writing
+void HT1632_LedMatrix::gotoXY(int x, int y) {
+    cursorX = x;
+    cursorY = y;
+}
+
+void HT1632_LedMatrix::getXY(int* x, int* y)
+{
+    *x = cursorX;
+    *y = cursorY;
+}
+
+void HT1632_LedMatrix::getXYMax(int* x, int* y)
+{
+    *x = xMax;
+    *y = yMax;
+}
+
+// Shift cursor X position a number of positions either left or right.
+void HT1632_LedMatrix::shiftCursorX(int xinc) {
+    cursorX += xinc;
+}
+
+
+/*
+ * plot a point on the display, with the upper left hand corner
+ * being (0,0), and the lower right hand corner being (xMax-1, yMax-1).
+ * Note that Y increases going "downward" in contrast with most
+ * mathematical coordiate systems, but in common with many displays
+ * basic bounds checking used.
+ */
+void HT1632_LedMatrix::plot (int x, int y, char val)
+{
+  if (x<0 || x>xMax || y<0 || y>yMax)
+     return;
+
+  uint8_t chipno = chip_number(x,y);
+  char addr = chip_byte_address(x,y); // compute which memory word this is in
+  char shadowAddress = addr >>1;
+
+  char bitval = 1<<(y&7);  // compute which bit will need set
+
+
+  if (val) {  // Modify the shadow memory
+    shadowram[shadowAddress +32*chipno] |= bitval;
+  }
+  else {
+    shadowram[shadowAddress +32*chipno] &= ~bitval;
+  }
+  // Now copy the new memory value to the display
+  sendcol(chipno, addr, shadowram[shadowAddress +32*chipno]);
+}
+
+
+void HT1632_LedMatrix::setCustomChar( int charNum, unsigned char cgchar[] ) {
+    for(int i=1; i<7; i++ ) {
+        cgram[charNum][i] = (uint8_t)cgchar[i];
+    }
+    cgram[charNum][6] = 0;
+    cgram[charNum][0] = 6;
+}
+
+void HT1632_LedMatrix::setCustomChar( int charNum, unsigned char cgchar[], uint8_t numCols ) {
+    numCols = max(numCols, 6 );
+    for(int i=1; i<=numCols; i++ ) {
+        cgram[charNum][i] = (uint8_t)cgchar[i];
+    }
+    cgram[charNum][0] = numCols;
+    cgram[charNum][numCols] = 0;
+}
+
+void HT1632_LedMatrix::scrollLeft(uint8_t numberCols)
+{
+    for (int i=0; i<128-numberCols-1; i++)
+    {
+        shadowram[i]=shadowram[i+numberCols];
+    }
+    for (int i=128-numberCols; i<128; i++)
+    {
+        shadowram[i]=0;
+    }
+    cursorX -= numberCols;
+    if (cursorX < 0 ) cursorX = 0;
+}
+
+void HT1632_LedMatrix::putShadowRam()
+{
+    for (int chipno=0; chipno<numDevices; chipno++)
+        putShadowRam(chipno);
+}
+
+void HT1632_LedMatrix::putShadowRam(uint8_t chipno)
+{
+    for (int i=0; i<64; i+=2)
+    {
+        sendcol(chipno,i,shadowram[(i>>1)+32*chipno]);
+    }
+}
+
+#ifdef USE_GRAPHIC
+/*
+ * Name         : drawLine
+ * Description  : Draws a line between two points on the display.
+ * Argument(s)  : x1, y1 - Absolute pixel coordinates for line origin.
+ *                x2, y2 - Absolute pixel coordinates for line end.
+ *                c - either PIXEL_ON, PIXEL_OFF
+ * Return value : none
+ */
+void HT1632_LedMatrix::drawLine(unsigned char x1, unsigned char y1,
+        unsigned char x2, unsigned char y2, unsigned char c) {
+    int dx, dy, stepx, stepy, fraction;
+
+    /* Calculate differential form */
+    /* dy   y2 - y1 */
+    /* -- = ------- */
+    /* dx   x2 - x1 */
+
+    /* Take differences */
+    dy = y2 - y1;
+    dx = x2 - x1;
+
+    /* dy is negative */
+    if ( dy < 0 ) {
+        dy    = -dy;
+        stepy = -1;
+    } else {
+        stepy = 1;
+    }
+
+    /* dx is negative */
+    if ( dx < 0 ) {
+        dx    = -dx;
+        stepx = -1;
+    } else {
+        stepx = 1;
+    }
+
+    dx <<= 1;
+    dy <<= 1;
+
+    /* Draw initial position */
+    plot( x1, y1, c );
+
+    /* Draw next positions until end */
+    if ( dx > dy ) {
+        /* Take fraction */
+        fraction = dy - ( dx >> 1);
+        while ( x1 != x2 ) {
+            if ( fraction >= 0 ) {
+                y1 += stepy;
+                fraction -= dx;
+            }
+            x1 += stepx;
+            fraction += dy;
+
+            /* Draw calculated point */
+            plot( x1, y1, c );
+        }
+    } else {
+        /* Take fraction */
+        fraction = dx - ( dy >> 1);
+        while ( y1 != y2 ) {
+            if ( fraction >= 0 ) {
+                x1 += stepx;
+                fraction -= dy;
+            }
+            y1 += stepy;
+            fraction += dx;
+
+            /* Draw calculated point */
+            plot( x1, y1, c );
+        }
+    }
+}
+
+
+/*
+ * Name         : drawRectangle
+ * Description  : Draw a rectangle given to top left and bottom right points
+ * Argument(s)  : x1, y1 - Absolute pixel coordinates for top left corner
+ *                x2, y2 - Absolute pixel coordinates for bottom right corner
+ *                c - either PIXEL_ON, PIXEL_OFF 
+ * Return value : none
+ */
+void HT1632_LedMatrix::drawRectangle(unsigned char x1, unsigned char y1,
+        unsigned char x2, unsigned char y2, unsigned char c){
+    drawLine( x1, y1, x2, y1, c );
+    drawLine( x1, y1, x1, y2, c );
+    drawLine( x1, y2, x2, y2, c );
+    drawLine( x2, y1, x2, y2, c );
+}
+
+
+/*
+ * Name         : drawFilledRectangle
+ * Description  : Draw a filled rectangle given to top left and bottom right points
+ *        just simply draws horizontal lines where the rectangle would be
+ * Argument(s)  : x1, y1 - Absolute pixel coordinates for top left corner
+ *                x2, y2 - Absolute pixel coordinates for bottom right corner
+ *                c - either PIXEL_ON, PIXEL_OFF
+ * Return value : none
+ */
+void HT1632_LedMatrix::drawFilledRectangle(unsigned char x1, unsigned char y1,
+        unsigned char x2, unsigned char y2, unsigned char c) {
+    for(int i=y1; i <= y2; i++ ) {
+        drawLine( x1, i, x2, i, c );
+    }
+}
+
+
+/*
+ * Name         : drawCircle
+ * Description  : Draw a circle using Bresenham's algorithm. 
+ *        Some small circles will look like squares!!
+ * Argument(s)  : xc, yc - Centre of circle
+ *        r - Radius
+ *        c - either PIXEL_ON, PIXEL_OFF
+ * Return value : None 
+ */
+void HT1632_LedMatrix::drawCircle(unsigned char xc, unsigned char yc,
+        unsigned char r, unsigned char c) {
+    int x=0;
+    int y=r;
+    int p=3-(2*r);
+
+        plot( xc+x,yc-y, c);
+
+    for(x=0;x<=y;x++) {
+        if (p<0) {
+            y=y;
+            p=(p+(4*x)+6);
+        } else {
+            y=y-1;
+            p=p+((4*(x-y)+10));
+        }
+
+        plot(xc+x,yc-y, c);
+        plot(xc-x,yc-y, c);
+        plot(xc+x,yc+y, c);
+        plot(xc-x,yc+y, c);
+        plot(xc+y,yc-x, c);
+        plot(xc-y,yc-x, c);
+        plot(xc+y,yc+x, c);
+        plot(xc-y,yc+x, c);
+    }
+}
+#endif
+
+// The end!
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/HT1632_LedMatrix.h	Thu Nov 08 21:41:33 2012 +0000
@@ -0,0 +1,87 @@
+/*
+*   HT1632_LedMatrix.h
+*   defintions for Holtek ht1632 LED driver
+*/
+
+#ifndef _HT1632_LEDMATRIX_H
+#define _HT1632_LEDMATRIX_H
+
+#define USE_GRAPHIC
+
+
+#include <inttypes.h>
+
+/*
+ * commands written to the chip consist of a 3 bit "ID", followed by
+ * either 9 bits of "Command code" or 7 bits of address + 4 bits of data.
+ */
+#define HT1632_ID_CMD 4     /* ID = 100 - Commands */
+#define HT1632_ID_RD  6     /* ID = 110 - Read RAM */
+#define HT1632_ID_WR  5     /* ID = 101 - Write RAM */
+
+#define HT1632_CMD_SYSDIS 0x00  /* CMD= 0000-0000-x Turn off oscil */
+#define HT1632_CMD_SYSON  0x01  /* CMD= 0000-0001-x Enable system oscil */
+#define HT1632_CMD_LEDOFF 0x02  /* CMD= 0000-0010-x LED duty cycle gen off */
+#define HT1632_CMD_LEDON  0x03  /* CMD= 0000-0011-x LEDs ON */
+#define HT1632_CMD_BLOFF  0x08  /* CMD= 0000-1000-x Blink ON */
+#define HT1632_CMD_BLON   0x09  /* CMD= 0000-1001-x Blink Off */
+#define HT1632_CMD_SLVMD  0x10  /* CMD= 0001-00xx-x Slave Mode */
+#define HT1632_CMD_MSTMD  0x14  /* CMD= 0001-01xx-x Master Mode */
+#define HT1632_CMD_RCCLK  0x18  /* CMD= 0001-10xx-x Use on-chip clock */
+#define HT1632_CMD_EXTCLK 0x1C  /* CMD= 0001-11xx-x Use external clock */
+#define HT1632_CMD_COMS00 0x20  /* CMD= 0010-ABxx-x commons options */
+#define HT1632_CMD_COMS01 0x24  /* CMD= 0010-ABxx-x commons options */
+#define HT1632_CMD_COMS10 0x28  /* CMD= 0010-ABxx-x commons options */
+#define HT1632_CMD_COMS11 0x2C  /* CMD= 0010-ABxx-x commons options */
+#define HT1632_CMD_PWM    0xA0  /* CMD= 101x-PPPP-x PWM duty cycle */
+
+#define PIXEL_OFF 0
+#define PIXEL_ON  1
+
+//class HT1632_LedMatrix 
+class HT1632_LedMatrix  //: public Print 
+{
+  private:
+    void chipselect( uint8_t );
+    void chipfree( uint8_t );
+    void writebits( uint8_t, uint8_t );
+    void writedatabits( uint8_t, uint8_t );
+    void sendcmd( uint8_t, uint8_t );
+    void senddata( uint8_t, uint8_t, uint8_t );
+    void sendcol( uint8_t, uint8_t, uint8_t );
+
+  public:
+    HT1632_LedMatrix( );
+    
+    // Init/Clear/position functions
+    void init( uint8_t, uint8_t );
+    void clear(void);
+    void setBrightness( unsigned char );
+    uint8_t putChar( int, int, char );
+    void write( uint8_t );
+    void putString( int, int, char* );
+    void plot( int, int, char );
+    void gotoXY(int , int);
+    void getXY(int* , int*);
+    void getXYMax(int*, int*);
+    void shiftCursorX(int );
+    void setCustomChar( int, unsigned char[]);
+    void setCustomChar( int, unsigned char[], uint8_t );
+    void scrollLeft(uint8_t);
+    void putShadowRam();
+    void putShadowRam(uint8_t);
+    // Graphic functions
+#ifdef  USE_GRAPHIC
+    void drawLine(unsigned char x1, unsigned char y1,
+            unsigned char x2, unsigned char y2, unsigned char c);
+    void drawRectangle(unsigned char x1, unsigned char y1,
+            unsigned char x2, unsigned char y2, unsigned char c);
+    void drawFilledRectangle(unsigned char x1, unsigned char y1,
+            unsigned char x2, unsigned char y2, unsigned char c);
+    void drawCircle(unsigned char xc, unsigned char yc,
+            unsigned char r, unsigned char c);
+#endif
+
+};
+
+#endif //_HT1632_LEDMATRIX_H

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/font_5x7_p.h	Thu Nov 08 21:41:33 2012 +0000
@@ -0,0 +1,103 @@
+// Font definition for LCD 3110 library
+// 5 x 7 font
+// 1 pixel space at left and bottom
+// index = ASCII - 32
+//#include <avr/pgmspace.h>
+
+//***** Small fonts (5x7) **********
+
+static const unsigned char smallFont[][7] =
+{
+      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4} ,   // sp
+      {0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 2} ,   // !
+      {0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 4} ,   // "
+      {0x14, 0x3e, 0x14, 0x3e, 0x14, 0x00, 6} ,   // #
+      {0x24, 0x2a, 0x7f, 0x2a, 0x12, 0x00, 6} ,   // $
+      {0x23, 0x13, 0x08, 0x64, 0x62, 0x00, 6} ,   // %
+      {0x36, 0x49, 0x56, 0x20, 0x50, 0x00, 6} ,   // &
+      {0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 2} ,   // '
+      {0x1c, 0x22, 0x41, 0x00, 0x00, 0x00, 4} ,   // (
+      {0x41, 0x22, 0x1c, 0x00, 0x00, 0x00, 4} ,   // )
+      {0x2a, 0x1c, 0x7f, 0x1c, 0x2a, 0x00, 6} ,   // *
+      {0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 6} ,   // +
+      {0x50, 0x30, 0x00, 0x00, 0x00, 0x00, 3} ,   // , 
+      {0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 6} ,   // -
+      {0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 3} ,   // .
+      {0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 6} ,   // /
+      {0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 6} ,   // 0
+      {0x42, 0x7F, 0x40, 0x00, 0x00, 0x00, 4} ,   // 1
+      {0x42, 0x61, 0x51, 0x49, 0x46, 0x00, 6} ,   // 2
+      {0x22, 0x41, 0x49, 0x49, 0x36, 0x00, 6} ,   // 3
+      {0x18, 0x14, 0x12, 0x7F, 0x10, 0x00, 6} ,   // 4
+      {0x27, 0x45, 0x45, 0x45, 0x39, 0x00, 6} ,   // 5
+      {0x3C, 0x4A, 0x49, 0x49, 0x30, 0x00, 6} ,   // 6
+      {0x01, 0x71, 0x09, 0x05, 0x03, 0x00, 6} ,   // 7
+      {0x36, 0x49, 0x49, 0x49, 0x36, 0x00, 6} ,   // 8
+      {0x06, 0x49, 0x49, 0x49, 0x3E, 0x00, 6} ,   // 9
+      {0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 3} ,   // :
+      {0x56, 0x36, 0x00, 0x00, 0x00, 0x00, 3} ,   // ;
+      {0x08, 0x14, 0x22, 0x41, 0x00, 0x00, 5} ,   // <
+      {0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 6} ,   // =
+      {0x41, 0x22, 0x14, 0x08, 0x00, 0x00, 5} ,   // >
+      {0x02, 0x01, 0x51, 0x09, 0x06, 0x00, 6} ,   // ?
+      {0x3e, 0x41, 0x5d, 0x55, 0x5E, 0x00, 6} ,   // @
+      {0x7c, 0x12, 0x11, 0x12, 0x7c, 0x00, 6} ,   // A
+      {0x7F, 0x49, 0x49, 0x49, 0x36, 0x00, 6} ,   // B
+      {0x3E, 0x41, 0x41, 0x41, 0x22, 0x00, 6} ,   // C
+      {0x7F, 0x41, 0x41, 0x41, 0x3e, 0x00, 6} ,   // D
+      {0x7F, 0x49, 0x49, 0x49, 0x41, 0x00, 6} ,   // E
+      {0x7F, 0x09, 0x09, 0x09, 0x01, 0x00, 6} ,   // F
+      {0x3E, 0x41, 0x49, 0x49, 0x3A, 0x00, 6} ,   // G
+      {0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 6} ,   // H
+      {0x41, 0x7F, 0x41, 0x00, 0x00, 0x00, 4} ,   // I
+      {0x20, 0x40, 0x40, 0x3F, 0x00, 0x00, 5} ,   // J
+      {0x7F, 0x08, 0x14, 0x22, 0x41, 0x00, 6} ,   // K
+      {0x7F, 0x40, 0x40, 0x40, 0x40, 0x00, 6} ,   // L
+      {0x7F, 0x02, 0x0C, 0x02, 0x7F, 0x00, 6} ,   // M
+      {0x7F, 0x02, 0x04, 0x08, 0x7F, 0x00, 6} ,   // N
+      {0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 6} ,   // O
+      {0x7F, 0x09, 0x09, 0x09, 0x06, 0x00, 6} ,   // P
+      {0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00, 6} ,   // Q
+      {0x7F, 0x09, 0x19, 0x29, 0x46, 0x00, 6} ,   // R
+      {0x26, 0x49, 0x49, 0x49, 0x32, 0x00, 6} ,   // S
+      {0x01, 0x01, 0x7F, 0x01, 0x01, 0x00, 6} ,   // T
+      {0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00, 6} ,   // U
+      {0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00, 6} ,   // V
+      {0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00, 6} ,   // W
+      {0x63, 0x14, 0x08, 0x14, 0x63, 0x00, 6} ,   // X
+      {0x07, 0x08, 0x70, 0x08, 0x07, 0x00, 6} ,   // Y
+      {0x61, 0x51, 0x49, 0x45, 0x43, 0x00, 6} ,   // Z
+      {0x7F, 0x41, 0x41, 0x00, 0x00, 0x00, 4} ,   // [
+      {0x55, 0x2A, 0x55, 0x2A, 0x55, 0x00, 6} ,   // Chequer
+      {0x41, 0x41, 0x7F, 0x00, 0x00, 0x00, 4} ,   // ]
+      {0x04, 0x02, 0x01, 0x02, 0x04, 0x00, 6} ,   // ^
+      {0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 6} ,   // _
+      {0x01, 0x02, 0x04, 0x00, 0x00, 0x00, 4} ,   // '
+      {0x20, 0x54, 0x54, 0x78, 0x00, 0x00, 5} ,   // a
+      {0x7F, 0x44, 0x44, 0x38, 0x00, 0x00, 5} ,   // b
+      {0x38, 0x44, 0x44, 0x44, 0x00, 0x00, 5} ,   // c
+      {0x38, 0x44, 0x44, 0x7F, 0x00, 0x00, 5} ,   // d
+      {0x38, 0x54, 0x54, 0x58, 0x00, 0x00, 5} ,   // e
+      {0x04, 0x7E, 0x05, 0x01, 0x00, 0x00, 5} ,   // f
+      {0x48, 0x54, 0x54, 0x3c, 0x00, 0x00, 5} ,   // g
+      {0x7F, 0x08, 0x04, 0x78, 0x00, 0x00, 5} ,   // h
+      {0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 2} ,   // i
+      {0x20, 0x40, 0x3D, 0x00, 0x00, 0x00, 4} ,   // j
+      {0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 5} ,   // k
+      {0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 2} ,   // l
+      {0x78, 0x04, 0x18, 0x04, 0x78, 0x00, 6} ,   // m
+      {0x7c, 0x08, 0x04, 0x78, 0x00, 0x00, 5} ,   // n
+      {0x38, 0x44, 0x44, 0x38, 0x00, 0x00, 5} ,   // o
+      {0x7C, 0x14, 0x14, 0x08, 0x00, 0x00, 5} ,   // p
+      {0x08, 0x14, 0x14, 0x7C, 0x00, 0x00, 5} ,   // q
+      {0x7C, 0x08, 0x04, 0x04, 0x00, 0x00, 5} ,   // r
+      {0x48, 0x54, 0x54, 0x24, 0x00, 0x00, 5} ,   // s
+      {0x04, 0x7F, 0x44, 0x00, 0x00, 0x00, 4} ,   // t
+      {0x3C, 0x40, 0x40, 0x3c, 0x00, 0x00, 5} ,   // u
+      {0x0C, 0x30, 0x40, 0x30, 0x0c, 0x00, 6} ,   // v
+      {0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00, 6} ,   // w
+      {0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 6} ,   // x
+      {0x0C, 0x50, 0x50, 0x3c, 0x00, 0x00, 5} ,   // y
+      {0x44, 0x64, 0x54, 0x4C, 0x44, 0x00, 6} ,   // z
+      {0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 5}     // degree
+};