therm Changeset - b5b1fc08b294 · protofusion repositories

Changeset - b5b1fc08b294

Parent rev.

Child rev.

[Not reviewed]

cortex-f0

0 5 0

Ethan Zonca - 11 years ago 2015-03-29 20:58:14
ez@ethanzonca.com

Added virtual serial port periodic transmission of temperature. Trying out bootloader code, but still doesn't work.

5 files changed with 53 insertions and 23 deletions:

config.h

flash.sh

main.c

startup_stm32f042x6.s

usbd_cdc_if.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 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

flash.sh

➞

Show inline comments

 #!/bin/bash
 cd build
 st-flash write main.bin 0x8000000
 cd ..
 # USB DFU:
 # sudo  dfu-util -a 0 -d 0483:df11 -s 0x08000000:leave -D build/main.bin

main.c

➞

Show inline comments

@@ @@ -138,498 +138,503 @@ void SystemClock_Config(void) @@
   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();
+}
 // Read temperature and update global temp vars
 int32_t temp = 0;
 uint8_t temp_frac = 0;
 uint8_t state_resume = 0;
 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);
         state = STATE_TC_ERROR;
         temp = 0;
         temp_frac = 0;
+    }
     else if(temp_pre & 0b0000000000000001 && !ignore_tc_error) {
         state_resume = state;
         state = STATE_TC_ERROR;
         temp = 0;
         temp_frac = 0;
+    }
     else
+    {
         if(state == STATE_TC_ERROR)
+        {
             state = state_resume;
             ssd1306_clearscreen();
+        }
         uint8_t sign = temp >> 15;// top bit is sign
         temp_pre = temp_pre >> 2; // Drop 2 lowest bits
         temp_frac = temp_pre & 0b11; // get fractional part
         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(temp_units == TEMP_UNITS_FAHRENHEIT)
+        {
             temp = signint * ((temp_pre*100) + temp_frac);
             temp = temp * 1.8;
             temp += 3200;
             temp_frac = temp % 100;
             temp /= 100;
+        }
         // Use Celsius values
         else
+        {
             temp = temp_pre * signint;
+        }
+    }
     // Print temp to cdc
 /*
     CDC_Transmit_FS("Temp: ", 6);
     char tempstr[6];
     zitoa(temp, tempstr);
     CDC_Transmit_FS(tempstr, sizeof(tempstr));
     CDC_Transmit_FS("\r\n", 2);
     CDC_Transmit_FS("\r\n", 2);
     CDC_Transmit_FS("\r\n", 2);
     CDC_Transmit_FS("\r\n", 2);
     CDC_Transmit_FS("\r\n", 2);
 */
+}
 // 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 = 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 * (temp - last_pid_temp));
   // Save temperature for next iteration
   last_pid_temp = temp;
   last_pid_temp_frac = 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;
 int32_t setpoint = 0;
 int16_t ssr_output = 0; // Duty cycle of ssr, 0 to SSR_PERIOD
 uint8_t pid_enabled = 0;
 // 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(pid_enabled)
+        {
             // Get ssr output for next time
             int16_t power_percent = update_pid(k_p, k_i, k_d, temp, temp_frac, 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[6];
         itoa_fp(temp, temp_frac, tempstr);
         while(CDC_Transmit_FS(tempstr, sizeof(tempstr)) == USBD_BUSY);
         while(CDC_Transmit_FS("\r\n", 2) == USBD_BUSY);
         last_vcp_tx = ticks;
+    }
+}
 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)
 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(); */
+}
 int16_t last_temp = 21245;
 ///////////////////////////////////////////////////////////////////////////////////////
 /// 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;
 int32_t temp_last = 43002;
 int32_t setpoint_last = 10023;
 void draw_setpoint() {
     // FIXME: need to do this when switching modes too
     if(temp != temp_last || trigger_drawsetpoint) {
         char tempstr[3];
         itoa_fp(temp, temp_frac, tempstr);
         ssd1306_DrawStringBig("      ", 3, 0);
         ssd1306_DrawStringBig(tempstr, 3, 0);
+    }
     if(trigger_drawsetpoint)
         ssd1306_DrawStringBig(">", 3, 74);
     if(setpoint != setpoint_last || trigger_drawsetpoint) {
         char tempstr[3];
         itoa(setpoint, tempstr, 10);
         ssd1306_DrawStringBig("   ", 3, 90);
         ssd1306_DrawStringBig(tempstr, 3, 90);
+    }
     trigger_drawsetpoint = 0;
     setpoint_last = setpoint;
     temp_last = temp;
+}
 void machine()
