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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › error C129: missing ';' before 'Ds18b20Init' 请问大 ...
返回列表 发新帖
查看: 2700|回复: 2
收起左侧

error C129: missing ';' before 'Ds18b20Init' 请问大佬们怎么修改？

[复制链接]
ID:545543 发表于 2019-5-29 22:24 | 显示全部楼层 |阅读模式
  1. #include<reg52.h>
  2. void LcdDisplay(int);
  3. void DigDisplay();
  4. void chaomax();
  5. void chaomin();
  6. void guomax();
  7. void guomin();
  8. //存储上下限变量
  9. int tempmax=30,tempmin=20,tempt,tempmode=0;
  10. int jileimax=0,jileimin=0,jileimid=0;

  12. void Delay1ms(unsigned char x)
  13. {
  14. unsigned char i,j;
  15.   for(i=0;i<x;i++)
  16.   for(j=0;j<112;j++);
  17. }
  18. uchar  Ds18b20Init()
  19. {
  20.         uchar i;
  21.         DSPORT = 0;                         //将总线拉低480us~960us
  22.         //i = 70;        
  23.         i = 900;        
  24.         while(i--);//延时642us
  25.         DSPORT = 1;                        //然后拉高总线，如果DS18B20做出反应会将在15us~60us后总线拉低
  26.         i = 0;
  27.         while(DSPORT)        //等待DS18B20拉低总线
  28.         {
  29.                 Delay1ms(1);
  30.                 i++;
  31.                 if(i>5)//等待>5MS
  32.                 {
  33.                         return 0;//初始化失败
  34.                 }
  35.         
  36.         }
  37.         return 1;//初始化成功
  38. }
  39. void Ds18b20WriteByte(uchar dat)//????????
  40. {
  41.         uint i, j;
  42.         for(j=0; j<8; j++)
  43.         {
  44.                 DSPORT = 0;                       //每写入一位数据之前先把总线拉低1us     
  45.                 i++;
  46.                 DSPORT = dat & 0x01;  //然后写入一个数据，从最低位开始
  47.                 i=8;
  48.                 while(i--); //延时8us        
  49.                 DSPORT = 1;        //然后释放总线，至少1us给总线恢复时间才能接着写入第二个数值
  50.                 dat >>= 1;
  51.         }
  52. }
  53. [u][i][b]uchar Ds18b20ReadByte()[/b][/i][/u]
  54. {
  55.         uchar byte, bi;
  56.         uint i, j;        
  57.         for(j=8; j>0; j--)
  58.         {
  59.                 DSPORT = 0;//先将总线拉低1us
  60.                 i++;
  61.                 DSPORT = 1;//然后释放总线
  62.                 i++;
  63.                 i++;//延时2us等待数据稳定
  64.                 bi = DSPORT;         //读取数据，从最低位开始读取
  65.         /*将byte左移一位，然后或上右移7位后的bi，注意移动之后移掉那位补0。*/
  66.                 byte = (byte >> 1) | (bi << 7);                                                  
  67.                 i = 4;                //读取完之后等待4us再接着读取下一个数
  68.                 while(i--);
  69.         }                                
  70.         return byte;
  71. }
  72. void  Ds18b20ChangTemp()
  73. {
  74.         Ds18b20Init();
  75.         Delay1ms(1);
  76.         Ds18b20WriteByte(0xcc);                //跳过ROM操作命令                 
  77.         Ds18b20WriteByte(0x44);            //温度转换命令
  78.         Delay1ms(20);        //等待转换成功，而如果你是一直刷着的话，就不用这个延时了
  79. }
  80. void  Ds18b20ReadTempCom()
  81. {        
  82.         Ds18b20Init();
  83.         Delay1ms(1);
  84.         Ds18b20WriteByte(0xcc);         //跳过ROM操作命令
  85.         Ds18b20WriteByte(0xbe);         //发送读取温度命令
  86. }
  87. int Ds18b20ReadTemp()
  88. {
  89.         int temp = 0;
  90.         uchar tmh, tml;
  91.         Ds18b20ChangTemp();                                 //先写入转换命令
  92.         Ds18b20ReadTempCom();                        //然后等待转换完后发送读取温度命令
  93.         tml = Ds18b20ReadByte();                //读取温度值共16位，先读低字节
  94.         tmh = Ds18b20ReadByte();                //再读高字节
  95.         temp = tmh;
  96.         temp <<= 8;
  97.         temp |= tml;
  98.         return temp;
  99. }
  100. void LcdDisplay(int temp)          //lcd显示
  101.         float tp;  
  102.         if(temp< 0)                                //当温度值为负数
  103.           {
  104.                 DisplayData[0] = 0x40;
  105.                 //因为读取的温度是实际温度的补码，所以减1，再取反求出原码
  106.                 temp=temp-1;
  107.                 temp=~temp;
  108.                 tp=temp;
  109.                 temp=tp*0.0625*100+0.5;        
  110.                 //留两个小数点就*100，+0.5是四舍五入，因为C语言浮点数转换为整型的时候把小数点
  111.                 //后面的数自动去掉，不管是否大于0.5，而+0.5之后大于0.5的就是进1了，小于0.5的就
  112.                 //算加上0.5，还是在小数点后面。
  113.           }
  114.          else
  115.           {                        
  116.                 DisplayData[0] = 0x00;
  117.                 tp=temp;//因为数据处理有小数点所以将温度赋给一个浮点型变量
  118.                 //如果温度是正的那么，那么正数的原码就是补码它本身
  119.                 temp=tp*0.0625*100+0.5;        
  120.                 //留两个小数点就*100，+0.5是四舍五入，因为C语言浮点数转换为整型的时候把小数点
  121.                 //后面的数自动去掉，不管是否大于0.5，而+0.5之后大于0.5的就是进1了，小于0.5的就
  122.                 //算加上0.5，还是在小数点后面。
  123.         }
  124.         DisplayData[0] = DIG_CODE[tempmax / 10];
  125.         DisplayData[1] = DIG_CODE[tempmax % 10];
  126.         DisplayData[4] = DIG_CODE[tempmin / 10];
  127.         DisplayData[5] = DIG_CODE[tempmin % 10];
  128.         DisplayData[2] = DIG_CODE[temp % 10000 / 1000];
  129.         DisplayData[3] = DIG_CODE[temp % 1000/100];
  130.          DigDisplay();                                           //扫描显示
  131. void DigDisplay()
  132. {
  133.         unsigned char i;
  134.         unsigned int j;
  135.         for(i=0;i<6;i++)
  136.         {
  137.                 switch(i)         //位选，选择点亮的数码管
  138.                 {
  139.                         
  140.                         case(0):
  141.                                 LS1=0;LS2=1;LS3=1;LS4=1;LS5=1;LS6=1; break;//显示第0位
  142.                         case(1):
  143.                                 LS1=1;LS2=0;LS3=1;LS4=1;LS5=1;LS6=1; break;//显示第1位
  144.                         
  145.                         case(2):
  146.                                 LS1=1;LS2=1;LS3=0;LS4=1;LS5=1;LS6=1; break;//显示第2位
  147.                         case(3):
  148.                                 LS1=1;LS2=1;LS3=1;LS4=0;LS5=1;LS6=1; break;//显示第3位
  149.                         
  150.                         case(4):
  151.                                 LS1=1;LS2=1;LS3=1;LS4=1;LS5=0;LS6=1; break;//显示第4位
  152.                         case(5):
  153.                                 LS1=1;LS2=1;LS3=1;LS4=1;LS5=1;LS6=0; break;//显示第5位
  154.                 }
  155.                 GPIO_DIG=DisplayData[i];//发送段码
  156.                 j=200;                                                 //扫描间隔时间设定
  157.                 while(j--);        
  158.                 GPIO_DIG=0x00;//消隐
  159.         }
  160. }

  162. void main()
  163. {
  164.         buzzer=1;
  165.         
  166.         while(1)
  167.         {
  168.                 LcdDisplay(Ds18b20ReadTemp());
  169.         }
  170. }
  171. //#include"temp.h"

  173. void chaomax()
  174.       {
  175.         buzzer=1;
  176.                         
  177.        }
  178.         if(key1==0)
  179.                 {
  180.                         Delay1ms(300);//按键防抖
  181.                         if(key1==0)
  182.                         {
  183.                         tempmax++;
  184.                         }
  185.                 }
  186.                         if(key2==0)
  187.                 {
  188.                         Delay1ms(300);
  189.                         if(key2==0)
  190.                         {
  191.                         tempmax--;
  192.                         }                        
  193.                 }
  194.                         if(key3==0)
  195.                 {
  196.                         Delay1ms(300);
  197.                         if(key3==0)
  198.                         {
  199.                         tempmin++;
  200.                         }        
  201.                 }
  202.                         if(key4==0)
  203.                 {
  204.                         Delay1ms(300);
  205.                         if(key4==0)
  206.                         {
  207.                         tempmin--;
  208.                         }
  209.                 }

  211. if(temp<(tempmin*100))//*100是为了使当前值和最小值在同一数量级比较
  212.         {
  213.                 jileimin++;
  214.                 jileimid=0;               
  215.                 if(jileimin>3)//扫描3次以确定已经低于下限值
  216.                 {
  217.                 tempmode=1;        //区分当前值是否是原值还是恢复值，原值为0，由上限值恢复是2，由下限值恢复时1
  218.           chaomin();
  219.                 jileimin=0;//积累值置位
  220.                 }
  221.         }
  222.         if(temp>(tempmax*100))
  223.         {
  224.                 jileimax++;
  225.                 jileimid=0;
  226.                 if(jileimax>3)
  227.                 {
  228.                 tempmode=2;         
  229.                         chaomax();
  230.                         jileimax=0;
  231.                 }
  232.         }
  233.         
  234.         if((tempmin*100)<temp&&temp<(tempmax*100))
  235.         {
  236.                 jileimax=0;
  237.                 jileimin=0;
  238.                 jileimid++;
  239.         if(jileimid>3)
  240.         {
  241.            switch(tempmode)
  242.                 {
  243.                          case 0:buzzer=0;break;
  244.                          case 1:guomin();break;
  245.                          case 2:guomax();break;                 
  246.                 }               
  247.                 tempmode=0;
  248.                 buzzer=0;
  249.                 jileimid=0;
  250.         }
  251.         }
  252. //三声短鸣表示低于温度下限
  253. void chaomin()
  254.     {
  255.        buzzer=1;
  256.                          Delay1ms(200);
  257.                          buzzer=0;
  258.                          Delay1ms(200);
  259.                          buzzer=1;
  260.                          Delay1ms(200);
  261.                          buzzer=0;
  262.                          Delay1ms(200);
  263.                          buzzer=1;
  264.                          Delay1ms(200);
  265.                          buzzer=0;
  266.                          Delay1ms(1000);
  267.                 }

  269. //三声短鸣表示超过温度上限               
  270. void guomax()
  271.                 {
  272.                          buzzer=0;
  273.                          Delay1ms(200);
  274.                    buzzer=1;
  275.                          Delay1ms(200);
  276.                          buzzer=0;
  277.                          Delay1ms(200);
  278.                          buzzer=1;
  279.                          Delay1ms(200);
  280.                          buzzer=0;
  281.                          Delay1ms(200);
  282.                          buzzer=1;
  283.                          Delay1ms(200);
  284.                          buzzer=0;
  285.                          Delay1ms(200);
  286.                 }
  287. //2秒长鸣表示超过温度下限               
  288. void guomin()
  289.     {
  290.       buzzer=1;
  291.                         Delay1ms(2000);
  292.                         buzzer=0;
  293.     }
