therm Changeset - 3dc8ab4e2928 · protofusion repositories

Changeset - 3dc8ab4e2928

Parent rev.

Child rev.

[Not reviewed]

cortex-f0

0 3 0

Ethan Zonca - 9 years ago 2015-06-15 21:07:11
ez@ethanzonca.com

Fix stupid thermocouple error issue finally. Temporarily disable CDC transmit. Move PID calcs into a different loop for fun and profit.

3 files changed with 47 insertions and 20 deletions:

config.h

display.c

main.c

0 comments (0 inline, 0 general)

config.h

➞

Show inline comments

 #ifndef CONFIG_H
 #define CONFIG_H
 #define VCP_TX_FREQ 1000
 #define SSR_PERIOD 200
 #define PID_PERIOD 200
 #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
 #endif
 // vim:softtabstop=4 shiftwidth=4 expandtab

display.c

➞

Show inline comments

@@ @@ -116,461 +116,468 @@ void display_process(therm_settings_t* s @@
                         bootloader_enter(); // Resets into bootloader
                         status->state = STATE_IDLE; // Just in case
                     } 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_drawlogo();
             char tempstr[6];
             itoa(set->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->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->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->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->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->k_d);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETSTEPS:
+        {
             // Write text to OLED
             // [ step #1:: Duration: ### ]
             // [           Setpoint: ### ]
             char tempstr[6];
             itoa(final_setpoint, tempstr, 10);
             ssd1306_DrawString("Step #", 0, 0);
             ssd1306_DrawString(tempstr, 0, 40);
             ssd1306_DrawString("Duration: ", 0, 5);
             itoa(step_duration[final_setpoint], tempstr, 10);
             ssd1306_DrawString(tempstr, 0, 70);
             ssd1306_DrawString("Setpoint: ", 0, 0);
             itoa(step_setpoint[final_setpoint], tempstr, 10);
             ssd1306_DrawString(tempstr, 0, 70);
             ssd1306_DrawString("Press to accept", 3, 40);
             // Button handler - TODO: increment max_step if pressed
             // return and go to next state otherwise
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETSTEPS;
                 final_setpoint++;
+            }
         //    else if(SW_LEFT_PRESSED) {
         //        state++; // go to next state or something
         //    }
             else {
                 user_input(&set->k_p);
+            }
             // 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->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->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->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->boottobrew = 1;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->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->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->temp_units = TEMP_UNITS_FAHRENHEIT;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->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->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->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_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->setpoint_brew;
             // Button handler
             if(SW_BTN_PRESSED) {
 		save_setpoints(&set); // TODO: Check for mod
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->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_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->setpoint_brew;
             // Button handler
             if(SW_BTN_PRESSED) {
 		save_setpoints(&set); // TODO: Check for mod
                 status->state = STATE_IDLE;
+            }
             else {
                 user_input(&set->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_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->setpoint_steam;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
 		save_setpoints(&set); // TODO: Check for mod
+            }
             else {
                 user_input(&set->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_drawlogo();
             draw_setpoint(status);
             status->pid_enabled = 1;
 	    status->setpoint = set->setpoint_steam;
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_IDLE;
 		save_setpoints(&set); // TODO: Check for mod
+            }
             else {
                 user_input(&set->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);
             char tempstr[6];
             itoa(status->tc_errno, tempstr, 10);
             ssd1306_DrawString(tempstr, 0, 57);
             if(status->tc_errno == 1)
-                ssd1306_DrawString("    Check Sensor (1)", 1, 0);
+                ssd1306_DrawString("    TC Open Circuit", 1, 0);
             else if(status->tc_errno == 4)
                 ssd1306_DrawString("    Check Sensor (2)", 1, 0);
                 ssd1306_DrawString("    TC Short to GND", 1, 0);
             else if(status->tc_errno == 8)
                 ssd1306_DrawString("    TC Short to VCC", 1, 0);
             else
                 ssd1306_DrawString("#?, Unknown Error", 1, 0);
             ssd1306_DrawString("                    ", 2, 0);
             ssd1306_DrawString("Press -> to ignore", 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->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;
+}
 int32_t temp_last = 43002;
 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);
+    }
     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

main.c

➞

Show inline comments

 #include "stm32f0xx_hal.h"
 #include "config.h"
 #include "states.h"
 #include "ssd1306.h"
 #include "gpio.h"
 #include "spi.h"
 #include "flash.h"
 #include "stringhelpers.h"
 #include "display.h"
 #include "storage.h"
 #include "usb_device.h"
 #include "usbd_cdc_if.h"
 // Prototypes
 // Move to header file
 void process();
 void SystemClock_Config(void);
 therm_settings_t set;
 therm_status_t status;
 // Globalish setting vars
 SPI_HandleTypeDef hspi1;
 static __IO uint32_t TimingDelay;
 void deinit(void)
+{
     HAL_DeInit();
+}
 volatile int i=0;
 int main(void)
+{
     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
     HAL_Init();
     /* Configure the system clock */
     SystemClock_Config();
     /* Unset bootloader option bytes (if set) */
     void bootloader_unset(void);
     /* Initialize all configured peripherals */
     init_gpio();
     MX_USB_DEVICE_Init();
 //    set.usb_plugged =
     // USB startup delay
     HAL_Delay(1000);
     HAL_GPIO_WritePin(LED_POWER, 1);
     if(!HAL_GPIO_ReadPin(SW_UP))
         bootloader_enter(); // Resets into bootloader
     // TODO: Awesome pwm of power LED
     // Configure 1ms SysTick (change if more temporal resolution needed)
     //RCC_ClocksTypeDef RCC_Clocks;
     //RCC_GetClocksFreq(&RCC_Clocks);
     //SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);
     // Init SPI busses
     init_spi();
     // Init OLED over SPI
     ssd1306_Init();
     ssd1306_clearscreen();
     // Default settings
     set.boottobrew = 0;
     set.temp_units = TEMP_UNITS_CELSIUS;
     set.windup_guard = 1;
     set.k_p = 1;
     set.k_i = 1;
     set.k_d = 1;
     set.ignore_tc_error = 0;
     set.setpoint_brew = 0;
     set.setpoint_steam = 0;
     // Default status
     status.temp = 0;
     status.temp_frac = 0;
     status.state_resume = 0;
     status.state = STATE_IDLE;
     status.setpoint = 0;
     status.pid_enabled = 0;
     // Load settings (if any) from EEPROM
     restore_settings(&set);
     // Go to brew instead of idle if configured thusly
     if(set.boottobrew)
       status.state = STATE_PREHEAT_BREW;
     // Startup screen
     ssd1306_DrawString("therm v0.2", 1, 40);
     ssd1306_DrawString("protofusion.org/therm", 3, 0);
     HAL_Delay(1500);
     flash_init(&set);
     HAL_Delay(1500);
     ssd1306_clearscreen();
     // Main loop
     while(1)
+    {
         // Process sensor inputs
         process();
         // Run state machine
         display_process(&set, &status);
+    }
+}
 // Clock configuration
 void SystemClock_Config(void)
+{
   RCC_OscInitTypeDef RCC_OscInitStruct;
   RCC_ClkInitTypeDef RCC_ClkInitStruct;
   RCC_PeriphCLKInitTypeDef PeriphClkInit;
   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;
   RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
   HAL_RCC_OscConfig(&RCC_OscInitStruct);
   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI48;
   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1);
   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
   PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_HSI48;
   HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
   __SYSCFG_CLK_ENABLE();
+}
 // Grab temperature reading from MAX31855
 void update_temp() {
     // Assert CS
     HAL_GPIO_WritePin(MAX_CS, 0);
     uint8_t rxdatah[1] = {0x00};
     uint8_t rxdatal[1] = {0x00};
     HAL_SPI_Receive(&hspi1, rxdatah, 1, 100);
     HAL_SPI_Receive(&hspi1, rxdatal, 1, 100);
     // Release CS
     HAL_GPIO_WritePin(MAX_CS, 1);
     // Assemble data array into one var
     uint16_t temp_pre = rxdatal[0] | (rxdatah[0]<<8);
     if(temp_pre & 0b0000000000000010) {
 /*
     if(temp_pre & 0b010) {
         ssd1306_clearscreen();
-        HAL_Delay(100); // FIXME: remove?
+        HAL_Delay(400); // FIXME: remove?
         status.tc_errno = 4;
         status.state = STATE_TC_ERROR;
         status.temp = 0;
         status.temp_frac = 0;
+    }
     else if(temp_pre & 0b0000000000000001 && !set.ignore_tc_error) {
     } */
     if(temp_pre & 0b001 && !set.ignore_tc_error) {
         status.tc_errno = 1;
-        HAL_Delay(100); // FIXME: remove?
+        HAL_Delay(400); // FIXME: remove?
         status.state_resume = status.state;
         status.state = STATE_TC_ERROR;
         status.temp = 0;
         status.temp_frac = 0;
+    }
     }/*
     else if(temp_pre & 0b100 && !set.ignore_tc_error) {
         status.tc_errno = 8;
         HAL_Delay(400); // FIXME: remove?
         status.state_resume = status.state;
         status.state = STATE_TC_ERROR;
         status.temp = 0;
         status.temp_frac = 0;
     }*/
     else
+    {
         if(status.state == STATE_TC_ERROR)
+        {
             status.state = status.state_resume;
             ssd1306_clearscreen();
+        }
         //if(status.state == STATE_TC_ERROR)
         //{
         //    status.state = status.state_resume;
         //    ssd1306_clearscreen();
         //}
         uint8_t sign = status.temp >> 15;// top bit is sign
         temp_pre = temp_pre >> 2; // Drop 2 lowest bits
         status.temp_frac = temp_pre & 0b11; // get fractional part
         status.temp_frac *= 25; // each bit is .25 a degree, up to fixed point
         temp_pre = temp_pre >> 2; // Drop 2 fractional bits
         int8_t signint;
         if(sign) {
             signint = -1;
+        }
         else {
             signint = 1;
+        }
         // Convert to Fahrenheit
         if(set.temp_units == TEMP_UNITS_FAHRENHEIT)
+        {
             status.temp = signint * ((temp_pre*100) + status.temp_frac);
             status.temp = status.temp * 1.8;
             status.temp += 3200;
             status.temp_frac = status.temp % 100;
             status.temp /= 100;
             status.temp += set.temp_offset;
+        }
         // Use Celsius values
         else
+        {
             status.temp = temp_pre * signint;
             status.temp += set.temp_offset;
+        }
+    }
+}
 // PID implementation
 // TODO: Make struct that has the last_temp and i_state in it, pass by ref. Make struct that has other input values maybe.
 int16_t last_pid_temp = 0;
 uint8_t last_pid_temp_frac = 0;
 int32_t i_state = 0;
 int16_t update_pid(uint16_t k_p, uint16_t k_i, uint16_t k_d, int16_t temp, uint8_t temp_frac, int16_t setpoint)
+{
   // Calculate instantaneous error
   int16_t error = setpoint - temp; // TODO: Use fixed point fraction
   // Proportional component
   int32_t p_term = k_p * error;
   // Error accumulator (integrator)
   i_state += error;
   // to prevent the iTerm getting huge from lots of
   //  error, we use a "windup guard"
   // (this happens when the machine is first turned on and
   // it cant help be cold despite its best efforts)
   // not necessary, but this makes windup guard values
   // relative to the current iGain
   int32_t windup_guard_res = set.windup_guard / k_i;
   // Calculate integral term with windup guard
   if (i_state > windup_guard_res)
     i_state = windup_guard_res;
   else if (i_state < -windup_guard_res)
     i_state = -windup_guard_res;
   int32_t i_term = k_i * i_state;
   // Calculate differential term (slope since last iteration)
   int32_t d_term = (k_d * (status.temp - last_pid_temp));
   // Save temperature for next iteration
   last_pid_temp = status.temp;
   last_pid_temp_frac = status.temp_frac;
   int16_t result = p_term + i_term - d_term;
   // Put out tenths of percent, 0-1000.
   if(result > 1000)
     result = 1000;
   else if(result < -1000)
     result = -1000;
   // Return feedback
   return result;
+}
 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
 // Turn SSR output on/off according to set duty cycle.
 // TODO: Eventually maybe replace with a very slow timer or something. Double-check this code...
 void process()
+{
     update_temp(); // Read MAX31855
     uint32_t ticks = HAL_GetTick();
     if(ticks - last_led > 400)
+    {
         HAL_GPIO_TogglePin(LED_POWER);
         last_led = ticks;
+    }
     // Every 200ms, set the SSR on unless output is 0
     if((ticks - last_ssr_on > SSR_PERIOD))
     if((ticks - last_pid > PID_PERIOD))
+    {
         update_temp(); // Read MAX31855
     HAL_GPIO_TogglePin(LED_POWER);
         if(status.pid_enabled)
+        {
             // Get ssr output for next time
             int16_t power_percent = update_pid(set.k_p, set.k_i, set.k_d, status.temp, status.temp_frac, status.setpoint);
             //power-percent is 0-1000
             ssr_output = power_percent; //(((uint32_t)SSR_PERIOD * (uint32_t)10 * (uint32_t)100) * power_percent) / (uint32_t)1000000;
+        }
         else
+        {
             ssr_output = 0;
+        }
         last_pid = ticks;
+    }
     // Every 200ms, set the SSR on unless output is 0
     if((ticks - 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);
             HAL_GPIO_WritePin(SSR_PIN, 1);
             last_ssr_on = ticks;
+        }
+    }
     // Kill SSR after elapsed period less than SSR_PERIOD
     if(ticks - last_ssr_on > ssr_output || ssr_output == 0)
+    {
         HAL_GPIO_WritePin(SSR_PIN, 0);
+    }
     if(ticks - 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';
         CDC_Transmit_FS(tempstr, numlen+2);
 //        if(set.usb_plugged)
 //            CDC_Transmit_FS(tempstr, numlen+2);
        // while(CDC_Transmit_FS("\r\n", 2) == USBD_BUSY);
         last_vcp_tx = ticks;
+    }
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

0 comments (0 inline, 0 general)