ugfx/driver/ST7735: code clean up

Author: redchenjs

components/ugfx/drivers/gdisp/ST7735/gdisp_lld_ST7735.c

@@ -9,7 +9,7 @@
 
 #if GFX_USE_GDISP
 
-#if defined(GDISP_SCREEN_HEIGHT) || defined(GDISP_SCREEN_HEIGHT)
+#if defined(GDISP_SCREEN_WIDTH) || defined(GDISP_SCREEN_HEIGHT)
     #if GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_DIRECT
         #warning "GDISP: This low level driver does not support setting a screen size. It is being ignored."
     #elif GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_MACRO
@@ -29,32 +29,30 @@
 /* Driver local definitions.                                                 */
 /*===========================================================================*/
 
-#ifndef GDISP_SCREEN_HEIGHT
-    #define GDISP_SCREEN_HEIGHT     ST7735_SCREEN_HEIGHT
-#endif
 #ifndef GDISP_SCREEN_WIDTH
     #define GDISP_SCREEN_WIDTH      ST7735_SCREEN_WIDTH
 #endif
+#ifndef GDISP_SCREEN_HEIGHT
+    #define GDISP_SCREEN_HEIGHT     ST7735_SCREEN_HEIGHT
+#endif
 #ifndef GDISP_INITIAL_CONTRAST
     #define GDISP_INITIAL_CONTRAST  100
 #endif
 #ifndef GDISP_INITIAL_BACKLIGHT
-    #define GDISP_INITIAL_BACKLIGHT 255
+    #define GDISP_INITIAL_BACKLIGHT 0
 #endif
 
-#define GDISP_FLG_NEEDFLUSH         (GDISP_FLG_DRIVER<<0)
+#define GDISP_FLG_NEEDFLUSH         (GDISP_FLG_DRIVER << 0)
 
 #include "ST7735.h"
 
 LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
-    g->priv = gfxAlloc(GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH * 2);
+    g->priv = gfxAlloc(GDISP_SCREEN_WIDTH*GDISP_SCREEN_HEIGHT*2);
     if (g->priv == NULL) {
         gfxHalt("GDISP ST7735: Failed to allocate private memory");
     }
 
-    for (int i=0; i<GDISP_SCREEN_HEIGHT*GDISP_SCREEN_WIDTH*2; i++) {
-        *((uint8_t *)g->priv + i) = 0x00;
-    }
+    memset(g->priv, 0x00, GDISP_SCREEN_WIDTH*GDISP_SCREEN_HEIGHT*2);
 
     // Initialise the board interface
     init_board(g);
@@ -105,7 +103,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
         write_data(g, 0x06);
     write_cmd(g, ST7735_INVON);     // 13: Invert display, no args, no delay
     write_cmd(g, ST7735_MADCTL);    // 14: Memory access control (directions), 1 arg:
-        write_data(g, 0x68);
+        write_data(g, 0xC8);
     write_cmd(g, ST7735_COLMOD);    // 15: Set color mode, 1 arg, no delay:
         write_data(g, 0x05);
     write_cmd(g, ST7735_GAMCTRP1);  // 16: Magical unicorn dust, 16 args, no delay:
@@ -145,25 +143,26 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
     write_cmd(g, ST7735_NORON);     // 18: Normal display on, no args, no delay
     write_cmd(g, ST7735_CASET);     // 19: Set column address, 4 args, no delay:
         write_data(g, 0x00);
-        write_data(g, 0x01);
+        write_data(g, 0x1A);
         write_data(g, 0x00);
-        write_data(g, 0xA0);
+        write_data(g, 0x69);
     write_cmd(g, ST7735_RASET);     // 20: Set row address, 4 args, no delay:
         write_data(g, 0x00);
-        write_data(g, 0x1A);
+        write_data(g, 0x01);
         write_data(g, 0x00);
-        write_data(g, 0x69);
+        write_data(g, 0xA0);
     write_cmd(g, ST7735_RAMWR);     // 21: Set write ram, N args, no delay:
-        write_buff(g, (uint8_t *)g->priv, GDISP_SCREEN_HEIGHT*GDISP_SCREEN_WIDTH*2);
+        write_buff(g, (uint8_t *)g->priv, GDISP_SCREEN_WIDTH*GDISP_SCREEN_HEIGHT*2);
     write_cmd(g, ST7735_DISPON);    // 22: Main screen turn on, no args, no delay
 
     /* Initialise the GDISP structure */
