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

Merge pull request 'US&IR' (#2) from US&IR into main

Browse Source 
Reviewed-on: #2
This commit is contained in:
hulk 2024-10-10 14:59:27 +08:00
commit 5936f69ec4
13 changed files with 353 additions and 901 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) 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(C)
enable_language(CXX) enable_language(CXX)
enable_language(ASM) enable_language(ASM)
@ -20,7 +29,6 @@ set(TARGET_C_SRC
${CMAKE_SOURCE_DIR}/src/systick.c ${CMAKE_SOURCE_DIR}/src/systick.c
${CMAKE_SOURCE_DIR}/src/ultrasonic_driver.c ${CMAKE_SOURCE_DIR}/src/ultrasonic_driver.c
${CMAKE_SOURCE_DIR}/src/mlx90614.c ${CMAKE_SOURCE_DIR}/src/mlx90614.c
${CMAKE_SOURCE_DIR}/src/gd32e23x_hw_i2c.c
) )
add_executable(xlsw_3dp_ultrasonic_300K ${TARGET_C_SRC}) 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) target_include_directories(xlsw_3dp_ultrasonic_300K PUBLIC inc)
# Generate .bin and .hex # Generate .bin and .hex
generate_binary_file(xlsw_3dp_ultrasonic_300K) generate_binary_file(xlsw_3dp_ultrasonic_300K "XLSW_US-IR_FW")
generate_hex_file(xlsw_3dp_ultrasonic_300K) generate_hex_file(xlsw_3dp_ultrasonic_300K "XLSW_US-IR_FW")

50
README.md
View File

@ -1,7 +1,44 @@
# XLSW-3DP-Ultrasonic-300K # 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 ## TODO List
### 超声
- [x] 超声驱动信号（300KHz 50%duty 5cycles）发送 - [x] 超声驱动信号（300KHz 50%duty 5cycles）发送
- [x] PA2/PA3配置为USART0 - [x] PA2/PA3配置为USART0
- [x] LED配置存活状态闪烁 - [x] LED配置存活状态闪烁
@ -15,4 +52,15 @@
- [x] 在产生指定时间的中断服务函数中，开启EXTI0（PA0,sensor信号接收引脚），开启TIMER14（计时计数器，1us计一个数，计算接收到外部中断的时间） - [x] 在产生指定时间的中断服务函数中，开启EXTI0（PA0,sensor信号接收引脚），开启TIMER14（计时计数器，1us计一个数，计算接收到外部中断的时间）
- [ ] 在外部中断服务函数中，产生一个事件或中断，进入到TIMER14的中断 - [ ] 在外部中断服务函数中，产生一个事件或中断，进入到TIMER14的中断
- [x] TIMER14不存在F4x系列，改用TIMER16. - [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_OBJDUMP NAMES ${TARGET_TRIPLET}-objdump HINTS ${TOOLCHAIN_BIN_PATH})
find_program(CMAKE_SIZE NAMES ${TARGET_TRIPLET}-size HINTS ${TOOLCHAIN_BIN_PATH}) find_program(CMAKE_SIZE NAMES ${TARGET_TRIPLET}-size HINTS ${TOOLCHAIN_BIN_PATH})
function(print_size_of_target TARGET) function(print_size_of_target TARGET)
add_custom_target(${TARGET}_always_display_size add_custom_target(${TARGET}_always_display_size
ALL COMMAND ${CMAKE_SIZE} "$<TARGET_FILE:${TARGET}>" ALL COMMAND ${CMAKE_SIZE} "$<TARGET_FILE:${TARGET}>"
@ -41,12 +43,12 @@ function(print_size_of_target TARGET)
) )
endfunction() 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) get_target_property(TARGET_OUTPUT_NAME ${TARGET} OUTPUT_NAME)
if (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() else()
set(OUTPUT_FILE_NAME "${TARGET}.${OUTPUT_EXTENSION}") set(OUTPUT_FILE_NAME "${PREFIX}_${POWER_VOLTAGE}_${VERSION}_${DATE}.${OUTPUT_EXTENSION}")
endif() endif()
get_target_property(RUNTIME_OUTPUT_DIRECTORY ${TARGET} RUNTIME_OUTPUT_DIRECTORY) get_target_property(RUNTIME_OUTPUT_DIRECTORY ${TARGET} RUNTIME_OUTPUT_DIRECTORY)
@ -65,12 +67,12 @@ function(_generate_file TARGET OUTPUT_EXTENSION OBJCOPY_BFD_OUTPUT)
) )
endfunction() endfunction()
function(generate_binary_file TARGET) function(generate_binary_file TARGET PREFIX)
_generate_file(${TARGET} "bin" "binary") _generate_file(${TARGET} "${PREFIX}" "${VERSION}" "${CURRENT_DATE}" "bin" "binary")
endfunction() endfunction()
function(generate_hex_file TARGET) function(generate_hex_file TARGET PREFIX)
_generate_file(${TARGET} "hex" "ihex") _generate_file(${TARGET} "${PREFIX}" "${VERSION}" "${CURRENT_DATE}" "hex" "ihex")
endfunction() endfunction()
set(CMAKE_EXECUTABLE_SUFFIX_C .elf) set(CMAKE_EXECUTABLE_SUFFIX_C .elf)

