File content as of revision 4:3e25a10c202c:

/*
Based on http://os.mbed.com/users/RRacer/code/Adafruit-16x32-basic-demo/

*/

#include "mbed.h"
#include "rtos.h"
#include "LedMatrix.h"
#include "BufferedSerial.h"

BufferedSerial pc(USBTX, USBRX, 1024); // tx, rx

LedMatrix matrix;

void PaintThread()
{
    matrix.Paint();
}

int getNextByte()
{
    char value = 0;
    
    while(pc.readable() == 0);
    value = pc.getc();
    return value;
}

int main()
{
    Ticker ticker;
    matrix.Init();
    
    pc.baud(460800);
    
    #if defined(TARGET_STM32F767ZI)
    ticker.attach_us(PaintThread, 15);
    #elif defined(TARGET_STM32F303K8)
    ticker.attach_us(PaintThread, 25);
    #endif   
    
    uint16_t currentX = 0, currentY = 0;
    
    while(1) {       
    
    /*
        int c = getNextByte();   // Read byte from master
        
        switch (c)
        {
            case 'L':   // Location
                currentX = (getNextByte() << 8) + getNextByte();
                currentY = (getNextByte() << 8) + getNextByte();
                pc.printf("X: %d, Y: %d\n", currentX, currentY);
                break;
                
            case 'G': // Set background
                {
                    uint16_t c = getNextByte() | (getNextByte() << 8);
                    
                    for(int y=0;y<HEIGHT;y++)
                    {            
                        for(int x=0;x<WIDTH;x++)
                        {
                            matrix.drawPixel(x, y, c);
                        }
                    }
                }
                break;
                
            case 'B':   // Load buffer            
                for(int y=0;y<HEIGHT;y++)
                {            
                    for(int x=0;x<WIDTH;x++)
                    {
                        uint16_t c = getNextByte() | (getNextByte() << 8);
                        matrix.drawPixel(x, y, c);
                    }
                }
                break;
                    
            case 'C':   // Color
                {
                    uint16_t c = getNextByte() | (getNextByte() << 8);
                    matrix.drawPixel(currentX, currentY, c);
                    
                    currentX++;
                    if (currentX >= WIDTH)
                    {
                        currentX = 0;
                        currentY++;
                    }
                    
                    if (currentY >= HEIGHT)
                    {
                        currentY = 0;
                    }
                }
                break;
                
            case 'D':   // Double Buffer
                {
                    bool dBuffer = getNextByte() == 1;
                    matrix.SetDoubleBuffer(dBuffer);
                }
                break;
                
            case 'S':   // Swap Buffers
                {
                    bool copyBuffer = getNextByte() == 1;
                    matrix.Swap(copyBuffer);
                }
                break;
                
            case 'T':   // Text
                {
                    int16_t x = getNextByte() | (getNextByte() << 8);
                    int16_t y = getNextByte() | (getNextByte() << 8);              
                    int size = getNextByte();
                    uint16_t color = getNextByte() | (getNextByte() << 8);
                    
                    matrix.setCursor(x, y);
                    matrix.setTextColor(color);
                    matrix.setTextSize(size);
        
                    int length = getNextByte();
                    for(int c = 0; c< length;c++)
                    {
                        matrix.print((char) getNextByte());
                    }
                }
                break;
            }
        */

        /*
        for(int c=0;c<64;c++)
        {
            matrix.setCursor(20, 12);
            matrix.setTextColor(matrix.ColorHSV(c * 22, 255, 255, true));
            matrix.setTextSize(1);
            matrix.println("Test!");
            Thread::wait(200);
        }
    
        */
        for(int x=0;x<WIDTH;x++)
        {
            for(int y=0;y<32;y++)
            {
                matrix.drawPixel(x, y, matrix.ColorHSV(x * 22, 255, 255, true));
            }   
        }
        
        Thread::wait(5000);
    
        for(int c=0; c<16; c++) {
            for(int x=c; x<((WIDTH-1)-c); x++) {// Top side
                matrix.drawPixel(x,c,matrix.Color444(c, 0, 0));
                Thread::wait(10);
            }
            for(int y=c; y<((HEIGHT-1)-c); y++) {// Right side
                matrix.drawPixel((WIDTH-1)-c,y, matrix.Color444(0, c, 0));
                Thread::wait(10);
            }
            for(int x=((WIDTH-1)-c); x>=c; x--) {// Bottom side
                matrix.drawPixel(x,((HEIGHT-1)-c), matrix.Color444(0, 0, c));
                Thread::wait(10);
            }
            for(int y=((HEIGHT-1)-c); y>=c; y--) { // Left side
                matrix.drawPixel(c,y, matrix.Color444(0, c, 0));
                Thread::wait(10);
            }
        }
        
        Thread::wait(1000);
    }
}