diff --git a/software/dumber3/.cproject b/software/dumber3/.cproject index 6b4ccbf..8e203ea 100644 --- a/software/dumber3/.cproject +++ b/software/dumber3/.cproject @@ -110,17 +110,6 @@ - - - - - - - - - - - - + @@ -220,6 +209,192 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -243,5 +418,8 @@ + + + \ No newline at end of file diff --git a/software/dumber3/.mxproject b/software/dumber3/.mxproject index 8787341..2b9ef62 100644 --- a/software/dumber3/.mxproject +++ b/software/dumber3/.mxproject @@ -1,5 +1,5 @@ [PreviousLibFiles] -LibFiles=Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_def.h;Drivers/STM32L0xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_bus.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_crs.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_system.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_utils.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ramfunc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_usart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_lpuart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_tim.h;Middlewares/Third_Party/FreeRTOS/Source/include/croutine.h;Middlewares/Third_Party/FreeRTOS/Source/include/deprecated_definitions.h;Middlewares/Third_Party/FreeRTOS/Source/include/event_groups.h;Middlewares/Third_Party/FreeRTOS/Source/include/FreeRTOS.h;Middlewares/Third_Party/FreeRTOS/Source/include/list.h;Middlewares/Third_Party/FreeRTOS/Source/include/message_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_prototypes.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_wrappers.h;Middlewares/Third_Party/FreeRTOS/Source/include/portable.h;Middlewares/Third_Party/FreeRTOS/Source/include/projdefs.h;Middlewares/Third_Party/FreeRTOS/Source/include/queue.h;Middlewares/Third_Party/FreeRTOS/Source/include/semphr.h;Middlewares/Third_Party/FreeRTOS/Source/include/stack_macros.h;Middlewares/Third_Party/FreeRTOS/Source/include/StackMacros.h;Middlewares/Third_Party/FreeRTOS/Source/include/stream_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/task.h;Middlewares/Third_Party/FreeRTOS/Source/include/timers.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os.h;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/portmacro.h;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ramfunc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_gpio.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_dma.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_cortex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_exti.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim_ex.c;Middlewares/Third_Party/FreeRTOS/Source/croutine.c;Middlewares/Third_Party/FreeRTOS/Source/event_groups.c;Middlewares/Third_Party/FreeRTOS/Source/list.c;Middlewares/Third_Party/FreeRTOS/Source/queue.c;Middlewares/Third_Party/FreeRTOS/Source/stream_buffer.c;Middlewares/Third_Party/FreeRTOS/Source/tasks.c;Middlewares/Third_Party/FreeRTOS/Source/timers.c;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.c;Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/port.c;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_def.h;Drivers/STM32L0xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_bus.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_crs.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_system.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_utils.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ramfunc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_usart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_lpuart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_tim.h;Middlewares/Third_Party/FreeRTOS/Source/include/croutine.h;Middlewares/Third_Party/FreeRTOS/Source/include/deprecated_definitions.h;Middlewares/Third_Party/FreeRTOS/Source/include/event_groups.h;Middlewares/Third_Party/FreeRTOS/Source/include/FreeRTOS.h;Middlewares/Third_Party/FreeRTOS/Source/include/list.h;Middlewares/Third_Party/FreeRTOS/Source/include/message_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_prototypes.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_wrappers.h;Middlewares/Third_Party/FreeRTOS/Source/include/portable.h;Middlewares/Third_Party/FreeRTOS/Source/include/projdefs.h;Middlewares/Third_Party/FreeRTOS/Source/include/queue.h;Middlewares/Third_Party/FreeRTOS/Source/include/semphr.h;Middlewares/Third_Party/FreeRTOS/Source/include/stack_macros.h;Middlewares/Third_Party/FreeRTOS/Source/include/StackMacros.h;Middlewares/Third_Party/FreeRTOS/Source/include/stream_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/task.h;Middlewares/Third_Party/FreeRTOS/Source/include/timers.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os.h;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/portmacro.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/stm32l071xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/stm32l0xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/system_stm32l0xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Source/Templates/system_stm32l0xx.c;Drivers/CMSIS/Include/core_armv8mml.h;Drivers/CMSIS/Include/mpu_armv8.h;Drivers/CMSIS/Include/core_cm3.h;Drivers/CMSIS/Include/core_cm7.h;Drivers/CMSIS/Include/core_cm4.h;Drivers/CMSIS/Include/cmsis_gcc.h;Drivers/CMSIS/Include/cmsis_iccarm.h;Drivers/CMSIS/Include/core_sc300.h;Drivers/CMSIS/Include/core_cm33.h;Drivers/CMSIS/Include/core_cm1.h;Drivers/CMSIS/Include/mpu_armv7.h;Drivers/CMSIS/Include/cmsis_version.h;Drivers/CMSIS/Include/core_cm23.h;Drivers/CMSIS/Include/cmsis_armclang.h;Drivers/CMSIS/Include/core_sc000.h;Drivers/CMSIS/Include/core_cm0plus.h;Drivers/CMSIS/Include/cmsis_compiler.h;Drivers/CMSIS/Include/core_cm0.h;Drivers/CMSIS/Include/tz_context.h;Drivers/CMSIS/Include/core_armv8mbl.h;Drivers/CMSIS/Include/cmsis_armcc.h; +LibFiles=Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_def.h;Drivers/STM32L0xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_bus.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_crs.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_system.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_utils.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ramfunc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_usart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_lpuart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_tim.h;Middlewares/Third_Party/FreeRTOS/Source/include/croutine.h;Middlewares/Third_Party/FreeRTOS/Source/include/deprecated_definitions.h;Middlewares/Third_Party/FreeRTOS/Source/include/event_groups.h;Middlewares/Third_Party/FreeRTOS/Source/include/FreeRTOS.h;Middlewares/Third_Party/FreeRTOS/Source/include/list.h;Middlewares/Third_Party/FreeRTOS/Source/include/message_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_prototypes.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_wrappers.h;Middlewares/Third_Party/FreeRTOS/Source/include/portable.h;Middlewares/Third_Party/FreeRTOS/Source/include/projdefs.h;Middlewares/Third_Party/FreeRTOS/Source/include/queue.h;Middlewares/Third_Party/FreeRTOS/Source/include/semphr.h;Middlewares/Third_Party/FreeRTOS/Source/include/stack_macros.h;Middlewares/Third_Party/FreeRTOS/Source/include/StackMacros.h;Middlewares/Third_Party/FreeRTOS/Source/include/stream_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/task.h;Middlewares/Third_Party/FreeRTOS/Source/include/timers.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os.h;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/portmacro.h;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ramfunc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_gpio.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_dma.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_cortex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_exti.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim_ex.c;Middlewares/Third_Party/FreeRTOS/Source/croutine.c;Middlewares/Third_Party/FreeRTOS/Source/event_groups.c;Middlewares/Third_Party/FreeRTOS/Source/list.c;Middlewares/Third_Party/FreeRTOS/Source/queue.c;Middlewares/Third_Party/FreeRTOS/Source/stream_buffer.c;Middlewares/Third_Party/FreeRTOS/Source/tasks.c;Middlewares/Third_Party/FreeRTOS/Source/timers.c;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.c;Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/port.c;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_adc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_adc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_def.h;Drivers/STM32L0xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_i2c_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_rcc_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_bus.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_rcc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_crs.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_system.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_utils.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ramfunc.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_flash_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_gpio_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_gpio.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_dma_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_dma.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_pwr_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_pwr.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_cortex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_exti.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_usart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_lpuart.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_tim_ex.h;Drivers/STM32L0xx_HAL_Driver/Inc/stm32l0xx_ll_tim.h;Middlewares/Third_Party/FreeRTOS/Source/include/croutine.h;Middlewares/Third_Party/FreeRTOS/Source/include/deprecated_definitions.h;Middlewares/Third_Party/FreeRTOS/Source/include/event_groups.h;Middlewares/Third_Party/FreeRTOS/Source/include/FreeRTOS.h;Middlewares/Third_Party/FreeRTOS/Source/include/list.h;Middlewares/Third_Party/FreeRTOS/Source/include/message_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_prototypes.h;Middlewares/Third_Party/FreeRTOS/Source/include/mpu_wrappers.h;Middlewares/Third_Party/FreeRTOS/Source/include/portable.h;Middlewares/Third_Party/FreeRTOS/Source/include/projdefs.h;Middlewares/Third_Party/FreeRTOS/Source/include/queue.h;Middlewares/Third_Party/FreeRTOS/Source/include/semphr.h;Middlewares/Third_Party/FreeRTOS/Source/include/stack_macros.h;Middlewares/Third_Party/FreeRTOS/Source/include/StackMacros.h;Middlewares/Third_Party/FreeRTOS/Source/include/stream_buffer.h;Middlewares/Third_Party/FreeRTOS/Source/include/task.h;Middlewares/Third_Party/FreeRTOS/Source/include/timers.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.h;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os.h;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/portmacro.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/stm32l071xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/stm32l0xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Include/system_stm32l0xx.h;Drivers/CMSIS/Device/ST/STM32L0xx/Source/Templates/system_stm32l0xx.c;Drivers/CMSIS/Include/core_cm23.h;Drivers/CMSIS/Include/mpu_armv7.h;Drivers/CMSIS/Include/cmsis_version.h;Drivers/CMSIS/Include/core_cm4.h;Drivers/CMSIS/Include/core_cm0plus.h;Drivers/CMSIS/Include/tz_context.h;Drivers/CMSIS/Include/core_cm3.h;Drivers/CMSIS/Include/cmsis_armcc.h;Drivers/CMSIS/Include/core_sc300.h;Drivers/CMSIS/Include/core_cm0.h;Drivers/CMSIS/Include/cmsis_compiler.h;Drivers/CMSIS/Include/cmsis_gcc.h;Drivers/CMSIS/Include/cmsis_armclang.h;Drivers/CMSIS/Include/core_armv8mml.h;Drivers/CMSIS/Include/core_sc000.h;Drivers/CMSIS/Include/cmsis_iccarm.h;Drivers/CMSIS/Include/core_cm7.h;Drivers/CMSIS/Include/core_armv8mbl.h;Drivers/CMSIS/Include/core_cm33.h;Drivers/CMSIS/Include/core_cm1.h;Drivers/CMSIS/Include/mpu_armv8.h; [PreviousUsedCubeIDEFiles] SourceFiles=Core/Src/main.c;Core/Src/freertos.c;Core/Src/stm32l0xx_it.c;Core/Src/stm32l0xx_hal_msp.c;Core/Src/stm32l0xx_hal_timebase_tim.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ramfunc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_gpio.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_dma.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_cortex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_exti.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim_ex.c;Middlewares/Third_Party/FreeRTOS/Source/croutine.c;Middlewares/Third_Party/FreeRTOS/Source/event_groups.c;Middlewares/Third_Party/FreeRTOS/Source/list.c;Middlewares/Third_Party/FreeRTOS/Source/queue.c;Middlewares/Third_Party/FreeRTOS/Source/stream_buffer.c;Middlewares/Third_Party/FreeRTOS/Source/tasks.c;Middlewares/Third_Party/FreeRTOS/Source/timers.c;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.c;Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/port.c;Drivers/CMSIS/Device/ST/STM32L0xx/Source/Templates/system_stm32l0xx.c;Core/Src/system_stm32l0xx.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_adc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_i2c_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_rcc_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ramfunc.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_flash_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_gpio.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_dma.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_pwr_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_cortex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_exti.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_uart_ex.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim.c;Drivers/STM32L0xx_HAL_Driver/Src/stm32l0xx_hal_tim_ex.c;Middlewares/Third_Party/FreeRTOS/Source/croutine.c;Middlewares/Third_Party/FreeRTOS/Source/event_groups.c;Middlewares/Third_Party/FreeRTOS/Source/list.c;Middlewares/Third_Party/FreeRTOS/Source/queue.c;Middlewares/Third_Party/FreeRTOS/Source/stream_buffer.c;Middlewares/Third_Party/FreeRTOS/Source/tasks.c;Middlewares/Third_Party/FreeRTOS/Source/timers.c;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.c;Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/port.c;Drivers/CMSIS/Device/ST/STM32L0xx/Source/Templates/system_stm32l0xx.c;Core/Src/system_stm32l0xx.c;;;Middlewares/Third_Party/FreeRTOS/Source/croutine.c;Middlewares/Third_Party/FreeRTOS/Source/event_groups.c;Middlewares/Third_Party/FreeRTOS/Source/list.c;Middlewares/Third_Party/FreeRTOS/Source/queue.c;Middlewares/Third_Party/FreeRTOS/Source/stream_buffer.c;Middlewares/Third_Party/FreeRTOS/Source/tasks.c;Middlewares/Third_Party/FreeRTOS/Source/timers.c;Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os2.c;Middlewares/Third_Party/FreeRTOS/Source/portable/MemMang/heap_4.c;Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM0/port.c; diff --git a/software/dumber3/.settings/language.settings.xml b/software/dumber3/.settings/language.settings.xml index d6d297a..d309561 100644 --- a/software/dumber3/.settings/language.settings.xml +++ b/software/dumber3/.settings/language.settings.xml @@ -5,7 +5,7 @@ - + @@ -17,7 +17,18 @@ - + + + + + + + + + + + + diff --git a/software/dumber3/Application/Xbee-API/xbee.c b/software/dumber3/Application/Xbee-API/xbee.c new file mode 100644 index 0000000..e4fecd0 --- /dev/null +++ b/software/dumber3/Application/Xbee-API/xbee.c @@ -0,0 +1,440 @@ +/* + * xbee.c + * + * Created on: Sep 12, 2022 + * Author: dimercur + */ + + +#include "xbee.h" +#include "semphr.h" +#include +#include +#include "stm32l0xx_ll_usart.h" + +extern UART_HandleTypeDef hlpuart1; +extern DMA_HandleTypeDef hdma_lpuart1_tx; +extern DMA_HandleTypeDef hdma_lpuart1_rx; + +/***** API2 escaped char *****/ +#define XBEE_API_ESCAPE_CHAR 0x7D +#define XBEE_API_START_OF_FRAME 0x7E +#define XBEE_API_XON 0x11 +#define XBEE_API_XOFF 0x13 + +/***** RX part *****/ + +/* Stuff for Xbee RX task */ +StaticTask_t xTaskXbeeRX; +StackType_t xStackXbeeRX[ STACK_SIZE ]; +TaskHandle_t xHandleXbeeRX = NULL; + +uint8_t txBuffer[XBEE_RX_BUFFER_MAX_LENGTH]={0}; +uint16_t txIndex; +uint16_t txDataToSend; + +void XBEE_RxThread(void* params); + +SemaphoreHandle_t xHandleSemaphoreRX = NULL; +StaticSemaphore_t xSemaphoreRx; + +uint8_t rxBuffer[XBEE_RX_BUFFER_MAX_LENGTH]={0}; +//uint8_t rxWaitForACK =0; +uint8_t rxPhase; +uint16_t rxFrameLength; +uint16_t rxDataToReceive; +uint16_t rxIndex; + +#define XBEE_RX_PHASE_SOF 0 +#define XBEE_RX_PHASE_HEADER 1 +#define XBEE_RX_PHASE_BODY 2 + +/****** TX part ******/ +SemaphoreHandle_t xHandleSemaphoreTX = NULL; +SemaphoreHandle_t xHandleSemaphoreTX_ACK = NULL; +StaticSemaphore_t xSemaphoreTX; +StaticSemaphore_t xSemaphoreTX_ACK; + +void XBEE_Init(void) { + xHandleSemaphoreTX = xSemaphoreCreateBinaryStatic( &xSemaphoreTX ); + xHandleSemaphoreTX_ACK = xSemaphoreCreateBinaryStatic( &xSemaphoreTX_ACK ); + xSemaphoreGive(xHandleSemaphoreTX); + //xSemaphoreTake(xHandleSemaphoreTX_ACK); + + xHandleSemaphoreRX = xSemaphoreCreateBinaryStatic( &xSemaphoreRx ); + + /* Create the task without using any dynamic memory allocation. */ + xHandleXbeeRX = xTaskCreateStatic( + XBEE_RxThread, /* Function that implements the task. */ + "XBEE Rx", /* Text name for the task. */ + STACK_SIZE, /* Number of indexes in the xStack array. */ + NULL, /* Parameter passed into the task. */ + PriorityMoteurs,/* Priority at which the task is created. */ + xStackXbeeRX, /* Array to use as the task's stack. */ + &xTaskXbeeRX); /* Variable to hold the task's data structure. */ + vTaskResume(xHandleXbeeRX); + + /* Enable Xbee */ + HAL_GPIO_WritePin(XBEE_RESET_GPIO_Port, XBEE_RESET_Pin, GPIO_PIN_SET); +} + +/**** Support functions ****/ + +/** + * Compute length of encoded data using escape char + * + * \param data pointer on raw data + * \param length length of raw data + * \return length of data when encoded + */ +int XBEE_GetDataLength(char* data, int length) { + int encodedLength=0; + + for (int i=0; i< length; i++) { + if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || + (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { + encodedLength++; /* Add 1 byte for escape char */ + } + + encodedLength++; /* Add current char in length calculation */ + data++; /* move to next byte in raw buffer */ + } + + return encodedLength; +} + +/** + * Convert raw data into escaped data. Create a new buffer that is returned + * + * \param data pointer on raw data + * \param length length of raw data + * \param encodedLength length of encoded data + * \return new buffer allocated with escaped char + */ +char* XBEE_EncodeWithEscapeChar(char* data, int length, int *encodedLength) { + char* encodedData; + + *encodedLength=XBEE_GetDataLength(data, length); + encodedData = (char*)malloc(*encodedLength); + + for (char* p=encodedData; p< (encodedData + *encodedLength); p++) { + if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || + (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { + *p = (char) XBEE_API_ESCAPE_CHAR; + p++; + } + + *p = *data; + data++; + } + + return encodedData; +} + +/** + * Get a raw buffer and convert it into a transmission frame + * + * \param data pointer on raw data + * \param length length of raw data + * \param destination address of the destination + * \param frameLength length of frame + * \return new frame (allocated) containing escaped data + */ +void XBEE_EncodeTransmissionFrame(char* data, int length, uint16_t destination, char* frame, int* frameLength) { + uint8_t checksum=0; + uint16_t localLength=0; + char* p; + + localLength = length+9; + + frame[0] = (char)XBEE_FRAME_SOF_CHAR; + frame[1] = (char)((uint16_t)(localLength-4)>>8); + frame[2] = (char)((uint16_t)(localLength-4)); + frame[3] = (char)XBEE_TX_16BIT_REQUEST_TYPE; + frame[4] = 0x1; + + frame[5] = (char)((uint16_t)(destination)>>8); + frame[6] = (char)((uint16_t)(destination)); + + frame[7] = 0x0; + + for (p = &frame[8]; p< (data + length); p++) { + if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || + (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { + *p = (char) XBEE_API_ESCAPE_CHAR; + p++; + *p = *data^0x20; + } else + *p = *data; + + data++; + } + + /* calcul du checksum */ + for (int i=3; i<(localLength-1); i++) { + checksum += (uint8_t)frame[i]; + } + + *p = 0xFF-checksum; + *frameLength = localLength; +} + +/** + * Get frame length + * + * \param frame pointer on frame header + * \return length of incoming frame + */ +uint16_t XBEE_GetFrameLength(uint8_t *frame) { + return (((uint16_t)frame[1])<<8) + (uint16_t)frame[2]; +} + +/** + * Get a complete frame, check if frame is correct and extract raw data + * + * \param raw_frame pointer on complete frame + * \param incomingFrame pointer to processed frame, with escape char removed + * \return status of decoding: XBEE_OK if decoding is successful, XBEE_INVALID_FRAME otherwise + */ +XBEE_Status XBEE_DecodeFrame(char* rawFrame, XBEE_INCOMING_FRAME** incomingFrame) { + uint8_t frame_type = (uint8_t)rawFrame[3]; + uint16_t rawFrameLength; + uint8_t checksum; + XBEE_Status status = XBEE_OK; + int allocatedSize; + int dataSize; + + int i; + + if (rawFrame[0] == '~') { + rawFrameLength = (((uint16_t)rawFrame[1])<<8) + (uint16_t)rawFrame[2]; + + /* verification du checksum */ + checksum =0; + for (i=3; i<3+rawFrameLength+1; i++) { + checksum += (uint8_t)rawFrame[i]; + } + + if (checksum != 0xFF) + return XBEE_INVALID_FRAME; + + switch (frame_type) { + case XBEE_RX_16BIT_PACKET_TYPE: + dataSize = rawFrameLength-5; // there is 5 bytes of "other" data than truly data bytes in a frame + allocatedSize = sizeof(XBEE_INCOMING_FRAME)+dataSize; + + *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ + (*incomingFrame)->type = frame_type; + + /* Get source address */ + (*incomingFrame)->source_addr = (((uint16_t)rawFrame[4])<<8) + (uint16_t)rawFrame[5]; + //XBEE_DecodeWithoutEscapeChar(&rawFrame[8], rawFrameLength-5, (*incomingFrame)->data, &incomingDataLength); // Data = Frame length -5 + (*incomingFrame)->length = (uint8_t)(dataSize); + (*incomingFrame)->ack = 0; + + for (i=0; idata[i] = rawFrame[i+8]; + + break; + + case XBEE_MODEM_STATUS_TYPE: + allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data + *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ + + (*incomingFrame)->type = frame_type; + + (*incomingFrame)->modem_status = rawFrame[4]; + (*incomingFrame)->data[0]=0x0; + (*incomingFrame)->length = 0; + break; + + case XBEE_TX_STATUS_TYPE: + allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data + *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ + + (*incomingFrame)->ack = rawFrame[5]; + (*incomingFrame)->data[0]=0x0; + (*incomingFrame)->length = 0; + break; + + case XBEE_EXTENDED_TX_STATUS_TYPE: + allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data + *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ + + (*incomingFrame)->ack = rawFrame[8]; + (*incomingFrame)->data[0]=0x0; + (*incomingFrame)->length = 0; + break; + + default: + *incomingFrame=NULL; + return XBEE_INVALID_FRAME; + }; + } else status = XBEE_INVALID_FRAME; + + return status; +} + +/**** TX Part *****/ + +/** + * Send data. Create a transmission frame, add escape char to data and send it over UART + * + * \param data raw data to send + * \param length length of data to send + * \return status of decoding: XBEE_OK if decoding is successful, + * XBEE_TX_ERROR in case of sending error, + * XBEE_TX_TIMEOUT in case semaphore takes too long + */ +int XBEE_SendData(uint16_t address, char* data, int length) { + BaseType_t state; + int status = XBEE_OK; + + // Prevents successive calls to overlap + state = xSemaphoreTake(xHandleSemaphoreTX, pdMS_TO_TICKS(XBEE_TX_SEMAPHORE_WAIT)); // wait max 500 ms (to avoid interlocking) + + if (state != pdFALSE) { /* test semaphore take answer + if answer is false, it means timeout appends + We should probably reset something in "else" branch */ + + XBEE_EncodeTransmissionFrame(data, length, address, (char*) txBuffer, (int*)&txDataToSend); + + LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[0]); + txIndex =1; + LL_USART_EnableIT_TXE(hlpuart1.Instance); // enable TX Interrupt + } else status= XBEE_TX_TIMEOUT; + + return status; +} + +void XBEE_TX_IRQHandler(void) { + BaseType_t xHigherPriorityTaskWoken = pdFALSE; + + LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[txIndex]); + txIndex++; + if (txIndex == txDataToSend) { + LL_USART_DisableIT_TXE(hlpuart1.Instance); + xSemaphoreGiveFromISR( xHandleSemaphoreTX, &xHigherPriorityTaskWoken ); + } + + if (xHigherPriorityTaskWoken) { + /* If xHigherPriorityTaskWoken is now set to pdTRUE then a context switch + should be performed to ensure the interrupt returns directly to the highest + priority task. The macro used for this purpose is dependent on the port in + use and may be called portEND_SWITCHING_ISR(). */ + portYIELD_FROM_ISR( xHigherPriorityTaskWoken ); + } +} + +/***** Rx Part *****/ + +/** + * Reception thread. Wait for incoming frame, process it and send message to application + * + * \param params not used + */ +void XBEE_RxThread(void* params) { + XBEE_INCOMING_FRAME *incomingFrame; + + rxPhase= XBEE_RX_PHASE_SOF; + rxFrameLength=0; + rxDataToReceive=1; + rxIndex=0; + + while (HAL_UART_Receive_IT(&hlpuart1, rxBuffer, 1)!= HAL_OK); // try starting reception of frame + LL_USART_Disable(hlpuart1.Instance); + LL_USART_DisableOverrunDetect(hlpuart1.Instance); + LL_USART_Enable(hlpuart1.Instance); + + // endless task + while (1) { + if (xSemaphoreTake(xHandleSemaphoreRX, portMAX_DELAY)==pdTRUE) { // wait forever + + /* Process frame */ + if (XBEE_DecodeFrame((char*) rxBuffer, &incomingFrame)==XBEE_OK) { // frame is valid + if (incomingFrame != 0x0) // frame is valid + MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_XBEE_CMD, (QueueHandle_t)0x0, (void*)incomingFrame); + // if (rxBuffer[3]== XBEE_RX_16BIT_PACKET_TYPE) { + // MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_XBEE_CMD, (QueueHandle_t)0x0, (void*)0x0); + } + + for (int i=0; isource_addr; + if (receivedCMD != NULL) { + decodedCmd = cmdDecode(receivedCMD,strlen(receivedCMD)); - switch (xbeeFrame->type) { - case XBEE_RX_16BIT_PACKET_TYPE: - decodedCmd = cmdDecode(xbeeFrame->data,xbeeFrame->length); + if (decodedCmd==CMD_DECODE_UNKNOWN) + cmdSendAnswer(ANS_UNKNOWN); + else { + systemInfos.cmd = decodedCmd->type; + systemTimeout.inactivityCnt = 0; - if (decodedCmd==CMD_DECODE_UNKNOWN) - cmdSendAnswer(systemInfos.senderAddress, ANS_UNKNOWN); - else { - systemInfos.cmd = decodedCmd->type; - systemTimeout.inactivityCnt = 0; - - /* Manage answer to command, when possible - * (further treatment of the command will be done in APPLICATION_StateMachine) */ - switch (decodedCmd->type) { - case CMD_PING: - case CMD_TEST: - case CMD_DEBUG: - case CMD_POWER_OFF: - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); - break; - case CMD_GET_BATTERY: - cmdSendBatteryLevel(systemInfos.senderAddress, systemInfos.batteryVoltage); - break; - case CMD_GET_VERSION: - cmdSendVersion(SYSTEM_VERSION); - break; - case CMD_GET_BUSY_STATE: - if (systemInfos.state == stateInMouvement) - cmdSendBusyState(systemInfos.senderAddress, 0x1); - else - cmdSendBusyState(systemInfos.senderAddress, 0x0); - break; - case CMD_MOVE: - systemInfos.distance = ((CMD_Move*)decodedCmd)->distance; - break; - case CMD_TURN: - systemInfos.turns = ((CMD_Turn*)decodedCmd)->turns; - break; - default: - /* All others commands must be processed in state machine - * in order to find what action to do and what answer to give - */ - break; - } - free(decodedCmd); + /* Manage answer to command, when possible + * (further treatment of the command will be done in APPLICATION_StateMachine) */ + switch (decodedCmd->type) { + case CMD_PING: + case CMD_TEST: + case CMD_DEBUG: + case CMD_POWER_OFF: + cmdSendAnswer(ANS_OK); + break; + case CMD_GET_BATTERY: + cmdSendBatteryLevel(systemInfos.batteryVoltage); + break; + case CMD_GET_VERSION: + cmdSendVersion(); + break; + case CMD_GET_BUSY_STATE: + if (systemInfos.state == stateInMouvement) + cmdSendBusyState(0x1); + else + cmdSendBusyState(0x0); + break; + case CMD_MOVE: + systemInfos.distance = ((CMD_Move*)decodedCmd)->distance; + break; + case CMD_TURN: + systemInfos.turns = ((CMD_Turn*)decodedCmd)->turns; + break; + default: + /* All others commands must be processed in state machine + * in order to find what action to do and what answer to give + */ + break; } - break; - - case XBEE_TX_STATUS_TYPE: - if (xbeeFrame->ack == 0) { - if (systemInfos.rfProblem !=0) - systemInfos.rfProblem--; - } else { - if (systemInfos.rfProblem !=255) - systemInfos.rfProblem++; - } - break; - - default: - break; + free(decodedCmd); } + break; - free(xbeeFrame); + default: + break; } + break; - case MSG_ID_BAT_NIVEAU: - case MSG_ID_BAT_CHARGE: + case MSG_ID_BAT_CHARGE_OFF: + case MSG_ID_BAT_CHARGE_COMPLETE: systemInfos.batteryVoltage = *((uint16_t*)msg.data); systemInfos.batteryUpdate = 1; - if (msg.id == MSG_ID_BAT_CHARGE) + if (msg.id == MSG_ID_BAT_CHARGE_COMPLETE) systemInfos.inCharge =1; else systemInfos.inCharge =0; break; - case MSG_ID_BAT_CHARGEUR_ON: - case MSG_ID_BAT_CHARGEUR_OFF: - if (msg.id == MSG_ID_BAT_CHARGEUR_ON) + case MSG_ID_BAT_CHARGE_ON: systemInfos.inCharge =1; - else - systemInfos.inCharge =0; break; case MSG_ID_MOTEURS_STOP: @@ -255,16 +232,16 @@ void APPLICATION_StateMachine() { (systemInfos.state == stateRun) || (systemInfos.state == stateInMouvement)) { /* command RESET is only applicable in those 3 states, otherwise it is rejected */ - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); + cmdSendAnswer(ANS_OK); APPLICATION_TransitionToNewState(stateIdle); } else - cmdSendAnswer(systemInfos.senderAddress, ANS_ERR); + cmdSendAnswer(ANS_ERR); break; case CMD_START_WITH_WATCHDOG: case CMD_START_WITHOUT_WATCHDOG: if (systemInfos.state == stateIdle) { /* only state where START cmd is accepted */ - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); + cmdSendAnswer(ANS_OK); APPLICATION_TransitionToNewState(stateRun); @@ -274,15 +251,15 @@ void APPLICATION_StateMachine() { systemTimeout.watchdogMissedCnt=0; } } else - cmdSendAnswer(systemInfos.senderAddress, ANS_ERR); + cmdSendAnswer(ANS_ERR); break; case CMD_RESET_WATCHDOG: if ((systemInfos.state == stateRun) || (systemInfos.state == stateInMouvement)) { if ((systemTimeout.watchdogEnabled ==0 ) || ((systemTimeout.watchdogCnt>=APPLICATION_WATCHDOG_MIN) && (systemTimeout.watchdogCnt<=APPLICATION_WATCHDOG_MAX))) - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); + cmdSendAnswer(ANS_OK); else - cmdSendAnswer(systemInfos.senderAddress, ANS_ERR); + cmdSendAnswer(ANS_ERR); systemTimeout.watchdogCnt =0; } @@ -294,17 +271,17 @@ void APPLICATION_StateMachine() { if (((systemInfos.cmd == CMD_MOVE) && (systemInfos.distance !=0)) || ((systemInfos.cmd == CMD_TURN) && (systemInfos.turns !=0))) { systemInfos.endOfMouvement = 0; - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); + cmdSendAnswer(ANS_OK); APPLICATION_TransitionToNewState(stateInMouvement); } // if TURN and MOVE are sent without parameter, do nothing: we are still in run state } else if (systemInfos.state == stateInMouvement) { // in this state, MOVE and TURN cmds are accepted only if they come with no parameter if (((systemInfos.cmd == CMD_MOVE) && (systemInfos.distance ==0)) || ((systemInfos.cmd == CMD_TURN) && (systemInfos.turns ==0))) { systemInfos.endOfMouvement = 1; - cmdSendAnswer(systemInfos.senderAddress, ANS_OK); + cmdSendAnswer(ANS_OK); } } else - cmdSendAnswer(systemInfos.senderAddress, ANS_ERR); + cmdSendAnswer(ANS_ERR); break; default: // commands no common for every states break; @@ -390,11 +367,11 @@ void APPLICATION_TransitionToNewState(APPLICATION_State new_state) { } const uint8_t APPLICATION_NiveauBatteryNormal[5] = { - 0 + 0 }; const uint8_t APPLICATION_NiveauBatteryCharge[5] = { - 0 + 0 }; LEDS_State APPLICATION_BatteryLevel(uint8_t voltage, APPLICATION_State state) { diff --git a/software/dumber3/Application/batterie.c b/software/dumber3/Application/batterie.c index 2d9c91f..8ba819e 100644 --- a/software/dumber3/Application/batterie.c +++ b/software/dumber3/Application/batterie.c @@ -6,6 +6,16 @@ */ #include "batterie.h" +#include "stm32l0xx.h" +#include "stm32l0xx_ll_gpio.h" +#include "timers.h" + +typedef enum { + CHARGEUR_NOT_PLUGGED, + CHARGEUR_IN_CHARGE, + CHARGEUR_CHARGE_COMPLETE, + CHARGEUR_ERROR +} BATTERIE_StatusChargerTypedef; extern ADC_HandleTypeDef hadc; uint8_t conversion_complete; @@ -21,6 +31,17 @@ TaskHandle_t xHandleBatterie = NULL; TaskHandle_t task_handler; TaskHandle_t charger_thread_handler; +/* TimerButton sert à attendre ~ 3secondes avant de prendre en compte les IT bouton + * En effet, au demarrage, le bouton est appuyé pour lancer le systeme. ceci genere alors une IT bouton, + * ammenant à envoyer le message MSG_ID_BUTTON_PRESSED, demandant l'arret du systeme + * + * De ce fait, avec cette tempo, on s'assure de ne pas prendre en compte les IT dans les 3 premieres secondes. + */ +StaticTimer_t xBufferTimerButton; +TimerHandle_t xHandleTimerButton = NULL; +void vTimerButtonCallback( TimerHandle_t xTimer ); +uint8_t BUTTON_Inactivity=1; //start with button on/off inactive + void BATTERIE_VoltageThread(void* params); void BATTERIE_Init(void) { @@ -33,12 +54,44 @@ void BATTERIE_Init(void) { "BATTERIE Voltage", /* Text name for the task. */ STACK_SIZE, /* Number of indexes in the xStack array. */ NULL, /* Parameter passed into the task. */ - PriorityLeds,/* Priority at which the task is created. */ + PriorityBatterieHandler,/* Priority at which the task is created. */ xStackBatterie, /* Array to use as the task's stack. */ &xTaskBatterie); /* Variable to hold the task's data structure. */ + + /* Create a periodic task without using any dynamic memory allocation. */ + xHandleTimerButton = xTimerCreateStatic( + "Inactivity Button Timer", + pdMS_TO_TICKS(BUTTON_INACTIVITY_PERIODE), + pdTRUE, + ( void * ) 0, + vTimerButtonCallback, + &xBufferTimerButton); + + xTimerStart(xHandleTimerButton,0 ); vTaskResume(xHandleBatterie); } +/* + * Lit les pins GPIO + */ +BATTERIE_StatusChargerTypedef BATTERIE_LireStatusChargeur(void) { + uint32_t st2 = LL_GPIO_ReadInputPort(CHARGER_ST2_GPIO_Port) & CHARGER_ST2_Pin; + uint32_t st1 = LL_GPIO_ReadInputPort(CHARGER_ST1_GPIO_Port) & CHARGER_ST1_Pin; + + BATTERIE_StatusChargerTypedef status; + + if (st1 && st2) + status = CHARGEUR_NOT_PLUGGED; + else if (st1 && !st2) + status = CHARGEUR_CHARGE_COMPLETE; + else if (!st1 && st2) + status = CHARGEUR_IN_CHARGE; + else /* !st1 && !st2 */ + status = CHARGEUR_ERROR; + + return status; +} + int BATTERIE_LireTension(uint16_t *val) { uint32_t ulNotificationValue; conversion_complete = 0; @@ -66,6 +119,8 @@ int BATTERIE_LireTension(uint16_t *val) { void BATTERIE_VoltageThread(void* params) { static uint16_t tension; + BATTERIE_StatusChargerTypedef currentStatus; + TickType_t xLastWakeTime; // Initialise the xLastWakeTime variable with the current time. @@ -73,10 +128,16 @@ void BATTERIE_VoltageThread(void* params) { while (1) { if (BATTERIE_LireTension(&tension) ==0) { - if (HAL_GPIO_ReadPin(GPIOB, USB_SENSE_Pin)==GPIO_PIN_SET) // le chargeur est branché - MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE, (QueueHandle_t)0x0, (void*)&tension); + + currentStatus = BATTERIE_LireStatusChargeur(); + if (currentStatus == CHARGEUR_ERROR) + MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_ERR, (QueueHandle_t)0x0, (void*)NULL); + else if (currentStatus == CHARGEUR_IN_CHARGE) + MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_ON, (QueueHandle_t)0x0, (void*)&tension); + else if (currentStatus == CHARGEUR_CHARGE_COMPLETE) + MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_COMPLETE, (QueueHandle_t)0x0, (void*)&tension); else - MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_NIVEAU, (QueueHandle_t)0x0, (void*)&tension); + MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_OFF, (QueueHandle_t)0x0, (void*)&tension); } else { MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_BAT_ADC_ERR, (QueueHandle_t)0x0, (void*)0x0); } @@ -106,21 +167,31 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { } } +void vTimerButtonCallback( TimerHandle_t xTimer ) { + BUTTON_Inactivity=0; + + xTimerStop(xHandleTimerButton,0 ); +} + /** * @brief This function handles EXTI line0 interrupt. */ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { BaseType_t xHigherPriorityTaskWoken = pdFALSE; - if (GPIO_Pin == USB_SENSE_Pin) { // Le chargeur vient d'etre branché ou debranché - if (HAL_GPIO_ReadPin(GPIOB, GPIO_Pin)==GPIO_PIN_SET) // le chargeur est branché - MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BAT_CHARGEUR_ON, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); - else - MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BAT_CHARGEUR_OFF, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); - } - else if (GPIO_Pin == BUTTON_SENSE_Pin) { // on vient d'appuyer sur le bouton on/off - if (HAL_GPIO_ReadPin(GPIOB, GPIO_Pin)==GPIO_PIN_SET) // le chargeur est branché - MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BUTTON_PRESSED, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); + // if (GPIO_Pin == USB_SENSE_Pin) { // Le chargeur vient d'etre branché ou debranché + // if (HAL_GPIO_ReadPin(USB_SENSE_GPIO_Port, GPIO_Pin)==GPIO_PIN_SET) // le chargeur est branché + // MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_ON, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); + // else + // MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BAT_CHARGE_OFF, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); + // } + // else + + if (GPIO_Pin == BUTTON_SENSE_Pin) { // on vient d'appuyer sur le bouton on/off + if (!BUTTON_Inactivity) { + if (HAL_GPIO_ReadPin(BUTTON_SENSE_GPIO_Port, GPIO_Pin)==GPIO_PIN_RESET) // GPIOB.3 = 0 => le bouton est appuyé + MESSAGE_SendMailboxFromISR(APPLICATION_Mailbox, MSG_ID_BUTTON_PRESSED, (QueueHandle_t)0x0, 0x0, &xHigherPriorityTaskWoken); + } } if (xHigherPriorityTaskWoken) { diff --git a/software/dumber3/Application/commands.c b/software/dumber3/Application/commands.c index c9851cf..152e4dd 100644 --- a/software/dumber3/Application/commands.c +++ b/software/dumber3/Application/commands.c @@ -7,40 +7,204 @@ #include "commands.h" #include +#include /* Definition des commandes */ +#define PingCMD 'p' +#define ResetCMD 'r' +#define SetMotorCMD 'm' +#define StartWWatchDogCMD 'W' +#define ResetWatchdogCMD 'w' +#define GetBatteryVoltageCMD 'v' +#define GetVersionCMD 'V' +#define StartWithoutWatchCMD 'u' +#define MoveCMD 'M' +#define TurnCMD 'T' +#define BusyStateCMD 'b' +#define TestCMD 't' +#define DebugCMD 'a' +#define PowerOffCMD 'z' + +#define OK_ANS "O\r" +#define ERR_ANS "E\r" +#define UNKNOW_ANS "C\r" +#define BAT_OK "2\r" +#define BAT_LOW "1\r" +#define BAT_EMPTY "0\r" + +char* cmdAddChecksum(const char* str); +char cmdVerifyChecksum(char* str); + +/** @addtogroup Checksum + * @{ + */ +/** + * @brief Inclut le checksum à sendString + * + * Parcours str pour y calculer le checksum ( xor sur chaque caractére) + * et inclut le resultat en fin de chaine. + * + * @param string sans checksum + * @retval string avec checksum + * + */ +char* cmdAddChecksum(const char* str) { + uint16_t j; + unsigned char checksum=0; + char *outstr = (char*) malloc(strlen(str)+2); // +1 for checksum to add, +1 for zero ending + + for (j = 0; str[j] != '\r'; j++) { + outstr[j] = str[j]; + checksum ^= str[j]; + } + + if (checksum == '\r') + checksum++; + outstr[j] = checksum; + outstr[j + 1] = '\r'; + outstr[j + 2] = 0; + + return outstr; +} + +/** + * @brief Verifie le checksum de la variable global recepitString + * + * Vérifie le dernier carctére de str sensé être le checksum. + * Si celui-ci est bon, ll retournera 0 et supprimera le checksum de str + * sinon il retournera 1 sans faire de modification. + * @param None + * @retval 0 ou 1 + * + */ +char cmdVerifyChecksum(char* str) { + uint16_t j; + uint16_t length; + unsigned char checksum=0; + + length = strlen(str); + for (j = 0; j < length - 2; j++) { + checksum ^= str[j]; + } + if (checksum == '\r') + checksum++; + + if (str[j] == checksum) { + str[length - 2] = 13; + str[length - 1] = 0; + str[length] = 0; + + return 0; + } else + return 1; +} + +/** + * @} + */ + +//CMD_Generic* cmdDecode(char* cmd, uint8_t length) { +// CMD_Generic* decodedCmd; +// char cmd_type = cmd[0]; +// +// switch (cmd_type) +// { +// case CMD_MOVE: +// decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Move)); +// decodedCmd->type = CMD_MOVE; +// ((CMD_Move*)decodedCmd)->distance = ((int16_t)cmd[1]<<8) + (int16_t)cmd[2]; +// break; +// +// case CMD_TURN: +// decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Turn)); +// decodedCmd->type = CMD_TURN; +// ((CMD_Turn*)decodedCmd)->turns = ((int16_t)cmd[1]<<8) + (int16_t)cmd[2]; +// break; +// +// case CMD_PING: +// case CMD_RESET: +// case CMD_START_WITHOUT_WATCHDOG: +// case CMD_START_WITH_WATCHDOG: +// case CMD_RESET_WATCHDOG: +// case CMD_GET_BATTERY: +// case CMD_GET_BUSY_STATE: +// case CMD_GET_VERSION: +// case CMD_TEST: +// case CMD_DEBUG: +// case CMD_POWER_OFF: +// decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); +// decodedCmd->type = cmd_type; +// break; +// +// default: +// decodedCmd = CMD_DECODE_UNKNOWN; +// } +// +// return decodedCmd; +//} + CMD_Generic* cmdDecode(char* cmd, uint8_t length) { CMD_Generic* decodedCmd; char cmd_type = cmd[0]; switch (cmd_type) { - case CMD_MOVE: + case MoveCMD: decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Move)); decodedCmd->type = CMD_MOVE; ((CMD_Move*)decodedCmd)->distance = ((int16_t)cmd[1]<<8) + (int16_t)cmd[2]; break; - case CMD_TURN: + case TurnCMD: decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Turn)); decodedCmd->type = CMD_TURN; ((CMD_Turn*)decodedCmd)->turns = ((int16_t)cmd[1]<<8) + (int16_t)cmd[2]; break; - case CMD_PING: - case CMD_RESET: - case CMD_START_WITHOUT_WATCHDOG: - case CMD_START_WITH_WATCHDOG: - case CMD_RESET_WATCHDOG: - case CMD_GET_BATTERY: - case CMD_GET_BUSY_STATE: - case CMD_GET_VERSION: - case CMD_TEST: - case CMD_DEBUG: - case CMD_POWER_OFF: + case PingCMD: decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); - decodedCmd->type = cmd_type; + decodedCmd->type = CMD_PING; + break; + case ResetCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_RESET; + break; + case StartWWatchDogCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_START_WITH_WATCHDOG; + break; + case StartWithoutWatchCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_START_WITHOUT_WATCHDOG; + break; + case ResetWatchdogCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_RESET_WATCHDOG; + break; + case GetBatteryVoltageCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_GET_BATTERY; + break; + case GetVersionCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_GET_VERSION; + break; + case BusyStateCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_GET_BUSY_STATE; + break; + case TestCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_TEST; + break; + case DebugCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_DEBUG; + break; + case PowerOffCMD: + decodedCmd = (CMD_Generic*)malloc(sizeof(CMD_Generic)); + decodedCmd->type = CMD_POWER_OFF; break; default: @@ -50,42 +214,82 @@ CMD_Generic* cmdDecode(char* cmd, uint8_t length) { return decodedCmd; } -void cmdSendAnswer(uint16_t address, uint8_t ans) { - ANS_Generic answer; +void cmdSendAnswer(uint8_t ans) { + char* answer; - answer.ans = ans; - XBEE_SendData(address, (char*)&answer, sizeof (answer)); + switch (ans) { + case ANS_OK: + answer = cmdAddChecksum(OK_ANS); + break; + case ANS_ERR: + answer = cmdAddChecksum(ERR_ANS); + break; + default: + answer = cmdAddChecksum(UNKNOW_ANS); + break; + } + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (char*) answer); } -void cmdSendBatteryLevel(uint16_t address, char level) { - ANS_Battery answer; +void cmdSendString(char *str) { + char* answer; + int strlength = strlen(str); + char localstr[strlength+2]; + + strncpy(localstr, str, strlength+2); + if (localstr[strlength-1]!='\r') { // \r n'est pas present + localstr[strlength]='\r'; + localstr[strlength+1]=0; + } + + answer = cmdAddChecksum(localstr); + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (char*) answer); +} + +void cmdSendBatteryLevel(char level) { + char* answer; char localLevel=level; if (localLevel<0) localLevel=0; else if (localLevel>2) localLevel=2; - answer.ans = ANS_OK; - answer.bat_level = localLevel; + switch (localLevel) { + case 2: + answer = cmdAddChecksum("2\r"); + break; + case 1: + answer = cmdAddChecksum("1\r"); + break; + default: + answer = cmdAddChecksum("0\r"); + break; + } - XBEE_SendData(address, (char*)&answer, sizeof (answer)); + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (char*) answer); } -void cmdSendVersion(uint16_t address) { - ANS_Version answer; +void cmdSendVersion(void) { + int versionlength = strlen(SYSTEM_VERSION_STR); + char versionstr[versionlength+2]; + char* answer; - answer.ans = ANS_OK; - answer.version=SYSTEM_VERSION; + strncpy(versionstr,SYSTEM_VERSION_STR,versionlength+2); + versionstr[versionlength] = '\r'; + versionstr[versionlength+1]=0; // zero ending string - XBEE_SendData(address, (char*)&answer, sizeof (answer)); + answer = cmdAddChecksum(versionstr); + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (char*) answer); } -void cmdSendBusyState(uint16_t address, uint8_t state) { - ANS_Busy_State answer; +void cmdSendBusyState(uint8_t state) { + char* answer; - answer.ans = ANS_OK; - answer.state = state; + if (state) + answer = cmdAddChecksum("1\r"); + else + answer = cmdAddChecksum("0\r"); - if (answer.state >1) answer.state=0; - - XBEE_SendData(address, (char*)&answer, sizeof (answer)); + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (char*) answer); } diff --git a/software/dumber3/Application/commands.h b/software/dumber3/Application/commands.h index 9e90eff..fe091ee 100644 --- a/software/dumber3/Application/commands.h +++ b/software/dumber3/Application/commands.h @@ -81,9 +81,10 @@ typedef struct __attribute__((packed)) { #define CMD_DECODE_UNKNOWN ((CMD_Generic*)UINT32_MAX) CMD_Generic* cmdDecode(char* cmd, uint8_t length); -void cmdSendAnswer(uint16_t address, uint8_t ans); -void cmdSendBatteryLevel(uint16_t address, char level); -void cmdSendVersion(uint16_t address); -void cmdSendBusyState(uint16_t address, uint8_t state); +void cmdSendAnswer(uint8_t ans); +void cmdSendString(char* str); +void cmdSendBatteryLevel(char level); +void cmdSendVersion(void); +void cmdSendBusyState(uint8_t state); #endif /* INC_CMD_H_ */ diff --git a/software/dumber3/Application/config.h b/software/dumber3/Application/config.h index ca18c29..430cd39 100644 --- a/software/dumber3/Application/config.h +++ b/software/dumber3/Application/config.h @@ -14,30 +14,47 @@ #define STACK_SIZE 0x100 #define PriorityMoteursAsservissement (configMAX_PRIORITIES -1) -#define PriorityXbeeRX (configMAX_PRIORITIES -2) -#define PriorityXbeeTX (configMAX_PRIORITIES -3) -#define PriorityMoteurs (configMAX_PRIORITIES -4) -#define PriorityBatterie (configMAX_PRIORITIES -5) -#define PriorityApplicationMain (configMAX_PRIORITIES -6) -#define PrioritySequenceurTimeout (configMAX_PRIORITIES -7) -#define PriorityLeds (configMAX_PRIORITIES -8) +#define PriorityXbeeRX (configMAX_PRIORITIES -2) +#define PriorityXbeeTX (configMAX_PRIORITIES -3) +#define PriorityMoteursHandler (configMAX_PRIORITIES -4) +#define PriorityBatterieHandler (configMAX_PRIORITIES -5) +#define PriorityApplicationHandler (configMAX_PRIORITIES -6) +#define PrioritySequenceurTimeout (configMAX_PRIORITIES -7) +#define PriorityLedsAction (configMAX_PRIORITIES -8) +#define PriorityLedsHandler (configMAX_PRIORITIES -9) + +#define PriorityTestsHandler (configMAX_PRIORITIES -10) /* Périodes des taches périodiques (en ms) */ #define MOTEURS_PERIODE_ASSERVISSEMENT (2) #define APPLICATION_PERIODE (100) #define BATTERIE_PERIODE_SCRUTATION (1000) #define LEDS_PERIODE (100) +#define BUTTON_INACTIVITY_PERIODE (1500) -#define XBEE_TX_SEMAPHORE_WAIT 500 -#define XBEE_RX_BUFFER_MAX_LENGTH 50 +#define TESTS_PERIODE (5000) -#define BATTERY_EMPTY_LEVEL 128 -#define BATTERY_LOW_LEVEL 140 +#define XBEE_TX_SEMAPHORE_WAIT 500 +#ifdef TESTS +#define XBEE_RX_BUFFER_MAX_LENGTH 100 +#define XBEE_TX_BUFFER_MAX_LENGTH 100 +#else +#define XBEE_RX_BUFFER_MAX_LENGTH 50 +#define XBEE_TX_BUFFER_MAX_LENGTH 50 +#endif /* TESTS */ + +#define BATTERY_EMPTY_LEVEL 128 +#define BATTERY_LOW_LEVEL 140 /* * Revoir les délais : c'est en 100 ms, pas ms */ +#ifdef TESTS +#define APPLICATION_INACTIVITY_TIMEOUT (0xFFFFFFFF) // Max U32, infinite timeout +#else #define APPLICATION_INACTIVITY_TIMEOUT (2*60*1000) // 2 minutes, expressed in ms +#endif /* TESTS */ + #define APPLICATION_WATCHDOG_MIN (900) // minimum time to wait before resetting watchdog, expressed in ms #define APPLICATION_WATCHDOG_MAX (1100) // maximum time to wait before resetting watchdog, expressed in ms #define APPLICATION_WATCHDOG_MISSED_MAX (3) // Maximum missed timeout reset before entering watchdog disabled state diff --git a/software/dumber3/Application/leds.c b/software/dumber3/Application/leds.c index fb0cfd3..f09968f 100644 --- a/software/dumber3/Application/leds.c +++ b/software/dumber3/Application/leds.c @@ -108,17 +108,26 @@ uint16_t LEDS_Patterns [LED_MAX_PATTERNS][4]= { LEDS_State LEDS_Animation; LEDS_State LEDS_AnimationAncien; -StaticTask_t xTaskLeds; +StaticTask_t xTaskLedsHandler; /* Buffer that the task being created will use as its stack. Note this is an array of StackType_t variables. The size of StackType_t is dependent on the RTOS port. */ -StackType_t xStackLeds[ STACK_SIZE ]; -TaskHandle_t xHandleLeds = NULL; +StackType_t xStackLedsHandler[ STACK_SIZE ]; +TaskHandle_t xHandleLedsHandler = NULL; -void LEDS_AnimationThread(void* params); +StaticTask_t xTaskLedsAction; + +/* Buffer that the task being created will use as its stack. Note this is + an array of StackType_t variables. The size of StackType_t is dependent on + the RTOS port. */ +StackType_t xStackLedsAction[ STACK_SIZE ]; +TaskHandle_t xHandleLedsAction = NULL; + +void LEDS_ActionThread(void* params); void LEDS_ShowPattern(uint8_t pattern); void LEDS_Tests(void* params); +void LEDS_HandlerThread(void* params); void LEDS_Init(void) { LEDS_Eteint_Tout(); @@ -129,15 +138,16 @@ void LEDS_Init(void) { /* Mailbox is created in messages.c */ /* Create the task without using any dynamic memory allocation. */ - xHandleLeds = xTaskCreateStatic( - LEDS_AnimationThread, /* Function that implements the task. */ - "LEDS Animation", /* Text name for the task. */ + xHandleLedsHandler = xTaskCreateStatic( + LEDS_HandlerThread, /* Function that implements the task. */ + "LEDS Handler", /* Text name for the task. */ STACK_SIZE, /* Number of indexes in the xStack array. */ NULL, /* Parameter passed into the task. */ - PriorityLeds,/* Priority at which the task is created. */ - xStackLeds, /* Array to use as the task's stack. */ - &xTaskLeds); /* Variable to hold the task's data structure. */ - vTaskResume(xHandleLeds); + PriorityLedsHandler,/* Priority at which the task is created. */ + xStackLedsHandler, /* Array to use as the task's stack. */ + &xTaskLedsHandler); /* Variable to hold the task's data structure. */ + + vTaskResume(xHandleLedsHandler); } void LEDS_ShowPattern(uint8_t pattern) { @@ -166,20 +176,12 @@ void LEDS_Tests(void* params) { } } -void LEDS_AnimationThread(void* params) { +void LEDS_HandlerThread(void* params) { MESSAGE_Typedef msg; - uint8_t cnt=0; - TickType_t xLastWakeTime; - - // Initialise the xLastWakeTime variable with the current time. - xLastWakeTime = xTaskGetTickCount(); while (1) { - // Wait for the next cycle. - vTaskDelayUntil( &xLastWakeTime, pdMS_TO_TICKS(LEDS_PERIODE)); - msg = MESSAGE_ReadMailboxNoDelay(LEDS_Mailbox); - cnt++; + msg = MESSAGE_ReadMailbox(LEDS_Mailbox); if (msg.id == MSG_ID_LED_ETAT) { // Si c'est bien un message de changement d'etat LEDS LEDS_Animation = *((LEDS_State*)msg.data); @@ -188,10 +190,35 @@ void LEDS_AnimationThread(void* params) { // dans ce cas, on eteint les leds pour repartir sur une base saine LEDS_AnimationAncien = LEDS_Animation; - LEDS_Eteint_Tout(); - cnt=0; + /* If action task is running, destroy it first */ + if (xHandleLedsAction!= NULL) vTaskDelete(xHandleLedsAction); + + /* Create the task without using any dynamic memory allocation. */ + xHandleLedsAction = xTaskCreateStatic( + LEDS_ActionThread, /* Function that implements the task. */ + "LEDS Action", /* Text name for the task. */ + STACK_SIZE, /* Number of indexes in the xStack array. */ + NULL, /* Parameter passed into the task. */ + PriorityLedsAction,/* Priority at which the task is created. */ + xStackLedsAction, /* Array to use as the task's stack. */ + &xTaskLedsAction); /* Variable to hold the task's data structure. */ + + vTaskResume(xHandleLedsAction); } } + } +} + +void LEDS_ActionThread(void* params) { + uint8_t cnt=0; + TickType_t xLastWakeTime; + + // Initialise the xLastWakeTime variable with the current time. + xLastWakeTime = xTaskGetTickCount(); + + LEDS_Eteint_Tout(); + + while (1) { switch (LEDS_Animation) { case leds_off: @@ -342,5 +369,11 @@ void LEDS_AnimationThread(void* params) { default: break; } + + // Wait for the next cycle. + vTaskDelayUntil( &xLastWakeTime, pdMS_TO_TICKS(LEDS_PERIODE)); + + cnt++; } } + diff --git a/software/dumber3/Application/messages.c b/software/dumber3/Application/messages.c index 9ed6d67..1eb2b00 100644 --- a/software/dumber3/Application/messages.c +++ b/software/dumber3/Application/messages.c @@ -13,13 +13,13 @@ QueueHandle_t LEDS_Mailbox; QueueHandle_t MOTEURS_Mailbox; QueueHandle_t APPLICATION_Mailbox; -QueueHandle_t BATTERIE_Mailbox; QueueHandle_t XBEE_Mailbox; void MESSAGE_Init(void) { LEDS_Mailbox = xQueueCreate(QUEUE_SIZE, sizeof(MESSAGE_Typedef)); MOTEURS_Mailbox = xQueueCreate(QUEUE_SIZE, sizeof(MESSAGE_Typedef)); APPLICATION_Mailbox = xQueueCreate(QUEUE_SIZE, sizeof(MESSAGE_Typedef)); + XBEE_Mailbox = xQueueCreate(QUEUE_SIZE, sizeof(MESSAGE_Typedef)); } MESSAGE_Typedef MESSAGE_ReadMailbox(QueueHandle_t mbx) { diff --git a/software/dumber3/Application/messages.h b/software/dumber3/Application/messages.h index 1a61190..faf4744 100644 --- a/software/dumber3/Application/messages.h +++ b/software/dumber3/Application/messages.h @@ -20,17 +20,17 @@ typedef struct { extern QueueHandle_t LEDS_Mailbox; extern QueueHandle_t MOTEURS_Mailbox; extern QueueHandle_t APPLICATION_Mailbox; +extern QueueHandle_t XBEE_Mailbox; #define MSG_ID_NO_MESSAGE 0x00 #define MSG_ID_LED_ETAT 0x10 -#define MSG_ID_BAT_NIVEAU 0x20 -#define MSG_ID_BAT_CHARGE 0x21 -#define MSG_ID_BAT_CHARGEUR_ON 0x22 -#define MSG_ID_BAT_CHARGEUR_OFF 0x23 -#define MSG_ID_BAT_CHARGEUR_ERR 0x24 -#define MSG_ID_BAT_ADC_ERR 0x25 +#define MSG_ID_BAT_CHARGE_COMPLETE 0x20 +#define MSG_ID_BAT_CHARGE_ON 0x21 +#define MSG_ID_BAT_CHARGE_OFF 0x22 +#define MSG_ID_BAT_CHARGE_ERR 0x23 +#define MSG_ID_BAT_ADC_ERR 0x24 #define MSG_ID_BUTTON_PRESSED 0x30 @@ -39,6 +39,7 @@ extern QueueHandle_t APPLICATION_Mailbox; #define MSG_ID_MOTEURS_TURN 0x42 #define MSG_ID_XBEE_CMD 0x50 +#define MSG_ID_XBEE_ANS 0x51 void MESSAGE_Init(void); MESSAGE_Typedef MESSAGE_ReadMailbox(QueueHandle_t mbx); diff --git a/software/dumber3/Application/moteurs.c b/software/dumber3/Application/moteurs.c index 697269c..9291e22 100644 --- a/software/dumber3/Application/moteurs.c +++ b/software/dumber3/Application/moteurs.c @@ -83,7 +83,7 @@ void MOTEURS_Init(void) { "MOTEURS Principale", /* Text name for the task. */ STACK_SIZE, /* Number of indexes in the xStack array. */ NULL, /* Parameter passed into the task. */ - PriorityMoteurs,/* Priority at which the task is created. */ + PriorityMoteursHandler,/* Priority at which the task is created. */ xStackMoteurs, /* Array to use as the task's stack. */ &xTaskMoteurs); /* Variable to hold the task's data structure. */ vTaskResume(xHandleMoteurs); diff --git a/software/dumber3/Application/xbee.c b/software/dumber3/Application/xbee.c index e4fecd0..efe7e4b 100644 --- a/software/dumber3/Application/xbee.c +++ b/software/dumber3/Application/xbee.c @@ -22,26 +22,37 @@ extern DMA_HandleTypeDef hdma_lpuart1_rx; #define XBEE_API_XON 0x11 #define XBEE_API_XOFF 0x13 +#define XBEE_ENDING_CHAR '\r' + +/***** TX part *****/ +void XBEE_TxHandlerThread(void* params); +int XBEE_SendData(char* data); + +/* Stuff for Xbee TX task */ +StaticTask_t xTaskXbeeTXHandler; +StackType_t xStackXbeeTXHandler[ STACK_SIZE ]; +TaskHandle_t xHandleXbeeTXHandler = NULL; + +uint8_t txBuffer[XBEE_TX_BUFFER_MAX_LENGTH]={0}; +uint16_t txIndex; +uint16_t txRemainingData; +uint16_t txDataToSend; + /***** RX part *****/ +void XBEE_RxThread(void* params); + +SemaphoreHandle_t xHandleSemaphoreRX = NULL; +StaticSemaphore_t xSemaphoreRx; /* Stuff for Xbee RX task */ StaticTask_t xTaskXbeeRX; StackType_t xStackXbeeRX[ STACK_SIZE ]; TaskHandle_t xHandleXbeeRX = NULL; -uint8_t txBuffer[XBEE_RX_BUFFER_MAX_LENGTH]={0}; -uint16_t txIndex; -uint16_t txDataToSend; - -void XBEE_RxThread(void* params); - -SemaphoreHandle_t xHandleSemaphoreRX = NULL; -StaticSemaphore_t xSemaphoreRx; - uint8_t rxBuffer[XBEE_RX_BUFFER_MAX_LENGTH]={0}; //uint8_t rxWaitForACK =0; uint8_t rxPhase; -uint16_t rxFrameLength; +uint16_t rxCmdLength; uint16_t rxDataToReceive; uint16_t rxIndex; @@ -51,13 +62,13 @@ uint16_t rxIndex; /****** TX part ******/ SemaphoreHandle_t xHandleSemaphoreTX = NULL; -SemaphoreHandle_t xHandleSemaphoreTX_ACK = NULL; +//SemaphoreHandle_t xHandleSemaphoreTX_ACK = NULL; StaticSemaphore_t xSemaphoreTX; -StaticSemaphore_t xSemaphoreTX_ACK; +//StaticSemaphore_t xSemaphoreTX_ACK; void XBEE_Init(void) { xHandleSemaphoreTX = xSemaphoreCreateBinaryStatic( &xSemaphoreTX ); - xHandleSemaphoreTX_ACK = xSemaphoreCreateBinaryStatic( &xSemaphoreTX_ACK ); + //xHandleSemaphoreTX_ACK = xSemaphoreCreateBinaryStatic( &xSemaphoreTX_ACK ); xSemaphoreGive(xHandleSemaphoreTX); //xSemaphoreTake(xHandleSemaphoreTX_ACK); @@ -69,224 +80,53 @@ void XBEE_Init(void) { "XBEE Rx", /* Text name for the task. */ STACK_SIZE, /* Number of indexes in the xStack array. */ NULL, /* Parameter passed into the task. */ - PriorityMoteurs,/* Priority at which the task is created. */ + PriorityXbeeRX,/* Priority at which the task is created. */ xStackXbeeRX, /* Array to use as the task's stack. */ &xTaskXbeeRX); /* Variable to hold the task's data structure. */ vTaskResume(xHandleXbeeRX); + /* Create the task without using any dynamic memory allocation. */ + xHandleXbeeTXHandler = xTaskCreateStatic( + XBEE_TxHandlerThread, /* Function that implements the task. */ + "XBEE Tx", /* Text name for the task. */ + STACK_SIZE, /* Number of indexes in the xStack array. */ + NULL, /* Parameter passed into the task. */ + PriorityXbeeTX,/* Priority at which the task is created. */ + xStackXbeeTXHandler, /* Array to use as the task's stack. */ + &xTaskXbeeTXHandler); /* Variable to hold the task's data structure. */ + vTaskResume(xHandleXbeeTXHandler); + /* Enable Xbee */ HAL_GPIO_WritePin(XBEE_RESET_GPIO_Port, XBEE_RESET_Pin, GPIO_PIN_SET); } /**** Support functions ****/ -/** - * Compute length of encoded data using escape char - * - * \param data pointer on raw data - * \param length length of raw data - * \return length of data when encoded - */ -int XBEE_GetDataLength(char* data, int length) { - int encodedLength=0; - - for (int i=0; i< length; i++) { - if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || - (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { - encodedLength++; /* Add 1 byte for escape char */ - } - - encodedLength++; /* Add current char in length calculation */ - data++; /* move to next byte in raw buffer */ - } - - return encodedLength; -} - -/** - * Convert raw data into escaped data. Create a new buffer that is returned - * - * \param data pointer on raw data - * \param length length of raw data - * \param encodedLength length of encoded data - * \return new buffer allocated with escaped char - */ -char* XBEE_EncodeWithEscapeChar(char* data, int length, int *encodedLength) { - char* encodedData; - - *encodedLength=XBEE_GetDataLength(data, length); - encodedData = (char*)malloc(*encodedLength); - - for (char* p=encodedData; p< (encodedData + *encodedLength); p++) { - if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || - (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { - *p = (char) XBEE_API_ESCAPE_CHAR; - p++; - } - - *p = *data; - data++; - } - - return encodedData; -} - -/** - * Get a raw buffer and convert it into a transmission frame - * - * \param data pointer on raw data - * \param length length of raw data - * \param destination address of the destination - * \param frameLength length of frame - * \return new frame (allocated) containing escaped data - */ -void XBEE_EncodeTransmissionFrame(char* data, int length, uint16_t destination, char* frame, int* frameLength) { - uint8_t checksum=0; - uint16_t localLength=0; - char* p; - - localLength = length+9; - - frame[0] = (char)XBEE_FRAME_SOF_CHAR; - frame[1] = (char)((uint16_t)(localLength-4)>>8); - frame[2] = (char)((uint16_t)(localLength-4)); - frame[3] = (char)XBEE_TX_16BIT_REQUEST_TYPE; - frame[4] = 0x1; - - frame[5] = (char)((uint16_t)(destination)>>8); - frame[6] = (char)((uint16_t)(destination)); - - frame[7] = 0x0; - - for (p = &frame[8]; p< (data + length); p++) { - if ((*data == (char)XBEE_API_ESCAPE_CHAR) || (*data == (char)XBEE_API_START_OF_FRAME) || - (*data == (char)XBEE_API_XOFF) ||(*data == (char)XBEE_API_XON)) { - *p = (char) XBEE_API_ESCAPE_CHAR; - p++; - *p = *data^0x20; - } else - *p = *data; - - data++; - } - - /* calcul du checksum */ - for (int i=3; i<(localLength-1); i++) { - checksum += (uint8_t)frame[i]; - } - - *p = 0xFF-checksum; - *frameLength = localLength; -} - -/** - * Get frame length - * - * \param frame pointer on frame header - * \return length of incoming frame - */ -uint16_t XBEE_GetFrameLength(uint8_t *frame) { - return (((uint16_t)frame[1])<<8) + (uint16_t)frame[2]; -} - -/** - * Get a complete frame, check if frame is correct and extract raw data - * - * \param raw_frame pointer on complete frame - * \param incomingFrame pointer to processed frame, with escape char removed - * \return status of decoding: XBEE_OK if decoding is successful, XBEE_INVALID_FRAME otherwise - */ -XBEE_Status XBEE_DecodeFrame(char* rawFrame, XBEE_INCOMING_FRAME** incomingFrame) { - uint8_t frame_type = (uint8_t)rawFrame[3]; - uint16_t rawFrameLength; - uint8_t checksum; - XBEE_Status status = XBEE_OK; - int allocatedSize; - int dataSize; - - int i; - - if (rawFrame[0] == '~') { - rawFrameLength = (((uint16_t)rawFrame[1])<<8) + (uint16_t)rawFrame[2]; - - /* verification du checksum */ - checksum =0; - for (i=3; i<3+rawFrameLength+1; i++) { - checksum += (uint8_t)rawFrame[i]; - } - - if (checksum != 0xFF) - return XBEE_INVALID_FRAME; - - switch (frame_type) { - case XBEE_RX_16BIT_PACKET_TYPE: - dataSize = rawFrameLength-5; // there is 5 bytes of "other" data than truly data bytes in a frame - allocatedSize = sizeof(XBEE_INCOMING_FRAME)+dataSize; - - *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ - (*incomingFrame)->type = frame_type; - - /* Get source address */ - (*incomingFrame)->source_addr = (((uint16_t)rawFrame[4])<<8) + (uint16_t)rawFrame[5]; - //XBEE_DecodeWithoutEscapeChar(&rawFrame[8], rawFrameLength-5, (*incomingFrame)->data, &incomingDataLength); // Data = Frame length -5 - (*incomingFrame)->length = (uint8_t)(dataSize); - (*incomingFrame)->ack = 0; - - for (i=0; idata[i] = rawFrame[i+8]; - - break; - - case XBEE_MODEM_STATUS_TYPE: - allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data - *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ - - (*incomingFrame)->type = frame_type; - - (*incomingFrame)->modem_status = rawFrame[4]; - (*incomingFrame)->data[0]=0x0; - (*incomingFrame)->length = 0; - break; - - case XBEE_TX_STATUS_TYPE: - allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data - *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ - - (*incomingFrame)->ack = rawFrame[5]; - (*incomingFrame)->data[0]=0x0; - (*incomingFrame)->length = 0; - break; - - case XBEE_EXTENDED_TX_STATUS_TYPE: - allocatedSize = sizeof(XBEE_INCOMING_FRAME); // no data - *incomingFrame = (XBEE_INCOMING_FRAME*) malloc(allocatedSize); /* Allocate a generic frame struct */ - - (*incomingFrame)->ack = rawFrame[8]; - (*incomingFrame)->data[0]=0x0; - (*incomingFrame)->length = 0; - break; - - default: - *incomingFrame=NULL; - return XBEE_INVALID_FRAME; - }; - } else status = XBEE_INVALID_FRAME; - - return status; -} - /**** TX Part *****/ +void XBEE_TxHandlerThread(void* params) { + MESSAGE_Typedef msg; + + while (1) { + msg = MESSAGE_ReadMailbox(XBEE_Mailbox); + + if (msg.id == MSG_ID_XBEE_ANS) { + XBEE_SendData((char*)msg.data); // block function during send + + free(msg.data); + } + } +} + /** * Send data. Create a transmission frame, add escape char to data and send it over UART * * \param data raw data to send - * \param length length of data to send * \return status of decoding: XBEE_OK if decoding is successful, * XBEE_TX_ERROR in case of sending error, * XBEE_TX_TIMEOUT in case semaphore takes too long */ -int XBEE_SendData(uint16_t address, char* data, int length) { +int XBEE_SendData(char* data) { BaseType_t state; int status = XBEE_OK; @@ -297,11 +137,17 @@ int XBEE_SendData(uint16_t address, char* data, int length) { if answer is false, it means timeout appends We should probably reset something in "else" branch */ - XBEE_EncodeTransmissionFrame(data, length, address, (char*) txBuffer, (int*)&txDataToSend); + strncpy((char*)txBuffer,data,XBEE_TX_BUFFER_MAX_LENGTH-1); + txBuffer[XBEE_TX_BUFFER_MAX_LENGTH-1]=0; + txRemainingData = strlen((char*)txBuffer); - LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[0]); - txIndex =1; - LL_USART_EnableIT_TXE(hlpuart1.Instance); // enable TX Interrupt + if (txRemainingData!=0) { + txIndex =1; + txRemainingData=txRemainingData-1; + + LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[0]); + LL_USART_EnableIT_TXE(hlpuart1.Instance); // enable TX Interrupt + } } else status= XBEE_TX_TIMEOUT; return status; @@ -310,11 +156,13 @@ int XBEE_SendData(uint16_t address, char* data, int length) { void XBEE_TX_IRQHandler(void) { BaseType_t xHigherPriorityTaskWoken = pdFALSE; - LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[txIndex]); - txIndex++; - if (txIndex == txDataToSend) { + if (txRemainingData==0) { // No more data, disable TXE bit LL_USART_DisableIT_TXE(hlpuart1.Instance); xSemaphoreGiveFromISR( xHandleSemaphoreTX, &xHigherPriorityTaskWoken ); + } else { + LL_USART_TransmitData8(hlpuart1.Instance, txBuffer[txIndex]); + txIndex++; + txRemainingData--; } if (xHigherPriorityTaskWoken) { @@ -334,11 +182,9 @@ void XBEE_TX_IRQHandler(void) { * \param params not used */ void XBEE_RxThread(void* params) { - XBEE_INCOMING_FRAME *incomingFrame; - - rxPhase= XBEE_RX_PHASE_SOF; - rxFrameLength=0; - rxDataToReceive=1; + //XBEE_INCOMING_FRAME *incomingFrame; + char* incomingData; + rxCmdLength=0; rxIndex=0; while (HAL_UART_Receive_IT(&hlpuart1, rxBuffer, 1)!= HAL_OK); // try starting reception of frame @@ -350,16 +196,13 @@ void XBEE_RxThread(void* params) { while (1) { if (xSemaphoreTake(xHandleSemaphoreRX, portMAX_DELAY)==pdTRUE) { // wait forever - /* Process frame */ - if (XBEE_DecodeFrame((char*) rxBuffer, &incomingFrame)==XBEE_OK) { // frame is valid - if (incomingFrame != 0x0) // frame is valid - MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_XBEE_CMD, (QueueHandle_t)0x0, (void*)incomingFrame); - // if (rxBuffer[3]== XBEE_RX_16BIT_PACKET_TYPE) { - // MESSAGE_SendMailbox(APPLICATION_Mailbox, MSG_ID_XBEE_CMD, (QueueHandle_t)0x0, (void*)0x0); - } + incomingData = (char*)malloc(rxCmdLength+1); // +1 for ending zero ! + strncpy (incomingData, (char*)rxBuffer, XBEE_RX_BUFFER_MAX_LENGTH); - for (int i=0; i=XBEE_RX_BUFFER_MAX_LENGTH) rxIndex=0; - rxPhase = XBEE_RX_PHASE_SOF; - xSemaphoreGiveFromISR( xHandleSemaphoreRX, &xHigherPriorityTaskWoken ); /* send event to receive task to process received task */ - } - break; - default: - while(1); + + rxCmdLength++; + if (rxCmdLength>=XBEE_RX_BUFFER_MAX_LENGTH) + rxCmdLength=0; + } else { // end of command received + rxBuffer[rxIndex] = 0; // ending zero for C string + xSemaphoreGiveFromISR( xHandleSemaphoreRX, &xHigherPriorityTaskWoken ); /* send event to receive task to process received task */ } if (xHigherPriorityTaskWoken) { @@ -426,15 +245,20 @@ void LPUART1_IRQHandler(void) { if (LL_USART_IsActiveFlag_RXNE(hlpuart1.Instance)) { XBEE_RX_IRQHandler(); - } else if (LL_USART_IsActiveFlag_TXE(hlpuart1.Instance)) { + } else if ((LL_USART_IsEnabledIT_TXE(hlpuart1.Instance)) && (LL_USART_IsActiveFlag_TXE(hlpuart1.Instance))) { XBEE_TX_IRQHandler(); } else { - if (LL_USART_IsActiveFlag_TC(hlpuart1.Instance)) + if ((LL_USART_IsEnabledIT_TC(hlpuart1.Instance)) && (LL_USART_IsActiveFlag_TC(hlpuart1.Instance))) LL_USART_DisableIT_TC(hlpuart1.Instance); - else if (LL_USART_IsActiveFlag_IDLE(hlpuart1.Instance)) + else if ((LL_USART_IsEnabledIT_IDLE(hlpuart1.Instance)) && (LL_USART_IsActiveFlag_IDLE(hlpuart1.Instance))) LL_USART_ClearFlag_IDLE(hlpuart1.Instance); - else if (LL_USART_IsActiveFlag_ORE(hlpuart1.Instance)) { + else { LL_USART_ClearFlag_ORE(hlpuart1.Instance); + LL_USART_ClearFlag_FE(hlpuart1.Instance); + LL_USART_ClearFlag_PE(hlpuart1.Instance); + LL_USART_ClearFlag_NE(hlpuart1.Instance); + LL_USART_DisableIT_ERROR(hlpuart1.Instance); + LL_USART_DisableIT_PE(hlpuart1.Instance); } } } diff --git a/software/dumber3/Application/xbee.h b/software/dumber3/Application/xbee.h index c3d9dc3..feee3a6 100644 --- a/software/dumber3/Application/xbee.h +++ b/software/dumber3/Application/xbee.h @@ -62,6 +62,5 @@ typedef struct { } XBEE_INCOMING_FRAME; void XBEE_Init(void); -int XBEE_SendData(uint16_t address, char* data, int length); #endif /* INC_XBEE_H_ */ diff --git a/software/dumber3/Core/Inc/FreeRTOSConfig.h b/software/dumber3/Core/Inc/FreeRTOSConfig.h index 5bdb46f..8237fe0 100644 --- a/software/dumber3/Core/Inc/FreeRTOSConfig.h +++ b/software/dumber3/Core/Inc/FreeRTOSConfig.h @@ -86,7 +86,7 @@ /* Software timer definitions. */ #define configUSE_TIMERS 1 -#define configTIMER_TASK_PRIORITY ( 2 ) +#define configTIMER_TASK_PRIORITY ( 3 ) #define configTIMER_QUEUE_LENGTH 10 #define configTIMER_TASK_STACK_DEPTH 256 diff --git a/software/dumber3/Core/Inc/main.h b/software/dumber3/Core/Inc/main.h index 833c8cc..7859ff8 100644 --- a/software/dumber3/Core/Inc/main.h +++ b/software/dumber3/Core/Inc/main.h @@ -67,8 +67,6 @@ void Error_Handler(void); #define ENC_PHA_GAUCHE_GPIO_Port GPIOA #define ENC_PHA_DROIT_Pin GPIO_PIN_2 #define ENC_PHA_DROIT_GPIO_Port GPIOA -#define ENC_PHB_DROIT_Pin GPIO_PIN_4 -#define ENC_PHB_DROIT_GPIO_Port GPIOA #define ENC_PHB_GAUCHE_Pin GPIO_PIN_5 #define ENC_PHB_GAUCHE_GPIO_Port GPIOA #define PWM_B_GAUCHE_Pin GPIO_PIN_6 diff --git a/software/dumber3/Core/Inc/stm32l0xx_it.h b/software/dumber3/Core/Inc/stm32l0xx_it.h index 6c0473b..3cc18a4 100644 --- a/software/dumber3/Core/Inc/stm32l0xx_it.h +++ b/software/dumber3/Core/Inc/stm32l0xx_it.h @@ -51,7 +51,6 @@ void NMI_Handler(void); void HardFault_Handler(void); void EXTI2_3_IRQHandler(void); void EXTI4_15_IRQHandler(void); -void DMA1_Channel2_3_IRQHandler(void); void ADC1_COMP_IRQHandler(void); void TIM2_IRQHandler(void); void TIM6_IRQHandler(void); diff --git a/software/dumber3/Core/Src/freertos.c b/software/dumber3/Core/Src/freertos.c index 08344c9..3981e5c 100644 --- a/software/dumber3/Core/Src/freertos.c +++ b/software/dumber3/Core/Src/freertos.c @@ -57,6 +57,7 @@ __weak void PreSleepProcessing(uint32_t *ulExpectedIdleTime) { /* place for user code */ + *ulExpectedIdleTime=0; } __weak void PostSleepProcessing(uint32_t *ulExpectedIdleTime) diff --git a/software/dumber3/Core/Src/main.c b/software/dumber3/Core/Src/main.c index 8f12367..d7f4120 100644 --- a/software/dumber3/Core/Src/main.c +++ b/software/dumber3/Core/Src/main.c @@ -24,6 +24,7 @@ /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ #include "application.h" +#include "tests.h" /* USER CODE END Includes */ @@ -45,12 +46,10 @@ ADC_HandleTypeDef hadc; UART_HandleTypeDef hlpuart1; -DMA_HandleTypeDef hdma_lpuart1_tx; TIM_HandleTypeDef htim2; TIM_HandleTypeDef htim3; TIM_HandleTypeDef htim21; -TIM_HandleTypeDef htim22; /* Definitions for defaultTask */ osThreadId_t defaultTaskHandle; @@ -66,13 +65,11 @@ const osThreadAttr_t defaultTask_attributes = { /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); static void MX_GPIO_Init(void); -static void MX_DMA_Init(void); static void MX_LPUART1_UART_Init(void); static void MX_TIM2_Init(void); static void MX_TIM3_Init(void); static void MX_TIM21_Init(void); static void MX_ADC_Init(void); -static void MX_TIM22_Init(void); void StartDefaultTask(void *argument); /* USER CODE BEGIN PFP */ @@ -112,15 +109,17 @@ int main(void) /* Initialize all configured peripherals */ MX_GPIO_Init(); - MX_DMA_Init(); MX_LPUART1_UART_Init(); MX_TIM2_Init(); MX_TIM3_Init(); MX_TIM21_Init(); MX_ADC_Init(); - MX_TIM22_Init(); /* USER CODE BEGIN 2 */ +#ifdef TESTS + TESTS_Init(); +#else APPLICATION_Init(); +#endif /* TESTS */ /* USER CODE END 2 */ /* Init scheduler */ @@ -292,7 +291,7 @@ static void MX_LPUART1_UART_Init(void) /* USER CODE END LPUART1_Init 1 */ hlpuart1.Instance = LPUART1; - hlpuart1.Init.BaudRate = 115200; + hlpuart1.Init.BaudRate = 9600; hlpuart1.Init.WordLength = UART_WORDLENGTH_8B; hlpuart1.Init.StopBits = UART_STOPBITS_1; hlpuart1.Init.Parity = UART_PARITY_NONE; @@ -354,7 +353,7 @@ static void MX_TIM2_Init(void) sSlaveConfig.InputTrigger = TIM_TS_TI1FP1; sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING; sSlaveConfig.TriggerPrescaler = TIM_ICPSC_DIV1; - sSlaveConfig.TriggerFilter = 0; + sSlaveConfig.TriggerFilter = 3; if (HAL_TIM_SlaveConfigSynchro(&htim2, &sSlaveConfig) != HAL_OK) { Error_Handler(); @@ -362,14 +361,13 @@ static void MX_TIM2_Init(void) sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING; sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI; sConfigIC.ICPrescaler = TIM_ICPSC_DIV1; - sConfigIC.ICFilter = TIM_CCMR1_IC1F_3; + sConfigIC.ICFilter = 3; if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) { Error_Handler(); } sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING; sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI; - sConfigIC.ICFilter = TIM_CCMR1_IC2F_3; if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_2) != HAL_OK) { Error_Handler(); @@ -504,7 +502,7 @@ static void MX_TIM21_Init(void) sSlaveConfig.InputTrigger = TIM_TS_TI1FP1; sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_RISING; sSlaveConfig.TriggerPrescaler = TIM_ICPSC_DIV1; - sSlaveConfig.TriggerFilter = 0; + sSlaveConfig.TriggerFilter = 3; if (HAL_TIM_SlaveConfigSynchro(&htim21, &sSlaveConfig) != HAL_OK) { Error_Handler(); @@ -512,14 +510,13 @@ static void MX_TIM21_Init(void) sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING; sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI; sConfigIC.ICPrescaler = TIM_ICPSC_DIV1; - sConfigIC.ICFilter = TIM_CCMR1_IC1F_3; + sConfigIC.ICFilter = 3; if (HAL_TIM_IC_ConfigChannel(&htim21, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) { Error_Handler(); } sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING; sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI; - sConfigIC.ICFilter = TIM_CCMR1_IC2F_3; if (HAL_TIM_IC_ConfigChannel(&htim21, &sConfigIC, TIM_CHANNEL_2) != HAL_OK) { Error_Handler(); @@ -536,70 +533,6 @@ static void MX_TIM21_Init(void) } -/** - * @brief TIM22 Initialization Function - * @param None - * @retval None - */ -static void MX_TIM22_Init(void) -{ - - /* USER CODE BEGIN TIM22_Init 0 */ - - /* USER CODE END TIM22_Init 0 */ - - TIM_ClockConfigTypeDef sClockSourceConfig = {0}; - TIM_MasterConfigTypeDef sMasterConfig = {0}; - - /* USER CODE BEGIN TIM22_Init 1 */ - - /* USER CODE END TIM22_Init 1 */ - htim22.Instance = TIM22; - htim22.Init.Prescaler = 0; - htim22.Init.CounterMode = TIM_COUNTERMODE_UP; - htim22.Init.Period = 65535; - htim22.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; - htim22.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; - if (HAL_TIM_Base_Init(&htim22) != HAL_OK) - { - Error_Handler(); - } - sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_ETRMODE2; - sClockSourceConfig.ClockPolarity = TIM_CLOCKPOLARITY_NONINVERTED; - sClockSourceConfig.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1; - sClockSourceConfig.ClockFilter = 0; - if (HAL_TIM_ConfigClockSource(&htim22, &sClockSourceConfig) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim22, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM22_Init 2 */ - - /* USER CODE END TIM22_Init 2 */ - -} - -/** - * Enable DMA controller clock - */ -static void MX_DMA_Init(void) -{ - - /* DMA controller clock enable */ - __HAL_RCC_DMA1_CLK_ENABLE(); - - /* DMA interrupt init */ - /* DMA1_Channel2_3_IRQn interrupt configuration */ - HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 3, 0); - HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn); - -} - /** * @brief GPIO Initialization Function * @param None @@ -608,6 +541,8 @@ static void MX_DMA_Init(void) static void MX_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; +/* USER CODE BEGIN MX_GPIO_Init_1 */ +/* USER CODE END MX_GPIO_Init_1 */ /* GPIO Ports Clock Enable */ __HAL_RCC_GPIOA_CLK_ENABLE(); @@ -653,11 +588,11 @@ static void MX_GPIO_Init(void) GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BUTTON_SENSE_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pin : USB_SENSE_Pin */ - GPIO_InitStruct.Pin = USB_SENSE_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(USB_SENSE_GPIO_Port, &GPIO_InitStruct); +// /*Configure GPIO pin : USB_SENSE_Pin */ +// GPIO_InitStruct.Pin = USB_SENSE_Pin; +// GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING; +// GPIO_InitStruct.Pull = GPIO_NOPULL; +// HAL_GPIO_Init(USB_SENSE_GPIO_Port, &GPIO_InitStruct); /*Configure GPIO pins : CHARGER_ST2_Pin CHARGER_ST1_Pin */ GPIO_InitStruct.Pin = CHARGER_ST2_Pin|CHARGER_ST1_Pin; @@ -676,9 +611,11 @@ static void MX_GPIO_Init(void) HAL_NVIC_SetPriority(EXTI2_3_IRQn, 3, 0); HAL_NVIC_EnableIRQ(EXTI2_3_IRQn); - HAL_NVIC_SetPriority(EXTI4_15_IRQn, 3, 0); - HAL_NVIC_EnableIRQ(EXTI4_15_IRQn); +// HAL_NVIC_SetPriority(EXTI4_15_IRQn, 3, 0); +// HAL_NVIC_EnableIRQ(EXTI4_15_IRQn); +/* USER CODE BEGIN MX_GPIO_Init_2 */ +/* USER CODE END MX_GPIO_Init_2 */ } /* USER CODE BEGIN 4 */ diff --git a/software/dumber3/Core/Src/stm32l0xx_hal_msp.c b/software/dumber3/Core/Src/stm32l0xx_hal_msp.c index aa600c4..ad10b42 100644 --- a/software/dumber3/Core/Src/stm32l0xx_hal_msp.c +++ b/software/dumber3/Core/Src/stm32l0xx_hal_msp.c @@ -21,10 +21,10 @@ /* Includes ------------------------------------------------------------------*/ #include "main.h" + /* USER CODE BEGIN Includes */ /* USER CODE END Includes */ -extern DMA_HandleTypeDef hdma_lpuart1_tx; /* Private typedef -----------------------------------------------------------*/ /* USER CODE BEGIN TD */ @@ -177,29 +177,11 @@ void HAL_UART_MspInit(UART_HandleTypeDef* huart) GPIO_InitStruct.Alternate = GPIO_AF4_LPUART1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); - /* LPUART1 DMA Init */ - /* LPUART1_TX Init */ - hdma_lpuart1_tx.Instance = DMA1_Channel2; - hdma_lpuart1_tx.Init.Request = DMA_REQUEST_5; - hdma_lpuart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; - hdma_lpuart1_tx.Init.PeriphInc = DMA_PINC_DISABLE; - hdma_lpuart1_tx.Init.MemInc = DMA_MINC_ENABLE; - hdma_lpuart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; - hdma_lpuart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; - hdma_lpuart1_tx.Init.Mode = DMA_NORMAL; - hdma_lpuart1_tx.Init.Priority = DMA_PRIORITY_HIGH; - if (HAL_DMA_Init(&hdma_lpuart1_tx) != HAL_OK) - { - Error_Handler(); - } - - __HAL_LINKDMA(huart,hdmatx,hdma_lpuart1_tx); - /* LPUART1 interrupt Init */ - HAL_NVIC_SetPriority(LPUART1_IRQn, 3, 0); + HAL_NVIC_SetPriority(LPUART1_IRQn, 2, 0); HAL_NVIC_EnableIRQ(LPUART1_IRQn); /* USER CODE BEGIN LPUART1_MspInit 1 */ - HAL_NVIC_SetPriority(LPUART1_IRQn, 2, 0); + //HAL_NVIC_SetPriority(LPUART1_IRQn, 3, 0); /* USER CODE END LPUART1_MspInit 1 */ } @@ -227,9 +209,6 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* huart) */ HAL_GPIO_DeInit(GPIOB, USART_TX_Pin|USART_RX_Pin); - /* LPUART1 DMA DeInit */ - HAL_DMA_DeInit(huart->hdmatx); - /* LPUART1 interrupt DeInit */ HAL_NVIC_DisableIRQ(LPUART1_IRQn); /* USER CODE BEGIN LPUART1_MspDeInit 1 */ @@ -311,29 +290,6 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base) /* USER CODE END TIM21_MspInit 1 */ } - else if(htim_base->Instance==TIM22) - { - /* USER CODE BEGIN TIM22_MspInit 0 */ - - /* USER CODE END TIM22_MspInit 0 */ - /* Peripheral clock enable */ - __HAL_RCC_TIM22_CLK_ENABLE(); - - __HAL_RCC_GPIOA_CLK_ENABLE(); - /**TIM22 GPIO Configuration - PA4 ------> TIM22_ETR - */ - GPIO_InitStruct.Pin = ENC_PHB_DROIT_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF5_TIM22; - HAL_GPIO_Init(ENC_PHB_DROIT_GPIO_Port, &GPIO_InitStruct); - - /* USER CODE BEGIN TIM22_MspInit 1 */ - - /* USER CODE END TIM22_MspInit 1 */ - } } @@ -431,23 +387,6 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* htim_base) /* USER CODE END TIM21_MspDeInit 1 */ } - else if(htim_base->Instance==TIM22) - { - /* USER CODE BEGIN TIM22_MspDeInit 0 */ - - /* USER CODE END TIM22_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM22_CLK_DISABLE(); - - /**TIM22 GPIO Configuration - PA4 ------> TIM22_ETR - */ - HAL_GPIO_DeInit(ENC_PHB_DROIT_GPIO_Port, ENC_PHB_DROIT_Pin); - - /* USER CODE BEGIN TIM22_MspDeInit 1 */ - - /* USER CODE END TIM22_MspDeInit 1 */ - } } diff --git a/software/dumber3/Core/Src/stm32l0xx_hal_timebase_tim.c b/software/dumber3/Core/Src/stm32l0xx_hal_timebase_tim.c index 530e636..e20d972 100644 --- a/software/dumber3/Core/Src/stm32l0xx_hal_timebase_tim.c +++ b/software/dumber3/Core/Src/stm32l0xx_hal_timebase_tim.c @@ -77,6 +77,7 @@ HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) htim6.Instance = TIM6; /* Initialize TIMx peripheral as follow: + + Period = [(TIM6CLK/1000) - 1]. to have a (1/1000) s time base. + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock. + ClockDivision = 0 diff --git a/software/dumber3/Core/Src/stm32l0xx_it.c b/software/dumber3/Core/Src/stm32l0xx_it.c index 81ae58a..af95539 100644 --- a/software/dumber3/Core/Src/stm32l0xx_it.c +++ b/software/dumber3/Core/Src/stm32l0xx_it.c @@ -57,7 +57,6 @@ /* External variables --------------------------------------------------------*/ extern ADC_HandleTypeDef hadc; -extern DMA_HandleTypeDef hdma_lpuart1_tx; extern UART_HandleTypeDef hlpuart1; extern TIM_HandleTypeDef htim2; extern TIM_HandleTypeDef htim21; @@ -135,20 +134,6 @@ void EXTI4_15_IRQHandler(void) /* USER CODE END EXTI4_15_IRQn 1 */ } -/** - * @brief This function handles DMA1 channel 2 and channel 3 interrupts. - */ -//void DMA1_Channel2_3_IRQHandler(void) -//{ -// /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */ -// -// /* USER CODE END DMA1_Channel2_3_IRQn 0 */ -// HAL_DMA_IRQHandler(&hdma_lpuart1_tx); -// /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */ -// -// /* USER CODE END DMA1_Channel2_3_IRQn 1 */ -//} - /** * @brief This function handles ADC, COMP1 and COMP2 interrupts (COMP interrupts through EXTI lines 21 and 22). */ @@ -211,11 +196,11 @@ void TIM21_IRQHandler(void) //void LPUART1_IRQHandler(void) //{ // /* USER CODE BEGIN LPUART1_IRQn 0 */ -// +//// // /* USER CODE END LPUART1_IRQn 0 */ // HAL_UART_IRQHandler(&hlpuart1); // /* USER CODE BEGIN LPUART1_IRQn 1 */ -// +//// // /* USER CODE END LPUART1_IRQn 1 */ //} diff --git a/software/dumber3/Dumber3 Tests.launch b/software/dumber3/Dumber3 Tests.launch new file mode 100644 index 0000000..35f8a5e --- /dev/null +++ b/software/dumber3/Dumber3 Tests.launch @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/software/dumber3/Dumber3.ioc b/software/dumber3/Dumber3.ioc index de6e099..d5493d4 100644 --- a/software/dumber3/Dumber3.ioc +++ b/software/dumber3/Dumber3.ioc @@ -10,17 +10,18 @@ FREERTOS.INCLUDE_xEventGroupSetBitFromISR=1 FREERTOS.INCLUDE_xTaskAbortDelay=1 FREERTOS.INCLUDE_xTaskGetCurrentTaskHandle=1 FREERTOS.INCLUDE_xTaskGetHandle=1 -FREERTOS.IPParameters=Tasks01,configTICK_RATE_HZ,configUSE_TICKLESS_IDLE,INCLUDE_xTaskGetHandle,INCLUDE_xTaskAbortDelay,INCLUDE_xEventGroupSetBitFromISR,INCLUDE_pcTaskGetTaskName,INCLUDE_xTaskGetCurrentTaskHandle,configTOTAL_HEAP_SIZE,configUSE_NEWLIB_REENTRANT,configMAX_TASK_NAME_LEN +FREERTOS.IPParameters=Tasks01,configTICK_RATE_HZ,configUSE_TICKLESS_IDLE,INCLUDE_xTaskGetHandle,INCLUDE_xTaskAbortDelay,INCLUDE_xEventGroupSetBitFromISR,INCLUDE_pcTaskGetTaskName,INCLUDE_xTaskGetCurrentTaskHandle,configTOTAL_HEAP_SIZE,configUSE_NEWLIB_REENTRANT,configMAX_TASK_NAME_LEN,configTIMER_TASK_PRIORITY FREERTOS.Tasks01=defaultTask,24,128,StartDefaultTask,Default,NULL,Dynamic,NULL,NULL FREERTOS.configMAX_TASK_NAME_LEN=25 FREERTOS.configTICK_RATE_HZ=1000 +FREERTOS.configTIMER_TASK_PRIORITY=3 FREERTOS.configTOTAL_HEAP_SIZE=1024 FREERTOS.configUSE_NEWLIB_REENTRANT=1 FREERTOS.configUSE_TICKLESS_IDLE=1 File.Version=6 GPIO.groupedBy=Group By Peripherals KeepUserPlacement=false -LPUART1.BaudRate=115200 +LPUART1.BaudRate=9600 LPUART1.DMADisableonRxErrorParam=UART_ADVFEATURE_DMA_DISABLEONRXERROR LPUART1.IPParameters=BaudRate,WordLength,DMADisableonRxErrorParam LPUART1.WordLength=UART_WORDLENGTH_8B @@ -75,14 +76,14 @@ Mcu.PinsNb=33 Mcu.ThirdPartyNb=0 Mcu.UserConstants= Mcu.UserName=STM32L071CBTx -MxCube.Version=6.7.0 -MxDb.Version=DB.6.0.70 +MxCube.Version=6.9.2 +MxDb.Version=DB.6.0.92 NVIC.ADC1_COMP_IRQn=true\:3\:0\:false\:false\:true\:true\:true\:true\:true NVIC.EXTI2_3_IRQn=true\:3\:0\:false\:false\:true\:true\:true\:true\:true NVIC.EXTI4_15_IRQn=true\:3\:0\:false\:false\:true\:true\:true\:true\:true NVIC.ForceEnableDMAVector=true NVIC.HardFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false -NVIC.LPUART1_IRQn=true\:3\:0\:false\:false\:true\:true\:true\:true\:true +NVIC.LPUART1_IRQn=true\:3\:0\:true\:false\:true\:true\:true\:true\:true NVIC.NonMaskableInt_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false NVIC.PendSV_IRQn=true\:3\:0\:false\:false\:false\:true\:false\:false\:false NVIC.SVC_IRQn=true\:0\:0\:false\:false\:false\:false\:false\:false\:true @@ -92,7 +93,7 @@ NVIC.SavedSystickIrqHandlerGenerated=true NVIC.SysTick_IRQn=true\:3\:0\:false\:false\:false\:true\:false\:true\:false NVIC.TIM21_IRQn=true\:1\:0\:true\:false\:true\:false\:true\:true\:true NVIC.TIM2_IRQn=true\:1\:0\:true\:false\:true\:false\:true\:true\:true -NVIC.TIM6_IRQn=true\:3\:0\:false\:false\:true\:false\:false\:true\:true +NVIC.TIM6_IRQn=true\:3\:0\:true\:false\:true\:false\:false\:true\:true NVIC.TimeBase=TIM6_IRQn NVIC.TimeBaseIP=TIM6 PA0.GPIOParameters=GPIO_Label @@ -242,10 +243,13 @@ ProjectManager.PreviousToolchain= ProjectManager.ProjectBuild=false ProjectManager.ProjectFileName=Dumber3.ioc ProjectManager.ProjectName=Dumber3 +ProjectManager.ProjectStructure= ProjectManager.RegisterCallBack= ProjectManager.StackSize=0x200 ProjectManager.TargetToolchain=STM32CubeIDE ProjectManager.ToolChainLocation= +ProjectManager.UAScriptAfterPath= +ProjectManager.UAScriptBeforePath= ProjectManager.UnderRoot=true ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_LPUART1_UART_Init-LPUART1-false-HAL-true,4-MX_TIM2_Init-TIM2-false-HAL-true,5-MX_TIM3_Init-TIM3-false-HAL-true,6-MX_TIM21_Init-TIM21-false-HAL-true,7-MX_ADC_Init-ADC-false-HAL-true RCC.ADCFreq_Value=4000000 @@ -324,4 +328,5 @@ VP_TIM2_VS_ClockSourceINT.Signal=TIM2_VS_ClockSourceINT VP_TIM3_VS_ClockSourceINT.Mode=Internal VP_TIM3_VS_ClockSourceINT.Signal=TIM3_VS_ClockSourceINT board=custom +rtos.0.ip=FREERTOS isbadioc=false diff --git a/software/dumber3/TestsPlans/tests.c b/software/dumber3/TestsPlans/tests.c new file mode 100644 index 0000000..57dae3f --- /dev/null +++ b/software/dumber3/TestsPlans/tests.c @@ -0,0 +1,256 @@ +/* + * tests.c + * + * Created on: 28 sept. 2023 + * Author: dimercur + */ + +#include "tests.h" +#include "application.h" +#include "timers.h" +#include "string.h" +#include +#include + +#include "moteurs.h" +#include "leds.h" +#include "xbee.h" +#include "batterie.h" +#include "messages.h" + +StaticTask_t xTaskBasicTests; + +/* Buffer that the task being created will use as its stack. Note this is + an array of StackType_t variables. The size of StackType_t is dependent on + the RTOS port. */ +StackType_t xStackBasicTests[ STACK_SIZE ]; +TaskHandle_t xHandleBasicTests = NULL; + +typedef enum { + LED_Tests=1, + XBEE_Tests, + COMMANDS_Tests, + BATTERY_Tests, + MOTEURS_Tests, + MISC_Tests +} TESTS_Type; + +TESTS_Type TESTS_Nbr=COMMANDS_Tests; // Number indicating which test is being run + +void TESTS_BasicTests(void* params); + +void TESTS_Init(void) { + /* Init Application */ + + /* Init des messages box */ + MESSAGE_Init(); + + /* Init de l'afficheur */ + LEDS_Init(); + + /* Init de la partie RF / reception des messages */ + XBEE_Init(); + BATTERIE_Init(); + MOTEURS_Init(); + + /* Tests starts here */ + xHandleBasicTests = xTaskCreateStatic( + TESTS_BasicTests, /* Function that implements the task. */ + "TESTS Basic", /* Text name for the task. */ + STACK_SIZE, /* Number of indexes in the xStack array. */ + NULL, /* Parameter passed into the task. */ + PriorityTestsHandler,/* Priority at which the task is created. */ + xStackBasicTests, /* Array to use as the task's stack. */ + &xTaskBasicTests); /* Variable to hold the task's data structure. */ + + vTaskResume(xHandleBasicTests); +} + +void TESTS_BasicTests(void* params) { + static LEDS_State ledsStates = leds_off; + MESSAGE_Typedef msg; + CMD_Generic* cmd; + + char* ans; + + ledsStates = leds_run; + MESSAGE_SendMailbox(LEDS_Mailbox, MSG_ID_LED_ETAT, APPLICATION_Mailbox, (void*)&ledsStates); // show program is running + + switch (TESTS_Nbr) { + case LED_Tests: //Leds tests + + while (ledsStates<=leds_state_unknown) { + ledsStates++; + + MESSAGE_SendMailbox(LEDS_Mailbox, MSG_ID_LED_ETAT, APPLICATION_Mailbox, (void*)&ledsStates); + vTaskDelay(pdMS_TO_TICKS(TESTS_PERIODE)); // wait 10s + } + break; + case XBEE_Tests: // Xbee tests + + while (1) { + int length; + + msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from Xbee + + if (msg.id == MSG_ID_XBEE_CMD) { + length = strlen((char*)msg.data) + strlen("Data received: ") +2; + ans = (char*)malloc(length); + ans[0] = 0; // empty string + + strncat(ans, "Data received: ", length); + strncat(ans, (char *)msg.data, length); + ans[length-2] = '\r'; + ans[length-1] = 0; + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)ans); + + free(msg.data); + } + } + + break; + case COMMANDS_Tests: + + while (1) { + int length; + char* str; + + msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from Xbee + + if (msg.id == MSG_ID_XBEE_CMD) { + length = strlen((char*)msg.data) + strlen("Data received: ") +2; + ans = (char*)malloc(length); + ans[0] = 0; // empty string + + strncat(ans, "Data received: ", length); + strncat(ans, (char *)msg.data, length); + ans[length-2] = '\r'; + ans[length-1] = 0; + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)ans); + + cmd = cmdDecode((char*)msg.data, strlen((char*)msg.data)); + free(msg.data); + str = (char*)malloc(100); + str[0] = 0; // empty string + + switch (cmd->type) { + case CMD_PING: + snprintf(str, 99, "PING received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_RESET: + snprintf(str, 99, "RESET received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_START_WITH_WATCHDOG: + snprintf(str, 99, "START with Watchdog received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_RESET_WATCHDOG: + snprintf(str, 99, "RESET Watchdog received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_GET_BATTERY: + snprintf(str, 99, "GET_BATTERY received\r"); + cmdSendBatteryLevel(ANS_BAT_OK); + break; + case CMD_GET_VERSION: + snprintf(str, 99, "GET_VERSION received\r"); + cmdSendVersion(); + break; + case CMD_START_WITHOUT_WATCHDOG: + snprintf(str, 99, "START without Watchdog received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_MOVE: + snprintf(str, 99, "MOVE received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_TURN: + snprintf(str, 99, "TURN received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_GET_BUSY_STATE: + snprintf(str, 99, "GET_BUSY_STATE received\r"); + cmdSendBusyState(ANS_STATE_BUSY); + break; + case CMD_TEST: + snprintf(str, 99, "TEST received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_DEBUG: + snprintf(str, 99, "DEBUG received\r"); + cmdSendAnswer(ANS_OK); + break; + case CMD_POWER_OFF: + snprintf(str, 99, "POWER_OFF received\r"); + cmdSendAnswer(ANS_OK); + break; + default: + snprintf(str, 99, "Unknown command\r"); + cmdSendAnswer(ANS_UNKNOWN); + break; + } + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)str); + } + } + break; + case BATTERY_Tests: + + while (1) { + char* str; + + msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from Xbee + str = (char*)malloc(100); /* allocate a buffer of 100 bytes */ + str[0]=0; + + switch (msg.id) { + case MSG_ID_BAT_ADC_ERR: + snprintf(str, 99, "ADC error received\r"); + break; + case MSG_ID_BAT_CHARGE_COMPLETE: + snprintf(str, 99, "Charge complete (plug in) [Level = %u]\r", *((uint16_t*)msg.data)); + break; + case MSG_ID_BAT_CHARGE_ON: + snprintf(str, 99, "Charging (plug in) [Level = %u]\r", *((uint16_t*)msg.data)); + break; + case MSG_ID_BAT_CHARGE_OFF: + snprintf(str, 99, "Not in charge (plug removed) [Level = %u]\r", *((uint16_t*)msg.data)); + break; + case MSG_ID_BAT_CHARGE_ERR: + snprintf(str, 99, "Charge error (plug in)\r"); + break; + default: + free(str); // buffer alloué non utilisé + break; + } + + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)str); + } + break; + case MOTEURS_Tests: + + break; + case MISC_Tests: // test du bouton on/off + + while (1) { + char* str; + + msg = MESSAGE_ReadMailbox(APPLICATION_Mailbox); // Wait for a message from button + + if (msg.id == MSG_ID_BUTTON_PRESSED) { + str = (char*)malloc(100); /* allocate a buffer of 100 bytes */ + str[0]=0; + + snprintf(str, 99, "Bouton on/off appuyé\r"); + MESSAGE_SendMailbox(XBEE_Mailbox, MSG_ID_XBEE_ANS, APPLICATION_Mailbox, (void*)str); + } + } + break; + default: + break; + } +} diff --git a/software/dumber3/TestsPlans/tests.h b/software/dumber3/TestsPlans/tests.h new file mode 100644 index 0000000..6e6819b --- /dev/null +++ b/software/dumber3/TestsPlans/tests.h @@ -0,0 +1,13 @@ +/* + * tests.h + * + * Created on: 28 sept. 2023 + * Author: dimercur + */ + +#ifndef TESTS_H_ +#define TESTS_H_ + +void TESTS_Init(void); + +#endif /* TESTS_H_ */ diff --git a/software/dumber3/commands.xml b/software/dumber3/commands.xml new file mode 100644 index 0000000..e6466bf --- /dev/null +++ b/software/dumber3/commands.xml @@ -0,0 +1,15 @@ + + + + false + 1 + 500 + + + 70700D + + + 72720D + + + diff --git a/software/dumber3/mx.scratch b/software/dumber3/mx.scratch index c0db5a3..ca35442 100644 --- a/software/dumber3/mx.scratch +++ b/software/dumber3/mx.scratch @@ -27,8 +27,8 @@ Arm Cortex-M0+ None - - + + /home/dimercur/STM32Cube/Repository/STM32Cube_FW_L0_V1.12.2/Drivers/CMSIS/Device\ST\STM32L0xx\Source\Templates\gcc\startup_stm32l071xx.s @@ -63,7 +63,6 @@ USE_FULL_LL_DRIVER - MBEDTLS_CONFIG_FILE="mbedtls_config.h" USE_FULL_ASSERT=1U