75
inc/gd32e23x_hw_i2c.h
View File

@ -1,75 +0,0 @@
#ifndef GD32E23X_HW_I2C_H
#define GD32E23X_HW_I2C_H
#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
#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;
/**
* \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);
#endif /* GD32E23X_HW_I2C_H */

24
inc/mlx90614.h
View File

@ -5,4 +5,28 @@
#ifndef MLX90614_H #ifndef MLX90614_H
#define MLX90614_H #define MLX90614_H
#include "gd32e23x.h"
#define I2C_SPEED 100000
#define IR_I2C I2C0
#define RCU_IR_GPIO RCU_GPIOF
#define RCU_I2C RCU_I2C0
#define I2C_SCL_PORT GPIOF
#define I2C_SCL_PIN GPIO_PIN_1
#define I2C_SDA_PORT GPIOF
#define I2C_SDA_PIN GPIO_PIN_0
#define I2C_GPIO_AF GPIO_AF_1
#define I2C_TIME_OUT (uint16_t)(5000)
#define SLAVE_ADDR (0x5A << 1)
#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 #endif //MLX90614_H

2
inc/systick.h
View File

@ -24,6 +24,6 @@ void delay_ms(uint32_t count);
/* delay a time in microseconds */ /* delay a time in microseconds */
void delay_us(uint32_t count); void delay_us(uint32_t count);
void delay_nop(void); void delay_5_nop(void);
#endif /* SYS_TICK_H */ #endif /* SYS_TICK_H */

28
inc/ultrasonic_driver.h
View File

@ -11,17 +11,19 @@
// #define POWER_SUPPLY_24V // #define POWER_SUPPLY_24V
#ifdef POWER_SUPPLY_12V #ifdef POWER_SUPPLY_12V
#define TIME_CORRECTION_US 250 #define POWER_VOLTAGE "12V"
#define CAPTURE_VALUE_MAX 515 #define TIME_CORRECTION_US 250
#define CAPTURE_VALUE_MAX 515
#elif defined(POWER_SUPPLY_24V) #elif defined(POWER_SUPPLY_24V)
#define TIME_CORRECTION_US 230 #define POWER_VOLTAGE "24V"
#define CAPTURE_VALUE_MAX 550 #define TIME_CORRECTION_US 230
#define CAPTURE_VALUE_MAX 550
#else #else
#error "Please define either POWER_SUPPLY_12V or POWER_SUPPLY_24V" #error "Please define either POWER_SUPPLY_12V or POWER_SUPPLY_24V"
#endif #endif
#define ULTRASONIC_CYCLES 0x05U #define ULTRASONIC_CYCLES 0x05U
#define ULTRASONIC_TRAN_US 500 // (ms) #define ULTRASONIC_TRAN_US 998 // (ms)
#define LED_PORT GPIOA #define LED_PORT GPIOA
#define LED_PIN GPIO_PIN_9 #define LED_PIN GPIO_PIN_9
@ -63,13 +65,13 @@
void led_config(void); void led_config(void);
void usart_config(void); void usart_config(void);
void ultrasonic_config(void); void UltraSonic_GPIO_Config(void);
void ultrasonic_transmit_config(void); void UltraSonic_Transmit_Config(void);
void ultrasonic_pwm_out_cycles(const uint8_t cycles); void UltraSonic_PwmOut_Cycles(const uint8_t cycles);
void ultrasonic_transmit_delay(const uint16_t micro_second); void UltraSonic_Transmit_Delay(const uint16_t micro_second);
void receive_exti_config(void); void UltraSonic_ReceExti_Config(void);
void ultrasonic_echo_timer_config(void); void UltraSonic_EchoTimer_Config(void);
void ultrasonic_receive_config(void); void UltraSonic_Receive_Config(void);
uint16_t calculate_distance(uint32_t us_value); uint16_t UltraSonic_CalcDistance(uint32_t us_value);
#endif //ULTRASONIC_DRIVER_H #endif //ULTRASONIC_DRIVER_H

