therm Changeset - f2990941d9d9 · protofusion repositories

Changeset - f2990941d9d9

Parent rev.

Child rev.

[Not reviewed]

cortex-f0

0 4 2

Ethan Zonca - 10 years ago 2015-06-01 16:48:26
ez@ethanzonca.com

Added untested jump-to-DFU using option bytes per ST forums. Should work, need to make sure the user program is run after DFU flash so the bits are unset

6 files changed with 71 insertions and 5 deletions:

Makefile

bootlib.c

bootlib.h

display.c

main.c

startup_stm32f042x6.s

0 comments (0 inline, 0 general)

Makefile

➞

Show inline comments

 # STM32F0xx Makefile
 # #####################################
+#
 # Part of the uCtools project
 # uctools.github.com
+#
 #######################################
 # user configuration:
 #######################################
 # SOURCES: list of sources in the user application
 SOURCES = main.c usbd_conf.c usbd_cdc_if.c usb_device.c usbd_desc.c stm32f0xx_hal_msp.c stm32f0xx_it.c system_stm32f0xx.c gpio.c spi.c ssd1306.c stringhelpers.c eeprom_min.c display.c
+SOURCES = main.c usbd_conf.c usbd_cdc_if.c usb_device.c usbd_desc.c stm32f0xx_hal_msp.c stm32f0xx_it.c system_stm32f0xx.c gpio.c spi.c ssd1306.c stringhelpers.c eeprom_min.c display.c bootlib.c
 # TARGET: name of the user application
 TARGET = main
 # BUILD_DIR: directory to place output files in
 BUILD_DIR = build
 # LD_SCRIPT: location of the linker script
 LD_SCRIPT = stm32f042c6_flash.ld
 # USER_DEFS user defined macros
 USER_DEFS = -D HSI48_VALUE=48000000 -D HSE_VALUE=16000000
 # USER_INCLUDES: user defined includes
 USER_INCLUDES =
 # USB_INCLUDES: includes for the usb library
 USB_INCLUDES = -Imiddlewares/ST/STM32_USB_Device_Library/Core/Inc
 USB_INCLUDES += -Imiddlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc
 # USER_CFLAGS: user C flags (enable warnings, enable debug info)
 USER_CFLAGS = -Wall -g -ffunction-sections -fdata-sections -Os
 # USER_LDFLAGS:  user LD flags
 USER_LDFLAGS = -fno-exceptions -ffunction-sections -fdata-sections -Wl,--gc-sections
 # TARGET_DEVICE: device to compile for
 TARGET_DEVICE = STM32F042x6
 #######################################
 # end of user configuration
 #######################################
