hulk/xlsw_3dp_ultrasonic_300K
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

规范第一版超声与红外代码函数，红外可以添加更多函数，待学习。同时修改CMakeList在生成bin与hex文件时的命名，以便区分。CMakeList与.h头文件的联动尚未实现。

Browse Source
This commit is contained in:
yelvlab 2024-10-10 14:56:13 +08:00
parent ea7d68e35e
commit 8ad278f76b
11 changed files with 133 additions and 1020 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
CMakeLists.txt
View File

@ -3,6 +3,15 @@ include(cmake/toolchain.cmake)
project(xlsw_3dp_ultrasonic_300K)
set(POWER_VOLTAGE "12V")
set(VERSION_MAJOR 0)
set(VERSION_MINOR 0)
set(VERSION_PATCH 13)
set(VERSION "V${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
string(TIMESTAMP CURRENT_DATE "%Y-%m-%d")
add_definitions(-DPOWER_VOLTAGE="${POWER_VOLTAGE}")
enable_language(C)
enable_language(CXX)
enable_language(ASM)
@ -20,7 +29,6 @@ set(TARGET_C_SRC
${CMAKE_SOURCE_DIR}/src/systick.c
${CMAKE_SOURCE_DIR}/src/ultrasonic_driver.c
${CMAKE_SOURCE_DIR}/src/mlx90614.c
# ${CMAKE_SOURCE_DIR}/src/gd32e23x_hw_i2c.c
)
add_executable(xlsw_3dp_ultrasonic_300K ${TARGET_C_SRC})
@ -29,5 +37,5 @@ target_link_libraries(xlsw_3dp_ultrasonic_300K GD32E23X_SDK)
target_include_directories(xlsw_3dp_ultrasonic_300K PUBLIC inc)
# Generate .bin and .hex
generate_binary_file(xlsw_3dp_ultrasonic_300K)
generate_hex_file(xlsw_3dp_ultrasonic_300K)
generate_binary_file(xlsw_3dp_ultrasonic_300K "XLSW_US-IR_FW")
generate_hex_file(xlsw_3dp_ultrasonic_300K "XLSW_US-IR_FW")

50
README.md
View File

@ -1,7 +1,44 @@
# XLSW-3DP-Ultrasonic-300K
## 传感器数据传输与样式
- USART
- baudrate 115200
- 8N1
- 数据格式
```cap_val:183 Distance: 7361 Temp:2735```
- cap_val:183 超声死区外的ToF数据
- Distance: 7361 距离数据，100倍mm距离值
- Temp:2735 温度数据，100倍摄氏度值
## 供电与数据
本项目支持12V/24V供电，默认编译选项为12V供电。主要相关部分为超声的驱动部分。
主要校准数据也会以12V为主。如果需要24V供电，请自行修改编译选项。
## 条件编译与输出
- 条件编译共有两个地方需要修改：
1. `ProjectDir/inc/ultrasonic_driver.h` 中配置12V/24V供电，默认为12V供电。
`#define POWER_SUPPLY_12V`
2. `ProjectDir/CMakeLists.txt` 中配置编译选项，默认为12V供电。
`set(POWER_VOLTAGE "12V")`
- 输出文件命名：
`XLSW_US-IR_FW_12V_V0.0.13_2024-x-x.bin/hex`
1. XLSW_US-IR_FW: 表示该项目为300K模拟超声波测距与IR非接触式测温方案的MCU固件
2. 12V: 表示目前编译固件为12V供电情况下优化的校正参数，建议与实际对应，这样可以获得更好的测距准确度
3. 2024-x-x: 表示编译日期
## TODO List
### 超声
- [x] 超声驱动信号（300KHz 50%duty 5cycles）发送
- [x] PA2/PA3配置为USART0
- [x] LED配置存活状态闪烁
@ -15,4 +52,15 @@
- [x] 在产生指定时间的中断服务函数中，开启EXTI0（PA0,sensor信号接收引脚），开启TIMER14（计时计数器，1us计一个数，计算接收到外部中断的时间）
- [ ] 在外部中断服务函数中，产生一个事件或中断，进入到TIMER14的中断
- [x] TIMER14不存在F4x系列，改用TIMER16.
- [x] 放弃上述流程，多一层中断层，直接在EXTI0的中断服务函数中，直接读取TIMER16的CH_0计数值。
- [x] 放弃上述流程，多一层中断层，直接在EXTI0的中断服务函数中，直接读取TIMER16的CH_0计数值。
### IR
- [x] 配置IIC接口到PF0/1
- [x] 移植读取目标温度的函数
- [ ] 设置不同反射率下的校准
- [ ] 读取环境温度
### 条件编译
- [ ] 自动判断某一个条件编译是否开启，并在CmakeList中添加对应选项，输出文件时加以标识

16
cmake/toolchain.cmake
View File

@ -33,6 +33,8 @@ find_program(CMAKE_OBJCOPY NAMES ${TARGET_TRIPLET}-objcopy HINTS ${TOOLCHAIN_BIN
find_program(CMAKE_OBJDUMP NAMES ${TARGET_TRIPLET}-objdump HINTS ${TOOLCHAIN_BIN_PATH})
find_program(CMAKE_SIZE NAMES ${TARGET_TRIPLET}-size HINTS ${TOOLCHAIN_BIN_PATH})
function(print_size_of_target TARGET)
add_custom_target(${TARGET}_always_display_size
ALL COMMAND ${CMAKE_SIZE} "$<TARGET_FILE:${TARGET}>"
@ -41,12 +43,12 @@ function(print_size_of_target TARGET)
)
endfunction()
function(_generate_file TARGET OUTPUT_EXTENSION OBJCOPY_BFD_OUTPUT)
function(_generate_file TARGET PREFIX VERSION DATE OUTPUT_EXTENSION OBJCOPY_BFD_OUTPUT)
get_target_property(TARGET_OUTPUT_NAME ${TARGET} OUTPUT_NAME)
if (TARGET_OUTPUT_NAME)
set(OUTPUT_FILE_NAME "${TARGET_OUTPUT_NAME}.${OUTPUT_EXTENSION}")
set(OUTPUT_FILE_NAME "${PREFIX}_${POWER_VOLTAGE}_${VERSION}_${DATE}.${OUTPUT_EXTENSION}")
else()
set(OUTPUT_FILE_NAME "${TARGET}.${OUTPUT_EXTENSION}")
set(OUTPUT_FILE_NAME "${PREFIX}_${POWER_VOLTAGE}_${VERSION}_${DATE}.${OUTPUT_EXTENSION}")
endif()
get_target_property(RUNTIME_OUTPUT_DIRECTORY ${TARGET} RUNTIME_OUTPUT_DIRECTORY)
@ -65,12 +67,12 @@ function(_generate_file TARGET OUTPUT_EXTENSION OBJCOPY_BFD_OUTPUT)
)
endfunction()
function(generate_binary_file TARGET)
_generate_file(${TARGET} "bin" "binary")
function(generate_binary_file TARGET PREFIX)
_generate_file(${TARGET} "${PREFIX}" "${VERSION}" "${CURRENT_DATE}" "bin" "binary")
endfunction()
function(generate_hex_file TARGET)
_generate_file(${TARGET} "hex" "ihex")
function(generate_hex_file TARGET PREFIX)
_generate_file(${TARGET} "${PREFIX}" "${VERSION}" "${CURRENT_DATE}" "hex" "ihex")
endfunction()
set(CMAKE_EXECUTABLE_SUFFIX_C .elf)

116
inc/gd32e23x_hw_i2c.h
View File

@ -1,116 +0,0 @@
#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 */

3
inc/mlx90614.h
View File

@ -23,7 +23,10 @@
#define REG_ADDR_OBJ_TEMP 0x07
#define REG_ADDR_AMB_TEMP 0x06
/* function declarations */
/* this function configures I2C Peripheral & GPIO AF for I2C */
void MLX90614_I2CConfig(void);
/* this function reads object temperature */
uint16_t MLX90614_GetObjectTemperature(void);
#endif //MLX90614_H

18
inc/ultrasonic_driver.h
View File

@ -11,9 +11,11 @@
// #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
@ -63,13 +65,13 @@
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);
void UltraSonic_GPIO_Config(void);
void UltraSonic_Transmit_Config(void);
void UltraSonic_PwmOut_Cycles(const uint8_t cycles);
void UltraSonic_Transmit_Delay(const uint16_t micro_second);
void UltraSonic_ReceExti_Config(void);
void UltraSonic_EchoTimer_Config(void);
void UltraSonic_Receive_Config(void);
uint16_t UltraSonic_CalcDistance(uint32_t us_value);
#endif //ULTRASONIC_DRIVER_H

864
src/gd32e23x_hw_i2c.c
View File

@ -1,864 +0,0 @@
#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;
}