742
src/gd32e23x_hw_i2c.c
View File

@ -1,742 +0,0 @@
#include <stdio.h>
#include <stdint.h>
#include "gd32e23x.h"
#include "gd32e23x_hw_i2c.h"
#include "gd32e23x.h"
/*!
\brief Enable IIC0 & NVIC
\param[in] none
\param[out] none
\retval none
*/
void i2c0_init(void) {
/* IIC config */
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);
}
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);
__NOP();__NOP();__NOP();__NOP();__NOP();
/* stop signal */
GPIO_BOP(I2C0_GPIO_PORT) |= I2C0_GPIO_SCL_PIN;
__NOP();__NOP();__NOP();__NOP();__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 */
i2c0_init();
}
/*!
\brief Deinit IIC0.
\param[in] none
\param[out] none
\retval none
*/
void i2c0_deinit(void)
{
rcu_periph_clock_disable(RCU_I2C0);
i2c_disable(I2C0);
nvic_irq_disable(I2C0_EV_IRQn);
nvic_irq_disable(I2C0_ER_IRQn);
}
/*!
\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;
unsigned char 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 TWI3(none) 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
\note No TWI3(IIC3) - No operation - Error log.
*/
uint8_t i2c_master_write_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){
__NOP();
#ifdef DEBUG_VERBOES
printf("\n[DebugVerboes]i2c_master_write_register3 @ i2c.c, no TWI3 \n");
#endif
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;
}
/*!
\brief TWI3(none) 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
\note No TWI3(IIC3) - No operation - Error log.
*/
uint8_t i2c_master_write_register3_raw(unsigned char Address, unsigned short len, unsigned char *data){
__NOP();
#ifdef DEBUG_VERBOES
printf("\n[DebugVerboes]i2c_master_write_register3_raw @ i2c.c, no TWI3 \n");
#endif
return IIC_SUCCESS;
}

22
src/gd32e23x_it.c
View File

