therm Changeset - 45ee045c249f · protofusion repositories

Changeset - 45ee045c249f

Parent rev.

Child rev.

[Not reviewed]

cortex-f0

0 7 0

matthewreed - 9 years ago 2015-12-22 22:39:09

Added checksum to flash write and restore functions and load default settings

7 files changed with 40 insertions and 32 deletions:

config.h

display.c

flash.c

flash.h

ssd1306.c

ssd1306.h

states.h

0 comments (0 inline, 0 general)

config.h

➞

Show inline comments

 #ifndef CONFIG_H
 #define CONFIG_H
 // Temperature sensor type
 //#define MAX31855_TC_SENSOR
 #define MAX31865_RTD_SENSOR
 // Virtual serial port transmit rate
 #define VCP_TX_FREQ 1000
 // Solid-state relay maximum on-time
 #define SSR_PERIOD 200
 // Interval of PID calculations
 #define PID_PERIOD 120
 // Pin settings
 #define LED_POWER GPIOF,GPIO_PIN_0
 #define MAX_CS GPIOA,GPIO_PIN_15
 #define SW_BTN  GPIOB, GPIO_PIN_4
 #define SW_UP   GPIOB, GPIO_PIN_7
 #define SW_DOWN GPIOB, GPIO_PIN_3
 #define SW_LEFT GPIOB, GPIO_PIN_5
 #define SW_RIGHT GPIOB, GPIO_PIN_6
 #define SSR_PIN GPIOA, GPIO_PIN_1
 // Visual niceness
 #define hal_init() HAL_Init()
 // Add bootloader option to top of idle screen menu
 #define BOOTLOADER_SHORTCUT
 #define DEFAULT_BOOT_TO_BREW 0
 #define DEFAULT_TEMP_UNITS TEMP_UNITS_FAHRENHEIT
 #define DEFAULT_WINDUP_GUARD 10
 #define DEFAULT_K_P 10
 #define DEFAULT_K_I 1
 #define DEFAULT_K_D 1
 #define DEFAULT_TEMP_OFFSET 0
 #define DEFAULT_IGNORE_ERROR 0
 #define DEFAULT_SETPOINT_BREW 70
 #define DEFAULT_SETPOINT_STEAM 70
 #endif
 // vim:softtabstop=4 shiftwidth=4 expandtab

display.c

➞

Show inline comments

 #include "stm32f0xx_hal.h"
 #include "ssd1306.h"
 #include "stringhelpers.h"
 #include "display.h"
 #include "config.h"
 #include "states.h"
 #include "syslib.h"
 #include "flash.h"
 #include "gpio.h"
 #ifdef MAX31865_RTD_SENSOR
 #include "max31865.h"
 #endif
 // Private function prototypes
 static void draw_setpoint(therm_status_t* status);
 // Button transition variables
 static uint8_t sw_btn_last = 0;
 static uint8_t sw_up_last = 0;
 static uint8_t sw_down_last = 0;
 static uint8_t sw_left_last = 0;
 static uint8_t sw_right_last = 0;
 // Buttonpress macros
 #define SW_BTN_PRESSED (sw_btn_last == 0 && sw_btn == 1) // rising edge on buttonpress
 #define SW_UP_PRESSED (sw_up_last == 0 && sw_up == 1)
 #define SW_DOWN_PRESSED (sw_down_last == 0 && sw_down == 1)
 #define SW_LEFT_PRESSED (sw_left_last == 0 && sw_left == 1)
 #define SW_RIGHT_PRESSED (sw_right_last == 0 && sw_right == 1)
 // States
 static uint8_t trigger_drawsetpoint = 1;
 static int16_t last_temp = 21245;
 static uint8_t goto_mode = MODE_HEAT;
