51单片机之大杂烩-九游会j9

单片机 > 单片机程序设计 > 详情

51单片机之大杂烩

发布时间：2024-11-04 发布时间：
|

  1. /************************************************************ 

  2.     程序实现的功能： 

  3.         用矩阵按键控制 8*8 led 点阵和数码管， 

  4.     实现按下1到9的数字键数码管从100或200。。。或900的 

  5.     倒计时，一秒钟减1，直到减到0为止。 

  6.     同时led点阵以呼吸灯的方式渐明渐暗，显示“王”字， 

  7.     当按下数字键0时，led点阵关闭，同时数码管停止计数 

  8.     并显示结果。 

  9.  

  10.     作者：宁静致远 

  11. ************************************************************/  

  12. #include   

  13.   

  14. typedef unsigned char uchar;  

  15. typedef unsigned int uint;  

  16. typedef unsigned long ulong;  

  17.   

  18. sbit addr0 = p1^0;  

  19. sbit addr1 = p1^1;  

  20. sbit addr2 = p1^2;  

  21. sbit addr3 = p1^3;  

  22. sbit enled = p1^4;  

  23.   

  24. sbit key_out_3 = p2^0;  

  25. sbit key_out_2 = p2^1;  

  26. sbit key_out_1 = p2^2;  

  27. sbit key_out_0 = p2^3;  

  28. sbit key_in_0 = p2^4;  

  29. sbit key_in_1 = p2^5;  

  30. sbit key_in_2 = p2^6;  

  31. sbit key_in_3 = p2^7;  

  32.   

  33. ulong periodcnt = 0;  //pwm周期计数值  

  34. uchar highrh = 0;  //高电平重载值的高字节  

  35. uchar highrl = 0;  //高电平重载值的低字节  

  36. uchar lowrh  = 0;  //低电平重载值的高字节  

  37. uchar lowrl  = 0;  //低电平重载值的低字节  

  38. uchar sumrh = 0;  

  39. uchar sumrl = 0;  

  40. uchar t1rh = 0;    //t1重载值的高字节  

  41. uchar t1rl = 0;    //t1重载值的低字节  

  42. bit enchange = 1;  

  43. bit enled1 = 1;  

  44. uint rate, rate2cnt;  

  45. uint numbershow = 100;  

  46.   

  47. uchar code dutycycle[13] = {  //占空比调整表  

  48.     5, 18, 30, 41, 51, 60, 68, 75, 81, 86, 90, 93, 95  

  49. };  

  50. uchar pdata hrhi[13], pdata hrli[13], pdata lrhi[13], pdata lrli[13];  

  51. uchar code image[8] = {  

  52.     0x81,0x81,0xe7,0xc3,0xc3,0xe7,0x81,0x81  

  53. };  

  54. uchar code ledchar[] = {  //数码管显示字符转换表  

  55.     0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8,  

  56.     0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e  

  57. };  

  58. uchar ledbuff[6] = {  //数码管显示缓冲区  

  59.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff  

  60. };  

  61. uchar code keycodemap[4][4] = { //矩阵按键编号到标准键盘键码的映射表  

  62.     {0x31, 0x32, 0x33, 0x26}, //数字键1、数字键2、数字键3、向上键  

  63.     {0x34, 0x35, 0x36, 0x25}, //数字键4、数字键5、数字键6、向左键  

  64.     {0x37, 0x38, 0x39, 0x28}, //数字键7、数字键8、数字键9、向下键  

  65.     {0x30, 0x1b, 0x0d, 0x27}  //数字键0、esc键、  回车键、 向右键  

  66. };  

  67. uchar keystate[4][4] = {  //全部矩阵按键的当前状态  

  68.     {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}  

  69. };  

  70.   

  71. void configtmr0(uint fr, uchar dc);  

  72. void configtmr1(uint ms1, uchar ms2);  

  73. void calcrldval(uchar idx);  

  74. void keyscan();  

  75. void keyaction(uchar keycode);  

  76. void keydriver();  

  77.   

  78. void main() {  

  79.     uchar i;  

  80.   

  81.     ea = 1;     //开总中断  

  82.     pt0 = 1;    //设置t0抢占优先  

  83.     addr3 = 0;  //选中led点阵  

  84.     enled = 0;  

  85.     configtmr0(1000, dutycycle[0]);  //配置并启动pwm  

  86.     for (i = 0; i 

  87.         calcrldval(i);  

  88.     configtmr1(50, 1);  

  89.     while (1) {  

  90.         keydriver();  

  91.     }  

  92. }  

  93. //配置并启动t1，ms1:呼吸灯的变化间隔，ms2:矩阵按键的扫描间隔(t1溢出时间)  

  94. void configtmr1(uint ms1, uchar ms2) {  

  95.     ulong tmp;  //临时变量  

  96.   

  97.     rate = ms1 / ms2;  

  98.     tmp = 11059200 / 12;      //定时器计数频率  

  99.     tmp = (tmp * ms2) / 1000;  //计算所需的计数值  

  100.     tmp = 65536 - tmp;        //计算定时器重载值  

  101.     tmp = tmp   12;           //补偿中断响应延时造成的误差  

  102.     t1rh = tmp >> 8;  //定时器重载值拆分为高低字节  

  103.     t1rl = tmp;  

  104.   

  105.     tmod &= 0x0f;   //清零t1的控制位  

  106.     tmod |= 0x10;   //配置t1为模式1  

  107.     th1 = t1rh;     //加载t1重载值  

  108.     tl1 = t1rl;  

  109.     et1 = 1;        //使能t1中断  

  110.     tr1 = 1;        //启动t1  

  111. }  

  112. /* 配置并启动pwm，fr-频率，dc-占空比 */  

  113. void configtmr0(uint fr, uchar dc) {  

  114.     uint high, low, sum;  

  115.   

  116.     rate2cnt = fr - 1;      //到达1秒所需的计数值  

  117.   

  118.     periodcnt = 11059200 / 12 / fr; //计算一个周期所需的计数值  

  119.     high = periodcnt * dc / 100;    //计算高电平所需的计数值  

  120.     low  = periodcnt - high;        //计算低电平所需的计数值  

  121.     high = 65536l - high   12;       //计算高电平的定时器重载值并补偿中断延时  

  122.     low  = 65536l - low    12;       //计算低电平的定时器重载值并补偿中断延时  

  123.     sum = 65536l - periodcnt   12;  

  124.   

  125.     highrh = high >> 8; //高电平重载值拆分为高低字节  

  126.     highrl = high;  

  127.     lowrh  = low >> 8;  //低电平重载值拆分为高低字节  

  128.     lowrl  = low;  

  129.     sumrh = sum >> 8;  

  130.     sumrl = sum;  

  131.   

  132.     tmod &= 0xf0;   //清零t0的控制位  

  133.     tmod |= 0x01;   //配置t0为模式1  

  134.     th0 = highrh;   //加载t0重载值  

  135.     tl0 = highrl;  

  136.     et0 = 1;        //使能t0中断  

  137.     tr0 = 1;        //启动t0  

  138. }  

  139.   

  140. void calcrldval(uchar idx) {  

  141.     uint  high, low;  

  142.   

  143.     high = periodcnt * dutycycle[idx] / 100;    //计算高电平所需的计数值  

  144.     low  = periodcnt - high;        //计算低电平所需的计数值  

  145.     high = 65536l - high   12;       //计算高电平的定时器重载值并补偿中断延时  

  146.     low  = 65536l - low    12;       //计算低电平的定时器重载值并补偿中断延时  

  147.     hrhi[idx] = high >> 8; //高电平重载值拆分为高低字节  

  148.     hrli[idx] = high;  

  149.     lrhi[idx] = low >> 8;  //低电平重载值拆分为高低字节  

  150.     lrli[idx] = low;  

  151. }  

  152. /* 

  153. #define led1_scan(); {   

  154.     static uchar i = 0;  

  155.     p0 = 0xff;   

  156.     p1 = (p1 & 0xf8) | i;    

  157.     p0 = image[i];   

  158.     i =  i & 0x07;  

  159. } 

  160.  

  161. #define led2_scan(); {   

  162.     static uchar i = 0;  

  163.     p0 = 0xff;   

  164.     p1 = (p1 & 0xf8) | i;    

  165.     p0 = ledbuff[i];     

  166.     if (i 

  167.         i ;     

  168.     else     

  169.         i = 0;   

  170. } 

  171. */  

  172. void keyscan() {  

  173.     static uchar i = 0;  

  174.     static uchar keybuf[4][4] = {  

  175.         {0xff, 0xff, 0xff, 0xff}, {0xff, 0xff, 0xff, 0xff},  

  176.         {0xff, 0xff, 0xff, 0xff}, {0xff, 0xff, 0xff, 0xff}  

  177.     };  

  178.     uchar j;  

  179.   

  180.     keybuf[i][0] = (keybuf[i][0] <

  181.     keybuf[i][1] = (keybuf[i][1] <

  182.     keybuf[i][2] = (keybuf[i][2] <

  183.     keybuf[i][3] = (keybuf[i][3] <

  184.     for (j=0; j<4; j ) {  

  185.         if (keybuf[i][j] == 0x00)  

  186.             keystate[i][j] = 0;  

  187.         else if (keybuf[i][j] == 0xff)  

  188.             keystate[i][j] = 1;  

  189.     }  

  190.     switch (i) {  

  191.         case 0: key_out_0 = 1; key_out_1 = 0; break;  

  192.         case 1: key_out_1 = 1; key_out_2 = 0; break;  

  193.         case 2: key_out_2 = 1; key_out_3 = 0; break;  

  194.         case 3: key_out_3 = 1; key_out_0 = 0; break;  

  195.         default : break;  

  196.     }  

  197.     i =  i & 0x03;  

  198. }  

  199.   

  200. #define resetledbuff(num); {      

  201.     ledbuff[0] = ledchar[(num)];     

  202.     ledbuff[1] = ledchar[(num)/10];      

  203.     ledbuff[2] = ledchar[(num)/100];     

  204. }  

  205.   

  206. void keyaction(uchar keycode) {  

  207.     if (keycode == 0x30) {  

  208.         enchange = 0;  

  209.         //tr0 = 0;  

  210.         enled1 = 0;  

  211.     }  

  212.     else if (keycode >= 0x31 && keycode <= 0x39) {  

  213.         enchange = 1;  

  214.         //tr0 = 1;  

  215.         enled1 = 1;  

  216.         numbershow = (keycode - 0x30) * 100;  

  217.         resetledbuff(numbershow);  

  218.     }  

  219. }  

  220.   

  221. void keydriver() {  

  222.     uchar i, j;  

  223.     static uchar backup[4][4] = {  

  224.         {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}  

  225.     };  

  226.   

  227.     for (i=0; i<4; i )  

  228.         for (j=0; j<4; j )  

  229.             if (keystate[i][j] != backup[i][j]) {  

  230.                 if (keystate[i][j] == 0)  

  231.                     keyaction(keycodemap[i][j]);  

  232.                 backup[i][j] = keystate[i][j];  

  233.             }  

  234. }  

  235. //定时器t0的中断服务函数，完成led点阵的扫描，数码管的扫描，数码管显示的动态调整  

  236. //和产生pwm输出  

  237. void interrupttmr0() interrupt 1 {  

  238.     static bit *** = 1;  

  239.     static uchar idx = 0;  

  240.     static uint cnt2 = 0;  

  241.   

  242.     if (addr3) {  

  243.         th0 = sumrh;  

  244.         tl0 = sumrl;  

  245.   

  246.         p0 = 0xff;  

  247.         p1 = (p1 & 0xf8) | idx;  

  248.         p0 = ledbuff[idx];  

  249.   

  250.         if (cnt2 == rate2cnt) {  

  251.             if (enchange) {  

  252.                 if (numbershow > 0) {  

  253.                     numbershow--;  

  254.                     resetledbuff(numbershow);  

  255.                 }  

  256.             }  

  257.             cnt2 = 0;  

  258.         }  

  259.         else  

  260.             cnt2 ;  

  261.   

  262.         if (idx 

  263.             idx ;  

  264.         else {  

  265.             idx = 0;  

  266.             addr3 = 0;  

  267.         }  

  268.     }  

  269.     else {  

  270.         if (***) {  

  271.             th0 = lowrh;  

  272.             tl0 = lowrl;  

  273.             if (enled1) {  

  274.                 p0 = 0xff;  

  275.                 p1 = (p1 & 0xf8) | idx;  

  276.                 p0 = image[idx];  

  277.             }  

  278.             *** = 0;  

  279.         }  

  280.         else {  

  281.             th0 = highrh;  

  282.             tl0 = highrl;  

  283.             p0 = 0xff;  

  284.             *** = 1;  

  285.             if (idx 

  286.                 idx ;  

  287.             else {  

  288.                 idx = 0;  

  289.                 addr3 = 1;  

  290.             }  

  291.         }  

  292.     }  

  293. }  

  294. //定时器t1的中断服务函数，完成矩阵按键的扫描，定时动态调整占空比  

  295. void interrupttimer1() interrupt 3 {  

  296.     static bit dir = 0;  

  297.     static uchar index = 0;  

  298.     static uint cnt = 0;  

  299.   

  300.     th1 = t1rh;  //重新加载t1重载值  

  301.     tl1 = t1rl;  

  302.     keyscan();  

  303.     if (cnt == rate) {  

  304.         highrh = hrhi[index];  

  305.         highrl = hrli[index];  

  306.         lowrh = lrhi[index];  

  307.         lowrl = lrli[index];  

  308.         cnt = 0;  

  309.     }  

  310.     else  

  311.         cnt ;  

  312.   

  313.     if (dir == 0) {  

  314.         index ;  

  315.         if (index == 12)  

  316.             dir = 1;  

  317.     }  

  318.     else {  

  319.         index--;  

  320.         if (index == 0)  

  321.             dir = 0;  

  322.     }  

  323. }  



『本文转载自网络,九游会j9的版权归原作者所有,如有侵权请联系删除』

相关推荐

热门文章 更多
stm32cubemx新建工程 基本io配置过程

技术

阅读

资源

互动

电巢app下载
"));
网站地图