@ -38,7 +38,7 @@ OF SUCH DAMAGE.
#include "systick.h" #include "systick.h"
#include "ultrasonic_driver.h" #include "ultrasonic_driver.h"
__IO uint32_t capture_value; __IO uint32_t g_capture_value;
/*! /*!
\brief this function handles NMI exception \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) { void TIMER5_IRQHandler(void) {
if (timer_interrupt_flag_get(LED_TIMER, TIMER_INT_FLAG_UP) == SET) 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) { void TIMER15_IRQHandler(void) {
if (timer_interrupt_flag_get(TIMER15, TIMER_INT_FLAG_UP) == SET) 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) { void EXTI0_1_IRQHandler(void) {
if (exti_interrupt_flag_get(EXTI_0) == SET) if (exti_interrupt_flag_get(EXTI_0) == SET)
{ {
exti_interrupt_flag_clear(EXTI_0); 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); timer_disable(TIMER16);
exti_interrupt_disable(EXTI_0); exti_interrupt_disable(EXTI_0);
} }

25
src/main.c
View File

@ -13,7 +13,7 @@
#include "ultrasonic_driver.h" #include "ultrasonic_driver.h"
#include "mlx90614.h" #include "mlx90614.h"
extern uint32_t capture_value; extern uint32_t g_capture_value;
uint16_t distance_uint16; uint16_t distance_uint16;
/*! /*!
@ -27,8 +27,10 @@ int main(void)
/* configure systick */ /* configure systick */
systick_config(); systick_config();
/* configure ultrasonic board hardware */ /* configure ultrasonic board hardware */
ultrasonic_transmit_config(); UltraSonic_Transmit_Config();
ultrasonic_receive_config(); UltraSonic_Receive_Config();
MLX90614_I2CConfig();
/* ---------- debug start ---------- */ /* ---------- debug start ---------- */
@ -43,27 +45,30 @@ int main(void)
delay_ms(2000); delay_ms(2000);
while(1) while (1)
{ {
delay_ms(ULTRASONIC_TRAN_US); delay_ms(ULTRASONIC_TRAN_US);
ultrasonic_pwm_out_cycles(ULTRASONIC_CYCLES); UltraSonic_PwmOut_Cycles(ULTRASONIC_CYCLES);
delay_ms(2); 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\n" : "Over Range\n"; const char* result = (g_capture_value <= CAPTURE_VALUE_MAX) ? "Distance: %d\t" : "Over Range\t";
distance_uint16 = calculate_distance(capture_value); distance_uint16 = UltraSonic_CalcDistance(g_capture_value);
printf(result, distance_uint16); printf(result, distance_uint16);
printf("Temp:%d\n", MLX90614_GetObjectTemperature());
} }
} }
/* retarget the C library printf function to the USART */ /* 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++) for (int i = 0; i < size; i++)
{ {
usart_data_transmit(USART0, (uint8_t)pBuffer[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; return size;
} }

156
src/mlx90614.c
View File

@ -5,7 +5,159 @@
#include "mlx90614.h" #include "mlx90614.h"
#include "gd32e23x.h" #include "gd32e23x.h"
#include "systick.h" #include "systick.h"
#include <stdio.h>
int read_ir_mlx90614(void) { /**
* @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);
} gpio_af_set(I2C_SCL_PORT, I2C_GPIO_AF, I2C_SCL_PIN);
gpio_af_set(I2C_SDA_PORT, I2C_GPIO_AF, I2C_SDA_PIN);
gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
i2c_clock_config(IR_I2C, I2C_SPEED, I2C_DTCY_2);
i2c_mode_addr_config(IR_I2C, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, SLAVE_ADDR);
i2c_enable(IR_I2C);
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;
uint16_t timeout = 0;
i2c_ack_config(IR_I2C, I2C_ACK_ENABLE);
while (i2c_flag_get(IR_I2C, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) //判断IIC总线是否忙，发送起始信号
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_start_on_bus(IR_I2C);
timeout = 0;
} else {
printf("err\r\n");
return -4100; // 超时返回错误
}
while (!i2c_flag_get(IR_I2C, I2C_FLAG_SBSEND) && (timeout < I2C_TIME_OUT)) //判断起始位是否发送，设置sensor地址并设置为写
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_master_addressing(IR_I2C, SLAVE_ADDR, I2C_TRANSMITTER);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
while (!i2c_flag_get(IR_I2C, I2C_FLAG_ADDSEND) && (timeout < I2C_TIME_OUT))
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_flag_clear(IR_I2C, I2C_FLAG_ADDSEND);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
while (!i2c_flag_get(IR_I2C, I2C_FLAG_TBE) && (timeout < I2C_TIME_OUT)) //判断地址是否发送完成，然后发送寄存器地址
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_data_transmit(IR_I2C, REG_ADDR_OBJ_TEMP);
timeout = 0;
// i2c_start_on_bus(IR_I2C);
} else {
return -4100; // 超时返回错误
}
while (i2c_flag_get(IR_I2C, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) //判断发送缓冲器是否为空，为空后（发送完毕）重新发送开始信号
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_start_on_bus(IR_I2C);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
while (!i2c_flag_get(IR_I2C, I2C_FLAG_SBSEND) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout < I2C_TIME_OUT) {
i2c_master_addressing(IR_I2C, SLAVE_ADDR, I2C_RECEIVER);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
while (!i2c_flag_get(IR_I2C, I2C_FLAG_ADDSEND) && (timeout < I2C_TIME_OUT))
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_flag_clear(IR_I2C, I2C_FLAG_ADDSEND);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
// 读取第一个字节的数据
while (!i2c_flag_get(IR_I2C, I2C_FLAG_RBNE) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout < I2C_TIME_OUT) {
data[0] = i2c_data_receive(IR_I2C);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
// 读取第二个字节的数据
while (!i2c_flag_get(IR_I2C, I2C_FLAG_RBNE) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout < I2C_TIME_OUT) {
data[1] = i2c_data_receive(IR_I2C);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
i2c_ack_config(IR_I2C, I2C_ACK_DISABLE); // 关闭发送ACK，它会在下一个字节完成后发送NAK
// 读取第三个字节的数据
while (!i2c_flag_get(IR_I2C, I2C_FLAG_RBNE) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout < I2C_TIME_OUT) {
data[2] = i2c_data_receive(IR_I2C);
timeout = 0;
} else {
return -4100; // 超时返回错误
}
i2c_stop_on_bus(IR_I2C);
temp_raw = ((uint16_t) (data[1] << 8) | data[0]) * 2 - 27315;
// (Data[1] << 8) | data[0] * 0.02 -273.15 为避免浮点运算，直接放大100倍
if (temp_raw > 8500) {
temp_raw = 8500;
}
if (temp_raw < -4000) {
temp_raw = -4000;
}
return temp_raw;
}

2
src/systick.c
View File

@ -96,6 +96,6 @@ void delay_ms(uint32_t count) {
* *
* ************************************************************************ * ************************************************************************
*/ */
void delay_nop(void) { void delay_5_nop(void) {
__NOP();__NOP();__NOP();__NOP();__NOP(); __NOP();__NOP();__NOP();__NOP();__NOP();
} }