+#
 #######################################
 # binaries
 #######################################
 CC = arm-none-eabi-gcc
 AR = arm-none-eabi-ar
 RANLIB = arm-none-eabi-ranlib
 SIZE = arm-none-eabi-size
 OBJCOPY = arm-none-eabi-objcopy
 MKDIR = mkdir -p
 #######################################
 # core and CPU type for Cortex M0
 # ARM core type (CORE_M0, CORE_M3)
 CORE = CORE_M0
 # ARM CPU type (cortex-m0, cortex-m3)
 CPU = cortex-m0
 # where to build STM32Cube
 CUBELIB_BUILD_DIR = $(BUILD_DIR)/STM32Cube
 # various paths within the STmicro library
 CMSIS_PATH = drivers/CMSIS
 CMSIS_DEVICE_PATH = $(CMSIS_PATH)/Device/ST/STM32F0xx
 DRIVER_PATH = drivers/STM32F0xx_HAL_Driver
 # includes for gcc
 INCLUDES = -I$(CMSIS_PATH)/Include
 INCLUDES += -I$(CMSIS_DEVICE_PATH)/Include
 INCLUDES += -I$(DRIVER_PATH)/Inc
 INCLUDES += -I$(CURDIR)
 INCLUDES += -I$(CURDIR)/usb
 INCLUDES += $(USB_INCLUDES)
 INCLUDES += $(USER_INCLUDES)
 # macros for gcc
 DEFS = -D$(CORE) $(USER_DEFS) -D$(TARGET_DEVICE)
 # compile gcc flags
 CFLAGS = $(DEFS) $(INCLUDES)
 CFLAGS += -mcpu=$(CPU) -mthumb
 CFLAGS += $(USER_CFLAGS)
 # default action: build the user application
 all: $(BUILD_DIR)/$(TARGET).hex
 #######################################
 # build the st micro peripherial library
 # (drivers and CMSIS)
 #######################################
 CUBELIB = $(CUBELIB_BUILD_DIR)/libstm32cube.a
 # List of stm32 driver objects
 CUBELIB_DRIVER_OBJS = $(addprefix $(CUBELIB_BUILD_DIR)/, $(patsubst %.c, %.o, $(notdir $(wildcard $(DRIVER_PATH)/Src/*.c))))
 # shortcut for building core library (make cubelib)
 cubelib: $(CUBELIB)
 $(CUBELIB): $(CUBELIB_DRIVER_OBJS)
 	$(AR) rv $@ $(CUBELIB_DRIVER_OBJS)
 	$(RANLIB) $@
 $(CUBELIB_BUILD_DIR)/%.o: $(DRIVER_PATH)/Src/%.c | $(CUBELIB_BUILD_DIR)
 	$(CC) -c $(CFLAGS) -o $@ $^
 $(CUBELIB_BUILD_DIR):
 	$(MKDIR) $@
 #######################################
 # build the USB library
 #######################################
 USB_MIDDLEWARE_PATH = ./middlewares/ST/STM32_USB_Device_Library/
 USB_BUILD_DIR = $(BUILD_DIR)/usb
 USB_SOURCES += usbd_ctlreq.c usbd_ioreq.c usbd_core.c usbd_cdc.c
 # list of usb library objects
 USB_OBJECTS += $(addprefix $(USB_BUILD_DIR)/,$(notdir $(USB_SOURCES:.c=.o)))
 usb: $(USB_OBJECTS)
 $(USB_BUILD_DIR)/%.o: $(USB_MIDDLEWARE_PATH)/Core/Src/%.c | $(USB_BUILD_DIR)
 	$(CC) -Os $(CFLAGS) -c -o $@ $^
 $(USB_BUILD_DIR)/%.o: $(USB_MIDDLEWARE_PATH)/Class/CDC/Src/%.c | $(USB_BUILD_DIR)
 	$(CC) -Os $(CFLAGS) -c -o $@ $^
 $(USB_BUILD_DIR):
 	@echo $(USB_BUILD_DIR)
 	$(MKDIR) $@
 #######################################
 # build the user application
 #######################################
 # list of user program objects
 OBJECTS = $(addprefix $(BUILD_DIR)/,$(notdir $(SOURCES:.c=.o)))
 # add an object for the startup code
 OBJECTS += $(BUILD_DIR)/startup_stm32f042x6.o
 # use the periphlib core library, plus generic ones (libc, libm, libnosys)
 LIBS = -lstm32cube -lc -lm -lnosys
 LDFLAGS = -T $(LD_SCRIPT) -L $(CUBELIB_BUILD_DIR) $(LIBS) $(USER_LDFLAGS)
 $(BUILD_DIR)/$(TARGET).hex: $(BUILD_DIR)/$(TARGET).elf
 	$(OBJCOPY) -O ihex $(BUILD_DIR)/$(TARGET).elf $@
 	$(OBJCOPY) -O binary $(BUILD_DIR)/$(TARGET).elf $(BUILD_DIR)/$(TARGET).bin
 $(BUILD_DIR)/$(TARGET).elf: $(OBJECTS) $(USB_OBJECTS) $(CUBELIB)
 	$(CC) -o $@ $(CFLAGS) $(USER_LDFLAGS) $(OBJECTS) $(USB_OBJECTS) \
 		-L$(CUBELIB_BUILD_DIR) -static $(LIBS) -Xlinker \
 		-Map=$(BUILD_DIR)/$(TARGET).map \
 		-T $(LD_SCRIPT)
 	$(SIZE) $@
 $(BUILD_DIR)/%.o: %.c | $(BUILD_DIR)
 	$(CC) $(CFLAGS) -Os -c -o $@ $^
 $(BUILD_DIR)/%.o: %.s | $(BUILD_DIR)
 	$(CC) $(CFLAGS) -c -o $@ $^
 $(BUILD_DIR):
 	$(MKDIR) $@
 # delete all user application files, keep the libraries
 clean:
 		-rm $(BUILD_DIR)/*.o
 		-rm $(BUILD_DIR)/*.elf
 		-rm $(BUILD_DIR)/*.bin
 		-rm $(BUILD_DIR)/*.map
 .PHONY: clean all cubelib

bootlib.c

➞

Show inline comments

@@ new file 100644 @@
 #include "stm32f0xx_hal.h"
 // Unset bootloader option bytes
 void bootloader_unset(void)
+{
     FLASH_OBProgramInitTypeDef OBParam;
     HAL_FLASHEx_OBGetConfig(&OBParam);
     if(OBParam.USERConfig != 0xFF)
+    {
         OBParam.OptionType = OPTIONBYTE_USER;
         OBParam.USERConfig = 0xFF;
         HAL_FLASH_Unlock();
         HAL_FLASH_OB_Unlock();
         HAL_FLASHEx_OBErase();
         HAL_FLASHEx_OBProgram(&OBParam);
         HAL_FLASH_OB_Lock();
         HAL_FLASH_OB_Launch();
+    }
+}
 // See thread: https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=https%3a%2f%2fmy.st.com%2fpublic%2fSTe2ecommunities%2fmcu%2fLists%2fcortex_mx_stm32%2fJump%20to%20USB%20DFU%20Bootloader%20in%20startup%20code%20on%20STM32F042&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=185
 // Set option bytes to enter bootloader upon reset
 void bootloader_enter(void) {
     FLASH_OBProgramInitTypeDef OBParam;
     HAL_FLASHEx_OBGetConfig(&OBParam);
     OBParam.OptionType = OPTIONBYTE_USER;
     /*Reset NBOOT0 and BOOT_SEL,  see: RM 2.5 Boot configuration*/
     OBParam.USERConfig = 0x77; //Sorry for magic number :)
     HAL_FLASH_Unlock();
     HAL_FLASH_OB_Unlock();
     HAL_FLASHEx_OBErase();
     HAL_FLASHEx_OBProgram(&OBParam);
     HAL_FLASH_OB_Lock();
     HAL_FLASH_Lock();
     HAL_FLASH_OB_Launch();
+}

bootlib.h

➞

Show inline comments

@@ new file 100644 @@
 #ifndef BOOTLIB_H
 #define BOOTLIB_H
 void bootloader_unset(void);
 void bootloader_enter(void);
 #endif

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 "bootlib.h"
 #include "gpio.h"
 uint8_t goto_mode = 2;
 // State machine
 uint8_t sw_btn_last = 0;
 uint8_t sw_up_last = 0;
 uint8_t sw_down_last = 0;
 uint8_t sw_left_last = 0;
 uint8_t sw_right_last = 0;
 #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)
 ///////////////////////////////////////////////////////////////////////////////////////
 /// freaking multiple setpoint support ///
 uint8_t step_duration[10] = {0,0,0,0,0,0,0,0,0,0};
 int16_t step_setpoint[10] = {0,0,0,0,0,0,0,0,0,0};
 uint8_t final_setpoint = 0;
 // Multiple screens to set setpoint and duration on each screen
 // press center to go to the next one, and press left or right or something to confirm
 // When executing, complete on time AND(?) temperature. Maybe allow switching to OR via settings
 ////////////////////////////////////////////////////////////////////////////////////////////////
 uint8_t trigger_drawsetpoint = 1;
 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);
             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 2:
+                {
                     ssd1306_DrawString("-> heat     ", 1, 40);
                 } break;
                 case 1:
+                {
                     ssd1306_DrawString("-> setup    ", 1, 40);
                 } break;
                 case 0:
+                {
                     ssd1306_DrawString("-> reset    ", 1, 40);
                 } break;
+            }
             // Button handler
             if(SW_BTN_PRESSED) {
                 switch(goto_mode) {
                     case 2:
                         status->state = STATE_PREHEAT_BREW;
                         break;
                     case 1:
                         status->state = STATE_SETP;
                         break;
                     case 0:
+                    {
                         ssd1306_clearscreen();
                         ssd1306_DrawString("Entering Bootloader", 1, 0);
                         ssd1306_DrawString("(hopefully)", 2, 0);
                         //HAL_Delay(1000);
                         HAL_Delay(1000);
                         bootloader_enter();
 /*
                         HAL_RCC_DeInit();
                         SysTick->CTRL = 0;
                         SysTick->LOAD = 0;
                         SysTick->VAL = 0;
                         __set_PRIMASK(1);
                         __set_MSP(0x200010000);
                         *((unsigned long *)0x200017F0) = 0xDEADBEEF; // 6KB STM32F042
                         NVIC_SystemReset();
+*/
                         status->state = STATE_IDLE;
                     } break;
                     default:
                         status->state = STATE_PREHEAT_BREW;
+                }
+            }
             else if(SW_UP_PRESSED && goto_mode < 2) {
                 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) {
                 save_settings();
                 status->state = STATE_IDLE;
+            }
             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_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(); // 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(); // 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(); // 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(); // 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);
             ssd1306_DrawString("Connect thermocouple", 1, 0);
             ssd1306_DrawString("Press -> to ignore", 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();

main.c

➞

Show inline comments

 #include "stm32f0xx_hal.h"
 #include "config.h"
 #include "states.h"
 #include "ssd1306.h"
 #include "eeprom_min.h"
 #include "gpio.h"
 #include "spi.h"
 #include "stringhelpers.h"
 #include "display.h"
 #include "usb_device.h"
 #include "usbd_cdc_if.h"
 // Prototypes
 // Move to header file
 void process();
 void restore_settings();
 void save_settings();
 void save_setpoints();
 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();
     // USB startup delay
     HAL_Delay(1000);
     HAL_GPIO_WritePin(LED_POWER, 1);
     // 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();
     if(set.boottobrew)
       status.state = STATE_PREHEAT_BREW; // Go to brew instead of idle if configured thusly
     // Startup screen
     ssd1306_DrawString("therm v0.1", 1, 40);
     ssd1306_DrawString("protofusion.org/therm", 3, 0);
     HAL_Delay(1500);
     ssd1306_clearscreen();
     // Main loop
     while(1)
+    {
         // Process sensor inputs
         process();
         // Run state machine
         display_process(&set, &status);
+    }
+}
 /** System 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();
+}
 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) {
         ssd1306_clearscreen();
         //ssd1306_DrawString("Fatal Error", 3, 35);
         HAL_Delay(100);
         status.state = STATE_TC_ERROR;
         status.temp = 0;
         status.temp_frac = 0;
+    }
     else if(temp_pre & 0b0000000000000001 && !set.ignore_tc_error) {
         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();
+        }
         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;
+        }
         // Use Celsius values
         else
+        {
             status.temp = temp_pre * signint;
+        }
+    }
+}
 // 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;
 int16_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 = (int16_t)setpoint - (int16_t)temp; // TODO: Use fixed point fraction
   // Proportional component
   int16_t p_term = k_p * error;
   // Error accumulator (integrator)
   i_state += error;
   // to prevent the iTerm getting huge despite 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
   int16_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;
   int16_t i_term = k_i * i_state;
   // Calculate differential term (slope since last iteration)
   int16_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;
 int16_t ssr_output = 0; // Duty cycle of ssr, 0 to SSR_PERIOD
 // Process things
 void process()
+{
     update_temp(); // Read MAX31855
     // TODO: Add calibration offset (linear)
     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(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;
+        }
         // 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);
        // while(CDC_Transmit_FS("\r\n", 2) == USBD_BUSY);
         last_vcp_tx = ticks;
+    }
+}
 void save_settings()
+{
 /*
    Minimal_EEPROM_Unlock();
     // Try programming a word at an address divisible by 4
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW, boottobrew);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD, windup_guard);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P, k_p);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I, k_i);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D, k_d);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_UNITS, temp_units);
     Minimal_EEPROM_Lock();
 */
+}
 void save_setpoints()
