Subversion Repositories Code-Repo

#include "defines.h"

#include "oled_ssd1331.h"

#include "spi.h"

#include "string.h"

#include "glcdfont.c"

#include <delays.h>

#include <string.h>

#include <stdio.h>

static SSD1331_DATA ssd1331_data;

static SSD1331_DATA *ssd1331_data_p = &ssd1331_data;

int SSD1331_Abs(int i) {

    if (i < 0)

        return -i;

    else

        return i;

}

void SSD1331_Swap(int *a, int *b) {

    int tmp = *a;

    *a = *b;

    *b = tmp;

}

void SSD1331_Init() {

    ssd1331_data_p->_width = ssd1331_data_p->WIDTH = SSD1331_LCDWIDTH;

    ssd1331_data_p->_height = ssd1331_data_p->HEIGHT = SSD1331_LCDHEIGHT;

    ssd1331_data_p->rotation = 0;

    ssd1331_data_p->cursor_x = ssd1331_data_p->cursor_y = 0;

    ssd1331_data_p->textsize = 1;

    ssd1331_data_p->textcolor = ssd1331_data_p->textbgcolor = 0xFFFF;

    ssd1331_data_p->wrap = 1;

}

void SSD1331_Begin() {

    unsigned char buffer[37];

    // Toggle reset pin

    SPI_RESET_LAT = 0;

    Delay10KTCYx(1);

    SPI_RESET_LAT = 1;

    // Initialization Sequence

    buffer[0] = SSD1331_CMD_DISPLAYOFF; // 0xAE

    buffer[1] = SSD1331_CMD_SETREMAP; // 0xA0

#if defined SSD1331_COLORORDER_RGB

    buffer[2] = 0x72; // RGB Color

#else

    buffer[2] = 0x76; // BGR Color

#endif

    buffer[3] = SSD1331_CMD_STARTLINE; // 0xA1

    buffer[4] = 0x0;

    buffer[5] = SSD1331_CMD_DISPLAYOFFSET; // 0xA2

    buffer[6] = 0x0;

    buffer[7] = SSD1331_CMD_NORMALDISPLAY; // 0xA4

    buffer[8] = SSD1331_CMD_SETMULTIPLEX; // 0xA8

    buffer[9] = 0x3F; // 0x3F 1/64 duty

    buffer[10] = SSD1331_CMD_SETMASTER; // 0xAD

    buffer[11] = 0x8E;

    buffer[12] = SSD1331_CMD_POWERMODE; // 0xB0

    buffer[13] = 0x0B;

    buffer[14] = SSD1331_CMD_PRECHARGE; // 0xB1

    buffer[15] = 0x31;

    buffer[16] = SSD1331_CMD_CLOCKDIV; // 0xB3

    buffer[17] = 0xF0; // 7:4 = Oscillator Frequency, 3:0 = CLK Div Ratio (A[3:0]+1 = 1..16)

    buffer[18] = SSD1331_CMD_PRECHARGEA; // 0x8A

    buffer[19] = 0x64;

    buffer[20] = SSD1331_CMD_PRECHARGEB; // 0x8B

    buffer[21] = 0x78;

    buffer[22] = SSD1331_CMD_PRECHARGEA; // 0x8C

    buffer[23] = 0x64;

    buffer[24] = SSD1331_CMD_PRECHARGELEVEL; // 0xBB

    buffer[25] = 0x3A;

    buffer[26] = SSD1331_CMD_VCOMH; // 0xBE

    buffer[27] = 0x3E;

    buffer[28] = SSD1331_CMD_MASTERCURRENT; // 0x87

    buffer[29] = 0x06;

    buffer[30] = SSD1331_CMD_CONTRASTA; // 0x81

    buffer[31] = 0x91;

    buffer[32] = SSD1331_CMD_CONTRASTB; // 0x82

    buffer[33] = 0x50;

    buffer[34] = SSD1331_CMD_CONTRASTC; // 0x83

    buffer[35] = 0x7D;

    buffer[36] = SSD1331_CMD_DISPLAYON; //--turn on oled panel

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 37);

}

