diff --git a/Makefile b/Makefile
index 0319ba7..de76c51 100644
--- a/Makefile
+++ b/Makefile
@@ -40,7 +40,6 @@ C_SOURCES =  \
 HAL_N_Middlewares/Src/main.c \
 HAL_N_Middlewares/Src/gpio.c \
 HAL_N_Middlewares/Src/i2c.c \
-HAL_N_Middlewares/Src/i2c.c \
 HAL_N_Middlewares/Src/adc.c \
 HAL_N_Middlewares/Src/can.c \
 HAL_N_Middlewares/Src/dma.c \
@@ -68,8 +67,6 @@ HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_flash_ramfunc.c
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_gpio.c \
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_i2c_ex.c \
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_i2c.c \
-HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_i2c_ex.c \
-HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_i2c.c \
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_dma_ex.c \
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_dma.c \
 HAL_N_Middlewares/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_pwr.c \
diff --git a/basic_framework.ioc b/basic_framework.ioc
index 52eb390..fbe356b 100644
--- a/basic_framework.ioc
+++ b/basic_framework.ioc
@@ -9,9 +9,6 @@ ADC1.master=1
 CAD.formats=
 CAD.pinconfig=
 CAD.provider=
-CAD.formats=
-CAD.pinconfig=
-CAD.provider=
 CAN1.BS1=CAN_BS1_10TQ
 CAN1.BS2=CAN_BS2_3TQ
 CAN1.CalculateBaudRate=1000000
@@ -24,87 +21,55 @@ CAN2.CalculateBaudRate=1000000
 CAN2.CalculateTimeQuantum=71.42857142857143
 CAN2.IPParameters=CalculateTimeQuantum,BS1,BS2,Prescaler,CalculateBaudRate
 CAN2.Prescaler=3
-Dma.MEMTOMEM.5.Direction=DMA_MEMORY_TO_MEMORY
-Dma.MEMTOMEM.5.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.MEMTOMEM.5.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.MEMTOMEM.5.Instance=DMA2_Stream3
-Dma.MEMTOMEM.5.MemBurst=DMA_MBURST_SINGLE
-Dma.MEMTOMEM.5.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.MEMTOMEM.5.MemInc=DMA_MINC_ENABLE
-Dma.MEMTOMEM.5.Mode=DMA_NORMAL
-Dma.MEMTOMEM.5.PeriphBurst=DMA_PBURST_SINGLE
-Dma.MEMTOMEM.5.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.MEMTOMEM.5.PeriphInc=DMA_PINC_ENABLE
-Dma.MEMTOMEM.5.Priority=DMA_PRIORITY_HIGH
-Dma.MEMTOMEM.5.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.ADC1.12.Direction=DMA_PERIPH_TO_MEMORY
-Dma.ADC1.12.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.ADC1.12.Instance=DMA2_Stream4
-Dma.ADC1.12.MemDataAlignment=DMA_MDATAALIGN_HALFWORD
-Dma.ADC1.12.MemInc=DMA_MINC_ENABLE
-Dma.ADC1.12.Mode=DMA_NORMAL
-Dma.ADC1.12.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD
-Dma.ADC1.12.PeriphInc=DMA_PINC_DISABLE
-Dma.ADC1.12.Priority=DMA_PRIORITY_LOW
-Dma.ADC1.12.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
-Dma.I2C2_RX.8.Direction=DMA_PERIPH_TO_MEMORY
-Dma.I2C2_RX.8.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.I2C2_RX.8.Instance=DMA1_Stream2
-Dma.I2C2_RX.8.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.I2C2_RX.8.MemInc=DMA_MINC_ENABLE
-Dma.I2C2_RX.8.Mode=DMA_NORMAL
-Dma.I2C2_RX.8.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.I2C2_RX.8.PeriphInc=DMA_PINC_DISABLE
-Dma.I2C2_RX.8.Priority=DMA_PRIORITY_LOW
-Dma.I2C2_RX.8.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
-Dma.I2C2_TX.9.Direction=DMA_MEMORY_TO_PERIPH
-Dma.I2C2_TX.9.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.I2C2_TX.9.Instance=DMA1_Stream7
-Dma.I2C2_TX.9.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.I2C2_TX.9.MemInc=DMA_MINC_ENABLE
-Dma.I2C2_TX.9.Mode=DMA_NORMAL
-Dma.I2C2_TX.9.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.I2C2_TX.9.PeriphInc=DMA_PINC_DISABLE
-Dma.I2C2_TX.9.Priority=DMA_PRIORITY_LOW
-Dma.I2C2_TX.9.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
-Dma.MEMTOMEM.11.Direction=DMA_MEMORY_TO_MEMORY
-Dma.MEMTOMEM.11.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.MEMTOMEM.11.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.MEMTOMEM.11.Instance=DMA2_Stream5
-Dma.MEMTOMEM.11.MemBurst=DMA_MBURST_SINGLE
-Dma.MEMTOMEM.11.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.MEMTOMEM.11.MemInc=DMA_MINC_ENABLE
-Dma.MEMTOMEM.11.Mode=DMA_NORMAL
-Dma.MEMTOMEM.11.PeriphBurst=DMA_PBURST_SINGLE
-Dma.MEMTOMEM.11.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.MEMTOMEM.11.PeriphInc=DMA_PINC_ENABLE
-Dma.MEMTOMEM.11.Priority=DMA_PRIORITY_LOW
-Dma.MEMTOMEM.11.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
+Dma.ADC1.8.Direction=DMA_PERIPH_TO_MEMORY
+Dma.ADC1.8.FIFOMode=DMA_FIFOMODE_DISABLE
+Dma.ADC1.8.Instance=DMA2_Stream4
+Dma.ADC1.8.MemDataAlignment=DMA_MDATAALIGN_HALFWORD
+Dma.ADC1.8.MemInc=DMA_MINC_ENABLE
+Dma.ADC1.8.Mode=DMA_NORMAL
+Dma.ADC1.8.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD
+Dma.ADC1.8.PeriphInc=DMA_PINC_DISABLE
+Dma.ADC1.8.Priority=DMA_PRIORITY_LOW
+Dma.ADC1.8.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
+Dma.I2C2_RX.9.Direction=DMA_PERIPH_TO_MEMORY
+Dma.I2C2_RX.9.FIFOMode=DMA_FIFOMODE_DISABLE
+Dma.I2C2_RX.9.Instance=DMA1_Stream2
+Dma.I2C2_RX.9.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.I2C2_RX.9.MemInc=DMA_MINC_ENABLE
+Dma.I2C2_RX.9.Mode=DMA_NORMAL
+Dma.I2C2_RX.9.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.I2C2_RX.9.PeriphInc=DMA_PINC_DISABLE
+Dma.I2C2_RX.9.Priority=DMA_PRIORITY_LOW
+Dma.I2C2_RX.9.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
+Dma.I2C2_TX.10.Direction=DMA_MEMORY_TO_PERIPH
+Dma.I2C2_TX.10.FIFOMode=DMA_FIFOMODE_DISABLE
+Dma.I2C2_TX.10.Instance=DMA1_Stream7
+Dma.I2C2_TX.10.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.I2C2_TX.10.MemInc=DMA_MINC_ENABLE
+Dma.I2C2_TX.10.Mode=DMA_NORMAL
+Dma.I2C2_TX.10.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.I2C2_TX.10.PeriphInc=DMA_PINC_DISABLE
+Dma.I2C2_TX.10.Priority=DMA_PRIORITY_LOW
+Dma.I2C2_TX.10.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.Request0=USART6_RX
 Dma.Request1=USART6_TX
-Dma.Request10=USART3_RX
-Dma.Request11=MEMTOMEM
-Dma.Request12=ADC1
+Dma.Request10=I2C2_TX
+Dma.Request11=SPI1_TX
 Dma.Request2=USART1_TX
 Dma.Request3=USART1_RX
 Dma.Request4=SPI1_RX
-Dma.Request5=SPI1_TX
-Dma.Request6=SPI2_RX
-Dma.Request7=SPI2_TX
-Dma.Request8=I2C2_RX
-Dma.Request9=I2C2_TX
-Dma.RequestsNb=13
+Dma.Request5=SPI2_RX
+Dma.Request6=SPI2_TX
+Dma.Request7=USART3_RX
+Dma.Request8=ADC1
+Dma.Request9=I2C2_RX
+Dma.RequestsNb=12
 Dma.SPI1_RX.4.Direction=DMA_PERIPH_TO_MEMORY
 Dma.SPI1_RX.4.FIFOMode=DMA_FIFOMODE_ENABLE
 Dma.SPI1_RX.4.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
 Dma.SPI1_RX.4.Instance=DMA2_Stream0
 Dma.SPI1_RX.4.MemBurst=DMA_MBURST_SINGLE
 Dma.SPI1_RX.4.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.Request5=MEMTOMEM
-Dma.Request6=SPI1_RX
-Dma.Request7=SPI1_TX
-Dma.Request8=SPI2_RX
-Dma.Request9=SPI2_TX
 Dma.SPI1_RX.4.MemInc=DMA_MINC_ENABLE
 Dma.SPI1_RX.4.Mode=DMA_NORMAL
 Dma.SPI1_RX.4.PeriphBurst=DMA_PBURST_SINGLE
@@ -112,100 +77,45 @@ Dma.SPI1_RX.4.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.SPI1_RX.4.PeriphInc=DMA_PINC_DISABLE
 Dma.SPI1_RX.4.Priority=DMA_PRIORITY_LOW
 Dma.SPI1_RX.4.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI1_TX.5.Direction=DMA_MEMORY_TO_PERIPH
