21ic电子技术开发论坛 › 单片机与嵌入式系统 › 芯源CW32 MCU › 【CW32L031CxTx StartKit评估板测评】02-软件模拟I2C读 ...
返回列表 发新帖我要提问

[产品应用] 【CW32L031CxTx StartKit评估板测评】02-软件模拟I2C读写板载EEPROM

[复制链接]
 楼主| 怀揣少年梦 发表于 2023-11-10 11:44 | 显示全部楼层 |阅读模式
EEPROM, I2C读写
本帖最后由 怀揣少年梦 于 2023-11-10 11:44 编辑

一、开发板上硬件设计
CW32L031CxTx StartKit评估板上板载一颗型号为CW24C02AD的EEPROM，EEPROM适用于保存数据量比较小的场景，并且可靠性比较高。
先看一下CW24C02AD的数据手册，可以看到该EEPROM只有2Kbit，也就是256字节（这是EEPROM中容量最小的芯片），每页8个字节，一共32页。工作电压1.7-5.5V；允许页面局部写入；I2C 时钟频率为 1MHz (5V，3V)，400 KHz (1.7V）；擦写寿命：100 万次；数据保持时间： 20年；
DATASHEET5.png
从评估板的原理图来看，EEPROM的A2\A1\A0三个引脚接地，说明读写EEPROM的地址为A0；
EEPROM.png
二、软件设计
使用GPIO口模拟I2C读写EEPROM。
具体代码如下：
1）.c代码
复制
  1. #include "eeprom.h"
    


  2. 

  3. #define I2C_DIR_TRANSMIT                 0x00
    

  4. #define I2C_DIR_RECEIVE                  0x01
    


  5. 

  6. #define I2C_ACK_TIMEOUT                  64
    


  7. 

  8. #define I2C_SCL_HIGH()                   GPIO_WritePin(I2Cx_SCL_GPIO_PORT, I2Cx_SCL_PIN, GPIO_Pin_SET)
    

  9. #define I2C_SCL_LOW()                    GPIO_WritePin(I2Cx_SCL_GPIO_PORT, I2Cx_SCL_PIN, GPIO_Pin_RESET)
    


  10. 

  11. #define I2C_SDA_HIGH()                   GPIO_WritePin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_PIN, GPIO_Pin_SET)
    

  12. #define I2C_SDA_LOW()                    GPIO_WritePin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_PIN, GPIO_Pin_RESET)
    


  13. 

  14. #define I2C_SDA_READ                     GPIO_ReadPin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_PIN)
    

  15. #define I2C_DALEY_US         5
    


  16. 

  17. /**
    

  18.   * [url=home.php?mod=space&uid=247401]@brief[/url] i2c address direction
    

  19.   */
    


  20. 

  21. void i2c_config(void)
    

  22. {
    

  23.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    

  24.   
    

  25.   /* i2c gpio clock enable */ 
    

  26.         __RCC_GPIOB_CLK_ENABLE();
    

  27.   
    

  28.   /* gpio configuration */  
    

  29.         GPIO_InitStruct.IT = GPIO_IT_NONE;
    

  30.         GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    


  31. 

  32.   /* configure i2c pins: scl */    
    

  33.   GPIO_InitStruct.Pins = I2Cx_SCL_PIN;
    

  34.   GPIO_Init(I2Cx_SCL_GPIO_PORT, &GPIO_InitStruct);
    


  35. 

  36.   /* configure i2c pins: sda */     
    

  37.   GPIO_InitStruct.Pins = I2Cx_SDA_PIN;
    

  38.   GPIO_Init(I2Cx_SDA_GPIO_PORT, &GPIO_InitStruct);
    


  39. 

  40.   I2C_SDA_HIGH();
    

  41.   I2C_SCL_HIGH();
    

  42. }
    


  43. 

  44. /** 
    

  45.   * @brief  used to set the i2c clock frequency.
    

  46.   * @param  none.
    

  47.   * @retval none.
    

  48.   */
    

  49. void i2c_delay(void)
    

  50. {
    

  51.         uint8_t i = 0;
    

  52.         uint8_t j = 48;
    

  53.         for (i = 0; i< I2C_DALEY_US; i++) {
    

  54.                 while(j--);
    

  55.         }
    

  56. }
    


  57. 


  58. 

  59. /**
    

  60.  * @brief 循环延时
    

  61.  *
    

  62.  * @param nCount
    

  63.  */
    

  64. void Delay(__IO uint16_t nCount)
    

  65. {
    

  66.     /* Decrement nCount value */
    

  67.     while (nCount != 0)
    

  68.     {
    

  69.         nCount--;
    

  70.     }
    

  71. }
    


  72. 

  73. /** 
    

  74.   * @brief  used to generate start conditions.
    

  75.   * @param  none.
    

  76.   * @retval none.
    

  77.   */
    

  78. void i2c_start(void)
    

  79. {
    

  80.   i2c_delay();
    

  81.   
    

  82.   I2C_SDA_HIGH();
    

  83.   I2C_SCL_HIGH();
    

  84.   i2c_delay();
    

  85.   
    

  86.   I2C_SDA_LOW();
    

  87.   i2c_delay();
    

  88.   
    

  89.   I2C_SCL_LOW();
    

  90.   i2c_delay();
    

  91. }
    


  92. 

  93. /** 
    

  94.   * @brief  used to generate stop conditions.
    

  95.   * @param  none.
    

  96.   * @retval none.
    

  97.   */
    

  98. void i2c_stop(void)
    

  99. {
    

  100.   I2C_SCL_LOW();
    

  101.   I2C_SDA_LOW();  
    

  102.   i2c_delay();
    

  103.   
    

  104.   I2C_SCL_HIGH();
    

  105.   i2c_delay();
    

  106.   
    

  107.   I2C_SDA_HIGH();
    

  108.   i2c_delay();
    

  109. }
    


  110. 

  111. /** 
    

  112.   * @brief  used to generate ack conditions.
    

  113.   * @param  none.
    

  114.   * @retval none.
    

  115.   */
    

  116. void i2c_ack(void)
    

  117. {
    

  118.   I2C_SCL_LOW();
    

  119.   I2C_SDA_LOW();
    

  120.   i2c_delay();
    

  121.   
    

  122.   I2C_SCL_HIGH();
    

  123.   i2c_delay();
    

  124.   
    

  125.   I2C_SCL_LOW();
    

  126.   i2c_delay();
    

  127. }
    


  128. 

  129. /** 
    

  130.   * @brief  used to generate nack conditions.
    

  131.   * @param  none.
    

  132.   * @retval none.
    

  133.   */
    

  134. void i2c_no_ack(void)
    

  135. {
    

  136.   I2C_SCL_LOW();
    

  137.   I2C_SDA_HIGH();
    

  138.   i2c_delay();
    

  139.   
    

  140.   I2C_SCL_HIGH();
    

  141.   i2c_delay();
    

  142.   
    

  143.   I2C_SCL_LOW();
    

  144.   i2c_delay();
    

  145. }
    


  146. 

  147. /** 
    

  148.   * @brief  used to wait ack conditions.
    

  149.   * @param  none.
    

  150.   * @retval ack receive status.
    

  151.   *         - 1: no ack received.
    

  152.   *         - 0: ack received.
    

  153.   */
    

  154. uint8_t i2c_wait_ack(uint8_t timeout)
    

  155. {
    

  156.   I2C_SCL_LOW();
    

  157.   I2C_SDA_HIGH();  
    

  158.   
    

  159.   i2c_delay();
    

  160.   
    

  161.   while(timeout)
    

  162.   {
    

  163.     if (I2C_SDA_READ == 0)
    

  164.     {
    

  165.       I2C_SCL_HIGH(); 
    

  166.       
    

  167.       i2c_delay(); 
    

  168.       
    

  169.       I2C_SCL_LOW();
    

  170.       
    

  171.       return 0;
    

  172.     }
    

  173.     
    

  174.     i2c_delay();
    

  175.     
    

  176.     timeout--;
    

  177.   }  
    

  178.   
    

  179.   return 1;
    

  180. }
    


  181. 

  182. /** 
    

  183.   * @brief  send a byte.
    

  184.   * @param  data: byte to be transmitted.
    

  185.   * @retval none.
    

  186.   */
    

  187. void i2c_send_byte(uint8_t data)
    

  188. {
    

  189.   uint8_t i = 8;
    

  190.         
    

  191.   I2C_SCL_LOW(); //
    

  192.   while (i--)
    

  193.   {
    

  194.     if (data & 0x80)
    

  195.     {
    

  196.       I2C_SDA_HIGH();    
    

  197.     }
    

  198.     else
    

  199.     {
    

  200.       I2C_SDA_LOW();    
    

  201.     }    
    

  202.     
    

  203.     i2c_delay();
    

  204.     
    

  205.     I2C_SCL_HIGH();
    

  206.     i2c_delay();
    

  207.                 I2C_SCL_LOW();
    

  208.     i2c_delay();
    

  209.         
    

  210.         data <<= 1;
    

  211.   }    
    

  212. }
    


  213. 

  214. /** 
    

  215.   * @brief  receive a byte.
    

  216.   * @param  data: byte to be received.
    

  217.   * @retval none.
    

  218.   */
    

  219. uint8_t i2c_receive_byte(void)
    

  220. {
    

  221.   uint8_t i = 8;
    

  222.   uint8_t byte = 0;
    


  223. 

  224.   I2C_SDA_HIGH();
    

  225.   I2C_SCL_LOW();
    

  226.         
    

  227.   while (i--) 
    

  228.   {
    

  229.     byte <<= 1; 
    

  230.     I2C_SCL_HIGH();
    

  231.     i2c_delay();
    

  232.   
    

  233.     byte |= I2C_SDA_READ;
    

  234.           I2C_SCL_LOW();
    

  235.     i2c_delay();
    


  236. 

  237.   }
    


  238. 

  239.   return byte;
    

  240. }
    


  241. 

  242. uint8_t i2c_WriteByte(uint8_t I2C_Addr,uint8_t addr,uint8_t data)
    

  243. {
    

  244.         i2c_start();
    

  245.         i2c_send_byte(I2C_Addr | I2C_DIR_TRANSMIT);; //
    

  246.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  247.         {
    

  248.       i2c_stop();
    

  249.                 
    

  250.           return 1;
    

  251.         }
    

  252.         i2c_send_byte(addr); //
    

  253.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  254.         {
    

  255.       i2c_stop();
    

  256.       printf("EEPROM %x \r\n",addr);        
    

  257.           return 1;
    

  258.         }          
    

  259.         i2c_send_byte(data); 
    

  260.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  261.         {
    

  262.       i2c_stop();
    

  263.       printf("EEPROM %x \r\n",data);                
    

  264.           return 1;
    

  265.         }
    

  266.         
    

  267.         i2c_stop(); //
    


  268. 

  269.         Delay(0xffff);
    

  270.         Delay(0xffff);
    

  271.         Delay(0xffff);
    

  272.         printf("write ok\r\n");
    

  273.         return 0;
    

  274. }
    


  275. 


  276. 

  277. uint8_t i2c_ReadCurrentAddrByte(uint8_t I2C_Addr)
    

  278. {
    

  279.         uint8_t data;
    

  280.         i2c_start();
    

  281.         i2c_send_byte(I2C_Addr | I2C_DIR_RECEIVE);; //锟斤拷锟酵从伙拷锟斤拷址
    

  282.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  283.         {
    

  284.       i2c_stop();
    

  285.                 
    

  286.           return 1;
    

  287.         }
    

  288.         data = i2c_receive_byte();
    

  289.         i2c_no_ack(); 
    

  290.         i2c_stop(); //
    

  291.         printf("receive1 ok\r\n");
    

  292.         return data;
    

  293. }
    


  294. 

  295. uint8_t i2c_ReadByte(uint8_t I2C_Addr,uint8_t addr)
    

  296. {
    

  297.         uint8_t data;
    

  298.         i2c_start();
    

  299.         i2c_send_byte(I2C_Addr | I2C_DIR_TRANSMIT);; //
    

  300.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  301.         {
    

  302.       i2c_stop();
    

  303.                 
    

  304.           return 1;
    

  305.         }
    

  306.         i2c_send_byte((uint8_t)addr); //
    

  307.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  308.         {
    

  309.       i2c_stop();
    

  310.       printf("EEPROM %x \r\n",addr);        
    

  311.           return 1;
    

  312.         }          
    

  313.         
    

  314.         i2c_start();
    

  315.         i2c_send_byte(I2C_Addr | I2C_DIR_RECEIVE);; //
    

  316.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  317.         {
    

  318.       i2c_stop();
    

  319.       printf("EEPROM %x \r\n",I2C_Addr);                
    

  320.           return 1;
    

  321.         }
    

  322.         data = i2c_receive_byte();
    

  323.         i2c_no_ack(); 
    

  324.         i2c_stop(); //
    

  325.         printf("receive ok\r\n");
    

  326.         return data;
    

  327. }
    


  328. 


  329. 

  330. uint8_t i2c_ReadMultByte(uint8_t I2C_Addr,uint16_t addr,uint8_t length, uint8_t *pdata)
    

  331. {
    

  332.         uint8_t i = 0;
    

  333.         
    

  334.         i2c_start();
    

  335.         i2c_send_byte(I2C_Addr | I2C_DIR_TRANSMIT);; //
    

  336.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  337.         {
    

  338.       i2c_stop();
    

  339.                 
    

  340.           return 1;
    

  341.         }
    


  342. 

  343.         i2c_send_byte((uint8_t)addr); //
    

  344.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  345.         {
    

  346.       i2c_stop();
    

  347.       printf("EEPROM %x \r\n",addr);        
    

  348.           return 1;
    

  349.         }          
    

  350.         
    

  351.         i2c_start();
    

  352.         i2c_send_byte(I2C_Addr | I2C_DIR_RECEIVE);; //
    

  353.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  354.         {
    

  355.       i2c_stop();
    

  356.       printf("EEPROM %x \r\n",I2C_Addr);                
    

  357.           return 1;
    

  358.         }
    

  359.         
    

  360.         for(i = 0; i< length; i++) {
    

  361.         
    

  362.       pdata[i] = i2c_receive_byte();
    

  363.     
    

  364.       if (i < (length - 1))
    

  365.       {
    

  366.         i2c_ack();
    

  367.       }
    

  368.       else
    

  369.       {
    

  370.         i2c_no_ack(); 
    

  371.       }
    

  372.         }
    


  373. 

  374.         i2c_stop(); //
    

  375.         printf("mul receive ok\r\n");
    

  376.         return 0;
    

  377. }
    


  378. 

  379. uint8_t i2c_WriteMultByte(uint8_t I2C_Addr,uint16_t addr,uint8_t length, uint8_t *pdata)
    

  380. {
    

  381.         uint8_t i = 0;
    

  382.         
    

  383.         i2c_start();
    

  384.         i2c_send_byte(I2C_Addr | I2C_DIR_TRANSMIT);; //
    

  385.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  386.         {
    

  387.       i2c_stop();
    

  388.                 
    

  389.           return 1;
    

  390.         }
    

  391.         
    

  392.         i2c_send_byte((uint8_t)addr); //
    

  393.   printf("addr high %x",(uint8_t)(addr));
    

  394.         if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  395.         {
    

  396.       i2c_stop();
    

  397.       printf("EEPROM %x\r\n",addr);        
    

  398.           return 1;
    

  399.         }          
    

  400.         
    

  401.         for(i = 0; i< length; i++) {
    

  402.       i2c_send_byte(pdata[i]);
    

  403.       if (i2c_wait_ack(I2C_ACK_TIMEOUT) == 1)
    

  404.       {
    

  405.         i2c_stop();
    

  406.         printf("EEPROM %d %x \r\n",i,addr);        
    

  407.         return 1;
    

  408.       }
    

  409.         }
    


  410. 

  411.         i2c_stop(); //
    

  412.   printf("write ok\r\n");
    

  413.         Delay(0xffff);
    


  414. 

  415.         return 0;
    

  416. }


2)、.h代码
复制
  1. #ifndef __EEPROM_H__
    

  2. #define __EEPROM_H__
    


  3. 

  4. #include "..\inc\main.h"
    


  5. 

  6. #define I2Cx_SCL_PIN                     GPIO_PIN_6
    

  7. #define I2Cx_SCL_GPIO_PORT               CW_GPIOB
    


  8. 

  9. #define I2Cx_SDA_PIN                     GPIO_PIN_7
    

  10. #define I2Cx_SDA_GPIO_PORT               CW_GPIOB
    


  11. 


  12. 


  13. 

  14. /** @defgroup I2C_library_exported_functions
    

  15.   * @{
    

  16.   */
    


  17. 

  18. void i2c_config(void);
    

  19. void delay_us(uint32_t us);
    

  20. void Delay(__IO uint16_t nCount);
    

  21. uint8_t i2c_WriteByte(uint8_t I2C_Addr,uint8_t addr,uint8_t data); 
    

  22. uint8_t i2c_ReadCurrentAddrByte(uint8_t I2C_Addr);
    

  23. uint8_t i2c_ReadByte(uint8_t I2C_Addr,uint8_t addr);
    

  24. uint8_t i2c_ReadMultByte(uint8_t I2C_Addr,uint16_t addr,uint8_t length, uint8_t *pdata);
    

  25. uint8_t i2c_WriteMultByte(uint8_t I2C_Addr,uint16_t addr,uint8_t length, uint8_t *pdata);
    

  26. #endif


