From 7eeae6e673ca14fadff4fdb739428d855f606832 Mon Sep 17 00:00:00 2001 From: esea_info Date: Tue, 24 Oct 2023 15:25:30 +0800 Subject: [PATCH] bsp_spi --- base/Src/delay_port.c | 136 +++++++ base/Src/interrupt_port.c | 176 +++++++++ bsp/Inc/bsp_i2c_soft.h | 210 +++++------ bsp/Inc/bsp_spi_soft.h | 115 ++++++ bsp/Src/bsp_i2c_soft.c | 729 ++++++++++---------------------------- bsp/Src/bsp_spi_soft.c | 193 ++++++++++ device/Inc/eeprom.h | 113 +++--- device/Src/eeprom.c | 358 +++++++++++-------- 8 files changed, 1167 insertions(+), 863 deletions(-) create mode 100644 base/Src/delay_port.c create mode 100644 base/Src/interrupt_port.c create mode 100644 bsp/Inc/bsp_spi_soft.h create mode 100644 bsp/Src/bsp_spi_soft.c diff --git a/base/Src/delay_port.c b/base/Src/delay_port.c new file mode 100644 index 0000000..efcc75a --- /dev/null +++ b/base/Src/delay_port.c @@ -0,0 +1,136 @@ +#include "FreeRTOS.h" +#include "task.h" +#include "main.h" +#include "cmsis_os.h" +#include "tim.h" + +extern void delay_us(uint16_t nus); + +// HAL_RCC_GetSysClockFreq(void) + +typedef enum{ + DELAY_DEFAULT, + DELAY_SYSTICK, + DELAY_SYSTICK_COMPLEX, + DELAY_TIMER, + +}DELAY_US_TypeDef; +// SystemCoreClock + +TIM_HandleTypeDef *Delay_TIM_hanle = NULL; + +#define DELAY_US_TYPE DELAY_DEFAULT + + +void delay_us(uint16_t nus) +{ +#if DELAY_US_TYPE == DELAY_DEFAULT + uint32_t cnt = nus * (SystemCoreClock/8000000); + while(cnt--); +#endif + +#if DELAY_US_TYPE == DELAY_TIMER + + __HAL_TIM_SET_COUNTER(&htim10, 0); // set the counter value a 0 + __HAL_TIM_ENABLE(&htim10); // start the counter + // wait for the counter to reach the us input in the parameter + while (__HAL_TIM_GET_COUNTER(&htim10) < nus); + __HAL_TIM_DISABLE(&htim10); // stop the counter + +#endif + +#if DELAY_US_TYPE == DELAY_SYSTICK + SysTick->LOAD = (nus * (SystemCoreClock/8000000))-1; + SysTick->VAL = 0; + SysTick->CTRL = 0; + SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk; + while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); + SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; + +#endif + +#if DELAY_US_TYPE == DELAY_SYSTICK_COMPLEX + + // 暂停系统，实现微秒延时 + // 保存sysTick的状态 + uint32_t val_temp=SysTick->VAL; + uint32_t load_temp=SysTick->LOAD; + uint16_t ctrl_temp=SysTick->CTRL; + + /*SysTick状态重新设置，用于延时（系统暂停）*/ + // SysTick->LOAD = 9 * us; // 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数 + SysTick->LOAD = (nus * HAL_RCC_GetSysClockFreq()/1000000) - 1; // 设置定时器重装值,168MHz 8分频后21HMz，即一微秒记21个数 + SysTick->VAL = 0x00; // 清空当前计数值,清空后会自动装入重载值 + SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器 + while (!(SysTick->CTRL & 0x00010000));// 等待计数到0 + + /*延时结束后恢复之前的状态，系统继续运行*/ + SysTick->LOAD = load_temp; + SysTick->VAL = val_temp; + SysTick->CTRL = ctrl_temp; + //SysTick->CTRL = 0x00000000; // 关闭定时器 +#endif + +} + + +// #if DELAY_US_TYPE == DELAY_TIMER +// void delay_us(uint16_t nus) +// { +// __HAL_TIM_SET_COUNTER(&htim10, 0); // set the counter value a 0 +// __HAL_TIM_ENABLE(&htim10); // start the counter +// // wait for the counter to reach the us input in the parameter +// while (__HAL_TIM_GET_COUNTER(&htim10) < nus); +// __HAL_TIM_DISABLE(&htim10); // stop the counter +// } +// #endif + +// #if DELAY_US_TYPE == DELAY_SYSTICK_COMPLEX +// void delay_us(uint16_t nus) +// { +// // // 暂停系统，实现微秒延时 +// // // 保存sysTick的状态 +// // uint32_t val_temp=SysTick->VAL; +// // uint32_t load_temp=SysTick->LOAD; +// // uint16_t ctrl_temp=SysTick->CTRL; + +// // /*SysTick状态重新设置，用于延时（系统暂停）*/ +// // SysTick->LOAD = 9 * us; // 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数 +// // SysTick->VAL = 0x00; // 清空当前计数值,清空后会自动装入重载值 +// // SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器 +// // while (!(SysTick->CTRL & 0x00010000));// 等待计数到0 + +// // /*延时结束后恢复之前的状态，系统继续运行*/ +// // SysTick->LOAD = load_temp; +// // SysTick->VAL = val_temp; +// // SysTick->CTRL = ctrl_temp; +// // //SysTick->CTRL = 0x00000000; // 关闭定时器 +// } + + +// #endif + +// #if DELAY_US_TYPE == DELAY_TIMER +// void delay_us(uint16_t nus) +// { +// // // 暂停系统，实现微秒延时 +// // // 保存sysTick的状态 +// // uint32_t val_temp=SysTick->VAL; +// // uint32_t load_temp=SysTick->LOAD; +// // uint16_t ctrl_temp=SysTick->CTRL; + +// // /*SysTick状态重新设置，用于延时（系统暂停）*/ +// // SysTick->LOAD = 9 * us; // 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数 +// // SysTick->VAL = 0x00; // 清空当前计数值,清空后会自动装入重载值 +// // SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器 +// // while (!(SysTick->CTRL & 0x00010000));// 等待计数到0 + +// // /*延时结束后恢复之前的状态，系统继续运行*/ +// // SysTick->LOAD = load_temp; +// // SysTick->VAL = val_temp; +// // SysTick->CTRL = ctrl_temp; +// // //SysTick->CTRL = 0x00000000; // 关闭定时器 +// } + + +// #endif \ No newline at end of file diff --git a/base/Src/interrupt_port.c b/base/Src/interrupt_port.c new file mode 100644 index 0000000..481b67f --- /dev/null +++ b/base/Src/interrupt_port.c @@ -0,0 +1,176 @@ + +#include "main.h" +#include "cmsis_os.h" +#include "usart.h" +#include "tim.h" +#include "bsp_uart.h" +#include "bsp_i2c.h" + +#include "elog.h" + +#include "base.h" + +// #include "PH.h" +// #include "temperature.h" + +#if 1 + +// #define huart3_helper ph_uart_helper +#define huart3_helper temp_uart_helper +#define hi2c1_helper ads1115_i2c_helper + +extern osSemaphoreId_t elog_dma_lockHandle; + + +void USART1_IRQHandler(void) +{ + if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TC) != RESET) + { + osSemaphoreRelease(elog_dma_lockHandle); + huart1.gState = HAL_UART_STATE_READY; + __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TC); + } + HAL_UART_IRQHandler(&huart1); +} + +void USART3_IRQHandler(void) +{ + + if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != RESET) + { + log_i(" usart 3 it tc ... "); + huart3.gState = HAL_UART_STATE_READY; + // max3160_485_receive_mode(); + // TODO 回调函数，带obj + UART_HELPER_Trans_TxCplt_Callback( huart3_helper ); + + __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC); + } + + // if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE) != RESET) + // { + // log_i( " usart3 it rxne...."); + // __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC); + // } + + if (__HAL_UART_GET_FLAG( &huart3, UART_FLAG_IDLE ) != RESET){ + log_i(" usart 3 it idle ... "); + uint16_t count = __HAL_DMA_GET_COUNTER( huart3.hdmarx ); + // // 判断是否有数据 count 为剩余未接收的字节数 + if (huart3_helper->rcv_size != count) + { + UART_HELPER_RCV_IDLE_Callback( huart3_helper , (huart3_helper->rcv_size-count)); + } + __HAL_UART_CLEAR_IDLEFLAG( &huart3 ); + } + + + HAL_UART_IRQHandler(&huart3); +} + +void USART6_IRQHandler(void) +{ + if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_TC) != RESET) + { + huart6.gState = HAL_UART_STATE_READY; + + log_i(" usart 6 it ... "); + __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_TC); + } + if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_RXNE) != RESET) + { + log_i( " huart6 it...."); + __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_TC); + } + HAL_UART_IRQHandler(&huart6); +} + +void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) +{ + + if (huart->Instance == huart3.Instance) + { + log_i("....huart3 rx callback.... " ); + UART_HELPER_RCV_Cplt_Callback( huart3_helper ); + __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE); + } +} + +// void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) +// { + +// if (huart->Instance == huart3.Instance) +// { +// /* 拷贝数据 到菜单 */ +// log_i("huart3 idle -> ****** HAL_UARTEx_RxEventCallback "); +// __HAL_UART_CLEAR_IDLEFLAG(&huart3); +// } +// } + +// void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) +// { +// // if (huart->Instance == huart3.Instance) +// // { +// // // max3160_485_receive_mode(); +// // // huart3.gState = HAL_UART_STATE_READY; +// // __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC); +// // } +// } + + +/******************************* I2C CallBack *********************************/ +void I2C1_EV_IRQHandler(void) +{ + HAL_I2C_EV_IRQHandler(&hi2c1); +} +void I2C1_ER_IRQHandler(void) +{ + HAL_I2C_ER_IRQHandler(&hi2c1); +} + +void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c) +{ + log_i( " HAL_I2C_Mem TxCpltCallback ------------------- "); + if (hi2c == &hi2c1) + { + log_i( " HAL_I2C_Mem TxCpltCallback --- hi2c1 ---------------- "); + I2C_HELPER_Trans_TxCplt_Callback(hi2c1_helper); + } +} + +void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c) +{ + log_i( " HAL_I2C_Mem RxCpltCallback ------------------- "); + { + log_i( " HAL_I2C_Mem RxCpltCallback --- hi2c1 ---------------- "); + I2C_HELPER_Trans_TxCplt_Callback(hi2c1_helper); + } +} + +void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) +{ + log_i( " i2c master send cplt ------------------- "); +} + +void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c) +{ + log_i( " i2c master rx cplt ------------------- "); +} + +void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) +{ + log_i( " HAL_I2C_ErrorCallback ------------------- "); +} +#endif + + +void TIM1_UP_TIM10_IRQHandler(void) +{ + /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 0 */ + + /* USER CODE END TIM1_UP_TIM10_IRQn 0 */ + HAL_TIM_IRQHandler(&htim10); + /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 1 */ + + /* USER CODE END TIM1_UP_TIM10_IRQn 1 */ +} \ No newline at end of file diff --git a/bsp/Inc/bsp_i2c_soft.h b/bsp/Inc/bsp_i2c_soft.h index 216172f..0b95059 100644 --- a/bsp/Inc/bsp_i2c_soft.h +++ b/bsp/Inc/bsp_i2c_soft.h @@ -1,142 +1,126 @@ #ifndef __BSP_I2C_SOFT_H #define __BSP_I2C_SOFT_H - - +#include "stm32f4xx_hal.h" #include "main.h" -#include "stm32f4xx.h" - - - -// //使用IIC1 PB6 -> SCL, PB7 -> SDA - -#define SCL_PORT GPIOB -#define SCL_PIN GPIO_PIN_6 -#define SDA_PORT GPIOB -#define SDA_PIN GPIO_PIN_7 - -// #define SDA_IN() { SDA_PORT->MODER &= ~(3 << 1 * 2); SDA_PORT->MODER = (0 << 1 * 2); } //PC1 1*2, -// #define SDA_OUT() { SDA_PORT->MODER &= ~(3 << 1 * 2); SDA_PORT->MODER = (1 << 1 * 2); } +// #include "sys.h" -#define SDA_IN() {GPIOB->MODER &= ~(3<<(7*2)); GPIOB->MODER |= 0<<7*2;} //PB7输入模式 -#define SDA_OUT() {GPIOB->MODER &= ~(3<<(7*2)); GPIOB->MODER |= 1<<7*2;} //PB7输出模式 - - -//IO操作函数 -#define i2c_scl_low() HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET) -#define i2c_scl_high() HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET) - -#define i2c_sda_low() HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET) -#define i2c_sda_high() HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET) - -#define i2c_read_sda() HAL_GPIO_ReadPin( SDA_PORT, SDA_PIN ) - -extern uint32_t delay1us; +// #define SCL_GPIO_PORT GPIOB +// #define SCL_PIN GPIO_PIN_6 +// #define SDA_GPIO_PORT GPIOB +// #define SDA_PIN GPIO_PIN_7 + + +typedef enum { + IIC_OK = 0x00, //IIC工作正常 + IIC_WAIT_ACK_ERR = 0x01, //slave设备返回ACK错误 + IIC_WRITE_ERR = 0x02, //向slave设备写入错误 + IIC_READ_ERR = 0x04 //从slave设备读取错误 +} IIC_STATUS; + +typedef struct +{ + GPIO_TypeDef *scl_port; //定义IIC时钟使用的端口 + uint16_t scl_pin; //定义IIC时钟使用的PIN脚 + GPIO_TypeDef *sda_port; //定义IIC数据使用的端口 + uint16_t sda_pin; //定义IIC数据使用的PIN脚 + uint8_t sda_pin_num; //定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定 + uint8_t addr; //器件地址 + uint32_t delaytick; //定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定 +}IIC_SOFT_TypeDef; -void delay_1us(uint32_t delay_1us); +//IO方向设置 +#define SDA_IN() {SDA_GPIO_PORT->MODER&=~(3<<(7*2));SDA_GPIO_PORT->MODER|=0<<7*2;} //PB7输入模式 +#define SDA_OUT() {SDA_GPIO_PORT->MODER&=~(3<<(7*2));SDA_GPIO_PORT->MODER|=1<<7*2;} //PB7输出模式 -void analog_i2c_delay(void); -void bsp_analog_i2c_init(void); +#define GPIO_WRITE_PIN(PORT,PIN,VALUE) HAL_GPIO_WritePin(PORT,PIN,(VALUE)?GPIO_PIN_SET:GPIO_PIN_RESET) +#define GPIO_READ_PIN(PORT,PIN) HAL_GPIO_ReadPin(PORT,PIN) -void bsp_analog_i2c_start(void); -void bsp_analog_i2c_stop(void); +//IIC所有操作函数 +// void IIC_Init( ); //初始化IIC的IO口 -uint8_t bsp_analog_i2c_wait_ack(void); +void IIC_Init(const IIC_SOFT_TypeDef *pSoftIIC); //初始化IIC的IO口 -void bsp_analog_i2c_ack(void); +int IIC_READ_SDA_Pin(const IIC_SOFT_TypeDef *pSoftIIC); +int IIC_SDA_Mode_In(const IIC_SOFT_TypeDef *pSoftIIC); +int IIC_SDA_Mode_Out(const IIC_SOFT_TypeDef *pSoftIIC); -void bsp_analog_i2c_nack(void); +void IIC_Start(const IIC_SOFT_TypeDef *pSoftIIC); //发送IIC开始信号 +void IIC_Stop(const IIC_SOFT_TypeDef *pSoftIIC); //发送IIC停止信号 +void IIC_Send_Byte(const IIC_SOFT_TypeDef *pSoftIIC,uint8_t txd); //IIC发送一个字节 +// uint8_t IIC_Read_Byte(unsigned char ack);//IIC读取一个字节 +uint8_t IIC_Read_Byte( const IIC_SOFT_TypeDef *pSoftIIC);//IIC读取一个字节 +uint8_t IIC_Wait_Ack(const IIC_SOFT_TypeDef *pSoftIIC); //IIC等待ACK信号 +void IIC_Ack(const IIC_SOFT_TypeDef *pSoftIIC); //IIC发送ACK信号 +void IIC_NAck(const IIC_SOFT_TypeDef *pSoftIIC); //IIC不发送ACK信号 -void bsp_analog_i2c_send_byte(uint8_t data); -uint8_t bsp_analog_i2c_read_byte(void); +uint8_t IIC_Read_Test(const IIC_SOFT_TypeDef *pSoftIIC, uint8_t reg_addr, uint8_t *buf, uint8_t len); +uint8_t IIC_Write_Test(const IIC_SOFT_TypeDef *pSoftIIC , uint8_t reg_addr, uint8_t *buf, uint8_t len); + +#endif +/* +时序 +// * @brief: I2C 开始,SCL为高电平的时候SDA产生一个下降沿信号 + +// _____ +// *SDA \_____________ +// * __________ +// *SCL \________ +// + + +// * @brief: I2C 停止,SCL为高电平的时候SDA产生一个上升沿信号 +// _______ +// *SDA __________/ +// * ____________ +// *SCL _____/ + +// * @brief: I2C 响应 +// ____ +// *SCL ______/ \______ +// * ____ _____ +// *SDA \_______/ +// +// * @brief: I2C 不响应 + +// ____ +// *SCL ______/ \______ +// * __________________ +// *SDA +// -// //使用IICX PB6 -> SCL, PB7 -> SDA -// #define SCL_PORT GPIOB -// #define SCL_PIN GPIO_PIN_6 -// #define SDA_PORT GPIOB -// #define SDA_PIN GPIO_PIN_7 + HAL_I2C_MspDeInit( &hi2c1 ); + uint8_t readout[256] = {0}; + uint8_t writein[1] = {0xFB}; -//IO方向设置 -// #define SDA_IN() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;} //PB7输入模式 -// #define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;} //PB7输出模式 - -// #define SDA_IN() {GPIOB->MODER &= ~(3<<(7*2)); GPIOB->MODER |= 0<<7*2;} //PB7输入模式 -// #define SDA_OUT() {GPIOB->MODER &= ~(3<<(7*2)); GPIOB->MODER |= 1<<7*2;} //PB7输出模式 - -// //IO操作 -// #define IIC_SCL PBout(6) //SCL -// #define IIC_SDA PBout(7) //SDA -// #define READ_SDA PBin(7) //输入SDA - -// //IIC所有操作函数 -// void IIC_Init(void); //初始化IIC的IO口 -// void IIC_Start(void); //发送IIC开始信号 -// void IIC_Stop(void); //发送IIC停止信号 -// void IIC_Send_Byte(uint8_t txd); //IIC发送一个字节 -// uint8_t IIC_Read_Byte(unsigned char ack);//IIC读取一个字节 -// uint8_t IIC_Wait_Ack(void); //IIC等待ACK信号 -// void IIC_Ack(void); //IIC发送ACK信号 -// void IIC_NAck(void); //IIC不发送ACK信号 + // IIC_Init( ); -// void IIC_Write_One_Byte(uint8_t daddr,uint8_t addr,uint8_t data); -// uint8_t IIC_Read_One_Byte(uint8_t daddr,uint8_t addr); + // IIC_Write_Test( 0xA0, 0, writein, 1 ); + // HAL_Delay( 200 ); -/* -//在AT24CXX指定地址读出一个数据 -//ReadAddr:开始读数的地址 -//返回值 :读到的数据 -u8 AT24CXX_ReadOneByte(u16 ReadAddr) -{ - u8 temp=0; - IIC_Start(); - if(EE_TYPE>AT24C16) - { - IIC_Send_Byte(0XA0); //发送写命令 - IIC_Wait_Ack(); - IIC_Send_Byte(ReadAddr>>8);//发送高地址 - }else IIC_Send_Byte(0XA0+((ReadAddr/256)<<1)); //发送器件地址0XA0,写数据 - IIC_Wait_Ack(); - IIC_Send_Byte(ReadAddr%256); //发送低地址 - IIC_Wait_Ack(); - IIC_Start(); - IIC_Send_Byte(0XA1); //进入接收模式 - IIC_Wait_Ack(); - temp=IIC_Read_Byte(0); - IIC_Stop();//产生一个停止条件 - return temp; -} -//在AT24CXX指定地址写入一个数据 -//WriteAddr :写入数据的目的地址 -//DataToWrite:要写入的数据 -void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite) -{ - IIC_Start(); - if(EE_TYPE>AT24C16) - { - IIC_Send_Byte(0XA0); //发送写命令 - IIC_Wait_Ack(); - IIC_Send_Byte(WriteAddr>>8);//发送高地址 - }else IIC_Send_Byte(0XA0+((WriteAddr/256)<<1)); //发送器件地址0XA0,写数据 - IIC_Wait_Ack(); - IIC_Send_Byte(WriteAddr%256); //发送低地址 - IIC_Wait_Ack(); - IIC_Send_Byte(DataToWrite); //发送字节 - IIC_Wait_Ack(); - IIC_Stop();//产生一个停止条件 - delay_ms(10); -} -*/ + // IIC_Read_Test( 0xA0, 0, readout, 1 ); + // log_i("iic test %02X .... ", *readout); + IIC_SOFT_TypeDef sIIC = { + GPIOB, GPIO_PIN_6, GPIOB, GPIO_PIN_7, + 7,0xA0,1, + }; + IIC_Init( &sIIC ); + + IIC_Write_Test( &sIIC,0xA0, 0, writein, 1 ); + HAL_Delay( 200 ); + IIC_Read_Test(&sIIC, 0xA0, 0, readout, 1 ); -#endif + log_i("iic test %02X .... ", *readout); +*/ \ No newline at end of file diff --git a/bsp/Inc/bsp_spi_soft.h b/bsp/Inc/bsp_spi_soft.h new file mode 100644 index 0000000..efb1a4f --- /dev/null +++ b/bsp/Inc/bsp_spi_soft.h @@ -0,0 +1,115 @@ +#ifndef __BSP_SPI_SOFT_H +#define __BSP_SPI_SOFT_H +#include "stm32f4xx_hal.h" +#include "main.h" +// #include "sys.h" + +// #define SCL_GPIO_PORT GPIOB +// #define SCL_PIN GPIO_PIN_6 +// #define SDA_GPIO_PORT GPIOB +// #define SDA_PIN GPIO_PIN_7 + + +typedef enum { + SPI_OK = 0x00, //IIC工作正常 + SPI_WAIT_ACK_ERR = 0x01, //slave设备返回ACK错误 + SPI_WRITE_ERR = 0x02, //向slave设备写入错误 + SPI_READ_ERR = 0x04 //从slave设备读取错误 +} SPI_STATUS; + +typedef struct +{ + GPIO_TypeDef *sclk_port; + uint16_t sclk_pin; + GPIO_TypeDef *mosi_port; + uint16_t mosi_pin; + GPIO_TypeDef *miso_port; + uint16_t miso_pin; + GPIO_TypeDef *cs_port; + uint16_t cs_pin; + uint8_t sda_pin_num; //定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定 + uint8_t addr; //器件地址 + uint32_t delaytick; //定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定 +}SPI_SOFT_TypeDef; + + + +#define CS_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_SET) +#define CS_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_RESET) +#define SCLK_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_SET) +#define SCLK_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET) +#define SDI_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_SET) +#define SDI_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_RESET) +#define SDO_R HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_1) + +#define SUCCESS 0 +#define FAILURE 1 + +void SPI_Init(const SPI_SOFT_TypeDef *pSoftSPI); +uint8_t WriteReg(uint32_t d); +uint8_t ReadReg(uint32_t d); + +#endif + + +/* +时序 +// * @brief: I2C 开始,SCL为高电平的时候SDA产生一个下降沿信号 + +// _____ +// *SDA \_____________ +// * __________ +// *SCL \________ +// + + +// * @brief: I2C 停止,SCL为高电平的时候SDA产生一个上升沿信号 +// _______ +// *SDA __________/ +// * ____________ +// *SCL _____/ + + +// * @brief: I2C 响应 +// ____ +// *SCL ______/ \______ +// * ____ _____ +// *SDA \_______/ +// + +// * @brief: I2C 不响应 + +// ____ +// *SCL ______/ \______ +// * __________________ +// *SDA +// + + + HAL_I2C_MspDeInit( &hi2c1 ); + uint8_t readout[256] = {0}; + uint8_t writein[1] = {0xFB}; + + // SPI_Init( ); + + // SPI_Write_Test( 0xA0, 0, writein, 1 ); + // HAL_Delay( 200 ); + + // SPI_Read_Test( 0xA0, 0, readout, 1 ); + + // log_i("iic test %02X .... ", *readout); + + SPI_SOFT_TypeDef sIIC = { + GPIOB, GPIO_PIN_6, GPIOB, GPIO_PIN_7, + 7,0xA0,1, + }; + SPI_Init( &sIIC ); + + SPI_Write_Test( &sIIC,0xA0, 0, writein, 1 ); + HAL_Delay( 200 ); + + SPI_Read_Test(&sIIC, 0xA0, 0, readout, 1 ); + + log_i("iic test %02X .... ", *readout); + +*/ \ No newline at end of file diff --git a/bsp/Src/bsp_i2c_soft.c b/bsp/Src/bsp_i2c_soft.c index c1cd912..feb9a04 100644 --- a/bsp/Src/bsp_i2c_soft.c +++ b/bsp/Src/bsp_i2c_soft.c @@ -1,583 +1,218 @@ #include "bsp_i2c_soft.h" - - -uint32_t delay1us; - -/** - * @brief: 1us延时 - * @param {uint32_t} delay_1us - * @return {*} - */ -// void delay_1us(uint32_t delay_1us) -// { -// HAL_TIM_Base_Start_IT( &htim3 ); -// delay1us = delay_1us; -// while (delay1us); -// HAL_TIM_Base_Stop_IT( &htim3 ); -// } - -void delay_1us(uint32_t delay_1us) -{ - uint16_t cnt = 0; - - while(delay_1us--) - { - for(cnt=168/5; cnt>0; cnt--); // TODO 168 - } -} - -// static void delay_us(uint32_t u_sec) -// { -// uint16_t cnt = 0; +#include "elog.h" +// #include "delay.h" -// while(u_sec--) -// { -// for(cnt=168/5; cnt>0; cnt--); -// } -// } - -/** - * @brief: IIC延时时间 - * @return {*} - */ -void analog_i2c_delay(void) -{ - delay_1us(2); -} - -/** - * @brief: 软件模拟I2C初始化 - * @return {*} - */ -void bsp_analog_i2c_init(void) -{ - GPIO_InitTypeDef GPIO_InitStruct = {0}; - - __HAL_RCC_GPIOD_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - - /*Configure GPIO pins : PD6 SCL */ - GPIO_InitStruct.Pin = SCL_PIN; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct); - - /*Configure GPIO pins : PC1 SDA */ - GPIO_InitStruct.Pin = SDA_PIN; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct); - - bsp_analog_i2c_stop(); -} - -/** - * @brief: I2C 开始,SCL为高电平的时候SDA产生一个下降沿信号 - * @return {*} - */ -void bsp_analog_i2c_start(void) +void IIC_Init(const IIC_SOFT_TypeDef *pSoftIIC ) { - /* _____ - *SDA \_____________ - * __________ - *SCL \________ - */ - i2c_sda_high(); - i2c_scl_high(); - analog_i2c_delay(); - i2c_sda_low(); - analog_i2c_delay(); - i2c_scl_low(); - analog_i2c_delay(); + GPIO_InitTypeDef GPIO_Initure; + + __HAL_RCC_GPIOB_CLK_ENABLE(); // 使能GPIOB时钟 + + //PB6 SCL PB7初始化设置 + GPIO_Initure.Pin = pSoftIIC->scl_pin ; + GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出 + GPIO_Initure.Pull = GPIO_PULLUP; // 上拉 + GPIO_Initure.Speed = GPIO_SPEED_FAST; // 快速 + HAL_GPIO_Init( pSoftIIC->scl_port, &GPIO_Initure ); + + // SDA PB7 初始化设置 + GPIO_Initure.Pin = pSoftIIC->sda_pin; + HAL_GPIO_Init( pSoftIIC->sda_port, &GPIO_Initure ); + + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); } -/** - * @brief: I2C 停止,SCL为高电平的时候SDA产生一个上升沿信号 - * @return {*} - */ -void bsp_analog_i2c_stop(void) -{ - /* _______ - *SDA __________/ - * ____________ - *SCL _____/ - */ - i2c_sda_low(); - i2c_scl_high(); - analog_i2c_delay(); - i2c_sda_high(); - analog_i2c_delay(); -} -/** - * @brief: I2C 等待响应 - * @return {*} - */ -uint8_t bsp_analog_i2c_wait_ack(void) +int IIC_READ_SDA_Pin(const IIC_SOFT_TypeDef *pSoftIIC) { - uint32_t timeout = 0; - - i2c_sda_high(); - SDA_IN(); - analog_i2c_delay(); - i2c_scl_high(); - analog_i2c_delay(); - while(i2c_read_sda()) - { - timeout++; - if(timeout > 2000) - { - return 1; - } - } - i2c_scl_low(); - analog_i2c_delay(); - return 0; + return HAL_GPIO_ReadPin(pSoftIIC->sda_port,pSoftIIC->sda_pin); } -/** - * @brief: I2C 响应 - * @return {*} - */ -void bsp_analog_i2c_ack(void) +int IIC_SDA_Mode_In(const IIC_SOFT_TypeDef *pSoftIIC) { - /* ____ - *SCL ______/ \______ - * ____ _____ - *SDA \_______/ - */ - i2c_sda_low(); - analog_i2c_delay(); - i2c_scl_high(); - analog_i2c_delay(); - i2c_scl_low(); - analog_i2c_delay(); - i2c_sda_high(); + // 取针脚号 pin6 的值为 2^6 + // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + pSoftIIC->sda_port->MODER&=~(3<<(pSoftIIC->sda_pin_num*2)); + pSoftIIC->sda_port->MODER|=0<sda_pin_num*2; } - -/** - * @brief: I2C 不响应 - * @return {*} - */ -void bsp_analog_i2c_nack(void) +int IIC_SDA_Mode_Out(const IIC_SOFT_TypeDef *pSoftIIC) { - /* ____ - *SCL ______/ \______ - * __________________ - *SDA - */ - i2c_sda_high(); - analog_i2c_delay(); - i2c_scl_high(); - analog_i2c_delay(); - i2c_scl_low(); - analog_i2c_delay(); + // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + pSoftIIC->sda_port->MODER&=~(3<<(pSoftIIC->sda_pin_num*2)); + pSoftIIC->sda_port->MODER|=1<sda_pin_num*2; } - -/** - * @brief: I2C 发送一个字节数据 - * @param {uint8_t} data - * @return {*} - */ -void bsp_analog_i2c_send_byte(uint8_t data) +//产生IIC起始信号 +void IIC_Start(const IIC_SOFT_TypeDef *pSoftIIC) { - uint8_t i; - - SDA_OUT(); - for(i = 0; i < 8; i++) - { - if(data & 0x80) - { - i2c_sda_high(); - } - else - { - i2c_sda_low(); - } - - analog_i2c_delay(); - i2c_scl_high(); - analog_i2c_delay(); - i2c_scl_low(); - if(i == 7) - { - i2c_sda_high(); - } - data <<= 1; - analog_i2c_delay(); - } -} - -/** - * @brief: I2C 读一个字节数据 - * @return {*} - */ -uint8_t bsp_analog_i2c_read_byte(void) + // SDA_OUT();//sda线输出 + IIC_SDA_Mode_Out( pSoftIIC); //sda线输出 + + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + delay_us(4); + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0); //START:when CLK is high,DATA change form high to low + delay_us(4); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//钳住I2C总线，准备发送或接收数据 +} + +//产生IIC停止信号 +void IIC_Stop(const IIC_SOFT_TypeDef *pSoftIIC) { - uint8_t i, data = 0; - - i2c_sda_high(); - SDA_IN(); - for(i = 0; i < 8; i++ ) - { - data <<= 1; - i2c_scl_high(); - analog_i2c_delay(); - if(i2c_read_sda()) - { - data++; - } - i2c_scl_low(); - analog_i2c_delay(); - } - - return data; + // SDA_OUT();//sda线输出 + IIC_SDA_Mode_Out( pSoftIIC); //sda线输出 + + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0);//STOP:when CLK is high DATA change form low to high + delay_us(4); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);//发送I2C总线结束信号 + delay_us(4); } - - -uint8_t bsp_i2c_test_write( uint8_t slave_addr, uint8_t reg_addr, uint8_t *buf, uint8_t len) +//等待应答信号到来 +//返回值：1，接收应答失败 +// 0，接收应答成功 +uint8_t IIC_Wait_Ack(const IIC_SOFT_TypeDef *pSoftIIC) { - bsp_analog_i2c_start(); - //发送器件地址+写命令 - bsp_analog_i2c_send_byte(slave_addr & 0xFE); - if(bsp_analog_i2c_wait_ack()) //等待应答 - { - bsp_analog_i2c_stop(); - return -1; - } - //发送写（起始）寄存器地址 - bsp_analog_i2c_send_byte(reg_addr); - if(bsp_analog_i2c_wait_ack()) //等待应答 - { - bsp_analog_i2c_stop(); - return -1; - } - //发送写数据 - for(int i=0; isda_port, pSoftIIC->sda_pin, 1);delay_us(1); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);delay_us(1); + while(IIC_READ_SDA_Pin(pSoftIIC)) + // while( READ_SDA() ) { - bsp_analog_i2c_send_byte(*buf++); - if(bsp_analog_i2c_wait_ack()) //等待应答 + ucErrTime++; + if(ucErrTime>250) { - bsp_analog_i2c_stop(); - return -1; + IIC_Stop(pSoftIIC); + return 1; } } - //停止位 - bsp_analog_i2c_stop(); -} + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//时钟输出0 + return 0; +} +//产生ACK应答 +void IIC_Ack(const IIC_SOFT_TypeDef *pSoftIIC) +{ + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); -uint8_t bsp_i2c_test_read(uint8_t slave_addr, uint8_t reg_addr, uint8_t *buf, uint8_t len) + // SDA_OUT();//sda线输出 + IIC_SDA_Mode_Out( pSoftIIC); //sda线输出 + + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); +} +//不产生ACK应答 +void IIC_NAck(const IIC_SOFT_TypeDef *pSoftIIC) { - //发送起始位 - bsp_analog_i2c_start(); - //发送器件地址+写命令 - bsp_analog_i2c_send_byte(slave_addr & 0xFE); - if(bsp_analog_i2c_wait_ack()) //等待应答 - { - bsp_analog_i2c_stop(); - return -1; - } - //发送写（起始）寄存器地址 - bsp_analog_i2c_send_byte(reg_addr); - if(bsp_analog_i2c_wait_ack()) //等待应答 - { - bsp_analog_i2c_stop(); - return -1; - } - //发送重复起始位 - bsp_analog_i2c_start(); - //发送器件地址+读命令 - bsp_analog_i2c_send_byte(slave_addr | 0x01); - if(bsp_analog_i2c_wait_ack()) //等待应答 - { - bsp_analog_i2c_stop(); - return -1; - } - //读取数据 - // for(int i=0; iscl_port, pSoftIIC->scl_pin, 0); + + // SDA_OUT();//sda线输出 + IIC_SDA_Mode_Out( pSoftIIC); //sda线输出 + + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); +} +//IIC发送一个字节 +//返回从机有无应答 +//1，有应答 +//0，无应答 +void IIC_Send_Byte(const IIC_SOFT_TypeDef *pSoftIIC,uint8_t txd) +{ + uint8_t t; + // SDA_OUT();//sda线输出 + IIC_SDA_Mode_Out( pSoftIIC); //sda线输出 + + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//拉低时钟开始数据传输 + for(t=0;t<8;t++) + { + // IIC_SDA=(txd&0x80)>>7; + // IIC_SDA( (txd&0x80)>>7); + GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, (txd&0x80)>>7 ); + txd<<=1; + delay_us(2); //对TEA5767这三个延时都是必须的 + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); + delay_us(2); + } +} + +uint8_t IIC_Read_Byte( const IIC_SOFT_TypeDef *pSoftIIC) +{ + unsigned char i,receive=0; - for(int i=0; iscl_port, pSoftIIC->scl_pin, 0); + delay_us(2); + GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + receive<<=1; + if(IIC_READ_SDA_Pin(pSoftIIC))receive++; + // if( READ_SDA() )receive++; + + delay_us(1); + } + + return receive; } + uint8_t IIC_Write_Test(const IIC_SOFT_TypeDef *pSoftIIC , uint8_t reg_addr, uint8_t *buf, uint8_t len) + { + IIC_Start(pSoftIIC); + IIC_Send_Byte(pSoftIIC,pSoftIIC->addr & 0xFE); + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; -// //IIC初始化 -// void IIC_Init(void) -// { -// GPIO_InitTypeDef GPIO_Initure; - -// __HAL_RCC_GPIOB_CLK_ENABLE(); //使能GPIOB时钟 - -// //PH4,5初始化设置 -// GPIO_Initure.Pin=GPIO_PIN_6|GPIO_PIN_7; -// GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP; //推挽输出 -// GPIO_Initure.Pull=GPIO_PULLUP; //上拉 -// GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速 -// HAL_GPIO_Init(GPIOB,&GPIO_Initure); - -// IIC_SDA=1; -// IIC_SCL=1; -// } + IIC_Send_Byte(pSoftIIC,reg_addr); + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; -// //产生IIC起始信号 -// void IIC_Start(void) -// { -// SDA_OUT(); //sda线输出 -// IIC_SDA=1; -// IIC_SCL=1; -// delay_us(4); -// IIC_SDA=0;//START:when CLK is high,DATA change form high to low -// delay_us(4); -// IIC_SCL=0;//钳住I2C总线，准备发送或接收数据 -// } -// //产生IIC停止信号 -// void IIC_Stop(void) -// { -// SDA_OUT();//sda线输出 -// IIC_SCL=0; -// IIC_SDA=0;//STOP:when CLK is high DATA change form low to high -// delay_us(4); -// IIC_SCL=1; -// IIC_SDA=1;//发送I2C总线结束信号 -// delay_us(4); -// } -// //等待应答信号到来 -// //返回值：1，接收应答失败 -// // 0，接收应答成功 -// uint8_t IIC_Wait_Ack(void) -// { -// uint8_t ucErrTime=0; -// SDA_IN(); //SDA设置为输入 -// IIC_SDA=1;delay_us(1); -// IIC_SCL=1;delay_us(1); -// while(READ_SDA) -// { -// ucErrTime++; -// if(ucErrTime>250) -// { -// IIC_Stop(); -// return 1; -// } -// } -// IIC_SCL=0;//时钟输出0 -// return 0; -// } -// //产生ACK应答 -// void IIC_Ack(void) -// { -// IIC_SCL=0; -// SDA_OUT(); -// IIC_SDA=0; -// delay_us(2); -// IIC_SCL=1; -// delay_us(2); -// IIC_SCL=0; -// } -// //不产生ACK应答 -// void IIC_NAck(void) -// { -// IIC_SCL=0; -// SDA_OUT(); -// IIC_SDA=1; -// delay_us(2); -// IIC_SCL=1; -// delay_us(2); -// IIC_SCL=0; -// } -// //IIC发送一个字节 -// //返回从机有无应答 -// //1，有应答 -// //0，无应答 -// void IIC_Send_Byte(uint8_t txd) -// { -// uint8_t t; -// SDA_OUT(); -// IIC_SCL=0;//拉低时钟开始数据传输 -// for(t=0;t<8;t++) -// { -// IIC_SDA=(txd&0x80)>>7; -// txd<<=1; -// delay_us(2); //对TEA5767这三个延时都是必须的 -// IIC_SCL=1; -// delay_us(2); -// IIC_SCL=0; -// delay_us(2); -// } -// } -// //读1个字节，ack=1时，发送ACK，ack=0，发送nACK -// uint8_t IIC_Read_Byte(unsigned char ack) -// { -// unsigned char i,receive=0; -// SDA_IN();//SDA设置为输入 -// for(i=0;i<8;i++ ) -// { -// IIC_SCL=0; -// delay_us(2); -// IIC_SCL=1; -// receive<<=1; -// if(READ_SDA)receive++; -// delay_us(1); -// } -// if (!ack) -// IIC_NAck();//发送nACK -// else -// IIC_Ack(); //发送ACK -// return receive; -// } + IIC_Send_Byte(pSoftIIC,*buf); + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; + IIC_Stop(pSoftIIC);//产生一个停止条件 + // HAL_Delay( 200 ); + // delay_us(6000); + return 0; +} +// 寄存器地址 8位置 +uint8_t IIC_Read_Test(const IIC_SOFT_TypeDef *pSoftIIC, uint8_t reg_addr, uint8_t *buf, uint8_t len) +{ + uint8_t temp=0; + IIC_Start(pSoftIIC); + + IIC_Send_Byte(pSoftIIC,pSoftIIC->addr & 0xFE); + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; + IIC_Send_Byte(pSoftIIC,reg_addr); + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; + IIC_Start(pSoftIIC); + IIC_Send_Byte(pSoftIIC,pSoftIIC->addr |0x01); //进入接收模式 + if(IIC_Wait_Ack(pSoftIIC)) { IIC_Stop(pSoftIIC); return -1;}; + for(int i=0; iscl_pin ; + // GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出 + // GPIO_Initure.Pull = GPIO_PULLUP; // 上拉 + // GPIO_Initure.Speed = GPIO_SPEED_FAST; // 快速 + // HAL_GPIO_Init( pSoftIIC->scl_port, &GPIO_Initure ); + + // // SDA PB7 初始化设置 + // GPIO_Initure.Pin = pSoftIIC->sda_pin; + // HAL_GPIO_Init( pSoftIIC->sda_port, &GPIO_Initure ); + + // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1); + // GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); + + + // RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); + // GPIO_InitTypeDef GPIO_InitStructure; + // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //457引脚配置为推挽输出 + // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5| GPIO_Pin_7;//457引脚配置为推挽输出 + // GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + // GPIO_Init(GPIOA, &GPIO_InitStructure); + + // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//pin6是MISO，对于STM32来说是输入，配置为上拉输入 + // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;//pin6是MISO，对于STM32来说是输入，配置为上拉输入 + // GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + // GPIO_Init(GPIOA, &GPIO_InitStructure); + + // //CS引脚初始化 + // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; + // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //推挽输出 + // GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + // GPIO_Init(GPIOC, &GPIO_InitStructure); + + // //SCK和MOSI引脚初始化 + // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_7; + // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //推挽输出 + // GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + // GPIO_Init(GPIOA, &GPIO_InitStructure); + + // //MISO引脚初始化 + // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; + // GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ; //浮空输入 + // GPIO_Init(GPIOA, &GPIO_InitStructure); +} + +/** + * @brief Set SDIO as the input mode + */ +void SDO_IN(void) +{ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + GPIO_InitStruct.Pin = GPIO_PIN_1; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_PULLUP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); +} +/** + * @brief Set SDIO as the output mode + */ +void SDO_OUT(void) +{ + GPIO_InitTypeDef GPIO_InitStruct; + GPIO_InitStruct.Pin = GPIO_PIN_1; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_PULLUP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); +} +/** + * @brief Send one byte by SPI bus + * + * @param u8_writedata + */ +void SPI_Write_OneByte(uint8_t u8_writedata) +{ + uint8_t i; + for (i = 0; i < 8; i++) + { + if (u8_writedata & 0x80) + SDI_H; + else + SDI_L; + SCLK_H; + u8_writedata <<= 1; + SCLK_L; + } +} +/** + * @brief Read one byte by SPI bus + * + * @return temp + */ +uint8_t SPI_Read_OneByte(void) +{ + uint8_t i; + uint8_t temp = 0; + for (i = 0; i < 8; i++) + { + temp <<= 1; + SCLK_H; + if (SDO_R) + temp |= 0x01; + else + temp &= ~0x01; + SCLK_L; + } + return temp; +} + +/** + * @brief Write a register + * + * @param d: {D2, D1, D0} + * @return SUCCESS + */ +uint8_t WriteReg(uint32_t d) +{ + uint8_t tx[3] = {(d >> 16) & 0xff, (d >> 8) & 0xff, d & 0xff}; + SDO_OUT(); + CS_L; + SPI_Write_OneByte(tx[0]); + SPI_Write_OneByte(tx[1]); + SPI_Write_OneByte(tx[2]); + CS_H; + SDI_L; + return SUCCESS; +} + +/** + * @brief Read a register + * @param d: {D2, D1, D0} + * @return data: The data be read in a register + */ +uint8_t ReadReg(uint32_t d) +{ + uint8_t tx[3] = {(d >> 16) & 0xff, (d >> 8) & 0xff, d & 0xff}; + uint8_t data; + // tx[0] = tx[0] | RF_DATA_READ_BIT; + // SDO_OUT(); + // CS_L; + // SPI_Write_OneByte(tx[0]); + // SPI_Write_OneByte(tx[1]); + // SDO_IN(); + // data = SPI_Read_OneByte(); + // CS_H; + // SDO_OUT(); + // SDI_L; + return data; +} + + +/* ，同步传输数据，比如在时钟的上升沿是写数据，那么在时钟的下降沿就是读数据 +static uint8_t W25QXX_SPI_ReadWriteByte(uint8_t TxData) +{ + int i = 0; + uint8_t RxData = 0; + W25QXX_SCK_L(); // 时钟拉低 + for(i = 7; i >= 0; i--) + { + W25QXX_SCK_L(); // 时钟拉低 ，发送1bit + if(TxData & (1 << i)) + { + W25QXX_MOSI_H(); + } + else + { + W25QXX_MOSI_L(); + } + delay_us(1); // 延时1微秒 + W25QXX_SCK_H(); // 拉高时钟读 1bit + RxData <<= 1; + RxData |= W25QXX_MISO_GET(); + delay_us(1); + } + W25QXX_SCK_L(); + return RxData; +} + + + + +*/ diff --git a/device/Inc/eeprom.h b/device/Inc/eeprom.h index 20d9864..d3d3187 100644 --- a/device/Inc/eeprom.h +++ b/device/Inc/eeprom.h @@ -6,15 +6,17 @@ * 一种设置size send_buf 实现 */ #include "main.h" -// #include "platform.h" -#include "i2c.h" -#include "i2c_helper.h" - -#include "FreeRTOSConfig.h" -#include "cmsis_os2.h" + +#include "FreeRTOS.h" +#include "task.h" +#include "main.h" +#include "cmsis_os.h" +#include "bsp_i2c.h" #include "elog.h" #define EEPROM_BYTE_DELAY_ENABLE 1 +#define EEPROM_WRITE_ADDRESS 0xA0 +#define EEPROM_READ_ADDRESS 0xA1 typedef enum { EEPROM_EVT_WRITE, @@ -57,80 +59,74 @@ typedef enum { // typedef void (*read_callback)(); // typedef void (*write_callback)(); -typedef struct -{ - I2C_HandleTypeDef *hi2c; - // I2CHelper_TypeDef *i2chelper; - EEPROM_MODEL_TypeDef model; // AT24C01 AT24C02 AT24C256 - EEPROM_MEM_ADDR_TypeDef mem_addr_type; // 1: 8bit 2: 16bit I2C_MEMADD_SIZE_8BIT I2C_MEMADD_SIZE_16BIT - // EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit; // 1: 7bit 2: 10bit - EEPROM_DEV_ADDR_TypeDef dev_addr; // 8bit 写地址 - uint8_t page_addr; - - volatile EEPROM_STATE_TypeDef state; - uint8_t write_delay_ms; // 5-8ms - uint32_t time_base; // 从系统获得一个systick的毫秒数 - - uint8_t mode; // polling 0 , it 1, dma 2 - uint8_t writeCplt; - uint8_t readCplt; - // 设置任务参数 发送一个 mem_addr++ send_buf++ size-- - uint8_t *send_buf; - uint16_t size; - uint16_t mem_addr; - uint8_t is_busy; - uint8_t error; +extern I2C_HELPER_TypeDef *eeprom_helper; - HAL_I2C_StateTypeDef stat; -}EEPROM_TypeDef; -extern EEPROM_TypeDef *eeprom; +typedef enum { + EEPROM_WORK_STATE_WAITING, + EEPROM_WORK_STATE_READY, + EEPROM_WORK_STATE_Writing, + EEPROM_WORK_STATE_WRITE_Waiting, + EEPROM_WORK_STATE_Reading, + EEPROM_WORK_STATE_ERROR, + EEPROM_WORK_STATE_STOP +}EEPROM_WORK_STATE_TypeDef; typedef struct { void (*init)(void); - void (*deinit)(void); void (*port)(void) ; + int (*test)(void); + EEPROM_MODEL_TypeDef model; // AT24C01 AT24C02 AT24C256 - EEPROM_MEM_ADDR_TypeDef mem_addr_type; - // EEPROM_MEM_ADDR_BIT_TypeDef data_addr_bit; + uint16_t mem_addr_size; EEPROM_DEV_ADDR_TypeDef dev_addr; uint8_t page_addr; + uint8_t write_delay_ms; + uint32_t size; + uint8_t *buf; + volatile EEPROM_WORK_STATE_TypeDef state; }My_EEPROM_TypeDef; + extern My_EEPROM_TypeDef my_eeprom; void Eeprom_Init( ); -void Eeprom_DeInit( ); + void Eeprom_Port( ); -int Eeprom_SET_I2CHelper( EEPROM_TypeDef *eeprom, I2CHelper_TypeDef *i2chelper ); -int Eeprom_SET_Device_Model( EEPROM_TypeDef *eeprom, EEPROM_MODEL_TypeDef model ); -int Eeprom_SET_Device_Addr( EEPROM_TypeDef *eeprom, uint8_t dev_addr ); -int Eeprom_SET_Mem_Addr ( EEPROM_TypeDef *eeprom, uint16_t mem_addr ); -int Eeprom_SET_Mem_Addr_Type( EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_TypeDef mem_addr_type ); -int Eeprom_SET_Mem_Addr_Bit_Type( EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit ); +void Eeprom_Task( ); +int Eeprom_Test( void ); + +int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size); -int Eeprom_SET_WorkMode( EEPROM_TypeDef *eeprom, I2C_HELPER_MODE_TypeDef mem_addr_type); -int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms); +// int Eeprom_SET_WorkMode( uint16_t mem_addr_type); +int Eeprom_SET_Device_Model(EEPROM_MODEL_TypeDef model); +int Eeprom_SET_Write_Delay_ms( uint8_t write_delay_ms); // int Eeprom_Transmit(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); // int Eeprom_Begin_Rcv(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); -int Eeprom_Read(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size ); -// int Eeprom_Write(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size ); +int Eeprom_Read( uint8_t * buf, uint16_t size ); +int Eeprom_Write( uint8_t * buf, uint16_t size ); -void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); +// void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); -int Eeprom_Test( ); -#ifdef EEPROM_BYTE_DELAY_ENABLE -int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); -#endif +// #ifdef EEPROM_BYTE_DELAY_ENABLE +// int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size); + +// int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size); + +// #endif #endif + + + /** + * * @brief 用非阻塞方法写 EEPROM 会写不进去--> 写数据到EEPROM,每个字节加5-8ms 延时 * 还是用阻塞的方法区写， 读可以考虑非阻塞 --> IT DMA * 不用 i2chelper 直接用hi2c, @@ -164,4 +160,17 @@ int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t osDelay(10); log_i( "buf2 %d %d ", buf2[0] , buf2[1]); - */ \ No newline at end of file + + uint8_t buf1[24] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09,0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09,0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09}; + uint8_t buf2[24] ={0}; + my_eeprom.buf = buf1; + my_eeprom.size = 24; + my_eeprom.state = EEPROM_WORK_STATE_Writing; + + while(my_eeprom.size != 0) { osDelay(2);}; + log_i("write ok...."); + + HAL_Delay(200); + my_eeprom.state = EEPROM_WORK_STATE_Reading; + */ + \ No newline at end of file diff --git a/device/Src/eeprom.c b/device/Src/eeprom.c index e6d966d..9f2bbdf 100644 --- a/device/Src/eeprom.c +++ b/device/Src/eeprom.c @@ -8,170 +8,241 @@ * @copyright ESEA (c) 2020 * */ +#include "eeprom.h" -// osEventFlagsId_t eepromEventHandle; -// const osEventFlagsAttr_t eepromEvent_attributes = { -// .name = "eepromEvent" -// }; +osThreadId_t eepromTaskHandle; +const osThreadAttr_t eepromTask_attributes = { + .name = "eepromTask", + .stack_size = 256 * 4, + .priority = (osPriority_t) osPriorityNormal, +}; +uint8_t eeprom_read_buf[1024] ={0}; -#include "eeprom.h" #define pEepromI2C &hi2c1 -EEPROM_TypeDef *eeprom; + +I2C_HELPER_TypeDef *eeprom_helper; + +// EEPROM_TypeDef *eeprom; My_EEPROM_TypeDef my_eeprom= { - Eeprom_Init, - Eeprom_DeInit, - Eeprom_Port, + Eeprom_Init, Eeprom_Port, Eeprom_Test, + AT24C02, EEPROM_MEM_ADDR_TYPE_Bit8, - // EEPROM_MEM_ADDR_BIT_10, 0xA0, // 7+1 bit or 10 + 1 bit, EEPROM 8bit , write A0 , read A1 0, + 8, + 0,NULL, + 0, }; void Eeprom_Init() { - eeprom = (EEPROM_TypeDef *)malloc(sizeof(EEPROM_TypeDef)); - if ( eeprom == NULL ) - { - return NULL; - } - eeprom->hi2c = pEepromI2C; - // eeprom->i2chelper = I2CHelper_Init( ); - // I2CHelper_Set_Hi2c( eeprom->i2chelper, pEepromI2C ); - Eeprom_SET_Device_Model( eeprom, my_eeprom.model ); - Eeprom_SET_Device_Addr( eeprom, my_eeprom.dev_addr ); - Eeprom_SET_Mem_Addr_Type( eeprom, my_eeprom.mem_addr_type ); - - eeprom->writeCplt = 0; - eeprom->readCplt = 0; - eeprom->size = 0; - eeprom->is_busy = 0; - eeprom->time_base = 0; - eeprom->write_delay_ms = 5; - eeprom->mem_addr = 0; + + eeprom_helper = I2C_HELPER_Init( ); + I2C_HELPER_Set_Hi2c( eeprom_helper, pEepromI2C ); + I2C_HELPER_Set_dev_addr( eeprom_helper, EEPROM_WRITE_ADDRESS); + I2C_HELPER_Set_mem_addr_size( eeprom_helper, I2C_MEMADD_SIZE_8BIT ); //I2C_MEMADD_SIZE_8BIT + // I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, uint16_t mem_addr); + + // I2C_HELPER_Setup_Trans_mode( eeprom_helper, I2C_Trans_IT ); + + // 设置回调 + I2C_HELPER_Set_Callback( eeprom_helper, (void *)&my_eeprom, (i2c_callback_fun) Eeprom_callback); + return 0; } -void Eeprom_DeInit( ) + + +void Eeprom_Port( ) { - free(eeprom); + eepromTaskHandle = osThreadNew(Eeprom_Task, NULL, &eepromTask_attributes ); } -void Eeprom_Port( ) +void Eeprom_Task( ) { - uint32_t i; + uint64_t ticks; + int count = 0; int st; for (;;) { - /* 判断size, size 大于零才开始工作*/ - if (eeprom->size == 0) - { - eeprom->send_buf = NULL; - eeprom->is_busy == 0; - // log_i("eeprom port func..."); - osDelay(100); - }; - - /* size> 0, 写入一个数据 */ - if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 0 ) + switch (my_eeprom.state) { - eeprom->time_base = osKernelGetTickCount( ); - eeprom->is_busy = 1; - // log_i("eeporm write ... "); - st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, eeprom->send_buf, 1, eeprom->write_delay_ms); - if (st != HAL_OK) { - log_e(" Eeprom Write error"); - eeprom->size = 0; - eeprom->send_buf = NULL; - eeprom->is_busy = 0; - break; + case EEPROM_WORK_STATE_WAITING: + log_d( " eeporm waiting ********** " ); + osDelay(20); + break; + case EEPROM_WORK_STATE_READY: + // log_d( " eeporm ready ********** " ); + osDelay(1); + break; + case EEPROM_WORK_STATE_Writing: + log_d( " eeporm writing ********** %d" ,count ); + if (my_eeprom.size == 0 ) + { + my_eeprom.state = EEPROM_WORK_STATE_STOP; } - // I2CHelper_Write( eeprom->i2chelper, eeprom->send_buf, 1 ); - continue; - }; - - /* 等待 eeprom->write_delay_ms ，写入数据*/ - if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 1 ) - { - if( (osKernelGetTickCount( ) - eeprom->time_base) > eeprom->write_delay_ms) + I2C_HELPER_Set_mem_addr( eeprom_helper, count ); + st = I2C_HELPER_Trans( eeprom_helper, my_eeprom.buf, 1 ); + ticks = osKernelGetTickCount(); + my_eeprom.state = EEPROM_WORK_STATE_WRITE_Waiting; + break; + case EEPROM_WORK_STATE_WRITE_Waiting: + if (osKernelGetTickCount()-ticks >my_eeprom.write_delay_ms){ + count++; + my_eeprom.size--; + my_eeprom.buf++; + } + if (my_eeprom.size> 0 ) { - // log_i("eeporm write ... 5ms "); - eeprom->writeCplt = 1 ; + my_eeprom.state = EEPROM_WORK_STATE_Writing; + continue; } - continue; - }; - - /* 写完成，处理数据等待进入下一组 */ - if ( eeprom->size > 0 && eeprom->writeCplt == 1 ) - { - eeprom->send_buf++; - eeprom->mem_addr++; - eeprom->size--; - eeprom->is_busy = 0; - eeprom->writeCplt = 0; - continue; - }; - osDelay( 1); + my_eeprom.state = EEPROM_WORK_STATE_STOP; + count = 0; + break; + case EEPROM_WORK_STATE_Reading: + I2C_HELPER_Set_mem_addr(eeprom_helper, 0); + while( I2C_HELPER_Start_Rcv( eeprom_helper, eeprom_read_buf, 24 ) != HAL_OK ) + { + osDelay(1); + } + // log_d( " eeprom_read_buf ********** %02X %02X " ,eeprom_read_buf[0],eeprom_read_buf[23] ); + // 或等到 I2C 状态为 ready + // while(i2c_get_state(&i2c_buf)!=0){ + // if(time_clock_get_time_offset_ms(&time)>1000){ + // return -1; + // } + // } + my_eeprom.state = EEPROM_WORK_STATE_STOP; + break; + case EEPROM_WORK_STATE_ERROR: + log_w( " ADS1115 error ..... " ); + // my_ads1115.state = ADS1115_WORK_STATE_WAITING ; + osDelay(10); + continue; + case EEPROM_WORK_STATE_STOP: + log_w( " ADS1115 stop..... " ); + // my_ads1115.state = ADS1115_WORK_STATE_WAITING ; + osDelay(10); + continue; + default: + break; + } + // /* 判断size, size 大于零才开始工作*/ + // if (eeprom->size == 0) + // { + // eeprom->send_buf = NULL; + // eeprom->is_busy == 0; + // // log_i("eeprom port func..."); + // osDelay(100); + // }; + + // /* size> 0, 写入一个数据 */ + // if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 0 ) + // { + // eeprom->time_base = osKernelGetTickCount( ); + // eeprom->is_busy = 1; + // // log_i("eeporm write ... "); + // st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, eeprom->send_buf, 1, eeprom->write_delay_ms); + // if (st != HAL_OK) { + // log_e(" Eeprom Write error"); + // eeprom->size = 0; + // eeprom->send_buf = NULL; + // eeprom->is_busy = 0; + // break; + // } + // // I2CHelper_Write( eeprom->i2chelper, eeprom->send_buf, 1 ); + // continue; + // }; + + // /* 等待 eeprom->write_delay_ms ，写入数据*/ + // if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 1 ) + // { + // if( (osKernelGetTickCount( ) - eeprom->time_base) > eeprom->write_delay_ms) + // { + // // log_i("eeporm write ... 5ms "); + // eeprom->writeCplt = 1 ; + // } + // continue; + // }; + + // /* 写完成，处理数据等待进入下一组 */ + // if ( eeprom->size > 0 && eeprom->writeCplt == 1 ) + // { + // eeprom->send_buf++; + // eeprom->mem_addr++; + // eeprom->size--; + // eeprom->is_busy = 0; + // eeprom->writeCplt = 0; + // continue; + // }; + osDelay( 10); } } -// int Eeprom_SET_I2CHelper( EEPROM_TypeDef *eeprom, I2CHelper_TypeDef *i2chelper ) -// { -// eeprom->i2chelper = i2chelper; -// return 0; -// } - -int Eeprom_SET_Device_Model(EEPROM_TypeDef *eeprom, EEPROM_MODEL_TypeDef model) +int Eeprom_Test( ) { - eeprom->model = model; - if (eeprom->model < AT24C04 ) - { - eeprom->mem_addr_type = I2C_MEMADD_SIZE_8BIT; - }else{ - eeprom->mem_addr_type = I2C_MEMADD_SIZE_16BIT; - } - return 0; -} + uint8_t test_send[1] = { 0xFF }; // 不同model,地址不同 方法也不同 + uint8_t test_rcv = 0; + int st; + // write + I2C_HELPER_Set_mem_addr( eeprom_helper, AT24C02 ); + st = I2C_HELPER_Trans( eeprom_helper, test_send, 1 ); -int Eeprom_SET_Device_Addr(EEPROM_TypeDef *eeprom, uint8_t dev_addr) -{ - eeprom->dev_addr = dev_addr; - // TODO: 需要对I2C 进行设置 - return 0; -} + HAL_Delay(my_eeprom.write_delay_ms); -int Eeprom_SET_Mem_Addr ( EEPROM_TypeDef *eeprom, uint16_t mem_addr ) -{ - eeprom->mem_addr = mem_addr; - return 0; + // // Read + I2C_HELPER_Set_mem_addr(eeprom_helper, AT24C02); + st = I2C_HELPER_Start_Rcv(eeprom_helper, (uint8_t *)&test_rcv , 2); + + if ( test_rcv == 255 ){ + return 0; + } + + return -1; } -int Eeprom_SET_Mem_Addr_Type(EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_TypeDef mem_addr_type) +int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size) { - eeprom->mem_addr_type = mem_addr_type; - return 0; -} + // switch (my_eeprom.state) + // { + // // case ADS1115_WORK_STATE_TESTING : + // // my_ads1115.state++; + // // break; + // // case ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait : + // // my_ads1115.state++; + // // break; + // // case ADS1115_WORK_STATE_GET_DATA_RCV_Wait : + // // // TODO Check data? + // // my_ads1115.state++; + // // break; + // default: + // break; + // } + +} -int Eeprom_SET_Mem_Addr_Bit(EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit) +int Eeprom_SET_Device_Model(EEPROM_MODEL_TypeDef model) { - // eeprom->mem_addr_bit = mem_addr_bit; + my_eeprom.model = model; + if (my_eeprom.model < AT24C04 ) + { + I2C_HELPER_Set_mem_addr_size( eeprom_helper, I2C_MEMADD_SIZE_8BIT ); + }else{ + I2C_HELPER_Set_mem_addr_size( eeprom_helper, I2C_MEMADD_SIZE_16BIT ); + } return 0; } -// int Eeprom_SET_WorkMode( EEPROM_TypeDef *eeprom, I2C_HELPER_MODE_TypeDef mode ) -// { -// eeprom->mode = mode; -// I2CHelper_Set_Mode( eeprom->i2chelper, mode ); -// return 0; -// } -int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms) +int Eeprom_SET_Write_Delay_ms(uint8_t write_delay_ms) { - eeprom->write_delay_ms = write_delay_ms; + my_eeprom.write_delay_ms = write_delay_ms; return 0; } @@ -190,12 +261,10 @@ int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms) // } -int Eeprom_Read(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size) +int Eeprom_Read( uint8_t * buf, uint16_t size) { - // osEventFlagsGet(eepromEventHandle, EEPROM_EVT_READ); - eeprom->readCplt = 0; int st; - st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF); + // st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF); if ( st != HAL_OK ) { return -1; } @@ -203,41 +272,28 @@ int Eeprom_Read(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size) // HAL_I2C_Master_Transmit_IT (eeprom->hi2c, eeprom->dev_addr, buf ,size); } -// int Eeprom_Write(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size) -// { -// // osEventFlagsGet(eepromEventHandle, EEPROM_EVT_WRITE); -// eeprom->writeCplt = 0; -// // HAL_I2C_Master_Transmit_IT (eeprom->i2chelper->hi2c, eeprom->dev_addr, buf ,size); -// } - -void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom, uint8_t * buf, uint16_t size) +int Eeprom_Write( uint8_t * buf, uint16_t size) { - eeprom->send_buf = buf; - eeprom->size = size; - return ; + my_eeprom.buf = buf; + my_eeprom.size = size; + int st; + // st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF); + if ( st != HAL_OK ) { + return -1; + } + return 0; + // HAL_I2C_Master_Transmit_IT (eeprom->hi2c, eeprom->dev_addr, buf ,size); } + -int Eeprom_Test( ) +void Eeprom_Set_Sendbuf_Size( uint8_t * buf, uint16_t size) { - uint8_t test_send[1] = { 0xFF }; // 不同model,地址不同 方法也不同 - uint8_t test_rcv = 0; - int st; - - // st = Eeprom_Write( eeprom, test_send, 1 ); - st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, test_send, 1, eeprom->write_delay_ms); - osDelay( 10 ); + my_eeprom.buf = buf; + my_eeprom.size = size; + return ; +} - // st = Eeprom_Read( eeprom, &test_rcv, 1); - st = HAL_I2C_Mem_Read(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, &test_rcv, 1, eeprom->write_delay_ms); - osDelay( 5 ); - if ( test_rcv == 255 ){ - // log_i( " Test Result : PASS " ); - return 0; - } - // log_i( " Test Result : Error st %d val %d " , st, test_rcv ); - return -1; -} // //主机模式发送回调函数 // void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *I2cHandle)