void SSD1331_GoTo(int x, int y) {

    unsigned char buffer[6];

    if ((x >= SSD1331_LCDWIDTH) || (y >= SSD1331_LCDHEIGHT)) return;

    // set x and y coordinate

    buffer[0] = (SSD1331_CMD_SETCOLUMN);

    buffer[1] = (x); // Start x address

    buffer[2] = (SSD1331_LCDWIDTH - 1); // End x address

    buffer[3] = (SSD1331_CMD_SETROW);

    buffer[4] = (y); // Start y address

    buffer[5] = (SSD1331_LCDHEIGHT - 1); // End y address

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 6);

}

void SSD1331_Command(unsigned char cmd) {

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(&cmd, 1);

}

void SSD1331_Data(unsigned char data) {

    SPI_DC_SELECT_LAT = 1; // D/C high (data)

    SPI2_Write(&data, 1);

}

void SSD1331_Clear_Display() {

    unsigned char buffer[5];

    buffer[0] = SSD1331_CMD_CLEARWINDOW;

    buffer[1] = 0;

    buffer[2] = 0;

    buffer[3] = SSD1331_LCDWIDTH-1;

    buffer[4] = SSD1331_LCDHEIGHT-1;

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 5);

    Delay1KTCYx(4);

}

void SSD1331_Draw_Pixel(int x, int y, unsigned int color) {

    unsigned char buffer[2];

    buffer[0] = color >> 8;

    buffer[1] = color;

    if ((x < 0) || (x >= ssd1331_data_p->_width) || (y < 0) || (y >= ssd1331_data_p->_height)) return;

    // check rotation, move pixel around if necessary

    switch (ssd1331_data_p->rotation) {

        case 1:

            SSD1331_Swap(&x, &y);

            x = SSD1331_LCDWIDTH - x - 1;

            break;

        case 2:

            x = SSD1331_LCDWIDTH - x - 1;

            y = SSD1331_LCDHEIGHT - y - 1;

            break;

        case 3:

            SSD1331_Swap(&x, &y);

            y = SSD1331_LCDHEIGHT - y - 1;

            break;

    }

    SSD1331_GoTo(x, y);

    // setup for data

    SPI_DC_SELECT_LAT = 1; // D/C high (data)

    SPI2_Write(buffer, 2);

}

void SSD1331_Draw_Line(int x0, int y0, int x1, int y1, unsigned int color) {

    unsigned char buffer[8];

    // check rotation, move pixel around if necessary

    switch (ssd1331_data_p->rotation) {

        case 1:

            SSD1331_Swap(&x0, &y0);

            SSD1331_Swap(&x1, &y1);

            x0 = SSD1331_LCDWIDTH - x0 - 1;

            x1 = SSD1331_LCDWIDTH - x1 - 1;

            break;

        case 2:

            x0 = SSD1331_LCDWIDTH - x0 - 1;

            y0 = SSD1331_LCDHEIGHT - y0 - 1;

            x1 = SSD1331_LCDWIDTH - x1 - 1;

            y1 = SSD1331_LCDHEIGHT - y1 - 1;

            break;

        case 3:

            SSD1331_Swap(&x0, &y0);

            SSD1331_Swap(&x1, &y1);

            y0 = SSD1331_LCDHEIGHT - y0 - 1;

            y1 = SSD1331_LCDHEIGHT - y1 - 1;

            break;

    }

    // Boundary check

    if ((y0 >= SSD1331_LCDHEIGHT) && (y1 >= SSD1331_LCDHEIGHT))

        return;

    if ((x0 >= SSD1331_LCDWIDTH) && (x1 >= SSD1331_LCDWIDTH))

        return;

    if (x0 >= SSD1331_LCDWIDTH)

        x0 = SSD1331_LCDWIDTH - 1;

    if (y0 >= SSD1331_LCDHEIGHT)

        y0 = SSD1331_LCDHEIGHT - 1;

    if (x1 >= SSD1331_LCDWIDTH)

        x1 = SSD1331_LCDWIDTH - 1;

    if (y1 >= SSD1331_LCDHEIGHT)

        y1 = SSD1331_LCDHEIGHT - 1;

    if (x0 < 0)

        x0 = 0;

    if (y0 < 0)

        y0 = 0;

    if (x1 < 0)

        x1 = 0;

    if (y1 < 0)

        y1 = 0;

    buffer[0] = SSD1331_CMD_DRAWLINE;

    buffer[1] = x0;

    buffer[2] = y0;

    buffer[3] = x1;

    buffer[4] = y1;

    buffer[5] = (color >> 11) << 1;

    buffer[6] = (color >> 5) & 0x3F;

    buffer[7] = (color << 1) & 0x3F;

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 8);

}

