开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
I2C.c
资源名称：msp430.rar　[点击查看]
上传用户：xs588588
上传日期：2021-03-30
资源大小：242k
文件大小：5k
源码类别：

DSP编程

开发平台：

C/C++

I2C.c：源码内容
  1. #include "I2C.h"
  3. void I2C_Initial( void )
  4. {
  5.     P1DIR |= SCL; //将SCL管脚（P1.3)设置为输出管脚
  6.     I2C_Set_sck_low();
  7.     I2C_STOP();
  8.     Delay_ms(10);
  9.     return;
  10. }
  11. void I2C_Set_sda_high( void )
  12. {
  13.     P1DIR |= SDA; //将SDA设置为输出模式
  14.     P1OUT |= SDA; //SDA管脚输出为高电平
  15.     
  16.     _NOP();
  17.     _NOP();
  18.     return;
  19. }
  20. void I2C_Set_sda_low ( void )
  21. {
  22.     P1DIR |= SDA; //将SDA设置为输出模式
  23.     P1OUT &= ~(SDA); //SDA管脚输出为低电平
  24.     
  25.     _NOP();
  26.     _NOP();
  27.     return;
  28. }
  29. void I2C_Set_sck_high( void )
  30. {
  31.     P1DIR |= SCL; //将SCL设置为输出模式
  32.     P1OUT |= SCL; //SCL管脚输出为高电平
  33.     
  34.     _NOP();
  35.     _NOP();
  36.     return;
  37. }
  38. void I2C_Set_sck_low ( void )
  39. {
  40.     P1DIR |= SCL; //将SCL设置为输出模式
  41.     P1OUT &= ~(SCL); //SCL管脚输出为低电平
  42.     
  43.     _NOP();
  44.     _NOP();
  45.     return;
  46. }
  47. int  I2C_GetACK(void)
  48. {
  49.     int nTemp = 0;
  50.     int j;
  51.     
  52.     _NOP();
  53.     _NOP();
  54.     I2C_Set_sck_low();
  55.     for(j = 30;j > 0;j--);
  56.     P1DIR &= ~(SDA); //将SDA设置为输入方向
  57.     //I2C_Set_sda_high();
  58.     I2C_Set_sck_high();
  59.     
  60.     for(j = 30;j > 0;j--);
  61.     nTemp = (int)(P1IN & SDA); //获得数据
  62.     
  63.     I2C_Set_sck_low();
  64.     
  65.     return (nTemp & SDA);
  66. }
  67. void I2C_SetACK(void)
  68. {   
  69.     I2C_Set_sck_low();
  70.     I2C_Set_sda_low();
  71.     I2C_Set_sck_high();
  72.     I2C_Set_sck_low();
  73.     return;
  74. }
  75. void I2C_SetNAk(void)
  76. {
  77.     I2C_Set_sck_low();
  78.     I2C_Set_sda_high();
  79.     I2C_Set_sck_high();
  80.     I2C_Set_sck_low();
  81.     return;
  82. }
  83. void I2C_START(void)
  84. {
  85.     int i;
  86.     
  87.     I2C_Set_sda_high();
  88.     for(i = 5;i > 0;i--);
  89.     I2C_Set_sck_high();
  90.     for(i = 5;i > 0;i--);
  91.     I2C_Set_sda_low();
  92.     for(i = 5;i > 0;i--);
  93.     I2C_Set_sck_low();
  94.     return;
  95. }
  96. void I2C_STOP(void)
  97. {
  98.     int i;
  99.     
  100.     I2C_Set_sda_low();
  101.     for(i = 5;i > 0;i--);
  102.     I2C_Set_sck_low();
  103.     for(i = 5;i > 0;i--);
  104.     I2C_Set_sck_high();
  105.     for(i = 5;i > 0;i--);
  106.     I2C_Set_sda_high();
  107.     for(i = 5;i > 0;i--);
  108.     I2C_Set_sck_low();
  109.     Delay_ms(10); //延迟一点时间
  110.     
  111.     return;
  112. }
  113. void I2C_TxByte(int nValue)
  114. {
  115.     int i;
  116.     int j;
  117.     
  118.     for(i = 0;i < 8;i++)
  119.     {
  120.      if(nValue & 0x80)
  121.          I2C_Set_sda_high();
  122.      else
  123.          I2C_Set_sda_low();
  124.      for(j = 30;j > 0;j--);
  125.      I2C_Set_sck_high();
  126.      nValue <<= 1;
  127.      for(j = 30;j > 0;j--);
  128.      I2C_Set_sck_low();
  129.     }
  130.     
  131.     return;
  132. }
  133. /////////////////////////////////////////////
  134. // 接收是从 LSB 到 MSB 的顺序
  135. int  I2C_RxByte(void)
  136. {
  137.     int nTemp = 0;
  138.     int i;
  139.     int j;
  140.     
  141.     I2C_Set_sda_high();
  142.     
  143.     P1DIR &= ~(SDA); //将SDA管脚设置为输入方向
  144.     _NOP();
  145.     _NOP();
  146.     _NOP();
  147.     _NOP();
  148.     for(i = 0;i < 8;i++)
  149.     {
  150.      I2C_Set_sck_high();
  151.     
  152.      if(P1IN & SDA)
  153.      {
  154.          nTemp |= (0x01 << i);
  155.      }
  156.      for(j = 30;j > 0;j--);
  157.      I2C_Set_sck_low();
  158.     }
  159.     
  160.     return nTemp;
  161. }
  162. void I2C_Write(char nAddr,char nValue)
  163. {
  164. int nTemp = 0xA0;//写命令
  165. // 启动数据总线
  166. I2C_START();
  167. // 发送控制字节
  168. I2C_TxByte(nTemp);
  169. // 等待 ACK
  170. nTemp = I2C_GetACK();
  172. // 发送地址字节
  173. I2C_TxByte(nAddr);
  174. // 等待 ACK
  175. nTemp = I2C_GetACK();
  177. // 发送数据字节
  178. I2C_TxByte(nValue);
  179. // 等待 ACK
  180. nTemp = I2C_GetACK();
  182. // 停止总线
  183. I2C_STOP();
  184.         return;
  185. }
  186. int PageWrite(char nAddr,char pBuf[])
  187. {
  188. int i;
  189. int nTemp = 0xA0;//写命令
  190. // 启动数据总线
  191. I2C_START();
  192. // 发送控制字节
  193. I2C_TxByte(nTemp);
  194. // 等待 ACK
  195. nTemp = I2C_GetACK();
  196. if(nTemp & BIT3) return 0;
  198. // 发送地址字节
  199. I2C_TxByte(nAddr);
  200. // 等待 ACK
  201. nTemp = I2C_GetACK();
  202. if(nTemp & BIT3) return 0;
  204. // 发送数据字节
  205. for(i = 0; i < 8;i++)
  206. {
  207. I2C_TxByte(pBuf[0]);
  208. // 等待 ACK
  209. nTemp = I2C_GetACK();
  210. if(nTemp & BIT3) return 0;
  211. }
  213. // 停止总线
  214. I2C_STOP();
  215.     return (nTemp & SDA);
  216. }
  217. char I2C_Read(int nAddr)
  218. {
  219.         int nRes = -1;
  220. //写命令
  221. int nTemp = 0xA0;
  222. // 启动数据总线
  223. I2C_START();
  224. // 发送控制字节
  225. I2C_TxByte(nTemp);
  226. // 等待 ACK
  227. nTemp = I2C_GetACK();
  229. // 发送地址字节
  230. I2C_TxByte(nAddr);
  231. // 等待 ACK
  232. nTemp = I2C_GetACK();
  234. // 启动数据总线
  235. I2C_START();
  236. // 发送控制字节
  237. nTemp = 0xA1;
  238. I2C_TxByte(nTemp);
  239. // 等待 ACK
  240. nTemp = I2C_GetACK();
  242. //读取数据
  243.     nRes = I2C_RxByte();
  245. // 停止总线
  246. I2C_STOP();
  247. //成功返回
  248. return nRes;
  249. }
  250. int ReadSeq(char nAddr, char nValue[], int nLen)
  251. {
  252. int i;
  253. //写命令
  254. int nTemp = 0xA0;
  255. // 启动数据总线
  256. I2C_START();
  257. // 发送控制字节
  258. I2C_TxByte(nTemp);
  259. // 等待 ACK
  260. nTemp = I2C_GetACK();
  261. if(nTemp & BIT3) return 0;
  263. // 发送地址字节
  264. I2C_TxByte(nAddr);
  265. // 等待 ACK
  266. nTemp = I2C_GetACK();
  267. if(nTemp & BIT3) return 0;
  269. // 启动数据总线
  270. I2C_START();
  271. // 发送控制字节
  272. nTemp = 0xA1;
  273. I2C_TxByte(nTemp);
  274. // 等待 ACK
  275. nTemp = I2C_GetACK();
  276. if(nTemp & BIT3) return 0;
  278. //读取数据
  279. for(i = 0; i < nLen; i++)
  280. {
  281. //读一个字节数据
  282. nValue[i] = I2C_RxByte();
  283. //发送ACK
  284. I2C_SetACK();
  285. }    
  287. // 停止总线
  288. I2C_STOP();
  289. //成功返回
  290. return 1;
  291. }
  292. void Delay_ms(unsigned long nValue)//毫秒为单位，8MHz为主时钟
  293. {
  294.     unsigned long nCount;
  295.     int i;
  296.     unsigned long j;
  297.     nCount = 2667;
  298.     for(i = nValue;i > 0;i--)
  299.     {
  300.      for(j = nCount;j > 0;j--);
  301.     }
  302.     return;
  303. }
  304. void Delay_us(unsigned long nValue)//微秒为单位，8MHz为主时钟
  305. {
  306.     int nCount;
  307.     int i;
  308.     int j;
  309.     nCount = 3;
  310.     for(i = nValue;i > 0;i--)
  311.     {
  312.      for(j = nCount;j > 0;j--);
  313.     }
  314.     return;
  315. }