-static uint8_t reset_mode = RESET_RESET;
+static uint8_t reset_mode = RESET_REBOOT;
 // Display state machine
 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);
             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_drawlogo();
             switch(goto_mode) {
                 case MODE_HEAT:
+                {
                     ssd1306_drawstring("-> heat     ", 1, 40);
                 } break;
                 case MODE_SETUP:
+                {
                     ssd1306_drawstring("-> setup    ", 1, 40);
                 } break;
                 case MODE_RESET:
+                {
                     ssd1306_drawstring("-> reset    ", 1, 40);
                 } break;
 				#ifdef BOOTLOADER_SHORTCUT
                 case MODE_BOOTLOADER:
+                {
                     ssd1306_drawstring("-> dfu      ", 1, 40);
+                }
 				#endif
+            }
             // Button handler
             if(SW_BTN_PRESSED) {
                 switch(goto_mode) {
                     case MODE_HEAT:
                         status->state = STATE_PREHEAT;
                         break;
                     case MODE_SETUP:
                         status->state = STATE_SETP;
                         break;
                     case MODE_RESET:
                         status->state = STATE_RESET;
-                        reset_mode = RESET_RESET;
+                        reset_mode = RESET_REBOOT;
                         break;
 					#ifdef BOOTLOADER_SHORTCUT
                     case MODE_BOOTLOADER:
                         ssd1306_clearscreen();
                         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_RESET; // Just in case
                         break;
 					#endif
                     default:
                         status->state = STATE_PREHEAT;
+                }
+            }
             else if(SW_DOWN_PRESSED && goto_mode < (MODE_SIZE - 1)) {
                 goto_mode++;
+            }
             else if(SW_UP_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_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("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_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("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_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("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_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("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_drawlogo();
             ssd1306_drawstring("sob=", 1, 45);
             if(set->val.boottobrew)
                 ssd1306_drawstring("Enabled ", 1, 70);
             else
                 ssd1306_drawstring("Disabled", 1, 70);
             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_drawlogo();
             if(set->val.temp_units == TEMP_UNITS_FAHRENHEIT)
                 ssd1306_drawstring("Fahrenheit", 1, 60);
             else
                 ssd1306_drawstring("Celsius   ", 1, 60);
             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_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("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:
+        {
             // Write text to OLED
             // [ therm : preheating brew ]
             // [ 30 => 120 C             ]
             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;
+            }
         } break;
         case STATE_MAINTAIN:
+        {
             // Write text to OLED
             // [ therm : ready to brew ]
             // [ 30 => 120 C           ]
             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;
         // Thermocouple error
         case STATE_TC_ERROR:
+        {
             // Write text to OLED
             // [ therm : ready to steam ]
             // [ 30 => 120 C            ]
             ssd1306_drawstring("Error:              ", 0, 0);
             char tempstr[6];
             itoa(status->error_code, tempstr, 10);
             ssd1306_drawstring(tempstr, 0, 57);
             //TODO: add RTD error codes
             if(status->error_code == 1)
                 ssd1306_drawstring("    TC Open Circuit", 1, 0);
             else if(status->error_code == 4)
                 ssd1306_drawstring("    TC Short to GND", 1, 0);
             else if(status->error_code == 8)
                 ssd1306_drawstring("    TC Short to VCC", 1, 0);
             else
                 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);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
 				#ifdef MAX31865_RTD_SENSOR
 				max31865_clear_errors(spi_get());
 				#endif
+            }
             else if(SW_RIGHT_PRESSED) {
                 set->val.ignore_error = 1;
                 status->state = STATE_IDLE;
+            }
             // Event Handler
             // Maybe handle if TC is plugged in
             // N/A
         } break;
         // Reset state
         case STATE_RESET:
+        {
             // Write text to OLED
             // [ therm :: reset ]
             ssd1306_drawstring("therm :: reset ", 0, 40);
             status->pid_enabled = 0;
             ssd1306_drawlogo();
             switch(reset_mode) {
-				case RESET_RESET:
+				case RESET_DEFAULTS:
+				{
-					ssd1306_drawstring("-> reset     ", 1, 40);
+					ssd1306_drawstring("-> defaults   ", 1, 40);
 				} break;
                 case RESET_BOOTLOADER:
+                {
                     ssd1306_drawstring("-> bootloader", 1, 40);
                 } break;
                 case RESET_REBOOT:
+                {
                     ssd1306_drawstring("-> reboot     ", 1, 40);
                 } break;
                 case RESET_EXIT:
+                {
                     ssd1306_drawstring("-> exit      ", 1, 40);
                 } break;
+            }
             // Button handler
             if(SW_BTN_PRESSED) {
                 switch(reset_mode) {
                     case RESET_BOOTLOADER:
+                    {
                         ssd1306_clearscreen();
                         ssd1306_drawstring("Bootloader Entered", 0, 0);
                         ssd1306_drawstring("Device won't boot", 2, 0);
                         ssd1306_drawstring("until reflashed!", 3, 0);
                         HAL_Delay(1000);
                         bootloader_enter(); // Resets into bootloader
                         status->state = STATE_RESET; // Just in case
                     } break;
-                    case RESET_RESET:
+                    case RESET_DEFAULTS:
+                    {
                         status->state = STATE_RESET;
                         flash_load_defaults(set);
                         flash_save(set);
                         NVIC_SystemReset();
                     } break;
                     case RESET_REBOOT:
+                    {
                         status->state = STATE_RESET;
                         NVIC_SystemReset();
                     } break;
                     case RESET_EXIT:
+                    {
                         status->state = STATE_IDLE;
                     } break;
+                }
+            }
             else if(SW_DOWN_PRESSED && reset_mode < (RESET_SIZE-1)) {
                 reset_mode++;
+            }
             else if(SW_UP_PRESSED && reset_mode > 0) {
                 reset_mode--;
+            }
             // Event Handler
             // 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 = MODE_HEAT;
         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;
 // Draw current setpoint on display
 static 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);
+    }
     if(trigger_drawsetpoint)
         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);
