标题: 求大神帮忙看看单片机代码哪里错了，万分感谢，比较急 [打印本页]
作者: 糯米团子丫    时间: 2020-6-25 19:36
标题: 求大神帮忙看看单片机代码哪里错了，万分感谢，比较急
  1. #include<reg51.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. uchar temp,num,klnum;
  6. uchar code table[]={"18B20 OKTL"};
  7. char shangxiaxian[2]={-10,10};
  8. char a;
  9. sbit k1=P1^0;
  10. sbit k2=P1^1;
  11. sbit k3=P1^2;
  12. sbit k4=P1^3;
  13. sbit LCD_RW=P2^5;
  14. sbit lcdrs=P2^6;
  15. sbit lcden=P2^7;
  16. sbit Beep=P3^0;
  17. sbit led=P3^1;
  18. sbit DQ=P3^7;    /*液晶显示屏的延时程序*/
  19. void delay(uint z)
  20. {
  21. uint x,y;
  22. for(x=z;x>0;x--)
  23.     for(y=110;y>0;y--);
  24. }                 /*温度传感器的延时程序*/
  25. void Delay1(uint y)
  26. {
  27. uint x;
  28. for( ;y>0; y--)
  29.   {
  30.    for(x=110;x>0;x--);
  31.   }
  32. }                 /*蜂鸣器，18B20写数据函数的延时程序*/
  33. void delay2(uint a)
  34. {
  35. while(--a);
  36. }                                       /*温度传感器初始化函数*/
  37. void init_18B20()
  38. {
  39. DQ=1;
  40. delay2(8);
  41. DQ=0;
  42. delay2(90);
  43. DQ=1;
  44. _nop_();
  45. _nop_();
  46. delay2(100);
  47. DQ=1;
  48. }                  /*温度传感器写字节命令函数*/
  49. void DS18B20xiezijie(uchar date)
  50. {
  51. uchar i;
  52. for(i=0;i<8;i++)
  53.   {
  54.    DQ=0;                                      //在写入一位数据之前先把总线拉低
  55.          DQ=date&0x01;                   //写入一个数据，从最低位开始写
  56.          delay2(5);                               //延时
  57.          DQ=1;                                      //将总线拉高，等待第二位数据写入
  58.          date>>=1;                              //右移一位，写入第二位数据
  59.          }
  60. }                                                          /*温度传感器读字节命令函数*/
  61. uchar DS18B20duzijie()
  62. {
  63. uchar i,dat=0;
  64. DQ=1;
  65. _nop_();
  66. for(i=0;i<8;i++)
  67.   {
  68.    DQ=0;                  //先将总线拉低
  69.          _nop_();
  70.          _nop_();
  71.          dat>>=1;
  72.          DQ=1;                                      //然后释放总线
  73.          _nop_();                         //延时一下等待数据稳定
  74.          _nop_();                        
  75.          if(DQ)
  76.          dat|=0x80;                             //读取数据，从最低位开始读取
  77.          delay2(30);                             //读取完之后等待一下，再接着读取下一个数
  78.          DQ=1;
  79.   }
  80. return dat;                        //返回所读到的温度
  81. }                                                        /*写温度转换命令函数*/
  82. void DS18B20ChangTemp()
  83. {
  84. init_18B20();
  85. Delay1(1);
  86. DS18B20xiezijie(0xcc);   //跳过ROM操作命令
  87. DS18B20xiezijie(0x44);   //温度转换命令
  88. }                                                          /*读温度命令函数*/
  89. void DS18B20ReadTempCom()
  90. {
  91. init_18B20();
  92. Delay1(1);
  93. DS18B20xiezijie(0xcc);   //跳过ROM操作命令
  94. DS18B20xiezijie(0xbe);   //发送读取温度命令
  95. }                                                          /*读温度函数*/
  96. int DS18B20ReadTemp()
  97. {
  98.   inttemp=0;
  99.   uchartmh,tml;
  100. DS18B20ChangTemp();           //先写入转换命令
  101. DS18B20ReadTempCom();     //然后等待转换完成后发送读取温度命令
  102. tml=DS18B20duzijie();             //读取温度值共16位，先读低字节
  103. tmh=DS18B20duzijie();           //再读高字节
  104. temp=tmh;
  105. temp<<=8;
  106. temp|=tml;
  107. return temp;                              /*液晶屏写指令函数*/
  108. }
  109. void write_com(uchar com)
  110. {
  111. lcdrs=0;
  112. lcden=0;
  113. LCD_RW=0;
  114. P0=com;
  115. delay(5);
  116. lcden=1;
  117. delay(5);
  118. lcden=0;
  119. }                                                          /*液晶屏写指令函数*/
  120. void write_com2(int com)
  121. {
  122. lcdrs=0;
  123. LCD_RW=0;
  124. lcden=0;
  125. delay(5);
  126. P0=com;
  127. delay(5);
  128. lcden=1;
  129. delay(5);
  130.   lcden=0;
  131. P0=(com&0x0f)<<4;
  132. delay(5);
  133. lcden=1;
  134. delay(5);
  135. lcden=0;
  136. }                                                          /*液晶屏写数据命令函数*/
  137. void write_data(char date)
  138. {
  139. lcdrs=1;
  140. LCD_RW=0;
  141. lcden=0;
  142. P0=date;
  143. delay(5);
  144. lcden=1;
  145. delay(5);
  146. lcden=0;
  147. lcdrs=1;
  148. LCD_RW=0;
  149. lcden=0;
  150. P0=(date&0x0f)<<4;       //一次写入4位
  151. delay(5);
  152. lcden=1;
  153. delay(5);
  154. lcden=0;
  155. }                                                          /*液晶屏初始化函数*/
  156. void init()
  157. {
  158. lcden=0;
  159. write_com(0x28);
  160. write_com2(0x28);
  161. write_com2(0x0c);
  162. write_com2(0x06);
  163. write_com2(0x01);
  164. write_com2(0x80);
  165. }                                                          /*报警上下线处理函数*/
  166. void write_hl(uchar add,char date)
  167. {
  168. uchar bai,shi,ge;
  169. if(date<0){date=-date;}
  170. bai=date/100;
  171. shi=date%100/10;
  172. ge=date%100%10;
  173. write_com2(0x80+0x40+add);
  174. write_date(0x30+bai);
  175. write_date(0x30+shi);
  176. write_date(0x30+ge);
  177. }                                                        /*报警上下线处理函数*/
  178. void write_hl1(uchar add,char date)
  179. {
  180. uchar bai,shi,ge;
  181. if(date<0){date=-date;}
  182. bai=date/100;
  183. shi=date%100/10;
  184. ge=date%100%10;
  185. write_com2(0x80+add);
  186. write_date(0x30+bai);
  187. write_date(0x30+shi);
  188. write_date(0x30+ge);
  189. }                                                        /*液晶屏显示函数，显示温度值*/
  190. void Lcdxianshi(int temp)
  191. {
  192. uchar sz[4]={0,0,0,0};
  193. unsigned char datas[]={0,0,0,0,0}; //定义数组
  194. float tp;
  195. if(temp<0)                //当温度值为负数
  196. {
  197. write_com2(0x80+0x40);    //写地址80表示初始地址
  198. write_data('-');          //显示负
  199. temp=temp-1; //因为读取的温度是实际温度的补码，所以减一，再取反求出原码
  200. temp=~temp;
  201. tp=temp;
  202. temp=tp*0.0625*100+0.5
  203. }
  204. else
  205. {
  206.   write_com2(0x80+0x40);  //写地址80表示初始地址
  207.   write_data('+');                    //显示正
  208.   tp=temp;  //因为数据处理有小数点，所以将温度赋给一个浮点型变量，如果温度是正，那么正数的原码就是补码本身
  209.   temp=tp*0.0625*100+0.5;
  210.   }
  211. datas[0]=temp/1000;                       //百位
  212. datas[1]=tem%10000/1000;          //十位
  213. datas[2]=temp%1000/100;       //个位
  214. datas[3]=temp%100/10;                          //小数
  215. write_com2(0x80+0x40+1);
  216. write_data('0'+datas[0]);
  217. write_com2(0x80+0x40+2);
  218. write_data('0'+datas[1]);
  219. write_com2(0x80+0x40+3);
  220. write_data('0'+datas[2]);
  221. write_com2(0x80+0x40+4);
  222. write_data('.');
  223. write_com2(0x80+0x40+5);
  224. write_data('0'+datas[3]);
  225. a=(datas[0]*100+datas[1]*10+datas[2]);  //用于温度的比较值
  226. write_hl(13,shangxiaxian[1]);  //显示报警上限
  227. write_hl1(13,shangxiaxian[0]);      //显示报警下限
  228. }                                                                         /*按键处理函数，用于设置温度报警值*/
  229. void key()
  230. {
  231. if(k1==0)
  232.   {
  233.   delay(5);
  234.   if(k1==0)  //温度报警下限加
  235.    {
  236.     shangxiaxian[0]++;
  237.           if(shangxiaxian[0]==127)
  238.           shangxiaxian[0]=126;
  239.           write_hl1(13,shangxiaxian[0]);
  240.          }
  241.    }
  242.     if(k2==0)  //温度报警下限减
  243.             {
  244.               delay(5);
  245.                     if(k2==0)
  246.                     {
  247.                      shangxiaxian[0]--;
  248.                      if(shangxiaxian[0]==-56)
  249.                      shangxiaxian[0]=-55;
  250.                      write_hl1(13,shangxiaxian[0]);
  251.                     }
  252.                    }
  253.           if(k3==0)  //温度报警上限加
  254.             {
  255.              delay(5);
  256.                    if(k3==0)
  257.                     {
  258.                       shangxiaxian[1]++;
  259.                       if(shangxiaxian[1]==127)
  260.                       shangxiaxian[1]=126;
  261.                       write_hl(13,shangxiaxian[1]);
  262.                      }
  263.                    }
  264.                     if(k4==0)  //温度报警上限减
  265.                     {
  266.                      delay(5);
  267.                      if(k4==0)
  268.                      {
  269.                       shangxiaxian[1]--;
  270.                       if(shangxiaxian[1]==-56)
  271.                       shangxiaxian[1]=-55;
  272.                       write_hl(13,shangxiaxian[1]);
  273.                      }
  274.                     }
  275.          }
  276. void main()
  277. {
  278. intb;
  279. init();
  280. led=0;
  281. for(num=0;num<11;num++)   //让液晶屏显示“18B20 OK TL”
  282. {
  283. write_data(table[num]);
  284. delay(20);
  285.   }
  286. write_com2(0x80+0x40+9);
  287. write_data('T');
  288. write_com2(0x80+0x40+10);
  289. write_data('H');
  290. while(1)
  291.   {
  292.    key();
  293.          Lcdxianshi(Ds18B20ReadTemp());
  294.          delay(100);
  295.          if(shangxiaxian[0]<0)
  296.          {
  297.            write_com2(0x80+12);
  298.            write_data('-');
  299.          }
  300.   else
  301.    {
  302.     write_com2(0x80+12);
  303.           write_data('+');
  304.          }
  305.    if(shangxiaxian[1]<0)
  306.          {
  307.          write_com2(0x80+0x40+12);
  308.          write_data('-');
  309.     }
  310.          else
  311.          {
  312.          write_com2(0x80+0x40+12);
  313.          write_data('+');
  314.          }
  315.            if(a>shangxiaxian[1])    //判断温度值与报警值的大小
  316.            {
  317.              write_com2(0x80+0x40+6);
  318.                    write_data('<');
  319.                    write_com2(0x80+0x40+7);
  320.                    write_data('L');
  321.            }
  322.           if(a>=shangxiaxian[0]&&a<=shangxiaxian[1]) //判断温度值与报警值的大小
  323.            {
  324.              write_com2(0x80+0x40+6);
  325.                    write_data('');
  326.                    write_com2(0x80+0x40+7);
  327.                    write_data('！');
  328.            }
  329.           if(a>shangxiaxian[0]||a>shangxiaxian[1])  //如果温度值在报警值之外，蜂鸣器响
  330.            {
  331.              for(b=0;b<1000;b++)
  332.                      {Beep=1;led=1;
  333.                       delay2(20);
  334.                       Beep=0;led=0;
  335.                       delay0(20);
  336.                       }
  337.                    }
  338.          }
  339. }