22
src/gd32e23x_it.c
View File

@ -38,7 +38,7 @@ OF SUCH DAMAGE.
#include "systick.h"
#include "ultrasonic_driver.h"
__IO uint32_t capture_value;
__IO uint32_t g_capture_value;
/*!
\brief this function handles NMI exception
@ -102,6 +102,12 @@ void SysTick_Handler(void)
{
}
/**
* @brief This function handles TIMER5 interrupt request.
* @param[in] none
* @param[out] none
* @retval None
*/
void TIMER5_IRQHandler(void) {
if (timer_interrupt_flag_get(LED_TIMER, TIMER_INT_FLAG_UP) == SET)
{
@ -119,6 +125,12 @@ void TIMER5_IRQHandler(void) {
}
}
/**
* @brief This function handles TIMER15 interrupt request.
* @param[in] none
* @param[out] none
* @retval None
*/
void TIMER15_IRQHandler(void) {
if (timer_interrupt_flag_get(TIMER15, TIMER_INT_FLAG_UP) == SET)
{
@ -130,11 +142,17 @@ void TIMER15_IRQHandler(void) {
}
}
/**
* @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(EXTI_0) == SET)
{
exti_interrupt_flag_clear(EXTI_0);
capture_value = timer_channel_capture_value_register_read(TIMER16, TIMER_CH_0);
g_capture_value = timer_channel_capture_value_register_read(TIMER16, TIMER_CH_0);
timer_disable(TIMER16);
exti_interrupt_disable(EXTI_0);
}

14
src/main.c
View File

@ -13,7 +13,7 @@
#include "ultrasonic_driver.h"
#include "mlx90614.h"
extern uint32_t capture_value;
extern uint32_t g_capture_value;
uint16_t distance_uint16;
/*!
@ -27,8 +27,8 @@ int main(void)
/* configure systick */
systick_config();
/* configure ultrasonic board hardware */
ultrasonic_transmit_config();
ultrasonic_receive_config();
UltraSonic_Transmit_Config();
UltraSonic_Receive_Config();
MLX90614_I2CConfig();
@ -49,13 +49,13 @@ int main(void)
{
delay_ms(ULTRASONIC_TRAN_US);
ultrasonic_pwm_out_cycles(ULTRASONIC_CYCLES);
UltraSonic_PwmOut_Cycles(ULTRASONIC_CYCLES);
delay_ms(2);
printf("cap_val:%ld\t", capture_value);
printf("cap_val:%ld\t", g_capture_value);
const char* result = (capture_value <= CAPTURE_VALUE_MAX) ? "Distance: %d\t" : "Over Range\t";
distance_uint16 = calculate_distance(capture_value);
const char* result = (g_capture_value <= CAPTURE_VALUE_MAX) ? "Distance: %d\t" : "Over Range\t";
distance_uint16 = UltraSonic_CalcDistance(g_capture_value);
printf(result, distance_uint16);
printf("Temp:%d\n", MLX90614_GetObjectTemperature());

12
src/mlx90614.c
View File

@ -7,6 +7,12 @@
#include "systick.h"
#include <stdio.h>
/**
* @brief This function configure the I2C peripheral & GPIO
* @param[in] none
* @param[out] none
* @retval None
*/
void MLX90614_I2CConfig(void) {
rcu_periph_clock_enable(RCU_IR_GPIO);
rcu_periph_clock_enable(RCU_I2C);
@ -27,6 +33,12 @@ void MLX90614_I2CConfig(void) {
i2c_ack_config(IR_I2C, I2C_ACK_ENABLE);
}
/**
* @brief This function read object temperature
* @param[in] none
* @param[out] temp_raw: object temperature
* @retval None
*/
uint16_t MLX90614_GetObjectTemperature(void) {
uint8_t data[3] = {0};
uint16_t temp_raw = 0;

24
src/ultrasonic_driver.c
View File

@ -54,7 +54,7 @@ void usart_config(void)
usart_enable(USART0_PHY);
}
void ultrasonic_config(void)
void UltraSonic_GPIO_Config(void)
{
rcu_periph_clock_enable(US_TRAN_GPIO_RCU);
@ -92,14 +92,14 @@ void ultrasonic_config(void)
timer_interrupt_enable(US_TRAN_TIMER, TIMER_INT_UP);
}
void ultrasonic_transmit_config(void)
void UltraSonic_Transmit_Config(void)
{
led_config();
usart_config();
ultrasonic_config();
UltraSonic_GPIO_Config();
}
void ultrasonic_pwm_out_cycles(const uint8_t cycles)
void UltraSonic_PwmOut_Cycles(const uint8_t cycles)
{
uint8_t current_cycle = 0;
@ -123,7 +123,7 @@ void ultrasonic_pwm_out_cycles(const uint8_t cycles)
// }
}
void ultrasonic_transmit_delay(const uint16_t micro_second)
void UltraSonic_Transmit_Delay(const uint16_t micro_second)
{
rcu_periph_clock_enable(US_TRAN_DELAY_RCU);
timer_deinit(US_TRAN_DELAY_TIMER);
@ -143,7 +143,7 @@ void ultrasonic_transmit_delay(const uint16_t micro_second)
nvic_irq_enable(TIMER15_IRQn, 1U);
}
void receive_exti_config(void)
void UltraSonic_ReceExti_Config(void)
{
rcu_periph_clock_enable(US_FB_GPIO_RCU);
rcu_periph_clock_enable(US_FB_EXTI_RCU);
@ -158,7 +158,7 @@ void receive_exti_config(void)
// exti_interrupt_enable(EXTI_0);
}
void ultrasonic_echo_timer_config(void)
void UltraSonic_EchoTimer_Config(void)
{
rcu_periph_clock_enable(US_ECHO_RCU);
timer_deinit(US_ECHO_TIMER);
@ -182,14 +182,14 @@ void ultrasonic_echo_timer_config(void)
timer_input_capture_config(US_ECHO_TIMER, US_ECHO_CH, &timer_icinitpara);
}
void ultrasonic_receive_config(void)
void UltraSonic_Receive_Config(void)
{
ultrasonic_transmit_delay(TIME_CORRECTION_US);
receive_exti_config();
ultrasonic_echo_timer_config();
UltraSonic_Transmit_Delay(TIME_CORRECTION_US);
UltraSonic_ReceExti_Config();
UltraSonic_EchoTimer_Config();
}
uint16_t calculate_distance(uint32_t us_value)
uint16_t UltraSonic_CalcDistance(uint32_t us_value)
{
uint16_t distace = (TIME_CORRECTION_US + us_value) * 17;
/*