+    }
     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];
 #define MAGIC_NUMBER 0x0BAE
 static void __flash_write(therm_settings_t* tosave);
 #define EEPROM_MAGIC_INDEX 0
 #define EEPROM_MAGIC_VALUE 0xbeef
 void flash_save(therm_settings_t* tosave)
+{
     __flash_write(tosave);
+}
 void flash_restore(therm_settings_t* torestore)
+{
     if(eeprom[EEPROM_MAGIC_INDEX] == EEPROM_MAGIC_VALUE)
 	//read flash and calculate checksum
 	uint16_t checksum = MAGIC_NUMBER;
 	uint16_t i;
     for(i = 0; i < (sizeof(therm_settings_t)/2); i++)
+    {
         for(uint8_t i = 1; i <= 20; i++) {
             torestore->data[i] = *(eeprom+i);
 		torestore->data[i] = eeprom[i];
 		checksum ^= torestore->data[i];
+        }
+    }
     else {
         // load default settings
     //if checksum doesn't match, load default settings
     if((checksum ^ eeprom[i+1]) != 0) {
     	flash_load_defaults(torestore);
+    }
+}
 void flash_load_defaults(therm_settings_t* torestore) {
 	torestore->val.boottobrew = DEFAULT_BOOT_TO_BREW;
 	torestore->val.temp_units = DEFAULT_TEMP_UNITS;
 	torestore->val.windup_guard = DEFAULT_WINDUP_GUARD;
 	torestore->val.k_p = DEFAULT_K_P;
 	torestore->val.k_i = DEFAULT_K_I;
 	torestore->val.k_d = DEFAULT_K_D;
 	torestore->val.temp_offset = DEFAULT_TEMP_OFFSET;
 	torestore->val.ignore_error = DEFAULT_IGNORE_ERROR;
 	torestore->val.setpoint_brew = DEFAULT_SETPOINT_BREW;
 	torestore->val.setpoint_steam = DEFAULT_SETPOINT_STEAM;
+}
 static void __flash_write(therm_settings_t* tosave)
+{
     // Erase mem
     HAL_FLASH_Unlock();
     //TODO: add checksum instead of magic value
     //TODO: change checksum to invalidate flash instead of erase?
     // Erase the FLASH pages
     FLASH_EraseInitTypeDef erase;
     erase.TypeErase = TYPEERASE_PAGES;
     erase.PageAddress = (uint32_t) eeprom;
     erase.NbPages = 1;
     uint32_t SectorError = 0;
     HAL_FLASHEx_Erase(&erase, &SectorError);
     CLEAR_BIT(FLASH->CR, FLASH_CR_PER);
     for(uint8_t i = 1; i <= (sizeof(therm_settings_t)/2); i++)
     // write to flash and calculate the checksum
     uint16_t checksum = MAGIC_NUMBER;
     uint16_t i;
     for(i = 0; i < (sizeof(therm_settings_t)/2); i++)
+	{
     	HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, (uint32_t)(eeprom + i), tosave->data[i]);
 		HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, (uint32_t)&eeprom[i], tosave->data[i]);
     	checksum ^= tosave->data[i];
+	}
     HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, (uint32_t)(eeprom + EEPROM_MAGIC_INDEX), EEPROM_MAGIC_VALUE);
     // write the checksum
     HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, (uint32_t)&eeprom[i+1], checksum);
     HAL_FLASH_Lock();
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

