2016年3月2日 星期三

STM32F103 I2C Master Driver

話不說多, 直接上code.

I2C_Master.h
  1.  
  2. #include "stm32f10x.h"
  3.  
  4. void I2C_Master_Init(void);
  5. void I2C_Master_DeInit(void);
  6. int I2C_Master_Read(uint8_t deviceAddr, uint8_t readAddr, uint8_t* pBuffer, uint16_t numByteToRead);
  7. int I2C_Master_Write(uint8_t deviceAddress, uint8_t WriteAddr, uint8_t* pBuffer, uint16_t numByteToWrite);
  8. int I2C_TIMEOUT_UserCallback(void);
  9.  

I2C_Master.c
  1.  
  2. #include "I2C_Master.h"
  3.  
  4. #define I2C_MEMS                I2C1
  5. #define I2C_MEMS_CLK            RCC_APB1Periph_I2C1
  6. #define I2C_MEMS_GPIO           GPIOB
  7. #define I2C_MEMS_GPIO_CLK       RCC_APB2Periph_GPIOB
  8. #define I2C_MEMS_SCL            GPIO_Pin_6
  9. #define I2C_MEMS_SDA            GPIO_Pin_7
  10.  
  11. #define I2C_Speed               400000
  12. #define I2C_SLAVE_ADDRESS7      0xA0
  13. #define I2C_TIMEOUT             3000
  14.  
  15. /* I2C STOP mask */
  16. #define CR1_STOP_Set            ((uint16_t)0x0200)
  17. #define CR1_STOP_Reset          ((uint16_t)0xFDFF)
  18.  
  19. /* I2C ACK mask */
  20. #define CR1_ACK_Set             ((uint16_t)0x0400)
  21. #define CR1_ACK_Reset           ((uint16_t)0xFBFF)
  22.  
  23. /* I2C POS mask */
  24. #define CR1_POS_Set             ((uint16_t)0x0800)
  25. #define CR1_POS_Reset           ((uint16_t)0xF7FF)
  26.  
  27. #define NULL ((void *)0)
  28.  
  29.  
  30. void I2C_Master_Init(void)
  31. {
  32.   GPIO_InitTypeDef  GPIO_InitStructure; 
  33.   I2C_InitTypeDef  I2C_InitStructure; 
  34.   
  35.   /* I2C Periph clock enable */
  36.   RCC_APB1PeriphClockCmd(I2C_MEMS_CLK, ENABLE);   
  37.   
  38.   /* GPIO Periph clock enable */
  39.   RCC_APB2PeriphClockCmd(I2C_MEMS_GPIO_CLK, ENABLE);    
  40.   
  41.   /* GPIO configuration */
  42.   GPIO_InitStructure.GPIO_Pin =  I2C_MEMS_SCL | I2C_MEMS_SDA; 
  43.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  44.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
  45.   GPIO_Init(I2C_MEMS_GPIO, &GPIO_InitStructure);  
  46.   
  47.    /* I2C configuration */
  48.   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  49.   I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  50.   I2C_InitStructure.I2C_OwnAddress1 = I2C_SLAVE_ADDRESS7;
  51.   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  52.   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  53.   I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
  54.   
  55.   /* I2C Peripheral Enable */
  56.   I2C_Cmd(I2C_MEMS, ENABLE);
  57.   /* Apply I2C configuration after enabling it */
  58.   I2C_Init(I2C_MEMS, &I2C_InitStructure);
  59. }
  60.  
  61. void I2C_Master_DeInit(void)
  62. {
  63.   GPIO_InitTypeDef  GPIO_InitStructure;  
  64.     
  65.   /* UnConfigure I2C */
  66.   I2C_DeInit(I2C_MEMS);
  67.   I2C_Cmd(I2C_MEMS, DISABLE);
  68.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, DISABLE);
  69.            
  70.   /* UnConfigure I2C_MEMS pins: SCL and SDA */
  71.   GPIO_InitStructure.GPIO_Pin = I2C_MEMS_SCL | I2C_MEMS_SDA; 
  72.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  73.   GPIO_Init(I2C_MEMS_GPIO, &GPIO_InitStructure);  
  74.   
  75. }
  76.  
  77.  
  78. int I2C_Master_Read(uint8_t deviceAddr, uint8_t readAddr, uint8_t* pBuffer, uint16_t numByteToRead) {
  79.   
  80.   __IO uint32_t temp = 0;
  81.   volatile int I2C_TimeOut = 0;
  82.   
  83.   // /* While the bus is busy * /
  84.   I2C_TimeOut = I2C_TIMEOUT;
  85.   while(I2C_GetFlagStatus(I2C_MEMS, I2C_FLAG_BUSY))
  86.   {
  87.  if (I2C_TimeOut-- <= 0){
  88.   return(I2C_TIMEOUT_UserCallback());
  89.  }
  90.   }
  91.   
  92.   
  93.   // * Send START condition * /
  94.   I2C_GenerateSTART(I2C_MEMS, ENABLE);
  95.  
  96.   // / * Test on EV5 and clear it * /
  97.   I2C_TimeOut = I2C_TIMEOUT;
  98.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_MODE_SELECT))
  99.   {
  100.  if (I2C_TimeOut-- <= 0){
  101.   return(I2C_TIMEOUT_UserCallback());
  102.  }
  103.   }
  104.   
  105.   // / * Send EEPROM address for write  * /
  106.   I2C_Send7bitAddress(I2C_MEMS, deviceAddr, I2C_Direction_Transmitter);
  107.  
  108.   // / * Test on EV6 and clear it * /
  109.   I2C_TimeOut = I2C_TIMEOUT;
  110.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  111.   {
  112.  if (I2C_TimeOut-- <= 0){
  113.   return(I2C_TIMEOUT_UserCallback());
  114.  }
  115.   }
  116.   
  117.   // / * Send the EEPROM's internal address to read from: Only one byte address  * /
  118.   I2C_SendData(I2C_MEMS, readAddr);  
  119.  
  120.   /// * Test on EV8 and clear it * /
  121.   I2C_TimeOut = I2C_TIMEOUT;
  122.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  123.   {
  124.  if (I2C_TimeOut-- <= 0){
  125.   return(I2C_TIMEOUT_UserCallback());
  126.  }
  127.   }  
  128.     
  129.   /// * Send STRAT condition a second time * /  
  130.   I2C_GenerateSTART(I2C_MEMS, ENABLE);
  131.  
  132.   /// * Test on EV5 and clear it * /
  133.   I2C_TimeOut = I2C_TIMEOUT;
  134.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_MODE_SELECT))
  135.   {
  136.  if (I2C_TimeOut-- <= 0){
  137.   return(I2C_TIMEOUT_UserCallback());
  138.  }
  139.   }  
  140.   
  141.     // * Send EEPROM address for read * /
  142.   I2C_Send7bitAddress(I2C_MEMS, deviceAddr, I2C_Direction_Receiver);  
  143.  
  144.   if (numByteToRead == 1)  {
  145.     /* Wait until ADDR is set */
  146.     I2C_TimeOut = I2C_TIMEOUT;
  147.     while ((I2C_MEMS->SR1&0x0002) != 0x0002)
  148.     {
  149.  if (I2C_TimeOut-- <= 0){
  150.   return(I2C_TIMEOUT_UserCallback());
  151.  }
  152.     }    
  153.    /* Clear ACK bit */
  154.     I2C_MEMS->CR1 &= CR1_ACK_Reset;
  155.     /* Disable all active IRQs around ADDR clearing and STOP programming because the EV6_3
  156.     software sequence must complete before the current byte end of transfer */
  157.     __disable_irq();
  158.     /* Clear ADDR flag */
  159.     temp = I2C_MEMS->SR2;
  160.     /* Program the STOP */
  161.     I2C_GenerateSTOP(I2C_MEMS, ENABLE);
  162.     /* Re-enable IRQs */
  163.     __enable_irq();
  164.     /* Wait until a data is received in DR register (RXNE = 1) EV7 */
  165.     I2C_TimeOut = I2C_TIMEOUT;
  166.     while ((I2C_MEMS->SR1 & 0x00040) != 0x000040)
  167.     {
  168.  if (I2C_TimeOut-- <= 0){
  169.   return(I2C_TIMEOUT_UserCallback());
  170.  }
  171.     }    
  172.     /* Read the data */
  173.       *pBuffer = I2C_MEMS->DR;
  174.   
  175.   }
  176.   else if (numByteToRead == 2) {
  177.                   
  178.     /* Set POS bit */
  179.     I2C_MEMS->CR1 |= CR1_POS_Set;
  180.     /* Wait until ADDR is set: EV6 */
  181.     I2C_TimeOut = I2C_TIMEOUT;
  182.     while ((I2C_MEMS->SR1&0x0002) != 0x0002)
  183.     {
  184.  if (I2C_TimeOut-- <= 0){
  185.   return(I2C_TIMEOUT_UserCallback());
  186.  }
  187.     }      
  188.     /* EV6_1: The acknowledge disable should be done just after EV6,
  189.     that is after ADDR is cleared, so disable all active IRQs around ADDR clearing and 
  190.     ACK clearing */
  191.     __disable_irq();
  192.     /* Clear ADDR by reading SR2 register  */
  193.     temp = I2C_MEMS->SR2;
  194.     /* Clear ACK */
  195.     I2C_MEMS->CR1 &= CR1_ACK_Reset;
  196.     /*Re-enable IRQs */
  197.     __enable_irq();
  198.     /* Wait until BTF is set */
  199.     I2C_TimeOut = I2C_TIMEOUT;
  200.     while ((I2C_MEMS->SR1 & 0x00004) != 0x000004)
  201.     {
  202.  if (I2C_TimeOut-- <= 0){
  203.   return(I2C_TIMEOUT_UserCallback());
  204.  }
  205.     }        
  206.     /* Disable IRQs around STOP programming and data reading */
  207.     __disable_irq();
  208.     /* Program the STOP */
  209.     I2C_GenerateSTOP(I2C_MEMS, ENABLE);
  210.     /* Read first data */
  211.     *pBuffer = I2C_MEMS->DR;
  212.     /* Re-enable IRQs */
  213.     __enable_irq();
  214.     /**/
  215.     pBuffer++;
  216.     /* Read second data */
  217.     *pBuffer = I2C_MEMS->DR;
  218.     /* Clear POS bit */
  219.     I2C_MEMS->CR1  &= CR1_POS_Reset;
  220.   }
  221.   
  222.  
  223.   else { //numByteToRead > 2 
  224.     // * Test on EV6 and clear it * /
  225.     I2C_TimeOut = I2C_TIMEOUT;
  226.     while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
  227.     {
  228.  if (I2C_TimeOut-- <= 0){
  229.   return(I2C_TIMEOUT_UserCallback());
  230.  }
  231.     }         
  232.     // * While there is data to be read * /
  233.     while(numByteToRead)   {
  234.       /* Receive bytes from first byte until byte N-3 */
  235.       if (numByteToRead != 3) {
  236.         /* Poll on BTF to receive data because in polling mode we can not guarantee the
  237.         EV7 software sequence is managed before the current byte transfer completes */
  238.         I2C_TimeOut = I2C_TIMEOUT;
  239.         while ((I2C_MEMS->SR1 & 0x00004) != 0x000004)
  240.         {
  241.             if (I2C_TimeOut-- <= 0){
  242.                     return(I2C_TIMEOUT_UserCallback());
  243.             }
  244.         }           
  245.         /* Read data */
  246.         *pBuffer = I2C_MEMS->DR;
  247.          pBuffer++;
  248.         /* Decrement the read bytes counter */
  249.         numByteToRead--;
  250.       }
  251.       
  252.       /* it remains to read three data: data N-2, data N-1, Data N */
  253.       if (numByteToRead == 3) {
  254.         /* Wait until BTF is set: Data N-2 in DR and data N -1 in shift register */
  255.         I2C_TimeOut = I2C_TIMEOUT;
  256.         while ((I2C_MEMS->SR1 & 0x00004) != 0x000004)
  257.         {
  258.             if (I2C_TimeOut-- <= 0){
  259.                     return(I2C_TIMEOUT_UserCallback());
  260.             }
  261.         }            
  262.         /* Clear ACK */
  263.         I2C_MEMS->CR1 &= CR1_ACK_Reset;
  264.     
  265.         /* Disable IRQs around data reading and STOP programming */
  266.         __disable_irq();
  267.         /* Read Data N-2 */
  268.         *pBuffer = I2C_MEMS->DR;
  269.         /* Increment */
  270.         pBuffer++;
  271.         /* Program the STOP */
  272.         I2C_MEMS->CR1 |= CR1_STOP_Set;
  273.         /* Read DataN-1 */
  274.         *pBuffer = I2C_MEMS->DR;
  275.         /* Re-enable IRQs */
  276.         __enable_irq();
  277.         /* Increment */
  278.         pBuffer++;
  279.         /* Wait until RXNE is set (DR contains the last data) */
  280.         I2C_TimeOut = I2C_TIMEOUT;
  281.         while ((I2C_MEMS->SR1 & 0x00040) != 0x000040)
  282.         {
  283.             if (I2C_TimeOut-- <= 0){
  284.                     return(I2C_TIMEOUT_UserCallback());
  285.             }
  286.         }           
  287.         /* Read DataN */
  288.         *pBuffer = I2C_MEMS->DR;
  289.         /* Reset the number of bytes to be read by master */
  290.         numByteToRead = 0;
  291.       }
  292.     }
  293.   }
  294.  
  295.   /* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
  296.   I2C_TimeOut = I2C_TIMEOUT;
  297.   while ((I2C_MEMS->CR1&0x200) == 0x200)
  298.   {
  299.             if (I2C_TimeOut-- <= 0){
  300.                     return(I2C_TIMEOUT_UserCallback());
  301.             }
  302.   }             
  303.   
  304.   // * Enable Acknowledgement to be ready for another reception * /
  305.   I2C_AcknowledgeConfig(I2C_MEMS, ENABLE);
  306.   
  307.   return 0;
  308.     
  309. }
  310.  
  311. int I2C_Master_Write(uint8_t deviceAddress, uint8_t WriteAddr, uint8_t* pBuffer, uint16_t numByteToWrite) {    
  312.   
  313.   volatile int I2C_TimeOut = 0;  
  314.   
  315.   /* Send STRAT condition */
  316.   I2C_GenerateSTART(I2C_MEMS, ENABLE);
  317.  
  318.   /* Test on EV5 and clear it */
  319.   I2C_TimeOut = I2C_TIMEOUT;
  320.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_MODE_SELECT))
  321.   {
  322.     if (I2C_TimeOut-- <= 0){
  323.             return(I2C_TIMEOUT_UserCallback());
  324.     }
  325.   }       
  326.  
  327.   /* Send EEPROM address for write */
  328.   I2C_Send7bitAddress(I2C_MEMS, deviceAddress, I2C_Direction_Transmitter);
  329.   
  330.   /* Test on EV6 and clear it */
  331.   I2C_TimeOut = I2C_TIMEOUT;
  332.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  333.   {
  334.     if (I2C_TimeOut-- <= 0){
  335.             return(I2C_TIMEOUT_UserCallback());
  336.     }
  337.   }        
  338.  
  339.   /* Send the EEPROM's internal address to write to : only one byte Address */
  340.   I2C_SendData(I2C_MEMS, WriteAddr); 
  341.   
  342.   /* Test on EV8 and clear it */
  343.   I2C_TimeOut = I2C_TIMEOUT;
  344.   while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  345.   {
  346.     if (I2C_TimeOut-- <= 0){
  347.             return(I2C_TIMEOUT_UserCallback());
  348.     }
  349.   }        
  350.  
  351.   while(numByteToWrite > 0) {
  352.     /* Send the byte to be written */
  353.     I2C_SendData(I2C_MEMS, *pBuffer); 
  354.    
  355.     /* Test on EV8 and clear it */
  356.     I2C_TimeOut = I2C_TIMEOUT;
  357.     while(!I2C_CheckEvent(I2C_MEMS, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  358.     {
  359.       if (I2C_TimeOut-- <= 0){
  360.             return(I2C_TIMEOUT_UserCallback());
  361.       }
  362.     }     
  363.   
  364.     pBuffer++;
  365.     numByteToWrite--;
  366.   }
  367.   
  368.   /* Send STOP condition */
  369.   I2C_GenerateSTOP(I2C_MEMS, ENABLE);
  370.   
  371.   return 0;
  372. }
  373.  
  374. int I2C_TIMEOUT_UserCallback(void)
  375. {
  376.   /* User can add his own implementation to manage TimeOut Communication failure */
  377.   /* Block communication and all processes */
  378.   I2C_Master_DeInit();
  379.   for(int i=0; i<3000; i++){__asm("nop");}
  380.   I2C_Master_Init();
  381.   for(int i=0; i<3000; i++){__asm("nop");}
  382.   return -1;
  383. }
  384.  

張貼者： 於
標籤：

沒有留言:

張貼留言

訂閱： 張貼留言 (Atom)