void SSD1331_Draw_Fast_VLine(int x, int y, int h, unsigned int color) {

    SSD1331_Draw_Line(x, y, x, y + h - 1, color);

}

void SSD1331_Draw_Fast_HLine(int x, int y, int w, unsigned int color) {

    SSD1331_Draw_Line(x, y, x + w - 1, y, color);

}

void SSD1331_Draw_Rect(int tx0, int ty0, int tx1, int ty1, unsigned int color) {

    unsigned char buffer[13];

    int x0,y0,x1,y1;

    // check rotation, move pixel around if necessary

    switch (ssd1331_data_p->rotation) {

        case 0:

            x0 = tx0;

            y0 = ty0;

            x1 = tx1;

            y1 = ty1;

            break;

        case 1:

            x0 = SSD1331_LCDWIDTH - ty1 - 1;

            y0 = tx0;

            x1 = SSD1331_LCDWIDTH - ty0 - 1;

            y1 = tx1;

            break;

        case 2:

            x0 = SSD1331_LCDWIDTH - tx1 - 1;

            y0 = SSD1331_LCDHEIGHT - ty1 - 1;

            x1 = SSD1331_LCDWIDTH - tx0 - 1;

            y1 = SSD1331_LCDHEIGHT - ty0 - 1;

            break;

        case 3:

            x0 = ty0;

            y0 = SSD1331_LCDHEIGHT - tx1 - 1;

            x1 = ty1;

            y1 = SSD1331_LCDHEIGHT - tx0 - 1;

            break;

    }

    // Boundary check

    if ((y0 >= SSD1331_LCDHEIGHT) && (y1 >= SSD1331_LCDHEIGHT))

        return;

    if ((x0 >= SSD1331_LCDWIDTH) && (x1 >= SSD1331_LCDWIDTH))

        return;

    if (x0 >= SSD1331_LCDWIDTH)

        x0 = SSD1331_LCDWIDTH - 1;

    if (y0 >= SSD1331_LCDHEIGHT)

        y0 = SSD1331_LCDHEIGHT - 1;

    if (x1 >= SSD1331_LCDWIDTH)

        x1 = SSD1331_LCDWIDTH - 1;

    if (y1 >= SSD1331_LCDHEIGHT)

        y1 = SSD1331_LCDHEIGHT - 1;

    if (x0 < 0)

        x0 = 0;

    if (y0 < 0)

        y0 = 0;

    if (x1 < 0)

        x1 = 0;

    if (y1 < 0)

        y1 = 0;

    buffer[0] = SSD1331_CMD_FILL;

    buffer[1] = 0;

    buffer[2] = SSD1331_CMD_DRAWRECT;

    buffer[3] = x0;

    buffer[4] = y0;

    buffer[5] = x1;

    buffer[6] = y1;

    buffer[7] = (color >> 11) << 1;

    buffer[8] = (color >> 5) & 0x3F;

    buffer[9] = (color << 1) & 0x3F;

    buffer[10] = 0;

    buffer[11] = 0;

    buffer[12] = 0;

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 13);

}