flash.h

➞

Show inline comments

 #ifndef FLASH_H
 #define FLASH_H
 #include "states.h"
 #include "stm32f0xx_hal_flash.h"
 #define PAGE_SIZE ((uint16_t)0x400)
 #define END_ADDR 0x08007FFF
 void flash_save(therm_settings_t* tosave);
 void flash_restore(therm_settings_t* tosave);
 void flash_load_defaults(therm_settings_t* torestore);
 void flash_erase(void);
 #endif

ssd1306.c

➞

Show inline comments

 #include "stm32f0xx_hal_conf.h"
 #include "ssd1306.h"
 // Write command to OLED
 static void WriteCommand(unsigned char command)
+{
   SSD_CS_Low();
   SSD_A0_Low();
   SPI_SendByte(command);
   SSD_CS_High();
+}
 // Write data to OLED
 static void WriteData(unsigned char data)
+{
   SSD_CS_Low();
   SSD_A0_High();
   SPI_SendByte(data);
   SSD_CS_High();
+}
 // Initialize OLED
 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)
   WriteCommand(0xDA); // setcompins
   WriteCommand(0x02);
   WriteCommand(0x81); // contrast
   WriteCommand(0x0F); // contrast value. 8f is a good one.
   WriteCommand(0xD9);
   WriteCommand(0xF1); //22 or F1 if not externalvcc
   WriteCommand(0xDB);
   WriteCommand(0x40);
   WriteCommand(0xA4); // dispalyallon_resume
   WriteCommand(0xA6); // normaldisplay
   WriteCommand(0xAF); // display on