复制代码


回复

使用道具 举报

ID:155507 发表于 2019-5-29 23:54 | 显示全部楼层
你这个程序不完整，你检查一下

少了这个
#define uchar unsigned char
#define uint unsigned int
回复

使用道具 举报

ID:155507 发表于 2019-5-30 19:37 | 显示全部楼层
原理图得提供啊，怎么接线的
单片机程序是要针对相应的硬件环境的，
给你改了一下试试。这个要看你的硬件电路了


  2. #include <reg52.h>

  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define GPIO_DIG P1

  8. sbit DSPORT=P3^6; //DS18B20管脚定义
  9. sbit buzzer=P3^7;
  10. sbit key1=P3^2; //按键
  11. sbit key2=P3^3;
  12. sbit key3=P3^4;
  13. sbit key4=P3^5;

  15. sbit LS1=P2^0; //位选
  16. sbit LS2=P2^1;
  17. sbit LS3=P2^2;
  18. sbit LS4=P2^3;
  19. sbit LS5=P2^4;
  20. sbit LS6=P2^5;

  22. void LcdDisplay(int);
  23. void DigDisplay();
  24. void chaomax();
  25. void chaomin();
  26. void guomax();
  27. void guomin();
  28. void key();

  30. //存储上下限变量
  31. int tempmax=30, tempmin=20, tempt, tempmode=0;
  32. int jileimax=0, jileimin=0, jileimid=0;

  34. void Delay1ms(unsigned char x)
  35. {
  36.         unsigned char i,j;
  37.         for(i=0;i<x;i++)
  38.             for(j=0;j<112;j++);
  39. }
  40. uchar  Ds18b20Init()
  41. {
  42.         uchar i;
  43.         DSPORT = 0;                         //将总线拉低480us~960us
  44.         //i = 70;        
  45.         i = 900;        
  46.         while(i--);//延时642us
  47.         DSPORT = 1;                        //然后拉高总线，如果DS18B20做出反应会将在15us~60us后总线拉低
  48.         i = 0;
  49.         while(DSPORT)        //等待DS18B20拉低总线
  50.         {
  51.                 Delay1ms(1);
  52.                 i++;
  53.                 if(i>5)//等待>5MS
  54.                 {
  55.                         return 0;//初始化失败
  56.                 }
  57.                
  58.         }
  59.         return 1;//初始化成功
  60. }
  61. void Ds18b20WriteByte(uchar dat)//????????
  62. {
  63.         uint i, j;
  64.         for(j=0; j<8; j++)
  65.         {
  66.                 DSPORT = 0;                       //每写入一位数据之前先把总线拉低1us     
  67.                 i++;
  68.                 DSPORT = dat & 0x01;  //然后写入一个数据，从最低位开始
  69.                 i=8;
  70.                 while(i--); //延时8us        
  71.                 DSPORT = 1;        //然后释放总线，至少1us给总线恢复时间才能接着写入第二个数值
  72.                 dat >>= 1;
  73.         }
  74. }
  75. uchar Ds18b20ReadByte()
  76. {
  77.         uchar byte, bi;
  78.         uint i, j;        
  79.         for(j=8; j>0; j--)
  80.         {
  81.                 DSPORT = 0; //先将总线拉低1us
  82.                 i++;
  83.                 DSPORT = 1; //然后释放总线
  84.                 i++;
  85.                 i++; //延时2us等待数据稳定
  86.                 bi = DSPORT;         //读取数据，从最低位开始读取
  87.                 /*将byte左移一位，然后或上右移7位后的bi，注意移动之后移掉那位补0。*/
  88.                 byte = (byte >> 1) | (bi << 7);                                                  
  89.                 i = 4;                //读取完之后等待4us再接着读取下一个数
  90.                 while(i--);
  91.         }                                
  92.         return byte;
  93. }
  94. void  Ds18b20ChangTemp()
  95. {
  96.         Ds18b20Init();
  97.         Delay1ms(1);
  98.         Ds18b20WriteByte(0xcc);    //跳过ROM操作命令                 
  99.         Ds18b20WriteByte(0x44);    //温度转换命令
  100.         Delay1ms(20);         //等待转换成功，而如果你是一直刷着的话，就不用这个延时了
  101. }
  102. void  Ds18b20ReadTempCom()
  103. {        
  104.         Ds18b20Init();
  105.         Delay1ms(1);
  106.         Ds18b20WriteByte(0xcc);         //跳过ROM操作命令
  107.         Ds18b20WriteByte(0xbe);         //发送读取温度命令
  108. }
  109. int Ds18b20ReadTemp()
  110. {
  111.         int temp = 0;
  112.         uchar tmh, tml;
  113.         Ds18b20ChangTemp();                     //先写入转换命令
  114.         Ds18b20ReadTempCom();                   //然后等待转换完后发送读取温度命令
  115.         tml = Ds18b20ReadByte();                //读取温度值共16位，先读低字节
  116.         tmh = Ds18b20ReadByte();                //再读高字节
  117.         temp = tmh;
  118.         temp <<= 8;
  119.         temp |= tml;
  120.         return temp;
  121. }
  122. void LcdDisplay(int temp)          //lcd显示???
  123. {

  125.         float tp;  
  126.         if(temp< 0)                                //当温度值为负数
  127.         {
  128.                 DisplayData[0] = 0x40;
  129.                 //因为读取的温度是实际温度的补码，所以减1，再取反求出原码
  130.                 temp=temp-1;
  131.                 temp=~temp;
  132.                 tp=temp;
  133.                 temp=tp*0.0625*100+0.5;        
  134.                 //留两个小数点就*100，+0.5是四舍五入，因为C语言浮点数转换为整型的时候把小数点
  135.                 //后面的数自动去掉，不管是否大于0.5，而+0.5之后大于0.5的就是进1了，小于0.5的就
  136.                 //算加上0.5，还是在小数点后面。
  137.         }
  138.         else
  139.         {                        
  140.                 DisplayData[0] = 0x00;
  141.                 tp=temp;//因为数据处理有小数点所以将温度赋给一个浮点型变量
  142.                 //如果温度是正的那么，那么正数的原码就是补码它本身
  143.                 temp=tp*0.0625*100+0.5;        
  144.                 //留两个小数点就*100，+0.5是四舍五入，因为C语言浮点数转换为整型的时候把小数点
  145.                 //后面的数自动去掉，不管是否大于0.5，而+0.5之后大于0.5的就是进1了，小于0.5的就
  146.                 //算加上0.5，还是在小数点后面。
  147.         }
  148.         DisplayData[0] = DIG_CODE[tempmax / 10];
  149.         DisplayData[1] = DIG_CODE[tempmax % 10];
  150.         DisplayData[4] = DIG_CODE[tempmin / 10];
  151.         DisplayData[5] = DIG_CODE[tempmin % 10];
  152.         DisplayData[2] = DIG_CODE[temp % 10000 / 1000];
  153.         DisplayData[3] = DIG_CODE[temp % 1000/100];
  154.         DigDisplay();   
  155. }                                        //扫描显示
  156. void DigDisplay()
  157. {
  158.         unsigned char i;
  159.         unsigned int j;
  160.         for(i=0;i<6;i++)
  161.         {
  162.                 switch(i)         //位选，选择点亮的数码管
  163.                 {
  164.                        
  165.                         case(0):
  166.                         LS1=0;LS2=1;LS3=1;LS4=1;LS5=1;LS6=1; break;//显示第0位
  167.                         case(1):
  168.                         LS1=1;LS2=0;LS3=1;LS4=1;LS5=1;LS6=1; break;//显示第1位
  169.                        
  170.                         case(2):
  171.                         LS1=1;LS2=1;LS3=0;LS4=1;LS5=1;LS6=1; break;//显示第2位
  172.                         case(3):
  173.                         LS1=1;LS2=1;LS3=1;LS4=0;LS5=1;LS6=1; break;//显示第3位
  174.                        
  175.                         case(4):
  176.                         LS1=1;LS2=1;LS3=1;LS4=1;LS5=0;LS6=1; break;//显示第4位
  177.                         case(5):
  178.                         LS1=1;LS2=1;LS3=1;LS4=1;LS5=1;LS6=0; break;//显示第5位
  179.                 }
  180.                 GPIO_DIG=DisplayData[i]; //发送段码
  181.                 j=200;                                         //扫描间隔时间设定
  182.                 while(j--);        
  183.                 GPIO_DIG=0x00; //消隐
  184.         }
  185. }

  187. void main()
  188. {
  189.         buzzer=1;
  190.        
  191.         while(1)
  192.         {
  193.                 LcdDisplay(Ds18b20ReadTemp());
  194.                 key();
  195.         }
  196. }
  197. //#include"temp.h"

  199. void chaomax()
  200. {
  201.         buzzer=1;
  202.        
  203. }

  205. void key()
  206. {

  208.         if(key1==0)
  209.         {
  210.                 Delay1ms(300);//按键防抖
  211.                 if(key1==0)
  212.                 {
  213.                         tempmax++;
  214.                 }
  215.         }
  216.         if(key2==0)
  217.         {
  218.                 Delay1ms(300);
  219.                 if(key2==0)
  220.                 {
  221.                         tempmax--;
  222.                 }                        
  223.         }
  224.         if(key3==0)
  225.         {
  226.                 Delay1ms(300);
  227.                 if(key3==0)
  228.                 {
  229.                         tempmin++;
  230.                 }        
  231.         }
  232.         if(key4==0)
  233.         {
  234.                 Delay1ms(300);
  235.                 if(key4==0)
  236.                 {
  237.                         tempmin--;
  238.                 }
  239.         }

  241.         if(temp<(tempmin*100))//*100是为了使当前值和最小值在同一数量级比较
  242.         {
  243.                 jileimin++;
  244.                 jileimid=0;               
  245.                 if(jileimin>3)//扫描3次以确定已经低于下限值
  246.                 {
  247.                         tempmode=1;        //区分当前值是否是原值还是恢复值，原值为0，由上限值恢复是2，由下限值恢复时1
  248.                         chaomin();
  249.                         jileimin=0;//积累值置位
  250.                 }
  251.         }
  252.         if(temp>(tempmax*100))
  253.         {
  254.                 jileimax++;
  255.                 jileimid=0;
  256.                 if(jileimax>3)
  257.                 {
  258.                         tempmode=2;         
  259.                         chaomax();
  260.                         jileimax=0;
  261.                 }
  262.         }

  264.         if((tempmin*100)<temp&&temp<(tempmax*100))
  265.         {
  266.                 jileimax=0;
  267.                 jileimin=0;
  268.                 jileimid++;
  269.                 if(jileimid>3)
  270.                 {
  271.                         switch(tempmode)
  272.                         {
  273.                         case 0:buzzer=0;break;
  274.                         case 1:guomin();break;
  275.                         case 2:guomax();break;                 
  276.                         }               
  277.                         tempmode=0;
  278.                         buzzer=0;
  279.                         jileimid=0;
  280.                 }
  281.         }
  282. }
  283. //三声短鸣表示低于温度下限
  284. void chaomin()
  285. {
  286.         buzzer=1;
  287.         Delay1ms(200);
  288.         buzzer=0;
  289.         Delay1ms(200);
  290.         buzzer=1;
  291.         Delay1ms(200);
  292.         buzzer=0;
  293.         Delay1ms(200);
  294.         buzzer=1;
  295.         Delay1ms(200);
  296.         buzzer=0;
  297.         Delay1ms(1000);
  298. }

  300. //三声短鸣表示超过温度上限               
  301. void guomax()
  302. {
  303.         buzzer=0;
  304.         Delay1ms(200);
  305.         buzzer=1;
  306.         Delay1ms(200);
  307.         buzzer=0;
  308.         Delay1ms(200);
  309.         buzzer=1;
  310.         Delay1ms(200);
  311.         buzzer=0;
  312.         Delay1ms(200);
  313.         buzzer=1;
  314.         Delay1ms(200);
  315.         buzzer=0;
  316.         Delay1ms(200);
  317. }
  318. //2秒长鸣表示超过温度下限               
  319. void guomin()
  320. {
  321.         buzzer=1;
  322.         Delay1ms(2000);
  323.         buzzer=0;
  324. }

复制代码
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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