therm-ng Changeset - f602474ad6c6 · protofusion repositories

Changeset - f602474ad6c6

Parent rev.

Child rev.

[Not reviewed]

default

0 4 2

Ethan Zonca (ethanzonca) - 8 years ago 2017-06-26 18:19:08
e@ethanzonca.com

Initial work on max31856 driver, etc

6 files changed with 129 insertions and 2 deletions:

inc/states.h

lib/max31856/max31856.c

lib/max31856/max31856.h

src/display.c

src/pid.c

src/tempsense.c

0 comments (0 inline, 0 general)

inc/states.h

➞

Show inline comments

 #ifndef STATES_H
 #define STATES_H
 #include "stm32f3xx_hal.h"
 #include "config.h"
 typedef struct {
     float temp;
     uint8_t state_resume;
     uint8_t state;
     float 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;
         uint32_t control_mode;
         uint32_t sensor_type;
         uint32_t plant_type;
         uint32_t hysteresis;
     } val;
     uint16_t data[128];
 } therm_settings_t;
 enum tempunits {
     TEMP_UNITS_CELSIUS = 0,
     TEMP_UNITS_FAHRENHEIT,
 };
 enum state {
     STATE_IDLE = 0,
 	STATE_SETSENSORTYPE,
     STATE_SETMODE,
     STATE_SETPLANTTYPE,
     STATE_SETHYSTERESIS,
     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 control_mode {
     MODE_PID = 0,
     MODE_THERMOSTAT,
 };
 enum plant_type {
     PLANT_HEATER = 0,
     PLANT_COOLER,
 };
 enum GOTO_MODE {
 	#ifdef BOOTLOADER_SHORTCUT
 	MODE_BOOTLOADER,
 	#endif
 	MODE_HEAT,
 	MODE_SETUP,
 	MODE_RESET,
 	MODE_SIZE,
 };
 enum RESET_MODE {
 	RESET_REBOOT = 0,
 	RESET_DEFAULTS,
 	RESET_BOOTLOADER,
 	RESET_EXIT,
 	RESET_SIZE,
 };
 enum SENSOR_TYPE {
 	SENSOR_NTC = 0,
 	SENSOR_TC_K,
 	SENSOR_TC_E,
 	SENSOR_TC_N,
 	SENSOR_TC_R,
 	SENSOR_TC_S,
 	SENSOR_TC_T,
 };
 #endif

lib/max31856/max31856.c

➞

Show inline comments

@@ new file 100644 @@
 //
 // MAX31856: Driver to configure and read temperature from the MAX31856 thermoouple-to-Digital IC
 //
 #include "max31856.h"
 #include "states.h"
 // Private variables
 static float temp_latest = 0.0;
 static float temp_avg = 0.0;
 static SPI_HandleTypeDef* spiport;
 // Initialize the MAX31856 driver
 void max31856_init(SPI_HandleTypeDef* spi_port, GPIO_TypeDef* cs_port, uint32_t cs_pin, uint32_t sensor_type)
+{
 	// Set SPI port reference
 	spiport = spi_port;
 	// Configure the CS pin for output
 	GPIO_InitTypeDef GPIO_InitStruct;
 	GPIO_InitStruct.Pin = cs_pin;
 	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 	GPIO_InitStruct.Pull = GPIO_NOPULL;
 	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 	HAL_GPIO_Init(cs_port, &GPIO_InitStruct);
 	// MAX31856
 	// - set to continuous conversion mode
 	// - probably no filtering, we'll do that on this side of things
 	// - set up to read the typical open/short faults but not the high/low alarms
 	uint8_t data[] = {0,0,0,0};
 	HAL_SPI_Transmit(spiport, data, 1, 100);
 	// sensor type - could we just mask bits off? maybe optimize the enum for this
+}
 void max31856_process(void)
+{
 	// Read temperature from the MAX31856 (approx 10hz optimally)
 	uint8_t data[] = {0,0,0,0};
 	HAL_SPI_Transmit(spiport, data, 1, 100);
+}
 // Return latest temperature reading (unaveraged, deg C)
 float max31856_latest_temp(void)
+{
 	return temp_latest;
+}
 // Return average temperature reading (deg C)
 float max31856_avg_temp(void)
+{
 	return temp_latest;
+}

lib/max31856/max31856.h

➞

Show inline comments

@@ new file 100644 @@
 #ifndef MAX31856_H
 #define MAX31856_H
 #include "stm32f3xx_hal.h"
 #endif

src/display.c

➞

Show inline comments

@@ @@ -21,227 +21,253 @@ 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 int16_t last_temp_frac = 21245;
 static int16_t last_state = 123;
 static uint8_t goto_mode = MODE_HEAT;
 static uint8_t reset_mode = RESET_REBOOT;
 // Display state machine
 void display_process(void)
+{
 	therm_status_t* status = runtime_status();
 	therm_settings_t* set = flash_getsettings();
     uint8_t state_changed = status->state != last_state;
     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 || state_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);
+            }
             if (state_changed) {
             	ssd1306_drawlogo();
+            }
             switch(goto_mode) {
                 case MODE_HEAT:
+                {
                     if(set->val.plant_type == PLANT_HEATER)
                         ssd1306_drawstring("-> heat     ", 1, 40);
                     else
                         ssd1306_drawstring("-> cool     ", 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_SETMODE;
+                        status->state = STATE_SETSENSORTYPE;
                         break;
                     case MODE_RESET:
                         status->state = STATE_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_SETSENSORTYPE:
+        {
             // Write text to OLED
             // [ therm :: set mode ]
             // [ m =          ]
             ssd1306_drawstring("Sensor Type", 0, 40);
             ssd1306_drawlogo();
             // change scope to global?
             char* sensor_lookup[] = {"NTC", "K  ", "E  ", "N  ", "R  ", "S  ", "T  "};
 			ssd1306_drawstring(sensor_lookup[set->val.sensor_type], 1, 60);
             ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETMODE;
+            }
             else
+            {
             	user_input((uint16_t*)&set->val.hysteresis);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETMODE:
+        {
             // Write text to OLED
             // [ therm :: set mode ]
             // [ m =          ]
             ssd1306_drawstring("Control Mode", 0, 40);
             ssd1306_drawlogo();
             if(set->val.control_mode == MODE_PID)
                 ssd1306_drawstring("PID       ", 1, 60);
             else
                 ssd1306_drawstring("Thermostat", 1, 60);
             ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 status->state = STATE_SETPLANTTYPE;
+            }
             else if (!HAL_GPIO_ReadPin(SW_UP)) {
                 set->val.control_mode = MODE_PID;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->val.control_mode = MODE_THERMOSTAT;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETPLANTTYPE:
+        {
             // Write text to OLED
             // [ therm :: set mode ]
             // [ m =          ]
             ssd1306_drawstring("Plant Type", 0, 40);
             ssd1306_drawlogo();
             if(set->val.plant_type == PLANT_HEATER)
                 ssd1306_drawstring("Heater", 1, 60);
             else
                 ssd1306_drawstring("Cooler", 1, 60);
             ssd1306_drawstring("Press to accept", 3, 40);
             // Button handler
             if(SW_BTN_PRESSED) {
                 if(set->val.control_mode == MODE_PID)
                     status->state = STATE_SETP;
                 else
                     status->state = STATE_SETHYSTERESIS;
+            }
             else if (!HAL_GPIO_ReadPin(SW_UP)) {
                 set->val.plant_type = PLANT_COOLER;
+            }
             else if(!HAL_GPIO_ReadPin(SW_DOWN)) {
                 set->val.plant_type = PLANT_HEATER;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETHYSTERESIS:
+        {
             // Write text to OLED
             ssd1306_drawstring("Hysteresis", 0, 40);
             ssd1306_drawlogo();
             char tempstr[6];
             itoa(set->val.hysteresis, tempstr, 10);
             ssd1306_drawstring("H=", 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((uint16_t*)&set->val.hysteresis);
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETP:
+        {

src/pid.c

➞

Show inline comments

 //
 // PID: proportional/integral/derivative controller
 //
 #include "pid.h"
 #include "flash.h"
 // PID implementation
 static pid_state_t state;
 void pid_init()
+{
 	state.i_state = 0;
 	state.last_pid_temp = 0;
 	state.last_pid_temp_frac = 0;
+}
 float pid_process(void)
+{
 //            #ifdef MAX31865_RTD_SENSOR
 //            max31865_readtemp(spi_get(), &set, &status);
 //			#else
 //			max31855_readtemp(spi_get(), &set, &status); // Read MAX31855
 //			#endif
 		float ssr_output = 0;
 		if(runtime_status()->pid_enabled)
+		{
 			// Get ssr output for next time
 			int16_t power_percent = pid_update();
 			if(flash_getsettings()->val.plant_type == PLANT_HEATER)
 				power_percent *= -1;
 			//power-percent is 0-1000?
 			ssr_output = power_percent; //(((uint32_t)SSR_PERIOD * (uint32_t)10 * (uint32_t)100) * power_percent) / (uint32_t)1000000;
 			// put ssr output on display
 			ssd1306_drawstring("      ", 0, 90); //fixme: this is bad, but I can't get the old digits to clear otherwise
 			char tempstr[6];
 			itoa(ssr_output, tempstr, 10);
 			ssd1306_drawstring(tempstr, 0, 90);
+		}
 		else
+		{
 			ssr_output = 0.0;
+		}
 		return ssr_output;
+}
 int16_t pid_update(void)
+{
 	therm_status_t* status = runtime_status();
 	therm_settings_t* set = flash_getsettings();
   // Convert temperature to fixed point number with 1/10th resolution
   float temp = status->temp;
   // Calculate instantaneous error
   int16_t error = status->setpoint * 10 - temp; // TODO: Use fixed point fraction
   // Proportional component
   int32_t p_term = set->val.k_p * error;
   // Error accumulator (integrator)
   state.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->val.windup_guard * 10) / set->val.k_i;
   // Calculate integral term with windup guard
   if (state.i_state > windup_guard_res)
 	  state.i_state = windup_guard_res;
   else if (state.i_state < -windup_guard_res)
 	  state.i_state = -windup_guard_res;
   int32_t i_term = set->val.k_i * state.i_state;
   // Calculate differential term (slope since last iteration)
   int32_t d_term = (set->val.k_d * (temp - state.last_pid_temp));
   // Save temperature for next iteration
   state.last_pid_temp = temp;
   int16_t result = (p_term + i_term - d_term) / 10;
   // Put out tenths of percent, 0-1000.
   if(result > 1000)
     result = 1000;
   else if(result < -1000)
     result = -1000;
   // Return feedback
   return result;
+}

src/tempsense.c

➞

Show inline comments

 //
 // TempSense: read temperature from TC, RTD, or NTC
 //
 #include "tempsense.h"
 #include "flash.h"
 void tempsense_init(void)
+{
 	// Maybe don't perform temp sensor setup in here, but in readtemp?
 	// what happens if the user changes the tempsense type while running?
 	// we need to re-init...
+}
 // Returns the latest reading from the configured temperature sensor
 float tempsense_readtemp(void)
+{
 	// TODO: Support multiple temperature sensors
 	switch(flash_getsettings()->val.sensor_type)
+	{
 		case SENSOR_TC_K:
 		case SENSOR_TC_E:
 		case SENSOR_TC_N:
 		case SENSOR_TC_R:
 		case SENSOR_TC_S:
 		case SENSOR_TC_T:
+		{
 			// Read MAX31856
 		} break;
 		case SENSOR_NTC:
+		{
 			// Read analog value from internal ADC, linearize the reading, etc
 		} break;
+	}
 	// either return latest reading from DMA loop (NTC, etc)
 	// or initiate a blocking read and return it.
 	// Need to gracefully handle the timeout...
+}

0 comments (0 inline, 0 general)