+{
     uint8_t last_state = state;
     uint8_t temp_changed = temp != last_temp;
     last_temp = 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(state)
+    {
         // Idle state
         case STATE_IDLE:
+        {
             // Write text to OLED
             // [ therm :: idle ]
             ssd1306_DrawString("therm :: idle ", 0, 40);
             pid_enabled = 0;
             if(temp_changed) {
                 char tempstr[6];
                 itoa_fp(temp, 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:
                         state = STATE_PREHEAT_BREW;
                         break;
                     case 1:
                         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);
                         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();
                         state = STATE_IDLE;
                     } break;
                     default:
                         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(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) {
                 state = STATE_SETI;
+            }
             else {
                 user_input(&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(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) {
                 state = STATE_SETD;
+            }
             else {
                 user_input(&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(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);

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:
   ldr r0, =0x1FFFF6A6 /* Address of bootloader on f042 from CD00167594 pg 15 table 3 */
   /* This replaces ldr sp, [r0, #0] which doesn't work on m0 */
   // Set stack pointer
   ldr r1, [r0, #0]
   mov sp, r1
   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, =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
 //  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                         */

usbd_cdc_if.c

➞

Show inline comments

@@ @@ -197,132 +197,135 @@ static int8_t CDC_Control_FS (uint8_t c @@
 	/* 6      | bDataBits  |   1   | Number Data bits (5, 6, 7, 8 or 16).          */
 	/*******************************************************************************/
     case CDC_SET_LINE_CODING:
 	break;
     case CDC_GET_LINE_CODING:
 	pbuf[0] = (uint8_t)(115200);
 	pbuf[1] = (uint8_t)(115200 >> 8);
 	pbuf[2] = (uint8_t)(115200 >> 16);
 	pbuf[3] = (uint8_t)(115200 >> 24);
 	pbuf[4] = 0; // stop bits (1)
 	pbuf[5] = 0; // parity (none)
 	pbuf[6] = 8; // number of bits (8)
 	break;
     case CDC_SET_CONTROL_LINE_STATE:
 	break;
     case CDC_SEND_BREAK:
 	break;
     default:
 	break;
+    }
     return (USBD_OK);
     /* USER CODE END 6 */
+}
 /**
  * @brief  CDC_Receive_FS
  *         Data received over USB OUT endpoint are sent over CDC interface
  *         through this function.
+ *
  *         @note
  *         This function will block any OUT packet reception on USB endpoint
  *         untill exiting this function. If you exit this function before transfer
  *         is complete on CDC interface (ie. using DMA controller) it will result
  *         in receiving more data while previous ones are still not sent.
+ *
  * @param  Buf: Buffer of data to be received
  * @param  Len: Number of data received (in bytes)
  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
  */
 //uint8_t slcan_str[SLCAN_MTU];
 //int8_t slcan_str_index = 0;
 static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len)
+{
     /* USER CODE BEGIN 7 */
     uint32_t status;
  //  CanTxMsgTypeDef TxMsg;
     /*uint8_t test_str[] = "t71181122334455667788";
       slcan_parse_str(&TxMsg, test_str, sizeof(test_str));*/
 //   uint8_t n = *Len;
 //   uint8_t i;
 //   for (i = 0; i < n; i++) {
 //	if (Buf[i] == '\r') {
 //	    status = slcan_parse_str(slcan_str, slcan_str_index);
 //	    slcan_str_index = 0;
 //	} else {
 //	    slcan_str[slcan_str_index++] = Buf[i];
 //	}
 //    }
     // prepare for next read
     //USBD_CDC_SetRxBuffer(hUsbDevice_0, UserRxBufferFS);
     USBD_CDC_ReceivePacket(hUsbDevice_0);
     return (USBD_OK);
     /* USER CODE END 7 */
+}
 /**
  * @brief  CDC_Transmit_FS
  *         Data send over USB IN endpoint are sent over CDC interface
  *         through this function.
  *         @note
+ *
+ *
  * @param  Buf: Buffer of data to be send
  * @param  Len: Number of data to be send (in bytes)
  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL or USBD_BUSY
  */
 uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)
+{
     uint8_t result = USBD_OK;
     /* USER CODE BEGIN 8 */
     uint16_t i;
     // Zero out user TX buffer (EMZ FIXME: why bother?)
     for (i=0; i < sizeof(UserTxBufferFS); i++) {
 	UserTxBufferFS[i] = 0;
+    }
     // Copy input buff to user TX buffer
     for (i=0; i < Len; i++) {
 	UserTxBufferFS[i] = Buf[i];
+    }
     USBD_CDC_SetTxBuffer(hUsbDevice_0, UserTxBufferFS, Len);
     result = USBD_CDC_TransmitPacket(hUsbDevice_0);
 /*
     for (i = 0; i < 1 + (Len/8); i++) {
 	USBD_CDC_SetTxBuffer(hUsbDevice_0, UserTxBufferFS + (8*i), 8);
 	do {
 	    result = USBD_CDC_TransmitPacket(hUsbDevice_0);
 	} while (result != HAL_BUSY);
+    }
 */
     /* USER CODE END 8 */
     return result;
+}
 /**
  * @}
  */
 /**
  * @}
  */
 /**
  * @}
  */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

0 comments (0 inline, 0 general)