Merge pull request 'detached' (#1 ) from detached into US&IR

Reviewed-on: #1
shit
2024-09-27 18:24:56 +08:00 · 2024-09-27 18:22:57 +08:00 · 2024-09-27 15:41:22 +08:00 · 2024-09-27 00:15:24 +08:00 · 2024-09-27 00:12:13 +08:00 · 2024-09-26 17:32:57 +08:00
17 changed files with 1439 additions and 212 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,7 +19,8 @@ set(TARGET_C_SRC
        ${CMAKE_SOURCE_DIR}/src/gd32e23x_it.c
        ${CMAKE_SOURCE_DIR}/src/systick.c
        ${CMAKE_SOURCE_DIR}/src/ultrasonic_driver.c
-        ${CMAKE_SOURCE_DIR}/src/input_capture_exp.c
+        ${CMAKE_SOURCE_DIR}/src/mlx90614.c
+        ${CMAKE_SOURCE_DIR}/src/gd32e23x_hw_i2c.c
 )

 add_executable(xlsw_3dp_ultrasonic_300K ${TARGET_C_SRC})
--- a/README.md
+++ b/README.md
@@ -5,4 +5,14 @@
 - [x] 超声驱动信号（300KHz 50%duty 5cycles）发送
 - [x] PA2/PA3配置为USART0
 - [x] LED配置存活状态闪烁
- [ ] 超声反射回波接受与精准计时
+- [x] 超声反射回波接受与精准计时
+
+- 超声波反射回来后到sensor成功接收，GPIO上的反应主要分为两部分，
+    1. 超声波在发送时产生的余震，24V下大概为230us，12V下大概为210us。（前面所说的时间均为比较保守的时间）
+    2. 超声波会在接触到目标后反射回sensor上，并产生一个低电平，主要就是检测这部分。
+  
+- [x] 产生一个210-230us可调节的准确延时。（TIMER15配置为1us计一个数，设置重载为需要的时间，产生中断即可。）
+- [x] 在产生指定时间的中断服务函数中，开启EXTI0（PA0,sensor信号接收引脚），开启TIMER14（计时计数器，1us计一个数，计算接收到外部中断的时间）
+- [ ] 在外部中断服务函数中，产生一个事件或中断，进入到TIMER14的中断
+- [x] TIMER14不存在F4x系列，改用TIMER16.
+- [x] 放弃上述流程，多一层中断层，直接在EXTI0的中断服务函数中，直接读取TIMER16的CH_0计数值。
--- a/about_template.md
+++ b/about_template.md
@@ -15,7 +15,6 @@ set(TARGET_C_SRC
        ${CMAKE_SOURCE_DIR}/src/main.c
        ${CMAKE_SOURCE_DIR}/src/gd32e23x_it.c
        ${CMAKE_SOURCE_DIR}/src/systick.c
-        ${CMAKE_SOURCE_DIR}/src/peripheral.c
 )
 ```
 ## 关于链接脚本
--- a/inc/gd32e23x_hw_i2c.h
+++ b/inc/gd32e23x_hw_i2c.h
@@ -0,0 +1,116 @@
+#ifndef GD32E23X_HW_I2C_H
+#define GD32E23X_HW_I2C_H
+
+// #define I2C1_ENABLE
+
+#define I2C0_BUS_RCU          RCU_I2C0
+
+#define I2C0_GPIO_RCU         RCU_GPIOF
+#define I2C0_GPIO_PORT        GPIOF
+#define I2C0_GPIO_SDA_PIN     GPIO_PIN_0
+#define I2C0_GPIO_SCL_PIN     GPIO_PIN_1
+#define I2C0_GPIO_AF          GPIO_AF_1
+
+#define I2C0_SPEED            400000U
+#define I2C0_DCTY             I2C_DTCY_2
+#define I2C0_ADDR7            0xA0
+
+#ifdef I2C1_ENABLE
+#define I2C1_BUS_RCU          RCU_I2C1
+
+#define I2C1_GPIO_RCU         RCU_GPIOA
+#define I2C1_GPIO_PORT        GPIOA
+#define I2C1_GPIO_SDA_PIN     GPIO_PIN_1
+#define I2C1_GPIO_SCL_PIN     GPIO_PIN_0
+#define I2C1_GPIO_AF          GPIO_AF_4
+
+#define I2C1_SPEED            400000U
+#define I2C1_DCTY             I2C_DTCY_2
+#define I2C1_ADDR7            0xA1
+#endif
+
+
+
+
+
+
+
+
+
+#define I2C_TIME_OUT          (uint16_t)(5000)
+#define I2C_OK                1
+#define I2C_FAIL              0
+#define I2C_END               1
+
+typedef enum {
+    I2C_START = 0,
+    I2C_SEND_ADDR,
+    I2C_CLEAR_ADDRESS_FLAG,
+    I2C_TRANSMIT_DATA,
+    I2C_STOP
+} i2c_process_enum;
+
+typedef struct
+{
+    uint32_t i2c_gpio_rcu;
+    uint32_t i2c_gpio_port;
+    uint32_t i2c_gpio_sda_pin;
+    uint32_t i2c_gpio_scl_pin;
+    uint32_t i2c_gpio_af;
+    uint32_t i2c_speed;
+    uint32_t i2c_dcty;
+    uint32_t i2c_addr7;
+}i2c_parameter_struct;
+
+
+
+
+/**
+ * \brief Return codes for IIC APIs.
+ * @{
+ */
+#define IIC_SUCCESS              0
+#define IIC_INVALID_ARGUMENT     1
+#define IIC_ARBITRATION_LOST     2
+#define IIC_NO_CHIP_FOUND        3
+#define IIC_RECEIVE_OVERRUN      4
+#define IIC_RECEIVE_NACK         5
+#define IIC_SEND_OVERRUN         6
+#define IIC_SEND_NACK            7
+#define IIC_BUSY                 8
+#define IIC_ERROR_TIMEOUT        9
+/**
+ * @}
+ */
+
+void i2c_master_initialize1(void);
+void i2c_master_initialize3(void);
+void i2c_master_init(void);
+void i2c_master_deinit1(void);
+void i2c_master_deinit3(void);
+
+uint8_t i2c_master_read_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue);
+uint8_t i2c_master_read_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue);
+
+uint8_t i2c_master_read_register1_raw(unsigned char Address, unsigned short len, unsigned char *data);
+uint8_t i2c_master_read_register3_raw(unsigned char Address, unsigned short len, unsigned char *data);
+
+
+uint8_t i2c_master_write_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue);
+uint8_t i2c_master_write_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue);
+
+uint8_t i2c_master_write_register1_raw(unsigned char Address, unsigned short len, unsigned char *data);
+uint8_t i2c_master_write_register3_raw(unsigned char Address, unsigned short len, unsigned char *data);
+
+
+void i2c0_master_init(void);
+
+
+int read_ir_mlx90614(void);
+
+void i2c_struct_para_init(i2c_parameter_struct* initpara);
+void i2c_init(uint32_t i2c_periph, i2c_parameter_struct* initpara);
+void i2c0_config(void);
+
+
+#endif /* GD32E23X_HW_I2C_H */
--- a/inc/gd32e23x_it.h
+++ b/inc/gd32e23x_it.h
@@ -49,6 +49,8 @@ void PendSV_Handler(void);
 /* this function handles SysTick exception */
 void SysTick_Handler(void);

-void TIMER13_IRQHandler(void);
+void TIMER5_IRQHandler(void);
+void TIMER15_IRQHandler(void);
+void EXTI0_1_IRQHandler(void);

 #endif /* GD32E23X_IT_H */
--- a/inc/input_capture_exp.h
+++ b/inc/input_capture_exp.h
@@ -1,11 +0,0 @@
-//
-// Created by yelv1 on 24-9-23.
-//
-
-#ifndef INPUT_CAPTURE_EXP_H
-#define INPUT_CAPTURE_EXP_H
-
-void input_capture_config(void);
-void pwm_config(void);
-
-#endif //INPUT_CAPTURE_EXP_H
--- a/inc/mlx90614.h
+++ b/inc/mlx90614.h
@@ -0,0 +1,13 @@
+//
+// Created by dell on 24-9-26.
+//
+
+#ifndef MLX90614_H
+#define MLX90614_H
+
+#define I2C_EVENT_MASTER_MODE_SELECT          ((uint32_t)(I2C_FLAG_I2CBSY | I2C_FLAG_MASTER | I2C_FLAG_RBNE))
+
+void i2c_config(void);
+int read_ir_mlx90614(void);
+
+#endif //MLX90614_H
--- a/inc/systick.h
+++ b/inc/systick.h
@@ -24,6 +24,6 @@ void delay_ms(uint32_t count);
 /* delay a time in microseconds */
 void delay_us(uint32_t count);

-void delay_nop(void);
+void delay_5_nop(void);

 #endif /* SYS_TICK_H */
--- a/inc/ultrasonic_driver.h
+++ b/inc/ultrasonic_driver.h
@@ -7,14 +7,69 @@

 #include "gd32e23x.h"

-#define USART_RCU           RCU_USART0
-#define USART_GPIO_RCU      RCU_GPIOA
-#define USARET_GPIO_PORT    GPIOA
-#define USART_TX_PIN        GPIO_PIN_2
-#define USART_RX_PIN        GPIO_PIN_3
-#define USART0_PHY          USART0
-#define USART_BAUDRATE      115200U
+#define POWER_SUPPLY_12V
+// #define POWER_SUPPLY_24V

+#ifdef POWER_SUPPLY_12V
+#define TIME_CORRECTION_US  250
+#define CAPTURE_VALUE_MAX   515
+#elif defined(POWER_SUPPLY_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 ULTRASONIC_CYCLES   0x05U
+#define ULTRASONIC_TRAN_US  500  // (ms)
+
+#define LED_PORT            GPIOA
+#define LED_PIN             GPIO_PIN_9
+#define LED_RCU             RCU_GPIOA
+#define LED_TIMER_RCU       RCU_TIMER5
+#define LED_TIMER           TIMER5
+#define LED_IRQ             TIMER5_IRQn
+
+#define USART_RCU            RCU_USART0
+#define USART_GPIO_RCU       RCU_GPIOA
+#define USARET_GPIO_PORT     GPIOA
+#define USART_TX_PIN         GPIO_PIN_2
+#define USART_RX_PIN         GPIO_PIN_3
+#define USART0_PHY           USART0
+#define USART_BAUDRATE       115200U
+
+#define US_TRAN_GPIO_RCU     RCU_GPIOB
+#define US_TRAN_GPIO_PORT    GPIOB
+#define US_TRAN_PIN          GPIO_PIN_1
+#define US_TRAN_AF           GPIO_AF_0
+
+#define US_TRAN_RCU          RCU_TIMER13
+#define US_TRAN_TIMER        TIMER13
+#define US_TRAN_CH           TIMER_CH_0
+
+#define US_TRAN_DELAY_RCU     RCU_TIMER15
+#define US_TRAN_DELAY_TIMER   TIMER15
+
+#define US_FB_GPIO_RCU       RCU_GPIOA
+#define US_FB_EXTI_RCU       RCU_CFGCMP
+#define US_FB_GPIO_PORT      GPIOA
+#define US_FB_GPIO_PIN       GPIO_PIN_0
+#define US_FB_EXTI_IRQ       EXTI0_1_IRQn
+#define US_FB_GPIO_EXTI      EXTI_0
+
+#define US_ECHO_RCU          RCU_TIMER16
+#define US_ECHO_TIMER        TIMER16
+#define US_ECHO_CH           TIMER_CH_0
+
+void led_config(void);
 void usart_config(void);
+void ultrasonic_config(void);
+void ultrasonic_transmit_config(void);
+void ultrasonic_pwm_out_cycles(const uint8_t cycles);
+void ultrasonic_transmit_delay(const uint16_t micro_second);
+void receive_exti_config(void);
+void ultrasonic_echo_timer_config(void);
+void ultrasonic_receive_config(void);
+uint16_t calculate_distance(uint32_t us_value);

-#endif //ULTRASONIC_DRIVER_H
+#endif //ULTRASONIC_DRIVER_H
--- a/src/gd32e23x_hw_i2c.c
+++ b/src/gd32e23x_hw_i2c.c
@@ -0,0 +1,864 @@
+#include <stdio.h>
+#include <stdint.h>
+#include "gd32e23x.h"
+#include "systick.h"
+#include "gd32e23x_hw_i2c.h"
+#include "gd32e23x.h"
+
+void i2c_struct_para_init(i2c_parameter_struct* initpara)
+{
+    initpara->i2c_gpio_rcu     = RCU_GPIOF;
+    initpara->i2c_gpio_port    = GPIOF;
+    initpara->i2c_gpio_scl_pin = GPIO_PIN_1;
+    initpara->i2c_gpio_sda_pin = GPIO_PIN_0;
+    initpara->i2c_speed        = 400000U;
+    initpara->i2c_dcty         = I2C_DTCY_2;
+    initpara->i2c_addr7        = 0xA0;
+}
+
+
+
+void i2c_init(uint32_t i2c_periph, i2c_parameter_struct* initpara)
+{
+    switch (i2c_periph){
+    case I2C0:
+        rcu_periph_clock_enable(RCU_I2C0);
+        rcu_periph_clock_enable(initpara->i2c_gpio_rcu);
+
+        gpio_af_set(I2C0_GPIO_PORT, I2C0_GPIO_AF, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+        gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+
+        i2c_clock_config(I2C0, I2C0_SPEED, I2C0_DCTY);
+        i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_ADDR7);
+        i2c_enable(I2C0);
+        i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+        break;
+    case I2C1:
+
+        break;
+    default:
+        break;
+    }
+}
+
+/*!
+    \brief      Enable IIC0 & NVIC
+    \param[in]  none
+    \param[out] none
+    \retval     none
+*/
+void i2c_init(uint32_t i2c_periph)
+{
+    switch (i2c_periph) {
+    case I2C0:
+        rcu_periph_clock_enable(RCU_I2C0);
+        rcu_periph_clock_enable(I2C0_GPIO_RCU);
+
+        gpio_af_set(I2C0_GPIO_PORT, I2C0_GPIO_AF, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+        gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+
+        i2c_clock_config(I2C0, I2C0_SPEED, I2C0_DCTY);
+        i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_ADDR7);
+        i2c_enable(I2C0);
+        i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+        break;
+#ifdef I2C1_ENABLE
+    case I2C1:
+        rcu_periph_clock_enable(RCU_I2C1);
+        rcu_periph_clock_enable(I2C1_GPIO_RCU);
+
+        gpio_af_set(I2C1_GPIO_PORT, I2C1_GPIO_AF, I2C1_GPIO_SDA_PIN | I2C1_GPIO_SCL_PIN);
+        gpio_output_options_set(I2C1_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C1_GPIO_SDA_PIN | I2C1_GPIO_SCL_PIN);
+
+        i2c_clock_config(I2C1, I2C1_SPEED, I2C1_DCTY);
+        i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_ADDR7);
+        i2c_enable(I2C1);
+        i2c_ack_config(I2C1, I2C_ACK_ENABLE);
+        break;
+#endif
+    default:
+        break;
+    }
+}
+
+void i2c_bus_reset(void)
+{
+    i2c_deinit(I2C0);
+    /* configure SDA/SCL for GPIO */
+    GPIO_BC(I2C0_GPIO_PORT) |= I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN;
+    gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+    delay_5_nop();
+    /* stop signal */
+    GPIO_BOP(I2C0_GPIO_PORT) |= I2C0_GPIO_SCL_PIN;
+    delay_5_nop();
+    GPIO_BOP(I2C0_GPIO_PORT) |= I2C0_GPIO_SDA_PIN;
+    /* connect I2C_SCL_PIN to I2C_SCL */
+    /* connect I2C_SDA_PIN to I2C_SDA */
+    gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN);
+    /* configure the I2CX interface */
+    i2c_init(I2C0);
+}
+
+/*!
+    \brief      TWI1(IIC0) read data from the IIC Slave Device
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  RegisterAddr: the IIC Slave Device's internal address to start reading from
+    \param[in]  RegisterLen: number of bytes to reads from the IIC Slave Device
+    \param[in]  RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device
+    \param[out] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device
+    \retval     IIC_SUCCESS
+*/
+uint8_t i2c_master_receive(uint32_t i2c_periph, uint8_t Dev_Address, uint8_t)
+uint8_t i2c_master_read_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){
+    uint8_t state = I2C_START;
+    uint8_t read_cycle = 0;
+    uint16_t timeout = 0;
+    uint8_t i2c_timeout_flag = 0;
+    uint8_t IIC_SLAVE_ADDR = (Address << 1);
+
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+    while (!(i2c_timeout_flag))
+    {
+        switch (state)
+        {
+        case I2C_START:
+            if(RESET == read_cycle)
+            {
+                /* i2c master sends start signal only when the bus is idle */
+                while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < i2c_timeout_flag))
+                {
+                    timeout ++;
+                }
+                if(timeout < I2C_TIME_OUT)
+                {
+                    /* whether to send ACK or not for the next byte */
+                    if(2 == RegisterLen) {
+                        i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
+                    }
+                } else {
+                    i2c_bus_reset();
+                    timeout = 0;
+                    state = I2C_START;
+                    printf("i2c bus is busy in READ!\n");
+                }
+            }
+            /* send the start signal */
+            i2c_start_on_bus(I2C0);
+            timeout = 0;
+            state = I2C_SEND_ADDR;
+            break;
+
+        case I2C_SEND_ADDR:
+            /* i2c master sends START signal successfully */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT))
+            {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT)
+            {
+                if(RESET == read_cycle)
+                {
+                    i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_TRANSMITTER);
+                    state = I2C_CLEAR_ADDRESS_FLAG;
+                } else {
+                    i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_RECEIVER);
+                    if(RegisterLen < 3) {
+                        /* disable acknowledge */
+                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                    }
+                    state = I2C_CLEAR_ADDRESS_FLAG;
+                }
+                timeout = 0;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                read_cycle = 0;
+                printf("i2c master sends start signal timeout in READ!\n");
+            }
+            break;
+
+        case I2C_CLEAR_ADDRESS_FLAG:
+            /* address flag set means i2c slave sends ACK */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT))
+            {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT)
+            {
+                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                if((SET == read_cycle) && (1 == RegisterLen)) {
+                    /* send a stop condition to I2C bus */
+                    i2c_stop_on_bus(I2C0);
+                }
+                timeout = 0;
+                state = I2C_TRANSMIT_DATA;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                read_cycle = 0;
+                printf("i2c master clears address flag timeout in READ!\n");
+            }
+            break;
+
+        case I2C_TRANSMIT_DATA:
+            if(RESET == read_cycle) {
+                /* wait until the transmit data buffer is empty */
+                while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if(timeout < I2C_TIME_OUT) {
+                    /* send the EEPROM's internal address to write to : only one byte address */
+                    i2c_data_transmit(I2C0, RegisterAddr);
+                    timeout = 0;
+                } else {
+                    timeout = 0;
+                    state = I2C_START;
+                    read_cycle = 0;
+                    printf("i2c master wait data buffer is empty timeout in READ!\n");
+                }
+                /* wait until BTC bit is set */
+                while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if(timeout < I2C_TIME_OUT) {
+                    timeout = 0;
+                    state = I2C_START;
+                    read_cycle++;
+                } else {
+                    timeout = 0;
+                    state = I2C_START;
+                    read_cycle = 0;
+                    printf("i2c master sends i2c_master_read_register1 internal address timeout in READ!\n");
+                }
+            } else {
+                while(RegisterLen) {
+                    timeout++;
+                    if(3 == RegisterLen) {
+                        /* wait until BTC bit is set */
+                        while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
+                        /* disable acknowledge */
+                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                    }
+                    if(2 == RegisterLen) {
+                        /* wait until BTC bit is set */
+                        while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
+                        /* send a stop condition to I2C bus */
+                        i2c_stop_on_bus(I2C0);
+                    }
+                    /* wait until RBNE bit is set */
+                    if(i2c_flag_get(I2C0, I2C_FLAG_RBNE)) {
+                        /* read a byte from the EEPROM */
+                        *RegisterValue = i2c_data_receive(I2C0);
+                        /* point to the next location where the byte read will be saved */
+                        RegisterValue++;
+                        /* decrement the read bytes counter */
+                        RegisterLen--;
+                        timeout = 0;
+                    }
+                    if(timeout > I2C_TIME_OUT) {
+                        timeout = 0;
+                        state = I2C_START;
+                        read_cycle = 0;
+                        printf("i2c master sends data timeout in READ!\n");
+                    }
+                }
+                timeout = 0;
+                state = I2C_STOP;
+            }
+            break;
+
+        case I2C_STOP:
+            /* i2c master sends STOP signal successfully */
+            while((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                timeout = 0;
+                state = I2C_END;
+                i2c_timeout_flag = I2C_OK;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                read_cycle = 0;
+                printf("i2c master sends stop signal timeout in READ!\n");
+            }
+            break;
+
+        default:
+            state = I2C_START;
+            read_cycle = 0;
+            i2c_timeout_flag = I2C_OK;
+            timeout = 0;
+            printf("i2c master sends start signal in READ.\n");
+            break;
+        }
+    }
+    return IIC_SUCCESS;
+}
+
+/*!
+    \brief      TWI3(none) read data from the IIC Slave Device
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  RegisterAddr: the IIC Slave Device's internal address to start reading from
+    \param[in]  RegisterLen: number of bytes to reads from the IIC Slave Device
+    \param[in]  RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device
+    \param[out] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device
+    \retval     IIC_SUCCESS
+    \note       No TWI3(IIC3) - No operation - Error log.
+*/
+uint8_t i2c_master_read_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){
+    __NOP();
+    #ifdef DEBUG_VERBOES
+	printf("\n[DebugVerboes]i2c_master_read_register3 @ i2c.c, no TWI3 \n");
+    #endif
+    return IIC_SUCCESS;
+}
+
+/*!
+    \brief      TWI1(IIC0) read data from the IIC Slave Device
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  len: number of bytes to reads from the IIC Slave Device
+    \param[in]  data: pointer to the buffer that receives the data read from the IIC Slave Device
+    \param[out] data: pointer to the buffer that receives the data read from the IIC Slave Device
+    \retval     IIC_SUCCESS
+*/
+uint8_t i2c_master_read_register1_raw(unsigned char Address, unsigned short len, unsigned char *data){
+    uint8_t state = I2C_START;
+    // uint8_t read_cycle = 0;
+    uint16_t timeout = 0;
+    uint8_t i2c_timeout_flag = 0;
+    unsigned char IIC_SLAVE_ADDR = (Address << 1);
+
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+    while (!(i2c_timeout_flag))
+    {
+        switch (state)
+        {
+        case I2C_START:
+            /* i2c master sends start signal only when the bus is idle */
+            while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < i2c_timeout_flag))
+            {
+                timeout ++;
+            }
+            if(timeout < I2C_TIME_OUT)
+            {
+                /* whether to send ACK or not for the next byte */
+                if(2 == len) {
+                    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
+                }
+            } else {
+                i2c_bus_reset();
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c bus is busy in READ!\n");
+            }
+            /* send the start signal */
+            i2c_start_on_bus(I2C0);
+            timeout = 0;
+            state = I2C_SEND_ADDR;
+            break;
+
+        case I2C_SEND_ADDR:
+            /* i2c master sends START signal successfully */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT))
+            {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT)
+            {
+                i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_RECEIVER);
+                if(len < 3) {
+                    /* disable acknowledge */
+                    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                }
+                state = I2C_CLEAR_ADDRESS_FLAG;
+                timeout = 0;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                // read_cycle = 0;
+                printf("i2c master sends start signal timeout in READ!\n");
+            }
+            break;
+
+        case I2C_CLEAR_ADDRESS_FLAG:
+            /* address flag set means i2c slave sends ACK */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT))
+            {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT)
+            {
+                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                timeout = 0;
+                state = I2C_TRANSMIT_DATA;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                // read_cycle = 0;
+                printf("i2c master clears address flag timeout in READ!\n");
+            }
+            break;
+
+        case I2C_TRANSMIT_DATA:
+                while(len) {
+                    timeout++;
+                    if(3 == len) {
+                        /* wait until BTC bit is set */
+                        while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
+                        /* disable acknowledge */
+                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                    }
+                    if(2 == len) {
+                        /* wait until BTC bit is set */
+                        while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
+                        /* send a stop condition to I2C bus */
+                        i2c_stop_on_bus(I2C0);
+                    }
+                    /* wait until RBNE bit is set */
+                    if(i2c_flag_get(I2C0, I2C_FLAG_RBNE)) {
+                        /* read a byte from the EEPROM */
+                        *data = i2c_data_receive(I2C0);
+                        /* point to the next location where the byte read will be saved */
+                        data++;
+                        /* decrement the read bytes counter */
+                        len--;
+                        timeout = 0;
+                    }
+                    if(timeout > I2C_TIME_OUT) {
+                        timeout = 0;
+                        state = I2C_START;
+                        // read_cycle = 0;
+                        printf("i2c master sends data timeout in READ!\n");
+                    }
+                }
+                timeout = 0;
+                state = I2C_STOP;
+            // }
+            break;
+
+        case I2C_STOP:
+            /* i2c master sends STOP signal successfully */
+            while((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                timeout = 0;
+                state = I2C_END;
+                i2c_timeout_flag = I2C_OK;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                // read_cycle = 0;
+                printf("i2c master sends stop signal timeout in READ!\n");
+            }
+            break;
+
+        default:
+            state = I2C_START;
+            // read_cycle = 0;
+            i2c_timeout_flag = I2C_OK;
+            timeout = 0;
+            printf("i2c master sends start signal in READ.\n");
+            break;
+        }
+    }
+    return IIC_SUCCESS;
+}
+
+/*!
+    \brief      TWI3(none) read data from the IIC Slave Device with no regisiter address
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  len: number of bytes to reads from the IIC Slave Device
+    \param[in]  data: pointer to the buffer that receives the data read from the IIC Slave Device
+    \param[out] data: pointer to the buffer that receives the data read from the IIC Slave Device
+    \retval     IIC_SUCCESS
+    \note       No TWI3(IIC3) - No operation - Error log.
+*/
+uint8_t i2c_master_read_register3_raw(unsigned char Address, unsigned short len, unsigned char *data){
+    __NOP();
+    #ifdef DEBUG_VERBOES
+	printf("\n[DebugVerboes]i2c_master_read_register3_raw @ i2c.c, no TWI3 \n");
+    #endif
+    return IIC_SUCCESS;
+}
+
+/*!
+    \brief      TWI1(IIC0) write data to the IIC Slave Device
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  RegisterAddr: the IIC Slave Device's internal address to start writing to
+    \param[in]  RegisterLen: number of bytes to write to the IIC Slave Device
+    \param[in]  RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device
+    \param[out] RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device
+    \retval     IIC_SUCCESS
+*/
+
+uint8_t i2c_master_write_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue)
+{
+    uint8_t state = I2C_START;
+    uint16_t timeout = 0;
+    uint8_t i2c_timeout_flag = 0;
+    unsigned char IIC_SLAVE_ADDR = (Address << 1);
+
+    /* enable acknowledge */
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+    while(!(i2c_timeout_flag)) {
+        switch(state) {
+        case I2C_START:
+            /* i2c master sends start signal only when the bus is idle */
+            while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_start_on_bus(I2C0);
+                timeout = 0;
+                state = I2C_SEND_ADDR;
+            } else {
+                i2c_bus_reset();
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c bus is busy in WRITE!\n");
+            }
+            break;
+
+        case I2C_SEND_ADDR:
+            /* i2c master sends START signal successfully */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_TRANSMITTER);
+                timeout = 0;
+                state = I2C_CLEAR_ADDRESS_FLAG;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends start signal timeout in WRITE!\n");
+            }
+            break;
+
+        case I2C_CLEAR_ADDRESS_FLAG:
+            /* address flag set means i2c slave sends ACK */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                timeout = 0;
+                state = I2C_TRANSMIT_DATA;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master clears address flag timeout in WRITE!\n");
+            }
+            break;
+
+        case I2C_TRANSMIT_DATA:
+            /* wait until the transmit data buffer is empty */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                /* send the EEPROM's internal address to write to : only one byte address */
+                i2c_data_transmit(I2C0, RegisterAddr);
+                timeout = 0;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends i2c_master_write_register1 internal address timeout in WRITE!\n");
+            }
+            /* wait until BTC bit is set */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                timeout = 0;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends data timeout in WRITE!\n");
+            }
+            while(RegisterLen--) {
+                i2c_data_transmit(I2C0, *RegisterValue);
+                /* point to the next byte to be written */
+                RegisterValue++;
+                /* wait until BTC bit is set */
+                while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if(timeout < I2C_TIME_OUT) {
+                    timeout = 0;
+                } else {
+                    timeout = 0;
+                    state = I2C_START;
+                    printf("i2c master sends data timeout in WRITE!\n");
+                }
+            }
+            timeout = 0;
+            state = I2C_STOP;
+            break;
+
+        case I2C_STOP:
+            /* send a stop condition to I2C bus */
+            i2c_stop_on_bus(I2C0);
+            /* i2c master sends STOP signal successfully */
+            while((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                timeout = 0;
+                state = I2C_END;
+                i2c_timeout_flag = I2C_OK;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends stop signal timeout in WRITE!\n");
+            }
+            break;
+
+        default:
+            state = I2C_START;
+            i2c_timeout_flag = I2C_OK;
+            timeout = 0;
+            printf("i2c master sends start signal in WRITE.\n");
+            break;
+        }
+    }
+    return IIC_SUCCESS;
+}
+
+
+/*!
+    \brief      TWI1(IIC0) write data to the IIC Slave Device with no regisiter address
+    \param[in]  Address: the IIC Slave Device's IIC Device Address
+    \param[in]  len: number of bytes to write to the IIC Slave Device
+    \param[in]  data: pointer to the buffer that transfer the data write to the IIC Slave Device
+    \param[out] data: pointer to the buffer that transfer the data write to the IIC Slave Device
+    \retval     IIC_SUCCESS
+*/
+uint8_t i2c_master_write_register1_raw(unsigned char Address, unsigned short len, unsigned char *data){
+    uint8_t state = I2C_START;
+    uint16_t timeout = 0;
+    uint8_t i2c_timeout_flag = 0;
+    unsigned char IIC_SLAVE_ADDR = (Address << 1);
+
+    /* enable acknowledge */
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+    while(!(i2c_timeout_flag)) {
+        switch(state) {
+        case I2C_START:
+            /* i2c master sends start signal only when the bus is idle */
+            while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_start_on_bus(I2C0);
+                timeout = 0;
+                state = I2C_SEND_ADDR;
+            } else {
+                i2c_bus_reset();
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c bus is busy in WRITE!\n");
+            }
+            break;
+
+        case I2C_SEND_ADDR:
+            /* i2c master sends START signal successfully */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_TRANSMITTER);
+                timeout = 0;
+                state = I2C_CLEAR_ADDRESS_FLAG;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends start signal timeout in WRITE!\n");
+            }
+            break;
+
+        case I2C_CLEAR_ADDRESS_FLAG:
+            /* address flag set means i2c slave sends ACK */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                timeout = 0;
+                state = I2C_TRANSMIT_DATA;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master clears address flag timeout in WRITE!\n");
+            }
+            break;
+
+        case I2C_TRANSMIT_DATA:
+            /* wait until the transmit data buffer is empty */
+            while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            while(len--) {
+                i2c_data_transmit(I2C0, *data);
+                /* point to the next byte to be written */
+                data++;
+                /* wait until BTC bit is set */
+                while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if(timeout < I2C_TIME_OUT) {
+                    timeout = 0;
+                } else {
+                    timeout = 0;
+                    state = I2C_START;
+                    printf("i2c master sends data timeout in WRITE!\n");
+                }
+            }
+            timeout = 0;
+            state = I2C_STOP;
+            break;
+
+        case I2C_STOP:
+            /* send a stop condition to I2C bus */
+            i2c_stop_on_bus(I2C0);
+            /* i2c master sends STOP signal successfully */
+            while((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                timeout++;
+            }
+            if(timeout < I2C_TIME_OUT) {
+                timeout = 0;
+                state = I2C_END;
+                i2c_timeout_flag = I2C_OK;
+            } else {
+                timeout = 0;
+                state = I2C_START;
+                printf("i2c master sends stop signal timeout in WRITE!\n");
+            }
+            break;
+
+        default:
+            state = I2C_START;
+            i2c_timeout_flag = I2C_OK;
+            timeout = 0;
+            printf("i2c master sends start signal in WRITE.\n");
+            break;
+        }
+    }
+    return IIC_SUCCESS;
+}
+
+
+int read_ir_mlx90614(void)
+{
+	uint8_t	Data[5];
+	int inttemp_ir=0;
+	uint32_t TIMEOUT=0;
+	while(TIMEOUT<10000&&i2c_flag_get(I2C0,I2C_FLAG_I2CBSY))
+			TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR0\r\n");
+			return -410;
+		}
+	TIMEOUT=0;
+	I2C_GenerateSTART(I2C0,ENABLE);
+	while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_MODE_SELECT))
+		TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR1\r\n");
+			return -410;
+		}
+//	I2C_AcknowledgeConfig(I2C0,DISABLE);
+	TIMEOUT=0;
+	I2C_Send7bitAddress(I2C0,0XB4,I2C_Direction_Transmitter);
+	while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
+		TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			printf("ERROR2\r\n");
+			return -410;
+
+		}
+	I2C_SendData(I2C0,0x07);
+
+	TIMEOUT=0;
+	I2C_GenerateSTART(I2C0,ENABLE);
+	while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_MODE_SELECT))
+		TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR3\r\n");
+			return -410;
+		}
+		TIMEOUT=0;
+	I2C_Send7bitAddress(I2C0,0XB4,I2C_Direction_Receiver);
+	while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED ))
+		TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR4\r\n");
+			return -410;
+		}
+		//I2C_AcknowledgeConfig(I2C0,DISABLE);
+		TIMEOUT=0;
+	  Data[0]=I2C_ReceiveData(I2C0);
+		while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED))
+	   TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR5\r\n");
+			return -410;
+		}
+
+		TIMEOUT=0;
+		Data[1]=I2C_ReceiveData(I2C0);
+		while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED))
+	   TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR6\r\n");
+			return -410;
+		}
+
+		TIMEOUT=0;
+		Data[2]=I2C_ReceiveData(I2C0);
+		while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED))
+	   TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR7\r\n");
+			return -410;
+		}
+
+
+
+
+
+	I2C_AcknowledgeConfig(I2C0,DISABLE);
+		Data[3]=I2C_ReceiveData(I2C0);
+				while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED))
+	   TIMEOUT++;
+		if(TIMEOUT>=10000)
+		{
+			//printf("ERROR11\r\n");
+			return -410;
+		}
+
+
+	I2C_GenerateSTOP(I2C0,ENABLE);
+	I2C_AcknowledgeConfig(I2C0,ENABLE);
+		//printf("data:%x,%x,%x\r\n",Data[0],Data[1],Data[2]);
+	inttemp_ir=(int)((Data[0]+Data[1]*255)*0.2-2731.5);
+//		printf("temp:%d\r\n",inttemp_ir);
+
+
+	if(inttemp_ir<-400)
+		inttemp_ir=-400;
+	if(inttemp_ir>850)
+		inttemp_ir=850;
+//
+	return inttemp_ir;
+}
--- a/src/gd32e23x_it.c
+++ b/src/gd32e23x_it.c
@@ -33,8 +33,12 @@ OF SUCH DAMAGE.
 */

 #include "gd32e23x_it.h"
+#include <stdio.h>
 #include "main.h"
 #include "systick.h"
+#include "ultrasonic_driver.h"
+
+__IO uint32_t capture_value;

 /*!
    \brief      this function handles NMI exception
@@ -98,6 +102,40 @@ void SysTick_Handler(void)
 {
 }

-void TIMER2_IRQHandler(void) {
+void TIMER5_IRQHandler(void) {
+    if (timer_interrupt_flag_get(LED_TIMER, TIMER_INT_FLAG_UP) == SET)
+    {
+        timer_interrupt_flag_clear(LED_TIMER, TIMER_INT_FLAG_UP);
+        static uint8_t led_status = 0;
+        if (led_status)
+        {
+        gpio_bit_write(LED_PORT, LED_PIN, RESET);
+        timer_autoreload_value_config(LED_TIMER, 19200);
+        } else {
+        gpio_bit_write(LED_PORT, LED_PIN, SET);
+        timer_autoreload_value_config(LED_TIMER, 800);
+        }
+        led_status = !led_status;
+    }
+}

+void TIMER15_IRQHandler(void) {
+    if (timer_interrupt_flag_get(TIMER15, TIMER_INT_FLAG_UP) == SET)
+    {
+        timer_interrupt_flag_clear(TIMER15, TIMER_INT_FLAG_UP);
+        exti_interrupt_enable(EXTI_0); // turn on hardware external input interrupt
+        timer_counter_value_config(TIMER16, 0);
+        timer_enable(TIMER16);   // turn on timer to calculate the first ultrasonic echo time
+        timer_disable(TIMER15);
+    }
+}
+
+void EXTI0_1_IRQHandler(void) {
+    if (exti_interrupt_flag_get(EXTI_0) == SET)
+    {
+        exti_interrupt_flag_clear(EXTI_0);
+        capture_value = timer_channel_capture_value_register_read(TIMER16, TIMER_CH_0);
+        timer_disable(TIMER16);
+        exti_interrupt_disable(EXTI_0);
+    }
 }
--- a/src/input_capture_exp.c
+++ b/src/input_capture_exp.c
@@ -1,105 +0,0 @@
-//
-// Created by yelv1 on 24-9-23.
-//
-
-#include "input_capture_exp.h"
-#include "gd32e23x.h"
-
-/*
- * TIMER0-CH2(PA9) output 1K 50%duty
- * TIMER2 CH0(PA6) input capture
- */
-
-void input_capture_config(void)
-{
-    rcu_periph_clock_enable(RCU_GPIOA);
-
-    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_6);
-    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,GPIO_PIN_6);
-    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_6);
-
-    timer_ic_parameter_struct timer_icinitpara;
-    timer_parameter_struct timer_initpara;
-
-    /* enable the TIMER clock */
-    rcu_periph_clock_enable(RCU_TIMER2);
-    /* disable a TIMER */
-    timer_deinit(TIMER2);
-    /* initialize TIMER init parameter struct */
-    timer_struct_para_init(&timer_initpara);
-    /* TIMER2 configuration */
-    timer_initpara.prescaler         = 71;
-    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
-    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
-    timer_initpara.period            = 65535;
-    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
-    timer_init(TIMER2, &timer_initpara);
-
-    /* TIMER2  configuration */
-    /* initialize TIMER channel input parameter struct */
-    timer_channel_input_struct_para_init(&timer_icinitpara);
-    /* TIMER2 CH0 input capture configuration */
-    timer_icinitpara.icpolarity  = TIMER_IC_POLARITY_RISING;
-    timer_icinitpara.icselection = TIMER_IC_SELECTION_DIRECTTI;
-    timer_icinitpara.icprescaler = TIMER_IC_PSC_DIV1;
-    timer_icinitpara.icfilter    = 0x0;
-    timer_input_capture_config(TIMER2,TIMER_CH_0,&timer_icinitpara);
-
-    /* auto-reload preload enable */
-    timer_auto_reload_shadow_enable(TIMER2);
-    /* clear channel 0 interrupt bit */
-    timer_interrupt_flag_clear(TIMER2,TIMER_INT_FLAG_CH0);
-    /* channel 0 interrupt enable */
-    timer_interrupt_enable(TIMER2,TIMER_INT_CH0);
-
-    /* TIMER2 counter enable */
-    timer_enable(TIMER2);
-
-    nvic_irq_enable(TIMER2_IRQn, 0);
-}
-
-/*
- * GPIOB-1 PWM output
- * TIMER13_CH0(AF0)
- */
-void pwm_config(void)
-{
-    timer_oc_parameter_struct timer_ocinitpara;
-    timer_parameter_struct    timer_initpara;
-
-    rcu_periph_clock_enable(RCU_GPIOA);
-
-    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_9);
-    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
-    gpio_af_set(GPIOA, GPIO_AF_2, GPIO_PIN_9);
-
-    rcu_periph_clock_enable(RCU_TIMER0);
-    timer_deinit(TIMER0);
-
-    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            = 999;
-    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
-    timer_init(TIMER0, &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(TIMER0, TIMER_CH_1, &timer_ocinitpara);
-
-    timer_channel_output_pulse_value_config(TIMER0, TIMER_CH_1, 500);
-    timer_channel_output_mode_config(TIMER0, TIMER_CH_1, TIMER_OC_MODE_PWM1);
-    timer_channel_output_shadow_config(TIMER0, TIMER_CH_1, TIMER_OC_SHADOW_DISABLE);
-
-    timer_primary_output_config(TIMER0, ENABLE);
-
-    timer_auto_reload_shadow_enable(TIMER0);
-
-    timer_enable(TIMER0);
-}
--- a/src/main.c
+++ b/src/main.c
@@ -4,16 +4,17 @@

    \version 2024-02-22, V2.1.0, firmware for GD32E23x
 */
-#include "main.h"
+// #include "main.h"
 #include <stdio.h>
 #include "gd32e23x.h"
 #include "systick.h"
 #include "gd32e23x_libopt.h"

 #include "ultrasonic_driver.h"
-#include "input_capture_exp.h"
+#include "mlx90614.h"

-#define ULTRASONIC_CYCLES 0x05U
+extern uint32_t capture_value;
+uint16_t distance_uint16;

 /*!
    \brief      main function
@@ -26,40 +27,44 @@ int main(void)
    /* configure systick */
    systick_config();
    /* configure ultrasonic board hardware */
-    // ultrasonic_config();
-    usart_config();
-    input_capture_config();
-
-    pwm_config();
+    ultrasonic_transmit_config();
+    ultrasonic_receive_config();

    /* ---------- debug start ---------- */

-
-
+    i2c_config();


    /* ---------- debug end ---------- */

    printf("\r\n");
-    printf("START!\r\n");
-    printf("Input Capture Test!\r\n");
+    printf("XLSW-3DP-UltraSonic Analog 300K!\r\n");
    printf("\r\n");

-    while(1)
-    {
-        printf("Input Capture Test!\r\n");
-        delay_ms(500);
+    delay_ms(2000);

+    while (1)
+    {
+        delay_ms(ULTRASONIC_TRAN_US);
+
+        ultrasonic_pwm_out_cycles(ULTRASONIC_CYCLES);
+
+        delay_ms(2);
+        printf("cap_val:%ld\t", capture_value);
+
+        const char* result = (capture_value <= CAPTURE_VALUE_MAX) ? "Distance: %d\n" : "Over Range\n";
+        distance_uint16 = calculate_distance(capture_value);
+        printf(result, distance_uint16);
    }
 }

 /* retarget the C library printf function to the USART */
-int _write (int fd, char *pBuffer, int size)
+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));
+        while (RESET == usart_flag_get(USART0, USART_FLAG_TBE));
    }
    return size;
 }
--- a/src/mlx90614.c
+++ b/src/mlx90614.c
@@ -0,0 +1,127 @@
+//
+// Created by dell on 24-9-26.
+//
+
+#include "mlx90614.h"
+#include "gd32e23x.h"
+#include "systick.h"
+#include <stdio.h>
+
+void i2c_config(void) {
+    rcu_periph_clock_enable(RCU_I2C0);
+    rcu_periph_clock_enable(GPIOF);
+
+    gpio_af_set(GPIOF, GPIO_AF_1, GPIO_PIN_0 | GPIO_PIN_1);
+    gpio_output_options_set(GPIOF, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_0 | GPIO_PIN_1);
+
+    i2c_clock_config(I2C0, 400000U, I2C_DTCY_2);
+    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0xA0);
+    i2c_enable(I2C0);
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+
+    nvic_irq_enable(I2C0_EV_IRQn, 2);
+    nvic_irq_enable(I2C0_ER_IRQn, 2);
+}
+
+int read_ir_mlx90614(void) {
+    uint8_t Data[5];
+    int inttemp_ir = 0;
+    uint32_t TIMEOUT = 0;
+    while (TIMEOUT < 10000 && i2c_flag_get(I2C0, I2C_FLAG_I2CBSY))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR0\r\n");
+        return -410;
+    }
+    TIMEOUT = 0;
+    // I2C_GenerateSTART(I2C0, ENABLE);
+    i2c_start_on_bus(I2C0);
+    // while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_MODE_SELECT))
+    while (TIMEOUT < 10000 && !i2c_flag_get(I2C0, I2C_EVENT_MASTER_MODE_SELECT))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR1\r\n");
+        return -410;
+    }
+    //	I2C_AcknowledgeConfig(I2C0,DISABLE);
+    TIMEOUT = 0;
+    // I2C_Send7bitAddress(I2C0, 0XB4, I2C_Direction_Transmitter);
+    i2c_master_addressing(I2C0, 0XB4, I2C_TRANSMITTER);
+    // while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
+    while (TIMEOUT < 10000 && !i2c_flag_get(I2C0, I2C_FLAG_TR))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        printf("ERROR2\r\n");
+        return -410;
+    }
+    I2C_SendData(I2C0, 0x07);
+
+    TIMEOUT = 0;
+    I2C_GenerateSTART(I2C0, ENABLE);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_MODE_SELECT))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR3\r\n");
+        return -410;
+    }
+    TIMEOUT = 0;
+    I2C_Send7bitAddress(I2C0, 0XB4, I2C_Direction_Receiver);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_BYTE_RECEIVED))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR4\r\n");
+        return -410;
+    }
+    //I2C_AcknowledgeConfig(I2C0,DISABLE);
+    TIMEOUT = 0;
+    Data[0] = I2C_ReceiveData(I2C0);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_BYTE_RECEIVED))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR5\r\n");
+        return -410;
+    }
+
+    TIMEOUT = 0;
+    Data[1] = I2C_ReceiveData(I2C0);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_BYTE_RECEIVED))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR6\r\n");
+        return -410;
+    }
+
+    TIMEOUT = 0;
+    Data[2] = I2C_ReceiveData(I2C0);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_BYTE_RECEIVED))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR7\r\n");
+        return -410;
+    }
+
+
+    I2C_AcknowledgeConfig(I2C0, DISABLE);
+    Data[3] = I2C_ReceiveData(I2C0);
+    while (TIMEOUT < 10000 && !I2C_CheckEvent(I2C0, I2C_EVENT_MASTER_BYTE_RECEIVED))
+        TIMEOUT++;
+    if (TIMEOUT >= 10000) {
+        //printf("ERROR11\r\n");
+        return -410;
+    }
+
+
+    I2C_GenerateSTOP(I2C0, ENABLE);
+    I2C_AcknowledgeConfig(I2C0, ENABLE);
+    //printf("data:%x,%x,%x\r\n",Data[0],Data[1],Data[2]);
+    inttemp_ir = (int) ((Data[0] + Data[1] * 255) * 0.2 - 2731.5);
+    //		printf("temp:%d\r\n",inttemp_ir);
+
+
+    if (inttemp_ir < -400)
+        inttemp_ir = -400;
+    if (inttemp_ir > 850)
+        inttemp_ir = 850;
+    //
+    return inttemp_ir;
+}
--- a/src/peripheral.c
+++ b/src/peripheral.c
@@ -1,63 +0,0 @@
-//
-// Created by yelv1 on 24-9-22.
-//
-#include "peripheral.h"
-#include "gd32e23x.h"
-
-void usart_config(void)
-{
-    rcu_periph_clock_enable(RCU_GPIOA);
-    rcu_periph_clock_enable(RCU_USART0);
-
-    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_3);
-    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_2);
-
-    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_3);
-    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
-    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_2);
-    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
-
-    usart_deinit(USART0);
-    usart_baudrate_set(USART0, 115200U);
-    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
-    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
-
-    usart_enable(USART0);
-
-    gpio_mode_set(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_4);
-    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
-
-    gpio_bit_write(GPIOA, GPIO_PIN_4, SET);
-}
-
-/*!
-    \brief      led blink configuration
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void led_blink_config(void)
-{
-    rcu_periph_clock_enable(RCU_GPIOB);
-
-    gpio_mode_set(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_1);
-    gpio_output_options_set(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_1);
-    gpio_bit_write(GPIOB, GPIO_PIN_1, SET);
-
-    rcu_periph_clock_enable(RCU_TIMER13);
-    timer_deinit(RCU_TIMER13);
-
-    timer_parameter_struct timer_initpara;
-    timer_struct_para_init(&timer_initpara);
-    timer_initpara.prescaler        =7199;
-    timer_initpara.alignedmode      =TIMER_COUNTER_EDGE;
-    timer_initpara.counterdirection =TIMER_COUNTER_UP;
-    timer_initpara.period           =999;
-    timer_initpara.clockdivision    =TIMER_CKDIV_DIV1;
-    timer_init(TIMER13, &timer_initpara);
-
-    timer_auto_reload_shadow_enable(TIMER13);
-    timer_interrupt_enable(TIMER13, TIMER_INT_UP);
-    nvic_irq_enable(TIMER13_IRQn, 0);
-    timer_enable(TIMER13);
-}
--- a/src/systick.c
+++ b/src/systick.c
@@ -96,6 +96,6 @@ void delay_ms(uint32_t count) {
 *
 * ************************************************************************
 */
-void delay_nop(void) {
+void delay_5_nop(void) {
    __NOP();__NOP();__NOP();__NOP();__NOP();
 }
--- a/src/ultrasonic_driver.c
+++ b/src/ultrasonic_driver.c
@@ -6,6 +6,34 @@
 #include "gd32e23x.h"
 #include "systick.h"

+void led_config(void)
+{
+    rcu_periph_clock_enable(LED_RCU);
+
+    gpio_mode_set(LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_PIN);
+    gpio_output_options_set(LED_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LED_PIN);
+    gpio_bit_write(LED_PORT, LED_PIN, SET);
+
+    rcu_periph_clock_enable(LED_TIMER_RCU);
+    timer_deinit(LED_TIMER);
+
+    timer_parameter_struct timer_initpara;
+    timer_struct_para_init(&timer_initpara);
+    timer_initpara.prescaler = 7199;
+    timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
+    timer_initpara.counterdirection = TIMER_COUNTER_UP;
+    timer_initpara.period = 999;
+    timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
+    timer_init(LED_TIMER, &timer_initpara);
+
+    timer_auto_reload_shadow_enable(LED_TIMER);
+    timer_interrupt_enable(LED_TIMER, TIMER_INT_UP);
+
+    timer_enable(LED_TIMER);
+
+    nvic_irq_enable(LED_IRQ, 0);
+}
+
 void usart_config(void)
 {
    rcu_periph_clock_enable(USART_GPIO_RCU);
@@ -25,3 +53,151 @@ void usart_config(void)

    usart_enable(USART0_PHY);
 }
+
+void ultrasonic_config(void)
+{
+    rcu_periph_clock_enable(US_TRAN_GPIO_RCU);
+
+    gpio_mode_set(US_TRAN_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, US_TRAN_PIN);
+    gpio_output_options_set(US_TRAN_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, US_TRAN_PIN);
+    gpio_af_set(US_TRAN_GPIO_PORT, US_TRAN_AF, US_TRAN_PIN);
+
+    timer_oc_parameter_struct timer_ocinitpara;
+    timer_parameter_struct timer_initpara;
+
+    rcu_periph_clock_enable(US_TRAN_RCU);
+    timer_deinit(US_TRAN_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_TRAN_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_TRAN_TIMER, US_TRAN_CH, &timer_ocinitpara);
+
+    timer_channel_output_pulse_value_config(US_TRAN_TIMER, US_TRAN_CH, 120);
+    timer_channel_output_mode_config(US_TRAN_TIMER, US_TRAN_CH, TIMER_OC_MODE_PWM0);
+    timer_auto_reload_shadow_enable(US_TRAN_TIMER);
+
+    timer_interrupt_enable(US_TRAN_TIMER, TIMER_INT_UP);
+}
+
+void ultrasonic_transmit_config(void)
+{
+    led_config();
+    usart_config();
+    ultrasonic_config();
+}
+
+void ultrasonic_pwm_out_cycles(const uint8_t cycles)
+{
+    uint8_t current_cycle = 0;
+
+    timer_channel_output_pulse_value_config(US_TRAN_TIMER, US_TRAN_CH, 120);
+    timer_channel_output_mode_config(US_TRAN_TIMER, US_TRAN_CH, TIMER_OC_MODE_PWM1);
+    timer_enable(US_TRAN_TIMER);
+
+    timer_enable(TIMER15);
+
+    while (current_cycle < cycles)
+    {
+        while (!timer_interrupt_flag_get(US_TRAN_TIMER, TIMER_INT_FLAG_UP));
+        timer_interrupt_flag_clear(US_TRAN_TIMER, TIMER_INT_FLAG_UP);
+        current_cycle++;
+    }
+    // delay_nop();
+    timer_disable(US_TRAN_TIMER);
+    // if(gpio_output_bit_get(GPIOB, GPIO_PIN_1) == SET)
+    // {
+    //     gpio_bit_reset(GPIOB, GPIO_PIN_1);
+    // }
+}
+
+void ultrasonic_transmit_delay(const uint16_t micro_second)
+{
+    rcu_periph_clock_enable(US_TRAN_DELAY_RCU);
+    timer_deinit(US_TRAN_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_TRAN_DELAY_TIMER, &timer_initpara);
+
+    timer_auto_reload_shadow_enable(US_TRAN_DELAY_TIMER);
+    timer_interrupt_enable(US_TRAN_DELAY_TIMER, TIMER_INT_UP);
+    nvic_irq_enable(TIMER15_IRQn, 1U);
+}
+
+void receive_exti_config(void)
+{
+    rcu_periph_clock_enable(US_FB_GPIO_RCU);
+    rcu_periph_clock_enable(US_FB_EXTI_RCU);
+
+    gpio_mode_set(US_FB_GPIO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, US_FB_GPIO_PIN);
+    nvic_irq_enable(US_FB_EXTI_IRQ, 0U);
+    syscfg_exti_line_config(EXTI_SOURCE_GPIOA, EXTI_SOURCE_PIN0);
+
+    exti_init(US_FB_GPIO_EXTI, EXTI_INTERRUPT, EXTI_TRIG_FALLING);
+    exti_flag_clear(US_FB_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_receive_config(void)
+{
+    ultrasonic_transmit_delay(TIME_CORRECTION_US);
+    receive_exti_config();
+    ultrasonic_echo_timer_config();
+}
+
+uint16_t calculate_distance(uint32_t us_value)
+{
+    uint16_t distace = (TIME_CORRECTION_US + us_value) * 17;
+    /*
+     *  (TIME_CORRECTION_US + us_value) * 340 m/s
+     *  -----------------------------------------
+     *                  1000 000
+     *  ----------------------------------------------
+     *                          2
+     */
+    return distace;
+}
Author	SHA1	Message	Date
hulk	be81eb0c2e	Merge pull request 'detached' (#1 ) from detached into US&IR Reviewed-on: #1	2024-09-27 18:24:56 +08:00
yelvlab	1cf43e0371	shit	2024-09-27 18:22:57 +08:00
yelvlab	0bbec6209f	shit	2024-09-27 15:41:22 +08:00
yelvlab	d5814ddd62	shit	2024-09-27 00:15:24 +08:00
yelvlab	9ce4cd2e44	add i2c_config	2024-09-27 00:12:13 +08:00
yelvlab	9d7d0935ba	i2c function	2024-09-26 17:32:57 +08:00
yelvlab	a113fefbbe	add MLX90614 LIB	2024-09-26 10:09:05 +08:00
yelvlab	93a7aa7991	update some err	2024-09-26 10:07:43 +08:00
yelvlab	646ca87981	update readme	2024-09-25 18:58:24 +08:00
yelvlab	c7902a1722	Wrapping the receive configuration functions together	2024-09-25 18:47:40 +08:00
yelvlab	2c96ee7848	Add over-range judgment printing and compilation conditions under different voltages	2024-09-25 18:41:52 +08:00
yelvlab	9cdd0008a5	Convert ultrasonic flight time to distance value	2024-09-25 17:25:07 +08:00
yelvlab	b6b6932c08	constants replaced with macro definition	2024-09-25 17:22:55 +08:00
yelvlab	7cb354967c	fix	2024-09-25 15:56:26 +08:00
yelvlab	6581d6ff88	first version OK!!!!!	2024-09-25 15:42:11 +08:00
yelvlab	392ccaba81	change ultrasonic transmit cycles function & transmit delay function input parameter from void to const uint16_t	2024-09-25 11:05:12 +08:00
yelvlab	e345b826da	change the timer of LED to TIMER5(basic timer)	2024-09-25 11:01:14 +08:00
yelvlab	212ffff06b	change the timer of LED to TIMER5(basic timer)	2024-09-25 11:00:47 +08:00
yelvlab	4252d59581	add ultrasonic sending interval constant macro definition	2024-09-25 10:56:03 +08:00
yelvlab	48b081f736	delete template user lib	2024-09-25 10:52:58 +08:00
yelvlab	fce102e234	delete template user lib	2024-09-25 10:52:52 +08:00
yelvlab	f953864d11	add debug info	2024-09-24 23:26:13 +08:00
yelvlab	e3b6112411	change LED blink timer to TIMER16. change ultrasonic transmit pin timer to TIMER13 CH0 PB1(AF_0). rename function name.	2024-09-24 23:24:58 +08:00
yelvlab	d51a97df32	into exti IRQ OK	2024-09-24 19:55:44 +08:00
yelvlab	8abd25d7fa	fix include file name err	2024-09-23 21:45:38 +08:00
yelvlab	e26e1079d5	重构超声波驱动器代码和更新头文件代码重构包括：- 在`main.c`中使用`ultrasonic_peripheral_config`替代`ultrasonic_config`进行超声波硬件配置。 - 在`ultrasonic_driver.c`中重命名并重新组织超声波配置函数，以提高模块化和可读性。 - 更新`usonic_driver.h`头文件，以匹配最新的函数命名和增加硬件配置的宏定义。这些更改使代码更加清晰、易于理解和维护。同时，通过特定功能的宏定义，增强了代码的可配置性。	2024-09-23 21:35:32 +08:00