标题: 网上看到的mcp3421 iic单片机驱动程序 [打印本页]
作者: tk.minh    时间: 2019-4-19 16:37
标题: 网上看到的mcp3421 iic单片机驱动程序
网上看到的mcp3421 iic驱动    望对你有帮助

单片机源程序如下:


  3. #include  "mcp3421.h"
  4. #include  "delay.h"

  6. void I2CStart(u8 ch)  
  7. {
  8.     EA=0;
  9.     switch(ch)  
  10.     {
  11.             case 1:
  12.             {
  13.                   SDA_1=1;  
  14.                   Delay_ms(10) ;
  15.                   SCL_1=1;  
  16.                   Delay_ms(10) ;
  17.                   SDA_1=0;  
  18.                   Delay_ms(10) ;
  19.                   SCL_1=0;
  20.             }break;
  21.             case 2:
  22.             {
  23.                   SDA_2=1;  
  24.                   Delay_ms(10);  
  25.                   SCL_2=1;  
  26.                   Delay_ms(10);  
  27.                   SDA_2=0;  
  28.                   Delay_ms(10);  
  29.                   SCL_2=0;
  30.             }break;
  31.      default:break;
  32.       }  
  33. }
  34.   
  35.    void I2CStop(u8 ch)  
  36.   {  
  37.     switch(ch)  
  38.     {
  39.             case 1:
  40.             {  
  41.               SCL_1=0;  
  42.               Delay_ms(10);  
  43.               SDA_1=0;  
  44.               Delay_ms(10);  
  45.               SCL_1=1;  
  46.               Delay_ms(10);  
  47.               SDA_1=1;  
  48.               EA=1;
  49.             }break;
  50.             case 2:
  51.             {
  52.               SCL_2=0;  
  53.               Delay_ms(10);  
  54.               SDA_2=0;  
  55.               Delay_ms(10);  
  56.               SCL_2=1;  
  57.               Delay_ms(10);  
  58.               SDA_2=1;  
  59.               EA=1;
  60.                 }break;
  61.             default:break;
  62.       }
  63.    
  64.   }

  66.   
  67. void  WaitAck(u8 ch)  
  68.   {  
  69.   u8 i=20;
  70. switch(ch)  
  71.     {
  72.             case 1:
  73.             {
  74.       
  75.                    SDA_1=1;  
  76.                   Delay_ms(10);  
  77.                   SCL_1=1;  
  78.                   while(i--){  
  79.                             if(SDA_1==1)  
  80.                                     {  
  81.                                     SCL_1=0;  
  82.                                     Delay_ms(10);  
  83.                                     SCL_1=1;  
  84.                                     }  
  85.                             else  
  86.                                 SCL_1=0;  
  87.                               
  88.                             }  
  89.                   return;  
  90.                 }break;
  91.             
  92.                 case 2:
  93.                {
  94.       
  95.                    SDA_2=1;  
  96.                   Delay_ms(10);  
  97.                   SCL_2=1;  
  98.                   while(i--){  
  99.                             if(SDA_2==1)  
  100.                                     {  
  101.                                     SCL_2=0;  
  102.                                     Delay_ms(10)  ;
  103.                                     SCL_2=1;  
  104.                                     }  
  105.                             else  
  106.                                 SCL_2=0;  
  107.                               
  108.                             }  
  109.                                 
  110.                   return;  
  111.                 }break;
  112.      
  113.                 default:break;   
  114.             
  115.         }  
  116.     }
  117.   
  118. void SendAck(u8 ch)  
  119. {
  120. switch(ch)  
  121.     {
  122.             case 1:
  123.             {
  124.             SDA_1=0;  
  125.             Delay_ms(10);  
  126.             SCL_1=1;  
  127.             Delay_ms(10);  
  128.             SCL_1=0;  
  129.             }break;
  130.             case 2:
  131.             {
  132.             SDA_2=0;  
  133.             Delay_ms(10) ;
  134.             SCL_2=1;  
  135.             Delay_ms(10);  
  136.             SCL_2=0;  
  137.             }break;
  138.         default:break;   
  139.     }   
  140. }  
  141.   
  142. void SendNotAck(u8 ch)  
  143. {
  144. switch(ch)  
  145.     {
  146.             case 1:
  147.             {
  148.    
  149.                SDA_1=1;  
  150.                Delay_ms(10);  
  151.                SCL_1=1;  
  152.                Delay_ms(10);  
  153.                SCL_1=0;  
  154.             }break;
  155.             case 2:
  156.             {
  157.    
  158.                SDA_2=1;  
  159.                Delay_ms(10) ;
  160.                SCL_2=1;  
  161.                Delay_ms(10) ;
  162.                SCL_2=0;  
  163.             }break;
  164.             
  165.         default:break;
  166.     }
  167.    
  168. }  
  169.   
  170. void I2CSendbyte(u8 ch,u8 t)  
  171. {  
  172. u8 i=8;
  173. switch(t)  
  174.     {
  175.             case 1:
  176.             {   
  177.              while(i--)  
  178.                 {
  179.                
  180.                  SCL_1=0;  
  181.                  Delay_ms(10);  
  182.                  SDA_1=(bit)(ch&0x80);  
  183.                  ch<<=1;  
  184.                  Delay_ms(10);  
  185.                  SCL_1=1;  
  186.                  Delay_ms(10);  
  187.                 }  
  188.                SCL_1=0;  
  189.             }break;   
  190.             case 2:
  191.             {   
  192.              while(i--)  
  193.                 {
  194.                
  195.                  SCL_2=0;  
  196.                  Delay_ms(10);  
  197.                  SDA_2=(bit)(ch&0x80);  
  198.                  ch<<=1;  
  199.                  Delay_ms(10);  
  200.                  SCL_2=1;  
  201.                  Delay_ms(10);  
  202.                 }  
  203.                SCL_2=0;  
  204.             }break;   
  205.             default:break;
  206.         }        
  207. }  
  208.   
  209. u8 I2CRecebyte(u8 ch)  
  210. {  
  211. u8 i=8;  u8 ddata=0;
  212. switch(ch)  
  213.     {
  214.             case 1:
  215.             {   
  216.              SDA_1=1;  
  217.              while(i--){  
  218.               ddata<<=1;  
  219.               SCL_1=0;  
  220.               Delay_ms(10);  
  221.               SCL_1=1;  
  222.               Delay_ms(10);  
  223.               ddata|=SDA_1;  
  224.              }  
  225.              SCL_1=0;  
  226.             
  227.              }break;   
  228.             
  229.             case 2:
  230.             {   
  231.              SDA_2=1;  
  232.              while(i--){  
  233.               ddata<<=1;  
  234.               SCL_2=0;  
  235.               Delay_ms(10);  
  236.               SCL_2=1;  
  237.               Delay_ms(10);  
  238.               ddata|=SDA_2;  
  239.              }  
  240.              SCL_2=0;  
  241.              return ddata;
  242.              }break;
  243.                 default:break;
  244.         }
  245.     return ddata;         
  246. }  
  247.   
  248. void WRITE_MCP3421(u8 wr_data,u8 ch)  
  249. {  
  250. switch(ch)  
  251.     {
  252.         case 1:
  253.       {
  254.         I2CStart(1);  
  255.          I2CSendbyte(0xd0,1);  
  256.          WaitAck(1);  
  257.          I2CSendbyte(wr_data,1);  
  258.          WaitAck(1);  
  259.          I2CStop(1);  
  260.         }break;
  261.       
  262.       case 2:
  263.       {
  264.         I2CStart(2);  
  265.          I2CSendbyte(0xd0,2);  
  266.          WaitAck(2);  
  267.          I2CSendbyte(wr_data,2);  
  268.          WaitAck(2);  
  269.          I2CStop(2);  
  270.         }break;
  271.         default:break;
  272.         }
  273. }  
  274.   
  275. void READ_MCP3421(u8 ch)  
  276. {
  277.      switch(ch)  
  278.     {
  279.         case 1:
  280.       {
  281.         I2CStart(1);  
  282.          I2CSendbyte(0xd1,1);  
  283.           WaitAck(1);  
  284.           elech=I2CRecebyte(1);  
  285.           SendAck(1);  
  286.           elecl=I2CRecebyte(1);  
  287.           SendAck(1);  
  288.           mcp_busy=I2CRecebyte(1);  
  289.          SendNotAck(1);  
  290.           I2CStop(1);
  291.         }break;
  292.         case 2:
  293.       {
  294.         I2CStart(2);  
  295.          I2CSendbyte(0xd1,2);  
  296.           WaitAck(2);  
  297.           elech=I2CRecebyte(2);  
  298.           SendAck(2);  
  299.           elecl=I2CRecebyte(2);  
  300.           SendAck(2);  
  301.           mcp_busy=I2CRecebyte(2);  
  302.          SendNotAck(2);  
  303.           I2CStop(2);
  304.         }break;
  305.         default:break;
  306.     }
  307.          
  308. }
  309. //
  310. // u32 Get_Adc(u8 ch)
  311. // {
  312. //     u32 vol=0;
  313. //     switch(ch)  
  314. //    {
  315. //        case 1:
  316. //      {
  317. //     WRITE_MCP3421(0x8d,1);
  318. //     vol = READ_MCP3421(1);
  319. //     }break;
  320. //      case 2:
  321. //      {
  322. //     WRITE_MCP3421(0x8d,2);
  323. //     vol =READ_MCP3421(2) + 1;
  324. //    }break;
  325. //     default:break;
  326. //    }
  327. //    return vol;
  328. //   
  329. // }
复制代码

作者: aking991    时间: 2019-6-10 10:48
太好了，我虽对这个芯片已用很久了，但都是自己用经验测试写出来的，看到这个，我才觉行我写出来的差距，谢谢分享，我又可以用这种方法来试验了
作者: cjtdz    时间: 2019-10-16 11:09
下载学习一下
作者: 9291806    时间: 2020-5-27 22:46
谢谢分享，下来学习下。
作者: cdwess    时间: 2020-7-14 14:14
谢谢，刚用这片AD，学习下
作者: lsx116    时间: 2021-12-13 00:40
对于我们新手来说 一条备注都没有搞个蛋
作者: duckfans1    时间: 2023-6-17 23:12
头文件呢
作者: lksbbs    时间: 2024-1-13 20:57
有没有人知道，只读了第一个字节，后面就是读的0了，应答ACK应该是没问题的
作者: cy009    时间: 2024-2-24 13:08
抄也不会抄，mcp3421.h在哪里？



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1