void SSD1331_Fill_Rect(int tx0, int ty0, int tx1, int ty1, unsigned int color) {

    unsigned char buffer[13];

    int x0,y0,x1,y1;

    // check rotation, move pixel around if necessary

    switch (ssd1331_data_p->rotation) {

        case 0:

            x0 = tx0;

            y0 = ty0;

            x1 = tx1;

            y1 = ty1;

            break;

        case 1:

            x0 = SSD1331_LCDWIDTH - ty1 - 1;

            y0 = tx0;

            x1 = SSD1331_LCDWIDTH - ty0 - 1;

            y1 = tx1;

            break;

        case 2:

            x0 = SSD1331_LCDWIDTH - tx1 - 1;

            y0 = SSD1331_LCDHEIGHT - ty1 - 1;

            x1 = SSD1331_LCDWIDTH - tx0 - 1;

            y1 = SSD1331_LCDHEIGHT - ty0 - 1;

            break;

        case 3:

            x0 = ty0;

            y0 = SSD1331_LCDHEIGHT - tx1 - 1;

            x1 = ty1;

            y1 = SSD1331_LCDHEIGHT - tx0 - 1;

            break;

    }

    // Boundary check

    if ((y0 >= SSD1331_LCDHEIGHT) && (y1 >= SSD1331_LCDHEIGHT))

        return;

    if ((x0 >= SSD1331_LCDWIDTH) && (x1 >= SSD1331_LCDWIDTH))

        return;

    if (x0 >= SSD1331_LCDWIDTH)

        x0 = SSD1331_LCDWIDTH - 1;

    if (y0 >= SSD1331_LCDHEIGHT)

        y0 = SSD1331_LCDHEIGHT - 1;

    if (x1 >= SSD1331_LCDWIDTH)

        x1 = SSD1331_LCDWIDTH - 1;

    if (y1 >= SSD1331_LCDHEIGHT)

        y1 = SSD1331_LCDHEIGHT - 1;

    if (x0 < 0)

        x0 = 0;

    if (y0 < 0)

        y0 = 0;

    if (x1 < 0)

        x1 = 0;

    if (y1 < 0)

        y1 = 0;

    buffer[0] = SSD1331_CMD_FILL;

    buffer[1] = 1;

    buffer[2] = SSD1331_CMD_DRAWRECT;

    buffer[3] = x0;

    buffer[4] = y0;

    buffer[5] = x1;

    buffer[6] = y1;

    buffer[7] = (color >> 11) << 1;

    buffer[8] = (color >> 5) & 0x3F;

    buffer[9] = (color << 1) & 0x3F;

    buffer[10] = (color >> 11) << 1;

    buffer[11] = (color >> 5) & 0x3F;

    buffer[12] = (color << 1) & 0x3F;

    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)

    SPI2_Write(buffer, 13);

    Delay1KTCYx(4);

}

void SSD1331_Draw_Circle(int x0, int y0, int r, unsigned int color) {

    int f = 1 - r;

    int ddF_x = 1;

    int ddF_y = -2 * r;

    int x = 0;

    int y = r;

    SSD1331_Draw_Pixel(x0, y0 + r, color);

    SSD1331_Draw_Pixel(x0, y0 - r, color);

    SSD1331_Draw_Pixel(x0 + r, y0, color);

    SSD1331_Draw_Pixel(x0 - r, y0, color);

    while (x < y) {

        if (f >= 0) {

            y--;

            ddF_y += 2;

            f += ddF_y;

        }

        x++;

        ddF_x += 2;

        f += ddF_x;

        SSD1331_Draw_Pixel(x0 + x, y0 + y, color);

        SSD1331_Draw_Pixel(x0 - x, y0 + y, color);

        SSD1331_Draw_Pixel(x0 + x, y0 - y, color);

        SSD1331_Draw_Pixel(x0 - x, y0 - y, color);

        SSD1331_Draw_Pixel(x0 + y, y0 + x, color);

        SSD1331_Draw_Pixel(x0 - y, y0 + x, color);

        SSD1331_Draw_Pixel(x0 + y, y0 - x, color);

        SSD1331_Draw_Pixel(x0 - y, y0 - x, color);

    }

}

void SSD1331_Draw_Circle_Helper(int x0, int y0, int r, unsigned char cornername, unsigned int color) {

    int f = 1 - r;

    int ddF_x = 1;

    int ddF_y = -2 * r;

    int x = 0;

    int y = r;

    while (x < y) {

        if (f >= 0) {

            y--;

            ddF_y += 2;

            f += ddF_y;

        }

        x++;

        ddF_x += 2;

        f += ddF_x;

        if (cornername & 0x4) {

            SSD1331_Draw_Pixel(x0 + x, y0 + y, color);

            SSD1331_Draw_Pixel(x0 + y, y0 + x, color);

        }

        if (cornername & 0x2) {

            SSD1331_Draw_Pixel(x0 + x, y0 - y, color);

            SSD1331_Draw_Pixel(x0 + y, y0 - x, color);

        }

        if (cornername & 0x8) {

            SSD1331_Draw_Pixel(x0 - y, y0 + x, color);

            SSD1331_Draw_Pixel(x0 - x, y0 + y, color);

        }

        if (cornername & 0x1) {

            SSD1331_Draw_Pixel(x0 - y, y0 - x, color);

            SSD1331_Draw_Pixel(x0 - x, y0 - y, color);

        }

    }

}