+}
 // Times New Roman font
 static const char fontData[][5] =
 {                                       // Refer to "Times New Roman" Font Database
                                         //   Basic Characters
     {0x00,0x00,0x00,0x00,0x00},         //   (  0)    - 0x0020 No-Break Space
     {0x00,0x00,0x4F,0x00,0x00},         //   (  1)  ! - 0x0021 Exclamation Mark
     {0x00,0x07,0x00,0x07,0x00},         //   (  2)  " - 0x0022 Quotation Mark
     {0x14,0x7F,0x14,0x7F,0x14},         //   (  3)  # - 0x0023 Number Sign
     {0x24,0x2A,0x7F,0x2A,0x12},         //   (  4)  $ - 0x0024 Dollar Sign
     {0x23,0x13,0x08,0x64,0x62},         //   (  5)  % - 0x0025 Percent Sign
     {0x36,0x49,0x55,0x22,0x50},         //   (  6)  & - 0x0026 Ampersand
     {0x00,0x05,0x03,0x00,0x00},         //   (  7)  ' - 0x0027 Apostrophe
     {0x00,0x1C,0x22,0x41,0x00},         //   (  8)  ( - 0x0028 Left Parenthesis
     {0x00,0x41,0x22,0x1C,0x00},         //   (  9)  ) - 0x0029 Right Parenthesis
     {0x14,0x08,0x3E,0x08,0x14},         //   ( 10)  * - 0x002A Asterisk
     {0x08,0x08,0x3E,0x08,0x08},         //   ( 11)  + - 0x002B Plus Sign
     {0x00,0x50,0x30,0x00,0x00},         //   ( 12)  , - 0x002C Comma
     {0x08,0x08,0x08,0x08,0x08},         //   ( 13)  - - 0x002D Hyphen-Minus
     {0x00,0x60,0x60,0x00,0x00},         //   ( 14)  . - 0x002E Full Stop
     {0x20,0x10,0x08,0x04,0x02},         //   ( 15)  / - 0x002F Solidus
     {0x3E,0x51,0x49,0x45,0x3E},         //   ( 16)  0 - 0x0030 Digit Zero
     {0x00,0x42,0x7F,0x40,0x00},         //   ( 17)  1 - 0x0031 Digit One
     {0x42,0x61,0x51,0x49,0x46},         //   ( 18)  2 - 0x0032 Digit Two
     {0x21,0x41,0x45,0x4B,0x31},         //   ( 19)  3 - 0x0033 Digit Three
     {0x18,0x14,0x12,0x7F,0x10},         //   ( 20)  4 - 0x0034 Digit Four
     {0x27,0x45,0x45,0x45,0x39},         //   ( 21)  5 - 0x0035 Digit Five
     {0x3C,0x4A,0x49,0x49,0x30},         //   ( 22)  6 - 0x0036 Digit Six
     {0x01,0x71,0x09,0x05,0x03},         //   ( 23)  7 - 0x0037 Digit Seven
     {0x36,0x49,0x49,0x49,0x36},         //   ( 24)  8 - 0x0038 Digit Eight
     {0x06,0x49,0x49,0x29,0x1E},         //   ( 25)  9 - 0x0039 Dight Nine
     {0x00,0x36,0x36,0x00,0x00},         //   ( 26)  : - 0x003A Colon
     {0x00,0x56,0x36,0x00,0x00},         //   ( 27)  ; - 0x003B Semicolon
     {0x08,0x14,0x22,0x41,0x00},         //   ( 28)  < - 0x003C Less-Than Sign
     {0x14,0x14,0x14,0x14,0x14},         //   ( 29)  = - 0x003D Equals Sign
     {0x00,0x41,0x22,0x14,0x08},         //   ( 30)  > - 0x003E Greater-Than Sign
     {0x02,0x01,0x51,0x09,0x06},         //   ( 31)  ? - 0x003F Question Mark
     {0x32,0x49,0x79,0x41,0x3E},         //   ( 32)  @ - 0x0040 Commercial At
     {0x7E,0x11,0x11,0x11,0x7E},         //   ( 33)  A - 0x0041 Latin Capital Letter A
     {0x7F,0x49,0x49,0x49,0x36},         //   ( 34)  B - 0x0042 Latin Capital Letter B
     {0x3E,0x41,0x41,0x41,0x22},         //   ( 35)  C - 0x0043 Latin Capital Letter C
     {0x7F,0x41,0x41,0x22,0x1C},         //   ( 36)  D - 0x0044 Latin Capital Letter D
     {0x7F,0x49,0x49,0x49,0x41},         //   ( 37)  E - 0x0045 Latin Capital Letter E
     {0x7F,0x09,0x09,0x09,0x01},         //   ( 38)  F - 0x0046 Latin Capital Letter F
     {0x3E,0x41,0x49,0x49,0x7A},         //   ( 39)  G - 0x0047 Latin Capital Letter G
     {0x7F,0x08,0x08,0x08,0x7F},         //   ( 40)  H - 0x0048 Latin Capital Letter H
     {0x00,0x41,0x7F,0x41,0x00},         //   ( 41)  I - 0x0049 Latin Capital Letter I
     {0x20,0x40,0x41,0x3F,0x01},         //   ( 42)  J - 0x004A Latin Capital Letter J
     {0x7F,0x08,0x14,0x22,0x41},         //   ( 43)  K - 0x004B Latin Capital Letter K
     {0x7F,0x40,0x40,0x40,0x40},         //   ( 44)  L - 0x004C Latin Capital Letter L
     {0x7F,0x02,0x0C,0x02,0x7F},         //   ( 45)  M - 0x004D Latin Capital Letter M
     {0x7F,0x04,0x08,0x10,0x7F},         //   ( 46)  N - 0x004E Latin Capital Letter N
     {0x3E,0x41,0x41,0x41,0x3E},         //   ( 47)  O - 0x004F Latin Capital Letter O
     {0x7F,0x09,0x09,0x09,0x06},         //   ( 48)  P - 0x0050 Latin Capital Letter P
     {0x3E,0x41,0x51,0x21,0x5E},         //   ( 49)  Q - 0x0051 Latin Capital Letter Q
     {0x7F,0x09,0x19,0x29,0x46},         //   ( 50)  R - 0x0052 Latin Capital Letter R
     {0x46,0x49,0x49,0x49,0x31},         //   ( 51)  S - 0x0053 Latin Capital Letter S
     {0x01,0x01,0x7F,0x01,0x01},         //   ( 52)  T - 0x0054 Latin Capital Letter T
     {0x3F,0x40,0x40,0x40,0x3F},         //   ( 53)  U - 0x0055 Latin Capital Letter U
     {0x1F,0x20,0x40,0x20,0x1F},         //   ( 54)  V - 0x0056 Latin Capital Letter V
     {0x3F,0x40,0x38,0x40,0x3F},         //   ( 55)  W - 0x0057 Latin Capital Letter W
     {0x63,0x14,0x08,0x14,0x63},         //   ( 56)  X - 0x0058 Latin Capital Letter X
     {0x07,0x08,0x70,0x08,0x07},         //   ( 57)  Y - 0x0059 Latin Capital Letter Y
     {0x61,0x51,0x49,0x45,0x43},         //   ( 58)  Z - 0x005A Latin Capital Letter Z
     {0x00,0x7F,0x41,0x41,0x00},         //   ( 59)  [ - 0x005B Left Square Bracket
     {0x02,0x04,0x08,0x10,0x20},         //   ( 60)  \ - 0x005C Reverse Solidus
     {0x00,0x41,0x41,0x7F,0x00},         //   ( 61)  ] - 0x005D Right Square Bracket
     {0x04,0x02,0x01,0x02,0x04},         //   ( 62)  ^ - 0x005E Circumflex Accent
     {0x40,0x40,0x40,0x40,0x40},         //   ( 63)  _ - 0x005F Low Line
     {0x01,0x02,0x04,0x00,0x00},         //   ( 64)  ` - 0x0060 Grave Accent
     {0x20,0x54,0x54,0x54,0x78},         //   ( 65)  a - 0x0061 Latin Small Letter A
     {0x7F,0x48,0x44,0x44,0x38},         //   ( 66)  b - 0x0062 Latin Small Letter B
     {0x38,0x44,0x44,0x44,0x20},         //   ( 67)  c - 0x0063 Latin Small Letter C
     {0x38,0x44,0x44,0x48,0x7F},         //   ( 68)  d - 0x0064 Latin Small Letter D
     {0x38,0x54,0x54,0x54,0x18},         //   ( 69)  e - 0x0065 Latin Small Letter E
     {0x08,0x7E,0x09,0x01,0x02},         //   ( 70)  f - 0x0066 Latin Small Letter F
     {0x06,0x49,0x49,0x49,0x3F},         //   ( 71)  g - 0x0067 Latin Small Letter G
     {0x7F,0x08,0x04,0x04,0x78},         //   ( 72)  h - 0x0068 Latin Small Letter H
     {0x00,0x44,0x7D,0x40,0x00},         //   ( 73)  i - 0x0069 Latin Small Letter I
     {0x20,0x40,0x44,0x3D,0x00},         //   ( 74)  j - 0x006A Latin Small Letter J
     {0x7F,0x10,0x28,0x44,0x00},         //   ( 75)  k - 0x006B Latin Small Letter K
     {0x00,0x41,0x7F,0x40,0x00},         //   ( 76)  l - 0x006C Latin Small Letter L
     {0x7C,0x04,0x18,0x04,0x7C},         //   ( 77)  m - 0x006D Latin Small Letter M
     {0x7C,0x08,0x04,0x04,0x78},         //   ( 78)  n - 0x006E Latin Small Letter N
     {0x38,0x44,0x44,0x44,0x38},         //   ( 79)  o - 0x006F Latin Small Letter O
     {0x7C,0x14,0x14,0x14,0x08},         //   ( 80)  p - 0x0070 Latin Small Letter P
     {0x08,0x14,0x14,0x18,0x7C},         //   ( 81)  q - 0x0071 Latin Small Letter Q
     {0x7C,0x08,0x04,0x04,0x08},         //   ( 82)  r - 0x0072 Latin Small Letter R
     {0x48,0x54,0x54,0x54,0x20},         //   ( 83)  s - 0x0073 Latin Small Letter S
     {0x04,0x3F,0x44,0x40,0x20},         //   ( 84)  t - 0x0074 Latin Small Letter T
     {0x3C,0x40,0x40,0x20,0x7C},         //   ( 85)  u - 0x0075 Latin Small Letter U
     {0x1C,0x20,0x40,0x20,0x1C},         //   ( 86)  v - 0x0076 Latin Small Letter V
     {0x3C,0x40,0x30,0x40,0x3C},         //   ( 87)  w - 0x0077 Latin Small Letter W
     {0x44,0x28,0x10,0x28,0x44},         //   ( 88)  x - 0x0078 Latin Small Letter X
     {0x0C,0x50,0x50,0x50,0x3C},         //   ( 89)  y - 0x0079 Latin Small Letter Y
     {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
 };
 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 */
 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++)