-Dma.SPI1_TX.5.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI1_TX.5.FIFOThreshold=10
-Dma.SPI1_RX.6.Direction=DMA_PERIPH_TO_MEMORY
-Dma.SPI1_RX.6.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI1_RX.6.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI1_RX.6.Instance=DMA2_Stream0
-Dma.SPI1_RX.6.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI1_RX.6.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI1_RX.6.MemInc=DMA_MINC_ENABLE
-Dma.SPI1_RX.6.Mode=DMA_NORMAL
-Dma.SPI1_RX.6.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI1_RX.6.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI1_RX.6.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI1_RX.6.Priority=DMA_PRIORITY_LOW
-Dma.SPI1_RX.6.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI1_TX.7.Direction=DMA_MEMORY_TO_PERIPH
-Dma.SPI1_TX.7.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI1_TX.7.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI1_TX.7.Instance=DMA2_StreamDMA_FIFO_THRESHOLD_FULL
-Dma.SPI1_TX.5.Instance=DMA2_Stream3
-Dma.SPI1_TX.7.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI1_TX.7.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI1_TX.7.MemInc=DMA_MINC_ENABLE
-Dma.SPI1_TX.7.Mode=DMA_NORMAL
-Dma.SPI1_TX.7.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI1_TX.7.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI1_TX.7.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI1_TX.7.Priority=DMA_PRIORITY_LOW
-Dma.SPI1_TX.7.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI2_RX.8.Direction=DMA_PERIPH_TO_MEMORY
-Dma.SPI2_RX.8.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI2_RX.8.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI2_RX.8.Instance=DMA1_Stream3
-Dma.SPI2_RX.8.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI2_RX.8.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI2_RX.8.MemInc=DMA_MINC_ENABLE
-Dma.SPI2_RX.8.Mode=DMA_NORMAL
-Dma.SPI2_RX.8.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI2_RX.8.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI2_RX.8.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI2_RX.8.Priority=DMA_PRIORITY_LOW
-Dma.SPI2_RX.8.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI2_TX.9.Direction=DMA_MEMORY_TO_PERIPH
-Dma.SPI2_TX.9.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI2_TX.9.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI2_TX.9.Instance=DMA1_Stream4
-Dma.SPI2_TX.9.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI2_TX.9.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI2_TX.9.MemInc=DMA_MINC_ENABLE
-Dma.SPI2_TX.9.Mode=DMA_NORMAL
-Dma.SPI2_TX.9.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI2_TX.9.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI2_TX.9.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI2_TX.9.Priority=DMA_PRIORITY_LOW
-Dma.SPI2_TX.9.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI1_TX.5.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI1_TX.5.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI1_TX.5.MemInc=DMA_MINC_ENABLE
-Dma.SPI1_TX.5.Mode=DMA_NORMAL
-Dma.SPI1_TX.5.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI1_TX.5.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI1_TX.5.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI1_TX.5.Priority=DMA_PRIORITY_LOW
-Dma.SPI1_TX.5.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI2_RX.6.Direction=DMA_PERIPH_TO_MEMORY
-Dma.SPI2_RX.6.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI2_RX.6.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI2_RX.6.Instance=DMA1_Stream3
-Dma.SPI2_RX.6.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI2_RX.6.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI2_RX.6.MemInc=DMA_MINC_ENABLE
-Dma.SPI2_RX.6.Mode=DMA_NORMAL
-Dma.SPI2_RX.6.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI2_RX.6.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI2_RX.6.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI2_RX.6.Priority=DMA_PRIORITY_LOW
-Dma.SPI2_RX.6.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
-Dma.SPI2_TX.7.Direction=DMA_MEMORY_TO_PERIPH
-Dma.SPI2_TX.7.FIFOMode=DMA_FIFOMODE_ENABLE
-Dma.SPI2_TX.7.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
-Dma.SPI2_TX.7.Instance=DMA1_Stream4
-Dma.SPI2_TX.7.MemBurst=DMA_MBURST_SINGLE
-Dma.SPI2_TX.7.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.SPI2_TX.7.MemInc=DMA_MINC_ENABLE
-Dma.SPI2_TX.7.Mode=DMA_NORMAL
-Dma.SPI2_TX.7.PeriphBurst=DMA_PBURST_SINGLE
-Dma.SPI2_TX.7.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.SPI2_TX.7.PeriphInc=DMA_PINC_DISABLE
-Dma.SPI2_TX.7.Priority=DMA_PRIORITY_LOW
-Dma.SPI2_TX.7.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
+Dma.SPI1_TX.11.Direction=DMA_MEMORY_TO_PERIPH
+Dma.SPI1_TX.11.FIFOMode=DMA_FIFOMODE_DISABLE
+Dma.SPI1_TX.11.Instance=DMA2_Stream3
+Dma.SPI1_TX.11.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.SPI1_TX.11.MemInc=DMA_MINC_ENABLE
+Dma.SPI1_TX.11.Mode=DMA_NORMAL
+Dma.SPI1_TX.11.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.SPI1_TX.11.PeriphInc=DMA_PINC_DISABLE
+Dma.SPI1_TX.11.Priority=DMA_PRIORITY_LOW
+Dma.SPI1_TX.11.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
+Dma.SPI2_RX.5.Direction=DMA_PERIPH_TO_MEMORY
+Dma.SPI2_RX.5.FIFOMode=DMA_FIFOMODE_ENABLE
+Dma.SPI2_RX.5.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
+Dma.SPI2_RX.5.Instance=DMA1_Stream3
+Dma.SPI2_RX.5.MemBurst=DMA_MBURST_SINGLE
+Dma.SPI2_RX.5.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.SPI2_RX.5.MemInc=DMA_MINC_ENABLE
+Dma.SPI2_RX.5.Mode=DMA_NORMAL
+Dma.SPI2_RX.5.PeriphBurst=DMA_PBURST_SINGLE
+Dma.SPI2_RX.5.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.SPI2_RX.5.PeriphInc=DMA_PINC_DISABLE
+Dma.SPI2_RX.5.Priority=DMA_PRIORITY_LOW
+Dma.SPI2_RX.5.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
+Dma.SPI2_TX.6.Direction=DMA_MEMORY_TO_PERIPH
+Dma.SPI2_TX.6.FIFOMode=DMA_FIFOMODE_ENABLE
+Dma.SPI2_TX.6.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
+Dma.SPI2_TX.6.Instance=DMA1_Stream4
+Dma.SPI2_TX.6.MemBurst=DMA_MBURST_SINGLE
+Dma.SPI2_TX.6.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.SPI2_TX.6.MemInc=DMA_MINC_ENABLE
+Dma.SPI2_TX.6.Mode=DMA_NORMAL
+Dma.SPI2_TX.6.PeriphBurst=DMA_PBURST_SINGLE
+Dma.SPI2_TX.6.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.SPI2_TX.6.PeriphInc=DMA_PINC_DISABLE
+Dma.SPI2_TX.6.Priority=DMA_PRIORITY_LOW
+Dma.SPI2_TX.6.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
 Dma.USART1_RX.3.Direction=DMA_PERIPH_TO_MEMORY
 Dma.USART1_RX.3.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.USART1_RX.3.Instance=DMA2_Stream2
+Dma.USART1_RX.3.Instance=DMA2_Stream5
 Dma.USART1_RX.3.MemDataAlignment=DMA_MDATAALIGN_BYTE
 Dma.USART1_RX.3.MemInc=DMA_MINC_ENABLE
 Dma.USART1_RX.3.Mode=DMA_NORMAL
@@ -223,19 +133,19 @@ Dma.USART1_TX.2.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
 Dma.USART1_TX.2.PeriphInc=DMA_PINC_DISABLE
 Dma.USART1_TX.2.Priority=DMA_PRIORITY_VERY_HIGH
 Dma.USART1_TX.2.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
-Dma.USART3_RX.10.Direction=DMA_PERIPH_TO_MEMORY
-Dma.USART3_RX.10.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.USART3_RX.10.Instance=DMA1_Stream1
-Dma.USART3_RX.10.MemDataAlignment=DMA_MDATAALIGN_BYTE
-Dma.USART3_RX.10.MemInc=DMA_MINC_ENABLE
-Dma.USART3_RX.10.Mode=DMA_NORMAL
-Dma.USART3_RX.10.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
-Dma.USART3_RX.10.PeriphInc=DMA_PINC_DISABLE
-Dma.USART3_RX.10.Priority=DMA_PRIORITY_LOW
-Dma.USART3_RX.10.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
+Dma.USART3_RX.7.Direction=DMA_PERIPH_TO_MEMORY
+Dma.USART3_RX.7.FIFOMode=DMA_FIFOMODE_DISABLE
+Dma.USART3_RX.7.Instance=DMA1_Stream1
+Dma.USART3_RX.7.MemDataAlignment=DMA_MDATAALIGN_BYTE
+Dma.USART3_RX.7.MemInc=DMA_MINC_ENABLE
+Dma.USART3_RX.7.Mode=DMA_NORMAL
+Dma.USART3_RX.7.PeriphDataAlignment=DMA_PDATAALIGN_BYTE
+Dma.USART3_RX.7.PeriphInc=DMA_PINC_DISABLE
+Dma.USART3_RX.7.Priority=DMA_PRIORITY_LOW
+Dma.USART3_RX.7.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode
 Dma.USART6_RX.0.Direction=DMA_PERIPH_TO_MEMORY
 Dma.USART6_RX.0.FIFOMode=DMA_FIFOMODE_DISABLE