+{
 /*
     Minimal_EEPROM_Unlock();
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP, setpoint_brew);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP, setpoint_steam);
     Minimal_EEPROM_Lock();
 */
+}
 // TODO: Make a struct that has all settings in it. Pass by ref to this func in a library.
 void restore_settings()
+{
 /*    Minimal_EEPROM_Unlock();
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     boottobrew = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     windup_guard = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_p = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_i = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_d = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     setpoint_brew = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     setpoint_steam = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP));
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     temp_units = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_UNITS));
     Minimal_EEPROM_Lock(); */
+}
 // vim:softtabstop=4 shiftwidth=4 expandtab

startup_stm32f042x6.s

➞

Show inline comments

 /**
   ******************************************************************************
   * @file      startup_stm32f042x6.s
   * @author    MCD Application Team
   * @version   V2.1.0
   * @date      03-Oct-2014
   * @brief     STM32F042x4/STM32F042x6 devices vector table for Atollic TrueSTUDIO toolchain.
   *            This module performs:
   *                - Set the initial SP
   *                - Set the initial PC == Reset_Handler,
   *                - Set the vector table entries with the exceptions ISR address
   *                - Branches to main in the C library (which eventually
   *                  calls main()).
   *            After Reset the Cortex-M0 processor is in Thread mode,
   *            priority is Privileged, and the Stack is set to Main.
   ******************************************************************************
+  *
   * Redistribution and use in source and binary forms, with or without modification,
   * are permitted provided that the following conditions are met:
   *   1. Redistributions of source code must retain the above copyright notice,
   *      this list of conditions and the following disclaimer.
   *   2. Redistributions in binary form must reproduce the above copyright notice,
   *      this list of conditions and the following disclaimer in the documentation
   *      and/or other materials provided with the distribution.
   *   3. Neither the name of STMicroelectronics nor the names of its contributors
   *      may be used to endorse or promote products derived from this software
   *      without specific prior written permission.
+  *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
   ******************************************************************************
   */
   .syntax unified
   .cpu cortex-m0
   .fpu softvfp
   .thumb
 .global g_pfnVectors
 .global Default_Handler
 /* start address for the initialization values of the .data section.
 defined in linker script */
 .word _sidata
 /* start address for the .data section. defined in linker script */
 .word _sdata
 /* end address for the .data section. defined in linker script */
 .word _edata
 /* start address for the .bss section. defined in linker script */
 .word _sbss
 /* end address for the .bss section. defined in linker script */
 .word _ebss
   .section .text.Reset_Handler
   .weak Reset_Handler
   .type Reset_Handler, %function
 Reset_Handler:
   /* Bootloader jumping */
   ldr r0, =0x200017F0 /* address of magic token, is addr within memory range? */
   ldr r1, =0xDEADBEEF /* magical beef token */
   ldr r2, [r0, #0] /* load data from magic address */
   str r0, [r0, #0] /* zero data at magic address so we don't bootloop */
   cmp r2, r1 /* compare data at magic address to magic token */
   beq Reboot_Loader /* jump to bootloader if token match */
   /* End bootloader jumping */
   ldr   r0, =_estack
   mov   sp, r0          /* set stack pointer */
 /* Copy the data segment initializers from flash to SRAM */
   movs r1, #0
   b LoopCopyDataInit
 /* Boot into bootloader */
 Reboot_Loader:
   b Reboot_Loader
   LDR     R0, =0x40021018 // RCC_APB2ENR (+0x18)
   LDR     R1, =0x00000001 // ENABLE SYSCFG CLOCK
   STR     R1, [R0, #0]
   LDR     R0, =0x40010000 // SYSCFG_CFGR1 (+0x00)
   LDR     R1, =0x00000001 // MAP ROM AT ZERO
   STR     R1, [R0, #0]
   //                LDR     R0, =0x1FFFEC00 ; ROM BASE (STM32F03x)
-  LDR     R0, =0x1FFFC400 // ROM BASE (STM32F04x)
+  LDR     R0, =0x1FFFC800 // ROM BASE (STM32F04x)
   //                LDR     R0, =0x1FFFEC00 ; ROM BASE (STM32F05x)
   //                LDR     R0, =0x1FFFC800 ; ROM BASE (STM32F07x)
   //                LDR     R0, =0x1FFFD800 ; ROM BASE (STM32F09x)
   LDR     R1, [R0, #0]    // SP @ +0
   MOV     SP, R1
   LDR     R0, [R0, #4]    // PC @ +4
   BX      R0
   // On reset, SP=value at address 0x0
 //  ldr r0, =0x00000000
 //  ldr r0, [r0, #0]
 //  mov sp, r0
 //  ldr r0, =0x1FFFC800 /* Address of bootloader on f042 from CD00167594 pg 15 table 3 */
   // Branch to bootloader
 //  ldr r0, [r0, #4]
 //  bx r0
 CopyDataInit:
   ldr r3, =_sidata
   ldr r3, [r3, r1]
   str r3, [r0, r1]
   adds r1, r1, #4
 LoopCopyDataInit:
   ldr r0, =_sdata
   ldr r3, =_edata
   adds r2, r0, r1
   cmp r2, r3
   bcc CopyDataInit
   ldr r2, =_sbss
   b LoopFillZerobss
 /* Zero fill the bss segment. */
 FillZerobss:
   movs r3, #0
   str  r3, [r2]
   adds r2, r2, #4
 LoopFillZerobss:
   ldr r3, = _ebss
   cmp r2, r3
   bcc FillZerobss
 /* Call the clock system intitialization function.*/
   bl  SystemInit
 /* Call static constructors */
   bl __libc_init_array
 /* Call the application's entry point.*/
   bl main
 LoopForever:
     b LoopForever
 .size Reset_Handler, .-Reset_Handler
 /**
  * @brief  This is the code that gets called when the processor receives an
  *         unexpected interrupt.  This simply enters an infinite loop, preserving
  *         the system state for examination by a debugger.
+ *
  * @param  None
  * @retval : None
 */
     .section .text.Default_Handler,"ax",%progbits
 Default_Handler:
 Infinite_Loop:
   b Infinite_Loop
   .size Default_Handler, .-Default_Handler
 /******************************************************************************
+*
 * The minimal vector table for a Cortex M0.  Note that the proper constructs
 * must be placed on this to ensure that it ends up at physical address
 * 0x0000.0000.
+*
 ******************************************************************************/
    .section .isr_vector,"a",%progbits
   .type g_pfnVectors, %object
   .size g_pfnVectors, .-g_pfnVectors
 g_pfnVectors:
   .word  _estack
   .word  Reset_Handler
   .word  NMI_Handler
   .word  HardFault_Handler
   .word  0
   .word  0
   .word  0
   .word  0
   .word  0
   .word  0
   .word  0
   .word  SVC_Handler
   .word  0
   .word  0
   .word  PendSV_Handler
   .word  SysTick_Handler
   .word  WWDG_IRQHandler                   /* Window WatchDog              */
   .word  PVD_VDDIO2_IRQHandler             /* PVD and VDDIO2 through EXTI Line detect */
   .word  RTC_IRQHandler                    /* RTC through the EXTI line    */
   .word  FLASH_IRQHandler                  /* FLASH                        */
   .word  RCC_CRS_IRQHandler                /* RCC and CRS                  */
   .word  EXTI0_1_IRQHandler                /* EXTI Line 0 and 1            */
   .word  EXTI2_3_IRQHandler                /* EXTI Line 2 and 3            */
   .word  EXTI4_15_IRQHandler               /* EXTI Line 4 to 15            */
   .word  TSC_IRQHandler                    /* TSC                          */
   .word  DMA1_Channel1_IRQHandler          /* DMA1 Channel 1               */
   .word  DMA1_Channel2_3_IRQHandler        /* DMA1 Channel 2 and Channel 3 */
   .word  DMA1_Channel4_5_IRQHandler        /* DMA1 Channel 4 and Channel 5 */
   .word  ADC1_IRQHandler                   /* ADC1                         */
   .word  TIM1_BRK_UP_TRG_COM_IRQHandler    /* TIM1 Break, Update, Trigger and Commutation */
   .word  TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */
   .word  TIM2_IRQHandler                   /* TIM2                         */
   .word  TIM3_IRQHandler                   /* TIM3                         */
   .word  0                                 /* Reserved                     */
   .word  0                                 /* Reserved                     */
   .word  TIM14_IRQHandler                  /* TIM14                        */
   .word  0                                 /* Reserved                     */
   .word  TIM16_IRQHandler                  /* TIM16                        */
   .word  TIM17_IRQHandler                  /* TIM17                        */
   .word  I2C1_IRQHandler                   /* I2C1                         */
   .word  0                                 /* Reserved                     */
   .word  SPI1_IRQHandler                   /* SPI1                         */
   .word  SPI2_IRQHandler                   /* SPI2                         */
   .word  USART1_IRQHandler                 /* USART1                       */
   .word  USART2_IRQHandler                 /* USART2                       */
   .word  0                                 /* Reserved                     */
   .word  CEC_CAN_IRQHandler                /* CEC and CAN                  */
   .word  USB_IRQHandler                    /* USB                          */
 /*******************************************************************************
+*
 * Provide weak aliases for each Exception handler to the Default_Handler.
 * As they are weak aliases, any function with the same name will override
 * this definition.
+*
 *******************************************************************************/
   .weak      NMI_Handler
   .thumb_set NMI_Handler,Default_Handler
   .weak      HardFault_Handler
   .thumb_set HardFault_Handler,Default_Handler
   .weak      SVC_Handler
   .thumb_set SVC_Handler,Default_Handler
   .weak      PendSV_Handler
   .thumb_set PendSV_Handler,Default_Handler
   .weak      SysTick_Handler
   .thumb_set SysTick_Handler,Default_Handler
   .weak      WWDG_IRQHandler
   .thumb_set WWDG_IRQHandler,Default_Handler
   .weak      PVD_VDDIO2_IRQHandler
   .thumb_set PVD_VDDIO2_IRQHandler,Default_Handler
   .weak      RTC_IRQHandler
   .thumb_set RTC_IRQHandler,Default_Handler
   .weak      FLASH_IRQHandler
   .thumb_set FLASH_IRQHandler,Default_Handler
   .weak      RCC_CRS_IRQHandler
   .thumb_set RCC_CRS_IRQHandler,Default_Handler
   .weak      EXTI0_1_IRQHandler
   .thumb_set EXTI0_1_IRQHandler,Default_Handler
   .weak      EXTI2_3_IRQHandler
   .thumb_set EXTI2_3_IRQHandler,Default_Handler
   .weak      EXTI4_15_IRQHandler
   .thumb_set EXTI4_15_IRQHandler,Default_Handler
   .weak      TSC_IRQHandler
   .thumb_set TSC_IRQHandler,Default_Handler
   .weak      DMA1_Channel1_IRQHandler
   .thumb_set DMA1_Channel1_IRQHandler,Default_Handler
   .weak      DMA1_Channel2_3_IRQHandler
   .thumb_set DMA1_Channel2_3_IRQHandler,Default_Handler
   .weak      DMA1_Channel4_5_IRQHandler
   .thumb_set DMA1_Channel4_5_IRQHandler,Default_Handler
   .weak      ADC1_IRQHandler
   .thumb_set ADC1_IRQHandler,Default_Handler
   .weak      TIM1_BRK_UP_TRG_COM_IRQHandler
   .thumb_set TIM1_BRK_UP_TRG_COM_IRQHandler,Default_Handler
   .weak      TIM1_CC_IRQHandler
   .thumb_set TIM1_CC_IRQHandler,Default_Handler
   .weak      TIM2_IRQHandler
   .thumb_set TIM2_IRQHandler,Default_Handler
   .weak      TIM3_IRQHandler
   .thumb_set TIM3_IRQHandler,Default_Handler
   .weak      TIM14_IRQHandler
   .thumb_set TIM14_IRQHandler,Default_Handler
   .weak      TIM16_IRQHandler
   .thumb_set TIM16_IRQHandler,Default_Handler
   .weak      TIM17_IRQHandler
   .thumb_set TIM17_IRQHandler,Default_Handler
   .weak      I2C1_IRQHandler
   .thumb_set I2C1_IRQHandler,Default_Handler
   .weak      SPI1_IRQHandler
   .thumb_set SPI1_IRQHandler,Default_Handler
   .weak      SPI2_IRQHandler
   .thumb_set SPI2_IRQHandler,Default_Handler
   .weak      USART1_IRQHandler
   .thumb_set USART1_IRQHandler,Default_Handler
   .weak      USART2_IRQHandler
   .thumb_set USART2_IRQHandler,Default_Handler
   .weak      CEC_CAN_IRQHandler
   .thumb_set CEC_CAN_IRQHandler,Default_Handler
   .weak      USB_IRQHandler
   .thumb_set USB_IRQHandler,Default_Handler
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

0 comments (0 inline, 0 general)