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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机测漏仪程序+PCB原理图 利用气泵测试漏气的仪器（ ...
返回列表 发新帖
查看: 3380|回复: 2
打印 上一主题 下一主题
收起左侧

单片机测漏仪程序+PCB原理图 利用气泵测试漏气的仪器（显示实时气压版）

[复制链接]
跳转到指定楼层
楼主
ID:268407 发表于 2019-5-20 11:35 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
元件配置及传感器在原理图中
Altium Designer画的原理图和PCB图如下：(51hei附件中可下载工程文件)


单片机源程序如下:
  1. #include <reg52.h>                  
  2. #include <intrins.H>            
  3. #include "i2c.h"

  5. #define DataPort2_DuanMa P2  //数码管段码数据口
  6. #define DataPort1_WeiMa P1          //数码管位码数据口
  7. #define uchar unsigned char   
  8. #define uint unsigned int

  10. #define AddWr 0x90   //写数据地址
  11. #define AddRd 0x91   //读数据地址
  12. #define Pre_Max 45  //设定气压最大值
  13. #define Pre_Min 10  //设定气压最小值
  14. extern bit ack;
  15. unsigned char ReadADC(unsigned char Chl);
  16. bit WriteDAC(unsigned char dat);

  18. sbit Key_Set=P3^0;                                 //设置
  19. sbit Key_Add=P3^1;                                  //        加
  20. sbit Key_Dec=P3^2;                                  //减
  21. sbit Key_Str=P3^3;                                //启动
  22. sbit Realy_1=P3^6;                                  //继电器1
  23. sbit Realy_2=P3^7;                                          //继电器2
  24. sbit Led=P0^6;                 //系统指示灯
  25. sbit Bee=P0^7;                                                                 //蜂鸣器
  26. sbit Led_Red=P0^4;
  27. sbit Led_Green=P0^5;
  28. /*******************************************新加***********************************************************************/
  29.   
  30. sfr ISP_DATA = 0xe2;     
  31. sfr ISP_ADDRH = 0xe3;      
  32. sfr ISP_ADDRL = 0xe4;     
  33. sfr ISP_CMD = 0xe5;     
  34. sfr ISP_TRIG = 0xe6;        
  35. sfr ISP_CONTR = 0xe7;  

  37. void  cc(uint addr);//擦除
  38. void  xcx(uint addr,uchar dat);//写字节
  39. uchar dcx(uint addr);//读字节
  40. void  Q0();//关闭ISP
  41.                                        

  43. /*擦除一个扇区*/
  44. void cc(uint addr)
  45. {       
  46.                                                   // 0x83(??<5M)   0x82(??<10M)   0x81(??<20M)   0x80(??<40M)
  47.     ISP_CONTR = 0x83;              // ?? IAP ??(ISPEN(ISP_CONTR.7)=1:??????Flash, ?? Flash ???????
  48.     ISP_CMD   = 0x03;                  // ?????"Data Flash/EEPROM?"??????
  49.     ISP_ADDRL = addr;         // ISP/IAP????????????,
  50.     ISP_ADDRH = addr>>8;      // ISP/IAP?????????????
  51.                 EA =0;   
  52.     ISP_TRIG = 0x46;          // ?ISPEN(ISP_CONTR.7)=1?,?ISP_TRIG???46h,
  53.     ISP_TRIG = 0xB9;          // ???B9h,ISP/IAP???????
  54.     _nop_();
  55.     Q0();                                          // ??ISP/IAP
  56. }
  57. /*写一个字节*/
  58. void xcx(uint addr,uchar dat)
  59. {
  60.     ISP_CONTR = 0x83;                  
  61.     ISP_CMD   = 0x02;              // ?????"Data Flash/EEPROM?"??????
  62.     ISP_ADDRL = addr;        
  63.     ISP_ADDRH = addr>>8;      
  64.     ISP_DATA  = dat;          // ???ISP_DATA
  65.     EA = 0;
  66.     ISP_TRIG = 0x46;         
  67.     ISP_TRIG = 0xB9;         
  68.     _nop_();
  69.     Q0();                                          // ??ISP/IAP
  70. }
  71. /*读一个字节*/
  72. uchar dcx(uint addr)
  73. {   
  74.     uchar dat;
  75.        
  76.         ISP_CONTR = 0x83;                  
  77.     ISP_CMD   = 0x01;         // ?????"Data Flash/EEPROM?"?????
  78.     ISP_ADDRL = addr;         
  79.     ISP_ADDRH = addr>>8;      
  80.     EA = 0;
  81.     ISP_TRIG = 0x46;         
  82.     ISP_TRIG = 0xB9;         
  83.     _nop_();
  84.     dat = ISP_DATA;                          // ????
  85.         Q0();                                          // ??ISP/IAP                   
  86.         return dat;
  87. }
  88. /*关闭ISP操作*/
  89. void Q0()
  90. {
  91.     ISP_CONTR = 0;            // ??IAP??
  92.     ISP_CMD   = 0;            // ????,?ISP??
  93.     ISP_TRIG  = 0;            // ??IAP??, ??ISP??????????
  94. }


  97. /***************************************************************************************************************/





  103. unsigned char code DuanMa[10]={0x03,0x9f,0x25,0x0d,0x99,0x49,0x41,0x1f,0x01,0x09};// 显示段码值0~9
  104. unsigned char code WeiMa[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//分别对应相应的数码管点亮,即位码
  105. unsigned char TempData[6]; //存储显示值的全局变量

  107. uchar Pressure_Flag;
  108. uchar Time_Flag;
  109. uchar Flash_Pressure_Flag;
  110. uchar Flash_Time_Flag;


  113. uchar Data_IIC,Pressure,Pressure2,Time,Time_Buffer,key_press_num,Key_Set_Num;
  114. uchar Flag_Str,Flag_Test,Flag_Bee,Flag_Count,Flag_Result,State_Red,State_Green,Flag_GetTime,Flag_Realy_1;

  116. int Time_500ms,Time_CountDown;
  117. void Display(unsigned char FirstBit,unsigned char Num);
  118. void Init_Timer0(void);
  119. void Init_Timer1(void);
  120. void DelayUs2x(unsigned char t);//微秒延时函数声明
  121. void DelayMs(unsigned char t);//毫秒延时函数声明
  122. // void ISR_INT0(void);

  124. /*------------------------------------------------
  125.                     定时器初始化子程序
  126. ------------------------------------------------*/
  127. void Init_Timer1(void)
  128. {
  129. TMOD |= 0x10;          //使用模式1，16位定时器，使用"|"符号可以在使用多个定时器时不受影响
  130. TH1=0x00;              //给定初值，这里使用定时器最大值从0开始计数一直到65535溢出
  131. TL1=0x00;
  132. EA=1;            //总中断打开
  133. ET1=1;           //定时器中断打开
  134. TR1=1;           //定时器开关打开
  135. }

  137. /*------------------------------------------------
  138.                 显示数据处理函数1
  139. ------------------------------------------------*/
  140. void Display_Data_Operation1(void)
  141. {
  142.         TempData[0]=DuanMa[(Pressure2)/100];
  143.         TempData[1]=DuanMa[((Pressure2)%100)/10];
  144.         TempData[2]=DuanMa[((Pressure2)%100)%10];
  145.         TempData[3]=DuanMa[Time/100];
  146.         TempData[4]=DuanMa[(Time%100)/10];
  147.         TempData[5]=DuanMa[(Time%100)%10];
  148. }


  151. /*------------------------------------------------
  152.                 显示数据处理函数2
  153. ------------------------------------------------*/
  154. void Display_Data_Operation2(void)
  155. {
  156.         TempData[0]=DuanMa[Pressure/100];
  157.         TempData[1]=DuanMa[(Pressure%100)/10];
  158.         TempData[2]=DuanMa[(Pressure%100)%10];
  159.         TempData[3]=0xff;
  160.         TempData[4]=0xff;
  161.         TempData[5]=0xff;
  162. }


  165. /*------------------------------------------------
  166.                 显示数据处理函数3
  167. ------------------------------------------------*/
  168. void Display_Data_Operation3(void)
  169. {
  170.         TempData[0]=0xff;
  171.         TempData[1]=0xff;
  172.         TempData[2]=0xff;
  173.         TempData[3]=DuanMa[Time/100];
  174.         TempData[4]=DuanMa[(Time%100)/10];
  175.         TempData[5]=DuanMa[(Time%100)%10];
  176. }

  178. /*------------------------------------------------
  179.                 显示数据处理函数4
  180. ------------------------------------------------*/
  181. void Display_Data_Operation4(void)
  182. {
  183.         TempData[0]=DuanMa[Pressure/100];
  184.         TempData[1]=DuanMa[(Pressure%100)/10];
  185.         TempData[2]=DuanMa[(Pressure%100)%10];
  186.         TempData[3]=DuanMa[Time/100];
  187.         TempData[4]=DuanMa[(Time%100)/10];
  188.         TempData[5]=DuanMa[(Time%100)%10];
  189. }

  191. /*------------------------------------------------
  192.                     主函数
  193. ------------------------------------------------*/
  194. void main (void)
  195. {
  196.         Flag_Str=0;
  197.         Flag_Test=0;
  198.         Pressure = dcx(0x2000);       
  199.         Time= dcx(0x2004);       
  200.         EA=1;          //全局中断开
  201. //   EX0=1;         //外部中断0开
  202. //   IT0=1;         //0电平触发  1边沿触发
  203.         Realy_1=1;
  204.         Realy_2=1;
  205.         Init_Timer0();
  206.   Init_Timer1();

  208.         while (1)                       
  209.   {   
  210.                 Data_IIC=ReadADC(0);
  211.                 Pressure2=(Data_IIC-11)*113/255;
  212.                
  213.                 if(!Key_Add && Pressure_Flag==1)  //如果检测到低电平，说明按键按下
  214.                 {
  215.                         DelayMs(10); //延时去抖，一般10-20ms
  216.                         if(!Key_Add&& Pressure_Flag==1)     //再次确认按键是否按下，没有按下则退出
  217.                         {
  218.                                 while(!Key_Add&& Pressure_Flag==1)
  219.                                 {
  220.                                         key_press_num++;
  221.                                         DelayMs(10);           //10x100=1000ms=1s
  222.                                         if(key_press_num==90) //大约1s
  223.                                         {
  224.                                                 key_press_num=0;    //如果达到长按键标准
  225.                                                                  //则进入长按键动作
  226.                                                 while(!Key_Add && Pressure_Flag==1)     //这里用于识别是否按
  227.                                                 //键还在按下，如果按
  228.                                                 //下执行相关动作，否则退出
  229.                                                 {
  230. //                                                         if(Vol<99)    //加操作
  231.                                                         Pressure++;
  232.                                                         if(Pressure>Pre_Max)
  233.                                                                                 {
  234.                                                                                                 Pressure=Pre_Min;
  235.                                                                                 }
  236.                                                         DelayMs(80);//用于调节长按循环操作
  237.                                                         //的速度，可以自行调整此值以便达到最佳效果
  238.                                                 }
  239.                                         }
  240.                                 }
  241.                                 key_press_num=0;//防止累加造成错误识别

  243.                                 Pressure++;
  244.                                 if(Pressure>Pre_Max)
  245.                                                         {
  246.                                                                         Pressure=Pre_Min;
  247.                                                         }
  248.                         }
  249.                 }

  251.                 if(!Key_Dec && Pressure_Flag==1)  //如果检测到低电平，说明按键按下
  252.                 {
  253.                         DelayMs(10); //延时去抖，一般10-20ms
  254.                         if(!Key_Dec && Pressure_Flag==1) //再次确认按键是否按下，没有
  255.                         //按下则退出
  256.                         {
  257.                                 while(!Key_Dec && Pressure_Flag==1)
  258.                                 {
  259.                                         key_press_num++;
  260.                                         DelayMs(10);
  261.                                         if(key_press_num==100) //大约1s
  262.                                         {
  263.                                                 key_press_num=0;
  264.                                                 while(!Key_Dec && Pressure_Flag==1)
  265.                                                 {
  266.                                                         if(Pressure>Pre_Min)  //减操作
  267.                                                         Pressure--;

  269.                                                         DelayMs(80);
  270.                                                         //用于调节长按循环操作的速度
  271.                                                 }
  272.                                         }
  273.                                 }
  274.                                 key_press_num=0;//防止累加造成错误识别
  275.                                 if(Pressure>Pre_Min)  //减操作
  276.                                 Pressure--;

  278.                         }
  279.                 }

  281.         if(!Key_Add && Time_Flag==1)  //如果检测到低电平，说明按键按下
  282.                 {
  283.                         DelayMs(10); //延时去抖，一般10-20ms
  284.                         if(!Key_Add && Time_Flag==1)     //再次确认按键是否按下，没有按下则退出
  285.                         {
  286.                                 while(!Key_Add && Time_Flag==1)
  287.                                 {
  288.                                         key_press_num++;
  289.                                         DelayMs(10);           //10x100=1
  290.                                         if(key_press_num==100) //大约1s
  291.                                         {
  292.                                                 key_press_num=0;    //如果达到长按键标准
  293.                                                                  //则进入长按键动作
  294.                                                 while(!Key_Add && Time_Flag==1)     //这里用于识别是否按
  295.                                                 //键还在按下，如果按
  296.                                                 //下执行相关动作，否则退出
  297.                                                 {

  299.                                                         Time++;
  300.                                                         if(Time>600)
  301.                                                         {
  302.                                                                         Time=0;
  303.                                                         }
  304.                                                         DelayMs(50);//用于调节长按循环操作
  305.                                                         //的速度，可以自行调整此值以便达到最佳效果
  306.                                                 }
  307.                                         }
  308.                                 }
  309.                                 key_press_num=0;//防止累加造成错误识别

  311.                                 Time++;
  312.                                 if(Time>600)
  313.                                                         {
  314.                                                                         Time=0;
  315.                                                         }
  316.                         }
  317.                 }

  319.                 if(!Key_Dec && Time_Flag==1)  //如果检测到低电平，说明按键按下
  320.                 {
  321.                         DelayMs(10); //延时去抖，一般10-20ms
  322.                         if(!Key_Dec && Time_Flag==1) //再次确认按键是否按下，没有
  323.                         //按下则退出
  324.                         {
  325.                                 while(!Key_Dec && Time_Flag==1)
  326.                                 {
  327.                                         key_press_num++;
  328.                                         DelayMs(10);
  329.                                         if(key_press_num==100) //大约1s
  330.                                         {
  331.                                                 key_press_num=0;
  332.                                                 while(!Key_Dec && Time_Flag==1)
  333.                                                 {
  334.                                                         if(Time>0)  //减操作
  335.                                                         Time--;
  336.                                                         DelayMs(50);
  337.                                                         //用于调节长按循环操作的速度
  338.                                                 }
  339.                                         }
  340.                                 }
  341.                                 key_press_num=0;//防止累加造成错误识别
  342.                                 if(Time>0)  //减操作
  343.                                 Time--;
  344.                         }
  345.                 }
  346. /*------------------------------------------------
  347. 按设置键，保存数据，循环设置参数
  348.         ------------------------------------------------*/

  350.                
  351.                 if((!Key_Set) &&(Flag_Count==0) && (Flag_Str==0)&&(Flag_Bee==0)&& (State_Red==0) && (State_Green==0) ) //如果检测到低电平，说明按键按下，并且启动标志为零
  352.     {
  353.                         DelayMs(10); //延时去抖，一般10-20ms
  354.                         if((!Key_Set) &&(Flag_Count==0)&& (Flag_Str==0)&&(Flag_Bee==0)&& (State_Red==0)&& (State_Green==0))    //再次确认按键是否按下，并且启动标志为零，没有按下则退出
  355.                         {
  356.                                 while((!Key_Set)&&(Flag_Count==0)&& (Flag_Str==0)&&(Flag_Bee==0)&& (State_Red==0)&& (State_Green==0));//如果确认按下按键等待按键释放，没有释放则一直等待
  357.                                 {
  358.                                         Key_Set_Num++;                       
  359.                                         if(Key_Set_Num>2)
  360.                                         {
  361.                                                 Key_Set_Num=0;
  362.                                         }                                               
  363. //                         EX0=1;
  364. //                         IT0=1;
  365.                         cc(0x2000);
  366.                         xcx(0x2000,Pressure);          // ?EEPROM?2002h??2
  367.                         xcx(0x2004,Time);         
  368.                         EA = 1;               
  369.                                 }
  370.                         }
  371.                 }
  372. /*------------------------------------------------
  373.                 设置时的三种循环状态
  374.         ------------------------------------------------*/

  376.                 if(Key_Set_Num==0)
  377.                 {
  378.                         Pressure_Flag=0;
  379.                         Time_Flag=0;
  380.                         Flash_Pressure_Flag=0;
  381.                         Flash_Time_Flag=0;               
  382.                 }
  383.                
  384.                 if(Key_Set_Num==1)
  385.                 {
  386.                         Pressure_Flag=1;
  387.                         Time_Flag=0;
  388.                         Flash_Pressure_Flag=1;
  389.                         Flash_Time_Flag=0;
  390.                 }
  391.                                
  392.                 if(Key_Set_Num==2)
  393.                 {
  394.                         Pressure_Flag=0;
  395.                         Time_Flag=1;
  396.                         Flash_Pressure_Flag=0;
  397.                         Flash_Time_Flag=1;
  398.                 }
  399. /*------------------------------------------------
  400.                 按下启动且启动标志置0，不合格状态置0，则启动气泵，并把启动标志置1
  401.         ------------------------------------------------*/               
  402.                 if( (!Key_Str) && (Flag_Str==0) &&(State_Red==0) &&(Flag_Count==0)) //如果检测到低电平，说明按键按下，并且启动标志为零
  403.                 {
  404.                         DelayMs(10); //延时去抖，一般10-20ms
  405.                         if((!Key_Str) && (Flag_Str==0)  &&(State_Red==0) &&(Flag_Count==0) )  //再次确认按键是否按下，并且启动标志为零，没有按下则退出
  406.                         {
  407.                                 while((!Key_Str)&& (Flag_Str==0) &&(State_Red==0)&&(Flag_Count==0) )//如果确认按下按键等待按键释放，没有释放则一直等待
  408.                                 {
  409.                                         Flag_Realy_1=1;
  410.                                         Flag_Str=1;
  411.                                 }
  412.                         }
  413.                 }
  414.                 if((Pressure2<Pressure)&&(Flag_Realy_1==1))
  415.                 {
  416.                         Realy_1=0;
  417.                 }               
  418.        
  419.                
  420. /*------------------------------------------------
  421. 同时按下 加 减 ，清除报警状态
  422.         ------------------------------------------------*/                       
  423.                 if( (!Key_Add) &&(!Key_Dec) ) //如果检测到低电平，说明按键按下，并且启动标志为零
  424.                 {
  425.                         DelayMs(10); //延时去抖，一般10-20ms
  426.                         if( (!Key_Add) &&(!Key_Dec) )  //再次确认按键是否按下，并且启动标志为零，没有按下则退出
  427.                         {
  428.                                 while( (!Key_Add) &&(!Key_Dec) )//如果确认按下按键等待按键释放，没有释放则一直等待
  429.                                 {
  430.                                         Led_Red=1;
  431.                                         Bee=1;
  432.                                         State_Red=0;
  433.                                         Flag_Count=0;
  434.                                         Time=Time_Buffer;
  435.                                         Realy_1=1;
  436.                                 }
  437.                         }
  438.                 }               


  441.                
  442. /*------------------------------------------------
  443. 如果实时压力 > 设定压力 ，且启动标志置1，那么，关闭气泵，把时间放入缓存
  444.         ------------------------------------------------*/       
  445.                 if( (Pressure2>(Pressure))&&(Flag_Str==1)&&(Flag_Realy_1==1) )
  446.                 {
  447.                         Realy_1=1;
  448.                         Flag_Realy_1=0;                       
  449.                         Time_Buffer=Time;       
  450.                         Flag_Bee=1;//充气完成的声音提醒
  451.                         Flag_Test=1;//检测开始的标志
  452.                         Flag_Str=0;        //启动标志置0       
  453.                 }
  454.                
  455.                
  456.                 if(Flag_Bee==1)//声音提醒
  457.                 {
  458.                         Bee=0;        
  459.                         DelayMs(500);
  460.                         DelayMs(500);
  461.                         Bee=1;
  462.                         Flag_Bee=0;
  463.                 }
  464.                
  465.                 if(Flag_Test==1)//开始检测
  466.                 {
  467.                         Time=0;//初始化时间
  468.                         Time_CountDown=0;
  469.                         Flag_GetTime=1;
  470.                         Flag_Test=0;
  471.                         Flag_Count=1;
  472.                 }
  473.                 if(Flag_Count==1)//计数标志置1，时间开始从0计数到设定值
  474.                 {
  475.                         Time=Time_CountDown/2;
  476.                 }
  477.                 if((Time==Time_Buffer)&&(Flag_GetTime==1))//计时完成，结果标志置1
  478.                 {
  479.                         Flag_Count=0;
  480.                         Flag_Result=1;
  481.                         Flag_GetTime=0;
  482.                 }       

  484. /*------------------------------------------------
  485. 经过一段时间后，如果压力小了，说明不合格，亮红灯，蜂鸣器长响，不合格标志置1
  486.         ------------------------------------------------*/       
  487.                
  488.                 if((Flag_Count==1) &&(Pressure2*10 < Pressure*8) )
  489.                 {
  490.                         Flag_Result=0;
  491.                         Led_Red=0;
  492.                         Bee=0;
  493.                         State_Red=1;
  494.                 }       
  495.                
  496.                
  497.                
  498.                
  499.                
  500.                
  501. /*------------------------------------------------
  502. 经过一段时间后，如果压力没减小，说明合格，合格标志置1
  503.         ------------------------------------------------*/                       
  504.                 if((Flag_Result==1) &&(Pressure2*10 > Pressure*9) )
  505.                 {
  506.                         State_Green=1;
  507.                 }
  508. /*------------------------------------------------
  509. 合格标志置1后，且结果标志置1，则发出合格提示
  510.         ------------------------------------------------*/                               
  511.                 if((State_Green==1) && (Flag_Result==1))
  512.                 {
  513.                         Led_Green=0;
  514.                         Realy_2=0;
  515.                         Bee=0;
  516.                         DelayMs(500); //第一响
  517.                         Bee=1;
  518.                         DelayMs(300);
  519.                         Bee=0;        //第二响
  520.                         DelayMs(500); //第二响
  521.                         Bee=1;
  522.                         Led_Green=1;
  523.                         DelayMs(500);
  524.                         Realy_2=1;
  525.                         Flag_Result=0;
  526.                         State_Green=0;
  527.                         Time=Time_Buffer;
  528.                 }
  529.                                
  530.         }       
  531. }



  535. /*------------------------------------------------
  536.              读AD转值程序
  537. 输入参数 Chl 表示需要转换的通道，范围从0-3
  538. 返回值范围0-255
  539. ------------------------------------------------*/
  540. unsigned char ReadADC(unsigned char Chl)
  541. {
  542.    unsigned char Val;
  543.    Start_I2c();               //启动总线
  544.    SendByte(AddWr);             //发送器件地址
  545.      if(ack==0)return(0);
  546.    SendByte(0x40|Chl);            //发送器件子地址
  547.      if(ack==0)return(0);
  548.    Start_I2c();
  549.    SendByte(AddWr+1);
  550.      if(ack==0)return(0);
  551.    Val=RcvByte();
  552.    NoAck_I2c();                 //发送非应位
  553.    Stop_I2c();                  //结束总线
  554.   return(Val);
  555. }




  560. /*------------------------------------------------
  561. us延时函数


  564. 含有输入参数 unsigned char t，无返回值
  565. unsigned char 是定义无符号字符变量，其值的范围是
  566. 0~255 这里使用晶振12M，精确延时请使用汇编,大致延时
  567. 长度如下 T=tx2+5 uS
  568. ------------------------------------------------*/
  569. void DelayUs2x(unsigned char t)
  570. {   
  571. while(--t);
  572. }
  573. /*------------------------------------------------
  574. mS延时函数

  576. 含有输入参数 unsigned char t，无返回值
  577. unsigned char 是定义无符号字符变量，其值的范围是
  578. 0~255 这里使用晶振12M，精确延时请使用汇编
  579. ------------------------------------------------*/
  580. void DelayMs(unsigned char t)
  581. {
  582.      
  583. while(t--)
  584. {
  585.      //大致延时1mS
  586.    DelayUs2x(245);
  587.          DelayUs2x(245);
  588. }
  589. }




  594. /*数码管显示函数*/
  595. void Display(unsigned char FirstBit,unsigned char Lenth)
  596. {
  597.         static unsigned char i=0;
  598.         DataPort2_DuanMa=0;   //清空段码数据，防止重影
  599.         DataPort1_WeiMa=WeiMa[i+FirstBit]; //取位码
  600.         DataPort2_DuanMa=TempData[i]; //取显示数据，段码
  601.         i++;
  602.         if(i==Lenth)
  603.         i=0;
  604. ……………………

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

所有资料51hei提供下载:
测漏仪工程.rar (674.25 KB, 下载次数: 53)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:543424 发表于 2022-2-6 19:22 | 只看该作者
请问这个制作完气压需要校准吗？
回复

使用道具 举报

板凳
ID:1045538 发表于 2022-9-25 15:58 来自手机 | 只看该作者
有没有哪位大神知道原理图左上角的p1，p2是啥啊，仿真的话怎么办啊
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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