-Dma.USART6_RX.0.Instance=DMA2_Stream1
+Dma.USART6_RX.0.Instance=DMA2_Stream2
 Dma.USART6_RX.0.MemDataAlignment=DMA_MDATAALIGN_BYTE
 Dma.USART6_RX.0.MemInc=DMA_MINC_ENABLE
 Dma.USART6_RX.0.Mode=DMA_NORMAL
@@ -265,10 +175,6 @@ I2C2.I2C_Mode=I2C_Fast
 I2C2.IPParameters=I2C_Mode
 I2C3.I2C_Mode=I2C_Fast
 I2C3.IPParameters=I2C_Mode
-I2C2.I2C_Mode=I2C_Fast
-I2C2.IPParameters=I2C_Mode
-I2C3.I2C_Mode=I2C_Fast
-I2C3.IPParameters=I2C_Mode
 KeepUserPlacement=false
 Mcu.CPN=STM32F407IGH6
 Mcu.Family=STM32F4
@@ -313,8 +219,6 @@ Mcu.Pin16=PD1
 Mcu.Pin17=PA11
 Mcu.Pin18=PF0
 Mcu.Pin19=PA9
-Mcu.Pin18=PF0
-Mcu.Pin19=PA9
 Mcu.Pin2=PG14
 Mcu.Pin20=PC9
 Mcu.Pin21=PA8
@@ -326,16 +230,6 @@ Mcu.Pin26=PG6
 Mcu.Pin27=PH12
 Mcu.Pin28=PG3
 Mcu.Pin29=PH11
-Mcu.Pin20=PC9
-Mcu.Pin21=PA8
-Mcu.Pin22=PH0-OSC_IN
-Mcu.Pin23=PH1-OSC_OUT
-Mcu.Pin24=PF1
-Mcu.Pin25=PC6
-Mcu.Pin26=PG6
-Mcu.Pin27=PH12
-Mcu.Pin28=PG3
-Mcu.Pin29=PH11
 Mcu.Pin3=PB4
 Mcu.Pin30=PH10
 Mcu.Pin31=PD14
@@ -391,11 +285,10 @@ NVIC.DMA1_Stream3_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DMA1_Stream4_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DMA1_Stream7_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DMA2_Stream0_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
-NVIC.DMA2_Stream1_IRQn=true\:5\:0\:false\:false\:true\:false\:false\:true\:true
 NVIC.DMA2_Stream2_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
-NVIC.DMA2_Stream3_IRQn=true\:5\:0\:false\:false\:true\:false\:false\:true\:true
+NVIC.DMA2_Stream3_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
 NVIC.DMA2_Stream4_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
-NVIC.DMA2_Stream5_IRQn=true\:5\:0\:false\:false\:true\:true\:false\:true\:true
+NVIC.DMA2_Stream5_IRQn=true\:5\:0\:false\:false\:true\:false\:false\:true\:true
 NVIC.DMA2_Stream6_IRQn=true\:5\:0\:true\:false\:true\:true\:false\:true\:true
 NVIC.DMA2_Stream7_IRQn=true\:5\:0\:true\:false\:true\:true\:false\:true\:true
 NVIC.DebugMonitor_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false\:false
@@ -412,8 +305,6 @@ NVIC.PendSV_IRQn=true\:15\:0\:false\:false\:false\:true\:false\:false\:false
 NVIC.PriorityGroup=NVIC_PRIORITYGROUP_4
 NVIC.SPI1_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
 NVIC.SPI2_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
-NVIC.SPI1_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
-NVIC.SPI2_IRQn=true\:5\:0\:false\:false\:true\:true\:true\:true\:true
 NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:false\:false\:false\:false\:false
 NVIC.SavedPendsvIrqHandlerGenerated=true
 NVIC.SavedSvcallIrqHandlerGenerated=true
diff --git a/bsp/can/bsp_can.c b/bsp/can/bsp_can.c
index 4bb482d..389a1a4 100644
--- a/bsp/can/bsp_can.c
+++ b/bsp/can/bsp_can.c
@@ -5,7 +5,7 @@
 
 /* can instance ptrs storage, used for recv callback */
 // 在CAN产生接收中断会遍历数组,选出hcan和rxid与发生中断的实例相同的那个,调用其回调函数
-static CANInstance *instance[MX_REGISTER_DEVICE_CNT] = {NULL};
+static CANInstance *can_instance[MX_REGISTER_DEVICE_CNT] = {NULL};
 static uint8_t idx; // 全局CAN实例索引,每次有新的模块注册会自增
 
 /* ----------------two static function called by CANRegister()-------------------- */
@@ -67,22 +67,24 @@ CANInstance *CANRegister(CAN_Init_Config_s *config)
     {
         CANServiceInit(); // 第一次注册,先进行硬件初始化
     }
-    instance[idx] = (CANInstance *)malloc(sizeof(CANInstance)); // 分配空间
-    memset(instance[idx], 0, sizeof(CANInstance));
+    CANInstance *instance = (CANInstance *)malloc(sizeof(CANInstance)); // 分配空间
+    memset(instance, 0, sizeof(CANInstance));
     // 进行发送报文的配置
-    instance[idx]->txconf.StdId = config->tx_id;
-    instance[idx]->txconf.IDE = CAN_ID_STD;
-    instance[idx]->txconf.RTR = CAN_RTR_DATA;
-    instance[idx]->txconf.DLC = 0x08; // 默认发送长度为8
+    instance->txconf.StdId = config->tx_id;
+    instance->txconf.IDE = CAN_ID_STD;
+    instance->txconf.RTR = CAN_RTR_DATA;
+    instance->txconf.DLC = 0x08; // 默认发送长度为8
     // 设置回调函数和接收发送id
-    instance[idx]->can_handle = config->can_handle;
-    instance[idx]->tx_id = config->tx_id; // 好像没用,可以删掉
-    instance[idx]->rx_id = config->rx_id;
-    instance[idx]->can_module_callback = config->can_module_callback;
-    instance[idx]->id = config->id;
+    instance->can_handle = config->can_handle;
+    instance->tx_id = config->tx_id; // 好像没用,可以删掉
+    instance->rx_id = config->rx_id;
+    instance->can_module_callback = config->can_module_callback;
+    instance->id = config->id;
 
-    CANAddFilter(instance[idx]); // 添加CAN过滤器规则
-    return instance[idx++];      // 返回指针
+    CANAddFilter(instance);         // 添加CAN过滤器规则
+    can_instance[idx++] = instance; // 将实例保存到can_instance中
+
+    return instance; // 返回can实例指针
 }
 
 /* TODO:目前似乎封装过度,应该添加一个指向tx_buff的指针,tx_buff不应该由CAN instance保存 */
@@ -117,17 +119,16 @@ static void CANFIFOxCallback(CAN_HandleTypeDef *_hcan, uint32_t fifox)
     static CAN_RxHeaderTypeDef rxconf;
     HAL_CAN_GetRxMessage(_hcan, fifox, &rxconf, can_rx_buff);
     for (size_t i = 0; i < idx; ++i)
-    {
-        // 两者相等说明这是要找的实例
-        if (_hcan == instance[i]->can_handle && rxconf.StdId == instance[i]->rx_id)
+    { // 两者相等说明这是要找的实例
+        if (_hcan == can_instance[i]->can_handle && rxconf.StdId == can_instance[i]->rx_id)
         {
-            instance[i]->rx_len = rxconf.DLC;
-            memcpy(instance[i]->rx_buff, can_rx_buff, rxconf.DLC); // 消息拷贝到对应实例
-            if (instance[i]->can_module_callback != NULL)
+            if (can_instance[i]->can_module_callback != NULL)
             {
-                instance[i]->can_module_callback(instance[i]); // 触发回调进行数据解析和处理
+                can_instance[i]->rx_len = rxconf.DLC;                      // 保存接收到的数据长度
+                memcpy(can_instance[i]->rx_buff, can_rx_buff, rxconf.DLC); // 消息拷贝到对应实例
+                can_instance[i]->can_module_callback(can_instance[i]);     // 触发回调进行数据解析和处理
             }
-            break;
+            return;
         }
     }
 }
diff --git a/bsp/dac/bsp_dac.h b/bsp/dac/bsp_dac.h
deleted file mode 100644
index e69de29..0000000
diff --git a/bsp/dac/bsp_dac.md b/bsp/dac/bsp_dac.md
deleted file mode 100644
index e69de29..0000000
diff --git a/bsp/iic/bsp_iic.c b/bsp/iic/bsp_iic.c
index 88420cf..55065d1 100644
--- a/bsp/iic/bsp_iic.c
+++ b/bsp/iic/bsp_iic.c
@@ -37,16 +37,18 @@ void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c)
 IICInstance *IICRegister(IIC_Init_Config_s *conf)
 {
     // 申请到的空间未必是0, 所以需要手动初始化
-    iic_instance[idx] = (IICInstance *)malloc(sizeof(IICInstance));
-    memset(iic_instance[idx], 0, sizeof(IICInstance));
+    IICInstance *instance = (IICInstance *)malloc(sizeof(IICInstance));
+    instance = (IICInstance *)malloc(sizeof(IICInstance));
+    memset(instance, 0, sizeof(IICInstance));
 
-    iic_instance[idx]->dev_address = conf->dev_address;
-    iic_instance[idx]->callback = conf->callback;
-    iic_instance[idx]->work_mode = conf->work_mode;
-    iic_instance[idx]->handle = conf->handle;
-    iic_instance[idx]->id = conf->id;
+    instance->dev_address = conf->dev_address;
+    instance->callback = conf->callback;
+    instance->work_mode = conf->work_mode;
+    instance->handle = conf->handle;
+    instance->id = conf->id;
 
-    return iic_instance[idx++];
+    iic_instance[idx++] = instance;
+    return instance;
 }
 
 void IICSetMode(IICInstance *iic, IIC_Work_Mode_e mode)
