Simulate I2C interface code under STM32F103

Although hardware I2C is efficient, I always encounter various problems when debugging. I don’t have much time to mess around with it due to the rush of the project, so I use simulated I2C to complete it. Although the efficiency is not very good, it is simple and fast...

Without further ado, here is a fully annotated version of the simulated I2C code, which is applicable to the STM32 series. For other microcontrollers, you need to modify the definitions of SCL and SDA and modify the delay function.

1. #include "stm32f10x.h"  

2.   

3. #define HIGH 1  

4. #define LOW 0  

5.   

6. #define TRUE 1  

7. #define FALSE  

8.   

9. /* Here we use the STM32F103RC chip, using PB6 and PB7 as SCL and SDA respectively.  

10. Other chips use appropriate GPIO ports according to needs */  

11. #define SDA_IN()  {GPIOB->CRL& = 0X0FFFFFFF; GPIOB->CRL |= 4<<28;}  

12. #define SDA_OUT() {GPIOB->CRL& = 0X0FFFFFFF; GPIOB->CRL |= 3<<28;}  

13. #define IIC_SCL    PBout(6) //SCL  

14. #define IIC_SDA PBout(7) //SDA      

15. #define READ_SDA PBin(7) // Input SDA  

16.   

17. void delay_us(u16 time)  

18. {      

19.    u16 i = 0;    

20.    while(time--)  

21.    {  

22.       i = 10; //A random value, meaningless, just consuming CPU time, the compiler may be optimized    

23.       while(i--);      

24.    }  

25. }  

26.   

27. /* Initialize I2C */  

28. void IIC_Init(void)  

29. {  

30.     GPIO_InitTypeDef GPIO_Init_Structure;  

31.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);  

32.     GPIO_Init_Structure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;  

33.     GPIO_Init_Structure.GPIO_Mode = GPIO_Mode_Out_PP;  

34.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_50MHz;  

35.     GPIO_Init(GPIOB,&GPIO_Init_Structure);  

36.     GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);  

37. }  

38.   

39. /* Generate I2C start signal */  

40. void IIC_Start(void)  

41. {  

42.     /* Set the SDA line to output */  

43.     SDA_OUT();       

44.       

45.     /* Before starting to transmit data, pull both SDA and SCL high */  

46.     IIC_SDA = HIGH;         

47.     IIC_SCL = HIGH;  

48.       

49.     delay_us(5);  

50.       

51.     /* According to the I2C bus definition: When SCL is high, the data jumps from high to low to indicate the start signal */  

52.     IIC_SDA = LOW;  

53.     delay_us(5);  

54.       

55.     /*  

56.     When SCL is low, no data is transmitted and it is not used as a start or end condition.  

57.     So we can start sending data without causing a start or end signal  

58.     This is called clamping the I2C bus. 

59.     */  

60.     IIC_SCL = LOW;  

61. }  

62.   

63. /* Generate I2C stop signal */  

64. void IIC_Stop(void)  

65. {  

66.     SDA_OUT(); //sda line output  

67.       

68.     /*  

69.     First pull SCL low so that SDA can be switched to a low state without causing repeated start signals.  

70.     Remember the previous comment on I2C Start? When SCL is high, SDA changes from high to low. 

71.     */  

72.     IIC_SCL = LOW;  

73.       

74.     /*  

75.         SCL has been pulled low before, so here we can pull SDA low without restraint.  

76.         Prepare for the end signal 

77.     */  

78.     IIC_SDA = LOW;  

79.       

80.     delay_us(5);  

81.       

82.     /* Okay, let's start generating the end signal: First, we need to pull SCL high (why? Because the I2C bus specifies 

83.     Only when SCL is high is it the effective time to transmit data or generate start/end signals) */  

84.     IIC_SCL = HIGH;   

85.       

86.     /* Okay, we have already pulled SDA low, so here we just need to set SDA high to complete it */  

87.     IIC_SDA = HIGH;  

88.     delay_us(5);                                  

89. }  

90.   

91. /* 

92. Meaning of the response signal: 

93. The Master needs to wait for the Slave's ACK after sending each 8 bits of data. 

94. That is, at the 9th clock, if the slave IC sends an ACK, then SDA will be pulled low. 

95. If there is no ACK, SDA will be set high, which will cause the Master to issue a Restart or Stop process 

96. */  

97. /*  

98.     Waiting for the response signal to arrive 

99. */  

100. u8 IIC_Wait_Ack(void)  