复制代码


1.png (118.67 KB, 下载次数: 58)

1.png

0.png (120.94 KB, 下载次数: 38)

0.png
作者: wulin    时间: 2020-6-26 06:32
错误很多，基本都是抄写错误。大小写错误、中文符号错误、丢分号，缺空格等等。现已通过编译。
  1. #include<reg51.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. uchar temp,num,klnum;
  6. uchar code table[]={"18B20 OKTL"};
  7. char shangxiaxian[2]={-10,10};
  8. char a;
  9. sbit k1=P1^0;
  10. sbit k2=P1^1;
  11. sbit k3=P1^2;
  12. sbit k4=P1^3;
  13. sbit LCD_RW=P2^5;
  14. sbit lcdrs=P2^6;
  15. sbit lcden=P2^7;
  16. sbit Beep=P3^0;
  17. sbit led=P3^1;
  18. sbit DQ=P3^7;    /*液晶显示屏的延时程序*/
  19. void delay(uint z)
  20. {
  21.         uint x,y;
  22.         for(x=z;x>0;x--)
  23.                 for(y=110;y>0;y--);
  24. }
  25. /*温度传感器的延时程序*/
  26. void Delay1(uint y)
  27. {
  28.         uint x;
  29.         for( ;y>0; y--)
  30.         {
  31.                 for(x=110;x>0;x--);
  32.         }
  33. }
  34. /*蜂鸣器，18B20写数据函数的延时程序*/
  35. void delay2(uint a)
  36. {
  37.         while(--a);
  38. }
  39. /*温度传感器初始化函数*/
  40. void init_18B20()
  41. {
  42.         DQ=1;
  43.         delay2(8);
  44.         DQ=0;
  45.         delay2(90);
  46.         DQ=1;
  47.         _nop_();
  48.         _nop_();
  49.         delay2(100);
  50.         DQ=1;
  51. }
  52. /*温度传感器写字节命令函数*/
  53. void DS18B20xiezijie(uchar date)
  54. {
  55.         uchar i;
  56.         for(i=0;i<8;i++)
  57.         {
  58.                 DQ=0;                                      //在写入一位数据之前先把总线拉低
  59.                 DQ=date&0x01;                   //写入一个数据，从最低位开始写
  60.                 delay2(5);                               //延时
  61.                 DQ=1;                                      //将总线拉高，等待第二位数据写入
  62.                 date>>=1;                              //右移一位，写入第二位数据
  63.         }
  64. }                                                          /*温度传感器读字节命令函数*/
  65. uchar DS18B20duzijie()
  66. {
  67.         uchar i,dat=0;
  68.         DQ=1;
  69.         _nop_();
  70.         for(i=0;i<8;i++)
  71.         {
  72.                 DQ=0;                  //先将总线拉低
  73.                 _nop_();
  74.                 _nop_();
  75.                 dat>>=1;
  76.                 DQ=1;                                      //然后释放总线
  77.                 _nop_();                         //延时一下等待数据稳定
  78.                 _nop_();                        
  79.                 if(DQ)
  80.                 dat|=0x80;                             //读取数据，从最低位开始读取
  81.                 delay2(30);                             //读取完之后等待一下，再接着读取下一个数
  82.                 DQ=1;
  83.         }
  84.         return dat;                        //返回所读到的温度
  85. }                                                        /*写温度转换命令函数*/
  86. void DS18B20ChangTemp()
  87. {
  88.         init_18B20();
  89.         Delay1(1);
  90.         DS18B20xiezijie(0xcc);   //跳过ROM操作命令
  91.         DS18B20xiezijie(0x44);   //温度转换命令
  92. }                                                          /*读温度命令函数*/
  93. void DS18B20ReadTempCom()
  94. {
  95.         init_18B20();
  96.         Delay1(1);
  97.         DS18B20xiezijie(0xcc);   //跳过ROM操作命令
  98.         DS18B20xiezijie(0xbe);   //发送读取温度命令
  99. }                                                          /*读温度函数*/
  100. int DS18B20ReadTemp()
  101. {
  102.         int temp=0;
  103.         uchar tmh,tml;
  104.         DS18B20ChangTemp();           //先写入转换命令
  105.         DS18B20ReadTempCom();     //然后等待转换完成后发送读取温度命令
  106.         tml=DS18B20duzijie();             //读取温度值共16位，先读低字节
  107.         tmh=DS18B20duzijie();           //再读高字节
  108.         temp=tmh;
  109.         temp<<=8;
  110.         temp|=tml;
  111.         return temp;                              /*液晶屏写指令函数*/
  112. }
  113. void write_com(uchar com)
  114. {
  115.         lcdrs=0;
  116.         lcden=0;
  117.         LCD_RW=0;
  118.         P0=com;
  119.         delay(5);
  120.         lcden=1;
  121.         delay(5);
  122.         lcden=0;
  123. }                                                          /*液晶屏写指令函数*/
  124. void write_com2(int com)
  125. {
  126.         lcdrs=0;
  127.         LCD_RW=0;
  128.         lcden=0;
  129.         delay(5);
  130.         P0=com;
  131.         delay(5);
  132.         lcden=1;
  133.         delay(5);
  134.         lcden=0;
  135.         P0=(com&0x0f)<<4;
  136.         delay(5);
  137.         lcden=1;
  138.         delay(5);
  139.         lcden=0;
  140. }                                                          /*液晶屏写数据命令函数*/
  141. void write_data(char date)
  142. {
  143.         lcdrs=1;
  144.         LCD_RW=0;
  145.         lcden=0;
  146.         P0=date;
  147.         delay(5);
  148.         lcden=1;
  149.         delay(5);
  150.         lcden=0;
  151.         lcdrs=1;
  152.         LCD_RW=0;
  153.         lcden=0;
  154.         P0=(date&0x0f)<<4;       //一次写入4位
  155.         delay(5);
  156.         lcden=1;
  157.         delay(5);
  158.         lcden=0;
  159. }                                                          /*液晶屏初始化函数*/
  160. void init()
  161. {
  162.         lcden=0;
  163.         write_com(0x28);
  164.         write_com2(0x28);
  165.         write_com2(0x0c);
  166.         write_com2(0x06);
  167.         write_com2(0x01);
  168.         write_com2(0x80);
  169. }                                                          /*报警上下线处理函数*/
  170. void write_hl(uchar add,char date)
  171. {
  172.         uchar bai,shi,ge;
  173.         if(date<0){date=-date;}
  174.         bai=date/100;
  175.         shi=date%100/10;
  176.         ge=date%100%10;
  177.         write_com2(0x80+0x40+add);
  178.         write_data(0x30+bai);
  179.         write_data(0x30+shi);
  180.         write_data(0x30+ge);
  181. }                                                        /*报警上下线处理函数*/
  182. void write_hl1(uchar add,char date)
  183. {
  184.         uchar bai,shi,ge;
  185.         if(date<0){date=-date;}
  186.         bai=date/100;
  187.         shi=date%100/10;
  188.         ge=date%100%10;
  189.         write_com2(0x80+add);
  190.         write_data(0x30+bai);
  191.         write_data(0x30+shi);
  192.         write_data(0x30+ge);
  193. }                                                        /*液晶屏显示函数，显示温度值*/
  194. void Lcdxianshi(int temp)
  195. {
  196.         uchar sz[4]={0,0,0,0};
  197.         unsigned char datas[]={0,0,0,0,0}; //定义数组
  198.         float tp;
  199.         if(temp<0)                //当温度值为负数
  200.         {
  201.                 write_com2(0x80+0x40);    //写地址80表示初始地址
  202.                 write_data('-');          //显示负
  203.                 temp=temp-1; //因为读取的温度是实际温度的补码，所以减一，再取反求出原码
  204.                 temp=~temp;
  205.                 tp=temp;
  206.                 temp=tp*0.0625*100+0.5;
  207.         }
  208.         else
  209.         {
  210.                 write_com2(0x80+0x40);  //写地址80表示初始地址
  211.                 write_data('+');                    //显示正
  212.                 tp=temp;  //因为数据处理有小数点，所以将温度赋给一个浮点型变量，如果温度是正，那么正数的原码就是补码本身
  213.                 temp=tp*0.0625*100+0.5;
  214.         }
  215.         datas[0]=temp/10000;                       //百位
  216.         datas[1]=temp%10000/1000;          //十位
  217.         datas[2]=temp%1000/100;       //个位
  218.         datas[3]=temp%100/10;                          //小数
  219.         write_com2(0x80+0x40+1);
  220.         write_data('0'+datas[0]);
  221.         write_com2(0x80+0x40+2);
  222.         write_data('0'+datas[1]);
  223.         write_com2(0x80+0x40+3);
  224.         write_data('0'+datas[2]);
  225.         write_com2(0x80+0x40+4);
  226.         write_data('.');
  227.         write_com2(0x80+0x40+5);
  228.         write_data('0'+datas[3]);
  229.         a=(datas[0]*100+datas[1]*10+datas[2]);  //用于温度的比较值
  230.         write_hl(13,shangxiaxian[1]);  //显示报警上限
  231.         write_hl1(13,shangxiaxian[0]);      //显示报警下限
  232. }                                                                         /*按键处理函数，用于设置温度报警值*/
  233. void key()
  234. {
  235.         if(k1==0)
  236.         {
  237.                 delay(5);
  238.                 if(k1==0)  //温度报警下限加
  239.                 {
  240.                         shangxiaxian[0]++;
  241.                         if(shangxiaxian[0]==127)
  242.                                 shangxiaxian[0]=126;
  243.                         write_hl1(13,shangxiaxian[0]);
  244.                 }
  245.         }
  246.         if(k2==0)  //温度报警下限减
  247.         {
  248.                 delay(5);
  249.                 if(k2==0)
  250.                 {
  251.                         shangxiaxian[0]--;
  252.                         if(shangxiaxian[0]==-56)
  253.                                 shangxiaxian[0]=-55;
  254.                         write_hl1(13,shangxiaxian[0]);
  255.                 }
  256.         }
  257.         if(k3==0)  //温度报警上限加
  258.         {
  259.                 delay(5);
  260.                 if(k3==0)
  261.                 {
  262.                         shangxiaxian[1]++;
  263.                         if(shangxiaxian[1]==127)
  264.                                 shangxiaxian[1]=126;
  265.                         write_hl(13,shangxiaxian[1]);
  266.                 }
  267.         }
  268.         if(k4==0)  //温度报警上限减
  269.         {
  270.                 delay(5);
  271.                 if(k4==0)
  272.                 {
  273.                         shangxiaxian[1]--;
  274.                         if(shangxiaxian[1]==-56)
  275.                                 shangxiaxian[1]=-55;
  276.                         write_hl(13,shangxiaxian[1]);
  277.                 }
  278.         }
  279. }
  280. void main()
  281. {
  282.         int b;
  283.         init();
  284.         led=0;
  285.         for(num=0;num<11;num++)   //让液晶屏显示“18B20 OK TL”
  286.         {
  287.                 write_data(table[num]);
  288.                 delay(20);
  289.         }
  290.         write_com2(0x80+0x40+9);
  291.         write_data('T');
  292.         write_com2(0x80+0x40+10);
  293.         write_data('H');
  294.         while(1)
  295.         {
  296.                 key();
  297.                 Lcdxianshi(DS18B20ReadTemp());
  298.                 delay(100);
  299.                 if(shangxiaxian[0]<0)
  300.                 {
  301.                         write_com2(0x80+12);
  302.                         write_data('-');
  303.                 }
  304.                 else
  305.                 {
  306.                         write_com2(0x80+12);
  307.                         write_data('+');
  308.                 }
  309.                 if(shangxiaxian[1]<0)
  310.                 {
  311.                         write_com2(0x80+0x40+12);
  312.                         write_data('-');
  313.                 }
  314.                 else
  315.                 {
  316.                         write_com2(0x80+0x40+12);
  317.                         write_data('+');
  318.                 }
  319.                 if(a>shangxiaxian[1])    //判断温度值与报警值的大小
  320.                 {
  321.                         write_com2(0x80+0x40+6);
  322.                         write_data('<');
  323.                         write_com2(0x80+0x40+7);
  324.                         write_data('L');
  325.                 }
  326.                 if(a>=shangxiaxian[0]&&a<=shangxiaxian[1]) //判断温度值与报警值的大小
  327.                 {
  328.                         write_com2(0x80+0x40+6);
  329.                         write_data(' ');
  330.                         write_com2(0x80+0x40+7);
  331.                         write_data('!');
  332.                 }
  333.                 if(a>shangxiaxian[0]||a>shangxiaxian[1])  //如果温度值在报警值之外，蜂鸣器响
  334.                 {
  335.                         for(b=0;b<1000;b++)
  336.                         {
  337.                                 Beep=1;led=1;
  338.                                 delay2(20);
  339.                                 Beep=0;led=0;
  340.                                 delay(20);
  341.                         }
  342.                 }
  343.         }
  344. }

复制代码
作者: 随风飘远    时间: 2020-6-26 10:08
软件会提示错误在哪一行，其实 还是要自己学会去调试，刚开始先写一些简单一点的代码会容易一点
作者: 糯米团子丫    时间: 2020-6-26 20:48
随风飘远 发表于 2020-6-26 10:08
软件会提示错误在哪一行，其实 还是要自己学会去调试，刚开始先写一些简单一点的代码会容易一点

请问您有时间帮我看一下这个错误怎么改吗？



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