-    g->g.Width  = GDISP_SCREEN_HEIGHT;
-    g->g.Height = GDISP_SCREEN_WIDTH;
+    g->g.Width  = GDISP_SCREEN_WIDTH;
+    g->g.Height = GDISP_SCREEN_HEIGHT;
     g->g.Orientation = GDISP_ROTATE_0;
     g->g.Powermode = powerOn;
     g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
     g->g.Contrast  = GDISP_INITIAL_CONTRAST;
+
     return TRUE;
 }
 
@@ -178,120 +177,132 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 #endif
 
 #if GDISP_HARDWARE_STREAM_WRITE
-    static int16_t stream_write_x  = 0;
-    static int16_t stream_write_cx = 0;
-    static int16_t stream_write_y  = 0;
-    static int16_t stream_write_cy = 0;
+    static uint8_t write_x  = 0;
+    static uint8_t write_cx = 0;
+    static uint8_t write_y  = 0;
+    static uint8_t write_cy = 0;
     LLDSPEC void gdisp_lld_write_start(GDisplay *g) {
-        stream_write_x  = g->p.x;
-        stream_write_cx = g->p.cx;
-        stream_write_y  = g->p.y;
-        stream_write_cy = g->p.cy;
+        write_x  = g->p.x;
+        write_cx = g->p.cx;
+        write_y  = g->p.y;
+        write_cy = g->p.cy;
     }
     LLDSPEC void gdisp_lld_write_color(GDisplay *g) {
+        uint16_t pos = 0;
+        switch (g->g.Orientation) {
+            case GDISP_ROTATE_0:
+            default:
+                pos = write_y * g->g.Width + write_x;
+                break;
+            case GDISP_ROTATE_90:
+                pos = (g->g.Width - write_x - 1) * g->g.Height + write_y;
+                break;
+            case GDISP_ROTATE_180:
+                pos = (g->g.Height - write_y - 1) * g->g.Width + (g->g.Width - write_x - 1);
+                break;
+            case GDISP_ROTATE_270:
+                pos = write_x * g->g.Height + (g->g.Height - write_y - 1);
+                break;
+        }
         LLDCOLOR_TYPE c = gdispColor2Native(g->p.color);
-        *((uint8_t *)g->priv + (stream_write_x + stream_write_y * g->g.Width) * 2 + 0) = c >> 8;
-        *((uint8_t *)g->priv + (stream_write_x + stream_write_y * g->g.Width) * 2 + 1) = c;
-        stream_write_x++;
-        if (--stream_write_cx <= 0) {
-            stream_write_x  = g->p.x;
-            stream_write_cx = g->p.cx;
-            stream_write_y++;
-            if (--stream_write_cy <= 0) {
-                stream_write_y  = g->p.y;
-                stream_write_cy = g->p.cy;
+        *((uint8_t *)g->priv + pos * 2 + 0) = c >> 8;
+        *((uint8_t *)g->priv + pos * 2 + 1) = c;
+        write_x++;
+        if (--write_cx == 0) {
+            write_x  = g->p.x;
+            write_cx = g->p.cx;
+            write_y++;
+            if (--write_cy == 0) {
+                write_y  = g->p.y;
+                write_cy = g->p.cy;
             }
         }
     }
     LLDSPEC void gdisp_lld_write_stop(GDisplay *g) {
-        stream_write_x  = 0;
-        stream_write_cx = 0;
-        stream_write_y  = 0;
-        stream_write_cy = 0;
         g->flags |= GDISP_FLG_NEEDFLUSH;
     }
 #endif
 
 #if GDISP_HARDWARE_STREAM_READ
-    static int16_t stream_read_x  = 0;
-    static int16_t stream_read_cx = 0;
-    static int16_t stream_read_y  = 0;
-    static int16_t stream_read_cy = 0;
+    static uint8_t read_x  = 0;
+    static uint8_t read_cx = 0;
+    static uint8_t read_y  = 0;
+    static uint8_t read_cy = 0;
     LLDSPEC void gdisp_lld_read_start(GDisplay *g) {
-        stream_read_x  = g->p.x;
-        stream_read_cx = g->p.cx;
-        stream_read_y  = g->p.y;
-        stream_read_cy = g->p.cy;
+        read_x  = g->p.x;
+        read_cx = g->p.cx;
+        read_y  = g->p.y;
+        read_cy = g->p.cy;
     }
     LLDSPEC color_t gdisp_lld_read_color(GDisplay *g) {
-        LLDCOLOR_TYPE c = (*((uint8_t *)g->priv + (stream_read_x + stream_read_y * g->g.Width) * 2 + 0) << 8)
-                        | (*((uint8_t *)g->priv + (stream_read_x + stream_read_y * g->g.Width) * 2 + 1));
-        stream_read_x++;
-        if (--stream_read_cx <= 0) {
-            stream_read_x  = g->p.x;
-            stream_read_cx = g->p.cx;
-            stream_read_y++;
-            if (--stream_read_cy <= 0) {
-                stream_read_y  = g->p.y;
-                stream_read_cy = g->p.cy;
+        uint16_t pos = 0;
+        switch (g->g.Orientation) {
+            case GDISP_ROTATE_0:
+            default:
+                pos = read_y * g->g.Width + read_x;
+                break;
+            case GDISP_ROTATE_90:
+                pos = (g->g.Width - read_x - 1) * g->g.Height + read_y;
+                break;
+            case GDISP_ROTATE_180:
+                pos = (g->g.Height - read_y - 1) * g->g.Width + (g->g.Width - read_x - 1);
+                break;
+            case GDISP_ROTATE_270:
+                pos = read_x * g->g.Height + (g->g.Height - read_y - 1);
+                break;
+        }
+        LLDCOLOR_TYPE c = (*((uint8_t *)g->priv + pos * 2 + 0) << 8)
+                        | (*((uint8_t *)g->priv + pos * 2 + 1));
+        read_x++;
+        if (--read_cx == 0) {
+            read_x  = g->p.x;
+            read_cx = g->p.cx;
+            read_y++;
+            if (--read_cy == 0) {
+                read_y  = g->p.y;
+                read_cy = g->p.cy;
             }
         }
         return c;
     }
-    LLDSPEC void gdisp_lld_read_stop(GDisplay *g) {
-        stream_read_x  = 0;
-        stream_read_cx = 0;
-        stream_read_y  = 0;
-        stream_read_cy = 0;
-    }
+    LLDSPEC void gdisp_lld_read_stop(GDisplay *g) {}
 #endif
 
 #if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
 LLDSPEC void gdisp_lld_control(GDisplay *g) {
-    switch(g->p.x) {
-    case GDISP_CONTROL_POWER:
-        if (g->g.Powermode == (powermode_t)g->p.ptr)
-            return;
-        switch((powermode_t)g->p.ptr) {
-            case powerOff:
-            case powerSleep:
-            case powerDeepSleep:
-            case powerOn:
-            default:
-                return;
-        }
-        g->g.Powermode = (powermode_t)g->p.ptr;
-        return;
+    switch (g->p.x) {
     case GDISP_CONTROL_ORIENTATION:
-        if (g->g.Orientation == (orientation_t)g->p.ptr)
+        if (g->g.Orientation == (orientation_t)g->p.ptr) {
             return;
-        switch((orientation_t)g->p.ptr) {
+        }
+        switch ((orientation_t)g->p.ptr) {
             case GDISP_ROTATE_0:
-                g->g.Height = GDISP_SCREEN_HEIGHT;
                 g->g.Width  = GDISP_SCREEN_WIDTH;
+                g->g.Height = GDISP_SCREEN_HEIGHT;
                 break;
             case GDISP_ROTATE_90:
-                g->g.Height = GDISP_SCREEN_WIDTH;
                 g->g.Width  = GDISP_SCREEN_HEIGHT;
+                g->g.Height = GDISP_SCREEN_WIDTH;
                 break;
             case GDISP_ROTATE_180:
-                g->g.Height = GDISP_SCREEN_HEIGHT;
                 g->g.Width  = GDISP_SCREEN_WIDTH;
+                g->g.Height = GDISP_SCREEN_HEIGHT;
                 break;
             case GDISP_ROTATE_270:
-                g->g.Height = GDISP_SCREEN_WIDTH;
                 g->g.Width  = GDISP_SCREEN_HEIGHT;
+                g->g.Height = GDISP_SCREEN_WIDTH;
                 break;
             default:
                 return;
         }
         g->g.Orientation = (orientation_t)g->p.ptr;
         return;
     case GDISP_CONTROL_BACKLIGHT:
-        if ((unsigned)g->p.ptr > 255)
-            g->p.ptr = (void *)255;
-        g->g.Backlight = (unsigned)g->p.ptr;
-        set_backlight(g, g->g.Backlight);
+        if (g->g.Backlight == (uint32_t)g->p.ptr) {
+            return;
+        }
+        set_backlight(g, (uint32_t)g->p.ptr);
+        g->g.Backlight = (uint32_t)g->p.ptr;
         return;
     default:
         return;