WebSVN – DashDisplay – Diff – /trunk/SSD1306_lib/SSD1306.c

 /*********************************************************************
-This is a library for our Monochrome OLEDs based on SSD1306 drivers
+ This is a library for our Monochrome OLEDs based on SSD1306 drivers
-  Pick one up today in the adafruit shop!
+ Pick one up today in the adafruit shop!
-  ------> http://www.adafruit.com/category/63_98
+ ------> http://www.adafruit.com/category/63_98
-These displays use SPI to communicate, 4 or 5 pins are required to
+ These displays use SPI to communicate, 4 or 5 pins are required to
-interface
+ interface
-Adafruit invests time and resources providing this open source code,
+ Adafruit invests time and resources providing this open source code,
-please support Adafruit and open-source hardware by purchasing
+ please support Adafruit and open-source hardware by purchasing
-products from Adafruit!
+ products from Adafruit!
-Written by Limor Fried/Ladyada  for Adafruit Industries.
+ Written by Limor Fried/Ladyada  for Adafruit Industries.
-BSD license, check license.txt for more information
+ BSD license, check license.txt for more information
-All text above, and the splash screen below must be included in any redistribution
+ All text above, and the splash screen below must be included in any redistribution
-This code is taken from the ADAfruit library - it is used for playing with an OLED screen
+ This code is taken from the ADAfruit library - it is used for playing with an OLED screen
-*********************************************************************/
+ *********************************************************************/
 #include <stdint.h>
 #include <string.h>
 #include "stm32f1xx_hal.h"
 #include "SSD1306.h"
 #define swap(x,y) { typeof(x)t = x; x=y; y=t; }
 #define abs(x)      ((x)>0?(x):-(x))
 static uint8_t rotation = 0;
-const uint16_t WIDTH  = SSD1306_LCDWIDTH;
+const uint16_t WIDTH = SSD1306_LCDWIDTH;
 const uint16_t HEIGHT = SSD1306_LCDHEIGHT;
 extern SPI_HandleTypeDef hspi1;
 // the memory buffer for the LCD
 // pointer to the current display - affects buffer used and also chipselect
 static int cd = 0;
