for debug

# Conflicts:
#	CMakeLists.txt
#	inc/main.h
#	inc/rs485_protocol.h
#	src/main.c
#	src/rs485_protocol.c

CMakeLists.txt

@@ -6,17 +6,17 @@ set(PROJECT_NAME "XLSW_3DP_US-IR")
 project(${PROJECT_NAME})
 
 set(VERSION_MAJOR 0)
-set(VERSION_MINOR 0)
-set(VERSION_PATCH 1)
+set(VERSION_MINOR 2)
+set(VERSION_PATCH 0)
 set(VERSION "V${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
 string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
 
 # Options 1
-set(OPT1 "")
+set(OPT1 "_[12V]")
 #set(OPT1 "_[SW_IIC]")
 
 # Options 2
-set(OPT2 "")
+set(OPT2 "_[HW_IIC]")
 #set(OPT2 "_[NO_LED]")
 
 enable_language(C)
@@ -39,6 +39,9 @@ set(TARGET_C_SRC
         ${CMAKE_SOURCE_DIR}/src/soft_i2c.c
         ${CMAKE_SOURCE_DIR}/src/i2c.c
         ${CMAKE_SOURCE_DIR}/src/fwdgt.c
+        ${CMAKE_SOURCE_DIR}/src/rs485_protocol.c
+        ${CMAKE_SOURCE_DIR}/src/ultrasonic_analog.c
+        ${CMAKE_SOURCE_DIR}/src/gd60914.c
 )
 
 add_executable(${PROJECT_NAME} ${TARGET_C_SRC})

cmake/toolchain.cmake

@@ -91,9 +91,15 @@ set(TARGET_CFLAGS_HARDWARE "-mcpu=cortex-m23 -mfloat-abi=soft -mthumb -mthumb-in
 
 # Conditional flags
 # DEBUG
-set(CMAKE_C_FLAGS_DEBUG     "-DDEBUG=0 -O0 -g")
-set(CMAKE_CXX_FLAGS_DEBUG   "-DDEBUG=0 -O0 -g")
-set(CMAKE_ASM_FLAGS_DEBUG   "-DDEBUG=0 -O0 -g")
+#set(CMAKE_C_FLAGS_DEBUG     "-DDEBUG=0 -O0 -g")
+#set(CMAKE_CXX_FLAGS_DEBUG   "-DDEBUG=0 -O0 -g")
+#set(CMAKE_ASM_FLAGS_DEBUG   "-DDEBUG=0 -O0 -g")
+#set(CMAKE_C_FLAGS_DEBUG     "-DDEBUG=0 -O2 -g")
+#set(CMAKE_CXX_FLAGS_DEBUG   "-DDEBUG=0 -O2 -g")
+#set(CMAKE_ASM_FLAGS_DEBUG   "-DDEBUG=0 -O2 -g")
+set(CMAKE_C_FLAGS_DEBUG     "-DDEBUG=0 -Os -g")
+set(CMAKE_CXX_FLAGS_DEBUG   "-DDEBUG=0 -Os -g")
+set(CMAKE_ASM_FLAGS_DEBUG   "-DDEBUG=0 -Os -g")
 
 # RELEASE
 set(CMAKE_C_FLAGS_RELEASE        "-DNDEBUG -O3") #  -flto

inc/board_config.h

@@ -9,6 +9,24 @@
 
 // #define DEBUG_VERBOES
 
+#define POWER_SUPPLY_12V
+// #define POWER_SUPPLY_24V
+
+/******************************************************************************/
+
+#ifdef POWER_SUPPLY_12V
+#define POWER_VOLTAGE       "12V"
+#define TIME_CORRECTION_US  250
+#define CAPTURE_VALUE_MAX   515
+#elif defined(POWER_SUPPLY_24V)
+#define POWER_VOLTAGE       "24V"
+#define TIME_CORRECTION_US  230
+#define CAPTURE_VALUE_MAX   550
+#else
+    #error "Please define either POWER_SUPPLY_12V or POWER_SUPPLY_24V"
+#endif
+
+
 /******************************************************************************/
 
 #define I2C_GPIO_RCU         RCU_GPIOF
@@ -23,24 +41,57 @@
 /******************************************************************************/
 
 #define USART_GPIO_RCU       RCU_GPIOA
-#define USART_RCU            RCU_USART0
+#define USART_RCU            RCU_USART1
 #define USART_GPIO_PORT      GPIOA
 #define USART_GPIO_AF        GPIO_AF_1
 #define USART_TX_PIN         GPIO_PIN_2
 #define USART_RX_PIN         GPIO_PIN_3
-#define USART_PHY            USART0
+#define USART_PHY            USART1
 #define USART_PHY_BAUDRATE   115200U
+#define USART_PHY_IRQ        USART1_IRQn
 #define RS485_EN_PORT        GPIOA
-#define RS485_EN_PIN         GPIO_PIN_1
+#define RS485_EN_PIN         GPIO_PIN_4
 
 /******************************************************************************/
 
 #define LED_PORT             GPIOA
 #define LED_PIN              GPIO_PIN_9
 #define LED_RCU              RCU_GPIOA
-#define LED_BLINK_TIMER_RCU  RCU_TIMER16
-#define LED_BLINK_TIMER      TIMER16
-#define LED_BLINK_IRQ        TIMER16_IRQn
+#define LED_BLINK_TIMER_RCU  RCU_TIMER5
+#define LED_BLINK_TIMER      TIMER5
+#define LED_BLINK_IRQ        TIMER5_IRQn
+
+/******************************************************************************/
+
+
+#define US_TX_GPIO_RCU       RCU_GPIOB
+#define US_TX_GPIO_PORT      GPIOB
+#define US_TX_PIN            GPIO_PIN_1
+#define US_TX_GPIO_AF        GPIO_AF_0
+#define US_TX_RCU            RCU_TIMER13
+#define US_TX_TIMER          TIMER13
+#define US_TX_CH             TIMER_CH_0
+
+/******************************************************************************/
+
+#define US_TX_DELAY_RCU       RCU_TIMER15
+#define US_TX_DELAY_TIMER     TIMER15
+
+/******************************************************************************/
+
+#define US_RX_GPIO_RCU        RCU_GPIOA
+#define US_RX_EXTI_RCU        RCU_CFGCMP
+#define US_RX_GPIO_PORT       GPIOA
+#define US_RX_GPIO_PIN        GPIO_PIN_0
+#define US_RX_EXTI_IRQ        EXTI0_1_IRQn
+#define US_RX_GPIO_EXTI       EXTI_0
+#define US_RX_EXTI_LINE       EXTI_SOURCE_PIN0
+
+/******************************************************************************/
+
+#define US_ECHO_RCU          RCU_TIMER16
+#define US_ECHO_TIMER        TIMER16
+#define US_ECHO_CH           TIMER_CH_0
 
 /******************************************************************************/
 

inc/gd32e23x_it.h

@@ -39,6 +39,9 @@ OF SUCH DAMAGE.
 #include "main.h"
 #include "systick.h"
 #include "board_config.h"
+#include "usart.h"
+#include "fwdgt.h"
+#include "rs485_protocol.h"
 
 /* function declarations */
 /* this function handles NMI exception */
@@ -52,6 +55,6 @@ void PendSV_Handler(void);
 /* this function handles SysTick exception */
 void SysTick_Handler(void);
 
-void TIMER16_IRQHandler(void);
+void TIMER5_IRQHandler(void);
 
 #endif /* GD32E23X_IT_H */

inc/gd60914.h

@@ -0,0 +1,34 @@
+//
+// Created by dell on 25-1-7.
+//
+
+#ifndef GD60914_H
+#define GD60914_H
+
+#include "gd32e23x_it.h"
+#include "gd32e23x.h"
+
+#include "board_config.h"
+
+#ifdef SOFTWARE_IIC
+#include "soft_i2c.h"
+#else
+#include "i2c.h"
+#endif
+
+/******************************************************************************/
+
+#define GD60914_ADDR         (0x18 << 1)
+
+/******************************************************************************/
+
+#define GD60914_HUM_TEMP     0x1A
+#define GD60914_OBJ_TEMP     0x1F
+#define GD60914_AMB_TEMP     0x1E
+#define GD60914_TEMP_REG     0x1C
+
+void gd60914_get_object_tempture(void);
+
+void gd60914_read_temp(void);
+
+#endif //GD60914_H

inc/i2c.h

@@ -19,7 +19,7 @@
 
 /******************************************************************************/
 
-#define I2C_SPEED       20000
+#define I2C_SPEED       100000
 
 #define I2C_TIME_OUT    (uint16_t)(5000)
 #define I2C_OK          1

inc/main.h

@@ -43,6 +43,7 @@ OF SUCH DAMAGE.
 #include "usart.h"
 #include "fwdgt.h"
 #include "board_config.h"
+#include "gd60914.h"
 
 #ifdef SOFTWARE_IIC
 #include "soft_i2c.h"

inc/rs485_protocol.h

@@ -0,0 +1,78 @@
+//
+// Created by yelv1 on 24-12-31.
+//
+
+#ifndef RS485_PROTOCOL_H
+#define RS485_PROTOCOL_H
+
+#include "gd32e23x.h"
+#include "systick.h"
+#include "gd32e23x_libopt.h"
+#include "board_config.h"
+#include "usart.h"
+#include "fwdgt.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "ultrasonic_analog.h"
+
+/******************************************************************************/
+
+#define PROTOCOL_PACKAGE_HEADER   0xD5
+#define PROTOCOL_BOARD_TYPE       0x04
+#define PROTOCOL_PACKAGE_LENGTH   0x02
+
+#define PACKET_START_BYTE         0xD5
+
+#define MAX_SERIAL_CMD_SIZE       16
+#define BUF_SIZE      8
+
+/******************************************************************************/
+
+typedef enum
+{
+    VALIDATION_SUCCESS = 0,
+    VALIDATION_CRC_ERROR = 1,
+    VALIDATION_HEADER_ERROR = 2,
+    VALIDATION_TYPE_ERROR = 4,
+    VALIDATION_LENGTH_ERROR = 8
+} validation_result_t;
+
+typedef enum {
+    PS_LEN,
+    PS_TYPE,
+    PS_PAYLOAD,
+    PS_CRC,
+    PS_NULL
+}packet_state_t;
+
+/******************************************************************************/
+
+// void process_command(uint8_t* cmd, size_t length);
+
+bool code_seen(char code);
+
+float code_value(void);
+
+uint8_t calculate_crc(uint8_t data[], uint8_t data_length);
+
+validation_result_t validate_package_crc(uint8_t* data, uint8_t data_length);
+
+validation_result_t validate_package_header(uint8_t* data);
+
+validation_result_t validate_package_type(uint8_t* data);
+
+validation_result_t validate_data_length(uint8_t* data);
+
+void gd60914_tempture_report(void);
+
+void ultrasonic_distance_report(void);
+
+void start_communication(void);
+
+void get_command(void);
+
+void prcess_command(void);
+
+#endif //RS485_PROTOCOL_H

inc/ultrasonic_analog.h

@@ -0,0 +1,43 @@
+//
+// Created by yelv1 on 24-12-31.
+//
+
+#ifndef ULTRASONIC_ANALOG_H
+#define ULTRASONIC_ANALOG_H
+
+#include "gd32e23x.h"
+#include "systick.h"
+#include "gd32e23x_libopt.h"
+#include "board_config.h"
+#include "usart.h"
+#include "fwdgt.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+extern volatile bool ultrasonicMeasurementDone;
+
+/******************************************************************************/
+
+#define ULTRASONIC_TX_CYCLES        0x05U
+#define ULTRASONIC_TX_TIME          498  // (ms)
+
+/******************************************************************************/
+
+void ultrasonic_gpio_config(void);
+
+void ultrasonic_pwm_out_cycles(const uint8_t cycles);
+
+void ultrasonic_transmit_delay(const uint16_t micro_second);
+
+void ultrasonic_rece_exti_config(void);
+
+void ultrasonic_echo_timer_config(void);
+
+void ultrasonic_config(void);
+
+uint16_t ultrasonic_calc_distance(void);
+
+
+#endif //ULTRASONIC_ANALOG_H

inc/usart.h

@@ -8,8 +8,25 @@
 #include "gd32e23x.h"
 #include "board_config.h"
 
+#define RX_BUFFER_SIZE            64
+
+typedef struct
+{
+    unsigned char buffer[RX_BUFFER_SIZE];
+    volatile unsigned int head;
+    volatile unsigned int tail;
+}ring_buffer_t;
+
+static ring_buffer_t rx_buffer = {{0}, 0, 0}; // ring buffer for USART0
+
 void usart_config(void);
 
 void rs485_config(void);
 
+void store_char(unsigned char data, ring_buffer_t *rx_buf);
+
+uint16_t uart_available(void);
+
+int uart_read(void);
+
 #endif //USART_H

ld/gd32e23x_gcc.ld

@@ -1,8 +1,8 @@
 /* memory map */
 MEMORY
 {
-  FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 16K
-  RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 4K
+  FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 64K
+  RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 8K
 }
 
 ENTRY(Reset_Handler)

src/gd32e23x_it.c

@@ -34,6 +34,9 @@ OF SUCH DAMAGE.
 
 #include "gd32e23x_it.h"
 
+extern uint16_t g_capture_value;
+extern ring_buffer_t rx_buffer;
+
 /*!
     \brief      this function handles NMI exception
     \param[in]  none
@@ -102,8 +105,7 @@ void SysTick_Handler(void)
     \param[out] none
     \retval     none
 */
-void TIMER16_IRQHandler(void)
-{
+void TIMER5_IRQHandler(void) {
     if (timer_interrupt_flag_get(LED_BLINK_TIMER, TIMER_INT_FLAG_UP) == SET)
     {
         timer_interrupt_flag_clear(LED_BLINK_TIMER, TIMER_INT_FLAG_UP);
@@ -116,8 +118,68 @@ void TIMER16_IRQHandler(void)
         } else {
             //! turn off led & reconfig timer13 period to 1000(100ms)
             gpio_bit_write(LED_PORT, LED_PIN, SET);
-            timer_autoreload_value_config(LED_BLINK_TIMER, 800);
+            timer_autoreload_value_config(LED_BLINK_TIMER, 8000);
         }
         led_status = !led_status;
     }
+}
+
+/**
+  * @brief  This function handles TIMER15 interrupt request.
+  * @param[in]  none
+  * @param[out] none
+  * @retval None
+  */
+void TIMER15_IRQHandler(void) {
+    if (timer_interrupt_flag_get(US_TX_DELAY_TIMER, TIMER_INT_FLAG_UP) == SET)
+    {
+        timer_interrupt_flag_clear(US_TX_DELAY_TIMER, TIMER_INT_FLAG_UP);
+        exti_interrupt_enable(US_RX_GPIO_EXTI); // turn on hardware external input interrupt
+        timer_counter_value_config(US_ECHO_TIMER, 0);
+        timer_enable(US_ECHO_TIMER);   // turn on timer to calculate the first ultrasonic echo time
+        timer_disable(US_TX_DELAY_TIMER);
+    }
+}
+
+/**
+  * @brief  This function handles external lines 0 to 1 interrupt request
+  * @param[in]  none
+  * @param[out] none
+  * @retval None
+  */
+void EXTI0_1_IRQHandler(void) {
+    if (exti_interrupt_flag_get(US_RX_GPIO_EXTI) == SET)
+    {
+        exti_interrupt_flag_clear(US_RX_GPIO_EXTI);
+        g_capture_value = timer_channel_capture_value_register_read(US_ECHO_TIMER, US_ECHO_CH);
+        ultrasonicMeasurementDone = true;
+        timer_disable(US_ECHO_TIMER);
+        exti_interrupt_disable(US_RX_GPIO_EXTI);
+    }
+}
+
+void USART1_IRQHandler(void) {
+    // static uint8_t rx_index = 0;
+    // static uint8_t rx_buffer[RX_BUFFER_SIZE];
+
+    if (RESET != usart_interrupt_flag_get(USART_PHY, USART_INT_FLAG_RBNE)) {
+        // usart_interrupt_flag_clear(USART_PHY, USART_INT_FLAG_RBNE);
+        uint8_t received_data = (uint8_t) usart_data_receive(USART_PHY);
+
+        // printf("%c", received_data);
+        // 将接收到的数据存储到缓冲区
+        // if (rx_index < RX_BUFFER_SIZE - 1) {
+        //     rx_buffer[rx_index++] = received_data;
+        // }
+        store_char(received_data, &rx_buffer);
+    }
+    //
+    // if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE)) {
+    //     usart_interrupt_flag_clear(USART0, USART_INT_FLAG_IDLE);
+    //
+    //     process_command(rx_buffer, rx_index); // 处理指令
+    //
+    //     rx_index = 0; // 重置缓冲区索引
+    //     return;
+    // }
 }

src/gd60914.c

@@ -0,0 +1,51 @@
+//
+// Created by dell on 25-1-7.
+//
+
+#include "gd60914.h"
+
+void gd60914_get_object_tempture(void) {
+    #ifdef SOFTWARE_IIC
+    soft_i2c_config();
+    #else
+    i2c_config();
+    #endif
+
+    static uint8_t sensor_validation_data[2];
+    extern uint8_t g_temperature_uint8[2];
+
+#ifdef SOFTWARE_IIC
+    soft_i2c_read_16bits(GD60914_ADDR, GD60914_OBJ_TEMP, data);
+#else
+    i2c_read_16bits(GD60914_ADDR, GD60914_OBJ_TEMP, sensor_validation_data);
+#endif
+
+    if (sensor_validation_data[0] != 0xAA || sensor_validation_data[1] != 0x55) {
+#ifdef DEBUG_VERBOES
+        printf("sensor error\r\n");
+#endif
+        return;
+    }
+
+    delay_ms(350);
+
+#ifdef SOFTWARE_IIC
+    soft_i2c_read_16bits(GD60914_ADDR, GD60914_TEMP_REG, g_temperature_uint8);
+#else
+    i2c_read_16bits(GD60914_ADDR, GD60914_TEMP_REG, g_temperature_uint8);
+#endif
+
+    // printf("%d\r\n", g_temperature_uint8[1] << 8 | g_temperature_uint8[0]);
+}
+
+void gd60914_read_temp(void) {
+
+    uint8_t value[2] = {0};
+    #ifdef SOFTWARE_IIC
+    soft_i2c_read_16bits(GD60914_ADDR, GD60914_OBJ_TEMP, value);
+    #else
+    i2c_read_16bits(GD60914_ADDR, GD60914_TEMP_REG, value);
+    #endif
+
+    printf("%x %x\r\n", value[1], value[0]);
+}

src/main.c

@@ -6,6 +6,11 @@
 */
 #include "main.h"
 
+#include "newlib.h"
+
+volatile uint8_t g_temperature_uint8[2] = {0};
+volatile uint16_t g_capture_value;
+
 /*!
     \brief      main function
     \param[in]  none
@@ -14,6 +19,7 @@
 */
 int main(void)
 {
+    setbuf(stdout, NULL);
     /* configure systick */
     systick_config();
     /* configure USART */
@@ -21,23 +27,36 @@ int main(void)
     /* configure LED */
     led_blink_config();
     /* configure FWDGT */
-    watchdog_init();
+    // watchdog_init();
+
+// #ifdef SOFTWARE_IIC
+//     soft_i2c_config();
+// #else
+//     i2c_config();
+// #endif
 
     printf("system start!\r\n");
 
-    while(1){
-        printf("hello world!\r\n");
-        delay_ms(500);
+    // ultrasonic_config();
 
-        watchdog_reload();
+    while(1){
+        // gd60914_get_object_tempture();
+
+        delay_ms(500);
+        start_communication();
+        printf("hello world!\r\n");
+
+        // ultrasonic_pwm_out_cycles(ULTRASONIC_TX_CYCLES);
+
+        // watchdog_reload();
     }
 }
 
 /* retarget the C library printf function to the USART */
 int _write(int fd, char *pBuffer, int size) {
     for (int i = 0; i < size; i++) {
-        usart_data_transmit(USART0, (uint8_t) pBuffer[i]);
-        while (RESET == usart_flag_get(USART0, USART_FLAG_TBE));
+        usart_data_transmit(USART1, (uint8_t) pBuffer[i]);
+        while (RESET == usart_flag_get(USART1, USART_FLAG_TBE));
     }
     return size;
 }

src/rs485_protocol.c

@@ -0,0 +1,243 @@
+//
+// Created by yelv1 on 24-12-31.
+//
+
+#include "rs485_protocol.h"
+
+extern uint8_t g_temperature_uint8[2];
+
+static int buf_index_r = 0;
+static int buf_index_w = 0;
+static int buf_length = 0;
+
+static char cmd_buffer[BUF_SIZE][MAX_SERIAL_CMD_SIZE];
+static char serial_char = 0x00;
+
+static int serial_count = 0;
+static char *strchr_pointer = NULL;
+
+static packet_state_t packet_state = PS_LEN;
+
+// bool code_seen(char code) {
+//     // strchr_pointer = strchr(cmd_buffer[buf_index_r], code);
+//     return (strchr_pointer != NULL);  //Return True if a character was found
+// }
+
+bool code_seen(char code) {
+    strchr_pointer = NULL;
+    for (int i = 0; cmd_buffer[buf_index_r][i] != '\0'; i++) {
+        if (cmd_buffer[buf_index_r][i] == code) {
+            strchr_pointer = &cmd_buffer[buf_index_r][i];
+            break;
+        }
+    }
+    return (strchr_pointer != NULL);  // Return True if a character was found
+}
+
+float code_value(void) {
+    return (strtod(&cmd_buffer[buf_index_r][strchr_pointer - cmd_buffer[buf_index_r] + 1], NULL));
+}
+
+// void process_command(uint8_t *cmd, size_t length) {
+//     char combined_str[3];
+//     validation_result_t validate = VALIDATION_SUCCESS;
+//
+//     validate = (validate_package_header(cmd) |
+//                 validate_package_type(cmd) |
+//                 validate_data_length(cmd) |
+//                 validate_package_crc(cmd, length));
+//
+//     switch (validate) {
+//     case VALIDATION_SUCCESS:
+//         // printf("%d", length);
+//             sprintf(combined_str, "%c%c", cmd[3], cmd[4]);
+//         if (strcmp(combined_str, "M1") == 0) {
+//             ultrasonic_distance_report();
+//         } else if (strcmp(combined_str, "M2") == 0) {
+//             gd60914_tempture_report();
+//         } else if (strcmp(combined_str, "M3") == 0)
+//         {
+//             printf("%c%c%c%c%c%c", 0xB5, 0xF1, 0x02, 0x6F, 0x6B, 0xCC);
+//             fwdgt_reset_mcu();
+//         } else {
+//             printf("%c%c%c%c%c%c%c", 0xB5, 0xF0, 0x03, 0x65, 0x72, 0x72, 0x3C);
+//             return;
+//         }
+//         break;
+//     case VALIDATION_CRC_ERROR:
+//         printf("%c%c%c%c%c%c%c", 0xB5, 0xF1, 0x03, 0x65, 0x72, 0x72, 0x3D);
+//         break;
+//     case VALIDATION_HEADER_ERROR:
+//         printf("%c%c%c%c%c%c%c", 0xB5, 0xF2, 0x03, 0x65, 0x72, 0x72, 0x3E);
+//         break;
+//     case VALIDATION_TYPE_ERROR:
+//         printf("%c%c%c%c%c%c%c", 0xB5, 0xF3, 0x03, 0x65, 0x72, 0x72, 0x3F);
+//         break;
+//     case VALIDATION_LENGTH_ERROR:
+//         printf("%c%c%c%c%c%c%c", 0xB5, 0xF4, 0x03, 0x65, 0x72, 0x72, 0x40);
+//         break;
+//     default:
+//         break;
+//     }
+// }
+
+uint8_t calculate_crc(uint8_t data[], uint8_t data_length) {
+    uint8_t crc = 0;
+
+    for (uint8_t i = 1; i < data_length - 1; i++) {
+        crc += data[i];
+    }
+
+    return (uint8_t) (crc & 0xFF);
+}
+
+validation_result_t validate_package_crc(uint8_t *data, uint8_t data_length) {
+    if (data[data_length - 1] == calculate_crc(data, data_length) && data_length == 3 + data[2] + 1) {
+        return VALIDATION_SUCCESS;
+    } else {
+        return VALIDATION_CRC_ERROR;
+    }
+}
+
+validation_result_t validate_package_header(uint8_t *data) {
+    if (data[0] == PROTOCOL_PACKAGE_HEADER) {
+        return VALIDATION_SUCCESS;
+    } else {
+        return VALIDATION_HEADER_ERROR;
+    }
+}
+
+validation_result_t validate_package_type(uint8_t *data) {
+    if (data[1] == PROTOCOL_BOARD_TYPE) {
+        return VALIDATION_SUCCESS;
+    } else {
+        return VALIDATION_TYPE_ERROR;
+    }
+}
+
+validation_result_t validate_data_length(uint8_t *data) {
+    if (data[2] == PROTOCOL_PACKAGE_LENGTH) {
+        return VALIDATION_SUCCESS;
+    } else {
+        return VALIDATION_LENGTH_ERROR;
+    }
+}
+
+void gd60914_tempture_report(void) {
+    static uint8_t package_header[3] = {0xB5, 0xF0, 0x02};
+
+    uint8_t combined_data[5];
+    memcpy(combined_data, package_header, 3);
+    memcpy(combined_data + 3, g_temperature_uint8, 2);
+
+    printf("%c%c%c", package_header[0], package_header[1], package_header[2]);
+    printf("%c%c", g_temperature_uint8[1], g_temperature_uint8[0]);
+    printf("%c", calculate_crc(combined_data, 6));
+}
+
+void ultrasonic_distance_report(void) {
+    static uint16_t distance_uint16 = 0;
+    static uint8_t package_header[3] = {0xB5, 0xF0, 0x02};
+    static uint8_t package_data[4] = {0};
+
+    distance_uint16 = ultrasonic_calc_distance();
+
+    package_data[0] = (distance_uint16 >> 8) & 0xFF;
+    package_data[1] = distance_uint16 & 0xFF;
+
+    uint8_t combined_data[7];
+    memcpy(combined_data, package_header, 3);
+    memcpy(combined_data + 3, package_data, 2);
+
+    printf("%c%c%c", package_header[0], package_header[1], package_header[2]);
+    printf("%c%c", package_data[0], package_data[1]);
+    printf("%c", calculate_crc(combined_data, 6));
+}
+
+void start_communication(void) {
+    if (buf_length < (BUF_SIZE - 1)) {
+        get_command();
+    }
+
+    if (buf_length) {
+        printf("DONE！\r\n");
+        prcess_command();
+        buf_length--;
+        buf_index_r = (buf_index_r + 1) % BUF_SIZE;
+    }
+
+}
+
+void get_command(void) {
+    static uint8_t check_sum = 0;
+    static uint8_t packet_len ;
+    static uint8_t packet_type;
+    packet_state = PS_NULL;
+    serial_count = 0;
+    serial_char=0;
+
+    if (uart_available() > 0)
+        delay_ms(5);
+    while (uart_available() > 0 && buf_length < BUF_SIZE) {
+        delay_us(100);
+        serial_char = uart_read();
+        switch (packet_state) {
+            case PS_NULL:
+                if (serial_char == PACKET_START_BYTE) {
+                    packet_state = PS_TYPE;
+                    serial_count = 0;
+                    check_sum = 0;
+                } else {
+                    serial_count = 0;
+                }
+                break;
+            case PS_TYPE:
+                packet_type = serial_char;
+                check_sum += serial_char;
+                packet_state = PS_LEN;
+                break;
+            case PS_LEN:
+                check_sum += serial_char;
+                packet_len = serial_char;
+                packet_state = PS_PAYLOAD;
+                break;
+            case PS_PAYLOAD:
+                check_sum += serial_char;
+                cmd_buffer[buf_index_w][serial_count++] = serial_char;
+                if (serial_count >= packet_len) {
+                    packet_state = PS_CRC;
+                }
+                break;
+            case PS_CRC:
+                packet_state = PS_NULL;
+                if (!serial_count || check_sum != serial_char) {
+                    serial_count = 0;
+                    return;
+                }
+                cmd_buffer[buf_index_w][serial_count] = 0;
+                buf_index_w = (buf_index_w + 1) % BUF_SIZE;
+                buf_length++;
+                serial_count = 0;
+            default:
+                break;
+        }
+    }
+}
+
+void prcess_command(void) {
+    if (code_seen('M')) {
+        switch ((int)code_value()) {
+            case 1:
+                // ultrasonic_distance_report();
+                    printf("M1");
+                break;
+            case 2:
+                // gd60914_tempture_report();
+                    printf("M2");
+                break;
+            default:
+                break;
+        }
+    }
+
+}

src/soft_i2c.c

@@ -11,7 +11,7 @@
     \retval     none
 */
 void soft_i2c_delay(void) {
-    delay_us(20); // Adjust delay as needed
+    delay_us(1); // Adjust delay as needed
     /* delay to freq
      *  15KHz: delay_us(20);
      *  65KHz: delay_us(1);

src/ultrasonic_analog.c

@@ -0,0 +1,154 @@
+//
+// Created by yelv1 on 24-12-31.
+//
+
+#include "ultrasonic_analog.h"
+
+volatile bool ultrasonicMeasurementDone = false;
+extern uint32_t g_capture_value;
+
+/*!
+    \brief      configure ultrasonic gpio & timer13 ch0 pwm output
+    \param[in]  none
+    \param[out] none
+    \retval     none
+*/
+void ultrasonic_gpio_config(void) {
+    rcu_periph_clock_enable(US_TX_GPIO_RCU);
+
+    gpio_mode_set(US_TX_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, US_TX_PIN);
+    gpio_output_options_set(US_TX_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, US_TX_PIN);
+    gpio_af_set(US_TX_GPIO_PORT, US_TX_GPIO_AF, US_TX_PIN);
+
+    timer_oc_parameter_struct timer_ocinitpara;
+    timer_parameter_struct timer_initpara;
+
+    rcu_periph_clock_enable(US_TX_RCU);
+    timer_deinit(US_TX_TIMER);
+
+    timer_struct_para_init(&timer_initpara);
+    timer_initpara.prescaler = 0;
+    timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
+    timer_initpara.counterdirection = TIMER_COUNTER_UP;
+    timer_initpara.period = 239;
+    timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
+    timer_init(US_TX_TIMER, &timer_initpara);
+
+    timer_channel_output_struct_para_init(&timer_ocinitpara);
+    timer_ocinitpara.outputstate = TIMER_CCX_ENABLE;
+    timer_ocinitpara.outputnstate = TIMER_CCXN_DISABLE;
+    timer_ocinitpara.ocpolarity = TIMER_OC_POLARITY_HIGH;
+    timer_ocinitpara.ocnpolarity = TIMER_OCN_POLARITY_HIGH;
+    timer_ocinitpara.ocidlestate = TIMER_OC_IDLE_STATE_LOW;
+    timer_ocinitpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
+    timer_channel_output_config(US_TX_TIMER, US_TX_CH, &timer_ocinitpara);
+
+    timer_channel_output_pulse_value_config(US_TX_TIMER, US_TX_CH, 120);
+    timer_channel_output_mode_config(US_TX_TIMER, US_TX_CH, TIMER_OC_MODE_PWM0);
+    timer_auto_reload_shadow_enable(US_TX_TIMER);
+
+    timer_interrupt_enable(US_TX_TIMER, TIMER_INT_UP);
+}
+
+void ultrasonic_pwm_out_cycles(const uint8_t cycles) {
+    ultrasonicMeasurementDone = false;
+    uint8_t current_cycle = 0;
+
+    timer_channel_output_pulse_value_config(US_TX_TIMER, US_TX_CH, 120);
+    timer_channel_output_mode_config(US_TX_TIMER, US_TX_CH, TIMER_OC_MODE_PWM1);
+    timer_enable(US_TX_TIMER);
+
+    timer_enable(US_TX_DELAY_TIMER);
+
+    while (current_cycle < cycles)
+    {
+        while (!timer_interrupt_flag_get(US_TX_TIMER, TIMER_INT_FLAG_UP));
+        timer_interrupt_flag_clear(US_TX_TIMER, TIMER_INT_FLAG_UP);
+        current_cycle++;
+    }
+    // delay_nop();
+    timer_disable(US_TX_TIMER);
+}
+
+/*!
+    \brief      configure ultrasonic transmit debounce delay(timer15) 72MHz/72 = 1MHz 1us.
+    \param[in]  micro_second: delay time in micro second
+    \param[out] none
+    \retval     none
+*/
+void ultrasonic_transmit_debounce_delay(const uint16_t micro_second) {
+    rcu_periph_clock_enable(US_TX_DELAY_RCU);
+    timer_deinit(US_TX_DELAY_TIMER);
+
+    timer_parameter_struct timer_initpara;
+    timer_struct_para_init(&timer_initpara);
+    timer_initpara.prescaler = 71;
+    timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
+    timer_initpara.counterdirection = TIMER_COUNTER_UP;
+    timer_initpara.period = micro_second - 1;
+    timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
+    timer_initpara.repetitioncounter = 0;
+    timer_init(US_TX_DELAY_TIMER, &timer_initpara);
+
+    timer_auto_reload_shadow_enable(US_TX_DELAY_TIMER);
+    timer_interrupt_enable(US_TX_DELAY_TIMER, TIMER_INT_UP);
+    nvic_irq_enable(TIMER15_IRQn, 1U);
+}
+
+void ultrasonic_receive_exti_config(void) {
+    rcu_periph_clock_enable(US_RX_GPIO_RCU);
+    rcu_periph_clock_enable(US_RX_EXTI_RCU);
+
+    gpio_mode_set(US_RX_GPIO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, US_RX_GPIO_PIN);
+    nvic_irq_enable(US_RX_EXTI_IRQ, 0U);
+    syscfg_exti_line_config(EXTI_SOURCE_GPIOA, US_RX_EXTI_LINE);
+
+    exti_init(US_RX_GPIO_EXTI, EXTI_INTERRUPT, EXTI_TRIG_FALLING);
+    exti_flag_clear(US_RX_GPIO_EXTI);
+
+    // exti_interrupt_enable(EXTI_0);
+}
+
+void ultrasonic_echo_timer_config(void) {
+    rcu_periph_clock_enable(US_ECHO_RCU);
+    timer_deinit(US_ECHO_TIMER);
+
+    timer_parameter_struct timer_initpara;
+    timer_struct_para_init(&timer_initpara);
+    timer_initpara.prescaler = 71;
+    timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
+    timer_initpara.counterdirection = TIMER_COUNTER_UP;
+    timer_initpara.period = 59999;
+    timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
+    timer_initpara.repetitioncounter = 0;
+    timer_init(US_ECHO_TIMER, &timer_initpara);
+
+    timer_ic_parameter_struct timer_icinitpara;
+    timer_channel_input_struct_para_init(&timer_icinitpara);
+    timer_icinitpara.icpolarity = TIMER_IC_POLARITY_BOTH_EDGE;
+    timer_icinitpara.icselection = TIMER_IC_SELECTION_INDIRECTTI;
+    timer_icinitpara.icprescaler = TIMER_IC_PSC_DIV1;
+    timer_icinitpara.icfilter = 0x03;
+    timer_input_capture_config(US_ECHO_TIMER, US_ECHO_CH, &timer_icinitpara);
+}
+
+void ultrasonic_config(void) {
+    ultrasonic_gpio_config();
+    ultrasonic_transmit_debounce_delay(TIME_CORRECTION_US);
+    ultrasonic_receive_exti_config();
+    ultrasonic_echo_timer_config();
+}
+
+uint16_t ultrasonic_calc_distance(void) {
+    while (!ultrasonicMeasurementDone);
+    // uint32_t us_value = timer_channel_capture_value_register_read(US_ECHO_TIMER, US_ECHO_CH);
+    uint16_t distance = (TIME_CORRECTION_US + g_capture_value) * 17;
+    /*
+     *  (TIME_CORRECTION_US + us_value) * 340 m/s
+     *  -----------------------------------------
+     *                  1000 000
+     *  ----------------------------------------------
+     *                          2
+     */
+    return distance;
+}

src/usart.c

@@ -27,6 +27,9 @@ void usart_config(void)
     usart_receive_config(USART_PHY, USART_RECEIVE_ENABLE);
     usart_transmit_config(USART_PHY, USART_TRANSMIT_ENABLE);
 
+    nvic_irq_enable(USART_PHY_IRQ, 0);
+    usart_interrupt_enable(USART_PHY, USART_INT_RBNE);
+    // usart_interrupt_enable(USART_PHY, USART_INT_IDLE);
     usart_enable(USART_PHY);
 }
 
@@ -43,4 +46,27 @@ void rs485_config(void)
     gpio_output_options_set(RS485_EN_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, RS485_EN_PIN);
 
     gpio_bit_write(RS485_EN_PORT, RS485_EN_PIN, SET); //auto dircetion control
+}
+
+void store_char(unsigned char data, ring_buffer_t *rx_buf) {
+    uint16_t i = (unsigned int)(rx_buf->head + 1) % RX_BUFFER_SIZE;
+
+    if (i != rx_buf->tail) {
+        rx_buf->buffer[rx_buf->head] = data;
+        rx_buf->head = i;
+    }
+}
+
+uint16_t uart_available(void) {
+    return (unsigned int)(RX_BUFFER_SIZE + rx_buffer.head - rx_buffer.tail) % RX_BUFFER_SIZE;
+}
+
+int uart_read(void) {
+    if (rx_buffer.head == rx_buffer.tail) {
+        return -1;
+    } else {
+        unsigned char c = rx_buffer.buffer[rx_buffer.tail];
+        rx_buffer.tail = (unsigned int)(rx_buffer.tail + 1) % RX_BUFFER_SIZE;
+        return c;
+    }
 }