设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › stm8用IIC读写24c02源程序
返回列表 发新帖
查看: 6028|回复: 1
收起左侧

stm8用IIC读写24c02源程序

[复制链接]
ID:170809 发表于 2017-3-15 09:06 | 显示全部楼层 |阅读模式
给大家分享一个 stm8单片机用IIC总线方式读写24c02存储芯片 里面是自己写的程序
0.png
完整源码下载：
4.I2C 24C02.rar (396.59 KB, 下载次数: 85)


下面是部分文件预览：
  1. #include"i2c.h"

  3. uint8_t receive[N],send[N];             //全局数组变量

  5. void I2C_Start()       //发送起始信号——在SCL为高电平期间，SDA由高拉低
  6. {
  7.   SDA_OUT;
  8.   SDA_1;
  9.   SCL_1;
  10.   Delay_us(3);
  11.   SDA_0;
  12.   Delay_us(5);
  13.   SCL_0;
  14.   Delay_us(1);  
  15. }

  17. void I2C_Stop()          //结束信号——在SCL为高电平期间，SDA由低拉高
  18. {
  19.    SDA_OUT;
  20.    SDA_0;
  21.    SCL_0;
  22.    Delay_us(1);
  23.    SCL_1;
  24.    Delay_us(3);
  25.    SDA_1;
  26.    Delay_us(5);
  27.    SCL_0;  
  28.    Delay_us(1);
  29. }

  31. void I2C_Ack()            //检测应答——第9个时钟周期时，由24C16将SDA拉低
  32. {
  33.   SDA_1;
  34.   Delay_us(3);
  35.   SDA_IN;
  36.   Delay_us(1);
  37.   SCL_1;
  38.   Delay_us(2);
  39.   SCL_0;
  40.   Delay_us(3);
  41. }
  42. uint8_t I2C_Ack2()          //检测应答2
  43. {

  45.   SDA_1;
  46.   Delay_us(3);
  47.   SDA_IN;
  48.   Delay_us(2);  
  49.   SCL_1;
  50.   Delay_us(2);

  52. //  while(SDA);             //很快能完成应答，不需要等待，防止硬件故障导致出错
  53.   SCL_0;
  54.   Delay_us(2);
  55.   return SDA;
  56. }


  59. uint8_t I2C_Send(uint8_t buffer)           //发送1个字节的数据
  60. {
  61.   uint8_t temp = 0;
  62.   uint8_t BitCnt = 7;
  63.   
  64.   SDA_OUT;             //SDA为输出
  65.   Delay_us(1);
  66.   if((buffer&0x80)==0)    //由高位开始发送
  67.     SDA_0;
  68.   else
  69.     SDA_1;
  70.   Delay_us(1);
  71.   SCL_1;
  72.   Delay_us(1);
  73.   temp = buffer<<1;
  74.   buffer = temp;
  75.   while(BitCnt)
  76.   {
  77.     if((buffer&0x80)==0)
  78.     {
  79.       SCL_0;
  80.       SDA_0;
  81.     }
  82.     else
  83.     {
  84.       SCL_0;
  85.       SDA_1;
  86.     }
  87.     Delay_us(3);
  88.     SCL_1;
  89.     Delay_us(2);
  90.     temp = buffer<<1;
  91.     buffer = temp;
  92.     BitCnt--;
  93.   }
  94.   SCL_0;  
  95.   if(I2C_Ack2())           //发送8位数据后，检测应答 0：无应答 1：有应答   
  96.     return 0;
  97.   else
  98.     return 1;  
  99. }


  102. uint8_t I2C_Receive()             //接收一个字节的数据
  103. {
  104.   uint8_t ReceiveData,i;
  105.   SDA_IN;               //SDA为输入
  106.   Delay_us(1);
  107.   for(i=0;i<8;i++)      //SCL高电平时，记录SDA,由高位开始
  108.   {
  109.     SCL_1;
  110.     Delay_us(2);        //延时的时间
  111.     if(SDA==0)
  112.       ReceiveData &= 0xfe;
  113.     else
  114.       ReceiveData |= 0x01;
  115.     if(i<7)
  116.       ReceiveData = ReceiveData<<1;

  118.     SCL_0;
  119.     Delay_us(1);
  120.   }
  121.   return ReceiveData;
  122. }

  124. void I2C_NoAck()                //接收数据后不发送应答
  125. {
  126.   SDA_1;
  127.   SDA_OUT;
  128.   SDA_1;
  129.   Delay_us(1);
  130.   SCL_1;
  131.   Delay_us(2);
  132.   SCL_0;
  133.   Delay_us(2);
  134.   SDA_0;
  135.   Delay_us(2);
  136. }

  138. void I2C_SendAck()              //接收数据后发送应答，由主机发送，告知24C16已经接收到一个字节的数据
  139. {
  140.   SDA_OUT;
  141.   SDA_0;
  142.   Delay_us(1);
  143.   SCL_1;
  144.   Delay_us(3);
  145.   SCL_0;
  146.   SDA_0;
  147.   Delay_us(2);
  148. }

  150. void I2C_Write_Byte(uint8_t addr,uint8_t data)       //向24C06写入数据——单字节写
  151. {                                                                  

  153.     I2C_Start();                                //起始信号
  154.     I2C_Send(0xa0);                             //发送器件地址
  155.     I2C_Send(addr);                             //发送字节地址
  156.     I2C_Send(data);                             //发送数据
  157.     I2C_Stop();                                 //结束信号
  158. }

  160. void I2C_Write_Page(uint8_t addr,uint8_t data)       //向24C06写入数据——页写 16个字节
  161. {                                                                  
  162.   uint8_t i,j,k,p;
  163.   
  164.   if((N/16)==0)                 //判断N是否小于16 是：一次页写即可完成   否：需要多次页写
  165.   {
  166.       I2C_Start();                              //起始信号
  167.       I2C_Send(0xa0);                           //发送器件地址
  168.       I2C_Send(addr);                           //发送字节地址
  169.       for(j=0;j<N;j++)
  170.       {  
  171.         send[j] = data+j;
  172.         I2C_Send(send[j]);                      //发送数据      
  173.       }
  174.       I2C_Stop();                               //结束信号     
  175.       Delay_ms(5);
  176.   }
  177.   else                                          //多次页写
  178.   {
  179.     for(i=0;i<(N/16);i++)                       //i次页写
  180.     {
  181.       I2C_Start();                              //起始信号
  182.       I2C_Send(0xa0);                           //发送器件地址
  183.       I2C_Send(addr+i*16);                      //发送字节地址
  184.       for(j=0;j<16;j++)
  185.       {  
  186.         send[i*16+j] = data+i*16+j;
  187.         I2C_Send(send[i*16+j]);                 //发送数据      
  188.       }
  189.       I2C_Stop();                               //结束信号  
  190.       Delay_ms(5);
  191.     }
  192.    
  193.     if(N%16)                                    //写剩余的数据
  194.     {
  195.       p=N-(N%16);
  196.       I2C_Start();                              //起始信号
  197.       I2C_Send(0xa0);                           //发送器件地址   
  198.       I2C_Send(addr+p);                         //发送字节地址
  199.       for(k=0;k<(N%16);k++)  
  200.       {  
  201.         send[i*16+k] = data+i*16+k;
  202.         I2C_Send(send[i*16+k]);                 //发送数据      
  203.       }
  204.       I2C_Stop();                               //结束信号
  205.       Delay_ms(5);
  206.     }
  207.   }
  208. }


  211. void I2C_Read2(uint8_t add_start)//连续读
  212. {
  213.   uint8_t i;
  214.   
  215.   I2C_Start();                  //起始信号
  216.   I2C_Send(0xa0);               //发送器件地址——写
  217.   I2C_Send(add_start);          //发送字节地址
  218.   I2C_Start();                  //起始信号
  219.   I2C_Send(0xa1);               //发送器件地址——读
  220.   for(i=0;i<N-1;i++)
  221.   {  
  222.     receive[i]=I2C_Receive();
  223.     I2C_SendAck();              //主机发送应答，继续读
  224.   }
  225.   receive[i]=I2C_Receive();
  226.   I2C_NoAck();                  //第九个周期发送不应答
  227.   I2C_Stop();                   //停止信号
  228. // return receive;
  229. }


  232. uint8_t I2C_Read(uint8_t addr)                  //从24C06读出数据  
  233. {
  234.   uint8_t receive;
  235.   I2C_Start();                  //起始信号
  236.   I2C_Send(0xa0);               //发送器件地址——写
  237.   I2C_Send(addr);               //发送字节地址
  238.   I2C_Start();                  //起始信号
  239.   I2C_Send(0xa1);               //发送器件地址——读
  240.   receive=I2C_Receive();        //读出数据
  241.   I2C_Stop();                 //停止信号,结束读数据操作
  242.   return receive;
  243. }  

  245. void I2C_Ack_Check()          //应答查询
  246. {
  247.   I2C_Start();
  248.   I2C_Send(0xa0);
  249.   I2C_Ack2();
  250. }

  252. /*
  253. void test_1(uint8_t add,uint8_t data)     //单次测试
  254. {
  255.   uint8_t test=0;
  256.   I2C_Write_Byte(add,data);
  257.   Delay_ms(5);
  258.   test = I2C_Read(add);

  260.   if(test==data)
  261.     LED = LED1;
  262.   else
  263.     LED = LED2;
  264. }

  266. void test_write(uint8_t add,uint8_t data)     //测试_写
  267. {
  268.   
  269.   I2C_Write_Byte(add,data);
  270.   Delay_ms(5);
  271. }  
  272. uint8_t test_read(uint8_t add)                //测试_读
  273. {
  274.   uint8_t test=0;
  275.   test = I2C_Read(add);
  276.   return test;
  277. }

  279. void test1(uint8_t add_start)                  //测试函数1  
  280. {
  281.   uint8_t read[N]={0},write[N]={0},i,k=0;
  282.   
  283.   for(i=0;i<N;i++)
  284.   {
  285.     write[i]=0x02+i;
  286.     test_write(add_start+i,write[i]);
  287.   }
  288.   
  289.   for(i=0;i<N;i++)
  290.   {
  291.     read[i]=test_read(add_start+i);
  292.   }
  293.   for(i=0;i<N;i++)
  294.   {
  295.     if(write[i]==read[i])
  296.       k+=1;
  297.   }
  298.   if(k==N)
  299.     LED = LED1;
  300.   else
  301.     LED = LED2;
  302. }
  303. */
  304. void test2(uint8_t add_start,uint8_t data)                  //测试函数2  
  305. {
  306.   uint8_t i,k=0;
  307.   I2C_Write_Page(add_start,data);
  308.   I2C_Read2(add_start);
  309.   for(i=0;i<N;i++)
  310.   {
  311.     if(receive[i]==send[i])
  312.       k+=1;
  313.   }
  314.   if(k==N)
  315.     LED = LED1;
  316.   else
  317.     LED = LED2;
  318.   for(i=0;i<N;i++)
  319.   {
  320.     receive[i]=0;
  321.     send[i]=0;
  322.   }
  323.   
  324. }


  327. #pragma vector=5                //PA口的中断服务函数
  328. __interrupt void PORTA_IRQHandler(void)
  329. {
  330.   Delay_ms(20);                 //软件消抖
  331.   if(!(PA_IDR&0x04))
  332.   {
  333.     Delay_ms(20);
  334.     while(!(PA_IDR&0x04));

  336.     test2(0x00,0x06);
  337.   }
  338. }
复制代码


回复

使用道具 举报

ID:99174 发表于 2017-3-23 19:26 | 显示全部楼层
建议，延时加长，数据手册上说的是4.7us. 应答信号要加防出错标志，不等直接过，大批量的生产就会出问题
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表