![](/media/cache/group/default_image.jpg.50x50_q85.jpg)
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
diff -r 000000000000 -r a32d1a85a830 NeoMatrix/NeoMatrix.cpp --- /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(); +} +
diff -r 000000000000 -r a32d1a85a830 NeoMatrix/NeoMatrix.h --- /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 + +
diff -r 000000000000 -r a32d1a85a830 NeoMatrix/font.h --- /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
diff -r 000000000000 -r a32d1a85a830 main.cpp --- /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'; + } + *******************************************/ + } +}
diff -r 000000000000 -r a32d1a85a830 mbed.bld --- /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