+    {
         setStartPage(page);
         setStartColumn(0);
         for(i = 0; i<128; i++)
+        {
             WriteData(0x00);
+        }
+    }
     WriteData(0x00);
+}
 void ssd1306_drawlogo()
+{
     uint8_t i = 0;
     setStartPage(3);
     setStartColumn(0);
     for(i = 0; i<32; i++)
+    {
         WriteData(row[0][i]);
+    }
     WriteData(0x00);
     setStartPage(2);
     setStartColumn(0);
     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)
+{
     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)
+{
     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
         WriteData(data);
         WriteData(data);
         srcPointer++;
+    }
     WriteData(0x00);
     srcPointer -= 5;
     setStartPage(row);
     setStartColumn(xPos);
     // Write second row
     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)
+{
     char *srcPointer;
     srcPointer = (char*)dataPtr;
     ssd1306_drawchar(' ',row,xPos); // NBSP must be written first before the string start
     while(1)
+    {
         ssd1306_drawchar(*srcPointer,row,xPos);
         srcPointer++;
         xPos+=6;
         if(*srcPointer == 0) break;
+    }
+}
 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
     while(1)
+    {
         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)
 // EMZ FIXME this won't really work
 #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);
 #include "stm32f0xx_hal_conf.h"
 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

states.h