98
src/ultrasonic_driver.c
View File

@ -6,7 +6,8 @@
#include "gd32e23x.h" #include "gd32e23x.h"
#include "systick.h" #include "systick.h"
void led_config(void) { void led_config(void)
{
rcu_periph_clock_enable(LED_RCU); rcu_periph_clock_enable(LED_RCU);
gpio_mode_set(LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_PIN); gpio_mode_set(LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_PIN);
@ -18,11 +19,11 @@ void led_config(void) {
timer_parameter_struct timer_initpara; timer_parameter_struct timer_initpara;
timer_struct_para_init(&timer_initpara); timer_struct_para_init(&timer_initpara);
timer_initpara.prescaler =7199; timer_initpara.prescaler = 7199;
timer_initpara.alignedmode =TIMER_COUNTER_EDGE; timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
timer_initpara.counterdirection =TIMER_COUNTER_UP; timer_initpara.counterdirection = TIMER_COUNTER_UP;
timer_initpara.period =999; timer_initpara.period = 999;
timer_initpara.clockdivision =TIMER_CKDIV_DIV1; timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
timer_init(LED_TIMER, &timer_initpara); timer_init(LED_TIMER, &timer_initpara);
timer_auto_reload_shadow_enable(LED_TIMER); timer_auto_reload_shadow_enable(LED_TIMER);
@ -33,7 +34,8 @@ void led_config(void) {
nvic_irq_enable(LED_IRQ, 0); nvic_irq_enable(LED_IRQ, 0);
} }
void usart_config(void) { void usart_config(void)
{
rcu_periph_clock_enable(USART_GPIO_RCU); rcu_periph_clock_enable(USART_GPIO_RCU);
rcu_periph_clock_enable(USART_RCU); rcu_periph_clock_enable(USART_RCU);
@ -52,7 +54,8 @@ void usart_config(void) {
usart_enable(USART0_PHY); usart_enable(USART0_PHY);
} }
void ultrasonic_config(void) { void UltraSonic_GPIO_Config(void)
{
rcu_periph_clock_enable(US_TRAN_GPIO_RCU); 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_mode_set(US_TRAN_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, US_TRAN_PIN);
@ -60,26 +63,26 @@ void ultrasonic_config(void) {
gpio_af_set(US_TRAN_GPIO_PORT, US_TRAN_AF, US_TRAN_PIN); gpio_af_set(US_TRAN_GPIO_PORT, US_TRAN_AF, US_TRAN_PIN);
timer_oc_parameter_struct timer_ocinitpara; timer_oc_parameter_struct timer_ocinitpara;
timer_parameter_struct timer_initpara; timer_parameter_struct timer_initpara;
rcu_periph_clock_enable(US_TRAN_RCU); rcu_periph_clock_enable(US_TRAN_RCU);
timer_deinit(US_TRAN_TIMER); timer_deinit(US_TRAN_TIMER);
timer_struct_para_init(&timer_initpara); timer_struct_para_init(&timer_initpara);
timer_initpara.prescaler = 0; timer_initpara.prescaler = 0;
timer_initpara.alignedmode = TIMER_COUNTER_EDGE; timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
timer_initpara.counterdirection = TIMER_COUNTER_UP; timer_initpara.counterdirection = TIMER_COUNTER_UP;
timer_initpara.period = 239; timer_initpara.period = 239;
timer_initpara.clockdivision = TIMER_CKDIV_DIV1; timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
timer_init(US_TRAN_TIMER, &timer_initpara); timer_init(US_TRAN_TIMER, &timer_initpara);
timer_channel_output_struct_para_init(&timer_ocinitpara); timer_channel_output_struct_para_init(&timer_ocinitpara);
timer_ocinitpara.outputstate =TIMER_CCX_ENABLE; timer_ocinitpara.outputstate = TIMER_CCX_ENABLE;
timer_ocinitpara.outputnstate =TIMER_CCXN_DISABLE; timer_ocinitpara.outputnstate = TIMER_CCXN_DISABLE;
timer_ocinitpara.ocpolarity =TIMER_OC_POLARITY_HIGH; timer_ocinitpara.ocpolarity = TIMER_OC_POLARITY_HIGH;
timer_ocinitpara.ocnpolarity =TIMER_OCN_POLARITY_HIGH; timer_ocinitpara.ocnpolarity = TIMER_OCN_POLARITY_HIGH;
timer_ocinitpara.ocidlestate =TIMER_OC_IDLE_STATE_LOW; timer_ocinitpara.ocidlestate = TIMER_OC_IDLE_STATE_LOW;
timer_ocinitpara.ocnidlestate =TIMER_OCN_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_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_pulse_value_config(US_TRAN_TIMER, US_TRAN_CH, 120);
@ -89,13 +92,15 @@ void ultrasonic_config(void) {
timer_interrupt_enable(US_TRAN_TIMER, TIMER_INT_UP); timer_interrupt_enable(US_TRAN_TIMER, TIMER_INT_UP);
} }
void ultrasonic_transmit_config(void) { void UltraSonic_Transmit_Config(void)
{
led_config(); led_config();
usart_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; uint8_t current_cycle = 0;
timer_channel_output_pulse_value_config(US_TRAN_TIMER, US_TRAN_CH, 120); timer_channel_output_pulse_value_config(US_TRAN_TIMER, US_TRAN_CH, 120);
@ -108,7 +113,7 @@ void ultrasonic_pwm_out_cycles(const uint8_t cycles) {
{ {
while (!timer_interrupt_flag_get(US_TRAN_TIMER, TIMER_INT_FLAG_UP)); while (!timer_interrupt_flag_get(US_TRAN_TIMER, TIMER_INT_FLAG_UP));
timer_interrupt_flag_clear(US_TRAN_TIMER, TIMER_INT_FLAG_UP); timer_interrupt_flag_clear(US_TRAN_TIMER, TIMER_INT_FLAG_UP);
current_cycle ++; current_cycle++;
} }
// delay_nop(); // delay_nop();
timer_disable(US_TRAN_TIMER); timer_disable(US_TRAN_TIMER);
@ -118,18 +123,19 @@ 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); rcu_periph_clock_enable(US_TRAN_DELAY_RCU);
timer_deinit(US_TRAN_DELAY_TIMER); timer_deinit(US_TRAN_DELAY_TIMER);
timer_parameter_struct timer_initpara; timer_parameter_struct timer_initpara;
timer_struct_para_init(&timer_initpara); timer_struct_para_init(&timer_initpara);
timer_initpara.prescaler =71; timer_initpara.prescaler = 71;
timer_initpara.alignedmode =TIMER_COUNTER_EDGE; timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
timer_initpara.counterdirection =TIMER_COUNTER_UP; timer_initpara.counterdirection = TIMER_COUNTER_UP;
timer_initpara.period =micro_second - 1; timer_initpara.period = micro_second - 1;
timer_initpara.clockdivision =TIMER_CKDIV_DIV1; timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
timer_initpara.repetitioncounter =0; timer_initpara.repetitioncounter = 0;
timer_init(US_TRAN_DELAY_TIMER, &timer_initpara); timer_init(US_TRAN_DELAY_TIMER, &timer_initpara);
timer_auto_reload_shadow_enable(US_TRAN_DELAY_TIMER); timer_auto_reload_shadow_enable(US_TRAN_DELAY_TIMER);
@ -137,7 +143,8 @@ void ultrasonic_transmit_delay(const uint16_t micro_second) {
nvic_irq_enable(TIMER15_IRQn, 1U); 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_GPIO_RCU);
rcu_periph_clock_enable(US_FB_EXTI_RCU); rcu_periph_clock_enable(US_FB_EXTI_RCU);
@ -151,18 +158,19 @@ void receive_exti_config(void) {
// exti_interrupt_enable(EXTI_0); // exti_interrupt_enable(EXTI_0);
} }
void ultrasonic_echo_timer_config(void) { void UltraSonic_EchoTimer_Config(void)
{
rcu_periph_clock_enable(US_ECHO_RCU); rcu_periph_clock_enable(US_ECHO_RCU);
timer_deinit(US_ECHO_TIMER); timer_deinit(US_ECHO_TIMER);
timer_parameter_struct timer_initpara; timer_parameter_struct timer_initpara;
timer_struct_para_init(&timer_initpara); timer_struct_para_init(&timer_initpara);
timer_initpara.prescaler =71; timer_initpara.prescaler = 71;
timer_initpara.alignedmode =TIMER_COUNTER_EDGE; timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
timer_initpara.counterdirection =TIMER_COUNTER_UP; timer_initpara.counterdirection = TIMER_COUNTER_UP;
timer_initpara.period =59999; timer_initpara.period = 59999;
timer_initpara.clockdivision =TIMER_CKDIV_DIV1; timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
timer_initpara.repetitioncounter =0; timer_initpara.repetitioncounter = 0;
timer_init(US_ECHO_TIMER, &timer_initpara); timer_init(US_ECHO_TIMER, &timer_initpara);
timer_ic_parameter_struct timer_icinitpara; timer_ic_parameter_struct timer_icinitpara;
@ -174,13 +182,15 @@ void ultrasonic_echo_timer_config(void) {
timer_input_capture_config(US_ECHO_TIMER, US_ECHO_CH, &timer_icinitpara); 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_Transmit_Delay(TIME_CORRECTION_US);
ultrasonic_echo_timer_config(); 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; uint16_t distace = (TIME_CORRECTION_US + us_value) * 17;
/* /*
* (TIME_CORRECTION_US + us_value) * 340 m/s * (TIME_CORRECTION_US + us_value) * 340 m/s