diff --git a/bsp/pwm/bsp_pwm.c b/bsp/pwm/bsp_pwm.c
index e69de29..53d63eb 100644
--- a/bsp/pwm/bsp_pwm.c
+++ b/bsp/pwm/bsp_pwm.c
@@ -0,0 +1,67 @@
+#include "bsp_pwm.h"
+#include "stdlib.h"
+#include "memory.h"
+
+// 配合中断以及初始化
+static uint8_t idx;
+static PWMInstance *pwm_instance[PWM_DEVICE_CNT] = {NULL}; // 所有的pwm instance保存于此,用于callback时判断中断来源
+
+void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
+{
+    for (uint8_t i = 0; i < idx; i++)
+    { // 来自同一个定时器的中断且通道相同
+        if (pwm_instance[i]->htim == htim && htim->Channel == pwm_instance[i]->channel)
+        {
+            if (pwm_instance[i]->callback) // 如果有回调函数
+            {
+                pwm_instance[i]->callback(pwm_instance[i]);
+            }
+            return; // 一次只能有一个通道的中断,所以直接返回
+        }
+    }
+}
+
+PWMInstance *PWMRegister(PWM_Init_Config_s *config)
+{
+    PWMInstance *pwm = (PWMInstance *)malloc(sizeof(PWMInstance));
+    memset(pwm, 0, sizeof(PWMInstance));
+
+    pwm->htim = config->htim;
+    pwm->channel = config->channel;
+    pwm->period = config->period;
+    pwm->pulse = config->pulse;
+    pwm->callback = config->callback;
+    pwm->id = config->id;
+
+    HAL_TIM_PWM_Start(pwm->htim, pwm->channel);
+    __HAL_TIM_SetCompare(pwm->htim, pwm->channel, pwm->pulse);
+
+    pwm_instance[idx++] = pwm;
+    return pwm;
+}
+
+/* 只是对HAL的函数进行了形式上的封装 */
+void PWMStart(PWMInstance *pwm)
+{
+    HAL_TIM_PWM_Start(pwm->htim, pwm->channel);
+    __HAL_TIM_SetCompare(pwm->htim, pwm->channel, pwm->pulse);
+}
+
+/* 只是对HAL的函数进行了形式上的封装 */
+void PWMStop(PWMInstance *pwm)
+{
+    HAL_TIM_PWM_Stop(pwm->htim, pwm->channel);
+}
+
+/* 只是对HAL的函数进行了形式上的封装 */
+void PWMSetPulse(PWMInstance *pwm, uint32_t pulse)
+{
+    pwm->pulse = pulse;
+    __HAL_TIM_SetCompare(pwm->htim, pwm->channel, pwm->pulse);
+}
+
+/* 只是对HAL的函数进行了形式上的封装 */
+void PWMStartDMA(PWMInstance *pwm, uint32_t *pData, uint32_t Size)
+{
+    HAL_TIM_PWM_Start_DMA(pwm->htim, pwm->channel, pData, Size);
+}
\ No newline at end of file
diff --git a/bsp/pwm/bsp_pwm.h b/bsp/pwm/bsp_pwm.h
index e69de29..9386876 100644
--- a/bsp/pwm/bsp_pwm.h
+++ b/bsp/pwm/bsp_pwm.h
@@ -0,0 +1,71 @@
+#ifndef BSP_PWM_H
+#define BSP_PWM_H
+
+#include "tim.h"
+#include "stdint.h"
+
+#define PWM_DEVICE_CNT 16 // PWM实例数量
+
+/* pwm实例结构体 */
+typedef struct pwm_ins_temp
+{
+    TIM_HandleTypeDef *htim;                 // TIM句柄
+    uint32_t channel;                        // 通道
+    uint32_t period;                         // 周期
+    uint32_t pulse;                          // 脉宽
+    void (*callback)(struct pwm_ins_temp *); // DMA传输完成回调函数
+    void *id;                                // 实例ID
+} PWMInstance;
+
+typedef struct
+{
+    TIM_HandleTypeDef *htim;                 // TIM句柄
+    uint32_t channel;                        // 通道
+    uint32_t period;                         // 周期
+    uint32_t pulse;                          // 脉宽
+    void (*callback)(struct pwm_ins_temp *); // DMA传输完成回调函数
+    void *id;                                // 实例ID
+} PWM_Init_Config_s;
+
+/**
+ * @brief 注册一个pwm实例
+ *
+ * @param config 初始化配置
+ * @return PWMInstance*
+ */
+PWMInstance *PWMRegister(PWM_Init_Config_s *config);
+
+/**
+ * @brief 启动pwm
+ *
+ * @param pwm pwm实例
+ */
+void PWMStart(PWMInstance *pwm);
+
+/**
+ * @brief 停止pwm
+ *
+ * @param pwm pwm实例
+ */
+void PWMStop(PWMInstance *pwm);
+
+/**
+ * @brief 设置pwm脉宽
+ *
+ * @param pwm pwm实例
+ * @param pulse 脉宽
+ */
+void PWMSetPulse(PWMInstance *pwm, uint32_t pulse);
+
+/**
+ * @brief 启动pwm dma传输
+ *
+ * @param pwm pwm实例
+ * @param pData 数据首地址指针,注意数据的位数必须和CubeMX配置的DMA传输位数(字长)一致
+ * @param Size 数据长度
+ * @note 如果使用此函数,则需要在CubeMX中配置DMA传输位数为对应位数
+ *       例如:使用16位数据,则需要配置DMA传输位数为16位(half word),配置错误会导致指针越界或数据错误
+ */
+void PWMStartDMA(PWMInstance *pwm, uint32_t *pData, uint32_t Size);
+
+#endif // BSP_PWM_H
\ No newline at end of file
diff --git a/bsp/dac/bsp_dac.c b/bsp/pwm/bsp_pwm.md
similarity index 100%
rename from bsp/dac/bsp_dac.c
rename to bsp/pwm/bsp_pwm.md
diff --git a/bsp/spi/bsp_spi.c b/bsp/spi/bsp_spi.c
index 4e5ad15..74ab133 100644
--- a/bsp/spi/bsp_spi.c
+++ b/bsp/spi/bsp_spi.c
@@ -25,7 +25,7 @@ void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
                 HAL_GPIO_WritePin(spi_instance[i]->GPIO_cs, spi_instance[i]->cs_pin, GPIO_PIN_SET);
                 spi_instance[i]->callback(spi_instance[i]);
             }
-            break;
+            return;
         }
     }
 }
@@ -42,14 +42,17 @@ void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
 
 SPIInstance *SPIRegister(SPI_Init_Config_s *conf)
 {
-    spi_instance[idx] = (SPIInstance *)malloc(sizeof(SPIInstance));
-    spi_instance[idx]->callback = conf->callback;
-    spi_instance[idx]->spi_work_mode = conf->spi_work_mode;
-    spi_instance[idx]->spi_handle = conf->spi_handle;
-    spi_instance[idx]->GPIO_cs = conf->GPIO_cs;
-    spi_instance[idx]->cs_pin = conf->cs_pin;
-    spi_instance[idx]->id = conf->id;
-    return spi_instance[idx++];
+    SPIInstance *instance = (SPIInstance *)malloc(sizeof(SPIInstance));
+    memset(instance, 0, sizeof(SPIInstance));
+    instance->spi_handle = conf->spi_handle;
+    instance->GPIO_cs = conf->GPIO_cs;
+    instance->cs_pin = conf->cs_pin;
+    instance->spi_work_mode = conf->spi_work_mode;
+    instance->callback = conf->callback;
+    instance->id = conf->id;
+
+    spi_instance[idx++] = instance;
+    return instance;
 }
 
 void SPITransmit(SPIInstance *spi_ins, uint8_t *ptr_data, uint8_t len)
diff --git a/bsp/usart/bsp_usart.c b/bsp/usart/bsp_usart.c
index c77e97a..9eb33a3 100644
--- a/bsp/usart/bsp_usart.c
+++ b/bsp/usart/bsp_usart.c
@@ -14,7 +14,8 @@
 
 /* usart service instance, modules' info would be recoreded here using USARTRegister() */
 /* usart服务实例,所有注册了usart的模块信息会被保存在这里 */
