ROM Comm
5 by 14 Neo array
Dependencies: mbed
Revision 0:a32d1a85a830, committed 2017-06-12
- Comitter:
- RogerJKelly
- Date:
- Mon Jun 12 16:57:43 2017 +0000
- Commit message:
- working display using ARM to drive display.
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/NeoMatrix/NeoMatrix.cpp Mon Jun 12 16:57:43 2017 +0000
@@ -0,0 +1,401 @@
+/**********************************************
+ * NeoMatrix.cpp
+ *
+ * Taylor Powell
+ * March 2015
+ *
+ * Controls an Adafruit Neopixel NeoMatrix 8x8
+ * Because of the global nature of the IO register and bitmask variables, only one contiguous chain of NeoMatrix Arrays can be connected
+ * A large number of NeoMatrix arrays can be chained together by tying Din to Dout of sucessive arrays, but an external power sourece may be required
+ *
+ * This library supports only the NXP LPC1768
+ */
+
+#include "mbed.h"
+#include "NeoMatrix.h"
+#include "font.h"
+
+
+// FastIO register address and bitmask for the GPIO pin
+// because these are imported in the assembly
+//uint32_t neo_fio_reg;
+//uint32_t neo_bitmask;
+
+// function to write to the strip, implemented in ARM assembly
+//extern "C" void neo_out(NeoColor*, int);
+
+ #define max(a,b) \
+ ({ __typeof__ (a) _a = (a); \
+ __typeof__ (b) _b = (b); \
+ _a > _b ? _a : _b; })
+
+ #define min(a,b) \
+ ({ __typeof__ (a) _a = (a); \
+ __typeof__ (b) _b = (b); \
+ _a < _b ? _a : _b; })
+
+
+//__gpo(pin)
+NeoArr::NeoArr(PinName pin, int N, int zeroHigh, int zeroLow, int oneHigh, int oneLow) : N(N), __gpo(pin)
+{
+ bright = 0.2;
+ Nbytes = N * 70 * 3; // changed from 64 to 70 - 14 x 5
+ arr = (NeoColor*)malloc(N * 70 * sizeof(NeoColor));
+ if (arr == NULL)
+ {
+ printf("NeoArr: ERROR unable to malloc pixel array data");
+ N = 0;
+ }
+
+ __size = N * 70; // changed from 64 to 70 - 14 x 5
+ __transmitBuf = new bool[__size * FRAME_SIZE];
+
+ //gpio_init(&gpio, pin, PIN_OUTPUT); // initialize GPIO registers
+ //neo_fio_reg = (uint32_t)gpio.reg_dir; // set registers and bitmask for
+ //neo_bitmask = 1 << ((int)pin & 0x1F); // the assembly to use
+
+ // IO pin to use
+ __outPin = pin;
+ // Default values designed for K64f. Assumes GPIO toggle takes ~0.4us
+ setDelays(zeroHigh, zeroLow, oneHigh, oneLow);
+}
+
+void NeoArr::setDelays(int zeroHigh, int zeroLow, int oneHigh, int oneLow)
+{
+ __zeroHigh = zeroHigh;
+ __zeroLow = zeroLow;
+ __oneHigh = oneHigh;
+ __oneLow = oneLow;
+}
+
+void NeoArr::setBrightness(float bright)
+{
+ this->bright = bright;
+}
+
+
+void NeoArr::setPixel(int idx, int x, int y, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ setPixel(idx, x, y, red, green, blue);
+}
+
+void NeoArr::setPixel(int idx, int x, int y, uint8_t red, uint8_t green, uint8_t blue)
+{
+ //int pixel = idx*64 + x*8 + y; // specify pixel based on board index, x, and y values
+ //int pixel = idx*70 + x*14 + y; // specify pixel based on board index, x, and y values
+ int pixel = x + y*14; // specify pixel based x and y values
+ // modulate pixel by the total number of pixels
+ arr[pixel % (N*70)].red = (uint8_t)(red * bright);
+ arr[pixel % (N*70)].green = (uint8_t)(green * bright);
+ arr[pixel % (N*70)].blue = (uint8_t)(blue * bright);
+}
+
+void NeoArr::drawLine(int idx, int x1, int y1, int x2, int y2, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawLine(idx, x1, y1, x2,y2, red, green, blue);
+}
+
+void NeoArr::drawLine(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue)
+{
+ float k;
+ int j = rint(sqrt(pow((x1-x2),2.0) + pow((y1-y2),2.0))); // calculates magnitude of line
+ if(x1 != x2) // handle infinite case
+ k = atan2( (float)(y2-y1),(float) ( x2-x1)); // calculates angle of line
+ else
+ k = acos(0.0);
+
+ for(float n=0; n<=j; n++) // set a number pixels equal to the magnitude of the line along the closest (rounded) line
+ if((x1+ rint(n*cos(k))) >=0 && (x1+rint( n*cos(k))) <=7 && (y1+rint(n*sin(k)))>=0 && (y1+rint(n*sin(k)))<=7)
+ setPixel(idx, x1+ rint(n*cos(k)), y1+ rint(n*sin(k)), red, green, blue);
+
+
+}
+
+void NeoArr::drawRect(int idx, int x1, int y1, int x2, int y2, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawRect(idx, x1, y1, x2,y2, red, green, blue);
+}
+
+void NeoArr::drawRect(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue)
+{
+ // note: drawRect does not use drawLine function because the angles will always be 90 degrees and so for these for loops are faster
+ for(int i=0; i<=(abs(x2-x1)); i++){ // draws horizontal lines
+ if ((max(x1,x2)-i) >= 0 && max(x1, x2) -i <=7){
+ if(max(y1,y2) <= 7)
+ setPixel(idx, max(x1,x2)-i, max(y1,y2), red, green, blue);
+
+ if(min(y1,y2) >= 0)
+ setPixel(idx, max(x1,x2)-i, min(y1,y2), red, green, blue);
+ }
+ }
+
+ for(int i=0; i<=(abs(y2-y1)); i++){ // draws verticle lines
+ if ((max(y1,y2)-i) >= 0 && max(y1, y2) -i <=7){
+ if(max(x1,x2) <= 7)
+ setPixel(idx, max(x1,x2), max(y1,y2)-i, red, green, blue);
+
+ if(min(x1,x2) >= 0)
+ setPixel(idx, min(x1,x2), max(y1,y2)-i, red, green, blue);
+ }
+ }
+}
+
+
+void NeoArr::drawFilledRect(int idx, int x1, int y1, int x2, int y2, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawFilledRect(idx, x1, y1, x2,y2, red, green, blue);
+}
+
+void NeoArr::drawFilledRect(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue)
+{
+ for(int i=0; i<=(abs(x2-x1)); i++){
+ if ((max(x1,x2)-i) >= 0 && max(x1, x2) -i <=7){
+ for(int n=0; n<=(abs(y2-y1)); n++){
+ if((max(y1,y2)-n) >= 0 && max(y1, y2)-n <=7){
+ setPixel(idx, max(x1,x2)-i, max(y1,y2)-n, red, green, blue);
+ }
+ }
+ }
+ }
+
+}
+
+void NeoArr::fillScreen(int idx, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ fillScreen(idx, red, green, blue);
+}
+
+// adjusted for 14 x 5 screen
+void NeoArr::fillScreen(int idx,uint8_t red, uint8_t green, uint8_t blue)
+{
+ for(int i=0; i<14; i++)
+ for(int n=0; n<5; n++)
+ setPixel(idx, i, n, red, green, blue);
+}
+
+
+void NeoArr::drawTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawTriangle(idx, x1, y1, x2,y2, x3, y3, red, green, blue);
+}
+
+void NeoArr::drawTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, uint8_t red, uint8_t green, uint8_t blue)
+{
+
+ drawLine(idx, x1, y1, x2, y2, red, green, blue);
+ drawLine(idx, x2, y2, x3, y3, red, green, blue);
+ drawLine(idx, x3, y3, x1, y1, red, green, blue);
+
+}
+
+void NeoArr::drawFilledTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawFilledTriangle(idx, x1, y1, x2,y2, x3, y3, red, green, blue);
+}
+
+void NeoArr::drawFilledTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, uint8_t red, uint8_t green, uint8_t blue)
+{
+ // note: drawFilledTriangle draws two legs of the triangle and then draws lines from their corner to each point on the opposite leg
+ drawLine(idx, x1, y1, x2, y2, red, green, blue);
+ drawLine(idx, x2, y2, x3, y3, red, green, blue);
+
+
+ float k;
+ int j = rint(sqrt(pow((x1-x3),2.0) + pow((y1-y3),2.0))); // magnitude of opposite leg
+ if(x1 != x3)
+ k = atan2( (float)(y3-y1),(float) ( x3-x1)); // angle of line of opposite leg
+ else
+ k = acos(0.0);
+
+ for(float n=0; n<=j; n++)
+ if((x1+ rint(n*cos(k))) >=0 && (x1+rint( n*cos(k))) <=7 && (y1+rint(n*sin(k)))>=0 && (y1+rint(n*sin(k)))<=7)
+ drawLine(idx, x1+ rint(n*cos(k)), y1+ rint(n*sin(k)), x2, y2, red, green, blue); // draw line from corner to each point on opposite leg
+}
+
+void NeoArr::drawChar(int idx, int x, int y, char c, int color)
+{
+ int red = (color & 0xFF0000) >> 16;
+ int green = (color & 0x00FF00) >> 8;
+ int blue = (color & 0x0000FF);
+
+ drawChar(idx, x, y, c, red, green, blue);
+}
+
+void NeoArr::drawChar(int idx, int x, int y, char c, uint8_t red, uint8_t green, uint8_t blue)
+{
+ uint8_t i,j;
+
+ c = c & 0x7F; // mask c to avoid errors
+
+ if (c < ' ') { // convert c into index of font array
+ c = 0;
+ } else {
+ c -= ' ';
+ }
+
+ // font is BMplain, a 96x6 array stored in font.h, many free available fonts are online and can be swapped into this font
+ const uint8_t* chr = font[c];
+
+ for (j=0; j<6; j++) // character width is 6
+ {
+ for (i=0; i<5; i++) // character height is 5 - changed from 8
+ {
+ if (chr[j] & (1<<(i))) // if there is a pixel in the vertical line, set pixel on board
+ {
+ //if((x+j) <= 13 && (x+j)>=0 && (y+4-i)>=0 && (y+4-i) <=4)
+ setPixel(0, x+j, y+i, red,green,blue);
+ }
+ }
+ }
+}
+
+void NeoArr::showImage(int idx, const int *img)
+{
+ int r, g, b;
+ for (int i = 0; i < 8; i++)
+ {
+ for(int n=0; n<8;n++)
+ {
+ r = (img[i] & 0xFF0000) >> 16;
+ g = (img[i] & 0x00FF00) >>8;
+ b = img[i] & 0x0000FF;
+ setPixel(idx,i,n, r, g, b);
+ }
+ }
+}
+
+void NeoArr::showImageRGB(int idx, int bmp, int r, int g, int b)
+{
+ //int r, g, b;
+ bmp &= 0x03; // bounds check on the index
+ const unsigned char* img = smile_img[bmp];
+ for (int i = 0; i < 8; i++) // each byte in image file
+ {
+ for(int n=0; n<8;n++) // for each bit
+ {
+ if ( ((img[i] << n) & 0x80) == 0x80 )
+ setPixel(idx,i,n, r, g, b);
+ }
+ }
+}
+
+void NeoArr::clear()
+{
+ for (int i = 0; i < (N*70); i++) // changed from 64 to 70 - 14 x 5
+ {
+ arr[i].red = 0;
+ arr[i].green = 0;
+ arr[i].blue = 0;
+ }
+}
+
+/***************************************************************
+// original NeoArr::write --
+void NeoArr::write()
+{
+ __disable_irq(); // disable interrupts
+ neo_out(arr, Nbytes); // output to the strip
+ __enable_irq(); // enable interrupts
+ wait_us(50); // wait 50us for the reset pulse
+}
+***************************************************************/
+
+void NeoArr::__loadBuf()
+{
+ for (int i = 0; i < __size; i++)
+ {
+ unsigned char agrb[3] = {0x0, 0x0, 0x0};
+
+ // 0 = green, 1 = red, 2 = blue, 3 = brightness
+ agrb[0] = arr[i % (N*70)].green; // changed from 64 to 70 - 14 x 5
+ agrb[1] = arr[i % (N*70)].red; // changed from 64 to 70 - 14 x 5
+ agrb[2] = arr[i % (N*70)].blue; // changed from 64 to 70 - 14 x 5
+ //agrb[3] = (color & 0xFF000000) >> 24;
+
+ // load transmit buffer
+ for (int clr = 0; clr < 3; clr++) // for each color
+ {
+ for (int j = 0; j < 8; j++) // for each bit
+ {
+ if (((agrb[clr] << j) & 0x80) == 0x80)
+ {
+ // Bit is set (checks MSB fist)
+ __transmitBuf[(i * FRAME_SIZE) + (clr * 8) + j] = 1;
+ } else {
+ // Bit is clear
+ __transmitBuf[(i * FRAME_SIZE) + (clr * 8) + j] = 0;
+ }
+ }
+ }
+ }
+}
+
+//void NeoArr::write_offsets (int buf[],int r_offset, int g_offset, int b_offset)
+void NeoArr::write()
+{
+ int i, j;
+
+ // Load the transmit buffer.
+ // transmit buffer is array where each byte represents one bit in the pixel buffer
+ // 24 bytes per pixel * 64 pixels = 1536 bytes of ram
+ __loadBuf();
+
+ // Entering timing critical section, so disabling interrupts
+ __disable_irq();
+
+ // Begin bit-banging
+ for (i = 0; i < FRAME_SIZE * __size; i++) {
+ j = 0;
+ if (__transmitBuf[i]){
+ __gpo = 1;
+ for (; j < __oneHigh; j++) {
+ __nop();
+ }
+ __gpo = 0;
+ for (; j < __oneLow; j++) {
+ __nop();
+ }
+ } else {
+ __gpo = 1;
+ for (; j < __zeroHigh; j++) {
+ __nop();
+ }
+ __gpo = 0;
+ for (; j < __zeroLow; j++) {
+ __nop();
+ }
+ }
+ }
+
+ // Exiting timing critical section, so enabling interrutps
+ __enable_irq();
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/NeoMatrix/NeoMatrix.h Mon Jun 12 16:57:43 2017 +0000
@@ -0,0 +1,252 @@
+/**
+ * NeoMatrix.h
+ *
+ * Taylor Powell
+ * March 2015
+ *
+ * Library for the 8x8 grid array of Neopixel LEDs
+ *
+ */
+
+
+#ifndef NEOARRAY_H
+#define NEOARRAY_H
+
+//#ifndef TARGET_LPC1768
+//#error NeoArray only supports the NXP LPC1768
+//#endif
+
+// NeoColor struct definition to hold 24 bit
+// color data for each pixel, in GRB order
+typedef struct _NeoColor
+{
+ uint8_t green;
+ uint8_t red;
+ uint8_t blue;
+} NeoColor;
+
+
+#define FRAME_SIZE 24
+
+/**
+ * NeoArr objects manage the buffering and assigning of
+ * addressable NeoPixels
+ */
+class NeoArr
+{
+ public:
+
+ /**
+ * Create a NeoArr object
+ *
+ * @param pin The mbed data pin name
+ * @param N The number of arrays chained together.
+ */
+ //NeoArr(PinName pin, int N);
+ NeoArr(PinName pin, int N, int zeroHigh, int zeroLow, int oneHigh, int oneLow);
+ /**
+ * Sets the brightness of the entire array. All functions using set pixel are affected by this value.
+ * If a higher brightness is set, an external power supply may be necessary
+ *
+ * The default brightness is 0.5
+ *
+ * @param bright The brightness scaled between 0 and 1.0
+ */
+ void setBrightness(float bright);
+ /**
+ * sets up number of NOPS for pixel write functions.
+ *
+ * Sets the timing parameters for the bit-banged signal
+ *
+ * @param zeroHigh How many NOPs to insert to ensure TOH is properly generated. See library description for more information.
+ * @param zeroLow How many NOPs to insert to ensure TOL is properly generated. See library description for more information.
+ * @param oneHigh How many NOPs to insert to ensure T1H is properly generated. See library description for more information.
+ * @param oneLow How many NOPs to insert to ensure T1L is properly generated. See library description for more information.
+ *
+ */
+ void setDelays(int zeroHigh, int zeroLow, int oneHigh, int oneLow);
+ /**
+ * Set a single pixel in the array to a specific color.
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x The x co-ordinate of the pixel
+ * @param y The y co-ordinate of the pixel
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+ void setPixel(int idx, int x, int y, int color);
+
+ /**
+ * Set a single pixel in the array to a specific color with reg, blue, and blue values in seperate arguments
+ */
+ void setPixel(int idx, int x, int y, uint8_t red, uint8_t green, uint8_t blue);
+
+ /**
+ * Draws a line of a specific color between any two points
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x1 The first x co-ordinate of the line
+ * @param y1 The first y co-ordinate of the line
+ * @param x2 The second x co-ordinate of the line
+ * @param y2 The second y co-ordinate of the line
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+
+ void drawLine(int idx, int x1, int y1, int x2, int y2, int color);
+
+ /**
+ * Draws a line of a specific color between any two points with reg, blue, and blue values in seperate arguments
+ */
+ void drawLine(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue);
+ /**
+ * Draws a rectangle outline of a specific color given two opposite corner points
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x1 The first x co-ordinate of a corner
+ * @param y1 The first y co-ordinate of a corner
+ * @param x2 The second x co-ordinate of a corner
+ * @param y2 The second y co-ordinate of a corner
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+
+ void drawRect(int idx, int x1, int y1, int x2, int y2, int color);
+
+ /**
+ * Draws a rectangle outline of a specific color given two opposite corner points with reg, blue, and blue values in seperate arguments
+ */
+ void drawRect(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue);
+
+ /**
+ * Draws a filled rectangle of a specific color given two opposite corner points
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x1 The first x co-ordinate of a corner
+ * @param y1 The first y co-ordinate of a corner
+ * @param x2 The second x co-ordinate of a corner
+ * @param y2 The second y co-ordinate of a corner
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+
+ void drawFilledRect(int idx, int x1, int y1, int x2, int y2, int color);
+
+ /**
+ * Draws a filled rectangle of a specific color given two opposite corner points with reg, blue, and blue values in seperate arguments
+ */
+ void drawFilledRect(int idx, int x1, int y1, int x2, int y2, uint8_t red, uint8_t green, uint8_t blue);
+
+ /**
+ * Fills the entire array screen with one color
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+ void fillScreen(int idx, int color);
+
+ /**
+ * Fills the entire array screen with one color with reg, blue, and blue values in seperate arguments
+ *
+ */
+ void fillScreen(int idx, uint8_t red,uint8_t green, uint8_t blue);
+
+
+ /**
+ * Draws a triangle outline of a specific color given three corner points
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x1 The first x co-ordinate of a corner
+ * @param y1 The first y co-ordinate of a corner
+ * @param x2 The second x co-ordinate of a corner
+ * @param y2 The second y co-ordinate of a corner
+ * @param x3 The third x co-ordinate of a corner
+ * @param y3 The third y co-ordinate of a corner
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+ void drawTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, int color);
+
+ /**
+ * Draws a triangle outline of a specific color given three corner points with reg, blue, and blue values in seperate arguments
+ */
+ void drawTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, uint8_t red, uint8_t green, uint8_t blue);
+ /**
+ * Draws a filled triangle of a specific color given three corner points
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x1 The first x co-ordinate of a corner
+ * @param y1 The first y co-ordinate of a corner
+ * @param x2 The second x co-ordinate of a corner
+ * @param y2 The second y co-ordinate of a corner
+ * @param x3 The third x co-ordinate of a corner
+ * @param y3 The third y co-ordinate of a corner
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+
+ void drawFilledTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, int color);
+
+ /**
+ * Draws a filled triangle of a specific color given three corner points with reg, blue, and blue values in seperate arguments
+ */
+ void drawFilledTriangle(int idx, int x1, int y1, int x2, int y2, int x3, int y3, uint8_t red, uint8_t green, uint8_t blue);
+
+ /**
+ * Draws a single 6x8 character on the array. The character will be pulled from font.h
+ *
+ * @param idx The index of the array to write on. Indexing starts at 0 (use 0 if there is only one array)
+ * @param x The x co-ordinate of the lower left point of the character
+ * @param y The y co-ordinate of the lower left point of the character
+ * @para c The character to be drawn
+ * @param color Integer golding a 24 bit color using RGB hex indexing (e.g. 0xff0000 is red)
+ */
+ void drawChar(int idx, int x, int y, char c, int color);
+
+ /**
+ * Draws a single 6x8 character on the array. The character will be pulled from font.h with reg, blue, and blue values in seperate arguments
+ */
+ void drawChar(int idx, int x, int y, char c, uint8_t red, uint8_t green, uint8_t blue);
+
+
+ /**
+ * Displays a 64 bit image on board idx
+ *
+ * @param idx The index of the board
+ * @param colors An array of length 64 containing the image to be displayed
+ */
+ void showImage(int idx, const int *colors);
+
+ void showImageRGB(int idx, int bmp, int r, int g, int b);
+
+ /**
+ * Clears all pixels on all boards (sets them all to 0)
+ */
+ void clear();
+
+ /**
+ * Write the colors out to the strip; this method must be called
+ * to see any hardware effect.
+ *
+ * This function disables interrupts while the strip data is being sent,
+ * each pixel takes approximately 30us to send, plus a 50us reset pulse
+ * at the end.
+ */
+ void write();
+
+
+ protected:
+ NeoColor *arr; // pixel data buffer modified by setPixel() and used by neo_out()
+ int N; // the number of pixels in the strip
+ int Nbytes; // the number of bytes of pixel data (always N*3)
+ float bright; // the master strip brightness
+ //gpio_t gpio; // gpio struct for initialization and getting register addresses
+
+ private:
+ int __size;
+ int __zeroHigh, __zeroLow, __oneHigh, __oneLow;
+ //unsigned char __II;
+ //BrightnessControl __use_II;
+ bool *__transmitBuf;
+ void __loadBuf(void);
+ PinName __outPin;
+ DigitalOut __gpo;
+};
+
+#endif
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/NeoMatrix/font.h Mon Jun 12 16:57:43 2017 +0000
@@ -0,0 +1,261 @@
+/**********************************************
+ * font.h
+ *
+ * Taylor Powell
+ * March 2015
+ *
+ * font used is the free BMplain, which can be replaced with any 6x8 font array
+ */
+/*****************************************
+ 5 pixels wide
+ {0x3e,0x22,0x2a,0x22,0x3e,0x00}, // 0
+ {0x04,0x3e,0x00,0x00,0x00,0x00}, // 1
+ {0x3a,0x2a,0x2a,0x2a,0x2e,0x00}, // 2
+ {0x2a,0x2a,0x2a,0x2a,0x3e,0x00}, // 3
+ {0x0e,0x08,0x08,0x08,0x3e,0x00}, // 4
+ {0x2e,0x2a,0x2a,0x2a,0x3a,0x00}, // 5
+ {0x3e,0x2a,0x2a,0x2a,0x3a,0x00}, // 6
+ {0x02,0x02,0x02,0x02,0x3e,0x00}, // 7
+ {0x3e,0x2a,0x2a,0x2a,0x3e,0x00}, // 8
+ {0x2e,0x2a,0x2a,0x2a,0x3e,0x00}, // 9
+ {0x14,0x00,0x00,0x00,0x00,0x00}, // :
+ {0x34,0x00,0x00,0x00,0x00,0x00}, // ;
+4 pixels wide
+ {0x3e,0x22,0x22,0x3e,0x00,0x00}, // 0
+ {0x00,0x04,0x3e,0x00,0x00,0x00}, // 1
+ {0x3a,0x2a,0x2a,0x2e,0x00,0x00}, // 2
+ {0x2a,0x2a,0x2a,0x3e,0x00,0x00}, // 3
+ {0x0e,0x08,0x08,0x3e,0x00,0x00}, // 4
+ {0x2e,0x2a,0x2a,0x3a,0x00,0x00}, // 5
+ {0x3e,0x2a,0x2a,0x3a,0x00,0x00}, // 6
+ {0x02,0x02,0x02,0x3e,0x00,0x00}, // 7
+ {0x3e,0x2a,0x2a,0x3e,0x00,0x00}, // 8
+ {0x2e,0x2a,0x2a,0x3e,0x00,0x00}, // 9
+3 pixels wide
+ {0x3e,0x22,0x3e,0x00,0x00,0x00}, // 0
+ {0x00,0x04,0x3e,0x00,0x00,0x00}, // 1
+ {0x3a,0x2a,0x2e,0x00,0x00,0x00}, // 2
+ {0x2a,0x2a,0x3e,0x00,0x00,0x00}, // 3
+ {0x0e,0x08,0x3e,0x00,0x00,0x00}, // 4
+ {0x2e,0x2a,0x3a,0x00,0x00,0x00}, // 5
+ {0x3e,0x2a,0x3a,0x00,0x00,0x00}, // 6
+ {0x02,0x02,0x3e,0x00,0x00,0x00}, // 7
+ {0x3e,0x2a,0x3e,0x00,0x00,0x00}, // 8
+ {0x2e,0x2a,0x3e,0x00,0x00,0x00}, // 9
+*******************************************/
+const unsigned char font[96][6] = {
+ {0x00,0x00,0x00,0x00,0x00,0x00}, //
+ {0x2e,0x00,0x00,0x00,0x00,0x00}, // !
+ {0x03,0x00,0x03,0x00,0x00,0x00}, // "
+ {0x0a,0x1f,0x0a,0x1f,0x0a,0x00}, // #
+ {0x2e,0x2a,0x6b,0x2a,0x3a,0x00}, // $
+ {0x0e,0x2a,0x1e,0x08,0x3c,0x2a}, // %
+ {0x3e,0x2a,0x2a,0x22,0x38,0x08}, // &
+ {0x03,0x00,0x00,0x00,0x00,0x00}, // '
+ {0x1c,0x22,0x00,0x00,0x00,0x00}, // (
+ {0x22,0x1c,0x00,0x00,0x00,0x00}, // )
+ {0x15,0x0e,0x04,0x0e,0x15,0x00}, // *
+ {0x08,0x08,0x3e,0x08,0x08,0x00}, // +
+ {0x60,0x00,0x00,0x00,0x00,0x00}, // ,
+ {0x08,0x08,0x08,0x08,0x08,0x00}, // -
+ {0x20,0x00,0x00,0x00,0x00,0x00}, // .
+ {0x20,0x10,0x08,0x04,0x02,0x00}, // /
+ {0x1F,0x11,0x11,0x1F,0x00,0x00}, // 0 -adjusted
+ {0x00,0x02,0x1F,0x00,0x00,0x00}, // 1 -adjusted
+ {0x1D,0x15,0x15,0x17,0x00,0x00}, // 2 -adjusted
+ {0x15,0x15,0x15,0x1F,0x00,0x00}, // 3 -adjusted
+ {0x07,0x04,0x04,0x1F,0x00,0x00}, // 4 -adjusted
+ {0x17,0x15,0x15,0x1D,0x00,0x00}, // 5 -adjusted
+ {0x1F,0x15,0x15,0x1D,0x00,0x00}, // 6 -adjusted
+ {0x01,0x01,0x01,0x1F,0x00,0x00}, // 7 -adjusted
+ {0x1F,0x15,0x15,0x1F,0x00,0x00}, // 8 -adjusted
+ {0x17,0x15,0x15,0x1F,0x00,0x00}, // 9 -adjusted
+ {0x09,0x05,0x03,0x0F,0x00,0x00}, // Arrow NE :
+ {0x0F,0x03,0x05,0x09,0x00,0x00}, // Arrow NW :
+ {0x08,0x14,0x22,0x00,0x00,0x00}, // <
+ {0x14,0x14,0x14,0x14,0x14,0x00}, // =
+ {0x22,0x14,0x08,0x00,0x00,0x00}, // >
+ {0x10,0x18,0x1C,0x18,0x10,0x00}, // ? hazard triangle
+ {0x3e,0x02,0x3a,0x2a,0x3e,0x00}, // @
+ {0x1E,0x05,0x05,0x1E,0x00,0x00}, // A -adjusted
+ {0x1F,0x15,0x15,0x1B,0x00,0x00}, // B -adjusted
+ {0x1F,0x11,0x11,0x11,0x00,0x00}, // C -- adjusted
+ {0x1F,0x11,0x11,0x0E,0x00,0x00}, // D -adjusted
+ {0x1F,0x15,0x15,0x11,0x00,0x00}, // E -adjusted
+ {0x1F,0x05,0x05,0x01,0x00,0x00}, // F -adjusted
+ {0x1F,0x11,0x15,0x1D,0x00,0x00}, // G -adjusted
+ {0x1F,0x04,0x04,0x1F,0x00,0x00}, // H -adjusted
+ {0x11,0x1F,0x11,0x00,0x00,0x00}, // I -adjusted
+ {0x18,0x10,0x10,0x1F,0x00,0x00}, // J -adjusted
+ {0x1F,0x04,0x0A,0x11,0x00,0x00}, // K -adjusted
+ {0x1F,0x10,0x10,0x10,0x00,0x00}, // L -adjusted
+ {0x1F,0x02,0x1C,0x02,0x1F,0x00}, // M -adjusted
+ {0x1F,0x02,0x04,0x1F,0x00,0x00}, // N -adjusted
+ {0x0E,0x11,0x11,0x0E,0x00,0x00}, // O -adjusted
+ {0x1F,0x05,0x05,0x07,0x00,0x00}, // P -adjusted
+ {0x1F,0x11,0x19,0x1F,0x00,0x00}, // Q -adjusted
+ {0x1F,0x05,0x05,0x1A,0x00,0x00}, // R -adjusted
+ {0x17,0x15,0x15,0x1D,0x00,0x00}, // S -adjusted
+ {0x01,0x01,0x1F,0x01,0x00,0x00}, // T -adjusted
+ {0x0F,0x10,0x10,0x0F,0x00,0x00}, // U -adjusted
+ {0x07,0x08,0x10,0x08,0x07,0x00}, // V -adjusted
+ {0x1F,0x08,0x07,0x08,0x1F,0x00}, // W -adjusted
+ {0x11,0x0E,0x0E,0x11,0x00,0x00}, // X -adjusted
+ {0x01,0x02,0x1C,0x02,0x01,0x00}, // Y -adjusted
+ {0x19,0x15,0x15,0x13,0x00,0x00}, // Z -adjusted
+ {0x3e,0x22,0x00,0x00,0x00,0x00}, // [
+ {0x3f,0x21,0x3f,0x00,0x00,0x00}, // "\"
+ {0x22,0x3e,0x00,0x00,0x00,0x00}, // ]
+ {0x04,0x02,0x1F,0x02,0x04,0x00}, // ^ -- up arrow
+ {0x20,0x20,0x20,0x20,0x20,0x00}, // _
+ {0x1c,0x3e,0x3e,0x3e,0x1c,0x00}, // `
+ {0x3c,0x24,0x24,0x24,0x3c,0x20}, // a
+ {0x3e,0x24,0x24,0x24,0x3c,0x00}, // b
+ {0x3c,0x24,0x24,0x24,0x24,0x00}, // c
+ {0x3c,0x24,0x24,0x24,0x3e,0x00}, // d
+ {0x3c,0x24,0x34,0x2c,0x24,0x00}, // e
+ {0x08,0x3e,0x0a,0x0a,0x00,0x00}, // f
+ {0x1c,0x54,0x54,0x54,0x7c,0x00}, // g
+ {0x3e,0x04,0x04,0x04,0x3c,0x00}, // h
+ {0x3a,0x00,0x00,0x00,0x00,0x00}, // i
+ {0x20,0x40,0x7a,0x00,0x00,0x00}, // j
+ {0x3e,0x08,0x14,0x22,0x00,0x00}, // k
+ {0x02,0x3e,0x00,0x00,0x00,0x00}, // l
+ {0x3c,0x04,0x3c,0x04,0x3c,0x00}, // m
+ {0x3c,0x04,0x04,0x04,0x3c,0x00}, // n
+ {0x3c,0x24,0x24,0x24,0x3c,0x00}, // o
+ {0x7c,0x24,0x24,0x24,0x3c,0x00}, // p
+ {0x3c,0x24,0x24,0x24,0x7c,0x00}, // q
+ {0x3c,0x04,0x04,0x04,0x00,0x00}, // r
+ {0x24,0x2c,0x34,0x24,0x00,0x00}, // s
+ {0x04,0x3e,0x24,0x24,0x00,0x00}, // t
+ {0x3c,0x20,0x20,0x20,0x3c,0x00}, // u
+ {0x0c,0x10,0x20,0x10,0x0c,0x00}, // v
+ {0x3c,0x20,0x3c,0x20,0x3c,0x00}, // w
+ {0x24,0x24,0x18,0x24,0x24,0x00}, // x
+ {0x1c,0x50,0x50,0x50,0x7c,0x00}, // y
+ {0x24,0x34,0x2c,0x24,0x00,0x00}, // z
+ {0x08,0x3e,0x22,0x00,0x00,0x00}, // {
+ {0x1c,0x22,0x22,0x22,0x1c,0x00}, // |
+ {0x22,0x3e,0x08,0x00,0x00,0x00}, // }
+ {0x01,0x01,0x01,0x00,0x00,0x00}, // ~
+ {0x00,0x00,0x00,0x00,0x00,0x00}
+};
+//*************************************************/
+//{0x10,0x09,0x05,0x03,0x0F,0x00}, // Arrow NE
+//{0x0F,0x03,0x05,0x09,0x10,0x00}, // Arrow NW
+//{0x04,0x04,0x15,0x0E,0x04,0x00}, // Arrow E
+//{0x04,0x0E,0x15,0x04,0x04,0x00}, // Arrow W
+//{0x00,0x00,0x07,0x04,0x1e,0x00}, // $ 0x24 36
+//{0x00,0x23,0x13,0x08,0x64,0x62}, // % 0x25 37
+//{0x00,0x36,0x49,0x56,0x20,0x50}, // & 0x26 38
+//{0x00,0x00,0x00,0x07,0x00,0x00}, // ' 0x27 39
+// from http://www.sxlist.com/techref/datafile/charset/8x6.htm
+const unsigned char xfont[96][6] = {
+{0x00,0x00,0x00,0x00,0x00,0x00}, // 0x20 32
+{0x00,0x00,0x00,0x6f,0x00,0x00}, // ! 0x21 33
+{0x00,0x00,0x07,0x00,0x07,0x00}, // " 0x22 34
+{0x00,0x14,0x7f,0x14,0x7f,0x14}, // # 0x23 35
+{0x00,0x10,0x09,0x05,0x03,0x0F}, // Arrow NE $ 0x24 36
+{0x0F,0x03,0x05,0x09,0x10,0x00}, // Arrow NW % 0x25 37
+{0x04,0x04,0x15,0x0E,0x04,0x00}, // Arrow E & 0x26 38
+{0x04,0x0E,0x15,0x04,0x04,0x00}, // Arrow W ' 0x27 39
+{0x00,0x00,0x1c,0x22,0x41,0x00}, // ( 0x28 40
+{0x00,0x00,0x41,0x22,0x1c,0x00}, // ) 0x29 41
+{0x00,0x14,0x08,0x3e,0x08,0x14}, // * 0x2a 42
+{0x00,0x08,0x08,0x3e,0x08,0x08}, // + 0x2b 43
+{0x00,0x00,0x50,0x30,0x00,0x00}, // , 0x2c 44
+{0x00,0x08,0x08,0x08,0x08,0x08}, // - 0x2d 45
+{0x00,0x00,0x60,0x60,0x00,0x00}, // . 0x2e 46
+{0x00,0x20,0x10,0x08,0x04,0x02}, // / 0x2f 47
+{0x00,0x3e,0x51,0x49,0x45,0x3e}, // 0 0x30 48
+{0x00,0x00,0x42,0x7f,0x40,0x00}, // 1 0x31 49
+{0x00,0x42,0x61,0x51,0x49,0x46}, // 2 0x32 50
+{0x00,0x21,0x41,0x45,0x4b,0x31}, // 3 0x33 51
+{0x00,0x18,0x14,0x12,0x7f,0x10}, // 4 0x34 52
+{0x00,0x27,0x45,0x45,0x45,0x39}, // 5 0x35 53
+{0x00,0x3c,0x4a,0x49,0x49,0x30}, // 6 0x36 54
+{0x00,0x01,0x71,0x09,0x05,0x03}, // 7 0x37 55
+{0x00,0x36,0x49,0x49,0x49,0x36}, // 8 0x38 56
+{0x00,0x06,0x49,0x49,0x29,0x1e}, // 9 0x39 57
+{0x00,0x00,0x36,0x36,0x00,0x00}, // : 0x3a 58
+{0x00,0x00,0x56,0x36,0x00,0x00}, // ; 0x3b 59
+{0x00,0x08,0x14,0x22,0x41,0x00}, // < 0x3c 60
+{0x00,0x14,0x14,0x14,0x14,0x14}, // = 0x3d 61
+{0x00,0x00,0x41,0x22,0x14,0x08}, // > 0x3e 62
+{0x00,0x02,0x01,0x51,0x09,0x06}, // ? 0x3f 63
+{0x00,0x3e,0x41,0x5d,0x49,0x4e}, // @ 0x40 64
+{0x00,0x7e,0x09,0x09,0x09,0x7e}, // A 0x41 65
+{0x00,0x7f,0x49,0x49,0x49,0x36}, // B 0x42 66
+{0x00,0x3e,0x41,0x41,0x41,0x22}, // C 0x43 67
+{0x00,0x7f,0x41,0x41,0x41,0x3e}, // D 0x44 68
+{0x00,0x7f,0x49,0x49,0x49,0x41}, // E 0x45 69
+{0x00,0x7f,0x09,0x09,0x09,0x01}, // F 0x46 70
+{0x00,0x3e,0x41,0x49,0x49,0x7a}, // G 0x47 71
+{0x00,0x7f,0x08,0x08,0x08,0x7f}, // H 0x48 72
+{0x00,0x00,0x41,0x7f,0x41,0x00}, // I 0x49 73
+{0x00,0x20,0x40,0x41,0x3f,0x01}, // J 0x4a 74
+{0x00,0x7f,0x08,0x14,0x22,0x41}, // K 0x4b 75
+{0x00,0x7f,0x40,0x40,0x40,0x40}, // L 0x4c 76
+{0x00,0x7f,0x02,0x0c,0x02,0x7f}, // M 0x4d 77
+{0x00,0x7f,0x04,0x08,0x10,0x7f}, // N 0x4e 78
+{0x00,0x3e,0x41,0x41,0x41,0x3e}, // O 0x4f 79
+{0x00,0x7f,0x09,0x09,0x09,0x06}, // P 0x50 80
+{0x00,0x3e,0x41,0x51,0x21,0x5e}, // Q 0x51 81
+{0x00,0x7f,0x09,0x19,0x29,0x46}, // R 0x52 82
+{0x00,0x46,0x49,0x49,0x49,0x31}, // S 0x53 83
+{0x00,0x01,0x01,0x7f,0x01,0x01}, // T 0x54 84
+{0x00,0x3f,0x40,0x40,0x40,0x3f}, // U 0x55 85
+{0x00,0x0f,0x30,0x40,0x30,0x0f}, // V 0x56 86
+{0x00,0x3f,0x40,0x30,0x40,0x3f}, // W 0x57 87
+{0x00,0x63,0x14,0x08,0x14,0x63}, // X 0x58 88
+{0x00,0x07,0x08,0x70,0x08,0x07}, // Y 0x59 89
+{0x00,0x61,0x51,0x49,0x45,0x43}, // Z 0x5a 90
+{0x00,0x3c,0x4a,0x49,0x29,0x1e}, // [ 0x5b 91
+{0x00,0x02,0x04,0x08,0x10,0x20}, // \ 0x5c 92
+{0x00,0x00,0x41,0x7f,0x00,0x00}, // ] 0x5d 93
+{0x00,0x04,0x02,0x01,0x02,0x04}, // ^ 0x5e 94
+{0x00,0x40,0x40,0x40,0x40,0x40}, // _ 0x5f 95
+{0x00,0x00,0x00,0x03,0x04,0x00}, // ` 0x60 96
+{0x00,0x20,0x54,0x54,0x54,0x78}, // a 0x61 97
+{0x00,0x7f,0x48,0x44,0x44,0x38}, // b 0x62 98
+{0x00,0x38,0x44,0x44,0x44,0x20}, // c 0x63 99
+{0x00,0x38,0x44,0x44,0x48,0x7f}, // d 0x64 100
+{0x00,0x38,0x54,0x54,0x54,0x18}, // e 0x65 101
+{0x00,0x08,0x7e,0x09,0x01,0x02}, // f 0x66 102
+{0x00,0x0c,0x52,0x52,0x52,0x3e}, // g 0x67 103
+{0x00,0x7f,0x08,0x04,0x04,0x78}, // h 0x68 104
+{0x00,0x00,0x44,0x7d,0x40,0x00}, // i 0x69 105
+{0x00,0x20,0x40,0x44,0x3d,0x00}, // j 0x6a 106
+{0x00,0x00,0x7f,0x10,0x28,0x44}, // k 0x6b 107
+{0x00,0x00,0x41,0x7f,0x40,0x00}, // l 0x6c 108
+{0x00,0x7c,0x04,0x18,0x04,0x78}, // m 0x6d 109
+{0x00,0x7c,0x08,0x04,0x04,0x78}, // n 0x6e 110
+{0x00,0x38,0x44,0x44,0x44,0x38}, // o 0x6f 111
+{0x00,0x7c,0x14,0x14,0x14,0x08}, // p 0x70 112
+{0x00,0x08,0x14,0x14,0x18,0x7c}, // q 0x71 113
+{0x00,0x7c,0x08,0x04,0x04,0x08}, // r 0x72 114
+{0x00,0x48,0x54,0x54,0x54,0x20}, // s 0x73 115
+{0x00,0x04,0x3f,0x44,0x40,0x20}, // t 0x74 116
+{0x00,0x3c,0x40,0x40,0x20,0x7c}, // u 0x75 117
+{0x00,0x1c,0x20,0x40,0x20,0x1c}, // v 0x76 118
+{0x00,0x3c,0x40,0x30,0x40,0x3c}, // w 0x77 119
+{0x00,0x44,0x28,0x10,0x28,0x44}, // x 0x78 120
+{0x00,0x0c,0x50,0x50,0x50,0x3c}, // y 0x79 121
+{0x00,0x44,0x64,0x54,0x4c,0x44}, // z 0x7a 122
+{0x00,0x00,0x08,0x36,0x41,0x41}, // { 0x7b 123
+{0x00,0x00,0x00,0x7f,0x00,0x00}, // | 0x7c 124
+{0x00,0x41,0x41,0x36,0x08,0x00}, // } 0x7d 125
+{0x00,0x04,0x02,0x04,0x08,0x04}, // ~ 0x7e 126
+{0x00,0x00,0x00,0x00,0x00,0x00} // 0 0xff 255
+};
+
+const unsigned char smile_img[4][8] = {
+{0x1E,0x21,0xD2,0xC0,0xD2,0xCC,0x21,0x1E}, // wrong
+{0x2C,0x42,0x95,0xA1,0xA1,0x95,0x42,0x2C}, // smiley -- good
+{0x1E,0x21,0xD2,0xC0,0xD2,0xCC,0x21,0x1E}, // smiley
+{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00} // blank
+};
+//smile_bmp = [0b00011110,0b00100001,0b11010010,0b11000000,0b11010010,0b11001100,0b00100001,0b00011110]
+//neutral_bmp = [0b00011110,0b00100001,0b11010010,0b11000000,0b11011110,0b11000000,0b00100001,0b00011110]
+//frown_bmp = [0b00011110,0b00100001,0b11010010,0b11000000,0b11001100,0b11010010,0b00100001,0b00011110]
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Mon Jun 12 16:57:43 2017 +0000
@@ -0,0 +1,254 @@
+#include "mbed.h"
+
+#include "NeoMatrix.h"
+
+//#include "WS2812.h"
+//#include "PixelArray.h"
+
+#define WS2812_BUF 70
+
+#define Color(r, g, b) ((r&0xFF)<<16 | (g&0xFF) << 8 | (b&0xFF)) // pack colors
+
+#define Red (Color(255,0,0))
+#define Green (Color(0,255,0))
+#define Blue (Color(0,0,255))
+
+
+// for KL25Z
+//DigitalOut CPU_Mon(PTD5); // to measure time in output loop
+// for LPC1768
+//DigitalOut CPU_Mon(p21); // to measure time in output loop
+// for STM32F103 Nucleo
+DigitalOut CPU_Mon(PB_6); // to measure time in output loop
+
+DigitalOut myled(LED1);
+//DigitalOut myled2(LED2);
+//DigitalOut myled3(LED3);
+
+//PixelArray px(WS2812_BUF);
+//NeoArr = px(1);
+
+// See the program page for information on the timing numbers
+// The given numbers are for the K64F: 0, 5, 5, 0
+// K64F, KL46Z: 0, 5, 5, 0
+//NeoArr array(PTD2, 1, 0, 5, 5, 0);
+// LPC1768: 5, 10, 10, 15
+//NeoArr array(p18, 1, 5, 10, 10, 15);
+// STM32F103 Nucleo: 0, 5, 5, 0
+NeoArr array(PC_7, 1, 0, 5, 5, 0);
+
+Ticker timer;
+char second_tick;
+
+// -- sets a flag every time the 5 second timer fires
+void attime()
+{
+ second_tick = true;
+ //HazLed = 1; // turn Haz Led off
+ //NmeaPrint = true;
+}
+
+//const unsigned char smile_img[8] = {0x1E,0x21,0xD2,0xC0,0xD2,0xCC,0x21,0x1E}; // smiley
+void scroll_str(char *buff, int i)
+{
+ //int start_px, end_px;
+ //start_px = n;
+ //end_px = n * -6;
+
+ array.clear();
+ array.drawChar(0,i,0,buff[0], 128,128,128);
+ array.drawChar(0,i+6,0,buff[1], 128,128,128);
+ array.drawChar(0,i+12,0,buff[2], 128,128,128);
+ if ( buff[3] == '&' )
+ array.drawChar(0,i+18,0,buff[3], 255,255,0);
+ else
+ array.drawChar(0,i+18,0,buff[3], 255,0,0);
+ //CPU_Mon = 1;
+ array.write();
+
+}
+
+int main()
+{
+ char led_str[6];
+ char c;
+ int distance = 900;
+ float bright = 0.2; // 20% is bright enough for most indoor use and should run without need for external power
+
+ array.setBrightness(bright); // set brightness to default 0.2
+ array.clear();
+ myled = 1;
+ wait_ms(500);
+ myled = 0;
+ wait_ms(500);
+ myled = 1;
+ second_tick = false;
+ timer.attach(&attime, 1);
+ c = '0';
+
+ while (true)
+ {
+ while ( 1 )
+ {
+ /******************************
+ array.clear();
+ array.write();
+ wait_ms(2000);
+ array.drawChar(0,0,0,'V', 1,128,1);
+ array.drawChar(0,5,0,'C', 1,128,1);
+ array.drawChar(0,10,0,'P', 1,128,1);
+ array.write();
+ wait_ms(2000);
+ array.clear();
+ array.drawChar(0,0,0,'2', 128,128,1);
+ array.drawChar(0,5,0,'8', 128,128,1);
+ array.drawChar(0,10,0,'7', 128,128,1);
+ array.write();
+ wait_ms(2000);
+ ******************************/
+ /**********************************
+ for (char i='A'; i<'Z'; i+=3 )
+ {
+ array.clear();
+ array.drawChar(0,0,0,i, 1,128,1);
+ array.drawChar(0,5,0,i+1, 128,1,1);
+ array.drawChar(0,10,0,i+2, 1,1,128);
+ array.write();
+ wait_ms(2000);
+ }
+ *************************************/
+ array.clear();
+ array.drawChar(0,0,0,'?', 128,0,0);
+ array.drawChar(0,5,0,'6', 128,128,128);
+ array.drawChar(0,9,0,':', 128,1,1);
+ array.write();
+ wait_ms(2000);
+
+ array.clear();
+ array.drawChar(0,0,0,'?', 128,0,0);
+ array.drawChar(0,5,0,'1', 128,128,128);
+ array.drawChar(0,9,0,';', 128,1,1);
+ array.write();
+ wait_ms(2000);
+
+ array.clear();
+ array.drawChar(0,0,0,'?', 128,0,0);
+ array.drawChar(0,5,0,'8', 128,128,128);
+ array.drawChar(0,9,0,'^', 128,1,1);
+ array.write();
+ wait_ms(2000);
+
+ /****************************************************
+ array.fillScreen(0,128, 0, 0);
+ array.write();
+ wait_ms(2000);
+
+ array.fillScreen(0,0, 128, 0);
+ array.write();
+ wait_ms(2000);
+
+ array.fillScreen(0,0, 0, 128);
+ array.write();
+ wait_ms(2000);
+
+ array.clear();
+ for(int i=0; i<14; i++)
+ {
+ for(int n=0; n<5; n++)
+ {
+ array.setPixel(0, i, n, 128, 0, 128);
+ array.write();
+ wait_ms(200);
+ }
+ }
+
+ wait_ms(2000);
+ *****************************************/
+
+ //for ( i =
+ /*****************************************
+ //sprintf( led_str, "VCP", distance, c);
+ for(int i=7;i>=-16;i--)
+ {
+ array.clear();
+ array.drawChar(0,i,0,'V', 128,128,128);
+ array.drawChar(0,i+6,0,'C', 128,128,128);
+ array.drawChar(0,i+12,0,'P', 128,128,128);
+ array.write();
+ //scroll_str( led_str, i );
+ wait_ms(75);
+ }
+ wait_ms(100);
+ for(int i=7;i>=-16;i--)
+ {
+ array.clear();
+ array.drawChar(0,i,0,'2', 128,128,128);
+ array.drawChar(0,i+6,0,'7', 128,128,128);
+ array.drawChar(0,i+12,0,'1', 128,128,128);
+ array.write();
+ //scroll_str( led_str, i );
+ wait_ms(75);
+ }
+ wait_ms(100);
+ array.clear();
+ array.showImageRGB(0, 1, 255, 255, 0);
+ array.write();
+ wait_ms(400);
+ *******************************************/
+ //wait_ms(4000);
+ }
+ //sprintf( led_str, "%3d%c", distance, c);
+ /*************************************************
+ while ( 1 )
+ {
+ if ( distance > 500 ) c = '$';
+ else c = '&';
+ sprintf( led_str, "%3d%c", distance, c);
+ for(int i=7;i>=-24;i--)
+ {
+ //myled = 1;
+ //CPU_Mon = 1;
+ //array.clear();
+ //array.drawChar(0,i,0,'2', 128,128,128);
+ //array.drawChar(0,i+6,0,'4', 128,128,128);
+ //array.drawChar(0,i+12,0,'8', 128,128,128);
+ //array.drawChar(0,i+18,0,'$', 255,0,0);
+ //CPU_Mon = 1;
+ //array.write();
+ //myled = 0;
+ //CPU_Mon = 0;
+ scroll_str( led_str, i );
+ wait_ms(75);
+ }
+ //wait_ms(500);
+ //array.clear();
+ //array.showImageRGB(0, 1, 255, 255, 0);
+ //array.drawChar(0,i+18,0,'$', 255,0,0);
+ //array.write();
+ //wait_ms(500);
+ distance -= 108;
+ if ( distance < 100 ) distance = 900;
+ }
+
+ if ( second_tick == true )
+ {
+ second_tick = false;
+ array.clear();
+ array.drawChar(0,0,1,c, 128,128,128);
+ if ( c > '7' )
+ array.drawChar(0,4,0,'^', 255,0,0);
+ else if ( c > '4' )
+ array.drawChar(0,4,0,':', 255,0,0);
+ else if ( c == '3' )
+ array.drawChar(0,5,1,'>', 255,0,0);
+ else if ( c == '2' )
+ array.drawChar(0,5,1,'<', 255,0,0);
+ else
+ array.drawChar(0,4,0,';', 255,0,0);
+ array.write();
+ c++;
+ if ( c > '9' ) c = '0';
+ }
+ *******************************************/
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Mon Jun 12 16:57:43 2017 +0000 @@ -0,0 +1,1 @@ +https://mbed.org/users/mbed_official/code/mbed/builds/856d2700e60b \ No newline at end of file