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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 51单片机简易计算器程序报错
返回列表 发新帖
查看: 1638|回复: 0
收起左侧

51单片机简易计算器程序报错

[复制链接]
ID:265513 发表于 2017-12-22 23:15 | 显示全部楼层 |阅读模式
课设做的很简单的计算器，基本运算都有，可报错

单片机源程序如下:
  1. //----------------------------------------------------------------------------
  2. // C main line
  3. //----------------------------------------------------------------------------

  5. #include <m8c.h>        // part specific constants and macros
  6. #include "PSoCAPI.h"    // PSoC API definitions for all User Modules

  8. #include "Shuzi.h"
  9. #include "Character.h"
  10. #include "Define.h"


  13. void Delayms(void){
  14.         unsigned int n = 0x00;
  15.         for(n=2000;n>0;n--);
  16. }

  18. void Delays(unsigned int n){
  19.         unsigned int m = 0x00;
  20.         while(n--){
  21.                 for(m=0;m<500;m++){
  22.                         ;
  23.                 }
  24.         }
  25. }

  27. //向上边LCD还是向下边LCD写数据/命令
  28. void LCD_Write(unsigned char chn,unsigned char CMD_DAT,unsigned char dat){
  29.         unsigned char n = 0x00;
  30.        
  31.         if(CMD_DAT == COMMAND){
  32.                 LCD_RS_OUT0;
  33.         }else{
  34.                 LCD_RS_OUT1;
  35.         }
  36.        
  37.         LCD_DATA_PORT = dat;
  38.        
  39.         LCD_WR_OUT0;
  40.         LCD_RD_OUT0;
  41.        
  42.         if (chn == LCD_UP){//选择上边LCD
  43.                 LCD_CS1_OUT0;
  44.         }else{
  45.                 if(chn == LCD_DOWN){//选择下边LCD
  46.                         LCD_CS2_OUT0;
  47.                 }else{//选择两个LCD
  48.                         LCD_CS1_OUT0;
  49.                         LCD_CS2_OUT0;
  50.                 }
  51.         }
  52.         for(n=0;n<10;n++);
  53.        
  54.         LCD_RD_OUT1;
  55.         for(n=0;n<10;n++);
  56.        
  57.         //LCD_WR_OUT1;
  58.        
  59.         if (chn == LCD_UP){//选择上边LCD
  60.                 LCD_CS1_OUT1;
  61.         }else{
  62.                 if(chn == LCD_DOWN){//选择下边LCD
  63.                         LCD_CS2_OUT1;
  64.                 }else{//选择两个LCD
  65.                         LCD_CS1_OUT1;
  66.                         LCD_CS2_OUT1;
  67.                 }
  68.         }
  69.        
  70.         LCD_RD_OUT0;
  71.         for(n=0;n<10;n++);
  72.        
  73. }


  76. //在com,seg上写一个字节的数据
  77. void Draw_Line(unsigned char chn,unsigned char pg,unsigned char seg,unsigned char dat1,unsigned char dat2,unsigned char CNT){
  78.         unsigned char n = 0x00;
  79.         //unsigned char m = 0x00;
  80.        
  81.         seg = seg +4;
  82.        
  83.         LCD_Write(chn,COMMAND,(0xb0 | pg ));// 写 pg 地址
  84.         LCD_Write(chn,COMMAND,(0x10 | (((seg >> 4) & 0x0f))));// 写 seg 高4位地址
  85.         LCD_Write(chn,COMMAND,(0x00 | ((seg & 0x0f))));// 写 seg 低4位地址
  86.        
  87.         for(n=0;n<CNT;n++){
  88.                 LCD_Write(chn,DATA,dat1);
  89.                 n++;
  90.                 if(n<CNT){
  91.                         //for(m=0;m<5;m++);
  92.                         LCD_Write(chn,DATA,dat2);
  93.                         //for(m=0;m<5;m++);
  94.                 }
  95.         }

  97. }

  99. //清除LCD上所有的数据，使之显示空白
  100. void Clear_LCD(unsigned char chn){
  101.         unsigned int n = 0x00;
  102.        
  103.         for(n=0;n<LCD_HEIGHT_PAGE;n++){
  104.                 Draw_Line(chn,n,0x00,0x00,0x00,LCD_WIDTH);
  105.         }
  106. }

  108. //初始化LCD
  109. void LCD_Init(void){
  110.        
  111.         LCD_RST_OUT0;
  112.         Delays(50);
  113.         LCD_RST_OUT1;
  114.         Delays(50);
  115.        
  116.         //LCD_Write(LCD_TWO,COMMAND,0xa0);//
  117.         LCD_Write(LCD_TWO,COMMAND,0xc0);
  118.        
  119.         LCD_Write(LCD_TWO,COMMAND,0xa1);//
  120.         //LCD_Write(LCD_TWO,COMMAND,0xc8);
  121.        
  122.        
  123.         LCD_Write(LCD_TWO,COMMAND,0xf8);
  124.         LCD_Write(LCD_TWO,COMMAND,0x00);
  125.         LCD_Write(LCD_TWO,COMMAND,0xa2);
  126.         Delays(10);
  127.         LCD_Write(LCD_TWO,COMMAND,0x2c);
  128.         Delays(10);
  129.         LCD_Write(LCD_TWO,COMMAND,0x2e);
  130.         Delays(10);
  131.         LCD_Write(LCD_TWO,COMMAND,0x2f);
  132.         Delays(10);
  133.         LCD_Write(LCD_TWO,COMMAND,0x24);
  134.         Delays(10);
  135.         LCD_Write(LCD_TWO,COMMAND,0x81);
  136.         LCD_Write(LCD_TWO,COMMAND,41);// 41 = 9.0V
  137.         Delays(10);
  138.         LCD_Write(LCD_TWO,COMMAND,0x40);
  139.        
  140.         Clear_LCD(LCD_UP);
  141.         Clear_LCD(LCD_DOWN);
  142.        
  143.         LCD_Write(LCD_TWO,COMMAND,0xaf);
  144.        
  145.         Delays(10);
  146.        
  147. }

  149. //清除数字区
  150. void Clear_Num(unsigned char pg,unsigned char seg,unsigned char length){
  151.        
  152.         Draw_Line(LCD_UP,pg,seg,0x00,0x00,length);
  153.         Draw_Line(LCD_UP,pg+1,seg,0x00,0x00,length);
  154.        
  155. }
  156. //冀雅测试画面
  157. void Show_Test(unsigned char chn){
  158.         unsigned char n = 0x00;
  159.         unsigned char m = 0x00;
  160.        
  161.         for(n=0;n<TEST_CNT;n++){
  162.                 for(m=0;m<LCD_HEIGHT_PAGE;m++){
  163.                         Draw_Line(chn,m,0x00,TEST_CODE[n*2],TEST_CODE[n*2+1],LCD_WIDTH);
  164.                 }
  165.                 Delays(TEST_DELAY_VALUE);
  166.         }
  167.        
  168. }
  169. //显示框屏
  170. void Show_Kuang(unsigned char chn){
  171.         unsigned char n = 0x00;
  172.        
  173.         Draw_Line(chn,0,0x00,0x01,0x01,LCD_WIDTH);
  174.         Draw_Line(chn,(LCD_HEIGHT_PAGE - 1),0x00,0x80,0x80,LCD_WIDTH);
  175.         for(n=0;n<LCD_HEIGHT_PAGE;n++){
  176.                 Draw_Line(chn,n,0,0xff,0xff,0x01);
  177.                 Draw_Line(chn,n,(LCD_WIDTH - 1),0xff,0xff,0x01);
  178.         }
  179. }
  180. //显示冀雅模块汉字
  181. void Show_Hanzi(unsigned char chn,unsigned char pg,unsigned char seg,unsigned char color){
  182.         unsigned int n = 0x0000;
  183.         unsigned int m = 0x0000;
  184.         unsigned int k = 0x0000;
  185.        
  186.         for(k=0;k<4;k++){
  187.                 for(n=0;n<2;n++){
  188.                         for(m=0;m<16;m++){
  189.                                 if(color == BLACK){
  190.                                         Draw_Line(chn,pg+n,seg+k*16+m,JIYA[k*32+n*16+m],0x00,0x01);
  191.                                 }else{
  192.                                         Draw_Line(chn,pg+n,seg+k*16+m,~JIYA[k*32+n*16+m],0x00,0x01);
  193.                                 }
  194.                         }
  195.                 }
  196.         }
  197. }


  200. //显示+-*/ 标志触摸区
  201. //         ADD_FUHAO                0
  202. //        MIN_FUHAO                1
  203. //         MUL_FUHAO                2
  204. //         DIV_FUHAO                3
  205. void Show_Fuhao(unsigned char chn,unsigned char witch,unsigned char pg,unsigned char seg){
  206.         unsigned char n = 0x00;
  207.         unsigned char m = 0x00;
  208.        
  209.         if(witch != 0xff){//如果不是清屏命令
  210.                 for(n=0;n<2;n++){
  211.                         for(m=0;m<17;m++){
  212.                                 Draw_Line(chn,pg+n,seg+m,YUN_SUN_CODE[witch*34+n*17+m],0x00,0x01);
  213.                         }
  214.                 }
  215.         }else{
  216.                 for(n=0;n<2;n++){
  217.                         Draw_Line(chn,pg+n,seg,0x00,0x00,17);
  218.                 }
  219.         }
  220. }


  223. //显示单一字符，数字，或者+-*/=C功能按键符号
  224. void Show_Sig_Char(unsigned char chn,unsigned char pg,unsigned char seg,unsigned char num){
  225.         unsigned char n = 0x00;
  226.         unsigned char m = 0x00;
  227.        
  228.         if(num < 10){//如果是数字
  229.                 for(n=0;n<2;n++){
  230.                         for(m=0;m<9;m++){
  231.                                 Draw_Line(chn,pg+n,seg+m,MID_NUM_CODE[num*18+n*9+m],0x00,0x01);
  232.                         }
  233.                 }
  234.         }else{
  235.                 switch(num){
  236.                         case 'C':
  237.                                         Show_CLR_CAL_FUHAO(chn,CLR_FUHAO,pg,seg);
  238.                         break;
  239.                         case '=':
  240.                                         Show_CLR_CAL_FUHAO(chn,CAL_FUHAO,pg,seg);
  241.                         break;
  242.                         case '+':
  243.                                         Show_Fuhao(chn,ADD_FUHAO,pg,seg);
  244.                         break;
  245.                         case '-':
  246.                                         Show_Fuhao(chn,MIN_FUHAO,pg,seg);
  247.                         break;
  248.                         case '*':
  249.                                         Show_Fuhao(chn,MUL_FUHAO,pg,seg);
  250.                         break;
  251.                         case '/':
  252.                                         Show_Fuhao(chn,DIV_FUHAO,pg,seg);
  253.                         break;
  254.                                
  255.                         default:
  256.                                
  257.                         break;
  258.                 }
  259.         }
  260.        
  261. }

  263. //显示数字，long型数据，最多可显示10位数字
  264. void Show_Num(unsigned char chn,unsigned char pg,unsigned char seg,unsigned long num){
  265.         unsigned long dat[10];
  266.         unsigned long tmp = 0x00000000;
  267.         unsigned char dispay_on = 0x00;
  268.        
  269.         unsigned char n = 0x00;
  270.         unsigned char m = 0x00;
  271.         unsigned char k = 0x00;
  272.        
  273.         tmp = num;
  274.         dat[0] = tmp / 1000000000;
  275.         dat[1] = (num - dat[0] * 100000000) / 100000000;
  276.         dat[2] = (num - dat[0] * 1000000000 - dat[1] * 100000000) / 10000000;
  277.         dat[3] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000) / 1000000;
  278.         dat[4] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000 - dat[3] * 1000000) / 100000;
  279.         dat[5] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000 - dat[3] * 1000000 - dat[4] * 100000) / 10000;
  280.         dat[6] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000 - dat[3] * 1000000 - dat[4] * 100000 - dat[5] * 10000) / 1000;
  281.         dat[7] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000 - dat[3] * 1000000 - dat[4] * 100000 - dat[5] * 10000 - dat[6] * 1000) / 100;
  282.         dat[8] = (num - dat[0] * 1000000000 - dat[1] * 100000000 - dat[2] * 10000000 - dat[3] * 1000000 - dat[4] * 100000 - dat[5] * 10000 - dat[6] * 1000 - dat[7] * 100) / 10;
  283.         dat[9] = num % 10;
  284.        
  285.         for(n=0;n<10;n++){//显示10个数字
  286.                 if(dat[n] != 0x00){//数字不等于0，需要显示
  287.                         dispay_on = 0xff;
  288.                         Show_Sig_Char(chn,pg,seg+n*9,dat[n]);
  289.                 }else{
  290.                         if(dispay_on != 0x00){//已经有不为0的数字了，需要继续显示
  291.                                 Show_Sig_Char(chn,pg,seg+n*9,dat[n]);
  292.                         }else{
  293.                                 if(n == 9){
  294.                                         Show_Sig_Char(chn,pg,seg+n*9,dat[n]);
  295.                                 }
  296.                         }
  297.                 }
  298.                
  299.         }
  300.        
  301. }


  304. //显示输入的数字，最多5个数字
  305. void Show_Input_Num(unsigned char pg,unsigned char seg,unsigned char dat[5]){
  306.         unsigned char n = 0x00;
  307.         unsigned char dispay_on = 0x00;
  308.        
  309.         for(n=0;n<5;n++){
  310.                 if(dat[n] != 0x00){//数字不等于0，需要显示
  311.                         dispay_on = 0xff;
  312.                         Show_Sig_Char(LCD_UP,pg,seg+n*9,dat[n]);
  313.                 }else{
  314.                         if(dispay_on != 0x00){//已经有不为0的数字了，需要继续显示
  315.                                 Show_Sig_Char(LCD_UP,pg,seg+n*9,dat[n]);
  316.                         }
  317.                 }
  318.         }
  319.        
  320. }
  321. //开始SEG = 30
  322. //
  323. void Show_First_Num(unsigned char num){
  324.         if(num > 9){
  325.                
  326.         }
  327. }


  330. //显示计算器界面,下边的屏幕
  331. void Show_CAL_GUI(void ){
  332.         unsigned char n = 0x00;
  333.        
  334.         for(n=0;n<16;n++){
  335.                 Show_Sig_Char(LCD_DOWN,CAL_POSITION_GUI[n*2],CAL_POSITION_GUI[n*2+1],TP_KEY_CODE[n]);
  336.                
  337.         }
  338.        
  339. }

  341. const unsigned int MUL_CODE[]={
  342.         10000,1000,100,10,1,
  343. };
  344. //计算输入值
  345. unsigned long CAL_Input_Num(unsigned char num[5]){
  346.         unsigned long tmpl = 0x00;
  347.         unsigned long dt = 0x00;
  348.         unsigned char n = 0x00;
  349.        
  350.         tmpl = 0x00000000;
  351.        
  352.         for(n=0;n<5;n++){
  353.                 dt = num[n];
  354.                 dt = dt * MUL_CODE[n];
  355.                 tmpl = tmpl + dt;
  356.         }
  357.        
  358.         return tmpl;
  359.        
  360. }

  362. //显示 作者
  363. void Show_Author(unsigned char pg,unsigned char seg){
  364.         unsigned char n = 0x00;
  365.         unsigned char m = 0x00;
  366.         unsigned char k = 0x00;
  367.        
  368.         for(k=0;k<6;k++){
  369.                 for(n=0;n<2;n++){
  370.                         for(m=0;m<16;m++){
  371.                                 Draw_Line(LCD_UP,pg+n,seg+k*16+m,AUTHOR_CODE[k*32+n*16+m],0x00,0x01);
  372.                         }
  373.                 }
  374.         }
  375.        
  376. }

  378. //显示 冀雅
  379. void Show_Jiya(unsigned char pg,unsigned char seg){
  380.         unsigned char n = 0x00;
  381.         unsigned char m = 0x00;
  382.         unsigned char k = 0x00;
  383.        
  384.         for(k=0;k<2;k++){
  385.                 for(n=0;n<2;n++){
  386.                         for(m=0;m<16;m++){
  387.                                 Draw_Line(LCD_UP,pg+n,seg+k*16+m,JIYA[k*32+n*16+m],0x00,0x01);
  388.                         }
  389.                 }
  390.         }
  391.        
  392. }
  393. //显示 计算器
  394. void Show_Jisuanqi(unsigned char pg,unsigned char seg){
  395.         unsigned char n = 0x00;
  396.         unsigned char m = 0x00;
  397.         unsigned char k = 0x00;
  398.        
  399.         for(k=0;k<3;k++){
  400.                 for(n=0;n<2;n++){
  401.                         for(m=0;m<16;m++){
  402.                                 Draw_Line(LCD_UP,pg+n,seg+k*16+m,JISUANQI_CODE[k*32+n*16+m],0x00,0x01);
  403.                         }
  404.                 }
  405.         }
  406.        
  407. }
  408. //显示 参数错误
  409. void Show_Err_Tips(unsigned char pg,unsigned char seg){
  410.         unsigned char n = 0x00;
  411.         unsigned char m = 0x00;
  412.         unsigned char k = 0x00;
  413.        
  414.         for(k=0;k<4;k++){
  415.                 for(n=0;n<2;n++){
  416.                         for(m=0;m<16;m++){
  417.                                 Draw_Line(LCD_UP,pg+n,seg+k*16+m,ERROR_TIPS[k*32+n*16+m],0x00,0x01);
  418.                         }
  419.                 }
  420.         }
  421.        
  422. }
  423. //在上边屏幕显示冀雅LOGO
  424. void Show_Logo(void ){
  425.        
  426.         Show_Jiya(0,8);//显示冀雅
  427.         Show_Jisuanqi(3,0);//显示计算器
  428.        
  429. }


  432. //计算器测试
  433. void Caculate_Test(void ){
  434.         unsigned char Loop = 0x01;
  435.         unsigned char key = 0x00;
  436.         unsigned char Input_Num_Cnt = 0x00;
  437.         unsigned char Input_NUM[5];
  438.         unsigned char Fuhao = 0xff;
  439.         unsigned char n = 0x00;
  440.         unsigned char tmpm = 0x00;
  441.         unsigned char last_key = 0xff;
  442.         unsigned long rslt = 0x00;
  443.        
  444.         First_NUM = 0x00000000;
  445.         Second_NUM= 0x00000000;

  447.         for(n=0;n<5;n++){
  448.                 Input_NUM[n] = 0x00;
  449.         }
  450.        
  451.         Clear_LCD(LCD_UP);//清屏上边的屏幕
  452.         Clear_LCD(LCD_DOWN);//清屏下边的屏幕
  453.        
  454.         Show_Logo();//显示冀雅LOGO
  455.         Show_CAL_GUI();//显示下边屏幕的数字排列和符号标示
  456.        
  457.        
  458.         Input_Num_Cnt = 0x00;
  459.         while(Loop == 0x01){//进入有条件无限循环
  460.                 key = TP_Scan();//扫描按键
  461.                 if(key != 0xff){//如果有按键按下
  462.                         switch(key){//判断按下的是哪个按键
  463.                                 case '+':
  464.                                                         Show_Fuhao(LCD_UP,ADD_FUHAO,2,55);
  465.                                                         Fuhao = '+';
  466.                                                        
  467.                                                         Input_Num_Cnt = 0x00;
  468.                                                         for(n=0;n<5;n++){
  469.                                                                 Input_NUM[n] = 0x00;
  470.                                                         }
  471.                                                        
  472.                                 break;
  473.                                 case '-':
  474.                                                         Show_Fuhao(LCD_UP,MIN_FUHAO,2,55);
  475.                                                         Fuhao = '-';
  476.                                                        
  477.                                                         Input_Num_Cnt = 0x00;
  478.                                                         for(n=0;n<5;n++){
  479.                                                                 Input_NUM[n] = 0x00;
  480.                                                         }
  481.                                                        
  482.                                 break;
  483.                                 case '*':
  484.                                                         Show_Fuhao(LCD_UP,MUL_FUHAO,2,55);
  485.                                                         Fuhao = '*';
  486.                                                        
  487.                                                         Input_Num_Cnt = 0x00;
  488.                                                         for(n=0;n<5;n++){
  489.                                                                 Input_NUM[n] = 0x00;
  490.                                                         }
  491.                                                        
  492.                                 break;
  493.                                 case '/':
  494.                                                         Show_Fuhao(LCD_UP,DIV_FUHAO,2,55);
  495.                                                         Fuhao = '/';
  496.                                                        
  497.                                                         Input_Num_Cnt = 0x00;
  498.                                                         for(n=0;n<5;n++){
  499.                                                                 Input_NUM[n] = 0x00;
  500.                                                         }
  501.                                                        
  502.                                 break;
  503.                                 case 'C':
  504.                                                         for(n=0;n<5;n++){//数据清零
  505.                                                                 Input_NUM[n] = 0x00;
  506.                                                         }
  507.                                                         First_NUM = 0x00000000;
  508.                                                         Second_NUM= 0x00000000;
  509.                                                         Input_Num_Cnt = 0x00;
  510.                                                         Fuhao = 0xff;
  511.                                                        
  512.                                                         Clear_Num(0,80,45);//清除第一个数字
  513.                                                         Clear_Num(3,80,45);//清除第二个数字
  514.                                                         Clear_Num(6,36,90);//清除计算结果
  515.                                                         Show_Fuhao(LCD_UP,0xff,2,55);//清除符号区
  516.                                                         Clear_Num(6,20,9);//清除 " = "
  517.                                                        
  518.                                 break;
  519.                                 case '=':
  520.                                                         //Second_NUM = CAL_Input_Num(Input_NUM);
  521.                                                         Show_Sig_Char(LCD_UP,6,20,'=');
  522.                                                        
  523.                                                         switch(Fuhao){//根据符号做出不同处理；
  524.                                                                 case '+':
  525.                                                                                         rslt = First_NUM + Second_NUM;
  526.                                                                                        
  527.                                                                 break;
  528.                                                                 case '-':
  529.                                                                                         rslt = First_NUM - Second_NUM;
  530.                                                                                        
  531.                                                                 break;
  532.                                                                 case '*':
  533.                                                                                         rslt = First_NUM * Second_NUM;
  534.                                                                                        
  535.                                                                                        
  536.                                                                 break;
  537.                                                                 case '/':
  538.                                                                                 if(Second_NUM != 0x00){       
  539.                                                                                         rslt = First_NUM / Second_NUM;
  540.                                                                                 }else{//有错误
  541.                                                                                         Clear_LCD(LCD_UP);//
  542.                                                                                         for(n=0;n<3;n++){
  543.                                                                                                 Show_Err_Tips(3,32);//显示参数错误
  544.                                                                                                 Delays(100);
  545.                                                                                                 Clear_LCD(LCD_UP);//
  546.                                                                                                 Delays(100);
  547.                                                                                         }
  548.                                                                                         Loop = 0x00;//从此函数返回去
  549.                                                                                        
  550.                                                                                 }
  551.                                                                                        
  552.                                                                 break;
  553.                                                                 default:
  554.                                                                                 /*
  555.                                                                                 Clear_LCD(LCD_UP);//
  556.                                                                                 for(n=0;n<3;n++){
  557.                                                                                         Show_Err_Tips(3,32);//显示参数错误
  558.                                                                                         Delays(100);
  559.                                                                                         Clear_LCD(LCD_UP);//
  560.                                                                                         Delays(100);
  561.                                                                                 }
  562.                                                                                 Loop = 0x00;//从此函数返回去
  563.                                                                                 */
  564.                                                                 break;
  565.                                                         }
  566.                                                         Show_Num(LCD_UP,6,36,rslt);//显示计算结果
  567.                                                        
  568.                                                         //重新初始化所有参数
  569.                                                         Input_Num_Cnt = 0x00;
  570.                                                         for(n=0;n<5;n++){
  571.                                                                 Input_NUM[n] = 0x00;
  572.                                                         }
  573.                                                         First_NUM = 0x00000000;
  574.                                                         Second_NUM= 0x00000000;
  575.                                                         Input_Num_Cnt = 0x00;
  576.                                                         Fuhao = 0xff;
  577.                                                        
  578.                                                                                                
  579.                                 break;
  580.                                
  581.                                 default://输入的是0——9数字
  582.                                                 if(last_key == '='){//如果按数字时，之前有计算结果显示，则清除之，再正常显示
  583.                                                         for(n=0;n<5;n++){//数据清零
  584.                                                                 Input_NUM[n] = 0x00;
  585.                                                         }
  586.                                                         First_NUM = 0x00000000;
  587.                                                         Second_NUM= 0x00000000;
  588.                                                         Input_Num_Cnt = 0x00;
  589.                                                         Fuhao = 0xff;
  590.                                                        
  591.                                                         Clear_Num(0,80,45);//清除第一个数字
  592.                                                         Clear_Num(3,80,45);//清除第二个数字
  593.                                                         Clear_Num(6,36,90);//清除计算结果
  594.                                                         Show_Fuhao(LCD_UP,0xff,2,55);//清除符号区
  595.                                                         Clear_Num(6,20,9);//清除 " = "
  596.                                                 }//完成准备工作
  597.                                                
  598.                                                
  599.                                                
  600.                                                 if(Fuhao == 0xff){//输入第一个数据
  601.                                                         //判断输入的数据
  602.                                                         if(Input_Num_Cnt < 5){//输入的不够5个数字
  603.                                                                 for(n=0;n<4;n++){
  604.                                                                         Input_NUM[n] = Input_NUM[n+1];
  605.                                                                 }
  606.                                                                 Input_NUM[4] = key;
  607.                                                                 Input_Num_Cnt++;
  608.                                                         }
  609.                                                         Show_Input_Num(0,80,Input_NUM);
  610.                                                         First_NUM = CAL_Input_Num(Input_NUM);
  611.                                                        
  612.                                                 }else{//输入第二个数据
  613.                                                        
  614.                                                         if(Input_Num_Cnt < 5){//输入的不够5个数字
  615.                                                                 for(n=0;n<4;n++){
  616.                                                                         Input_NUM[n] = Input_NUM[n+1];
  617.                                                                 }
  618.                                                                 Input_NUM[4] = key;
  619.                                                                 Input_Num_Cnt++;
  620.                                                         }
  621.                                                        
  622.                                                         Show_Input_Num(3,80,Input_NUM);
  623.                                                         Second_NUM = CAL_Input_Num(Input_NUM);
  624.                                                        
  625.                                                 }
  626.                                                
  627.                                 break;
  628.                         }
  629.                        
  630.                         last_key = key;//记录最后一次的按键
  631.                        
  632.                 }
  633.                
  634.                
  635.                
  636.         }
  637.        
  638.        
  639. }

  641. void Start_LED(void ){
  642.         unsigned char n = 0x00;
  643.        
  644.         for(n=0;n<1;n++){
  645.                 OPEN_LED;
  646.                 Delays(100);
  647.                 CLOSE_LED;
  648.                 //Delays(100);
  649.         }
  650. }
  651. void main(void)
  652. {
  653.         // M8C_EnableGInt ; // Uncomment this line to enable Global Interrupts
  654.         // Insert your main routine code here.
  655.         unsigned char n = 0x00;
  656.         unsigned char Flash_CNT= 50;
  657.         unsigned char Wait_LED = 0x00;
  658.        
  659.         unsigned char Pre_Key = 0x00;
  660.         unsigned char Valid_Key;
  661.         unsigned char Valid_CNT = 0x00;
  662.         unsigned char KEY_STATE[SENSOR_CNT];
  663.        
  664.         for(n=0;n<SENSOR_CNT;n++){
  665.                 KEY_STATE[n] = KEY_RELEASE;
  666.                 Valid_Key = 0x00;
  667.         }
  668.        
  669.         LCD_Init();//初始化LCD
  670.         Delays(5);
  671.        
  672.         Capsense_Init();//初始化Capsense
  673.        
  674.         Start_LED();
  675.        
  676.         /*
  677.         for(n=0;n<2;n++){
  678.                 Show_Test(LCD_TWO);
  679.                 Clear_LCD(LCD_TWO);
  680.             Show_Kuang(LCD_TWO);
  681.                 Delays(TEST_DELAY_VALUE);
  682.                 Clear_LCD(LCD_TWO);
  683.                 Show_Hanzi(LCD_TWO,1,32,BLACK);
  684.                 Show_Hanzi(LCD_TWO,5,32,WHITE);
  685.                 Delays(TEST_DELAY_VALUE);
  686.                
  687.         }
  688.         */
  689.        
  690.         while(1){
  691.                
  692.                 Caculate_Test();
  693.                
  694.         }
  695. }

复制代码

所有资料51hei提供下载:
Calcu.rar (3.72 KB, 下载次数: 5)
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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