void SSD1331_Fill_Circle(int x0, int y0, int r, unsigned int color) {

    SSD1331_Draw_Fast_VLine(x0, y0 - r, 2 * r + 1, color);

    SSD1331_Fill_Circle_Helper(x0, y0, r, 3, 0, color);

}

void SSD1331_Fill_Circle_Helper(int x0, int y0, int r, unsigned char cornername, int delta, unsigned int color) {

    int f = 1 - r;

    int ddF_x = 1;

    int ddF_y = -2 * r;

    int x = 0;

    int y = r;

    while (x < y) {

        if (f >= 0) {

            y--;

            ddF_y += 2;

            f += ddF_y;

        }

        x++;

        ddF_x += 2;

        f += ddF_x;

        if (cornername & 0x1) {

            SSD1331_Draw_Fast_VLine(x0 + x, y0 - y, 2 * y + 1 + delta, color);

            SSD1331_Draw_Fast_VLine(x0 + y, y0 - x, 2 * x + 1 + delta, color);

        }

        if (cornername & 0x2) {

            SSD1331_Draw_Fast_VLine(x0 - x, y0 - y, 2 * y + 1 + delta, color);

            SSD1331_Draw_Fast_VLine(x0 - y, y0 - x, 2 * x + 1 + delta, color);

        }

    }

}

void SSD1331_Draw_Triangle(int x0, int y0, int x1, int y1, int x2, int y2, unsigned int color) {

    SSD1331_Draw_Line(x0, y0, x1, y1, color);

    SSD1331_Draw_Line(x1, y1, x2, y2, color);

    SSD1331_Draw_Line(x2, y2, x0, y0, color);

}

void SSD1331_Fill_Triangle(int x0, int y0, int x1, int y1, int x2, int y2, unsigned int color) {

    int a, b, y, last;

    int dx01 = x1 - x0;

    int dy01 = y1 - y0;

    int dx02 = x2 - x0;

    int dy02 = y2 - y0;

    int dx12 = x2 - x1;

    int dy12 = y2 - y1;

    int sa = 0;

    int sb = 0;

    // Sort coordinates by Y order (y2 >= y1 >= y0)

    if (y0 > y1) {

        SSD1331_Swap(&y0, &y1);

        SSD1331_Swap(&x0, &x1);

    }

    if (y1 > y2) {

        SSD1331_Swap(&y2, &y1);

        SSD1331_Swap(&x2, &x1);

    }

    if (y0 > y1) {

        SSD1331_Swap(&y0, &y1);

        SSD1331_Swap(&x0, &x1);

    }

    if (y0 == y2) { // Handle awkward all-on-same-line case as its own thing

        a = b = x0;

        if (x1 < a) a = x1;

        else if (x1 > b) b = x1;

        if (x2 < a) a = x2;

        else if (x2 > b) b = x2;

        SSD1331_Draw_Fast_HLine(a, y0, b - a + 1, color);

        return;

    }

    // For upper part of triangle, find scanline crossings for segments

    // 0-1 and 0-2.  If y1=y2 (flat-bottomed triangle), the scanline y1

    // is included here (and second loop will be skipped, avoiding a /0

    // error there), otherwise scanline y1 is skipped here and handled

    // in the second loop...which also avoids a /0 error here if y0=y1

    // (flat-topped triangle).

    if (y1 == y2) last = y1; // Include y1 scanline

    else last = y1 - 1; // Skip it

    for (y = y0; y <= last; y++) {

        a = x0 + sa / dy01;

        b = x0 + sb / dy02;

        sa += dx01;

        sb += dx02;

        /* longhand:

        a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);

        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);

         */

        if (a > b) SSD1331_Swap(&a, &b);

        SSD1331_Draw_Fast_HLine(a, y, b - a + 1, color);

    }

    // For lower part of triangle, find scanline crossings for segments

    // 0-2 and 1-2.  This loop is skipped if y1=y2.

    sa = dx12 * (y - y1);

    sb = dx02 * (y - y0);

    for (; y <= y2; y++) {

        a = x1 + sa / dy12;

        b = x0 + sb / dy02;

        sa += dx12;

        sb += dx02;

        /* longhand:

        a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);

        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);

         */

        if (a > b) SSD1331_Swap(&a, &b);

        SSD1331_Draw_Fast_HLine(a, y, b - a + 1, color);

    }

}

