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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 注释详细的单片机检漏仪源代码 在LCD1602显示 含原理图
返回列表 发新帖
查看: 730|回复: 0
打印 上一主题 下一主题
收起左侧

注释详细的单片机检漏仪源代码 在LCD1602显示 含原理图

[复制链接]
跳转到指定楼层
楼主
ID:1047761 发表于 2022-10-15 09:14 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式


  2. /*****************************************************
  3. 函数功能：延时1ms
  4. (3j+2)*i=(3×33+2)×10=1010(微秒)，可以认为是1毫秒
  5. ***************************************************/
  6. void delay1ms()
  7. {
  8.    unsigned char i,j;
  9.   for(i=0;i<10;i++)
  10.    for(j=0;j<33;j++)
  11.     ;   
  12. }
  13. /*****************************************************
  14. 函数功能：延时若干毫秒
  15. 入口参数：n
  16. ***************************************************/
  17. void delaynms(unsigned char n)
  18. {
  19.    unsigned char i;
  20. for(i=0;i<n;i++)
  21.     delay1ms();
  22. }
  23. /*****************************************************
  24. 函数功能：判断液晶模块的忙碌状态
  25. 返回值：result。result=1，忙碌;result=0，不忙
  26. ***************************************************/
  27. bit BusyTest(void)
  28.   {
  29.     bit result;
  30. RS=0;       //根据规定，RS为低电平，RW为高电平时，可以读状态
  31.     RW=1;
  32.     E=1;        //E=1，才允许读写
  33.     _nop_();   //空操作
  34.     _nop_();
  35.     _nop_();
  36.     _nop_();   //空操作四个机器周期，给硬件反应时间
  37.     result=BF;  //将忙碌标志电平赋给result
  38.    E=0;         //将E恢复低电平
  39.    return result;
  40.   }
  41. /*****************************************************
  42. 函数功能：将模式设置指令或显示地址写入液晶模块
  43. 入口参数：dictate
  44. ***************************************************/
  45. void WriteInstruction (unsigned char dictate)
  46. {   
  47.     while(BusyTest()==1);   //如果忙就等待
  48.   RS=0;                  //根据规定，RS和R/W同时为低电平时，可以写入指令
  49.   RW=0;   
  50.   E=0;                   //E置低电平(根据表8-6，写指令时，E为高脉冲，
  51.                            // 就是让E从0到1发生正跳变，所以应先置"0"
  52.   _nop_();
  53.   _nop_();               //空操作两个机器周期，给硬件反应时间
  54.   P0=dictate;            //将数据送入P0口，即写入指令或地址
  55.   _nop_();
  56.   _nop_();
  57.   _nop_();
  58.   _nop_();               //空操作四个机器周期，给硬件反应时间
  59.   E=1;                   //E置高电平
  60.   _nop_();
  61.   _nop_();
  62.   _nop_();
  63.   _nop_();               //空操作四个机器周期，给硬件反应时间
  64.    E=0;                  //当E由高电平跳变成低电平时，液晶模块开始执行命令
  65. }
  66. /*****************************************************
  67. 函数功能：指定字符显示的实际地址
  68. 入口参数：x
  69. ***************************************************/
  70. void WriteAddress(unsigned char x)
  71. {
  72.      WriteInstruction(x|0x80); //显示位置的确定方法规定为"80H+地址码x"
  73. }
  74. /*****************************************************
  75. 函数功能：将数据(字符的标准ASCII码)写入液晶模块
  76. 入口参数：y(为字符常量)
  77. ***************************************************/
  78. void WriteData(unsigned char y)
  79. {
  80.     while(BusyTest()==1);  
  81.    RS=1;           //RS为高电平，RW为低电平时，可以写入数据
  82.    RW=0;
  83.    E=0;            //E置低电平(根据表8-6，写指令时，E为高脉冲，
  84.                      // 就是让E从0到1发生正跳变，所以应先置"0"
  85.    P0=y;           //将数据送入P0口，即将数据写入液晶模块
  86.    _nop_();
  87.    _nop_();
  88.     _nop_();
  89.      _nop_();       //空操作四个机器周期，给硬件反应时间
  90.    E=1;           //E置高电平
  91.    _nop_();
  92.    _nop_();
  93.    _nop_();
  94.   _nop_();        //空操作四个机器周期，给硬件反应时间
  95.   E=0;            //当E由高电平跳变成低电平时，液晶模块开始执行命令
  96. }
  97. /*****************************************************
  98. 函数功能：对LCD的显示模式进行初始化设置
  99. ***************************************************/
  100. void LcdInitiate(void)
  101. {
  102. delaynms(15);               //延时15ms，首次写指令时应给LCD一段较长的反应时间
  103. WriteInstruction(0x38);     //显示模式设置：16×2显示，5×7点阵，8位数据接口
  104. delaynms(5);                //延时5ms　，给硬件一点反应时间
  105. WriteInstruction(0x38);
  106. delaynms(5);               //延时5ms　，给硬件一点反应时间
  107. WriteInstruction(0x38);     //连续三次，确保初始化成功
  108. delaynms(5);               //延时5ms　，给硬件一点反应时间
  109. WriteInstruction(0x0c);     //显示模式设置：显示开，无光标，光标不闪烁
  110. delaynms(5);               //延时5ms　，给硬件一点反应时间
  111. WriteInstruction(0x06);     //显示模式设置：光标右移，字符不移
  112. delaynms(5);                //延时5ms　，给硬件一点反应时间
  113. WriteInstruction(0x01);     //清屏幕指令，将以前的显示内容清除
  114. delaynms(5);             //延时5ms　，给硬件一点反应时间
  115. }

  117. /*****************************************************
  118. 函数功能：显示电压符号
  119. ***************************************************/   
  120. void display_volt(void)
  121. {
  122.     unsigned char i;
  123.   WriteAddress(0x00);    //写显示地址，将在第2行第1列开始显示
  124.   i = 0;                //从第一个字符开始显示
  125.   while(Str[i] != '\0')  //只要没有写到结束标志，就继续写
  126.    {      
  127.    WriteData(Str[i]);   //将字符常量写入LCD
  128.    i++;                 //指向下一个字符   
  129.   }
  130.   WriteAddress(0x08);    //写显示地址，将在第2行第1列开始显示
  131.   i = 0;                //从第一个字符开始显示
  132.   while(Str1[i] != '\0')  //只要没有写到结束标志，就继续写
  133.    {      
  134.    WriteData(Str1[i]);   //将字符常量写入LCD
  135.    i++;                 //指向下一个字符   
  136.   }
  137.   WriteAddress(0xC0);    //写显示地址，将在第2行第1列开始显示
  138.   i = 0;                //从第一个字符开始显示
  139.   while(Str2[i] != '\0')  //只要没有写到结束标志，就继续写
  140.    {      
  141.    WriteData(Str2[i]);   //将字符常量写入LCD
  142.    i++;                 //指向下一个字符   
  143.   }
  144.   WriteAddress(0xC8);    //写显示地址，将在第2行第1列开始显示
  145.   i = 0;                //从第一个字符开始显示
  146.   while(Str3[i] != '\0')  //只要没有写到结束标志，就继续写
  147.    {      
  148.    WriteData(Str3[i]);   //将字符常量写入LCD
  149.    i++;                 //指向下一个字符   
  150.   }   
  151. }
  152. /*****************************************************
  153. 函数功能：显示电压的小数点
  154. ***************************************************/   
  155. void  display_dot(void)
  156. {         
  157.   WriteAddress(0xc5);   //写显示地址，将在第1行第10列开始显示     
  158.   WriteData('.');       //将小数点的字符常量写入LCD  
  159.   WriteAddress(0x0D);   //写显示地址，将在第1行第10列开始显示     
  160.   WriteData('.');                //将小数点的字符常量写入LCD
  161.   WriteAddress(0x05);   //写显示地址，将在第1行第10列开始显示     
  162.   WriteData('.');        
  163. }
  164. /*****************************************************
  165. 函数功能：显示电压的单位(V)
  166. ***************************************************/   
  167. void  display_V(void)
  168. {
  169. //    WriteAddress(0x06); //写显示地址，将在第2行第13列开始显示
  170. //  WriteData('v');     //将字符常量写入LCD
  171.     WriteAddress(0x0F); //写显示地址，将在第2行第13列开始显示
  172.   WriteData('s');     //将字符常量写入LCD           
  173.    
  174. }
  175. /*****************************************************
  176. 函数功能：显示电压的整数部分
  177. 入口参数：x
  178. ***************************************************/
  179. void display1()
  180. {
  181. // WriteAddress(0x02);    //写显示地址,将在第行第7列开始显示
  182. // WriteData(digit[x]);    //将百位数字的字符常量写入LCD
  183. WriteAddress(0x0A);    //写显示地址,将在第行第7列开始显示
  184. WriteData(digit_time[0]);    //将百位数字的字符常量写入LCD
  185. WriteAddress(0x0B);    //写显示地址,将在第行第7列开始显示
  186. WriteData(digit_time[1]);    //将百位数字的字符常量写入LCD
  187. WriteAddress(0x0C);    //写显示地址,将在第行第7列开始显示
  188. WriteData(digit_time[2]);    //将百位数字的字符常量写入LCD
  189. WriteAddress(0x0E);    //写显示地址,将在第行第7列开始显示
  190. WriteData(digit_time[3]);    //将百位数字的字符常量写入LCD
  191. WriteAddress(0xC2);    //写显示地址,将在第行第7列开始显示
  192. WriteData('0'+s/10000);    //将百位数字的字符常量写入LCD
  193. WriteAddress(0xC3);    //写显示地址,将在第行第7列开始显示
  194. WriteData('0'+s%10000/1000);    //将百位数字的字符常量写入LCD
  195. WriteAddress(0xC4);    //写显示地址,将在第行第7列开始显示
  196. WriteData('0'+s%1000/100);    //将百位数字的字符常量写入LCD
  197. WriteAddress(0xC6);    //写显示地址,将在第行第7列开始显示
  198. WriteData('0'+s%100/10);    //将百位数字的字符常量写入LCD
  199. WriteAddress(0xC7);    //写显示地址,将在第行第7列开始显示
  200. WriteData('0'+s%10);    //将百位数字的字符常量写入LCD
  201. WriteAddress(0x80+6);//在第2行第4列位置写入新数据
  202. WriteData(TAB[d]);
  203. WriteAddress(0x82);//在第2行第1列位置写入新数据
  204. WriteData(TAB[a]);
  205. WriteAddress(0x80+3);//在第2行第2列位置写入新数据
  206. WriteData(TAB[b]);
  207. WriteAddress(0x80+4);//在第2行第3列位置写入新数据
  208. WriteData(TAB[c]);
  209. }
  210. /*****************************************************
  211. 函数功能：显示电压的小数数部分
  212. 入口参数：x
  213. ***************************************************/
  214. // void display2(unsigned char x)
  215. //{
  216. //  unsigned char i,j;
  217. //
  218. // i=x/10;            //取十位（小数点后第一位）
  219. // j=x%10;            //取个位（小数点后第二位）
  220. //   WriteAddress(0x04);      //写显示地址,将在第1行第11列开始显示
  221. // WriteData(digit[i]);     //将小数部分的第一位数字字符常量写入LCD
  222. // WriteData(digit[j]);     //将小数部分的第一位数字字符常量写入LCD
  223. //}
  224. /*****************************************************
  225. 函数功能：将模拟信号转换成数字信号
  226. ***************************************************/
  227. unsigned char  A_D1()
  228. {
  229.   unsigned char i,dat;
  230.    CS1=1;   //一个转换周期开始
  231.    CLK1=0;  //为第一个脉冲作准备
  232.    CS1=0;  //CS置0，片选有效
  233.    DIO1=1;    //DIO置1，规定的起始信号  
  234.    CLK1=1;   //第一个脉冲
  235.    CLK1=0;   //第一个脉冲的下降沿，此前DIO必须是高电平
  236.    DIO1=1;   //DIO置1， 通道选择信号  
  237.    CLK1=1;   //第二个脉冲，第2、3个脉冲下沉之前，DI必须跟别输入两位数据用于选择通道，这里选通道CH0
  238.    CLK1=0;   //第二个脉冲下降沿
  239.    
  240.    DIO1=0;   //DI置0，选择通道0
  241.    CLK1=1;    //第三个脉冲
  242.    CLK1=0;    //第三个脉冲下降沿
  243.    DIO1=1;    //第三个脉冲下沉之后，输入端DIO失去作用，应置1
  244.    CLK1=1;    //第四个脉冲
  245.    for(i=0;i<8;i++)  //高位在前
  246.     {
  247.       CLK1=1;         //第四个脉冲
  248.       CLK1=0;
  249.       dat<<=1;       //将下面储存的低位数据向右移
  250.    dat|=(unsigned char)DIO1;   //将输出数据DIO通过或运算储存在dat最低位
  251.     }            
  252.     CS1=1;          //片选无效
  253.   return dat;  //将读书的数据返回     
  254.   }
  255. unsigned char  A_D2()
  256. {
  257.   unsigned char i,dat;
  258.    CS1=1;   //一个转换周期开始
  259.    CLK1=0;  //为第一个脉冲作准备
  260.    CS1=0;  //CS置0，片选有效
  261.    DIO1=1;    //DIO置1，规定的起始信号  
  262.    CLK1=1;   //第一个脉冲
  263.    CLK1=0;   //第一个脉冲的下降沿，此前DIO必须是高电平
  264.    DIO1=1;   //DIO置1， 通道选择信号  
  265.    CLK1=1;   //第二个脉冲，第2、3个脉冲下沉之前，DI必须跟别输入两位数据用于选择通道，这里选通道CH0
  266.    CLK1=0;   //第二个脉冲下降沿
  267.    
  268.    DIO1=1;   //DI置0，选择通道0
  269.    CLK1=1;    //第三个脉冲
  270.    CLK1=0;    //第三个脉冲下降沿
  271.    DIO1=1;    //第三个脉冲下沉之后，输入端DIO失去作用，应置1
  272.    CLK1=1;    //第四个脉冲
  273.    for(i=0;i<8;i++)  //高位在前
  274.     {
  275.       CLK1=1;         //第四个脉冲
  276.       CLK1=0;
  277.       dat<<=1;       //将下面储存的低位数据向右移
  278.    dat|=(unsigned char)DIO1;   //将输出数据DIO通过或运算储存在dat最低位
  279.     }            
  280.     CS1=1;          //片选无效
  281.   return dat;  //将读书的数据返回     
  282.   }
  283. unsigned char  A_D3()
  284. {
  285.   unsigned char i,dat;
  286.    CS2=1;   //一个转换周期开始
  287.    CLK2=0;  //为第一个脉冲作准备
  288.    CS2=0;  //CS置0，片选有效
  289.    DIO2=1;    //DIO置1，规定的起始信号  
  290.    CLK2=1;   //第一个脉冲
  291.    CLK2=0;   //第一个脉冲的下降沿，此前DIO必须是高电平
  292.    DIO2=1;   //DIO置1， 通道选择信号  
  293.    CLK2=1;   //第二个脉冲，第2、3个脉冲下沉之前，DI必须跟别输入两位数据用于选择通道，这里选通道CH0
  294.    CLK2=0;   //第二个脉冲下降沿
  295.    
  296.    DIO2=0;   //DI置0，选择通道0
  297.    CLK2=1;    //第三个脉冲
  298.    CLK2=0;    //第三个脉冲下降沿
  299.    DIO2=1;    //第三个脉冲下沉之后，输入端DIO失去作用，应置1
  300.    CLK2=1;    //第四个脉冲
  301.    for(i=0;i<8;i++)  //高位在前
  302.     {
  303.       CLK2=1;         //第四个脉冲
  304.       CLK2=0;
  305.       dat<<=1;       //将下面储存的低位数据向右移
  306.    dat|=(unsigned char)DIO2;   //将输出数据DIO通过或运算储存在dat最低位
  307.     }            
  308.     CS2=1;          //片选无效
  309.   return dat;  //将读书的数据返回     
  310.   }
  311. unsigned char  A_D4()
  312. {
  313.   unsigned char i,dat;
  314.    CS2=1;   //一个转换周期开始
  315.    CLK2=0;  //为第一个脉冲作准备
  316.    CS2=0;  //CS置0，片选有效
  317.    DIO2=1;    //DIO置1，规定的起始信号  
  318.    CLK2=1;   //第一个脉冲
  319.    CLK2=0;   //第一个脉冲的下降沿，此前DIO必须是高电平
  320.    DIO2=1;   //DIO置1， 通道选择信号  
  321.    CLK2=1;   //第二个脉冲，第2、3个脉冲下沉之前，DI必须跟别输入两位数据用于选择通道，这里选通道CH0
  322.    CLK2=0;   //第二个脉冲下降沿
  323.    
  324.    DIO2=1;   //DI置0，选择通道0
  325.    CLK2=1;    //第三个脉冲
  326.    CLK2=0;    //第三个脉冲下降沿
  327.    DIO2=1;    //第三个脉冲下沉之后，输入端DIO失去作用，应置1
  328.    CLK2=1;    //第四个脉冲
  329.    for(i=0;i<8;i++)  //高位在前
  330.     {
  331.       CLK2=1;         //第四个脉冲
  332.       CLK2=0;
  333.       dat<<=1;       //将下面储存的低位数据向右移
  334.    dat|=(unsigned char)DIO2;   //将输出数据DIO通过或运算储存在dat最低位
  335.     }            
  336.     CS2=1;          //片选无效
  337.   return dat;  //将读书的数据返回     
  338. }

  340. void dischg()
  341. {
  342.         digit_time[3]=sec%10+0x30;
  343.         digit_time[2]=sec%100/10+0x30;
  344.         digit_time[1]=sec%1000/100+0x30;
  345.         digit_time[0]=sec/1000+0x30;        

  347. }

  349. void keyinput_data()
  350. {
  351. //unsigned char a=0;
  352. //unsigned char k=0;//光标
  353. //   LcdInitiate();
  354. //        SW0=SW1=SW2=1;
  355.         //LCD1602_Write_CMD(0x80); //第1行1列
  356.         //for(n=0;n<<16;n++)
  357.         //LCD1602_Write_DAT(TAB1[n]);
  358. //        WriteAddress(0x82);//第1行第3列
  359. //        WriteData(TAB[a]);
  360.         while(1)
  361.         {        
  362.                 if(SW0==0)
  363.                 {
  364.                         delaynms(5);
  365.                         if(SW0==0)
  366.                         {
  367.                                 p++;
  368.                                 TR0=0;
  369.                                 sec=0;
  370.                                 dischg();
  371.                                 while(!SW0);
  372.                                 if(p>4)p=1;
  373.                         }
  374.                 }
  375.                 if(p==1)
  376.                 {
  377.                         AD_val1= A_D1();    //进行A/D1转换
  378.                         AD_val2= A_D2();    //进行A/D2转换
  379.                         WriteAddress(0xcf);//在第2行第3列位置写入新数据
  380.                         WriteData('1');
  381.                 }
  382.                 if(p==2)
  383.                 {
  384.                         AD_val1= A_D3();    //进行A/D1转换
  385.                         AD_val2= A_D4();    //进行A/D2转换
  386.                         WriteAddress(0xcf);//在第2行第3列位置写入新数据
  387.                         WriteData('2');
  388.                 }
  389.                 if(p==3)
  390.                 {
  391.                         AD_val1= A_D5();    //进行A/D1转换
  392.                         AD_val2= A_D6();    //进行A/D2转换
  393.                         WriteAddress(0xcf);//在第2行第3列位置写入新数据
  394.                         WriteData('3');
  395.                 }
  396.                 if(p==4)
  397.                 {
  398.                         AD_val1= A_D7();    //进行A/D1转换
  399.                         AD_val2= A_D8();    //进行A/D2转换
  400.                         WriteAddress(0xcf);//在第2行第3列位置写入新数据
  401.                         WriteData('4');
  402.                 }
  403.                 if(SW1==0)
  404.                 {
  405.                         delaynms(5);
  406.                         if(SW1==0)
  407.                         {
  408.                                 k++;
  409.                         }
  410.                 }
  411.                 if(k==1)
  412.                 {
  413.                         while(!SW1);
  414.                         WriteAddress(0x82);//第2行第1列
  415.                         WriteAddress(0x0f);//光标闪烁
  416.                 }        
  417.                 if(k==2)
  418.                 {
  419.                         while(!SW1);
  420.                         WriteAddress(0x80+3);//第2行第2列
  421.                         WriteAddress(0x0f);
  422.                 }
  423.                 if(k==3)
  424.                 {
  425.                         while(!SW1);
  426.                         WriteAddress(0x80+4);//第2行第3列
  427.                         WriteAddress(0x0f);
  428.                 }
  429.                 if(k==4)
  430.                 {
  431.                         while(!SW1);
  432.                         WriteAddress(0x80+5);//第2行第4列
  433.                         WriteAddress(0x0f);
  434.                 }
  435.                 if(k==5)
  436.                 {
  437.                         while(!SW1);
  438.                         k=1;//光标标志清零
  439.                         WriteAddress(0x0c);//光标关闭
  440.                 }
  441.                 if(k==1)
  442.                 {
  443.                         if(SW2==0)
  444.                         {
  445.                                 delaynms(5);
  446.                                 if(SW2==0)
  447.                                 {
  448.                                         while(!SW2);
  449.                                         a=(a<9)?a+1:0;//若i小于9则a=a++，若a》=9则清除为0
  450.                                 }
  451.                         }
  452.                 }
  453.                 if(k==2)
  454.                 {
  455.                         if(SW2==0)
  456.                         {
  457.                                 delaynms(5);
  458.                                 if(SW2==0)
  459.                                 {
  460.                                         while(!SW2);
  461.                                         b=(b<9)?b+1:0;//若i小于9则a=a++，若a》=9则清除为0
  462.                                 
  463.                                 }
  464.                         }
  465.                 }
  466.                 if(k==3)
  467.                 {
  468.                         if(SW2==0)
  469.                         {
  470.                                 delaynms(5);
  471.                                 if(SW2==0)
  472.                                 {
  473.                                         while(!SW2);
  474.                                         c=(c<9)? c+1:0;//若i小于9则a=a++，若a》=9则清除为0
  475.                         
  476.                                 }
  477.                         }
  478.                 }
  479.                 if(k==4)
  480.                 {
  481.                         if(SW2==0)
  482.                         {
  483.                                 delaynms(5);
  484.                                 if(SW2==0)
  485.                                 {
  486.                                         while(!SW2);
  487.                                         d=(d<9)? d+1:0;//若i小于9则a=a++，若a》=9则清除为0

  489.                                 }
  490.                         }
  491.                 }
  492.         break;
  493.         }        
  494. }
  495. //void ext0() interrupt 0
  496. //{
  497. //        key++;
  498. //        key%=3;
  499. //}
  500. void t0isr() interrupt 1        //秒计时
  501. {
  502.         static unsigned int Time;
  503.         TH0=(65536-1000)/256;
  504.         TL0=(65536-1000)%256;
  505.         Time++;
  506.         if(Time==78)                                 
  507.         {
  508.                 Time=0;
  509. //                dat1++;
  510. //                if(dat1>=10)
  511. //                {
  512. //                dat1=0;
  513.                 sec++;
  514.                 s=(int)(((float)sum/60*sec));
  515.                 if(sec>10000)sec=0;
  516. //                }
  517.         dischg();
  518.         }
  519. }  
  520.   

  522. /*****************************************************
  523. 函数功能：主函数
  524. ***************************************************/
  525. main(void)
  526. {
  527. //  unsigned int AD_val;    //储存A/D转换后的值
  528. //  unsigned char Int,Dec;   //分别储存转换后的整数部分与小数部分
  529.    LcdInitiate();         //将液晶初始化
  530. //   delaynms(5);           //延时5ms给硬件一点反应时间
  531. display_volt();        //显示温度说明
  532.    display_dot();         //显示温度的小数点
  533.    display_V();           //显示温度的单位
  534.         TMOD=0x01;
  535.         TH0=(65536-1000)/256;
  536.         TL0=(65536-1000)%256;
  537.         TR0=0;
  538.         ET0=1;
  539.         EA=1;
  540.         dischg();
  541. //        lcd1602_Display(digit_time,1);
  542.    while(1)
  543.       {
  544. //    AD_val1= A_D1();    //进行A/D1转换
  545. //        AD_val2= A_D2();    //进行A/D2转换         
  546. //    Int=(AD_val)/51;  //计算整数部分
  547. //    Dec=(AD_val%51)*100/51;    //计算小数部分
  548.         keyinput_data();
  549. //    display(Dec);     //显示小数部分
  550.     display1();
  551.         sum=a*1000+b*100+c*100+d;
  552.         if(AD_val1>1)
  553.         {
  554.                 TR0=1;
  555.         }
  556.         if(AD_val2>1)
  557.         {                                                            
  558.                 TR0=0;
  559.         }



  563. /*****************************************************
  564. 函数功能：按键启动计时
  565. ***************************************************/                 
  566. //        switch(key)
  567. //                {
  568. //                case 0:TR0=0;break;
  569. //                case 1:TR0=1;break;
  570. //                case 2:sec=0;dischg();break;
  571. //                }
  572.   }
  573.       
  574. }
复制代码


评分

参与人数 1黑币 +50 收起 理由
admin + 50

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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