➞

Show inline comments

 #ifndef STATES_H
 #define STATES_H
 #include "stm32f0xx_hal.h"
 #include "config.h"
 typedef struct {
     int32_t temp;
     uint8_t temp_frac;
     uint8_t state_resume;
     uint8_t state;
     int32_t setpoint;
     uint8_t pid_enabled;
     uint8_t error_code;
 } therm_status_t;
 typedef union
+{
      struct {
         uint32_t boottobrew;
         uint32_t temp_units;
         uint32_t windup_guard;
         uint32_t k_p;
         uint32_t k_i;
         uint32_t k_d;
         int32_t temp_offset;
         uint32_t ignore_error;
         int32_t setpoint_brew;
         int32_t setpoint_steam;
     } val;
     uint16_t data[128];
 } therm_settings_t;
 enum tempunits {
     TEMP_UNITS_CELSIUS = 0,
     TEMP_UNITS_FAHRENHEIT,
 };
 enum state {
     STATE_IDLE = 0,
     STATE_SETP,
     STATE_SETI,
     STATE_SETD,
     STATE_SETSTEPS,
     STATE_SETWINDUP,
     STATE_SETBOOTTOBREW,
     STATE_SETUNITS,
     STATE_SETTEMPOFFSET,
     STATE_PREHEAT,
     STATE_MAINTAIN,
     STATE_TC_ERROR,
 	STATE_RESET,
 };
 enum GOTO_MODE {
 	#ifdef BOOTLOADER_SHORTCUT
 	MODE_BOOTLOADER,
 	#endif
 	MODE_HEAT,
 	MODE_SETUP,
 	MODE_RESET,
 	MODE_SIZE,
 };
 enum RESET_MODE {
 	RESET_RESET = 0,
 	RESET_REBOOT = 0,
 	RESET_DEFAULTS,
 	RESET_BOOTLOADER,
 	RESET_EXIT,
 	RESET_SIZE,
 };
 #endif

0 comments (0 inline, 0 general)