void SSD1331_Draw_Round_Rect(int x, int y, int w, int h, int r, unsigned int color) {

    // smarter version

    SSD1331_Draw_Fast_HLine(x + r, y, w - 2 * r, color); // Top

    SSD1331_Draw_Fast_HLine(x + r, y + h - 1, w - 2 * r, color); // Bottom

    SSD1331_Draw_Fast_VLine(x, y + r, h - 2 * r, color); // Left

    SSD1331_Draw_Fast_VLine(x + w - 1, y + r, h - 2 * r, color); // Right

    // draw four corners

    SSD1331_Draw_Circle_Helper(x + r, y + r, r, 1, color);

    SSD1331_Draw_Circle_Helper(x + w - r - 1, y + r, r, 2, color);

    SSD1331_Draw_Circle_Helper(x + w - r - 1, y + h - r - 1, r, 4, color);

    SSD1331_Draw_Circle_Helper(x + r, y + h - r - 1, r, 8, color);

}

void SSD1331_Fill_Round_Rect(int x, int y, int w, int h, int r, unsigned int color) {

    // smarter version

    SSD1331_Fill_Rect(x + r, y, w - 2 * r, h, color);

    // draw four corners

    SSD1331_Fill_Circle_Helper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color);

    SSD1331_Fill_Circle_Helper(x + r, y + r, r, 2, h - 2 * r - 1, color);

}

void SSD1331_Draw_Bitmap(int x, int y, const unsigned char* bitmap, int w, int h, unsigned int color) {

    int i, j;

    for (j = 0; j < h; j++) {

        for (i = 0; i < w; i++) {

            if (bitmap[i + (j / 8) * w] & (j % 8)) {

                SSD1331_Draw_Pixel(x + i, y + j, color);

            }

        }

    }

}

void SSD1331_Draw_Char(int x, int y, unsigned char c, unsigned int color, unsigned int bg, unsigned char size) {

    int i, j;

    unsigned int line;

    if ((x >= ssd1331_data_p->_width) || // Clip right

            (y >= ssd1331_data_p->_height) || // Clip bottom

            ((x + 5 * size - 1) < 0) || // Clip left

            ((y + 8 * size - 1) < 0)) // Clip top

        return;

    for (i = 0; i < 6; i++) {

        if (i == 5)

            line = 0x0;

        else

            line = font[(c * 5) + i];

        for (j = 0; j < 8; j++) {

            if (line & 0x1) {

                if (size == 1) {// default size

                    SSD1331_Draw_Pixel(x + i, y + j, color);

                } else { // big size

                    SSD1331_Fill_Rect(x + (i * size), y + (j * size), size, size, color);

                }

            } else if (bg != color) {

                if (size == 1) { // default size

                    SSD1331_Draw_Pixel(x + i, y + j, bg);

                } else { // big size

                    SSD1331_Fill_Rect(x + i*size, y + j*size, size, size, bg);

                }

            }

            line >>= 1;

        }

    }

}

void SSD1331_Write(unsigned char c) {

    if (c == '\n' || c == '\r') {

        ssd1331_data_p->cursor_y += ssd1331_data_p->textsize * 8;

        ssd1331_data_p->cursor_x = 0;

        //    } else if (c == '\r') {

        //        // skip em

    } else {

        SSD1331_Draw_Char(ssd1331_data_p->cursor_x, ssd1331_data_p->cursor_y, c, ssd1331_data_p->textcolor, ssd1331_data_p->textbgcolor, ssd1331_data_p->textsize);

        ssd1331_data_p->cursor_x += ssd1331_data_p->textsize * 6;

        if (ssd1331_data_p->wrap && (ssd1331_data_p->cursor_x > (ssd1331_data_p->_width - ssd1331_data_p->textsize * 6))) {

            ssd1331_data_p->cursor_y += ssd1331_data_p->textsize * 8;

            ssd1331_data_p->cursor_x = 0;

        }

    }

}

