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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › PXA270电子计算器实训报告 附程序
返回列表 发新帖
查看: 3544|回复: 0
打印 上一主题 下一主题
收起左侧

PXA270电子计算器实训报告 附程序

[复制链接]
跳转到指定楼层
楼主
ID:140725 发表于 2016-10-11 16:19 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
广东科学技术职业学院广州学院
实训报告

题目：简易电子计算器
专业：计算机应用技术(嵌入式)
班级：08计应1班
学生姓名：XXXXXX
学号：0801080105

一、 设计任务与要求
设计16键盘简易计算器，实现以下功能。
1、4*4键盘输入，用按键输入数和运算符号。
1              2              3              +
4              5              6              -
7              8              9              *
C              0              =              ∕
2、数码管显示运算过程和结果（十进制数），负号用一个LED灯显示。
3、具有清零和复位功能。
4、具有连续运算功能。
5、具有简易报错和提示功能。

二、 总体方案与说明
利用PXA270的16个键盘，通过中断输入。16个按键分为10个数字键（0-9），
+、-、*、/、=、清零等功能。整个计算器实现在结果为-9999到9999范围内的加
减乘除运算。负数的时候通过LED1亮表示，加减乘除被按下后，对应得LED
灯会亮，在输入数字后自动灭掉提示输入运算符号的LED灯。按下C键具有
清零的效果（清除数码管显示，和相关变量初始化，以及LED灯初始化等）
。“=”的功能是：若没有输入数，则还是显示0；若输入了一个数（正数或
负数）则直接显示这个数（负数显示的时候，要LED1亮）；具有连续运算的
功能（即具有记忆最近输入的运算符和操作数的功能，如：刚输入了1+5=，
显示6之后，再按下“=”，则执行6+5=的操作，以此类推）。当操作数大于
-9999到9999的范围后，显示Eoor和亮所有LED灯报错，当按下清零键后
，清除报错。同样，在运算中，若被除数为0，则报错。
声明：本程序不具备多级运算，如：1+15-45=这种一次运算超过一个运算
符的运算。若按下了多次运算符，则取最后按下的为有效。
由于本人使用的硬件是4个直入键盘和12个矩阵键盘，所以程序分开处理。
三、 电路原理图
数码管：

LED灯：
直入键盘：
矩阵键盘：