-static USARTInstance *instance[DEVICE_USART_CNT] = {NULL};
+static uint8_t idx;
+static USARTInstance *usart_instance[DEVICE_USART_CNT] = {NULL};
 
 /**
  * @brief usart service will start automatically, after each module registered
@@ -27,23 +28,21 @@ static void USARTServiceInit(USARTInstance *_instance)
     HAL_UARTEx_ReceiveToIdle_DMA(_instance->usart_handle, _instance->recv_buff, _instance->recv_buff_size);
     // 关闭dma half transfer中断防止两次进入HAL_UARTEx_RxEventCallback()
     // 这是HAL库的一个设计失误,发生DMA传输完成/半完成以及串口IDLE中断都会触发HAL_UARTEx_RxEventCallback()
-    // 我们只希望处理，因此直接关闭DMA半传输中断第一种和第三种情况
+    // 我们只希望处理第一种和第三种情况,因此直接关闭DMA半传输中断
     __HAL_DMA_DISABLE_IT(_instance->usart_handle->hdmarx, DMA_IT_HT);
 }
 
 USARTInstance *USARTRegister(USART_Init_Config_s *init_config)
 {
-    static uint8_t idx;
+    USARTInstance *instance = (USARTInstance *)malloc(sizeof(USARTInstance));
+    memset(instance, 0, sizeof(USARTInstance));
 
-    instance[idx] = (USARTInstance *)malloc(sizeof(USARTInstance));
-    memset(instance[idx], 0, sizeof(USARTInstance));
+    instance->usart_handle = init_config->usart_handle;
+    instance->recv_buff_size = init_config->recv_buff_size;
+    instance->module_callback = init_config->module_callback;
 
-    instance[idx]->module_callback = init_config->module_callback;
-    instance[idx]->recv_buff_size = init_config->recv_buff_size;
-    instance[idx]->usart_handle = init_config->usart_handle;
-    USARTServiceInit(instance[idx]);
-
-    return instance[idx++];
+    usart_instance[idx++] = instance;
+    return instance;
 }
 
 /* @todo 当前仅进行了形式上的封装,后续要进一步考虑是否将module的行为与bsp完全分离 */
@@ -70,15 +69,18 @@ void USARTSend(USARTInstance *_instance, uint8_t *send_buf, uint16_t send_size)
  */
 void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
 {
-    for (uint8_t i = 0; i < 3; ++i)
-    {
-        if (huart == instance[i]->usart_handle)
-        {
-            instance[i]->module_callback();
-            memset(instance[i]->recv_buff, 0, Size); // 接收结束后清空buffer,对于变长数据是必要的
-            HAL_UARTEx_ReceiveToIdle_DMA(instance[i]->usart_handle, instance[i]->recv_buff, instance[i]->recv_buff_size);
-            __HAL_DMA_DISABLE_IT(instance[i]->usart_handle->hdmarx, DMA_IT_HT);
-            break;
+    for (uint8_t i = 0; i < idx; ++i)
+    { // find the instance which is being handled
+        if (huart == usart_instance[i]->usart_handle)
+        { // call the callback function if it is not NULL
+            if (usart_instance[i]->module_callback != NULL)
+            {
+                usart_instance[i]->module_callback();
+                memset(usart_instance[i]->recv_buff, 0, Size); // 接收结束后清空buffer,对于变长数据是必要的
+            }
+            HAL_UARTEx_ReceiveToIdle_DMA(usart_instance[i]->usart_handle, usart_instance[i]->recv_buff, usart_instance[i]->recv_buff_size);
+            __HAL_DMA_DISABLE_IT(usart_instance[i]->usart_handle->hdmarx, DMA_IT_HT);
+            return; // break the loop
         }
     }
 }
@@ -93,13 +95,13 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
  */
 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
 {
-    for (uint8_t i = 0; i < 3; ++i)
+    for (uint8_t i = 0; i < idx; ++i)
     {
-        if (huart == instance[i]->usart_handle)
+        if (huart == usart_instance[i]->usart_handle)
         {
-            HAL_UARTEx_ReceiveToIdle_DMA(instance[i]->usart_handle, instance[i]->recv_buff, instance[i]->recv_buff_size);
-            __HAL_DMA_DISABLE_IT(instance[i]->usart_handle->hdmarx, DMA_IT_HT);
-            break;
+            HAL_UARTEx_ReceiveToIdle_DMA(usart_instance[i]->usart_handle, usart_instance[i]->recv_buff, usart_instance[i]->recv_buff_size);
+            __HAL_DMA_DISABLE_IT(usart_instance[i]->usart_handle->hdmarx, DMA_IT_HT);
+            return;
         }
     }
 }
\ No newline at end of file
diff --git a/modules/can_comm/can_comm.c b/modules/can_comm/can_comm.c
index c13a916..39702e9 100644
--- a/modules/can_comm/can_comm.c
+++ b/modules/can_comm/can_comm.c
@@ -16,7 +16,7 @@ static void CANCommResetRx(CANCommInstance *ins)
 }
 
 /**
- * @brief
+ * @brief cancomm的接收回调函数
  *
  * @param _instance
  */
@@ -66,7 +66,7 @@ static void CANCommRxCallback(CANInstance *_instance)
                 CANCommResetRx(comm);
                 return; // 重置状态然后返回
             }
-            return; // 访问完一个can comm直接退出,一次中断只会也只可能会处理一个实例的回调
+            return; // 访问完一个can comm直接退出,一次中断只处理一个实例的回调
         }
     }
 }
diff --git a/modules/can_comm/can_comm.h b/modules/can_comm/can_comm.h
index fb53822..c184f80 100644
--- a/modules/can_comm/can_comm.h
+++ b/modules/can_comm/can_comm.h
@@ -26,16 +26,16 @@ typedef struct
 {
     CANInstance *can_ins;
     /* 发送部分 */
-    uint8_t send_data_len;
-    uint8_t send_buf_len;
+    uint8_t send_data_len; // 发送数据长度
+    uint8_t send_buf_len;  // 发送缓冲区长度,为发送数据长度+帧头单包数据长度帧尾以及校验和(4)
     uint8_t raw_sendbuf[CAN_COMM_MAX_BUFFSIZE + CAN_COMM_OFFSET_BYTES]; // 额外4个bytes保存帧头帧尾和校验和
     /* 接收部分 */
-    uint8_t recv_data_len;
-    uint8_t recv_buf_len;
+    uint8_t recv_data_len; // 接收数据长度
+    uint8_t recv_buf_len;  // 接收缓冲区长度,为接收数据长度+帧头单包数据长度帧尾以及校验和(4)
     uint8_t raw_recvbuf[CAN_COMM_MAX_BUFFSIZE + CAN_COMM_OFFSET_BYTES]; // 额外4个bytes保存帧头帧尾和校验和
     uint8_t unpacked_recv_data[CAN_COMM_MAX_BUFFSIZE];                  // 解包后的数据,调用CANCommGet()后cast成对应的类型通过指针读取即可
     /* 接收和更新标志位*/
-    uint8_t recv_state;
+    uint8_t recv_state; // 接收状态,
     uint8_t cur_recv_len;
     uint8_t update_flag;
 } CANCommInstance;
diff --git a/modules/daemon/daemon.c b/modules/daemon/daemon.c
index 49d6677..ac74caa 100644
--- a/modules/daemon/daemon.c
+++ b/modules/daemon/daemon.c
@@ -1,21 +1,23 @@
 #include "daemon.h"
 #include "bsp_dwt.h" // 后续通过定时器来计时?
 #include "stdlib.h"
+#include "memory.h"
 
+// 用于保存所有的daemon instance
 static DaemonInstance *daemon_instances[DAEMON_MX_CNT] = {NULL};
-static uint8_t idx;
+static uint8_t idx; // 用于记录当前的daemon instance数量,配合回调使用
 
 DaemonInstance *DaemonRegister(Daemon_Init_Config_s *config)
 {
-    
-    daemon_instances[idx] = (DaemonInstance *)malloc(sizeof(DaemonInstance));
+    DaemonInstance *instance = (DaemonInstance *)malloc(sizeof(DaemonInstance));
+    memset(instance, 0, sizeof(DaemonInstance));
 
-    daemon_instances[idx]->reload_count = config->reload_count;
-    daemon_instances[idx]->callback = config->callback;
-    daemon_instances[idx]->owner_id = config->id;
-    daemon_instances[idx]->temp_count = config->reload_count;
+    instance->owner_id = config->owner_id;
+    instance->reload_count = config->reload_count;
+    instance->callback = config->callback;
 
-    return daemon_instances[idx++];
+    daemon_instances[idx++] = instance;
+    return instance;
 }
 
 void DaemonReload(DaemonInstance *instance)