3)、测试主程序
复制
  1. #include "..\inc\main.h"
    

  2. /******************************************************************************
    

  3.  * Local pre-processor symbols/macros ('#define')
    

  4.  ******************************************************************************/
    

  5. //UARTx
    

  6. #define  DEBUG_USARTx                   CW_UART1    
    

  7. #define  DEBUG_USART_CLK                RCC_APB2_PERIPH_UART1
    

  8. #define  DEBUG_USART_APBClkENx          RCC_APBPeriphClk_Enable2
    

  9. #define  DEBUG_USART_BaudRate           9600
    

  10. #define  DEBUG_USART_UclkFreq           8000000
    

  11. #define  LED_GPIO_PORT CW_GPIOB
    

  12. #define  LED_GPIO_PINS GPIO_PIN_8 | GPIO_PIN_9
    

  13. //UARTx GPIO
    

  14. #define  DEBUG_USART_GPIO_CLK           RCC_AHB_PERIPH_GPIOA
    

  15. #define  DEBUG_USART_TX_GPIO_PORT       CW_GPIOA
    

  16. #define  DEBUG_USART_TX_GPIO_PIN        GPIO_PIN_8
    

  17. #define  DEBUG_USART_RX_GPIO_PORT       CW_GPIOA
    

  18. #define  DEBUG_USART_RX_GPIO_PIN        GPIO_PIN_9
    


  19. 

  20. //GPIO AF
    

  21. #define  DEBUG_USART_AFTX               PA08_AFx_UART1TXD()
    

  22. #define  DEBUG_USART_AFRX               PA09_AFx_UART1RXD()
    

  23. /******************************************************************************
    

  24.  * Global variable definitions (declared in header file with 'extern')
    

  25.  ******************************************************************************/
    

  26. uint8_t test_data[] = {0x01,0x02,0x03};
    

  27. uint8_t test_readdata[3] = {0x00};
    

  28. /******************************************************************************
    

  29.  * Local type definitions ('typedef')
    

  30.  ******************************************************************************/
    


  31. 

  32. /******************************************************************************
    

  33.  * Local function prototypes ('static')
    

  34.  ******************************************************************************/
    

  35. void RCC_Configuration(void);
    

  36. void GPIO_Configuration(void);
    

  37. void UART_Configuration(void);
    


  38. 

  39. #ifdef __GNUC__
    

  40.     /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
    

  41.     set to 'Yes') calls __io_putchar() */
    

  42.     #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    

  43. #else
    

  44.     #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    

  45. #endif /* __GNUC__ */
    


  46. 

  47. /******************************************************************************
    

  48.  * Local variable definitions ('static')                                      *
    

  49.  ******************************************************************************/
    


  50. 

  51. /******************************************************************************
    

  52.  * Local pre-processor symbols/macros ('#define')
    

  53.  ******************************************************************************/
    


  54. 

  55. /*****************************************************************************
    

  56.  * Function implementation - global ('extern') and local ('static')
    

  57.  ******************************************************************************/
    


  58. 

  59. /**
    

  60.  ******************************************************************************
    

  61.  ** \brief  Main function of project
    

  62.  **
    

  63.  ** \return uint32_t return value, if needed
    

  64.  **
    

  65.  ******************************************************************************/
    

  66. int32_t main(void)
    

  67. {
    

  68.     //配置RCC
    

  69.     RCC_Configuration();
    


  70. 

  71.     //配置GPIO
    

  72.     GPIO_Configuration();
    

  73.                 //i2c_config();
    

  74.     //配置UART
    

  75.     UART_Configuration();
    

  76.                 
    

  77.     printf("\r\n use CW32L031 simulate I2C READ EEPROM Example\r\n");
    

  78.                 
    

  79.     while(1)
    

  80.     {
    

  81.                         if (GPIO_ReadPin(CW_GPIOA, GPIO_PIN_1) == 0) {
    

  82.                                 i2c_WriteByte(0xA0,0x01,0x5A);
    

  83.                                 i2c_WriteMultByte(0xA0,0x05,3,test_data);
    

  84.                         }
    

  85.                         
    

  86.                         if (GPIO_ReadPin(CW_GPIOA, GPIO_PIN_2) == 0) {
    

  87.                                 printf("data:%x \r\n",i2c_ReadByte(0xA0,0x01));
    

  88.                                 i2c_ReadMultByte(0xA0,0x05,3,test_readdata);
    

  89.                                 for(int i = 0;i < 3; i++) {
    

  90.                                         printf("test_readdata[%d] = %x \r\n",i,test_readdata[i]);
    

  91.                                 }
    

  92.                                 
    

  93.                         }
    

  94.                         
    

  95.                         GPIO_TogglePin(LED_GPIO_PORT, LED_GPIO_PINS);
    

  96.       Delay(0xFFFF);
    

  97.     }
    

  98. }
    


  99. 


  100. 

  101. /**
    

  102.  * @brief 配置RCC
    

  103.  *
    

  104.  */
    

  105. void RCC_Configuration(void)
    

  106. {
    

  107.     //SYSCLK = HSI = 8MHz = HCLK = PCLK
    

  108.     RCC_HSI_Enable(RCC_HSIOSC_DIV6);
    


  109. 

  110.     //外设时钟使能
    

  111.     RCC_AHBPeriphClk_Enable(DEBUG_USART_GPIO_CLK, ENABLE);
    

  112.     DEBUG_USART_APBClkENx(DEBUG_USART_CLK, ENABLE);
    

  113.                 RCC_AHBPeriphClk_Enable(RCC_AHB_PERIPH_GPIOB,ENABLE);
    

  114.                 __RCC_GPIOA_CLK_ENABLE();
    

  115. }
    


  116. 

  117. /**
    

  118.  * @brief 配置GPIO
    

  119.  *
    

  120.  */
    

  121. void GPIO_Configuration(void)
    

  122. {
    

  123.     GPIO_InitTypeDef GPIO_InitStructure = {0};
    


  124. 

  125.                 
    

  126.     //UART TX RX 复用
    

  127.     DEBUG_USART_AFTX;
    

  128.     DEBUG_USART_AFRX;
    


  129. 

  130.     GPIO_InitStructure.Pins = DEBUG_USART_TX_GPIO_PIN;
    

  131.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  132.     GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
    


  133. 

  134.                 GPIO_InitStructure.Pins = GPIO_PIN_1 | GPIO_PIN_2;
    

  135.     GPIO_InitStructure.Mode = GPIO_MODE_INPUT_PULLUP;
    

  136.     GPIO_Init(CW_GPIOA, &GPIO_InitStructure);
    

  137.                 
    

  138.     GPIO_InitStructure.Pins = DEBUG_USART_RX_GPIO_PIN;
    

  139.     GPIO_InitStructure.Mode = GPIO_MODE_INPUT_PULLUP;
    

  140.     GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);  
    


  141. 

  142.     GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  143.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    

  144.     GPIO_InitStructure.Pins = LED_GPIO_PINS;                
    

  145.                 
    

  146.                 GPIO_Init(LED_GPIO_PORT, &GPIO_InitStructure);
    

  147.                 
    

  148.                 
    

  149.                   /* gpio configuration */  
    

  150.                 GPIO_InitStructure.IT = GPIO_IT_NONE;
    

  151.                 GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD;
    


  152. 

  153.                 /* configure i2c pins: scl */    
    

  154.                 GPIO_InitStructure.Pins = I2Cx_SCL_PIN;
    

  155.                 GPIO_Init(I2Cx_SCL_GPIO_PORT, &GPIO_InitStructure);
    


  156. 

  157.                 /* configure i2c pins: sda */     
    

  158.                 GPIO_InitStructure.Pins = I2Cx_SDA_PIN;
    

  159.                 GPIO_Init(I2Cx_SDA_GPIO_PORT, &GPIO_InitStructure);
    


  160. 

  161.                 GPIO_WritePin(I2Cx_SCL_GPIO_PORT, I2Cx_SCL_PIN, GPIO_Pin_SET);
    

  162.                 GPIO_WritePin(I2Cx_SDA_GPIO_PORT, I2Cx_SDA_PIN, GPIO_Pin_SET);
    

  163. }
    


  164. 

  165. /**
    

  166.  * @brief 配置UART
    

  167.  *
    

  168.  */
    

  169. void UART_Configuration(void)
    

  170. {
    

  171.     USART_InitTypeDef USART_InitStructure = {0};
    


  172. 

  173.     USART_InitStructure.USART_BaudRate = DEBUG_USART_BaudRate;
    

  174.     USART_InitStructure.USART_Over = USART_Over_16;
    

  175.     USART_InitStructure.USART_Source = USART_Source_PCLK;
    

  176.     USART_InitStructure.USART_UclkFreq = DEBUG_USART_UclkFreq;
    

  177.     USART_InitStructure.USART_StartBit = USART_StartBit_FE;
    

  178.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    

  179.     USART_InitStructure.USART_Parity = USART_Parity_No ;
    

  180.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    

  181.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    

  182.     USART_Init(DEBUG_USARTx, &USART_InitStructure);
    

  183. }
    


  184. 

  185. // KEIL
    

  186. /**
    

  187.  * @brief Retargets the C library printf function to the USART.
    

  188.  *
    

  189.  */
    

  190. PUTCHAR_PROTOTYPE
    

  191. {
    

  192.     USART_SendData_8bit(DEBUG_USARTx, (uint8_t)ch);
    


  193. 

  194.     while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
    


  195. 

  196.     return ch;
    

  197. }
    


  198. 


  199. 

  200. // IAR
    

  201. size_t __write(int handle, const unsigned char * buffer, size_t size)
    

  202. {
    

  203.     size_t nChars = 0;
    


  204. 

  205.     if (buffer == 0)
    

  206.     {
    

  207.         /*
    

  208.          * This means that we should flush internal buffers.  Since we
    

  209.          * don't we just return.  (Remember, "handle" == -1 means that all
    

  210.          * handles should be flushed.)
    

  211.          */
    

  212.         return 0;
    

  213.     }
    


  214. 


  215. 

  216.     for (/* Empty */; size != 0; --size)
    

  217.     {
    

  218.         USART_SendData_8bit(DEBUG_USARTx, *buffer++);
    

  219.         while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
    

  220.         ++nChars;
    

  221.     }
    


  222. 

  223.     return nChars;
    

  224. }
三、实际测试串口输出
单字节写入5a，单字节读出来也是5a;
多字节写入01 02 03；多字节读出来也是01 02 03


微信图片_20231110103115.jpg
回复 赏

举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

怀揣少年梦
个人签名：一切皆有可能

45

主题

473

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部
怀揣少年梦
个人签名：一切皆有可能

45

主题

473

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部