四、 软件主要模块流程图
紧接上面的加减乘除、等于、清零键的流程图：
五、 问题分析与解决方案
问题1：如何做到连续运算功能？
答：首先，你要知道你在数学中是如何运算的。如：我要做(25+3-4)*2/3的运算，那么我的计算步骤为：25+3=28，28-4=24，24*2=48,48/3=16。其次，由数学运算推导出一个规律。（以刚才的举例为例）从刚才的运算可以看出，我们在做完一次运算后，其结果都作为了下一次运算的一个成员。那么我们不妨把这个结果放到一个变量如：firstnum中，同时我们第一个运算数25也可以放到变量firstnum中。然后，我们在把要运算的数，即在运算符号后面的数存放到另一个变量secondnum中。这时，我们就可以把运算表达式写为：firstnum = fisrtnum + secondnum;(在程序中，结果都是在=号左边的。)之后的几个表达式分别为：firstnum = firstnum – secondnum; firstnum = firstnum * secondnum; firstnum = firstnum / (secondnum*1.0);(在程序中除号运算的结果为整数，要做到真正的除法运算，就要运算数中至少一个为小数即可。)
最后，从这几个表达式我们可以看出其基本规律是:firstnum = firstnum 运算符 secondnum; 这样只要我们把第一个输入的数和第二个输入的数分开来存，就可以做到连续运算的效果。
问题2：如何正确的把一个表达式中的第一个运算数保存到firstnum中，第二个运算数保存到secondnum中？
答：根据问题1中的运算表达式，我们可以看出，在没有到运算符之前的是firstnum,在运算符后面的是secondnum。这样我们就可以根据有没有输入运算符来把输入的数存放到相应的变量中。当然，由于你的firstnum是可以作为下一个运算的一个运算数的，所以这里要把firstnum定义为全局变量。
问题3：如何实现大于10而小于9999的数显示？
答：由于我的硬件为4个数码管，所以这里仅以我的硬件为例解释。在我们的实验箱上面，都有两组两个的静态数码管，它们的控制端从左到右为：LED_CS2,LED_CS3。一个“CS”就控制两个数码管。从这里我们就可以知都CS2是显示千位和百位的，CS3是显示十位和个位的。由于旧版的PXA270实验箱的硬件时把要控制小数点端口用来控制数码管的开与关，所以整个程序不考虑小数，只考虑整数的运算。
回到正题，在这里我们用一个数码管显示一个数字。如：我们要显示14这个数，那么我们就要把这个两位数分开来分别送到CS3的两个数码管显示。如何分开这两个数？在程序中，我们可以通过这两个表达式获取这个数（用num表示）的十位（用swei表示）和各位（用gwei表示）：swei = num/10%10;  gwei = num%10;在这里有必要解释一下num/10和num%10的意思。num/10是表示num除以10，但这不是数学上的除法运算，而是把num除以10之后，取其能够整除的部分，即可以理解为整数部分。而num%10刚好和num/10相反，它是把num除以10后，不能整除的部分，即余数部分取出来的意思。这样，我们取到十位和个位后，就可以把这两个数分别送到数码管CS3中显示就可以了。同样的道理，要显示百位（用bwei表示）和千位（用qwei表示），可以通过这两个表达式获得：bwei = num /100%10;  qwei = num /1000%10;之后再把千位和百位送到数码管CS2中显示就可以了。
问题4：如何做到输入几位数（在-9999到9999之间）的效果？
答：要做到输入几位数的效果，我们不妨把整个效果想一下。在硬件上，我们是一个按键一个按键的按的，也就是说我们如果要输入123的话，就要分别按下1键、2键、3键。而每按下一个键，我们的程序就会记录刚按下的这个键。再考虑一下在硬件上按下123的效果：首先，我们按下1的时候，数码管就显示1；再按下2的时候，数码管要显示12,才能达到我们要的结果；再次按下3的时候，数码管就要显示123。那么从这里我们可以找出一个数学规律，那就是：1=1；12=1*10+2；123=12*10+3；这个规律就是第二个按下的键要显示的结果就是第一个按下的数字乘以10，再加上第二个按下的数字；而第三个按下的键的结果就是第二个按下的结果乘以10，再加上第三个按下的数字。用程序的表达式可以写成：firstnum = firstnum*10 +justnum;（justnum为最近按下的键）这个表达式就解决了硬件上实现输入多位数的问题。如果你不相信这个表达式可以实现的话，那我们再来验证一下，比如说你要输入5，那么这个表达式就应该为firstnum = 0*10 +5;最后结果为5（这里要说明一点，firstnum的初始值为0）。又比如说，你要输入的数为5678：那么每输入一个数字的对应表达式分别为：firstnum = 0*10 + 5；即firstnum此时为5；输入6的时候，firstnum = 5*10 +6;此时firstnum = 56;输入7，firstnum = 56*10 +7;此时firstnum = 567;最后按下8的时候，firstnum = 567*10 + 8;最后firstnum = 5678；这就说明我们这个表达式是正确的。
问题5：为何实现了操作数为多位数运算，却不能做到连续运算？
答：在解释这个问题前，先说明一点：由于我们的按键都是中断按键，所以每按一下按键就会重新进入一次键盘处理函数。在进行运算的时候，我们把第一个操作数和第二个操作数都定义为了全局变量。当我们进行完第一次运算，由于没有清零，所以再按下运算符继续运算的时候，你会发现数码管是接着第一次运算的结果为上一次的输入乘以10再加上你刚按下键显示出来的。比如说：你进行完的第一次运算为56+64=120；然后你再按下+1的时候，数码管却显示了641。这是为什么？？如何解决这个问题？出现这个问题的原因是：在进行完第一次运算后，firstnum的值变了，而secondnum中的值还是64，而且由于你判断把第二个操作数存放到secondnum中的条件是有没有输入运算符。这就导致你再输入一次运算符的时候，它还是满足条件，而直接进入到表达式：secondnum = secondnum*10 + justnum;其中的secondnum还保存到上一次输入的值64，现在再按下一个数字1，程序重新进入到这个函数就执行了secondnum = 64*10 + 1;的表达式，这就是问题出现的原因。那如何解决这个问题？在我看来，因为你运算完一次运算后，都会有一次=号被按下的机会。我们可以给等号定义一个标志位，这样就可以通过在输入第二个操作数之前判断这个等号是否被按下，按下就把secondnum清零，同时把等号标志位也清掉。这样就可以避免上述情况的发生。
问题6：为何在硬件上调试的时候，会经常出现卡死的情况（就是数码管显示一个东西不变，按任何键都没反应）？
答：开始我的程序出现这种情况的时候，检测程序好几遍都没发现程序上有啥错，也不关硬件的事。后来才知道原来是在boot.s里面把MDMRS配置成0x2800，MDMRS配置成这个的时候，会经常产生冲突，只要把其配置成0x320032就OK了。如：
原来是：
;MDMRS
              ldr                            r1, =0x2800
              str                            r1,[r11]
              mov                            pc,r14