@@ -25,20 +27,20 @@ void DaemonReload(DaemonInstance *instance)
 
 uint8_t DaemonIsOnline(DaemonInstance *instance)
 {
-    return instance->temp_count>0;
+    return instance->temp_count > 0;
 }
 
 void DaemonTask()
 {
-    static DaemonInstance* pins; //提高可读性同时降低访存开销
+    static DaemonInstance *dins; // 提高可读性同时降低访存开销
     for (size_t i = 0; i < idx; ++i)
     {
-        pins=daemon_instances[i];
-        if(pins->temp_count>0)
-            pins->temp_count--;
-        else if(pins->callback)
-        {   // 每个module根据自身的offline callback进行调用
-            pins->callback(pins->owner_id); // module将owner_id强制类型转换成自身类型
+        dins = daemon_instances[i];
+        if (dins->temp_count > 0)
+            dins->temp_count--;
+        else if (dins->callback) // 如果有callback
+        {
+            dins->callback(dins->owner_id); // module内可以将owner_id强制类型转换成自身类型从而调用自身的offline callback
         }
     }
 }
diff --git a/modules/daemon/daemon.h b/modules/daemon/daemon.h
index 7167885..f2e6a50 100644
--- a/modules/daemon/daemon.h
+++ b/modules/daemon/daemon.h
@@ -11,11 +11,11 @@ typedef void (*offline_callback)(void *);
 /* daemon结构体定义 */
 typedef struct daemon_ins
 {
-    uint16_t reload_count; // 重载值
+    uint16_t reload_count;     // 重载值
     offline_callback callback; // 异常处理函数,当模块发生异常时会被调用
 
-    uint16_t temp_count; //当前值,减为零说明模块离线或异常
-    void *owner_id; // daemon实例的地址,初始化的时候填入
+    uint16_t temp_count; // 当前值,减为零说明模块离线或异常
+    void *owner_id;      // daemon实例的地址,初始化的时候填入
 
 } DaemonInstance;
 
@@ -23,13 +23,13 @@ typedef struct daemon_ins
 typedef struct
 {
     uint16_t reload_count; // 实际上这是app唯一需要设置的值?
-    offline_callback callback; 
-    void *id; // id取拥有daemon的实例的地址,如DJIMotorInstance*,cast成void*类型
+    offline_callback callback;
+    void *owner_id; // id取拥有daemon的实例的地址,如DJIMotorInstance*,cast成void*类型
 } Daemon_Init_Config_s;
 
 /**
  * @brief 注册一个daemon实例
- * 
+ *
  * @param config 初始化配置
  * @return DaemonInstance* 返回实例指针
  */
@@ -37,14 +37,14 @@ DaemonInstance *DaemonRegister(Daemon_Init_Config_s *config);
 
 /**
  * @brief 当模块收到新的数据或进行其他动作时,调用该函数重载temp_count,相当于"喂狗"
- * 
+ *
  * @param instance daemon实例指针
  */
 void DaemonReload(DaemonInstance *instance);
 
 /**
  * @brief 确认模块是否离线
- * 
+ *
  * @param instance daemon实例指针
  * @return uint8_t 若在线且工作正常,返回1;否则返回零. 后续根据异常类型和离线状态等进行优化.
  */
@@ -53,7 +53,7 @@ uint8_t DaemonIsOnline(DaemonInstance *instance);
 /**
  * @brief 放入rtos中,会给每个daemon实例的temp_count按频率进行递减操作.
  *        模块成功接受数据或成功操作则会重载temp_count的值为reload_count.
- * 
+ *
  */
 void DaemonTask();
 
diff --git a/modules/motor/HT04.c b/modules/motor/HT04.c
index 5172eff..51381b8 100644
--- a/modules/motor/HT04.c
+++ b/modules/motor/HT04.c
@@ -3,7 +3,7 @@
 #include "general_def.h"
 
 static uint8_t idx;
-HTMotorInstance *ht_motor_info[HT_MOTOR_CNT];
+HTMotorInstance *ht_motor_instance[HT_MOTOR_CNT];
 
 /**
  * @brief
@@ -45,7 +45,7 @@ static void HTMotorDecode(CANInstance *motor_can)
     static uint8_t *rxbuff;
 
     rxbuff = motor_can->rx_buff;
-    measure = &((HTMotorInstance *)motor_can->id)->motor_measure;
+    measure = &((HTMotorInstance *)motor_can->id)->motor_measure; // 将can实例中保存的id转换成电机实例的指针
 
     measure->last_angle = measure->total_angle;
 
@@ -63,23 +63,23 @@ static void HTMotorDecode(CANInstance *motor_can)
 
 HTMotorInstance *HTMotorInit(Motor_Init_Config_s *config)
 {
+    HTMotorInstance *motor = (HTMotorInstance *)malloc(sizeof(HTMotorInstance));
+    memset(motor, 0, sizeof(HTMotorInstance));
 
-    ht_motor_info[idx] = (HTMotorInstance *)malloc(sizeof(HTMotorInstance));
-    memset(ht_motor_info[idx], 0, sizeof(HTMotorInstance));
-
-    ht_motor_info[idx]->motor_settings = config->controller_setting_init_config;
-    PID_Init(&ht_motor_info[idx]->current_PID, &config->controller_param_init_config.current_PID);
-    PID_Init(&ht_motor_info[idx]->speed_PID, &config->controller_param_init_config.speed_PID);
-    PID_Init(&ht_motor_info[idx]->angle_PID, &config->controller_param_init_config.angle_PID);
-    ht_motor_info[idx]->other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
-    ht_motor_info[idx]->other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
+    motor->motor_settings = config->controller_setting_init_config;
+    PID_Init(&motor->current_PID, &config->controller_param_init_config.current_PID);
+    PID_Init(&motor->speed_PID, &config->controller_param_init_config.speed_PID);
+    PID_Init(&motor->angle_PID, &config->controller_param_init_config.angle_PID);
+    motor->other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
+    motor->other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
 
     config->can_init_config.can_module_callback = HTMotorDecode;
-    config->can_init_config.id = ht_motor_info[idx];
-    ht_motor_info[idx]->motor_can_instace = CANRegister(&config->can_init_config);
+    config->can_init_config.id = motor;
+    motor->motor_can_instace = CANRegister(&config->can_init_config);
 
-    HTMotorEnable(ht_motor_info[idx]);
-    return ht_motor_info[idx++];
+    HTMotorEnable(motor);
+    ht_motor_instance[idx++] = motor;
+    return motor;
 }
 
 void HTMotorSetRef(HTMotorInstance *motor, float ref)
@@ -99,7 +99,7 @@ void HTMotorControl()
     // 遍历所有电机实例,计算PID
     for (size_t i = 0; i < idx; i++)
     { // 先获取地址避免反复寻址
-        motor = ht_motor_info[i];
+        motor = ht_motor_instance[i];
         measure = &motor->motor_measure;
         setting = &motor->motor_settings;
         motor_can = motor_can;
diff --git a/modules/motor/LK9025.c b/modules/motor/LK9025.c
index fd98fa3..decfda7 100644
--- a/modules/motor/LK9025.c
+++ b/modules/motor/LK9025.c
@@ -11,7 +11,7 @@ static void LKMotorDecode(CANInstance *_instance)
     static LKMotor_Measure_t *measure;
     static uint8_t *rx_buff;
     rx_buff = _instance->rx_buff;
-    measure = &((LKMotorInstance *)_instance)->measure;
+    measure = &((LKMotorInstance *)_instance)->measure; // 通过caninstance保存的id获取对应的motorinstance
 
     measure->last_ecd = measure->ecd;
     measure->ecd = (uint16_t)((rx_buff[7] << 8) | rx_buff[6]);
@@ -36,26 +36,27 @@ static void LKMotorDecode(CANInstance *_instance)
 
 LKMotorInstance *LKMotroInit(Motor_Init_Config_s *config)
 {
-    lkmotor_instance[idx] = (LKMotorInstance *)malloc(sizeof(LKMotorInstance));
-    memset(lkmotor_instance[idx], 0, sizeof(LKMotorInstance));
+    LKMotorInstance *motor = (LKMotorInstance *)malloc(sizeof(LKMotorInstance));
+    motor = (LKMotorInstance *)malloc(sizeof(LKMotorInstance));
+    memset(motor, 0, sizeof(LKMotorInstance));
 
-    lkmotor_instance[idx]->motor_settings = config->controller_setting_init_config;
-    PID_Init(&lkmotor_instance[idx]->current_PID, &config->controller_param_init_config.current_PID);
-    PID_Init(&lkmotor_instance[idx]->speed_PID, &config->controller_param_init_config.speed_PID);
-    PID_Init(&lkmotor_instance[idx]->angle_PID, &config->controller_param_init_config.angle_PID);
-    lkmotor_instance[idx]->other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
-    lkmotor_instance[idx]->other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
+    motor->motor_settings = config->controller_setting_init_config;
+    PID_Init(&motor->current_PID, &config->controller_param_init_config.current_PID);
+    PID_Init(&motor->speed_PID, &config->controller_param_init_config.speed_PID);
+    PID_Init(&motor->angle_PID, &config->controller_param_init_config.angle_PID);
+    motor->other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
+    motor->other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
 
-    config->can_init_config.id = lkmotor_instance[idx];
+    config->can_init_config.id = motor;
     config->can_init_config.can_module_callback = LKMotorDecode;
     config->can_init_config.rx_id = 0x140 + config->can_init_config.tx_id;
     config->can_init_config.tx_id = config->can_init_config.tx_id + 0x280;
-    lkmotor_instance[idx]->motor_can_ins = CANRegister(&config->can_init_config);
+    motor->motor_can_ins = CANRegister(&config->can_init_config);
 
     if (idx == 0)
-        sender_instance = lkmotor_instance[idx]->motor_can_ins;
+        sender_instance = motor->motor_can_ins;
 
-    LKMotorEnable(lkmotor_instance[idx]);
+    LKMotorEnable(motor);
     return lkmotor_instance[idx++];
 }
 
diff --git a/modules/motor/dji_motor.c b/modules/motor/dji_motor.c
index 38487ee..72ab446 100644
--- a/modules/motor/dji_motor.c
+++ b/modules/motor/dji_motor.c
@@ -4,7 +4,7 @@
 static uint8_t idx = 0; // register idx,是该文件的全局电机索引,在注册时使用
 
 /* DJI电机的实例,此处仅保存指针,内存的分配将通过电机实例初始化时通过malloc()进行 */
-static DJIMotorInstance *dji_motor_info[DJI_MOTOR_CNT] = {NULL};
+static DJIMotorInstance *dji_motor_instance[DJI_MOTOR_CNT] = {NULL};
 
 /**
  * @brief 由于DJI电机发送以四个一组的形式进行,故对其进行特殊处理,用6个(2can*3group)can_instance专门负责发送
@@ -54,7 +54,7 @@ static void MotorSenderGrouping(CAN_Init_Config_s *config)
     uint8_t motor_send_num;
     uint8_t motor_grouping;
 
-    switch (dji_motor_info[idx]->motor_type)
+    switch (dji_motor_instance[idx]->motor_type)
     {
     case M2006:
     case M3508:
@@ -72,13 +72,13 @@ static void MotorSenderGrouping(CAN_Init_Config_s *config)
         // 计算接收id并设置分组发送id
         config->rx_id = 0x200 + motor_id + 1;
         sender_enable_flag[motor_grouping] = 1;
-        dji_motor_info[idx]->message_num = motor_send_num;
-        dji_motor_info[idx]->sender_group = motor_grouping;
+        dji_motor_instance[idx]->message_num = motor_send_num;
+        dji_motor_instance[idx]->sender_group = motor_grouping;
 
         // 检查是否发生id冲突
         for (size_t i = 0; i < idx; ++i)
         {
-            if (dji_motor_info[i]->motor_can_instance->can_handle == config->can_handle && dji_motor_info[i]->motor_can_instance->rx_id == config->rx_id)
+            if (dji_motor_instance[i]->motor_can_instance->can_handle == config->can_handle && dji_motor_instance[i]->motor_can_instance->rx_id == config->rx_id)
                 IDcrash_Handler(i, idx);
         }
         break;
@@ -97,12 +97,12 @@ static void MotorSenderGrouping(CAN_Init_Config_s *config)
 
         config->rx_id = 0x204 + motor_id + 1;
         sender_enable_flag[motor_grouping] = 1;
-        dji_motor_info[idx]->message_num = motor_send_num;
-        dji_motor_info[idx]->sender_group = motor_grouping;
+        dji_motor_instance[idx]->message_num = motor_send_num;
+        dji_motor_instance[idx]->sender_group = motor_grouping;
 
         for (size_t i = 0; i < idx; ++i)
         {
-            if (dji_motor_info[i]->motor_can_instance->can_handle == config->can_handle && dji_motor_info[i]->motor_can_instance->rx_id == config->rx_id)
+            if (dji_motor_instance[i]->motor_can_instance->can_handle == config->can_handle && dji_motor_instance[i]->motor_can_instance->rx_id == config->rx_id)
                 IDcrash_Handler(i, idx);
         }
         break;
@@ -130,8 +130,8 @@ static void DecodeDJIMotor(CANInstance *_instance)
     measure->last_ecd = measure->ecd;
     measure->ecd = ((uint16_t)rxbuff[0]) << 8 | rxbuff[1];
     measure->angle_single_round = ECD_ANGLE_COEF_DJI * (float)measure->ecd;
-    measure->speed_aps = (1.0f - SPEED_SMOOTH_COEF) * measure->speed_aps + 
-                        RPM_2_ANGLE_PER_SEC * SPEED_SMOOTH_COEF * (float)((int16_t)(rxbuff[2] << 8 | rxbuff[3]));
+    measure->speed_aps = (1.0f - SPEED_SMOOTH_COEF) * measure->speed_aps +
+                         RPM_2_ANGLE_PER_SEC * SPEED_SMOOTH_COEF * (float)((int16_t)(rxbuff[2] << 8 | rxbuff[3]));
     measure->real_current = (1.0f - CURRENT_SMOOTH_COEF) * measure->real_current +
                             CURRENT_SMOOTH_COEF * (float)((int16_t)(rxbuff[4] << 8 | rxbuff[5]));
     measure->temperate = rxbuff[6];
@@ -147,42 +147,49 @@ static void DecodeDJIMotor(CANInstance *_instance)
 // 电机初始化,返回一个电机实例
 DJIMotorInstance *DJIMotorInit(Motor_Init_Config_s *config)
 {
-    dji_motor_info[idx] = (DJIMotorInstance *)malloc(sizeof(DJIMotorInstance));
-    memset(dji_motor_info[idx], 0, sizeof(DJIMotorInstance));
+    DJIMotorInstance *instance = (DJIMotorInstance *)malloc(sizeof(DJIMotorInstance));
+    memset(instance, 0, sizeof(DJIMotorInstance));
 
     // motor basic setting
-    dji_motor_info[idx]->motor_type = config->motor_type;
-    dji_motor_info[idx]->motor_settings = config->controller_setting_init_config;
+    instance->motor_type = config->motor_type;
+    instance->motor_settings = config->controller_setting_init_config;
 
     // motor controller init
-    PID_Init(&dji_motor_info[idx]->motor_controller.current_PID, &config->controller_param_init_config.current_PID);
-    PID_Init(&dji_motor_info[idx]->motor_controller.speed_PID, &config->controller_param_init_config.speed_PID);
-    PID_Init(&dji_motor_info[idx]->motor_controller.angle_PID, &config->controller_param_init_config.angle_PID);
-    dji_motor_info[idx]->motor_controller.other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
-    dji_motor_info[idx]->motor_controller.other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
+    PID_Init(&instance->motor_controller.current_PID, &config->controller_param_init_config.current_PID);
+    PID_Init(&instance->motor_controller.speed_PID, &config->controller_param_init_config.speed_PID);
+    PID_Init(&instance->motor_controller.angle_PID, &config->controller_param_init_config.angle_PID);
+    instance->motor_controller.other_angle_feedback_ptr = config->controller_param_init_config.other_angle_feedback_ptr;
+    instance->motor_controller.other_speed_feedback_ptr = config->controller_param_init_config.other_speed_feedback_ptr;
 
     // group motors, because 4 motors share the same CAN control message
     MotorSenderGrouping(&config->can_init_config);
 
     // register motor to CAN bus
     config->can_init_config.can_module_callback = DecodeDJIMotor; // set callback
-    config->can_init_config.id = dji_motor_info[idx];             // set id,eq to address(it is identity)
-    dji_motor_info[idx]->motor_can_instance = CANRegister(&config->can_init_config);
+    config->can_init_config.id = instance;                        // set id,eq to address(it is identity)
+    instance->motor_can_instance = CANRegister(&config->can_init_config);
 
-    DJIMotorEnable(dji_motor_info[idx]);
-    return dji_motor_info[idx++];
+    DJIMotorEnable(instance);
+    dji_motor_instance[idx++] = instance;
+    return instance;
 }
 
+/* 电流只能通过电机自带传感器监测,后续考虑加入力矩传感器应变片等 */
 void DJIMotorChangeFeed(DJIMotorInstance *motor, Closeloop_Type_e loop, Feedback_Source_e type)
 {
     if (loop == ANGLE_LOOP)
     {
         motor->motor_settings.angle_feedback_source = type;
     }
-    if (loop == SPEED_LOOP)
+    else if (loop == SPEED_LOOP)
     {
         motor->motor_settings.speed_feedback_source = type;
     }
+    else
+    {
+        while (1)
+            ; // LOOP TYPE ERROR!!!检查是否传入了正确的LOOP类型,或发生了指针越界
+    }
 }
 
 void DJIMotorStop(DJIMotorInstance *motor)
@@ -195,6 +202,7 @@ void DJIMotorEnable(DJIMotorInstance *motor)
     motor->stop_flag = MOTOR_ENALBED;
 }
 
