欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 基于51單片機四位一體數碼管顯示定時器控制短按加或減數值及長按連加或連減數值的... [打印本頁]
作者: 51黑電子會員    時間: 2020-5-20 14:55
標題: 基于51單片機四位一體數碼管顯示定時器控制短按加或減數值及長按連加或連減數值的...
本帖最后由 51黑電子會員 于 2020-5-26 22:08 編輯
  1. #include<reg51.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. sbit add=P3^0;
  5. sbit dec=P3^4;
  6. uchar lingweiflag;//顯示0標志位變量
  7. uchar code weima[]={0xfe,0xfd,0xfb,0xf7};//數碼管位碼表
  8. uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f} ; //共陰數碼管段碼數字0~9字碼表，高電平點亮數碼管段碼數字0~9。
  9. uint num;
  10. uint count;
  11. uint qian,bai,shi,ge;//定義拆字變量
  12. ///**ms級延時子程序**/
  13. //  void delay(uint x)
  14. //{
  15. //   uint i,j;                       
  16. //   for(i=0;i<x;i++)     
  17. //    for(j=0;j<110;j++);
  18. //  }
  19. ///**定時器ms級延時子程序**/
  20. //  void time0_delay(uchar time)//注意這里不是普通延時，而是定時器延時函數。
  21. //{
  22. //   TR0=1;
  23. //   count = 0;//需要定時器延時count，先清零，再循環檢測是否計到count，是則退出。
  24. //   while(1)
  25. // {
  26. //    if(count>=time)
  27. //  {     
  28. //     break;
  29. //   }
  30. //  }  
  31. // }
  32. //  void display()
  33. //{
  34. //   qian=num/1000;//取得千位
  35. //   bai=num%1000/100;//取得百位
  36. //   shi=num%100/10;//取得十位數字
  37. //   ge=num%10;//取得個位數字
  38. //
  39. //   P2=0xfe;//數碼管千位顯示位
  40. //   P1=table[qian];//數碼管千位數值顯示
  41. //   delay(2);//延時
  42. //
  43. //   P2=0xfd;//數碼管百位顯示位
  44. //   P1=table[bai];//數碼管百位數值顯示
  45. //   delay(2);//延時
  46. //
  47. //   P2=0xfb;//數碼管十位顯示位
  48. //   P1=table[shi];//數碼管十位數值顯示
  49. //   delay(2);//延時
  50. //
  51. //   P2=0xf7;//數碼管個位顯示位
  52. //   P1=table[ge];//數碼管個位數值顯示
  53. //   delay(2);//延時
  54. // }
  55.   void display()//顯示程序
  56. {
  57.    static uchar i;
  58.    P1=0x00;
  59.    P2=0xff;
  60.    switch(i)
  61. {
  62.     case 0:
  63.            P2=weima[i];
  64.            P1=table[num/1000];
  65.            i++;
  66.            break;
  67.     case 1:
  68.            P2=weima[i];
  69.            P1=table[num%1000/100];
  70.            i++;
  71.            break;
  72.     case 2:
  73.            P2=weima[i];
  74.            P1=table[num%100/10];
  75.            i++;
  76.            break;
  77.     case 3:
  78.            P2=weima[i];
  79.            P1=table[num%10];
  80.            i++;
  81.            break;
  82.     default : break;//自定義
  83.    }
  84.    if(i>3)
  85.    i=0;
  86. }
  87.   void keyscan()
  88. {         
  89.    while(!add)//增加鍵短按長按。為什么只用while(!add)？while(!add)它又表示什么？解釋：當你的按鍵一直沒有釋放，即add=0，那么while(!add)中的!add就為1，表示為真，可以執行while(!add)語句所在花括號內的程序。當你松開按鍵，即add=1,那么 while(!add)中的!add為0，表示為假，不可執行while(!add)語句所在花括號內的程序。
  90. {   
  91.     if(count>=100)
  92.   {
  93.      num++;
  94.      count=0;
  95.      lingweiflag=0;
  96.     }
  97.    }
  98.    while(!dec)//減少鍵短按長按。為什么只用while(!dec)？while(!dec)它又表示什么？解釋：當你的按鍵一直沒有釋放，即dec=0，那么while(!dec)中的!dec就為1，表示為真，可以執行while(!dec)語句所在花括號內的程序。當你松開按鍵，即dec=1,那么 while(!dec)中的!dec為0，表示為假，不可執行while(!dec)語句所在花括號內的程序。
  99. {   
  100.     if(lingweiflag==0)
  101.   {
  102.      if(count>=100)
  103.    {
  104.       num--;
  105.       count=0;
  106.       if(num==0)
  107.     {
  108.        num=0;
  109.        lingweiflag=1;
  110.       }
  111.      }
  112.     }
  113.    }
  114. //   if(add==0)//增加長按
  115. // {         
  116. //    TR0=1;
  117. //    if(count==100)
  118. //  {
  119. //     num++;
  120. //     count=0;
  121. //     lingweiflag=0;
  122. //    }
  123. //   }
  124. //   if(add==0)//增加短按
  125. // {         
  126. //    TR0=1;
  127. //      time0_delay(20);//注意這里不是普通延時，而是定時器延時。
  128. //    display();
  129. //    if(add==0)
  130. //  {
  131. //       time0_delay(20);//注意這里不是普通延時，而是定時器延時。
  132. //       while(!add)
  133. //       display();
  134. //     led=0;
  135. //       while(!add);
  136. //       led=1;
  137. //       num++;  
  138. //       count=0;
  139. //       lingweiflag=0;
  140. //    }
  141. //   }
  142. //   else if(dec==0&&lingweiflag==0)//減少長按
  143. // {
  144. //      TR0=1;
  145. //      if(count==100)
  146. //  {
  147. //       num--;
  148. //       count=0;
  149. //    }
  150. //   }
  151. //   if(dec==0&&lingweiflag==0)//減少短按
  152. // {         
  153. //    TR0=1;
  154. //      time0_delay(20);//注意這里不是普通延時，而是定時器延時。
  155. //    display();
  156. //    if(dec==0)
  157. //  {
  158. //       time0_delay(20);//注意這里不是普通延時，而是定時器延時。
  159. //       while(!dec)
  160. //       display();
  161. //       num--;
  162. //       count=0;
  163. //    }
  164. //   }
  165.    if(num>9999)
  166. {
  167.     num=0;
  168.    }
  169.    if(num==0)
  170. {
  171.     num=0;
  172.     lingweiflag=1;
  173.    }
  174. }
  175.   void Time0_init()
  176. {
  177.    TMOD=0x01;
  178.    TH0=(65536-2000)/256;
  179.    TL0=(65536-2000)%256;
  180.    EA=1;
  181.    ET0=1;
  182.    TR0=1;
  183.   }
  184.   void time0() interrupt 1
  185. {
  186.    TH0=(65536-2000)/256;
  187.    TL0=(65536-2000)%256;
  188.    count++;
  189.    display();
  190. }
  191.   void main()
  192. {
  193.    Time0_init();
  194.    while(1)
  195. {
  196.     keyscan();
  197.    }
  198.   }



  202. //按鍵短按加或減，長按連加或連減，四位一體數碼管顯示0~9999。
  203. //#include<reg52.h>
  204. //#define uchar unsigned char
  205. //#define uint unsigned int
  206. //#define key_short 10//宏定義短按20ms
  207. //#define key_long 50//宏定義長按100ms
  208. //#define key_middle 40//宏定義長按間隔80ms
  209. //sbit led=P1^4;//啟停指示燈
  210. //sbit addkey=P3^0;//位定義加鍵
  211. //sbit deckey=P3^2;//位定義減鍵
  212. //sbit qiting=P3^4;//位定義啟動按鍵端口
  213. //sbit tingzhi=P3^6;//位定義停止按鍵端口
  214. ////uchar i;//數碼管位數變量
  215. //uchar flag;//顯示函數標志位變量
  216. //uchar qitingnum;//聲明啟停次數變量
  217. //uint num;//數值變量
  218. //uint addcount,deccount;//計數變量
  219. //uint qian,bai,shi,ge;//定義拆字變量
  220. ////uchar code weima[]={0xfe,0xfd,0xfb,0xf7};//數碼管位碼表
  221. //uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f} ; //共陰數碼管段碼數字0~9字碼表，高電平點亮數碼管段碼數字0~9。
  222. ///**ms級延時子程序**/
  223. //  void delay(uint x)
  224. //{
  225. //   uint i,j;                       
  226. //   for(i=0;i<x;i++)     
  227. //    for(j=0;j<110;j++);
  228. //  }
  229. //  void display()
  230. //{
  231. //   qian=num/1000;//轉速/10000的余數/1000得到千位
  232. //   bai=num%1000/100;//取得百位
  233. //   shi=num%100/10;//取得十位數字
  234. //   ge=num%10;//取得個位數字
  235. //
  236. //   P2=0xfe;//數碼管千位顯示位
  237. //   P0=table[qian];//數碼管千位數值顯示
  238. //   delay(2);//延時
  239. //
  240. //   P2=0xfd;//數碼管百位顯示位
  241. //   P0=table[bai];//數碼管百位數值顯示
  242. //   delay(2);//延時
  243. //
  244. //   P2=0xfb;//數碼管十位顯示位
  245. //   P0=table[shi];//數碼管十位數值顯示
  246. //   delay(2);//延時
  247. //
  248. //   P2=0xf7;//數碼管個位顯示位
  249. //   P0=table[ge];//數碼管個位數值顯示
  250. //   delay(2);//延時
  251. //}
  252. //  void qidongkeyscan()//啟動函數
  253. //{
  254. //   if(qiting==0)
  255. // {
  256. //    delay(15);
  257. //    if(qiting==0)
  258. //  {
  259. //     qitingnum++;
  260. //     TR0=1;
  261. //     flag=0;
  262. //     while(qiting==1);
  263. //    }
  264. //   }
  265. // }
  266. //  void tingzhikeyscan()//關掉函數
  267. //{
  268. //   if(tingzhi==0)
  269. // {
  270. //    delay(15);
  271. //    if(tingzhi==0)
  272. //  {
  273. //     led=1;
  274. //     flag=1;
  275. //     TR0=0;
  276. //     P2=0xff;
  277. //     P0=0x00;
  278. //     qitingnum=0;
  279. //     while(tingzhi==1);
  280. //    }
  281. //   }
  282. // }
  283. //  void keyscan()//設置函數
  284. //{
  285. //   if(qitingnum==1)
  286. // {
  287. //    led=0;
  288. //    if(!addkey)
  289. //  {
  290. //     addcount++;
  291. ////   delay(10);
  292. //     if(addcount>=key_long)//增加長按
  293. //   {
  294. //      if(num<9999)
  295. //      num++;        
  296. //      addcount=key_middle;//為什么存在addcount=key_middle，由于一直按著按鍵，addcount計數會溢出，設定addcount=key_middle能讓addcount在這個addcount=key_middle基礎上反復累積計數，從而不會出現計數溢出的情況。
  297. //     }
  298. //    }
  299. //     else
  300. //   {
  301. //      if(key_short<addcount&&addcount<key_long)//增加短按，為什么不可以是key_short<addcount<key_long，假若是key_short<addcount<key_long，就相當于按鍵還沒按下，條件已經滿足，按鍵再按下去就沒意義啦。
  302. //    {
  303. //       if(num<9999)
  304. //       num++;        
  305. //      }
  306. //      addcount=0;
  307. //    }
  308. //    if(!deckey)
  309. //  {
  310. //     deccount++;
  311. ////   delay(10);
  312. //     if(deccount>=key_long)//減少長按
  313. //   {
  314. //      if(num>0)
  315. //      num--;        
  316. //      deccount=key_middle;//為什么存在deccount=key_middle，由于一直按著按鍵，deccount計數會溢出，設定deccount=key_middle能讓addcount在這個deccount=key_middle基礎上反復累積計數，從而不會出現計數溢出的情況。
  317. //     }
  318. //    }
  319. //     else
  320. //   {
  321. //      if(key_short<deccount&&deccount<key_long)//減少短按，為什么if條件不可以是key_short<deccount<key_long，假若是key_short<deccount<key_long，就相當于按鍵還沒按下，條件已經滿足，按鍵再按下去就沒意義啦。
  322. //    {
  323. //       if(num>0)
  324. //       num--;        
  325. //      }
  326. //      deccount=0;
  327. //    }
  328. //   }
  329. //  }
  330. ////  void display()//顯示程序
  331. ////{
  332. ////// static uchar i;
  333. ////   P0=0x00;
  334. ////   P2=weima[i];
  335. ////   switch(i)
  336. //// {
  337. ////    case 0:
  338. ////           P0=table[num/1000];
  339. ////           break;
  340. ////    case 1:
  341. ////           P0=table[num%1000/100];
  342. ////           break;
  343. ////    case 2:
  344. ////           P0=table[num%100/10];
  345. ////           break;
  346. ////    case 3:
  347. ////           P0=table[num%10];
  348. ////           break;
  349. ////  }
  350. ////   i++;
  351. ////   i%=4;
  352. //// }
  353. //  /**定時器0初始化子程序**/
  354. //  void Time0_init()
  355. //{
  356. //   TMOD=0X01;//模式選定時器0、計數器1，工作方式選定時器0定時模式1、計數器1計數模式1。
  357. //   TH0=(65536-5000)/256;//定時器0高8位定時50毫秒
  358. //   TL0=(65536-5000)%256;//定時器0低8位定時50毫秒
  359. //   EA=1;//打開總中斷
  360. //   ET0=1;//打開定時器0的中斷
  361. //   TR0=0;//打開定時器0
  362. //  }
  363. //  void Timer0() interrupt 1//定時器0中斷子程序
  364. //{
  365. //   TH0=(65536-5000)/256;//重裝定時器0高8位定時50毫秒
  366. //   TL0=(65536-5000)%256;//重裝定時器0低8位定時50毫秒
  367. //   keyscan();//設置函數
  368. //   if(flag==0)
  369. //   display();//顯示函數
  370. //   tingzhikeyscan();//關掉函數
  371. //  }
  372. //  void main()//主函數
  373. //{
  374. //   Time0_init();//定時器0初始化子程序
  375. //   while(1)
  376. // {
  377. //    qidongkeyscan();//啟動函數
  378. //  }
  379. // }
復制代碼


作者: 守候楓林紅葉時    時間: 2020-5-23 08:10
好好學習，感謝分享！
作者: 51黑電子會員    時間: 2020-5-23 12:22
本帖最后由 51黑電子會員 于 2020-5-26 22:10 編輯
守候楓林紅葉時 發表于 2020-5-23 08:10
好好學習，感謝分享！

謝謝 小伙伴



歡迎光臨 (http://m.raoushi.com/bbs/) Powered by Discuz! X3.1