void SSD1331_Write_String(const rom char *fmt, ...) {

    unsigned char i, len;

    unsigned char buffer[SSD1331_STRING_BUFFER_SIZE];

    // Parse and create string

    va_list args;

    va_start(args, fmt);

    vsprintf((char *) buffer, fmt, args);

    va_end(args);

    len = strlen((char *) buffer);

    // Make sure string to insert fits in buffer, truncate if necessary

    if (len > SSD1331_STRING_BUFFER_SIZE)

        len = SSD1331_STRING_BUFFER_SIZE;

    // Print buffer to string

    for (i = 0; i < len; i++) {

        SSD1331_Write(buffer[i]);

    }

}

void SSD1331_Set_Cursor(int x, int y) {

    ssd1331_data_p->cursor_x = x;

    ssd1331_data_p->cursor_y = y;

}

void SSD1331_Set_Text_Color(unsigned int c) {

    // for 'transparent' background, we'll set the bg

    // to the same as fg instead of using a flag

    ssd1331_data_p->textcolor = c;

    ssd1331_data_p->textbgcolor = c;

}

void SSD1331_Set_Text_Color_BG(unsigned int c, unsigned int bg) {

    ssd1331_data_p->textcolor = c;

    ssd1331_data_p->textbgcolor = bg;

}

void SSD1331_Set_Text_Size(unsigned char s) {

    ssd1331_data_p->textsize = (s > 0) ? s : 1;

}

void SSD1331_Set_Text_Wrap(unsigned char w) {

    ssd1331_data_p->wrap = w;

}

void SSD1331_Set_Rotation(unsigned char x) {

    x %= 4; // cant be higher than 3

    ssd1331_data_p->rotation = x;

    switch (x) {

        case 0:

        case 2:

            ssd1331_data_p->_width = ssd1331_data_p->WIDTH;

            ssd1331_data_p->_height = ssd1331_data_p->HEIGHT;

            break;

        case 1:

        case 3:

            ssd1331_data_p->_width = ssd1331_data_p->HEIGHT;

            ssd1331_data_p->_height = ssd1331_data_p->WIDTH;

            break;

    }

}

unsigned int SSD1331_Color565(unsigned char r, unsigned char g, unsigned char b) {

    unsigned int c;

    c = r >> 3;

    c <<= 6;

    c |= g >> 2;

    c <<= 5;

    c |= b >> 3;

    return c;

}

void SSD1331_Test_DrawLines(unsigned int color) {

    int x, y;

    SSD1331_Clear_Display();

    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {

        SSD1331_Draw_Line(0, 0, x, ssd1331_data_p->_height - 1, color);

    }

    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {

        SSD1331_Draw_Line(0, 0, ssd1331_data_p->_width - 1, y, color);

    }

    SSD1331_Clear_Display();

    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {

        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, 0, x, ssd1331_data_p->_height - 1, color);

    }

    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {

        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, 0, 0, y, color);

    }

    SSD1331_Clear_Display();

    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {

        SSD1331_Draw_Line(0, ssd1331_data_p->_height - 1, x, 0, color);

    }

    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {

        SSD1331_Draw_Line(0, ssd1331_data_p->_height - 1, ssd1331_data_p->_width - 1, y, color);

    }

    SSD1331_Clear_Display();

    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {

        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, ssd1331_data_p->_height - 1, x, 0, color);

    }

    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {

        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, ssd1331_data_p->_height - 1, 0, y, color);

    }

}

void SSD1331_Test_DrawRect(unsigned int color) {

    int x;

    SSD1331_Clear_Display();

    if (ssd1331_data_p->_height < ssd1331_data_p->_width) {

        for (x = 0; x < ssd1331_data_p->_height - 1; x += 6) {

            SSD1331_Draw_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color);

        }

    } else {

        for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {

            SSD1331_Draw_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color);

        }

    }

}

void SSD1331_Test_FillRect(unsigned int color1, unsigned int color2) {

    int x;

    SSD1331_Clear_Display();

    if (ssd1331_data_p->_height < ssd1331_data_p->_width) {

        for (x = ssd1331_data_p->_height - 1; x > 6; x -= 6) {

            SSD1331_Fill_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color1);

            SSD1331_Draw_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color2);

        }

    } else {

        for (x = ssd1331_data_p->_width - 1; x > 6; x -= 6) {

            SSD1331_Fill_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color1);

            SSD1331_Draw_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color2);

        }

    }

}