-uint8_t display_buffer[MAX_PHYS_DISPLAYS][SSD1306_LCDHEIGHT * SSD1306_LCDWIDTH / 8];
+uint8_t display_buffer[MAX_PHYS_DISPLAYS][SSD1306_LCDHEIGHT * SSD1306_LCDWIDTH
+                / 8];
-inline uint8_t * display_address(void)
+inline uint8_t * display_address(void) {
-{
-        return (uint8_t *)(&display_buffer[cd]);
+        return (uint8_t *) (&display_buffer[cd]);
+}
-inline uint8_t getRotation(void)
+inline uint8_t getRotation(void) {
-{
         return rotation;
+}
-inline int16_t width(void)
+inline int16_t width(void) {
-{
-        switch (rotation)
+        switch (rotation) {
-        {
         case 0:
                 return WIDTH;
                 break;
         case 1:
                 return WIDTH;
                 return HEIGHT;
                 break;
         case 3:
                 return -WIDTH;
                 break;
-    }
+        }
-  return 0;
+        return 0;
+}
-inline int16_t height(void)
+inline int16_t height(void) {
-{
-        switch (rotation)
+        switch (rotation) {
-        {
         case 0:
                 return HEIGHT;
                 break;
         case 1:
                 return HEIGHT;
                 return WIDTH;
                 break;
         case 3:
                 return -HEIGHT;
                 break;
-    }
+        }
         return 0;
+}
-inline void fastSPIwrite(uint8_t d)
+inline void fastSPIwrite(uint8_t d) {
-{
-  uint8_t buffer[1];
+        uint8_t buffer[1];
-  buffer[0] = d;
+        buffer[0] = d;
 // todo chipselect based on 'cd' buffer choice
-  HAL_SPI_Transmit(&hspi1, buffer, 1, 2);
+        HAL_SPI_Transmit(&hspi1, buffer, 1, 2);
+}
 // the most basic function, set a single pixel
 inline void drawPixel(int16_t x, int16_t y, uint16_t color) {
-  if ((x < 0) || (x >= width()) || (y < 0) || (y >= height()))
+        if ((x < 0) || (x >= width()) || (y < 0) || (y >= height()))
-    return;
+                return;
-  // check rotation, move pixel around if necessary
+        // check rotation, move pixel around if necessary
-  switch (getRotation()) {
+        switch (getRotation()) {
-  case 1:
+        case 1:
-    swap(x, y);
+                swap(x, y)
+                ;
-    x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-    break;
+                break;
-  case 2:
+        case 2:
-    x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-    y = HEIGHT - y - 1;
+                y = HEIGHT - y - 1;
-    break;
+                break;
-  case 3:
+        case 3:
-    swap(x, y);
+                swap(x, y)
-    y = HEIGHT - y - 1;
-    break;
-  }
-  // x is which column
-  switch(color)
-  {
+                ;
-  case BLACK:
-    display_buffer[cd][x+ (y/8)*SSD1306_LCDWIDTH] &= ~(1 << (y&7));
-    break;
-  default:
-  case  WHITE:
+                y = HEIGHT - y - 1;
-    display_buffer[cd][x+ (y/8)*SSD1306_LCDWIDTH] |= (1 << (y&7));
-    break;
-  case  INVERT:
-        display_buffer[cd][x+ (y/8)*SSD1306_LCDWIDTH] ^= (1 << (y&7));
-        break;
+                break;
-  }
-}
+        }
+        // x is which column
+        switch (color) {
+        case BLACK:
+                display_buffer[cd][x + (y / 8) * SSD1306_LCDWIDTH] &= ~(1 << (y & 7));
+                break;
+        default:
+        case WHITE:
+                display_buffer[cd][x + (y / 8) * SSD1306_LCDWIDTH] |= (1 << (y & 7));
+                break;
+        case INVERT:
+                display_buffer[cd][x + (y / 8) * SSD1306_LCDWIDTH] ^= (1 << (y & 7));
+                break;
+        }
+}
 void ssd1306_begin(uint8_t vccstate, uint8_t i2caddr) {
+        HAL_GPIO_WritePin(SPI_RESET_GPIO_Port, SPI_RESET_Pin, GPIO_PIN_SET);
+        // VDD (3.3V) goes high at start, lets just chill for a ms
+        HAL_Delay(1);
+        // bring reset low
+        HAL_GPIO_WritePin(SPI_RESET_GPIO_Port, SPI_RESET_Pin, GPIO_PIN_RESET);
+        // wait 10ms
+        HAL_Delay(10);
+        // bring out of reset
-   HAL_GPIO_WritePin(SPI_RESET_GPIO_Port,SPI_RESET_Pin,GPIO_PIN_SET);
+        HAL_GPIO_WritePin(SPI_RESET_GPIO_Port, SPI_RESET_Pin, GPIO_PIN_SET);
+        // turn on VCC (9V?)
+        for (cd = 0; cd < 2; cd++) {
+#if defined SSD1306_128_32
+                // Init sequence for 128x32 OLED module
+                ssd1306_command(SSD1306_DISPLAYOFF);// 0xAE
+                ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);// 0xD5
+                ssd1306_command(0x80);// the suggested ratio 0x80
+                ssd1306_command(SSD1306_SETMULTIPLEX);// 0xA8
+                ssd1306_command(0x1F);
+                ssd1306_command(SSD1306_SETDISPLAYOFFSET);// 0xD3
+                ssd1306_command(0x0);// no offset
+                ssd1306_command(SSD1306_SETSTARTLINE | 0x0);// line #0
+                ssd1306_command(SSD1306_CHARGEPUMP);// 0x8D
+                if (vccstate == SSD1306_EXTERNALVCC)
+                {       ssd1306_command(0x10);}
+                else
+                {       ssd1306_command(0x14);}
+                ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
+                ssd1306_command(0x00);// 0x0 act like ks0108
+                ssd1306_command(SSD1306_SEGREMAP | 0x1);
+                ssd1306_command(SSD1306_COMSCANDEC);
+                ssd1306_command(SSD1306_SETCOMPINS);// 0xDA
+                ssd1306_command(0x02);
+                ssd1306_command(SSD1306_SETCONTRAST);// 0x81
+                ssd1306_command(0x8F);
+                ssd1306_command(SSD1306_SETPRECHARGE);// 0xd9
+                if (vccstate == SSD1306_EXTERNALVCC)
+                {       ssd1306_command(0x22);}
+                else
+                {       ssd1306_command(0xF1);}
+                ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
+                ssd1306_command(0x40);
+                ssd1306_command(SSD1306_DISPLAYALLON_RESUME);// 0xA4
+                ssd1306_command(SSD1306_NORMALDISPLAY);// 0xA6
+#endif
+#if defined SSD1306_128_64
+                // Init sequence for 128x64 OLED module
+                ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
+                ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
+                ssd1306_command(0x80);                       // the suggested ratio 0x80
+                ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
+                ssd1306_command(0x3F);
+                ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
+                ssd1306_command(0x0);                                   // no offset
+                ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
+                ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
+                if (vccstate == SSD1306_EXTERNALVCC) {
+                        ssd1306_command(0x10);
+                } else {
+                        ssd1306_command(0x14);
+                }
+                ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
+                ssd1306_command(0x00);                            // 0x0 act like ks0108
+                ssd1306_command(SSD1306_SEGREMAP | 0x1);
+                ssd1306_command(SSD1306_COMSCANDEC);
+                ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
+                ssd1306_command(0x12);
+                ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
+                if (vccstate == SSD1306_EXTERNALVCC) {
+                        ssd1306_command(0x9F);
+                } else {
+                        ssd1306_command(0xCF);
+                }
+                ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
+                if (vccstate == SSD1306_EXTERNALVCC) {
+                        ssd1306_command(0x22);
+                } else {
+                        ssd1306_command(0xF1);
+                }
+                ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
+                ssd1306_command(0x40);
+                ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
+                ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
+#endif
-  // VDD (3.3V) goes high at start, lets just chill for a ms
-  HAL_Delay(1);
-  // bring reset low
-  HAL_GPIO_WritePin(SPI_RESET_GPIO_Port,SPI_RESET_Pin,GPIO_PIN_RESET);
-  // wait 10ms
-  HAL_Delay(10);
-  // bring out of reset
-  HAL_GPIO_WritePin(SPI_RESET_GPIO_Port,SPI_RESET_Pin,GPIO_PIN_SET);
-  // turn on VCC (9V?)
-  for(cd = 0; cd<2 ; cd++)
-  {
-   #if defined SSD1306_128_32
-    // Init sequence for 128x32 OLED module
-    ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
-    ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
-    ssd1306_command(0x80);                                  // the suggested ratio 0x80
-    ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
-    ssd1306_command(0x1F);
-    ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
-    ssd1306_command(0x0);                                   // no offset
-    ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
-    ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
-    if (vccstate == SSD1306_EXTERNALVCC)
-      { ssd1306_command(0x10); }
-    else
-      { ssd1306_command(0x14); }
-    ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
-    ssd1306_command(0x00);                                  // 0x0 act like ks0108
-        ssd1306_command(SSD1306_SEGREMAP | 0x1);
-    ssd1306_command(SSD1306_COMSCANDEC);
-    ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
-    ssd1306_command(0x02);
-    ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
-    ssd1306_command(0x8F);
-    ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
-    if (vccstate == SSD1306_EXTERNALVCC)
-      { ssd1306_command(0x22); }
-    else
-      { ssd1306_command(0xF1); }
-    ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
-    ssd1306_command(0x40);
-    ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
-    ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
-  #endif
-  #if defined SSD1306_128_64
-    // Init sequence for 128x64 OLED module
-    ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
-    ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
-    ssd1306_command(0x80);                                  // the suggested ratio 0x80
-    ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
-    ssd1306_command(0x3F);
-    ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
-    ssd1306_command(0x0);                                   // no offset
-    ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
-    ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
-    if (vccstate == SSD1306_EXTERNALVCC)
-      { ssd1306_command(0x10); }
-    else
-      { ssd1306_command(0x14); }
-    ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
-    ssd1306_command(0x00);                                  // 0x0 act like ks0108
-    ssd1306_command(SSD1306_SEGREMAP | 0x1);
-    ssd1306_command(SSD1306_COMSCANDEC);
-    ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
-    ssd1306_command(0x12);
-    ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
-    if (vccstate == SSD1306_EXTERNALVCC)
-      { ssd1306_command(0x9F); }
-    else
-      { ssd1306_command(0xCF); }
-    ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
-    if (vccstate == SSD1306_EXTERNALVCC)
-      { ssd1306_command(0x22); }
-    else
-      { ssd1306_command(0xF1); }
-    ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
-    ssd1306_command(0x40);
-    ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
-    ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
-  #endif
-  ssd1306_command(SSD1306_DISPLAYON);//--turn on oled panel
+                ssd1306_command(SSD1306_DISPLAYON);               //--turn on oled panel
-  }
+        }
+}
 void invertDisplay(uint8_t i) {
-  if (i) {
+        if (i) {
-    ssd1306_command(SSD1306_INVERTDISPLAY);
+                ssd1306_command(SSD1306_INVERTDISPLAY);
-  } else {
+        } else {
-    ssd1306_command(SSD1306_NORMALDISPLAY);
+                ssd1306_command(SSD1306_NORMALDISPLAY);
-  }
+        }
+}
-void ssd1306_command(uint8_t c)
+void ssd1306_command(uint8_t c) {
-{
-        HAL_GPIO_WritePin(SPI1CD_GPIO_Port,SPI1CD_Pin,GPIO_PIN_RESET);
+        HAL_GPIO_WritePin(SPI1CD_GPIO_Port, SPI1CD_Pin, GPIO_PIN_RESET);
-    fastSPIwrite(c);
+        fastSPIwrite(c);
+}
 // startscrollright
 // Activate a right handed scroll for rows start through stop
 // Hint, the display is 16 rows tall. To scroll the whole display, run:
 // display.scrollright(0x00, 0x0F)
-void startscrollright(uint8_t start, uint8_t stop){
+void startscrollright(uint8_t start, uint8_t stop) {
         ssd1306_command(SSD1306_RIGHT_HORIZONTAL_SCROLL);
         ssd1306_command(0X00);
         ssd1306_command(start);
         ssd1306_command(0X00);
         ssd1306_command(stop);
 // startscrollleft
 // Activate a right handed scroll for rows start through stop
 // Hint, the display is 16 rows tall. To scroll the whole display, run:
 // display.scrollright(0x00, 0x0F)
-void startscrollleft(uint8_t start, uint8_t stop){
+void startscrollleft(uint8_t start, uint8_t stop) {
         ssd1306_command(SSD1306_LEFT_HORIZONTAL_SCROLL);
         ssd1306_command(0X00);
         ssd1306_command(start);
         ssd1306_command(0X00);
         ssd1306_command(stop);
 // startscrolldiagright
 // Activate a diagonal scroll for rows start through stop
 // Hint, the display is 16 rows tall. To scroll the whole display, run:
 // display.scrollright(0x00, 0x0F)
-void startscrolldiagright(uint8_t start, uint8_t stop){
+void startscrolldiagright(uint8_t start, uint8_t stop) {
         ssd1306_command(SSD1306_SET_VERTICAL_SCROLL_AREA);
         ssd1306_command(0X00);
         ssd1306_command(SSD1306_LCDHEIGHT);
         ssd1306_command(SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL);
         ssd1306_command(0X00);
         ssd1306_command(start);
 // startscrolldiagleft
 // Activate a diagonal scroll for rows start through stop
 // Hint, the display is 16 rows tall. To scroll the whole display, run:
 // display.scrollright(0x00, 0x0F)
-void startscrolldiagleft(uint8_t start, uint8_t stop){
+void startscrolldiagleft(uint8_t start, uint8_t stop) {
         ssd1306_command(SSD1306_SET_VERTICAL_SCROLL_AREA);
         ssd1306_command(0X00);
         ssd1306_command(SSD1306_LCDHEIGHT);
         ssd1306_command(SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL);
         ssd1306_command(0X00);
         ssd1306_command(start);
         ssd1306_command(stop);
         ssd1306_command(0X01);
         ssd1306_command(SSD1306_ACTIVATE_SCROLL);
+}
-void stopscroll(void){
+void stopscroll(void) {
         ssd1306_command(SSD1306_DEACTIVATE_SCROLL);
+}
 // Dim the display
 // dim = true: display is dimmed
 // dim = false: display is normal
-void dim(boolean dim) {
+void dim(uint8_t dim) {
-  uint8_t contrast;
+        uint8_t contrast;
-  if (dim) {
+        if (dim) {
-    contrast = 0; // Dimmed display
+                contrast = 0; // Dimmed display
-  } else {
+        } else {
-      contrast = 0xCF;
+                contrast = 0xCF;
-  }
+        }
-  // the range of contrast to too small to be really useful
+        // the range of contrast to too small to be really useful
-  // it is useful to dim the display
+        // it is useful to dim the display
-  ssd1306_command(SSD1306_SETCONTRAST);
+        ssd1306_command(SSD1306_SETCONTRAST);
-  ssd1306_command(contrast);
+        ssd1306_command(contrast);
+}
 void display(void) {
-  ssd1306_command(SSD1306_COLUMNADDR);
+        ssd1306_command(SSD1306_COLUMNADDR);
-  ssd1306_command(0);   // Column start address (0 = reset)
+        ssd1306_command(0);   // Column start address (0 = reset)
-  ssd1306_command(131); // Column end address (127 = reset)
+        ssd1306_command(131); // Column end address (127 = reset)
-  ssd1306_command(SSD1306_PAGEADDR);
+        ssd1306_command(SSD1306_PAGEADDR);
-  ssd1306_command(0); // Page start address (0 = reset)
+        ssd1306_command(0); // Page start address (0 = reset)
-  ssd1306_command((SSD1306_LCDHEIGHT == 64) ? 7 : 3); // Page end address
+        ssd1306_command((SSD1306_LCDHEIGHT == 64) ? 7 : 3); // Page end address
-  int row;
+        int row;
-  int col=2;
+        int col = 2;
-  for(row=0;row<SSD1306_LCDHEIGHT/8;row++)
+        for (row = 0; row < SSD1306_LCDHEIGHT / 8; row++) {
-  {
-     // set the cursor to
+                // set the cursor to
-          ssd1306_command(0xB0 + row);//set page address
+                ssd1306_command(0xB0 + row); //set page address
-          ssd1306_command(col & 0xf);//set lower column address
+                ssd1306_command(col & 0xf); //set lower column address
-          ssd1306_command(0x10 | (col >> 4));//set higher column address
+                ssd1306_command(0x10 | (col >> 4)); //set higher column address
-      HAL_GPIO_WritePin(SPI1CD_GPIO_Port,SPI1CD_Pin,GPIO_PIN_SET);
+                HAL_GPIO_WritePin(SPI1CD_GPIO_Port, SPI1CD_Pin, GPIO_PIN_SET);
+                HAL_SPI_Transmit(&hspi1,
-      HAL_SPI_Transmit(&hspi1, (uint8_t *)(&display_buffer[cd])+row*SSD1306_LCDWIDTH, SSD1306_LCDWIDTH, 100);
+                                (uint8_t *) (&display_buffer[cd]) + row * SSD1306_LCDWIDTH,
+                                SSD1306_LCDWIDTH, 100);
-      }
+        }
+}
 // clear everything
 void clearDisplay(void) {
-  memset(&display_buffer[cd], 0, (SSD1306_LCDWIDTH*SSD1306_LCDHEIGHT/8));
+        memset(&display_buffer[cd], 0, (SSD1306_LCDWIDTH * SSD1306_LCDHEIGHT / 8));
+}
 void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) {
-  boolean bSwap = false;
+        boolean bSwap = false;
-  switch(rotation) {
+        switch (rotation) {
-    case 0:
+        case 0:
-      // 0 degree rotation, do nothing
+                // 0 degree rotation, do nothing
-      break;
+                break;
-    case 1:
+        case 1:
-      // 90 degree rotation, swap x & y for rotation, then invert x
+                // 90 degree rotation, swap x & y for rotation, then invert x
-      bSwap = true;
+                bSwap = true;
-      swap(x, y);
+                swap(x, y)
+                ;
-      x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-      break;
+                break;
-    case 2:
+        case 2:
-      // 180 degree rotation, invert x and y - then shift y around for height.
+                // 180 degree rotation, invert x and y - then shift y around for height.
-      x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-      y = HEIGHT - y - 1;
+                y = HEIGHT - y - 1;
-      x -= (w-1);
+                x -= (w - 1);
-      break;
+                break;
-    case 3:
+        case 3:
-      // 270 degree rotation, swap x & y for rotation, then invert y  and adjust y for w (not to become h)
+                // 270 degree rotation, swap x & y for rotation, then invert y  and adjust y for w (not to become h)
-      bSwap = true;
+                bSwap = true;
-      swap(x, y);
+                swap(x, y)
+                ;
-      y = HEIGHT - y - 1;
+                y = HEIGHT - y - 1;
-      y -= (w-1);
+                y -= (w - 1);
-      break;
+                break;
-  }
+        }
-  if(bSwap) {
+        if (bSwap) {
-    drawFastVLineInternal(x, y, w, color);
+                drawFastVLineInternal(x, y, w, color);
-  } else {
+        } else {
-    drawFastHLineInternal(x, y, w, color);
+                drawFastHLineInternal(x, y, w, color);
-  }
+        }
+}
 void drawFastHLineInternal(int16_t x, int16_t y, int16_t w, uint16_t color) {
-  // Do bounds/limit checks
+        // Do bounds/limit checks
-  if(y < 0 || y >= HEIGHT) { return; }
+        if (y < 0 || y >= HEIGHT) {
+                return;
+        }
+        // make sure we don't try to draw below 0
+        if (x < 0) {
+                w += x;
+                x = 0;
+        }
-  // make sure we don't try to draw below 0
-  if(x < 0) {
-    w += x;
-    x = 0;
-  }
-  // make sure we don't go off the edge of the display
+        // make sure we don't go off the edge of the display
-  if( (x + w) > WIDTH) {
+        if ((x + w) > WIDTH) {
-    w = (HEIGHT- x);
+                w = (HEIGHT - x);
-  }
+        }
-  // if our width is now negative, punt
+        // if our width is now negative, punt
-  if(w <= 0) { return; }
+        if (w <= 0) {
+                return;
+        }
-  // set up the pointer for  movement through the buffer
+        // set up the pointer for  movement through the buffer
-  register uint8_t *pBuf = display_address();
+        register uint8_t *pBuf = display_address();
-  // adjust the buffer pointer for the current row
+        // adjust the buffer pointer for the current row
-  pBuf += ((y/8) * SSD1306_LCDWIDTH);
+        pBuf += ((y / 8) * SSD1306_LCDWIDTH);
-  // and offset x columns in
+        // and offset x columns in
-  pBuf += x;
+        pBuf += x;
-  register uint8_t mask = 1 << (y&7);
+        register uint8_t mask = 1 << (y & 7);
-  if(color == WHITE) {
+        if (color == WHITE) {
+                while (w--) {
-    while(w--) { *pBuf++ |= mask; }
+                        *pBuf++ |= mask;
+                }
-  } else {
+        } else {
-    mask = ~mask;
+                mask = ~mask;
+                while (w--) {
-    while(w--) { *pBuf++ &= mask; }
+                        *pBuf++ &= mask;
-  }
+                }
+        }
+}
 void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
-  boolean bSwap = false;
+        boolean bSwap = false;
-  switch(rotation) {
+        switch (rotation) {
-    case 0:
+        case 0:
-      break;
+                break;
-    case 1:
+        case 1:
-      // 90 degree rotation, swap x & y for rotation, then invert x and adjust x for h (now to become w)
+                // 90 degree rotation, swap x & y for rotation, then invert x and adjust x for h (now to become w)
-      bSwap = true;
+                bSwap = true;
-      swap(x, y);
+                swap(x, y)
+                ;
-      x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-      x -= (h-1);
+                x -= (h - 1);
-      break;
+                break;
-    case 2:
+        case 2:
-      // 180 degree rotation, invert x and y - then shift y around for height.
+                // 180 degree rotation, invert x and y - then shift y around for height.
-      x = WIDTH - x - 1;
+                x = WIDTH - x - 1;
-      y = HEIGHT - y - 1;
+                y = HEIGHT - y - 1;
-      y -= (h-1);
+                y -= (h - 1);
-      break;
+                break;
-    case 3:
+        case 3:
-      // 270 degree rotation, swap x & y for rotation, then invert y
+                // 270 degree rotation, swap x & y for rotation, then invert y
-      bSwap = true;
+                bSwap = true;
-      swap(x, y);
+                swap(x, y)
-      y = HEIGHT - y - 1;
-      break;
-  }
+                ;
-  if(bSwap) {
+                y = HEIGHT - y - 1;
-    drawFastHLineInternal(x, y, h, color);
-  } else {
+                break;
-    drawFastVLineInternal(x, y, h, color);
-  }
-}
+        }
+        if (bSwap) {
+                drawFastHLineInternal(x, y, h, color);
+        } else {
+                drawFastVLineInternal(x, y, h, color);
+        }
+}
 void drawFastVLineInternal(int16_t x, int16_t __y, int16_t __h, uint16_t color) {
-  // do nothing if we're off the left or right side of the screen
+        // do nothing if we're off the left or right side of the screen
-  if(x < 0 || x >= WIDTH) { return; }
+        if (x < 0 || x >= WIDTH) {
+                return;
+        }
-  // make sure we don't try to draw below 0
+        // make sure we don't try to draw below 0
-  if(__y < 0) {
+        if (__y < 0) {
-    // __y is negative, this will subtract enough from __h to account for __y being 0
+                // __y is negative, this will subtract enough from __h to account for __y being 0
-    __h += __y;
+                __h += __y;
-    __y = 0;
+                __y = 0;
-  }
+        }
-  // make sure we don't go past the height of the display
+        // make sure we don't go past the height of the display
-  if( (__y + __h) > HEIGHT) {
+        if ((__y + __h) > HEIGHT) {
-    __h = (HEIGHT - __y);
+                __h = (HEIGHT - __y);
-  }
-  // if our height is now negative, punt
-  if(__h <= 0) {
-    return;
-  }
-  // this display doesn't need ints for coordinates, use local byte registers for faster juggling
-  register uint8_t y = __y;
-  register uint8_t h = __h;
-  // set up the pointer for fast movement through the buffer
-  register uint8_t *pBuf = display_address();
-  // adjust the buffer pointer for the current row
-  pBuf += ((y/8) * SSD1306_LCDWIDTH);
-  // and offset x columns in
-  pBuf += x;
-  // do the first partial byte, if necessary - this requires some masking
-  register uint8_t mod = (y&7);
-  if(mod) {
-    // mask off the high n bits we want to set
-    mod = 8-mod;
-    // note - lookup table results in a nearly 10% performance improvement in fill* functions
-    // register uint8_t mask = ~(0xFF >> (mod));
-    static uint8_t premask[8] = {0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE };
-    register uint8_t mask = premask[mod];
-    // adjust the mask if we're not going to reach the end of this byte
-    if( h < mod) {
-      mask &= (0XFF >> (mod-h));
-    }
-    if(color == WHITE) {
-      *pBuf |= mask;
-    } else {
-      *pBuf &= ~mask;
-    }
-    // fast exit if we're done here!
-    if(h<mod) { return; }
-    h -= mod;
-    pBuf += SSD1306_LCDWIDTH;
-  }
-  // write solid bytes while we can - effectively doing 8 rows at a time
-  if(h >= 8) {
-    // store a local value to work with
-    register uint8_t val = (color == WHITE) ? 255 : 0;
-    do  {
-      // write our value in
-      *pBuf = val;
-      // adjust the buffer forward 8 rows worth of data
-      pBuf += SSD1306_LCDWIDTH;
-      // adjust h & y (there's got to be a faster way for me to do this, but this should still help a fair bit for now)
-      h -= 8;
-    } while(h >= 8);
-  }
-  // now do the final partial byte, if necessary
-  if(h) {
-    mod = h & 7;
-    // this time we want to mask the low bits of the byte, vs the high bits we did above
-    // register uint8_t mask = (1 << mod) - 1;
-    // note - lookup table results in a nearly 10% performance improvement in fill* functions
-    static uint8_t postmask[8] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F };
-    register uint8_t mask = postmask[mod];
-    if(color == WHITE) {
-      *pBuf |= mask;
-    } else {
-      *pBuf &= ~mask;
-    }
-  }
-}
+        }
+        // if our height is now negative, punt
+        if (__h <= 0) {
+                return;
+        }
+        // this display doesn't need ints for coordinates, use local byte registers for faster juggling
+        register uint8_t y = __y;
+        register uint8_t h = __h;
+        // set up the pointer for fast movement through the buffer
+        register uint8_t *pBuf = display_address();
+        // adjust the buffer pointer for the current row
+        pBuf += ((y / 8) * SSD1306_LCDWIDTH);
+        // and offset x columns in
+        pBuf += x;
+        // do the first partial byte, if necessary - this requires some masking
+        register uint8_t mod = (y & 7);
+        if (mod) {
+                // mask off the high n bits we want to set
+                mod = 8 - mod;
+                // note - lookup table results in a nearly 10% performance improvement in fill* functions
+                // register uint8_t mask = ~(0xFF >> (mod));
+                static uint8_t premask[8] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC,
+xFE };
+                register uint8_t mask = premask[mod];
+                // adjust the mask if we're not going to reach the end of this byte
+                if (h < mod) {
+                        mask &= (0XFF >> (mod - h));
+                }
+                if (color == WHITE) {
+                        *pBuf |= mask;
+                } else {
+                        *pBuf &= ~mask;
+                }
-/* using Bresenham draw algorithm */
+                // fast exit if we're done here!
+                if (h < mod) {
+                        return;
+                }
+                h -= mod;
-void drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
+                pBuf += SSD1306_LCDWIDTH;
+        }
-{
+        // write solid bytes while we can - effectively doing 8 rows at a time
-        int16_t x,
+        if (h >= 8) {
+                // store a local value to work with
+                register uint8_t val = (color == WHITE) ? 255 : 0;
-                        y,
+                do {
+                        // write our value in
-                        dx,             //deltas
+                        *pBuf = val;
+                        // adjust the buffer forward 8 rows worth of data
+                        pBuf += SSD1306_LCDWIDTH;
+                        // adjust h & y (there's got to be a faster way for me to do this, but this should still help a fair bit for now)
+                        h -= 8;
-            dy,
+                } while (h >= 8);
+        }
-            dx2,        //scaled deltas
+        // now do the final partial byte, if necessary
+        if (h) {
-            dy2,
+                mod = h & 7;
-            ix,         //increase rate on the x axis
+                // this time we want to mask the low bits of the byte, vs the high bits we did above
-            iy,         //increase rate on the y axis
+                // register uint8_t mask = (1 << mod) - 1;
+                // note - lookup table results in a nearly 10% performance improvement in fill* functions
+                static uint8_t postmask[8] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F,
+x7F };
-            err;        //the error term
+                register uint8_t mask = postmask[mod];
-    uint16_t i;         //looping variable
+                if (color == WHITE) {
+                        *pBuf |= mask;
+                } else {
+                        *pBuf &= ~mask;
+                }
+        }
+}
+/* using Bresenham draw algorithm */
+void drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color) {
+        int16_t x, y, dx,               //deltas
+                        dy, dx2,        //scaled deltas
+                        dy2, ix,                //increase rate on the x axis
+                        iy,             //increase rate on the y axis
+                        err;    //the error term
+        uint16_t i;             //looping variable
         // identify the first pixel
-        x=x1;
+        x = x1;
-        y=y1;
+        y = y1;
         // difference between starting and ending points
         dx = x2 - x1;
         dy = y2 - y1;
         // calculate direction of the vector and store in ix and iy
         if (dx >= 0)
                 ix = 1;
-        if (dx < 0)
+        if (dx < 0) {
-        {
                 ix = -1;
                 dx = abs(dx);
+        }
         if (dy >= 0)
                 iy = 1;
-        if (dy < 0)
+        if (dy < 0) {
-        {
                 iy = -1;
                 dy = abs(dy);
+        }
         // scale deltas and store in dx2 and dy2
         dy2 = dy * 2;
 // all  variables are set and it's time to enter the main loop.
         if (dx > dy)    // dx is the major axis
-        {
+                        {
                 // initialize the error term
                 err = dy2 - dx;
-                for (i = 0; i <= dx; i++)
+                for (i = 0; i <= dx; i++) {
-                {
                         drawPixel(x, y, color);
-                        if (err >= 0)
+                        if (err >= 0) {
-                        {
                                 err -= dx2;
                                 y += iy;
+                        }
                         err += dy2;
                         x += ix;
         else            // dy is the major axis
+        {
                 // initialize the error term
                 err = dx2 - dy;
-                for (i = 0; i <= dy; i++)
+                for (i = 0; i <= dy; i++) {
-                {
                         drawPixel(x, y, color);
-                        if (err >= 0)
+                        if (err >= 0) {
-                        {
                                 err -= dy2;
                                 x += ix;
+                        }
                         err += dx2;
                         y += iy;
+                }
+        }
+}
-void select_display(int i)
+void select_display(int i) {
-{
-        if(i<MAX_PHYS_DISPLAYS)
+        if (i < MAX_PHYS_DISPLAYS) {
-        {
                 cd = i;
+        }
+}

Subversion Repositories DashDisplay

(root)/trunk/SSD1306_lib/SSD1306.c – Rev 2 → 4