+/* 修改电机的实际闭环对象 */
 void DJIMotorOuterLoop(DJIMotorInstance *motor, Closeloop_Type_e outer_loop)
 {
     motor->motor_settings.outer_loop_type = outer_loop;
@@ -211,70 +219,68 @@ void DJIMotorControl()
 {
     // 预先通过静态变量定义避免反复释放分配栈空间,直接保存一次指针引用从而减小访存的开销
     // 同样可以提高可读性
-    static uint8_t group, num;
-    static int16_t set;
+    static uint8_t group, num; // 电机组号和组内编号
+    static int16_t set;        // 电机控制CAN发送设定值
     static DJIMotorInstance *motor;
-    static Motor_Control_Setting_s *motor_setting;
-    static Motor_Controller_s *motor_controller;
-    static DJI_Motor_Measure_s *motor_measure;
-    static float pid_measure, pid_ref;
+    static Motor_Control_Setting_s *motor_setting; // 电机控制参数
+    static Motor_Controller_s *motor_controller;   // 电机控制器
+    static DJI_Motor_Measure_s *motor_measure;     // 电机测量值
+    static float pid_measure, pid_ref;             // 电机PID测量值和设定值
     // 遍历所有电机实例,进行串级PID的计算并设置发送报文的值
     for (size_t i = 0; i < idx; ++i)
-    {
-        if (dji_motor_info[i])
+    {   // 减小访存开销,先保存指针引用
+        motor = dji_motor_instance[i];
+        motor_setting = &motor->motor_settings;
+        motor_controller = &motor->motor_controller;
+        motor_measure = &motor->motor_measure;
+        pid_ref = motor_controller->pid_ref; // 保存设定值,防止motor_controller->pid_ref在计算过程中被修改
+
+        // pid_ref会顺次通过被启用的闭环充当数据的载体
+        // 计算位置环,只有启用位置环且外层闭环为位置时会计算速度环输出
+        if ((motor_setting->close_loop_type & ANGLE_LOOP) && motor_setting->outer_loop_type == ANGLE_LOOP)
         {
-            motor = dji_motor_info[i];
-            motor_setting = &motor->motor_settings;
-            motor_controller = &motor->motor_controller;
-            motor_measure = &motor->motor_measure;
-            pid_ref = motor_controller->pid_ref; // 保存设定值,防止motor_controller->pid_ref在计算过程中被修改
-
-            // pid_ref会顺次通过被启用的闭环充当数据的载体
-            // 计算位置环,只有启用位置环且外层闭环为位置时会计算速度环输出
-            if ((motor_setting->close_loop_type & ANGLE_LOOP) && motor_setting->outer_loop_type == ANGLE_LOOP)
-            {
-                if (motor_setting->angle_feedback_source == OTHER_FEED)
-                    pid_measure = *motor_controller->other_angle_feedback_ptr;
-                else                                          // MOTOR_FEED
-                    pid_measure = motor_measure->total_angle; // 对total angle闭环,防止在边界处出现突跃
-                // 更新pid_ref进入下一个环
-                pid_ref = PID_Calculate(&motor_controller->angle_PID, pid_measure, pid_ref);
-            }
-
-            // 计算速度环,(外层闭环为速度或位置)且(启用速度环)时会计算速度环
-            if ((motor_setting->close_loop_type & SPEED_LOOP) && (motor_setting->outer_loop_type & (ANGLE_LOOP | SPEED_LOOP)))
-            {
-                if (motor_setting->speed_feedback_source == OTHER_FEED)
-                    pid_measure = *motor_controller->other_speed_feedback_ptr;
-                else // MOTOR_FEED
-                    pid_measure = motor_measure->speed_aps;
-                // 更新pid_ref进入下一个环
-                pid_ref = PID_Calculate(&motor_controller->speed_PID, pid_measure, pid_ref);
-            }
-
-            // 计算电流环,只要启用了电流环就计算,不管外层闭环是什么,并且电流只有电机自身传感器的反馈
-            if (motor_setting->close_loop_type & CURRENT_LOOP)
-            {
-                pid_ref = PID_Calculate(&motor_controller->current_PID, motor_measure->real_current, pid_ref);
-            }
-
-            // 获取最终输出
-            set = (int16_t)pid_ref;
-            if (motor_setting->reverse_flag == MOTOR_DIRECTION_REVERSE)
-                set *= -1; // 设置反转
-
-            // 分组填入发送数据
-            group = motor->sender_group;
-            num = motor->message_num;
-            sender_assignment[group].tx_buff[2 * num] = (uint8_t)(set >> 8);
-            sender_assignment[group].tx_buff[2 * num + 1] = (uint8_t)(set & 0x00ff);
-
-            // 电机是否停止运行
-            if (motor->stop_flag == MOTOR_STOP)
-            { // 若该电机处于停止状态,直接将buff置零
-                memset(sender_assignment[group].tx_buff + 2 * num, 0, 16u);
-            }
+            if (motor_setting->angle_feedback_source == OTHER_FEED)
+                pid_measure = *motor_controller->other_angle_feedback_ptr;
+            else
+                pid_measure = motor_measure->total_angle; // MOTOR_FEED,对total angle闭环,防止在边界处出现突跃
+            // 更新pid_ref进入下一个环
+            pid_ref = PID_Calculate(&motor_controller->angle_PID, pid_measure, pid_ref);
         }
+
+        // 计算速度环,(外层闭环为速度或位置)且(启用速度环)时会计算速度环
+        if ((motor_setting->close_loop_type & SPEED_LOOP) && (motor_setting->outer_loop_type & (ANGLE_LOOP | SPEED_LOOP)))
+        {
+            if (motor_setting->speed_feedback_source == OTHER_FEED)
+                pid_measure = *motor_controller->other_speed_feedback_ptr;
+            else // MOTOR_FEED
+                pid_measure = motor_measure->speed_aps;
+            // 更新pid_ref进入下一个环
+            pid_ref = PID_Calculate(&motor_controller->speed_PID, pid_measure, pid_ref);
+        }
+
+        // 计算电流环,目前只要启用了电流环就计算,不管外层闭环是什么,并且电流只有电机自身传感器的反馈
+        if (motor_setting->close_loop_type & CURRENT_LOOP)
+        {
+            pid_ref = PID_Calculate(&motor_controller->current_PID, motor_measure->real_current, pid_ref);
+        }
+
+        // 获取最终输出
+        set = (int16_t)pid_ref;
+        if (motor_setting->reverse_flag == MOTOR_DIRECTION_REVERSE)
+            set *= -1; // 设置反转
+
+        // 分组填入发送数据
+        group = motor->sender_group;
+        num = motor->message_num;
+        sender_assignment[group].tx_buff[2 * num] = (uint8_t)(set >> 8);
+        sender_assignment[group].tx_buff[2 * num + 1] = (uint8_t)(set & 0x00ff);
+
+        // 电机是否停止运行
+        if (motor->stop_flag == MOTOR_STOP)
+        { // 若该电机处于停止状态,直接将buff置零
+            memset(sender_assignment[group].tx_buff + 2 * num, 0, 16u);
+        }
+        
     }
 
     // 遍历flag,检查是否要发送这一帧报文
diff --git a/modules/motor/servo_motor.c b/modules/motor/servo_motor.c
index 80132cc..fb15863 100644
--- a/modules/motor/servo_motor.c
+++ b/modules/motor/servo_motor.c
@@ -1,22 +1,26 @@
 #include "servo_motor.h"
+#include "stdlib.h"
+#include "memory.h"
 
 extern TIM_HandleTypeDef htim1;
 /*第二版*/
-static ServoInstance *servo_motor[SERVO_MOTOR_CNT] = {NULL};
-static int16_t compare_value[SERVO_MOTOR_CNT]={0};
+static ServoInstance *servo_motor_instance[SERVO_MOTOR_CNT] = {NULL};
+static int16_t compare_value[SERVO_MOTOR_CNT] = {0};
 static uint8_t servo_idx = 0; // register servo_idx,是该文件的全局舵机索引,在注册时使用
 
 // 通过此函数注册一个舵机
 ServoInstance *ServoInit(Servo_Init_Config_s *Servo_Init_Config)
 {
-    servo_motor[servo_idx] = (ServoInstance *)malloc(sizeof(ServoInstance));
-    memset(servo_motor[servo_idx], 0, sizeof(ServoInstance));
-    servo_motor[servo_idx]->Servo_type = Servo_Init_Config->Servo_type;
-    servo_motor[servo_idx]->htim = Servo_Init_Config->htim;
-    servo_motor[servo_idx]->Channel = Servo_Init_Config->Channel;
-    HAL_TIM_Base_Start(Servo_Init_Config->htim);
+    ServoInstance *servo = (ServoInstance *)malloc(sizeof(ServoInstance));
+    memset(servo, 0, sizeof(ServoInstance));
+
+    servo->Servo_type = Servo_Init_Config->Servo_type;
+    servo->htim = Servo_Init_Config->htim;
+    servo->Channel = Servo_Init_Config->Channel;
+
     HAL_TIM_PWM_Start(Servo_Init_Config->htim, Servo_Init_Config->Channel);
-    return servo_motor[servo_idx++];
+    servo_motor_instance[servo_idx++] = servo;
+    return servo;
 }
 
 /**
@@ -63,16 +67,15 @@ void Servo_Motor_StartSTOP_Angle_Set(ServoInstance *Servo_Motor, int16_t Start_a
 }
 /**
  * @brief 舵机模式选择
- * 
+ *
  * @param Servo_Motor 注册的舵机实例
  * @param mode 需要选择的模式
  */
-void Servo_Motor_Type_Select(ServoInstance *Servo_Motor,int16_t mode)
+void Servo_Motor_Type_Select(ServoInstance *Servo_Motor, int16_t mode)
 {
     Servo_Motor->Servo_Angle_Type = mode;
 }
 
-
 /**
  * @brief 舵机输出控制
  *
@@ -84,9 +87,9 @@ void Servo_Motor_Control()
 
     for (size_t i = 0; i < servo_idx; i++)
     {
-        if (servo_motor[i])
+        if (servo_motor_instance[i])
         {
-            Servo_Motor = servo_motor[i];
+            Servo_Motor = servo_motor_instance[i];
             Servo_type = Servo_Motor->Servo_type;
 
             switch (Servo_type)
diff --git a/modules/super_cap/super_cap.c b/modules/super_cap/super_cap.c
index 9c47809..fecbf84 100644
--- a/modules/super_cap/super_cap.c
+++ b/modules/super_cap/super_cap.c
@@ -26,6 +26,7 @@ SuperCapInstance *SuperCapInit(SuperCap_Init_Config_s *supercap_config)
 {
     super_cap_instance = (SuperCapInstance *)malloc(sizeof(SuperCapInstance));
     memset(super_cap_instance, 0, sizeof(SuperCapInstance));
+    
     supercap_config->can_config.can_module_callback = SuperCapRxCallback;
     super_cap_instance->can_ins = CANRegister(&supercap_config->can_config);
     return super_cap_instance;
diff --git a/modules/super_cap/super_cap.h b/modules/super_cap/super_cap.h
index 06d889e..0ac4754 100644
--- a/modules/super_cap/super_cap.h
+++ b/modules/super_cap/super_cap.h
@@ -28,8 +28,6 @@ typedef struct
 typedef struct
 {
     CAN_Init_Config_s can_config;
-    uint8_t send_data_len;
-    uint8_t recv_data_len;
 } SuperCap_Init_Config_s;
 
 SuperCapInstance *SuperCapInit(SuperCap_Init_Config_s *supercap_config);