101. {  

102.     u8 ucErrTime = 0;   

103.     IIC_SDA = HIGH;  

104.     delay_us(5);  

105.       

106.     /* Set SDA to input mode, so as to read the ACK on SDA */  

107.     SDA_IN();        

108.       

109.     /* Set SCL high to perform a read operation */  

110.     IIC_SCL = HIGH;  

111.     delay_us(5);      

112.       

113.     while(READ_SDA)  

114.     {  

115.         ucErrTime++;  

116.         if(ucErrTime > 250)  

117.         {//No ACK received from IC within the specified time, timeout processing  

118.             return FALSE;  

119.         }  

120.     }  

121.       

122.     /*  

123.     OK, this means there is no timeout and SDA is read as low, indicating that ACK confirmation is received  

124.     Then you can go home and set SCL to low level (why? Because effective operations are all in 

125.     Only when SCL is high) 

126.     */  

127.     IIC_SCL = LOW;  

128.       

129.     return TRUE;    

130. }  

131.   

132. /* 

133.  Send ACK confirmation operation 

134.  The purpose of issuing this operation is to let the slave IC know that we have received the data. 

135.  In this way, the IC will not perform the Restart or Stop process. 

136. */  

137. void IIC_Ack(void)  

138. {  

139.     /* The first step is to pull SCL low first to avoid SDA changes affecting I2C */  

140.     IIC_SCL = LOW;  

141.       

142.     /* Then we set SDA to output mode and prepare to output data */  

143.     SDA_OUT();  

144.       

145.     /* Pull SDA low, so that the confirmation signal is put on the bus, only the clock signal is missing */  

146.     IIC_SDA = LOW;  

147.       

148.     delay_us(5);  

149.       

150.     /* Pull SCL high to generate the necessary valid operation clock signal */  

151.     IIC_SCL = HIGH;  

152.       

153.     delay_us(5);  

154.       

155.     /*  

156.     There has been a delay before, and the clock is almost up, so the ACK signal ends 

157.     You can't keep occupying the bus all the time */  

158.     IIC_SCL = LOW;  

159. }  

160.   

161. /* 

162. For NACK, the I2C bus is defined as follows: 

163. When the SDA line remains high during the 9th clock pulse, it is defined as NACK. 

164. The master either generates a Stop condition to abandon the transmission or repeats the Start condition to 

165. Initiate a new beginning 

166. */  

167. void IIC_NAck(void)  

168. {  

169.     IIC_SCL = LOW;  

170.     SDA_OUT();  

171.       

172.     /* According to the definition, pull SDA high as the definition of NACK */  

173.     IIC_SDA = HIGH;  

174.     delay_us(5);  

175.       

176.     /* Set to high level, send NACK signal */  

177.     IIC_SCL = HIGH;  

178.     delay_us(5);  

179.       

180.     /* Pull SCL low, sending completed */  

181.     IIC_SCL = LOW;  

182. }  

183.   

184. void IIC_Send_Byte(u8 txd)  

185. {                          

186.     u8 t;    

187.     /* Now that data transmission has started, switch the SDA port to output mode first */      

188.     SDA_OUT();     

189.   

190.     /* Pull the clock signal low, prepare the data and then pull it high for transmission */      

191.     IIC_SCL = LOW;  

192.     for(t = 0; t < 8; t++)  

193.     {       

194.         /* I2C data is transmitted in big-endian format, i.e. the high bit is transmitted first */  

195.         if((txd&0x80) >> 7)  

196.             IIC_SDA = HIGH;  

197.         else  

198.             IIC_SDA = LOW;  

199.           

200.         txd <<= 1;   

201.         /* It is necessary to make a delay */          

202.         delay_us(5);     

203.           

204.         /* Pull SCL high to transmit data */  

205.         IIC_SCL = HIGH;  

206.           

207.         delay_us(5);  

208.           

209.         /* Pull SCL low, transmission completed */  

210.         IIC_SCL = LOW;    

211.           

212.         delay_us(5);  

213.     }      

214. }   

215.   

216. u8 IIC_Read_Byte(void)  

217. {  

218.     unsigned char i, receive = 0;  

219.       

220.     /* Switch the SDA port to input mode, ready to read data */  

221.     SDA_IN();  

222.       

223.     for(i = 0; i < 8; i++ )  

224.     {  

225.         /* Pull SCL low */  

226.         IIC_SCL = LOW;   

227.         delay_us(5);  

228.           

229.         /* Pull SCL high again to generate a valid clock signal */  

230.         IIC_SCL = HIGH;  

231.           

232.         /* Read data on the bus */  

233.         receive = (receive << 1) | READ_SDA;  

234.           

235.         delay_us(5);   

236.     }  

237.       

238.     return receive;  

239. }