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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › AD7799的单片机驱动程序（带详细注释,完全测试通过）
返回列表 发新帖
查看: 8517|回复: 4
收起左侧

AD7799的单片机驱动程序（带详细注释,完全测试通过）

[复制链接]
ID:319861 发表于 2018-11-25 14:49 | 显示全部楼层 |阅读模式
        本程序由《郑州轻工业大学》星空总创空间327房间鲁路编写,仅限于学习使用,如有问题,请联系:
        QQ:1224595453
        TEL:13071067331
        
        程序使用说明：
                1、Display包中是用与LCD1602显示的相关函数，使用只需重新定义LCD1602.h中的变量或者端口;
                2、Delay包中是相关延时函数;
                3、Main包中包括了实验板上的端口声明，以及菜单显示函数;
                4、AD7799包中是所有对AD7799的配置函数，每次使用时修改下面两个函数即可基本上配置所有AD7799的相关参数;
                        /*---------- AD7799修改单双极性增益倍数和通道 ----------*/
                        void AD7799_Set_Gain_and_Channel(uchar Polarity,uchar Gain,uchar Ch);        //Polarity为0代表双极性，为1代表单极性
        
                        /*---------- AD7799修改转换模式和转换速率 ----------*/
                        void AD7799_Set_Conversion_mode_and_Time(uchar Conversion_mode,uchar Time);        //Conversion_mode为0代表连续转换，为1代表单次转换，Conversion_mode代表转换速率
                5、本程序并未包含滤波算法，如需使用，请自己另加;
                6、更多相关知识，请参考AD7799Datasheet，建议学习英文原版手册，中文翻译的手册存在错误。

        附注：
                1、实验发现，AD7799内部增益调节最好不要超过2倍，超过2倍后，读数偏差巨大，这里不知道是否是电路或者程序的问题还是AD7799的问题；
                2、转换速率不要过高，使用推荐的16.7Hz较好；
                3、至于转换模式是连续还是单次，可以根据实际应用来设置，这里总结一下发现：连续转换适合于制作电压表或者测量仪器使用，因为转换速度快；单次转换在每次转换完成后会进入Power Down模式，因此适合于低功耗场合，
                   例如温度、湿度等变化速度不快的参量。
0.png

