WebSVN – Code-Repo – Diff – /PIC Stuff/PIC_27J13/oled_ssd1331.c

 #include "maindefs.h"
 #include "oled_ssd1331.h"
 #include "spi.h"
 #include "string.h"
-#include "Adafruit_GFX.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() {
-    GFX_Init(SSD1331_LCDWIDTH, SSD1331_LCDHEIGHT);
+    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
-    LATBbits.LATB6 = 0;
+    SPI_RESET_LAT = 0;
     Delay10KTCYx(1);
-    LATBbits.LATB6 = 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[33] = 0x50;
     buffer[34] = SSD1331_CMD_CONTRASTC; // 0x83
     buffer[35] = 0x7D;
     buffer[36] = SSD1331_CMD_DISPLAYON; //--turn on oled panel
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)
     SPI2_Write(buffer, 37);
+}
 void SSD1331_GoTo(int x, int y) {
     unsigned char buffer[6];
     buffer[3] = (SSD1331_CMD_SETROW);
     buffer[4] = (y); // Start y address
     buffer[5] = (SSD1331_LCDHEIGHT - 1); // End y address
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)
     SPI2_Write(buffer, 6);
+}
-void SSD1331_Reset() {
-}
 void SSD1331_Command(unsigned char cmd) {
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    SPI_DC_SELECT_LAT = 0; // D/C low (cmd)
     SPI2_Write(&cmd, 1);
+}
 void SSD1331_Data(unsigned char data) {
-    LATBbits.LATB5 = 1; // D/C high (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 >= GFX_width()) || (y < 0) || (y >= GFX_height())) return;
+    if ((x < 0) || (x >= ssd1331_data_p->_width) || (y < 0) || (y >= ssd1331_data_p->_height)) return;
     // check rotation, move pixel around if necessary
-    switch (GFX_getRotation()) {
+    switch (ssd1331_data_p->rotation) {
         case 1:
-            GFX_Swap(&x, &y);
+            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:
-            GFX_Swap(&x, &y);
+            SSD1331_Swap(&x, &y);
             y = SSD1331_LCDHEIGHT - y - 1;
             break;
+    }
     SSD1331_GoTo(x, y);
     // setup for data
-    LATBbits.LATB5 = 1; // D/C high (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 (GFX_getRotation()) {
+    switch (ssd1331_data_p->rotation) {
         case 1:
-            GFX_Swap(&x0, &y0);
+            SSD1331_Swap(&x0, &y0);
-            GFX_Swap(&x1, &y1);
+            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:
-            GFX_Swap(&x0, &y0);
+            SSD1331_Swap(&x0, &y0);
-            GFX_Swap(&x1, &y1);
+            SSD1331_Swap(&x1, &y1);
             y0 = SSD1331_LCDHEIGHT - y0 - 1;
             y1 = SSD1331_LCDHEIGHT - y1 - 1;
             break;
+    }
     buffer[4] = y1;
     buffer[5] = (color >> 11) << 1;
     buffer[6] = (color >> 5) & 0x3F;
     buffer[7] = (color << 1) & 0x3F;
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    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 (GFX_getRotation()) {
+    switch (ssd1331_data_p->rotation) {
         case 0:
             x0 = tx0;
             y0 = ty0;
             x1 = tx1;
             y1 = ty1;
     buffer[9] = (color << 1) & 0x3F;
     buffer[10] = 0;
     buffer[11] = 0;
     buffer[12] = 0;
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    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 (GFX_getRotation()) {
+    switch (ssd1331_data_p->rotation) {
         case 0:
             x0 = tx0;
             y0 = ty0;
             x1 = tx1;
             y1 = ty1;
     buffer[9] = (color << 1) & 0x3F;
     buffer[10] = (color >> 11) << 1;
     buffer[11] = (color >> 5) & 0x3F;
     buffer[12] = (color << 1) & 0x3F;
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    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);
-void SSD1331_Clear_Display() {
+    SSD1331_Draw_Pixel(x0 + r, y0, color);
+    SSD1331_Draw_Pixel(x0 - r, y0, color);
+    while (x < y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
-    unsigned char buffer[5];
+            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;
-    buffer[0] = SSD1331_CMD_CLEARWINDOW;
+    int ddF_y = -2 * r;
-    buffer[1] = 0;
+    int x = 0;
+    int y = r;
+    while (x < y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
-    buffer[2] = 0;
+        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);
+        }
-    buffer[3] = SSD1331_LCDWIDTH-1;
+        if (cornername & 0x8) {
+            SSD1331_Draw_Pixel(x0 - y, y0 + x, color);
+            SSD1331_Draw_Pixel(x0 - x, y0 + y, color);
+        }
-    buffer[4] = SSD1331_LCDHEIGHT-1;
+        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) {
-    LATBbits.LATB5 = 0; // D/C low (cmd)
+    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;
-    SPI2_Write(buffer, 5);
+        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);
-    Delay1KTCYx(4);
+    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;
     return c;
+}
 void SSD1331_Test_DrawLines(unsigned int color) {
     int x, y;
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    for (x = 0; x < GFX_width() - 1; x += 6) {
+    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {
-        GFX_drawLine(0, 0, x, GFX_height() - 1, color);
+        SSD1331_Draw_Line(0, 0, x, ssd1331_data_p->_height - 1, color);
+    }
-    for (y = 0; y < GFX_height() - 1; y += 6) {
+    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {
-        GFX_drawLine(0, 0, GFX_width() - 1, y, color);
+        SSD1331_Draw_Line(0, 0, ssd1331_data_p->_width - 1, y, color);
+    }
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    for (x = 0; x < GFX_width() - 1; x += 6) {
+    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {
-        GFX_drawLine(GFX_width() - 1, 0, x, GFX_height() - 1, color);
+        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, 0, x, ssd1331_data_p->_height - 1, color);
+    }
-    for (y = 0; y < GFX_height() - 1; y += 6) {
+    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {
-        GFX_drawLine(GFX_width() - 1, 0, 0, y, color);
+        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, 0, 0, y, color);
+    }
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    for (x = 0; x < GFX_width() - 1; x += 6) {
+    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {
-        GFX_drawLine(0, GFX_height() - 1, x, 0, color);
+        SSD1331_Draw_Line(0, ssd1331_data_p->_height - 1, x, 0, color);
+    }
-    for (y = 0; y < GFX_height() - 1; y += 6) {
+    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {
-        GFX_drawLine(0, GFX_height() - 1, GFX_width() - 1, y, color);
+        SSD1331_Draw_Line(0, ssd1331_data_p->_height - 1, ssd1331_data_p->_width - 1, y, color);
+    }
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    for (x = 0; x < GFX_width() - 1; x += 6) {
+    for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {
-        GFX_drawLine(GFX_width() - 1, GFX_height() - 1, x, 0, color);
+        SSD1331_Draw_Line(ssd1331_data_p->_width - 1, ssd1331_data_p->_height - 1, x, 0, color);
+    }
-    for (y = 0; y < GFX_height() - 1; y += 6) {
+    for (y = 0; y < ssd1331_data_p->_height - 1; y += 6) {
-        GFX_drawLine(GFX_width() - 1, GFX_height() - 1, 0, y, color);
+        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;
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    if (GFX_height() < GFX_width()) {
+    if (ssd1331_data_p->_height < ssd1331_data_p->_width) {
-        for (x = 0; x < GFX_height() - 1; x += 6) {
+        for (x = 0; x < ssd1331_data_p->_height - 1; x += 6) {
-            GFX_drawRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color);
+            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 < GFX_width() - 1; x += 6) {
+        for (x = 0; x < ssd1331_data_p->_width - 1; x += 6) {
-            GFX_drawRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color);
+            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;
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    if (GFX_height() < GFX_width()) {
+    if (ssd1331_data_p->_height < ssd1331_data_p->_width) {
-        for (x = GFX_height() - 1; x > 6; x -= 6) {
+        for (x = ssd1331_data_p->_height - 1; x > 6; x -= 6) {
-            GFX_fillRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color1);
+            SSD1331_Fill_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color1);
-            GFX_drawRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color2);
+            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 = GFX_width() - 1; x > 6; x -= 6) {
+        for (x = ssd1331_data_p->_width - 1; x > 6; x -= 6) {
-            GFX_fillRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color1);
+            SSD1331_Fill_Rect((ssd1331_data_p->_width - 1) / 2 - x / 2, (ssd1331_data_p->_height - 1) / 2 - x / 2, x, x, color1);
-            GFX_drawRect((GFX_width() - 1) / 2 - x / 2, (GFX_height() - 1) / 2 - x / 2, x, x, color2);
+            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 < GFX_width() - 1 + radius; x += radius * 2) {
+    for (x = 0; x < ssd1331_data_p->_width - 1 + radius; x += radius * 2) {
-        for (y = 0; y < GFX_height() - 1 + radius; y += radius * 2) {
+        for (y = 0; y < ssd1331_data_p->_height - 1 + radius; y += radius * 2) {
-            GFX_drawCircle(x, y, radius, color);
+            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 < GFX_width() - 1; x += radius * 2) {
+    for (x = radius; x < ssd1331_data_p->_width - 1; x += radius * 2) {
-        for (y = radius; y < GFX_height() - 1; y += radius * 2) {
+        for (y = radius; y < ssd1331_data_p->_height - 1; y += radius * 2) {
-            GFX_fillCircle(x, y, radius, color);
+            SSD1331_Fill_Circle(x, y, radius, color);
+        }
+    }
+}
 void SSD1331_Test_DrawTria(void) {
     int color = 0xF800;
     int t;
-    int w = GFX_width() / 2;
+    int w = ssd1331_data_p->_width / 2;
-    int x = GFX_height();
+    int x = ssd1331_data_p->_height;
     int y = 0;
-    int z = GFX_width();
+    int z = ssd1331_data_p->_width;
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
     for (t = 0; t <= 15; t += 1) {
-        GFX_drawTriangle(w, y, y, x, z, x, color);
+        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;
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
     for (t = 0; t <= 4; t += 1) {
         x = 0;
         y = 0;
-        w = GFX_width();
+        w = ssd1331_data_p->_width;
-        h = GFX_height();
+        h = ssd1331_data_p->_height;
         for (i = 0; i <= 24; i += 1) {
-            GFX_drawRoundRect(x, y, w, h, 5, color);
+            SSD1331_Draw_Round_Rect(x, y, w, h, 5, color);
             x += 2;
             y += 3;
             w -= 4;
             h -= 6;
             color += 1100;
+    }
+}
 void SSD1331_Test_MediaButtons(void) {
     // play
-    GFX_clearScreen();
+    SSD1331_Clear_Display();
-    GFX_fillRoundRect(25, 10, 78, 60, 8, SSD1331_WHITE);
+    SSD1331_Fill_Round_Rect(25, 10, 78, 60, 8, SSD1331_WHITE);
-    GFX_fillTriangle(42, 20, 42, 60, 90, 40, SSD1331_RED);
+    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_RED);
     Delay10KTCYx(100);
     // pause
-    GFX_fillRoundRect(25, 90, 78, 60, 8, SSD1331_WHITE);
+    SSD1331_Fill_Round_Rect(25, 90, 78, 60, 8, SSD1331_WHITE);
-    GFX_fillRoundRect(39, 98, 20, 45, 5, SSD1331_GREEN);
+    SSD1331_Fill_Round_Rect(39, 98, 20, 45, 5, SSD1331_GREEN);
-    GFX_fillRoundRect(69, 98, 20, 45, 5, SSD1331_GREEN);
+    SSD1331_Fill_Round_Rect(69, 98, 20, 45, 5, SSD1331_GREEN);
     Delay10KTCYx(100);
     // play color
-    GFX_fillTriangle(42, 20, 42, 60, 90, 40, SSD1331_BLUE);
+    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_BLUE);
     Delay10KTCYx(100);
     // pause color
-    GFX_fillRoundRect(39, 98, 20, 45, 5, SSD1331_RED);
+    SSD1331_Fill_Round_Rect(39, 98, 20, 45, 5, SSD1331_RED);
-    GFX_fillRoundRect(69, 98, 20, 45, 5, SSD1331_RED);
+    SSD1331_Fill_Round_Rect(69, 98, 20, 45, 5, SSD1331_RED);
     // play color
-    GFX_fillTriangle(42, 20, 42, 60, 90, 40, SSD1331_GREEN);
+    SSD1331_Fill_Triangle(42, 20, 42, 60, 90, 40, SSD1331_GREEN);
+}
 void SSD1331_Test_Pattern(void) {
     unsigned char buffer[2];
     unsigned int i, j;
                 buffer[1] = (SSD1331_YELLOW);
             } else {
                 buffer[0] = (SSD1331_BLACK >> 8);
                 buffer[1] = (SSD1331_BLACK);
+            }
-            LATBbits.LATB5 = 1; // D/C high (data)
+            SPI_DC_SELECT_LAT = 1; // D/C high (data)
             SPI2_Write(buffer, 2);
+        }
+    }
+}

Subversion Repositories Code-Repo

(root)/PIC Stuff/PIC_27J13/oled_ssd1331.c @ 129 – Rev 127 → 129