void SSD1331_Test_DrawCircle(unsigned int radius, unsigned int color) {

    int x, y;

    for (x = 0; x < ssd1331_data_p->_width - 1 + radius; x += radius * 2) {

        for (y = 0; y < ssd1331_data_p->_height - 1 + radius; y += radius * 2) {

            SSD1331_Draw_Circle(x, y, radius, color);

        }

    }

}

void SSD1331_Test_FillCircle(unsigned int radius, unsigned int color) {

    unsigned char x, y;

    for (x = radius; x < ssd1331_data_p->_width - 1; x += radius * 2) {

        for (y = radius; y < ssd1331_data_p->_height - 1; y += radius * 2) {

            SSD1331_Fill_Circle(x, y, radius, color);

        }

    }

}

void SSD1331_Test_DrawTria(void) {

    int color = 0xF800;

    int t;

    int w = ssd1331_data_p->_width / 2;

    int x = ssd1331_data_p->_height;

    int y = 0;

    int z = ssd1331_data_p->_width;

    SSD1331_Clear_Display();

    for (t = 0; t <= 15; t += 1) {

        SSD1331_Draw_Triangle(w, y, y, x, z, x, color);

        x -= 4;

        y += 4;

        z -= 4;

        color += 100;

    }

}

void SSD1331_Test_DrawRoundRect(void) {

    int color = 100;

    int i, t, x, y, w, h;

    SSD1331_Clear_Display();

    for (t = 0; t <= 4; t += 1) {

        x = 0;

        y = 0;

        w = ssd1331_data_p->_width;

        h = ssd1331_data_p->_height;

        for (i = 0; i <= 24; i += 1) {

            SSD1331_Draw_Round_Rect(x, y, w, h, 5, color);

            x += 2;

            y += 3;

            w -= 4;

            h -= 6;

            color += 1100;

        }

        color += 100;

    }

}

void SSD1331_Test_MediaButtons(void) {

    // play

    SSD1331_Clear_Display();

    SSD1331_Fill_Round_Rect(25, 10, 78, 60, 8, SSD1331_WHITE);

    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_RED);

    Delay10KTCYx(100);

    // pause

    SSD1331_Fill_Round_Rect(25, 90, 78, 60, 8, SSD1331_WHITE);

    SSD1331_Fill_Round_Rect(39, 98, 20, 45, 5, SSD1331_GREEN);

    SSD1331_Fill_Round_Rect(69, 98, 20, 45, 5, SSD1331_GREEN);

    Delay10KTCYx(100);

    // play color

    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_BLUE);

    Delay10KTCYx(100);

    // pause color

    SSD1331_Fill_Round_Rect(39, 98, 20, 45, 5, SSD1331_RED);

    SSD1331_Fill_Round_Rect(69, 98, 20, 45, 5, SSD1331_RED);

    // play color

    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_GREEN);

}

void SSD1331_Test_Pattern(void) {

    unsigned char buffer[2];

    unsigned int i, j;

    SSD1331_GoTo(0, 0);

    for (i = 0; i < 64; i++) {

        for (j = 0; j < 96; j++) {

            if (i > 55) {

                buffer[0] = (SSD1331_WHITE >> 8);

                buffer[1] = (SSD1331_WHITE);

            } else if (i > 47) {

                buffer[0] = (SSD1331_BLUE >> 8);

                buffer[1] = (SSD1331_BLUE);

            } else if (i > 39) {

                buffer[0] = (SSD1331_GREEN >> 8);

                buffer[1] = (SSD1331_GREEN);

            } else if (i > 31) {

                buffer[0] = (SSD1331_CYAN >> 8);

                buffer[1] = (SSD1331_CYAN);

            } else if (i > 23) {

                buffer[0] = (SSD1331_RED >> 8);

                buffer[1] = (SSD1331_RED);

            } else if (i > 15) {

                buffer[0] = (SSD1331_MAGENTA >> 8);

                buffer[1] = (SSD1331_MAGENTA);

            } else if (i > 7) {

                buffer[0] = (SSD1331_YELLOW >> 8);

                buffer[1] = (SSD1331_YELLOW);

            } else {

                buffer[0] = (SSD1331_BLACK >> 8);

                buffer[1] = (SSD1331_BLACK);

            }

            SPI_DC_SELECT_LAT = 1; // D/C high (data)

            SPI2_Write(buffer, 2);

        }

    }

}