therm Changeset - 857e86bbc10d · protofusion repositories

Changeset - 857e86bbc10d

Parent rev.

Child rev.

[Not reviewed]

cortex-f0

0 6 0

Ethan Zonca - 9 years ago 2015-11-28 14:29:25
ez@ethanzonca.com

Refactor ssd1306 functions

6 files changed with 100 insertions and 102 deletions:

display.c

flash.c

gpio.c

main.c

ssd1306.c

ssd1306.h

0 comments (0 inline, 0 general)

display.c

➞

Show inline comments

@@ @@ -27,504 +27,504 @@ static uint8_t sw_right_last = 0; @@
 static uint8_t trigger_drawsetpoint = 1;
 static int16_t last_temp = 21245;
 void display_process(therm_settings_t* set, therm_status_t* status)
+{
     uint8_t last_state = status->state;
     uint8_t temp_changed = status->temp != last_temp;
     last_temp = status->temp;
     uint8_t sw_btn = !HAL_GPIO_ReadPin(SW_BTN);
     uint8_t sw_up = !HAL_GPIO_ReadPin(SW_UP);
     uint8_t sw_down = !HAL_GPIO_ReadPin(SW_DOWN);
     uint8_t sw_left = !HAL_GPIO_ReadPin(SW_LEFT);
     uint8_t sw_right = !HAL_GPIO_ReadPin(SW_RIGHT);
     switch(status->state)
+    {
         // Idle state
         case STATE_IDLE:
+        {
             // Write text to OLED
             // [ therm :: idle ]
-            ssd1306_DrawString("therm :: idle ", 0, 40);
+            ssd1306_drawstring("therm :: idle ", 0, 40);
             status->pid_enabled = 0;
             if(temp_changed) {
                 char tempstr[6];
                 itoa_fp(status->temp, status->temp_frac, tempstr);
                 ssd1306_DrawString("Temp: ", 3, 40);
                 ssd1306_DrawString("    ", 3, 72);
                 ssd1306_DrawString(tempstr, 3, 72);
                 ssd1306_drawstring("Temp: ", 3, 40);
                 ssd1306_drawstring("    ", 3, 72);
                 ssd1306_drawstring(tempstr, 3, 72);
+            }
             ssd1306_drawlogo();
             switch(goto_mode) {
                 case 3:
+                {
-                    ssd1306_DrawString("-> loader   ", 1, 40);
+                    ssd1306_drawstring("-> loader   ", 1, 40);
                 } break;
                 case 2:
+                {
-                    ssd1306_DrawString("-> heat     ", 1, 40);
+                    ssd1306_drawstring("-> heat     ", 1, 40);
                 } break;
                 case 1:
+                {
-                    ssd1306_DrawString("-> setup    ", 1, 40);
+                    ssd1306_drawstring("-> setup    ", 1, 40);
                 } break;
                 case 0:
+                {
-                    ssd1306_DrawString("-> reset    ", 1, 40);
+                    ssd1306_drawstring("-> reset    ", 1, 40);
+                }
+            }
             // Button handler
             if(SW_BTN_PRESSED) {
                 switch(goto_mode) {
                     case 3:
+                    {
                         ssd1306_clearscreen();
                         ssd1306_DrawString("Bootloader Entered", 0, 0);
                         ssd1306_DrawString("Device won't boot", 2, 0);
                         ssd1306_DrawString("until reflashed!", 3, 0);
                         ssd1306_drawstring("Bootloader Entered", 0, 0);
                         ssd1306_drawstring("Device won't boot", 2, 0);
                         ssd1306_drawstring("until reflashed!", 3, 0);
                         bootloader_enter(); // Resets into bootloader
                         status->state = STATE_IDLE; // Just in case
                     } break;
                     case 2:
                         status->state = STATE_PREHEAT_BREW;
                         break;
                     case 1:
                         status->state = STATE_SETP;
                         break;
                     case 0:
                         status->state = STATE_IDLE;
                         //flash_erase();
                         NVIC_SystemReset();
                         break;
                     default:
                         status->state = STATE_PREHEAT_BREW;
+                }
+            }
             else if(SW_UP_PRESSED && goto_mode < 3) {
                 goto_mode++;
+            }
             else if(SW_DOWN_PRESSED && goto_mode > 0) {
                 goto_mode--;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETP:
+        {
             // Write text to OLED
             // [ therm :: set p ]
             // [ p = 12         ]
-            ssd1306_DrawString("Proportional", 0, 40);
+            ssd1306_drawstring("Proportional", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.k_p, tempstr, 10);
             ssd1306_DrawString("P=", 1, 45);
             ssd1306_DrawString("    ", 1, 57);
             ssd1306_DrawString(tempstr, 1, 57);
             ssd1306_drawstring("P=", 1, 45);
             ssd1306_drawstring("    ", 1, 57);
             ssd1306_drawstring(tempstr, 1, 57);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETI;
+            }
             else {
                 user_input(&set->val.k_p);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETI:
+        {
             // Write text to OLED
             // [ therm :: set i ]
             // [ i = 12         ]
-            ssd1306_DrawString("Integral", 0, 40);
+            ssd1306_drawstring("Integral", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.k_i, tempstr, 10);
             ssd1306_DrawString("I=", 1, 45);
             ssd1306_DrawString("    ", 1, 57);
             ssd1306_DrawString(tempstr, 1, 57);
             ssd1306_drawstring("I=", 1, 45);
             ssd1306_drawstring("    ", 1, 57);
             ssd1306_drawstring(tempstr, 1, 57);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETD;
+            }
             else {
                 user_input(&set->val.k_i);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETD:
+        {
             // Write text to OLED
             // [ therm :: set d ]
             // [ d = 12         ]
-            ssd1306_DrawString("Derivative", 0, 40);
+            ssd1306_drawstring("Derivative", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.k_d, tempstr, 10);
             ssd1306_DrawString("D=", 1, 45);
             ssd1306_DrawString("    ", 1, 57);
             ssd1306_DrawString(tempstr, 1, 57);
             ssd1306_drawstring("D=", 1, 45);
             ssd1306_drawstring("    ", 1, 57);
             ssd1306_drawstring(tempstr, 1, 57);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETWINDUP;
+            }
             else {
                 user_input(&set->val.k_d);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETWINDUP:
+        {
             // Write text to OLED
             // [ therm :: set windup ]
             // [ g = 12         ]
-            ssd1306_DrawString("Windup Guard", 0, 40);
+            ssd1306_drawstring("Windup Guard", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.windup_guard, tempstr, 10);
             ssd1306_DrawString("G=", 1, 45);
             ssd1306_DrawString("    ", 1, 57);
             ssd1306_DrawString(tempstr, 1, 57);
             ssd1306_drawstring("G=", 1, 45);
             ssd1306_drawstring("    ", 1, 57);
             ssd1306_drawstring(tempstr, 1, 57);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETBOOTTOBREW;
+            }
             else {
                 user_input(&set->val.windup_guard);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETBOOTTOBREW:
+        {
             // Write text to OLED
             // [ therm :: set windup ]
             // [ g = 12         ]
-            ssd1306_DrawString("Start on Boot", 0, 40);
+            ssd1306_drawstring("Start on Boot", 0, 40);
             ssd1306_drawlogo();
-            ssd1306_DrawString("sob=", 1, 45);
+            ssd1306_drawstring("sob=", 1, 45);
             if(set->val.boottobrew)
-                ssd1306_DrawString("Enabled ", 1, 70);
+                ssd1306_drawstring("Enabled ", 1, 70);
             else
-                ssd1306_DrawString("Disabled", 1, 70);
+                ssd1306_drawstring("Disabled", 1, 70);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETUNITS;
+            }
             else if(!HAL_GPIO_ReadPin(SW_UP)) {
                 set->val.boottobrew = 1;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->val.boottobrew = 0;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETUNITS:
+        {
             // Write text to OLED
             // [ therm :: set windup ]
             // [ g = 12         ]
-            ssd1306_DrawString("Units: ", 0, 40);
+            ssd1306_drawstring("Units: ", 0, 40);
             ssd1306_drawlogo();
             if(set->val.temp_units == TEMP_UNITS_FAHRENHEIT)
-                ssd1306_DrawString("Fahrenheit", 1, 60);
+                ssd1306_drawstring("Fahrenheit", 1, 60);
             else
-                ssd1306_DrawString("Celsius   ", 1, 60);
+                ssd1306_drawstring("Celsius   ", 1, 60);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETTEMPOFFSET;
+            }
             else if(!HAL_GPIO_ReadPin(SW_UP)) {
                 set->val.temp_units = TEMP_UNITS_FAHRENHEIT;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->val.temp_units = TEMP_UNITS_CELSIUS;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETTEMPOFFSET:
+        {
             // Write text to OLED
             // [ therm :: set temp offset ]
             // [ g = 12         ]
-            ssd1306_DrawString("Temp Cal Offset", 0, 40);
+            ssd1306_drawstring("Temp Cal Offset", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.temp_offset, tempstr, 10);
             ssd1306_DrawString("O=", 1, 45);
             ssd1306_DrawString("    ", 1, 57);
             ssd1306_DrawString(tempstr, 1, 57);
             ssd1306_drawstring("O=", 1, 45);
             ssd1306_drawstring("    ", 1, 57);
             ssd1306_drawstring(tempstr, 1, 57);
-            ssd1306_DrawString("Press to accept", 3, 40);
+            ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 flash_save(&set);
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input_signed(&set->val.temp_offset);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_PREHEAT_BREW:
+        {
             // Write text to OLED
             // [ therm : preheating brew ]
             // [ 30 => 120 C             ]
-            ssd1306_DrawString("Preheating...", 0, 0);
+            ssd1306_drawstring("Preheating...", 0, 0);
             //ssd1306_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->val.setpoint_brew;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->val.setpoint_brew);
+            }
             // Event Handler
             if(status->temp >= status->setpoint) {
                 status->state = STATE_MAINTAIN_BREW;
+            }
         } break;
         case STATE_MAINTAIN_BREW:
+        {
             // Write text to OLED
             // [ therm : ready to brew ]
             // [ 30 => 120 C           ]
-            ssd1306_DrawString("Preheated!", 0, 0);
+            ssd1306_drawstring("Preheated!", 0, 0);
             //ssd1306_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->val.setpoint_brew;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->val.setpoint_brew);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_PREHEAT_STEAM:
+        {
             // Write text to OLED
             // [ therm : preheating steam ]
             // [ 30 => 120 C           ]
-            ssd1306_DrawString("Preheating...", 0, 0);
+            ssd1306_drawstring("Preheating...", 0, 0);
             //ssd1306_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->val.setpoint_steam;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->val.setpoint_steam);
+            }
             // Event Handler
             if(status->temp >= status->setpoint) {
                 status->state = STATE_MAINTAIN_STEAM;
+            }
         } break;
         case STATE_MAINTAIN_STEAM:
+        {
             // Write text to OLED
             // [ therm : ready to steam ]
             // [ 30 => 120 C            ]
-            ssd1306_DrawString("Ready to Steam!", 0, 0);
+            ssd1306_drawstring("Ready to Steam!", 0, 0);
             //ssd1306_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->val.setpoint_steam;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->val.setpoint_steam);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_TC_ERROR:
+        {
             // Write text to OLED
             // [ therm : ready to steam ]
             // [ 30 => 120 C            ]
-            ssd1306_DrawString("Error:              ", 0, 0);
+            ssd1306_drawstring("Error:              ", 0, 0);
             char tempstr[6];
             itoa(status->tc_errno, tempstr, 10);
-            ssd1306_DrawString(tempstr, 0, 57);
+            ssd1306_drawstring(tempstr, 0, 57);
             if(status->tc_errno == 1)
-                ssd1306_DrawString("    TC Open Circuit", 1, 0);
+                ssd1306_drawstring("    TC Open Circuit", 1, 0);
             else if(status->tc_errno == 4)
-                ssd1306_DrawString("    TC Short to GND", 1, 0);
+                ssd1306_drawstring("    TC Short to GND", 1, 0);
             else if(status->tc_errno == 8)
-                ssd1306_DrawString("    TC Short to VCC", 1, 0);
+                ssd1306_drawstring("    TC Short to VCC", 1, 0);
             else
                 ssd1306_DrawString("#?, Unknown Error", 1, 0);
             ssd1306_DrawString("                    ", 2, 0);
                 ssd1306_drawstring("#?, Unknown Error", 1, 0);
             ssd1306_drawstring("                    ", 2, 0);
             ssd1306_DrawString("-> to ignore all or", 2, 0);
             ssd1306_DrawString("press to continue", 3, 0);
             ssd1306_drawstring("-> to ignore all or", 2, 0);
             ssd1306_drawstring("press to continue", 3, 0);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
+            }
             else if(SW_RIGHT_PRESSED) {
                 set->val.ignore_tc_error = 1;
                 status->state = STATE_IDLE;
+            }
             // Event Handler
             // Maybe handle if TC is plugged in
             // N/A
         } break;
         // Something is terribly wrong
         default:
+        {
             status->state = STATE_IDLE;
             status->pid_enabled = 0;
         } break;
+    }
     if(last_state != status->state) {
         // Clear screen on state change
         goto_mode = 2;
         trigger_drawsetpoint = 1;
         ssd1306_clearscreen();
+    }
     // Last buttonpress
     sw_btn_last = sw_btn;
     sw_up_last = sw_up;
     sw_down_last = sw_down;
     sw_left_last = sw_left;
     sw_right_last = sw_right;
+}
 static int32_t temp_last = 43002;
 static int32_t setpoint_last = 10023;
 void draw_setpoint(therm_status_t* status) {
     // FIXME: need to do this when switching modes too
     if(status->temp != temp_last || trigger_drawsetpoint) {
         char tempstr[3];
         itoa_fp(status->temp, status->temp_frac, tempstr);
         ssd1306_DrawStringBig("      ", 3, 0);
         ssd1306_DrawStringBig(tempstr, 3, 0);
         ssd1306_drawstringbig("      ", 3, 0);
         ssd1306_drawstringbig(tempstr, 3, 0);
+    }
     if(trigger_drawsetpoint)
-        ssd1306_DrawStringBig(">", 3, 74);
+        ssd1306_drawstringbig(">", 3, 74);
     if(status->setpoint != setpoint_last || trigger_drawsetpoint) {
         char tempstr[3];
         itoa(status->setpoint, tempstr, 10);
         ssd1306_DrawStringBig("   ", 3, 90);
         ssd1306_DrawStringBig(tempstr, 3, 90);
         ssd1306_drawstringbig("   ", 3, 90);
         ssd1306_drawstringbig(tempstr, 3, 90);
+    }
     trigger_drawsetpoint = 0;
     setpoint_last = status->setpoint;
     temp_last = status->temp;
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

flash.c

➞

Show inline comments

 #include "stm32f0xx_hal.h"
 #include "ssd1306.h"
 #include "stm32f0xx_hal_flash.h"
 #include "flash.h"
 __attribute__((__section__(".eeprom"))) uint16_t eeprom[512];
 static void __flash_write(therm_settings_t* tosave);
 #define EEPROM_MAGIC_INDEX 16
 #define EEPROM_MAGIC_VALUE 0xbeef
 void flash_save(therm_settings_t* tosave)
+{
     ssd1306_clearscreen();
-    ssd1306_DrawString("Erase...", 0, 0);
+    ssd1306_drawstring("Erase...", 0, 0);
     HAL_Delay(100);
-    ssd1306_DrawString("Save...", 1, 0);
+    ssd1306_drawstring("Save...", 1, 0);
     __flash_write(tosave);
     HAL_Delay(100);
-    ssd1306_DrawString("Done!", 2, 0);
+    ssd1306_drawstring("Done!", 2, 0);
     HAL_Delay(500);
+}
 void flash_restore(therm_settings_t *torestore)
+{
     ssd1306_clearscreen();
-    ssd1306_DrawString("READING SAVE", 1, 0);
+    ssd1306_drawstring("READING SAVE", 1, 0);
     if(eeprom[EEPROM_MAGIC_INDEX] != EEPROM_MAGIC_VALUE)
+    {
-        ssd1306_DrawString("No data to read!", 2, 0);
+        ssd1306_drawstring("No data to read!", 2, 0);
         return;
+    }
     uint16_t i;
     for(i=0;i<128;i++)
         torestore->data[i] = *(eeprom+i);
-    ssd1306_DrawString("READ COMPLETE", 3, 0);
+    ssd1306_drawstring("READ COMPLETE", 3, 0);
+}
 static void __flash_write(therm_settings_t* tosave)
+{
     // Erase mem
     HAL_FLASH_Unlock();
     // Erase the FLASH pages
     FLASH_EraseInitTypeDef erase;
     erase.TypeErase = TYPEERASE_PAGES;
     erase.PageAddress = eeprom;
     erase.NbPages = 1;
     uint32_t SectorError = 0;
     HAL_FLASHEx_Erase(&erase, &SectorError);
     CLEAR_BIT(FLASH->CR, FLASH_CR_PER);
     uint16_t i;
 //    for(i=1;i<20;i++)
  //   {
   //      HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, eeprom+i, tosave->data[i]);

gpio.c

➞

Show inline comments

 #include "gpio.h"
 #include "config.h"
 #include "stm32f0xx_hal_conf.h"
 #include <inttypes.h>
 // Increase on each press, and increase at a fast rate after duration elapsed of continuously holding down... somehow...
 uint32_t change_time_reset = 0;
+static uint32_t change_time_reset = 0;
 // Increment/decrement unsigned variable with up/down buttons
 void user_input(uint16_t* to_modify)
+{
     if(CHANGE_ELAPSED) {
         if(!HAL_GPIO_ReadPin(SW_UP) ) {
             CHANGE_RESET;
             (*to_modify)++;
+        }
         else if(!HAL_GPIO_ReadPin(SW_DOWN) && (*to_modify) > 0) {
             CHANGE_RESET;
             (*to_modify)--;
+        }
+    }
+}
 // Increment/decrement signed variable with up/down buttons
 void user_input_signed(int16_t* to_modify)
+{
     // TODO: Bounds check on int16_t
     if(CHANGE_ELAPSED) {
         if(!HAL_GPIO_ReadPin(SW_UP) ) {
             CHANGE_RESET;
             (*to_modify)++;
+        }
         else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
             CHANGE_RESET;
             (*to_modify)--;
+        }
+    }
+}
 void gpio_init(void) {
 // Initialize GPIO
 void gpio_init(void)
+{
   GPIO_InitTypeDef GPIO_InitStruct;
     /* GPIO Ports Clock Enable */
   __GPIOF_CLK_ENABLE();
   __GPIOA_CLK_ENABLE();
   __GPIOB_CLK_ENABLE();
   __SPI1_CLK_ENABLE();
   //////////////////
   // PORT F       //
   //////////////////
   // PORTF OUTPUT
   // Configure GPIO pin : PF0 [Power LED]
   GPIO_InitStruct.Pin = GPIO_PIN_0;
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
   HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
   // PORTF UNUSED
   // Configure GPIO pin : PF1
   GPIO_InitStruct.Pin = GPIO_PIN_1;

main.c

➞

Show inline comments

@@ @@ -28,77 +28,77 @@ int main(void) @@
     // Unset bootloader option bytes (if set)
     // FIXME this was never getting called. Try again sometime.
     //bootloader_unset();
     // Init GPIO
     gpio_init();
     // Init USB (TODO: Handle plugged/unplugged with external power)
     MX_USB_DEVICE_Init();
 //    set.val.usb_plugged =
     // USB startup delay
     HAL_Delay(500);
     HAL_GPIO_WritePin(LED_POWER, 1);
     // Enter into bootloader if up button pressed on boot
     if(!HAL_GPIO_ReadPin(SW_UP))
         bootloader_enter();
     // Init SPI busses
     spi_init();
     // Init OLED over SPI
-    ssd1306_Init();
+    ssd1306_init();
     ssd1306_clearscreen();
     // Default settings
     set.val.boottobrew = 0;
     set.val.temp_units = TEMP_UNITS_FAHRENHEIT;
     set.val.windup_guard = 200;
     set.val.k_p = 10;
     set.val.k_i = 10;
     set.val.k_d = 1;
     set.val.ignore_tc_error = 0;
     set.val.setpoint_brew = 70;
     set.val.setpoint_steam = 70;
     // Default status
     status.temp = 0;
     status.temp_frac = 0;
     status.state_resume = 0;
     status.state = STATE_IDLE;
     status.setpoint = 70;
     status.pid_enabled = 0;
     // Go to brew instead of idle if configured thusly
     if(set.val.boottobrew)
       status.state = STATE_PREHEAT_BREW;
     // Startup screen
     ssd1306_DrawString("therm v0.2", 1, 40);
     ssd1306_DrawString("protofusion.org/therm", 3, 0);
     ssd1306_drawstring("therm v0.2", 1, 40);
     ssd1306_drawstring("protofusion.org/therm", 3, 0);
     HAL_Delay(1000);
     // Restore settings from flash memory
     flash_restore(&set);
     HAL_Delay(1000);
     ssd1306_clearscreen();
     // Soft timers
     uint32_t last_ssr_on = 0;
     uint32_t last_vcp_tx = 0;
     uint32_t last_led = 0;
     uint32_t last_pid = 0;
     int16_t ssr_output = 0; // Duty cycle of ssr, 0 to SSR_PERIOD
     // Main loop
     while(1)
+    {
         // Process sensor inputs
         if(HAL_GetTick() - last_led > 400)
+        {
             last_led = HAL_GetTick();
@@ @@ -124,49 +124,49 @@ int main(void) @@
+            }
             else
+            {
                 ssr_output = 0;
+            }
             last_pid = HAL_GetTick();
+        }
         // Kill SSR once the desired on-time has elapsed
         if(HAL_GetTick() - last_ssr_on > ssr_output || ssr_output <= 0)
+        {
             HAL_GPIO_WritePin(SSR_PIN, 0);
             HAL_GPIO_WritePin(LED_POWER, 0);
+        }
         // Every 200ms, set the SSR on unless output is 0
         if(HAL_GetTick() - last_ssr_on > SSR_PERIOD)
+        {
             // Only support heating (ssr_output > 0) right now
             if(ssr_output > 0)
+            {
                 char tempstr[6];
                 itoa(ssr_output, tempstr, 10);
-                ssd1306_DrawString(tempstr, 0, 90);
+                ssd1306_drawstring(tempstr, 0, 90);
                 HAL_GPIO_WritePin(SSR_PIN, 1);
                 HAL_GPIO_WritePin(LED_POWER, 1);
                 last_ssr_on = HAL_GetTick();
+            }
             else {
                 // Make sure everything is off
                 HAL_GPIO_WritePin(SSR_PIN, 0);
                 HAL_GPIO_WritePin(LED_POWER, 0);
+            }
+        }
         // Transmit temperature over USB-CDC on a regulat basis
         if(HAL_GetTick() - last_vcp_tx > VCP_TX_FREQ)
+        {
             // Print temp to cdc
             char tempstr[16];
             itoa_fp(status.temp, status.temp_frac, tempstr);
             uint8_t numlen = strlen(tempstr);
             tempstr[numlen] = '\r';
             tempstr[numlen+1] = '\n';
     //        if(set.val.usb_plugged)

ssd1306.c

➞

Show inline comments

 #include "stm32f0xx_hal_conf.h"
 #include "ssd1306.h"
 // Write command to OLED
 void WriteCommand(unsigned char command)
+static void WriteCommand(unsigned char command)
+{
   SSD_CS_Low();
   SSD_A0_Low();
   SPI_SendByte(command);
   SSD_CS_High();
+}
 // Write data to OLED
 void WriteData(unsigned char data)
+static void WriteData(unsigned char data)
+{
   SSD_CS_Low();
   SSD_A0_High();
   SPI_SendByte(data);
   SSD_CS_High();
+}
 // Initialize OLED
-void ssd1306_Init(void)
+void ssd1306_init(void)
+{
   /* Generate a reset */
   SSD_Reset_Low();
   uint32_t i;
   for(i=5000; i>1; i--)
   SSD_Reset_High();
   WriteCommand(0xAE);
   WriteCommand(0xD5);
   WriteCommand(0x80);
   WriteCommand(0xA8);
   WriteCommand(0x1F);
   WriteCommand(0xD3);
   WriteCommand(0x00);
   WriteCommand(0x40 | 0x00); // line #0
   WriteCommand(0x8D);
   WriteCommand(0x14); //10 or 14 if not externalvcc
   WriteCommand(0x20);
   WriteCommand(0x00);
 //  WriteCommand(0xA0 | 0x1); // segremap (normal)
   WriteCommand(0xA0); // segremap (flip)
 //  WriteCommand(0xC8); // comscandec (normal)
   WriteCommand(0xC0); // comscandec (flip)
@@ @@ -158,55 +158,55 @@ static const char fontData[][5] = @@
     {0x44,0x64,0x54,0x4C,0x44},         //   ( 90)  z - 0x007A Latin Small Letter Z
     {0x00,0x08,0x36,0x41,0x00},         //   ( 91)  { - 0x007B Left Curly Bracket
     {0x00,0x00,0x7F,0x00,0x00},         //   ( 92)  | - 0x007C Vertical Line
     {0x00,0x41,0x36,0x08,0x00},         //   ( 93)  } - 0x007D Right Curly Bracket
     {0x02,0x01,0x02,0x04,0x02},         //   ( 94)  ~ - 0x007E Tilde
     {0x08,0x14,0x2A,0x14,0x22},         //   ( 95) << - 0x00AB Left-Pointing Double Angle Quotation Mark
     {0x00,0x02,0x05,0x02,0x00},         //   ( 96)    - 0x00B0 Degree Sign
 //    {0x44,0x44,0x5F,0x44,0x44},         //   ( 97) +- - 0x00B1 Plus-Minus Sign
 //    {0x7E,0x20,0x20,0x10,0x3E},         //   ( 98)  u - 0x00B5 Micro Sign
 //    {0x22,0x14,0x2A,0x14,0x08},         //   ( 99) >> - 0x00BB Right-Pointing Double Angle Quotation Mark
 //    {0x30,0x48,0x45,0x40,0x20},         //   (100)  ? - 0x00BF Inverted Question Mark
 //    {0x22,0x14,0x08,0x14,0x22},         //   (101)  x - 0x00D7 Multiplcation Sign
 //    {0x08,0x08,0x2A,0x08,0x08},         //   (102)  + - 0x00F7 Division Sign
 //    {0x18,0x14,0x08,0x14,0x0C},         //   (103)    - 0x221E Infinity
 //    {0x44,0x4A,0x4A,0x51,0x51},         //   (104)  < - 0x2264 Less-Than or Equal to
 //    {0x51,0x51,0x4A,0x4A,0x44},         //   (105)  > - 0x2265 Greater-Than or Equal to
 //    {0x54,0x14,0x64,0x08,0x70},         //   (106)  .: - RF Symbol
 //    {0x70,0x7C,0x72,0x7C,0x70},         //   (107)  ^ - Lock symbol
 //    {0x70,0x5C,0x52,0x54,0x70},         //   (108)  / - Unlock symbol
 //    {0x0C,0x1E,0x3C,0x1E,0x0C},         //   (109)  <3 - Heart Symbol
 //    {0x18,0x22,0xFF,0x12,0x0C},         //   (110)  U - USB Symbol
 };
 void setStartPage(unsigned char d)
+static void setStartPage(unsigned char d)
+{
     WriteCommand(0xB0|d);       // Set Page Start Address for Page Addressing Mode
                                 // Default => 0xB0 (0x00)
+}
 /* Below are functions used to configure the OLED */
 void setStartColumn(unsigned char d)
+static void setStartColumn(unsigned char d)
+{
     WriteCommand(0x00+d%16);    // Set Lower Column Start Address for Page Addressing Mode
     WriteCommand(0x10+d/16);    // Set Higher Column Start Address for Page Addressing Mode
                                 // Default => 0x10
+}
 const uint8_t row[4][32] = {
 	{0x00,0x00,0x01,0x03,0x07,0x0F,0x1E,0x3C,0x3C,0x7C,0x7C,0x7C,0xFC,0xFF,0xFF,0xFC,0xFC,0xFC,0xFC,0xFF,0x7F,0x7F,0x7F,0x3C,0x3C,0x1C,0x0C,0x06,0x03,0x01,0x00,0x00},
 	{0x0F,0x7F,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x3F,0x3F,0x7F,0xFF,0xFF,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x7F,0x0F},
 	{0xF0,0xFE,0xFF,0xFF,0xFF,0xC7,0x00,0x00,0x00,0x00,0x87,0xC7,0xC7,0xFF,0xFF,0x00,0x00,0x00,0x00,0x87,0x87,0xC7,0xC3,0x03,0x07,0x07,0x0F,0x7F,0xFF,0xFF,0xFE,0xF0},
 	{0x00,0x00,0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFC,0xFE,0xFE,0xFE,0xFF,0xFF,0xFF,0x1F,0x1F,0x1F,0x1F,0xFF,0xFE,0xFE,0xFE,0xFC,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x00},
 };
 void ssd1306_clearscreen()
+{
     uint8_t i = 0;
     uint8_t page = 0;
     for(page = 0; page<4; page++)
@@ @@ -238,67 +238,67 @@ void ssd1306_drawlogo() @@
     for(i = 0; i<32; i++)
+    {
         WriteData(row[1][i]);
+    }
     WriteData(0x00);
     setStartPage(1);
     setStartColumn(0);
     for(i = 0; i<32; i++)
+    {
         WriteData(row[2][i]);
+    }
     WriteData(0x00);
     setStartPage(0);
     setStartColumn(0);
     for(i = 0; i<32; i++)
+    {
         WriteData(row[3][i]);
+    }
     WriteData(0x00);
+}
 /* Print a single character from font.cpp */
-void ssd1306_DrawChar(char ascii, unsigned char row, unsigned char xPos)
+void ssd1306_drawchar(char ascii, unsigned char row, unsigned char xPos)
+{
     char *srcPointer = -1;
     unsigned char i;
     srcPointer = &fontData[(ascii-32)][0];
     setStartPage(row);
     setStartColumn(xPos);
     for(i=0;i<5;i++)
+    {
         WriteData(*srcPointer);
         srcPointer++;
+    }
     WriteData(0x00);
+}
-void ssd1306_DrawCharBig(char ascii, unsigned char row, unsigned char xPos)
+void ssd1306_drawcharbig(char ascii, unsigned char row, unsigned char xPos)
+{
     char *srcPointer = -1;
     unsigned char i;
     srcPointer = &fontData[(ascii-32)][0];
     setStartPage(row-1);
     setStartColumn(xPos);
     // Write first row
     for(i=0;i<5;i++)
+    {
         uint8_t data = 0;
         data |= ((*srcPointer) & 0b1000) << 4; // get top 4 bits
         data |= ((*srcPointer) & 0b1000) << 3; // get top 4 bits
         data |= ((*srcPointer) & 0b0100) << 3; // get top 4 bits
         data |= ((*srcPointer) & 0b0100) << 2; // get top 4 bits
         data |= ((*srcPointer) & 0b0010) << 2; // get top 4 bits
         data |= ((*srcPointer) & 0b0010) << 1; // get top 4 bits
         data |= ((*srcPointer) & 0b0001) << 1; // get top 4 bits
         data |= ((*srcPointer) & 0b0001); // get top 4 bits
@@ @@ -319,59 +319,59 @@ void ssd1306_DrawCharBig(char ascii, uns @@
     for(i=0;i<5;i++)
+    {
         uint8_t data = 0;
         data |=  (*srcPointer) & 0b10000000; // get top 4 bits
         data |= ((*srcPointer) & 0b10000000) >> 1; // get top 4 bits
         data |= ((*srcPointer) & 0b01000000) >> 1; // get top 4 bits
         data |= ((*srcPointer) & 0b01000000) >> 2; // get top 4 bits
         data |= ((*srcPointer) & 0b00100000) >> 2; // get top 4 bits
         data |= ((*srcPointer) & 0b00100000) >> 3; // get top 4 bits
         data |= ((*srcPointer) & 0b00010000) >> 3; // get top 4 bits
         data |= ((*srcPointer) & 0b00010000) >> 4; // get top 4 bits
         WriteData(data);
         WriteData(data);
         srcPointer++;
+    }
     WriteData(0x00);
+}
-void ssd1306_DrawString(const char *dataPtr, unsigned char row, unsigned char xPos)
+void ssd1306_drawstring(const char *dataPtr, unsigned char row, unsigned char xPos)
+{
     char *srcPointer;
     srcPointer = (char*)dataPtr;
-    ssd1306_DrawChar(' ',row,xPos); // NBSP must be written first before the string start
+    ssd1306_drawchar(' ',row,xPos); // NBSP must be written first before the string start
     while(1)
+    {
-        ssd1306_DrawChar(*srcPointer,row,xPos);
+        ssd1306_drawchar(*srcPointer,row,xPos);
         srcPointer++;
         xPos+=6;
         if(*srcPointer == 0) break;
+    }
+}
-void ssd1306_DrawStringBig(const char *dataPtr, unsigned char row, unsigned char xPos)
+void ssd1306_drawstringbig(const char *dataPtr, unsigned char row, unsigned char xPos)
+{
     char *srcPointer;
     srcPointer = (char*)dataPtr;
-    ssd1306_DrawCharBig(' ',row,xPos); // NBSP must be written first before the string start
+    ssd1306_drawcharbig(' ',row,xPos); // NBSP must be written first before the string start
     while(1)
+    {
-        ssd1306_DrawCharBig(*srcPointer,row,xPos);
+        ssd1306_drawcharbig(*srcPointer,row,xPos);
         srcPointer++;
         xPos+=12;
         if(*srcPointer == 0) break;
+    }
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

ssd1306.h

➞

Show inline comments

 #ifndef   ssd1306_H
 #define   ssd1306_H
 #define   SSD_RESET       GPIOA,GPIO_PIN_3
 #define   SSD_A0          GPIOA,GPIO_PIN_4
 #define   SSD_CS          GPIOA,GPIO_PIN_2
 #define   SSD_Reset_Low()   HAL_GPIO_WritePin(SSD_RESET, 0)
 #define   SSD_Reset_High()  HAL_GPIO_WritePin(SSD_RESET, 1)
 #define   SSD_A0_Low()      HAL_GPIO_WritePin(SSD_A0, 0)
 #define   SSD_A0_High()     HAL_GPIO_WritePin(SSD_A0, 1)
 #define   SSD_CS_Low()      HAL_GPIO_WritePin(SSD_CS, 0)
 #define   SSD_CS_High()     HAL_GPIO_WritePin(SSD_CS, 1)
 // Use stdperiph
 //extern SPI_HandleTypeDef spi1;
 extern SPI_HandleTypeDef hspi1;
 // EMZ FIXME this won't really work
-#define   SPI_SendByte(data)  HAL_SPI_Transmit(&hspi1, &data, 1, 100)
+#define   SPI_SendByte(data)  HAL_SPI_Transmit(spi_get(), &data, 1, 100)
 //#define SPI_SendByte(data)
 #define SPI_Wait()
 //#define   SPI_SendByte(data)  SPI_I2S_SendData(SPI1,data)
 //#define   SPI_Wait()       while(!(SPI1->SR&SPI_FLAG_TXE));while(SPI1->SR&SPI_FLAG_BSY);
 void ssd1306_Init(void);
 void ssd1306_DrawChar(char ascii, unsigned char row, unsigned char xPos);
 void ssd1306_DrawCharBig(char ascii, unsigned char row, unsigned char xPos);
 void ssd1306_DrawString(const char *dataPtr, unsigned char row, unsigned char xPos);
 void ssd1306_DrawStringBig(const char *dataPtr, unsigned char row, unsigned char xPos);
 void ssd1306_init(void);
 void ssd1306_drawchar(char ascii, unsigned char row, unsigned char xPos);
 void ssd1306_drawcharbig(char ascii, unsigned char row, unsigned char xPos);
 void ssd1306_drawstring(const char *dataPtr, unsigned char row, unsigned char xPos);
 void ssd1306_drawstringbig(const char *dataPtr, unsigned char row, unsigned char xPos);
 void ssd1306_drawlogo();
 void ssd1306_clearscreen();
 #endif
 // vim:softtabstop=4 shiftwidth=4 expandtab

0 comments (0 inline, 0 general)