更改后：
;MDMRS
                 ldr                            r1,  =0x320032
                 str               r1, [r11]
              mov               pc,r14
问题7：为何下载镜像文件到实验箱的时候老是提示失败？
答：出现这类情况的原因有多种，这里只介绍软件设置错误的解决方法。软件上到底是哪设置的问题会导致这种情况呢？这个地方的设置很容易被人忽视。下面以截图说明：
步骤1：
步骤2：
步骤3：
步骤4：
步骤5：
如果以上的设置都没错，但下载还是总是失败的话，那就要看你的bootloader配置了。

六、 实验体会
心得体会：在刚接触到这个项目的时候，大概想了一下挺简单的。但是在实践写程序的时候总是会出现各种各样的原因，现实往往和自己想的不一样。就像我自己按照自己的思路写好的程序，在上硬件调试的时候会发现有很多情况自己都没有考虑到。通过这个项目，使得自己对PXA270的这一部分硬件了解了很多，在写程序方面也有点点的长进。在试验中遇到的比较常见的情况都写出来了，在这里就不罗嗦了。
  1. /******************************************************
  2. *
  3. *项目名称：简易计算器
  4. *
  5. *函    数：cal.c
  6. *
  7. *作    用：按键处理，主函数
  8. *
  9. *有待改进：本程序还可以进一步的完善，其一就有如按下1+2，
  10. *                   再按下+号的时候，就直接计算出结果并显示。
  11. *                   希望有兴趣的朋友能够加以改进。
  12. *
  13. *制 作 人：沐雨青林
  14. *
  15. *******************************************************/

  17. #include "led_8.h"

  19. #define                uchar        unsigned        char
  20. #define                usint        unsigned         short int
  21. #define                uint        unsigned         int

  23. extern void Led8_disp(int num);
  24. extern const uchar key_source_code[];
  25. extern void init_key(void);

  27. #define                key_add                '+'
  28. #define                key_de                '-'
  29. #define                key_mul                '*'
  30. #define                key_mol                '/'
  31. #define                key_canal        'C'
  32. #define                key_means        '='



  36. const uchar key_code[] ={ 1, 2, 3, key_add,        // +
  37.                                                   4, 5, 6, key_de,                // -
  38.                                                   7, 8, 9, key_mul,        // *
  39.                                                   key_canal, 0x00, key_means, key_mol};// /
  40. int                firstnum=0;//存放第1个数
  41. int                secondnum=0;//存放第2个数
  42. uchar        operation='\0';//运算符号
  43. uchar        mean_sign=0;//等号标志位        1为开，0位关
  44. uint        optimes=0;//运算符号计数位

  46. //以运算符+、-、*、/为标志，当这些标志出现后，则输入的数字存放到
  47. //secondnum中

  49. //变量初始化
  50. void init_clear(void)
  51. {
  52.         firstnum = 0;
  53.         secondnum = 0;
  54.         operation = '\0';
  55.         optimes = 0;
  56.         LED_CS4 = 0xff;
  57.         Led8_disp(0);
  58.         return;
  59. }

  61. //计算多位数，num为新输入的一位数
  62. //算好的多位数存放在snum,snum为原来存放有数的变量
  63. int duoweishu(int snum, int num)
  64. {
  65.         snum = num + snum*10;
  66.         return snum;
  67. }


  70. //直入式键盘处理
  71. void op_disdir(usint key_d)
  72. {
  73.         uint i;
  74.         for(i=0; i<4; i++)
  75.         {
  76.                 if(key_d == key_source_code[i])
  77.                 {
  78.                         if(i == 3)// ‘+’ 按键处理
  79.                         {
  80.                                 LED_CS4 = 0x7f;
  81.                                 optimes++;
  82.                                 operation = key_code[i];//operation 为‘+’
  83.                         }
  84.                         else
  85.                         {        
  86.                                 //在没有按下运算符的时候，把按键对应的键值存到firstnum
  87.                                 if(operation == '\0')
  88.                                 {
  89.                                         firstnum = duoweishu(firstnum,key_code[i]);
  90.                                         Led8_disp(firstnum);
  91.                                 }
  92.                                 else//按下运算符的时候，把按键对应的键值存到secondnum
  93.                                 {
  94.                                         if(mean_sign == 1)//等号标志位
  95.                                         {
  96.                                                 secondnum = 0;
  97.                                                 mean_sign = 0;//清等号标志位        
  98.                                         }
  99.                                        
  100.                                         if(operation == '-' && optimes == 1)//负数输入
  101.                                         {
  102.                                                 firstnum = duoweishu(firstnum,-key_code[i]);
  103.                                                 Led8_disp(firstnum);
  104.                                         }
  105.                                         else
  106.                                         {
  107.                                                 secondnum = duoweishu(secondnum, key_code[i]);
  108.                                                 Led8_disp(secondnum);
  109.                                         }
  110.                                 }
  111.                         }        
  112.                 }
  113.         }
  114. }
  115. //矩阵键盘处理
  116. void op_dismatrix(usint key_d)
  117. {
  118.         uint i;
  119.         for(i=4; i<16; i++)
  120.         {
  121.                 if(key_d == key_source_code[i])
  122.                 {        
  123.                         if(i == 7)        // ‘-’ 键处理
  124.                         {
  125.                                 LED_CS4 = 0xbf;        
  126.                                 if(operation == '\0' && firstnum == 0)
  127.                                         optimes = 1;
  128.                                 else
  129.                                         optimes += 2;
  130.                                        
  131.                                 operation = key_code[i];        
  132.                         }
  133.                         else if(i == 11)        // ‘*’ 键处理
  134.                         {
  135.                                 LED_CS4 = 0xdf;        
  136.                                 optimes++;
  137.                                 operation = key_code[i];        
  138.                         }
  139.                         else if(i == 12)        // ‘C’ 键处理
  140.                         {
  141.                                 init_clear();//变量初始化
  142.                                 break;
  143.                         }
  144.                         else if(i == 14)        // ‘=’ 键处理
  145.                         {
  146.                                 mean_sign=1;//等号标志位
  147.                                 if(operation == '+')
  148.                                         firstnum = firstnum + secondnum;
  149.                                 else if(operation == '-')
  150.                                         firstnum = firstnum - secondnum;
  151.                                 else if(operation == '*')
  152.                                         firstnum = firstnum * secondnum;
  153.                                 else if(operation == '/')
  154.                                 {
  155.                                         if(secondnum == 0)//被除数为0，结果为无穷大
  156.                                                 firstnum = 88888;
  157.                                         else        
  158.                                                 firstnum = firstnum / secondnum*1.0;
  159.                                 }
  160.                                 
  161.                                 //secondnum = 0;
  162.                                 Led8_disp( firstnum);//显示和
  163.                         }
  164.                         else if(i == 15)// ‘/‘ 键处理
  165.                         {
  166.                                 LED_CS4 = 0xef;
  167.                                 optimes++;
  168.                                 operation = key_code[i];
  169.                         }
  170.                         else // 数字键输入
  171.                         {        
  172.                                 //在没有按下运算符的时候，把按键对应的键值存到firstnum
  173.                                 if(operation == '\0')
  174.                                 {
  175.                                         firstnum = duoweishu(firstnum,key_code[i]);
  176.                                         Led8_disp(firstnum);
  177.                                 }
  178.                                 else//按下运算符的时候，把按键对应的键值存到secondnum
  179.                                 {
  180.                                         if(mean_sign == 1)//等号标志位
  181.                                         {
  182.                                                 secondnum = 0;
  183.                                                 mean_sign = 0;//清等号标志位        
  184.                                         }
  185.                                        
  186.                                         if(operation == '-' && optimes == 1)//负数输入
  187.                                         {
  188.                                                 firstnum = duoweishu(firstnum,-key_code[i]);
  189.                                                 Led8_disp(firstnum);
  190.                                         }
  191.                                         else
  192.                                         {
  193.                                                 secondnum = duoweishu(secondnum, key_code[i]);
  194.                                                 Led8_disp(secondnum);
  195.                                         }
  196.                                 }
  197.                         }
  198.                 }
  199.         }
  200. }


  203. void Main(void)
  204. {        
  205.         LED_CS4 = 0xff;
  206.         //Led8_disp(0);
  207.         init_clear();//变量初始化
  208.         init_key();
  209.         while (1)
  210.         {        
  211.         }

  213. }
