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

Compare commits

base: hulk:V0.1.1
Branches Tags
hulk:main hulk:dev hulk:US&IR hulk:inputCaptureEXP
hulk:V0.0.13 hulk:V0.1.1
..
compare: hulk:d5814ddd62a83f8fb15bce785a636e3e35a3c3d4
Branches Tags
hulk:dev hulk:main hulk:US&IR hulk:inputCaptureEXP
hulk:V0.0.13 hulk:V0.1.1

4 Commits
V0.1.1 ... d5814ddd62

Author SHA1 Message Date
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
10 changed files with 1192 additions and 54 deletions
Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -19,6 +19,8 @@ set(TARGET_C_SRC
${CMAKE_SOURCE_DIR}/src/gd32e23x_it.c ${CMAKE_SOURCE_DIR}/src/gd32e23x_it.c
${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/gd32e23x_hw_i2c.c
) )
add_executable(xlsw_3dp_ultrasonic_300K ${TARGET_C_SRC}) add_executable(xlsw_3dp_ultrasonic_300K ${TARGET_C_SRC})

116
inc/gd32e23x_hw_i2c.h Normal file
View File

@@ -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 */

11
inc/mlx90614.h Normal file
View File

@@ -0,0 +1,11 @@
//
// Created by dell on 24-9-26.
//
#ifndef MLX90614_H
#define MLX90614_H
void i2c_config(void);
int read_ir_mlx90614(void);
#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 */

12
inc/ultrasonic_driver.h
View File

@@ -11,11 +11,11 @@
// #define POWER_SUPPLY_24V // #define POWER_SUPPLY_24V
#ifdef POWER_SUPPLY_12V #ifdef POWER_SUPPLY_12V
#define TIME_CORRECTION_US 250 #define TIME_CORRECTION_US 250
#define CAPTURE_VALUE_MAX 515 #define CAPTURE_VALUE_MAX 515
#elif defined(POWER_SUPPLY_24V) #elif defined(POWER_SUPPLY_24V)
#define TIME_CORRECTION_US 230 #define TIME_CORRECTION_US 230
#define CAPTURE_VALUE_MAX 550 #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
@@ -67,9 +67,9 @@ void ultrasonic_config(void);
void ultrasonic_transmit_config(void); void ultrasonic_transmit_config(void);
void ultrasonic_pwm_out_cycles(const uint8_t cycles); 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);
void recevice_exti_config(void); void receive_exti_config(void);
void ultrasonic_echo_timer_config(void); void ultrasonic_echo_timer_config(void);
void ultrasonic_recevice_config(void); void ultrasonic_receive_config(void);
uint16_t calculate_distance(uint32_t us_value); uint16_t calculate_distance(uint32_t us_value);
#endif //ULTRASONIC_DRIVER_H #endif //ULTRASONIC_DRIVER_H

864
src/gd32e23x_hw_i2c.c Normal file
View File

@@ -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;
}

12
src/main.c
View File

@@ -11,6 +11,7 @@
#include "gd32e23x_libopt.h" #include "gd32e23x_libopt.h"
#include "ultrasonic_driver.h" #include "ultrasonic_driver.h"
#include "mlx90614.h"
extern uint32_t capture_value; extern uint32_t capture_value;
uint16_t distance_uint16; uint16_t distance_uint16;
@@ -27,11 +28,11 @@ int main(void)
systick_config(); systick_config();
/* configure ultrasonic board hardware */ /* configure ultrasonic board hardware */
ultrasonic_transmit_config(); ultrasonic_transmit_config();
ultrasonic_recevice_config(); ultrasonic_receive_config();
/* ---------- debug start ---------- */ /* ---------- debug start ---------- */
i2c_config();
/* ---------- debug end ---------- */ /* ---------- debug end ---------- */
@@ -42,7 +43,7 @@ int main(void)
delay_ms(2000); delay_ms(2000);
while(1) while (1)
{ {
delay_ms(ULTRASONIC_TRAN_US); delay_ms(ULTRASONIC_TRAN_US);
@@ -58,11 +59,12 @@ int main(void)
} }
/* 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;
} }

133
src/mlx90614.c Normal file
View File

@@ -0,0 +1,133 @@
//
// Created by dell on 24-9-26.
//
#include "mlx90614.h"
#include "gd32e23x.h"
#include "systick.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);
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;
}

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();
} }

92
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_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_config();
} }
void ultrasonic_pwm_out_cycles(const uint8_t cycles) { void ultrasonic_pwm_out_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 recevice_exti_config(void) { void receive_exti_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 recevice_exti_config(void) {
// exti_interrupt_enable(EXTI_0); // exti_interrupt_enable(EXTI_0);
} }
void ultrasonic_echo_timer_config(void) { void ultrasonic_echo_timer_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_recevice_config(void) { void ultrasonic_receive_config(void)
{
ultrasonic_transmit_delay(TIME_CORRECTION_US); ultrasonic_transmit_delay(TIME_CORRECTION_US);
recevice_exti_config(); receive_exti_config();
ultrasonic_echo_timer_config(); ultrasonic_echo_timer_config();
} }
uint16_t calculate_distance(uint32_t us_value) { uint16_t calculate_distance(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