单片机源程序如下:
  1. #include <AD7799.h>
  2. #include <intrins.h>
  3. #include <main.h>
  4. #define        uchar unsigned char
  5. #define uint unsigned int
  6. #define ulint unsigned long int
  7. #define N 16
  8. #define A 10   //限幅滤波的幅值波动

  10. /*---------- AD初始化 ----------*/
  11. void AD7799_init_1(void)        //AD7799初始化,通道3,增益1,速率120ms
  12. {
  13.         CS=0;
  14.         delay10ms();
  15.         
  16.         AD7799_Set_Gain_and_Channel(1,1,3);                //单极性,Gain=1,CH=3
  17.         Internal_Zero_Scale_Calibration();                //片内零刻度校准
  18.         Internal_Full_Scale_Calibration();                //片内满刻度校准
  19.         
  20.         AD7799_Set_Conversion_mode_and_Time(1,120);        //单次转换,转换速率120ms
  21.         
  22.         //写通信寄存器，下一次为写配置寄存器
  23. //        SPI_Write_Byte(0x10);
  24. //        delay10ms();
  25. //        //写配置寄存器选择增益，通道，缓冲    //1022
  26. //        SPI_Write_Byte(0x00);          //单极选择位=1（000000H--FFFFFFH）    增益为1
  27. //        SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  28. //                                                 //（22H）3通道为1级放大       （21H） 2通道 2级放大
  29. //        delay10ms();
  30.         

  32. //        //写通信寄存器，下一次为写模式寄存器
  33. //        SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  34. //        delay10ms();
  35. //        //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  36. //        SPI_Write_Byte(0x20);        //单次转换
  37. //        SPI_Write_Byte(0x0A);        //默认速率（120ms）
  38. //        delay10ms();

  40. }

  42. /*---------- AD7799修改单双极性增益倍数和通道 ----------*/
  43. void AD7799_Set_Gain_and_Channel(uchar Polarity,uchar Gain,uchar Ch)        //Polarity为0代表双极性，为1代表单极性
  44. {
  45.     if(Polarity==1)                        //为1代表单极性
  46.     {
  47.         if(Ch==1)
  48.         {
  49.             if(Gain==1)
  50.             {
  51.                 //写通信寄存器，下一次为写配置寄存器
  52.                 SPI_Write_Byte(0x10);
  53.                 delay10ms();
  54.                 //写配置寄存器选择增益，通道，缓冲    //
  55.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
  56.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  57.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  58.                 delay10ms();
  59.                 return;
  60.             }
  61.             else if(Gain==2)
  62.             {
  63.                 //写通信寄存器，下一次为写配置寄存器
  64.                 SPI_Write_Byte(0x10);
  65.                 delay10ms();
  66.                 //写配置寄存器选择增益，通道，缓冲    //
  67.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
  68.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  69.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  70.                 delay10ms();
  71.                 return;
  72.             }
  73.             else if(Gain==4)
  74.             {
  75.                 //写通信寄存器，下一次为写配置寄存器
  76.                 SPI_Write_Byte(0x10);
  77.                 delay10ms();
  78.                 //写配置寄存器选择增益，通道，缓冲    //
  79.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
  80.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  81.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  82.                 delay10ms();
  83.                 return;
  84.             }
  85.             else if(Gain==8)
  86.             {
  87.                 //写通信寄存器，下一次为写配置寄存器
  88.                 SPI_Write_Byte(0x10);
  89.                 delay10ms();
  90.                 //写配置寄存器选择增益，通道，缓冲    //
  91.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
  92.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  93.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  94.                 delay10ms();
  95.                 return;
  96.             }
  97.             else if(Gain==16)
  98.             {
  99.                 //写通信寄存器，下一次为写配置寄存器
  100.                 SPI_Write_Byte(0x10);
  101.                 delay10ms();
  102.                 //写配置寄存器选择增益，通道，缓冲    //
  103.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
  104.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  105.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  106.                 delay10ms();
  107.                 return;
  108.             }
  109.             else if(Gain==32)
  110.             {
  111.                 //写通信寄存器，下一次为写配置寄存器
  112.                 SPI_Write_Byte(0x10);
  113.                 delay10ms();
  114.                 //写配置寄存器选择增益，通道，缓冲    //
  115.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
  116.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  117.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  118.                 delay10ms();
  119.                 return;
  120.             }
  121.             else if(Gain==64)
  122.             {
  123.                 //写通信寄存器，下一次为写配置寄存器
  124.                 SPI_Write_Byte(0x10);
  125.                 delay10ms();
  126.                 //写配置寄存器选择增益，通道，缓冲    //
  127.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
  128.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  129.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  130.                 delay10ms();
  131.                 return;
  132.             }
  133.             else if(Gain==128)
  134.             {
  135.                 //写通信寄存器，下一次为写配置寄存器
  136.                 SPI_Write_Byte(0x10);
  137.                 delay10ms();
  138.                 //写配置寄存器选择增益，通道，缓冲    //
  139.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
  140.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  141.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  142.                 delay10ms();
  143.                 return;
  144.             }
  145.         }
  146.         else if(Ch==2)
  147.         {
  148.             if(Gain==1)
  149.             {
  150.                 //写通信寄存器，下一次为写配置寄存器
  151.                 SPI_Write_Byte(0x10);
  152.                 delay10ms();
  153.                 //写配置寄存器选择增益，通道，缓冲    //
  154.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
  155.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  156.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  157.                 delay10ms();
  158.                 return;
  159.             }
  160.             else if(Gain==2)
  161.             {
  162.                 //写通信寄存器，下一次为写配置寄存器
  163.                 SPI_Write_Byte(0x10);
  164.                 delay10ms();
  165.                 //写配置寄存器选择增益，通道，缓冲    //
  166.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
  167.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  168.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  169.                 delay10ms();
  170.                 return;
  171.             }
  172.             else if(Gain==4)
  173.             {
  174.                 //写通信寄存器，下一次为写配置寄存器
  175.                 SPI_Write_Byte(0x10);
  176.                 delay10ms();
  177.                 //写配置寄存器选择增益，通道，缓冲    //
  178.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
  179.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  180.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  181.                 delay10ms();
  182.                 return;
  183.             }
  184.             else if(Gain==8)
  185.             {
  186.                 //写通信寄存器，下一次为写配置寄存器
  187.                 SPI_Write_Byte(0x10);
  188.                 delay10ms();
  189.                 //写配置寄存器选择增益，通道，缓冲    //
  190.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
  191.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  192.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  193.                 delay10ms();
  194.                 return;
  195.             }
  196.             else if(Gain==16)
  197.             {
  198.                 //写通信寄存器，下一次为写配置寄存器
  199.                 SPI_Write_Byte(0x10);
  200.                 delay10ms();
  201.                 //写配置寄存器选择增益，通道，缓冲    //
  202.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
  203.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  204.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  205.                 delay10ms();
  206.                 return;
  207.             }
  208.             else if(Gain==32)
  209.             {
  210.                 //写通信寄存器，下一次为写配置寄存器
  211.                 SPI_Write_Byte(0x10);
  212.                 delay10ms();
  213.                 //写配置寄存器选择增益，通道，缓冲    //
  214.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
  215.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  216.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  217.                 delay10ms();
  218.                 return;
  219.             }
  220.             else if(Gain==64)
  221.             {
  222.                 //写通信寄存器，下一次为写配置寄存器
  223.                 SPI_Write_Byte(0x10);
  224.                 delay10ms();
  225.                 //写配置寄存器选择增益，通道，缓冲    //
  226.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
  227.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  228.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  229.                 delay10ms();
  230.                 return;
  231.             }
  232.             else if(Gain==128)
  233.             {
  234.                 //写通信寄存器，下一次为写配置寄存器
  235.                 SPI_Write_Byte(0x10);
  236.                 delay10ms();
  237.                 //写配置寄存器选择增益，通道，缓冲    //
  238.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
  239.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  240.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  241.                 delay10ms();
  242.                 return;
  243.             }
  244.         }
  245.         else if(Ch==3)
  246.         {
  247.             if(Gain==1)
  248.             {
  249.                 //写通信寄存器，下一次为写配置寄存器
  250.                 SPI_Write_Byte(0x10);
  251.                 delay10ms();
  252.                 //写配置寄存器选择增益，通道，缓冲    //
  253.                 SPI_Write_Byte(0x10);          //单极选择位=1（000000H--FFFFFFH）    增益为1
  254.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  255.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  256.                 delay10ms();
  257.                 return;
  258.             }
  259.             else if(Gain==2)
  260.             {
  261.                 //写通信寄存器，下一次为写配置寄存器
  262.                 SPI_Write_Byte(0x10);
  263.                 delay10ms();
  264.                 //写配置寄存器选择增益，通道，缓冲    //
  265.                 SPI_Write_Byte(0x11);          //单极选择位=1（000000H--FFFFFFH）    增益为2
  266.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  267.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  268.                 delay10ms();
  269.                 return;
  270.             }
  271.             else if(Gain==4)
  272.             {
  273.                 //写通信寄存器，下一次为写配置寄存器
  274.                 SPI_Write_Byte(0x10);
  275.                 delay10ms();
  276.                 //写配置寄存器选择增益，通道，缓冲    //
  277.                 SPI_Write_Byte(0x12);          //单极选择位=1（000000H--FFFFFFH）    增益为4
  278.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  279.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  280.                 delay10ms();
  281.                 return;
  282.             }
  283.             else if(Gain==8)
  284.             {
  285.                 //写通信寄存器，下一次为写配置寄存器
  286.                 SPI_Write_Byte(0x10);
  287.                 delay10ms();
  288.                 //写配置寄存器选择增益，通道，缓冲    //
  289.                 SPI_Write_Byte(0x13);          //单极选择位=1（000000H--FFFFFFH）    增益为8
  290.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  291.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  292.                 delay10ms();
  293.                 return;
  294.             }
  295.             else if(Gain==16)
  296.             {
  297.                 //写通信寄存器，下一次为写配置寄存器
  298.                 SPI_Write_Byte(0x10);
  299.                 delay10ms();
  300.                 //写配置寄存器选择增益，通道，缓冲    //
  301.                 SPI_Write_Byte(0x14);          //单极选择位=1（000000H--FFFFFFH）    增益为16
  302.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  303.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  304.                 delay10ms();
  305.                 return;
  306.             }
  307.             else if(Gain==32)
  308.             {
  309.                 //写通信寄存器，下一次为写配置寄存器
  310.                 SPI_Write_Byte(0x10);
  311.                 delay10ms();
  312.                 //写配置寄存器选择增益，通道，缓冲    //
  313.                 SPI_Write_Byte(0x15);          //单极选择位=1（000000H--FFFFFFH）    增益为32
  314.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  315.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  316.                 delay10ms();
  317.                 return;
  318.             }
  319.             else if(Gain==64)
  320.             {
  321.                 //写通信寄存器，下一次为写配置寄存器
  322.                 SPI_Write_Byte(0x10);
  323.                 delay10ms();
  324.                 //写配置寄存器选择增益，通道，缓冲    //
  325.                 SPI_Write_Byte(0x16);          //单极选择位=1（000000H--FFFFFFH）    增益为64
  326.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  327.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  328.                 delay10ms();
  329.                 return;
  330.             }
  331.             else if(Gain==128)
  332.             {
  333.                 //写通信寄存器，下一次为写配置寄存器
  334.                 SPI_Write_Byte(0x10);
  335.                 delay10ms();
  336.                 //写配置寄存器选择增益，通道，缓冲    //
  337.                 SPI_Write_Byte(0x17);          //单极选择位=1（000000H--FFFFFFH）    增益为128
  338.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  339.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  340.                 delay10ms();
  341.                 return;
  342.             }
  343.         }
  344.     }
  345.     else if(Polarity==0)        //为0代表双极性
  346.     {
  347.         if(Ch==1)
  348.         {
  349.             if(Gain==1)
  350.             {
  351.                 //写通信寄存器，下一次为写配置寄存器
  352.                 SPI_Write_Byte(0x10);
  353.                 delay10ms();
  354.                 //写配置寄存器选择增益，通道，缓冲    //
  355.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
  356.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  357.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  358.                 delay10ms();
  359.                 return;
  360.             }
  361.             else if(Gain==2)
  362.             {
  363.                 //写通信寄存器，下一次为写配置寄存器
  364.                 SPI_Write_Byte(0x10);
  365.                 delay10ms();
  366.                 //写配置寄存器选择增益，通道，缓冲    //
  367.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
  368.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  369.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  370.                 delay10ms();
  371.                 return;
  372.             }
  373.             else if(Gain==4)
  374.             {
  375.                 //写通信寄存器，下一次为写配置寄存器
  376.                 SPI_Write_Byte(0x10);
  377.                 delay10ms();
  378.                 //写配置寄存器选择增益，通道，缓冲    //
  379.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
  380.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  381.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  382.                 delay10ms();
  383.                 return;
  384.             }
  385.             else if(Gain==8)
  386.             {
  387.                 //写通信寄存器，下一次为写配置寄存器
  388.                 SPI_Write_Byte(0x10);
  389.                 delay10ms();
  390.                 //写配置寄存器选择增益，通道，缓冲    //
  391.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
  392.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  393.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  394.                 delay10ms();
  395.                 return;
  396.             }
  397.             else if(Gain==16)
  398.             {
  399.                 //写通信寄存器，下一次为写配置寄存器
  400.                 SPI_Write_Byte(0x10);
  401.                 delay10ms();
  402.                 //写配置寄存器选择增益，通道，缓冲    //
  403.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
  404.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  405.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  406.                 delay10ms();
  407.                 return;
  408.             }
  409.             else if(Gain==32)
  410.             {
  411.                 //写通信寄存器，下一次为写配置寄存器
  412.                 SPI_Write_Byte(0x10);
  413.                 delay10ms();
  414.                 //写配置寄存器选择增益，通道，缓冲    //
  415.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
  416.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  417.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  418.                 delay10ms();
  419.                 return;
  420.             }
  421.             else if(Gain==64)
  422.             {
  423.                 //写通信寄存器，下一次为写配置寄存器
  424.                 SPI_Write_Byte(0x10);
  425.                 delay10ms();
  426.                 //写配置寄存器选择增益，通道，缓冲    //
  427.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
  428.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  429.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  430.                 delay10ms();
  431.                 return;
  432.             }
  433.             else if(Gain==128)
  434.             {
  435.                 //写通信寄存器，下一次为写配置寄存器
  436.                 SPI_Write_Byte(0x10);
  437.                 delay10ms();
  438.                 //写配置寄存器选择增益，通道，缓冲    //
  439.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
  440.                 SPI_Write_Byte(0x20);         //REF-DEF=1 参考保护使能 通道选择为1    通道1 000  通道2  001   通道3  010
  441.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  442.                 delay10ms();
  443.                 return;
  444.             }
  445.         }
  446.         else if(Ch==2)
  447.         {
  448.             if(Gain==1)
  449.             {
  450.                 //写通信寄存器，下一次为写配置寄存器
  451.                 SPI_Write_Byte(0x10);
  452.                 delay10ms();
  453.                 //写配置寄存器选择增益，通道，缓冲    //
  454.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
  455.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  456.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  457.                 delay10ms();
  458.                 return;
  459.             }
  460.             else if(Gain==2)
  461.             {
  462.                 //写通信寄存器，下一次为写配置寄存器
  463.                 SPI_Write_Byte(0x10);
  464.                 delay10ms();
  465.                 //写配置寄存器选择增益，通道，缓冲    //
  466.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
  467.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  468.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  469.                 delay10ms();
  470.                 return;
  471.             }
  472.             else if(Gain==4)
  473.             {
  474.                 //写通信寄存器，下一次为写配置寄存器
  475.                 SPI_Write_Byte(0x10);
  476.                 delay10ms();
  477.                 //写配置寄存器选择增益，通道，缓冲    //
  478.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
  479.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  480.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  481.                 delay10ms();
  482.                 return;
  483.             }
  484.             else if(Gain==8)
  485.             {
  486.                 //写通信寄存器，下一次为写配置寄存器
  487.                 SPI_Write_Byte(0x10);
  488.                 delay10ms();
  489.                 //写配置寄存器选择增益，通道，缓冲    //
  490.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
  491.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  492.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  493.                 delay10ms();
  494.                 return;
  495.             }
  496.             else if(Gain==16)
  497.             {
  498.                 //写通信寄存器，下一次为写配置寄存器
  499.                 SPI_Write_Byte(0x10);
  500.                 delay10ms();
  501.                 //写配置寄存器选择增益，通道，缓冲    //
  502.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
  503.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  504.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  505.                 delay10ms();
  506.                 return;
  507.             }
  508.             else if(Gain==32)
  509.             {
  510.                 //写通信寄存器，下一次为写配置寄存器
  511.                 SPI_Write_Byte(0x10);
  512.                 delay10ms();
  513.                 //写配置寄存器选择增益，通道，缓冲    //
  514.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
  515.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  516.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  517.                 delay10ms();
  518.                 return;
  519.             }
  520.             else if(Gain==64)
  521.             {
  522.                 //写通信寄存器，下一次为写配置寄存器
  523.                 SPI_Write_Byte(0x10);
  524.                 delay10ms();
  525.                 //写配置寄存器选择增益，通道，缓冲    //
  526.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
  527.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  528.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  529.                 delay10ms();
  530.                 return;
  531.             }
  532.             else if(Gain==128)
  533.             {
  534.                 //写通信寄存器，下一次为写配置寄存器
  535.                 SPI_Write_Byte(0x10);
  536.                 delay10ms();
  537.                 //写配置寄存器选择增益，通道，缓冲    //
  538.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
  539.                 SPI_Write_Byte(0x21);         //REF-DEF=1 参考保护使能 通道选择为2    通道1 000  通道2  001   通道3  010
  540.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  541.                 delay10ms();
  542.                 return;
  543.             }
  544.         }
  545.         else if(Ch==3)
  546.         {
  547.             if(Gain==1)
  548.             {
  549.                 //写通信寄存器，下一次为写配置寄存器
  550.                 SPI_Write_Byte(0x10);
  551.                 delay10ms();
  552.                 //写配置寄存器选择增益，通道，缓冲    //
  553.                 SPI_Write_Byte(0x00);          //双极选择位=0（000000H--FFFFFFH）    增益为1
  554.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  555.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  556.                 delay10ms();
  557.                 return;
  558.             }
  559.             else if(Gain==2)
  560.             {
  561.                 //写通信寄存器，下一次为写配置寄存器
  562.                 SPI_Write_Byte(0x10);
  563.                 delay10ms();
  564.                 //写配置寄存器选择增益，通道，缓冲    //
  565.                 SPI_Write_Byte(0x01);          //双极选择位=0（000000H--FFFFFFH）    增益为2
  566.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  567.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  568.                 delay10ms();
  569.                 return;
  570.             }
  571.             else if(Gain==4)
  572.             {
  573.                 //写通信寄存器，下一次为写配置寄存器
  574.                 SPI_Write_Byte(0x10);
  575.                 delay10ms();
  576.                 //写配置寄存器选择增益，通道，缓冲    //
  577.                 SPI_Write_Byte(0x02);          //双极选择位=0（000000H--FFFFFFH）    增益为4
  578.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  579.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  580.                 delay10ms();
  581.                 return;
  582.             }
  583.             else if(Gain==8)
  584.             {
  585.                 //写通信寄存器，下一次为写配置寄存器
  586.                 SPI_Write_Byte(0x10);
  587.                 delay10ms();
  588.                 //写配置寄存器选择增益，通道，缓冲    //
  589.                 SPI_Write_Byte(0x03);          //双极选择位=0（000000H--FFFFFFH）    增益为8
  590.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  591.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  592.                 delay10ms();
  593.                 return;
  594.             }
  595.             else if(Gain==16)
  596.             {
  597.                 //写通信寄存器，下一次为写配置寄存器
  598.                 SPI_Write_Byte(0x10);
  599.                 delay10ms();
  600.                 //写配置寄存器选择增益，通道，缓冲    //
  601.                 SPI_Write_Byte(0x04);          //双极选择位=0（000000H--FFFFFFH）    增益为16
  602.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  603.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  604.                 delay10ms();
  605.                 return;
  606.             }
  607.             else if(Gain==32)
  608.             {
  609.                 //写通信寄存器，下一次为写配置寄存器
  610.                 SPI_Write_Byte(0x10);
  611.                 delay10ms();
  612.                 //写配置寄存器选择增益，通道，缓冲    //
  613.                 SPI_Write_Byte(0x05);          //双极选择位=0（000000H--FFFFFFH）    增益为32
  614.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  615.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  616.                 delay10ms();
  617.                 return;
  618.             }
  619.             else if(Gain==64)
  620.             {
  621.                 //写通信寄存器，下一次为写配置寄存器
  622.                 SPI_Write_Byte(0x10);
  623.                 delay10ms();
  624.                 //写配置寄存器选择增益，通道，缓冲    //
  625.                 SPI_Write_Byte(0x06);          //双极选择位=0（000000H--FFFFFFH）    增益为64
  626.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  627.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  628.                 delay10ms();
  629.                 return;
  630.             }
  631.             else if(Gain==128)
  632.             {
  633.                 //写通信寄存器，下一次为写配置寄存器
  634.                 SPI_Write_Byte(0x10);
  635.                 delay10ms();
  636.                 //写配置寄存器选择增益，通道，缓冲    //
  637.                 SPI_Write_Byte(0x07);          //双极选择位=0（000000H--FFFFFFH）    增益为128
  638.                 SPI_Write_Byte(0x22);         //REF-DEF=1 参考保护使能 通道选择为3    通道1 000  通道2  001   通道3  010
  639.                 //（22H）3通道      （21H） 2通道      （20H） 1通道
  640.                 delay10ms();
  641.                 return;
  642.             }
  643.         }
  644.     }
  645. }

  647. /*---------- AD7799修改转换模式和转换速率 ----------*/
  648. void AD7799_Set_Conversion_mode_and_Time(uchar Conversion_mode,uchar Time)        //Conversion_mode为0代表连续转换，为1代表单次转换，Conversion_mode代表转换速率
  649. {
  650.         if(Conversion_mode==0)                //Conversion_mode为0代表连续转换
  651.         {
  652.                 if(Time==4)                                //转换速率为4ms
  653.                 {
  654.                         //写通信寄存器，下一次为写模式寄存器
  655.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  656.                         delay10ms();
  657.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  658.                         SPI_Write_Byte(0x00);        //连续转换
  659.                         SPI_Write_Byte(0x01);        //速率（4ms）
  660.                         delay10ms();
  661.                 }
  662.                 else if(Time==8)                //转换速率为8ms
  663.                 {
  664.                         //写通信寄存器，下一次为写模式寄存器
  665.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  666.                         delay10ms();
  667.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  668.                         SPI_Write_Byte(0x00);        //连续转换
  669.                         SPI_Write_Byte(0x02);        //速率（8ms）
  670.                         delay10ms();
  671.                 }
  672.                 else if(Time==16)                //转换速率为16ms
  673.                 {
  674.                         //写通信寄存器，下一次为写模式寄存器
  675.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  676.                         delay10ms();
  677.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  678.                         SPI_Write_Byte(0x00);        //连续转换
  679.                         SPI_Write_Byte(0x03);        //速率（16ms）
  680.                         delay10ms();
  681.                 }
  682.                 else if(Time==32)                //转换速率为32ms
  683.                 {
  684.                         //写通信寄存器，下一次为写模式寄存器
  685.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  686.                         delay10ms();
  687.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  688.                         SPI_Write_Byte(0x00);        //连续转换
  689.                         SPI_Write_Byte(0x04);        //速率（32ms）
  690.                         delay10ms();
  691.                 }
  692.                 else if(Time==60)                //转换速率为60ms
  693.                 {
  694.                         //写通信寄存器，下一次为写模式寄存器
  695.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  696.                         delay10ms();
  697.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  698.                         SPI_Write_Byte(0x00);        //连续转换
  699.                         SPI_Write_Byte(0x07);        //速率（60ms）
  700.                         delay10ms();
  701.                 }
  702.                 else if(Time==120)                //转换速率为120ms
  703.                 {
  704.                         //写通信寄存器，下一次为写模式寄存器
  705.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  706.                         delay10ms();
  707.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  708.                         SPI_Write_Byte(0x00);        //连续转换
  709.                         SPI_Write_Byte(0x0A);        //速率（120ms）
  710.                         delay10ms();
  711.                 }
  712.                 else if(Time==200)                //转换速率为200ms
  713.                 {
  714.                         //写通信寄存器，下一次为写模式寄存器
  715.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  716.                         delay10ms();
  717.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  718.                         SPI_Write_Byte(0x00);        //连续转换
  719.                         SPI_Write_Byte(0x0C);        //速率（200ms）
  720.                         delay10ms();
  721.                 }
  722.                 else if(Time==480)                //转换速率为480ms
  723.                 {
  724.                         //写通信寄存器，下一次为写模式寄存器
  725.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  726.                         delay10ms();
  727.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  728.                         SPI_Write_Byte(0x00);        //连续转换
  729.                         SPI_Write_Byte(0x0F);        //速率（480ms）
  730.                         delay10ms();
  731.                 }
  732.         }
  733.         else if(Conversion_mode==1)                //Conversion_mode为1代表单次转换
  734.         {
  735.                 if(Time==4)                                //转换速率为4ms
  736.                 {
  737.                         //写通信寄存器，下一次为写模式寄存器
  738.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  739.                         delay10ms();
  740.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  741.                         SPI_Write_Byte(0x20);        //单次转换
  742.                         SPI_Write_Byte(0x01);        //速率（4ms）
  743.                         delay10ms();
  744.                 }
  745.                 else if(Time==8)                //转换速率为8ms
  746.                 {
  747.                         //写通信寄存器，下一次为写模式寄存器
  748.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  749.                         delay10ms();
  750.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  751.                         SPI_Write_Byte(0x20);        //单次转换
  752.                         SPI_Write_Byte(0x02);        //速率（8ms）
  753.                         delay10ms();
  754.                 }
  755.                 else if(Time==16)                //转换速率为16ms
  756.                 {
  757.                         //写通信寄存器，下一次为写模式寄存器
  758.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  759.                         delay10ms();
  760.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  761.                         SPI_Write_Byte(0x20);        //单次转换
  762.                         SPI_Write_Byte(0x03);        //速率（16ms）
  763.                         delay10ms();
  764.                 }
  765.                 else if(Time==32)                //转换速率为32ms
  766.                 {
  767.                         //写通信寄存器，下一次为写模式寄存器
  768.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  769.                         delay10ms();
  770.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  771.                         SPI_Write_Byte(0x20);        //单次转换
  772.                         SPI_Write_Byte(0x04);        //速率（32ms）
  773.                         delay10ms();
  774.                 }
  775.                 else if(Time==60)                //转换速率为60ms
  776.                 {
  777.                         //写通信寄存器，下一次为写模式寄存器
  778.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  779.                         delay10ms();
  780.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  781.                         SPI_Write_Byte(0x20);        //单次转换
  782.                         SPI_Write_Byte(0x07);        //速率（60ms）
  783.                         delay10ms();
  784.                 }
  785.                 else if(Time==120)                //转换速率为120ms
  786.                 {
  787.                         //写通信寄存器，下一次为写模式寄存器
  788.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  789.                         delay10ms();
  790.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  791.                         SPI_Write_Byte(0x20);        //单次转换
  792.                         SPI_Write_Byte(0x0A);        //速率（120ms）
  793.                         delay10ms();
  794.                 }
  795.                 else if(Time==200)                //转换速率为200ms
  796.                 {
  797.                         //写通信寄存器，下一次为写模式寄存器
  798.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  799.                         delay10ms();
  800.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  801.                         SPI_Write_Byte(0x20);        //单次转换
  802.                         SPI_Write_Byte(0x0C);        //速率（200ms）
  803.                         delay10ms();
  804.                 }
  805.                 else if(Time==480)                //转换速率为480ms
  806.                 {
  807.                         //写通信寄存器，下一次为写模式寄存器
  808.                         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  809.                         delay10ms();
  810.                         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  811.                         SPI_Write_Byte(0x20);        //单次转换
  812.                         SPI_Write_Byte(0x0F);        //速率（480ms）
  813.                         delay10ms();
  814.                 }
  815.         }
  816. }

  818. /*---------- SPI写函数        ----------*/
  819. void SPI_Write_Byte(uchar Data)
  820. {
  821.         uchar i;
  822.         for(i=0;i<8;i++)
  823.         {
  824.                 clk=0;
  825.                 if(Data&0x80) DIN=1;
  826.                 else DIN=0;
  827.                 Data=Data<<1;
  828.                 delay1ms();
  829.                 clk=1;
  830.                 delay1ms();
  831.         }
  832. }

  834. /*---------- AD7799复位        ----------*/
  835. void AD7799_Reset(void)
  836. {
  837.         SPI_Write_Byte(0xff);
  838.         SPI_Write_Byte(0xff);
  839.         SPI_Write_Byte(0xff);
  840.         SPI_Write_Byte(0xff);
  841.         AD7799_init_1();                //初始化
  842.         LED=1;                                        //灯灭
  843. }

  845. /*---------- 等待7799转换完成，看是否有错误        ----------*/
  846. uchar Waite_DOUT(void)
  847. {
  848.         uchar i;
  849.         unsigned int count=0;
  850.         while(DOUT)
  851.         {        
  852.                 count++;
  853.                 if(count>10000)
  854.                 {
  855.                         //灯亮
  856.                         LED=0;        
  857.                         while(i--)
  858.                                 delay10ms();
  859.                         return 0;
  860.                 }
  861.         }
  862.         return 1;
  863. }

  865. /*这两个函数是标准推荐程序，用于以后项目用，此处只是列写并不使用  (始)  */
  866. /*---------- AD单次转换及读取函数 ----------*/
  867. unsigned long Single_Conversion_and_Read_AD(void)        //单次转换及读取函数
  868. {
  869.         //写通信寄存器，下一次为写模式寄存器
  870.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  871.         delay10ms();
  872.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  873.         SPI_Write_Byte(0x20);        //单次转换
  874.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
  875.         delay10ms();
  876.         return Read_AD_Value();
  877. }

  879. /*---------- AD连续转换及读取函数 ----------*/
  880. unsigned long Continuous_Conversion_and_Read_AD(void)        //连续转换及读取函数，以后使用只需调用        Read_AD_Value();        函数即可返回AD值
  881. {
  882.         //写通信寄存器，下一次为写模式寄存器
  883.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  884.         delay10ms();
  885.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  886.         SPI_Write_Byte(0x00);        //连续转换
  887.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
  888.         delay10ms();
  889.         //以后使用只需调用        Read_AD_Value();        函数即可返回AD值
  890.         return Read_AD_Value();
  891. }
  892. /*这两个函数是标准推荐程序，用于以后项目用，此处只是列写并不使用  (终)  */

  894. /*---------- 从AD获取一次数据 ----------*/
  895. unsigned long Read_AD_Value(void)
  896. {
  897.     unsigned long get_data=0;
  898.         uchar i;
  899.         
  900.         if(Waite_DOUT()==0)                //查看是否超时
  901.         {
  902.                 //reset ad7799
  903.                 /*---------- 防止时序混乱，重新同步        ----------*/
  904.                 AD7799_Reset();
  905.                 return 0;                        //超时退出读函数
  906.         }
  907.         else
  908.         {
  909.                 SPI_Write_Byte(0x58);        //发送读操作指令，读数据寄存器
  910.                 delay1ms();
  911.                
  912.                 clk=1;
  913.                 delay1ms();
  914.                 //读数据
  915.                 for(i=0;i<24;i++)         //第一次进入本函数，就是下降沿
  916.                 {
  917.                         delay1ms();
  918.                         clk=0;
  919.                         
  920.                         get_data=get_data<<1;        
  921.                         if(DOUT)
  922.                                 get_data+=1;                                
  923.                         clk=1;                        
  924.                 }
  925. //                for(i=0;i<8;i++)
  926. //                {
  927. //                        delay1ms();
  928. //                        clk=0;
  929. //                        delay1ms();
  930. //                        clk=1;
  931. //                }
  932.                 DOUT=1;
  933.                 return get_data;
  934.         }
  935. }

  937. void Internal_Zero_Scale_Calibration(void)                //片内零刻度校准
  938. {
  939.         //写通信寄存器，下一次为写模式寄存器
  940.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  941.         delay10ms();
  942.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  943.         SPI_Write_Byte(0x80);        //内部零刻度校准模式
  944.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
  945.         delay10ms();
  946.         Waite_DOUT();                        //等待零刻度校准完成
  947. }

  949. void Internal_Full_Scale_Calibration(void)                //片内满刻度校准
  950. {
  951.         //写通信寄存器，下一次为写模式寄存器
  952.         SPI_Write_Byte(0x08);        //RS2 RS1 RS0  001(模式寄存器16bits) 设置数据寄存器不能连续可读
  953.         delay10ms();
  954.         //写模式寄存器，为低电平接地，操作模式为连续转换，频率为50HZ
  955.         SPI_Write_Byte(0xA0);        //内部慢刻度校准模式
  956.         SPI_Write_Byte(0x0A);        //默认速率（120ms）
  957.         delay10ms();
  958.         Waite_DOUT();                        //等待满刻度校准完成
  959. }        


  962. /**************************************
  963.   名称：display100num
  964.   功能：将24位数据转化为对应的ASCII码并在1602显示
  965.   输入参数：输入000-FFFF的任意一个数
  966.   输出参数： 对应的ASCII给1602显示
  967. *************************************/
  968. void display100num(unsigned long num)
  969. {
  970.         uchar a,b,c,d,e,f,g,h;
  971. /*显示电压的变量*/        
  972. //        float s;
  973. //        long vv;
  974. /*显示电压的变量*/        
  975.         uchar i,j,k,l,m,n;
  976.          
  977.         a=num/10000000;                        //
  978.         b=(num/1000000)%10;                //
  979.         c=(num/100000)%10;                //
  980.         d=(num/10000)%10;                //
  981.         e=(num/1000)%10;                //
  982.         f=(num/100)%10;                        //
  983.         g=(num/10)%10;                        //
  984.         h=num%10;                                //
  985.         
  986.         n=num%16;
  987.         m=(num/16)%16;
  988.         l=(num/16/16)%16;
  989.         k=(num/16/16/16)%16;
  990.         j=(num/16/16/16/16)%16;
  991.         i=(num/16/16/16/16/16)%16;

  993.         LCD1602_WriteCom(0xC0);         //10进制的AD值显示在第二行         
  994.         LCD1602_WriteData(0x30+a);                        
  995.         LCD1602_WriteData(0x30+b);
  996.         LCD1602_WriteData(0x30+c);
  997.         LCD1602_WriteData(0x30+d);
  998.         LCD1602_WriteData(0x30+e);
  999.         LCD1602_WriteData(0x30+f);
  1000.         LCD1602_WriteData(0x30+g);
  1001.         LCD1602_WriteData(0x30+h);
  1002.         
  1003. /*显示电压的函数*/        
  1004. //        s=((num*4.9869f)/16777215.0f);  //电压转换   
  1005. //        s*=10000.0f;
  1006. //        vv=(unsigned long)s;         
  1007. //        LCD1602_WriteCom(0xCA);   //显示在第二行        显示的电压
  1008. //        LCD1602_WriteData(0x30+(vv/10000));
  1009. //        LCD1602_WriteData('.');        
  1010. //        LCD1602_WriteData(0x30+(vv/1000%10));                          
  1011. //        LCD1602_WriteData(0x30+(vv/100%10));
  1012. //        LCD1602_WriteData(0x30+(vv/10%10));
  1013. //        LCD1602_WriteData(0x30+(vv%10));
  1014. //        LCD1602_WriteData('V');      
  1015. /*显示电压的函数*/        
  1016.         
  1017.         LCD1602_WriteCom(0xCA);   //16进制的AD值显示在第二行
  1018.         LCD1602_WriteData(LCD1602_HEX_to_ASC(i));
  1019.         LCD1602_WriteData(LCD1602_HEX_to_ASC(j));
  1020.         LCD1602_WriteData(LCD1602_HEX_to_ASC(k));
  1021.         LCD1602_WriteData(LCD1602_HEX_to_ASC(l));
  1022.         LCD1602_WriteData(LCD1602_HEX_to_ASC(m));
  1023.         LCD1602_WriteData(LCD1602_HEX_to_ASC(n));
  1024. }

  1026. //延时函数
  1027. void delay10ms(void)   //误差 0us
  1028. {
  1029.     unsigned char a,b,c;
  1030.     for(c=5;c>0;c--)
  1031.         for(b=4;b>0;b--)
  1032.             for(a=248;a>0;a--);
  1033. }

  1035. void delay1ms(void)   //误差 0us
  1036. {
  1037.     unsigned char a,b;
  1038.     for(b=199;b>0;b--)
  1039.         for(a=1;a>0;a--);
  1040. }