复制代码
  1. /******************************************************
  2. *
  3. *项目名称：简易计算器
  4. *
  5. *函    数：key.c
  6. *
  7. *作    用：按键GPIO定义及其相关定义，按键中断函数，按键
  8. *                   初始化函数
  9. *
  10. *有待改进：本程序还可以进一步的完善，其一就有如按下1+2，
  11. *                   再按下+号的时候，就直接计算出结果并显示。
  12. *                   希望有兴趣的朋友能够加以改进。
  13. *
  14. *制 作 人：沐雨青林
  15. *
  16. *******************************************************/


  19. #define                uchar        unsigned        char
  20. #define                usint        unsigned         short int
  21. #define                uint        unsigned         int


  24. #define         KPC                                (*((volatile uint *)(0x41500000)))
  25. #define         KPDK                        (*((volatile uint *)(0x41500008)))
  26. #define         KPREC                        (*((volatile uint *)(0x41500010)))
  27. #define         KPMK                        (*((volatile uint *)(0x41500018)))
  28. #define         KPAS                        (*((volatile uint *)(0x41500020)))
  29. #define         KPKDI                        (*((volatile uint *)(0x41500048)))

  31. #define         GPSR2                        (*((volatile uint *)(0x40E00020)))
  32. #define         GPCR2                        (*((volatile uint *)(0x40E0002C)))
  33. #define         GPDR2                        (*((volatile uint *)(0x40E00014)))
  34. #define         GPSR3                        (*((volatile uint *)(0x40E00118)))
  35. #define         GPCR3                        (*((volatile uint *)(0x40E00124)))
  36. #define         GPDR3                        (*((volatile uint *)(0x40E0010C)))
  37. #define         GAFR3_L                        (*((volatile uint *)(0x40E0006C)))
  38. #define         GAFR2_U                        (*((volatile uint *)(0x40E00068)))


  41. #define         ICMR                        (*((volatile uint *)(0x40D00004)))
  42. #define         ICLR                        (*((volatile uint *)(0x40D00008)))

  44. #define         CKEN                        (*((volatile uint *)(0x41300004)))

  46. extern void op_disdir(usint key_d);
  47. extern void op_dismatrix(usint key_d);


  50. const uchar key_source_code[] ={ 0x40, 0x02, 0x04, 0x20,
  51.                                                                  0x00, 0x01, 0x02, 0x05,
  52.                                                                  0x10, 0x11, 0x12, 0x15,
  53.                                                                  0x20, 0x21, 0x22, 0x25 };

  55. void Delay(uint x)
  56. {
  57.         uint i, j, k;
  58.         for (i =0; i <=x; i++)
  59.                 for (j = 0; j <0xff; j++)
  60.                         for (k = 0; k <0xff; k++);
  61. }

  63. #define                key_down        1
  64. #define                key_up                0
  65. volatile uchar key_f;


  68. void init_key(void)
  69. {
  70.         CKEN |= (1 << 19);
  71.         
  72.         //----gpio-----
  73.         //dirkey
  74.         //94-->KP_DKIN1(01)
  75.         GAFR2_U |= (1<<28);
  76.         GAFR2_U &=~(1<<29);
  77.         //95-->KP_DKIN2(01)
  78.         GAFR2_U |= (1<<30);
  79.         GAFR2_U &=~(1ul<<31);
  80.         //98-->KP_DKIN5(01)
  81.         GAFR3_L |= (1<<4);
  82.         GAFR3_L &= ~(1<<5);
  83.         //99-->KP_DKIN6(01)
  84.         GAFR3_L |= (1<<6);
  85.         GAFR3_L &= ~(1<<7);
  86.         
  87.         //matrixkey
  88.         //in
  89.         //100
  90.         GAFR3_L |= (1<<8);
  91.         GAFR3_L &= ~(1<<9);
  92.         GPDR3 &= ~(1<<4);
  93.         //101
  94.         GAFR3_L |= (1<<10);
  95.         GAFR3_L &= ~(1<<11);
  96.         GPDR3 &= ~(1<<5);        
  97.         //102
  98.         GAFR3_L |= (1<<12);
  99.         GAFR3_L &= ~(1<<13);
  100.         GPDR3 &= ~(1<<6);
  101.         //out
  102.         //108-->KP_MKOUT5(10)
  103.         GAFR3_L &= ~(1<<24);
  104.         GAFR3_L |= (1<<25);
  105.         GPDR3 |= (1<<12);
  106.         //107-->KP_MKOUT4(10)
  107.         GAFR3_L &= ~(1<<22);
  108.         GAFR3_L |= (1<<23);
  109.         GPDR3 |= (1<<11);
  110.         //106-->KP_MKOUT3(10)
  111.         GAFR3_L &= ~(1<<20);
  112.         GAFR3_L |= (1<<21);
  113.         GPDR3 |= (1<<10);
  114.         //105-->KP_MKOUT2(10)
  115.         GAFR3_L &= ~(1<<18);
  116.         GAFR3_L |= (1<<19);
  117.         GPDR3 |= (1<<9);
  118.         //104-->KP_MKOUT1(10)
  119.         GAFR3_L &= ~(1<<16);
  120.         GAFR3_L |= (1<<17);
  121.         GPDR3 |= (1<<8);
  122.         //103-->KP_MKOUT0(10)
  123.         GAFR3_L &= ~(1<<14);
  124.         GAFR3_L |= (1<<15);
  125.         GPDR3 |= (1<<7);
  126.         
  127.         //--------
  128.         KPC = 0x3fbff3c2;
  129.         KPC |= 0x01 ;
  130.         KPC |= (1<<11);
  131.         KPKDI = 0x6464;
  132.         
  133.         //interrupt
  134.         ICMR |= (1<<4);
  135.         ICLR &= ~(1<<4);
  136.                
  137.         //key_up
  138.         key_f = key_up;

  140. }

  142. //key_interrupt
  143. void key_del()
  144. {

  146.         
  147.         ICMR &= ~(1<<4);
  148.         key_f = !key_f;
  149.         if(key_f == key_down)
  150.         {
  151.                 usint key_d;
  152.                 uint kpc_tmp;
  153.                 kpc_tmp = KPC;
  154.                 if(kpc_tmp & (1<<5))
  155.                 {
  156.                         key_d = KPDK & 0xff;
  157.                         
  158.                         op_disdir(key_d);//直入式键盘处理
  159.                         //LED8_CS2 = LED_VALUE(10 , 10);
  160.                 }
  161.                 if(kpc_tmp & (1<<22))
  162.                 {
  163.                         key_d = KPAS & 0xff;
  164.                         op_dismatrix(key_d);//矩阵键盘处理
  165.                         //LED8_CS2 = LED_VALUE(10 , 10);
  166.                         
  167.                 }
  168.         }        
  169.         KPC = KPC;
  170.         ICMR |= (1<<4);
  171. }

  173. void key_dismatrix()
  174. {
  175.         usint key_d;
  176.         key_d = KPAS & 0xff;
  177.         
  178. //        LED8_CS3 = LED_VALUE((key_d & 0xf0) >> 4 ,key_d & 0xf);
  179. }

  181. void key_disdir()
  182. {
  183.         usint key_d;
  184.         while(key_d = KPDK & 0xff, key_d == 0x00);
  185. //        LED8_CS3 = LED_VALUE((key_d & 0xf0) >> 4 ,key_d & 0xf);               
  186. }
复制代码



所有资料下载地址：
http://www.51hei.com/bbs/dpj-4740-1.html
计算器, 实训报告, 程序, 电子
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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