复制代码

主程序：
  1. #include <main.h>

  3. uchar code str1[]=" Welcome to use ";
  4. uchar code str2[]="AD7799 Board 509";

  6. uchar Q_Menu=0;                                //全局变量-菜单号
  7. uchar Q_Channel=0;                        //全局变量-模拟通道(取值1,2,3)
  8. uchar Q_Gain_ADC=0;                        //全局变量-通道增益(最大128,不超过256,用uchar类型)
  9. uint  Q_Time_Settle=0;                //全局变量-转换时间(因为最大480,超过256,故用uint类型)
  10. uchar Q_Polarity=0;                        //全局变量-转换极性(1单极性 0双极性)
  11. uchar Q_Conversion_mode=0;        //全局变量-连续单次模式(1单次转换 0连续转换)
  12. uchar Q_enable_Conversion=0;//是否可以转换标志,为1代表可以转换,为0代表当前正在设置功能不能转换

  14. void main(void)
  15. {
  16.         
  17.         LCD1602_Init();                                //LCD1602初始化程序
  18.         LCD_Display_AnyStr(0x80,16,str1);                //位置  长度  指针
  19.         LCD_Display_AnyStr(0xC0,16,str2);                //位置  长度  指针
  20.         while(key1&&key2&&key3&&key4);                        //任意键继续
  21.         LCD1602_WriteCom(0x01);          //清屏
  22.         
  23.         AD7799_init_1();                        //AD7799初始化,通道3,增益1,速率120ms  
  24.         AD7799_Reset();                                //手动复位一次
  25.         
  26.         Q_Menu=0;
  27.         Q_enable_Conversion=0;
  28.         
  29.         Q_Channel=3;
  30.         Q_Gain_ADC=1;
  31.         Q_Time_Settle=120;
  32.         Q_Polarity=1;
  33.         Q_Conversion_mode=1;

  35.         
  36.         Display_Menu_0();        //显示基础框架
  37.         while(1)
  38.         {
  39.                
  40.                 if(Check_key1())                //检测设置功能键是否长按
  41.                 {
  42.                         Display_Menu_1();        //当前显示指向CHx
  43.                         Q_Menu=1;
  44.                         
  45.                         Q_enable_Conversion=0;                        //如果有按键触发,将Q_enable_Conversion置0,代表正在设置
  46.                         //再次检测是否抖动并且
  47.                         while(!Q_enable_Conversion)                //当还未按OK时,不能跳出while,只有按了OK,可以跳出本循环,执行显示数值
  48.                         {
  49.                                 Display_Menu(Judge_Key());
  50.                         }
  51.                 }
  52.                 else        //没有检测到按键
  53.                 {
  54.                         if(Q_Conversion_mode==1)        //为1代表当前是单次转换，用单次转换的读取函数
  55.                         {
  56.                                 //更新显示AD值及配置信息
  57.                                 Display_AD((float)Single_Conversion_and_Read_AD());                //更新显示AD值及配置信息
  58.                         }
  59.                         if(Q_Conversion_mode==0)        //为0代表当前是连续转换，用连续转换的读取函数
  60.                         {
  61.                                 Display_AD((float)Read_AD_Value());
  62.                         }
  63.                 }
  64.         }
  65. }

  67. uchar Check_key1(void)                        //检测设置功能键是否长按
  68. {
  69.         uint i=0;
  70.         while(!key1)                //按下了
  71.         {
  72.                 i++;                        //累加按下时间
  73.                 if(i>=40000)        //时间如果足够,则返回1
  74.                 {
  75.                         LED=0;                        //点亮
  76.                         return 1;
  77.                 }
  78.         }
  79.         return 0;                        //若按下时间不够或者没按,返回0
  80. }

  82. uchar Judge_Key(void)                //判键程序
  83. {
  84.         if(!key1)
  85.         {
  86.                 delay10ms_12M();        //10ms效抖
  87.                 if(!key1)
  88.                 {
  89.                         while(!key1);
  90.                         return 1;                //按key1
  91.                 }
  92.         }
  93.         else if(!key2)
  94.         {
  95.                 delay10ms_12M();        //10ms效抖
  96.                 if(!key2)
  97.                 {
  98.                         while(!key2);
  99.                         return 2;                //按key2
  100.                 }
  101.         }
  102.         else if(!key3)
  103.         {
  104.                 delay10ms_12M();        //10ms效抖
  105.                 if(!key3)
  106.                 {
  107.                         while(!key3);
  108.                         return 3;                //按key3
  109.                 }
  110.         }
  111.         else if(!key4)
  112.         {
  113.                 delay10ms_12M();        //10ms效抖
  114.                 if(!key4)
  115.                 {
  116.                         while(!key4);
  117.                         return 4;                //按key4
  118.                 }
  119.         }
  120.         return 0;                                //未按键或者是抖动
  121. }

  123. void Display_Menu(uchar key_Value)                //根据当前界面和按键号显示菜单内容
  124. {
  125.         if(key_Value==0)        //如果未按或者抖动直接退出
  126.         {
  127.                 return;
  128.         }
  129.         Q_enable_Conversion=0;        //为0代表正在设置功能,禁止显示
  130.         
  131.         switch (Q_Menu)                //判断当前菜单
  132.         {
  133.                 case 0:                //AD结果及设置显示界面
  134.                 {
  135.                         if(key_Value==1)
  136.                         {
  137.                                 Display_Menu_1();        //当前显示指向CHx
  138.                                 Q_Menu=1;
  139.                         }
  140.                         else if(key_Value==4)
  141.                         {
  142.                                 //fuwei
  143.                         }
  144.                         break;
  145.                 }
  146.                 case 1:                //当前显示指向CHx
  147.                 {
  148.                         if(key_Value==1)
  149.                         {
  150.                                 //fanhui
  151.                         }
  152.                         else if(key_Value==2)
  153.                         {
  154.                                 
  155. ……………………

  157. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


所有资料51hei提供下载:
AD7799程序C51.zip (125.19 KB, 下载次数: 140)


AD7799

评分

参与人数 1黑币 +100 收起 理由
admin + 100 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:384870 发表于 2020-4-15 15:34 | 显示全部楼层
谢谢，正在找这个代码
回复

使用道具 举报

ID:402026 发表于 2020-4-16 11:11 | 显示全部楼层
感谢您这么辛苦的整理资料，我在这里向您致敬！
回复

使用道具 举报

ID:756729 发表于 2020-5-20 18:35 | 显示全部楼层
太感谢楼主了
回复

使用道具 举报

ID:1144769 发表于 2025-3-11 17:16 | 显示全部楼层
感谢，很有帮助，不用自己挨个对寄存器了。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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