標(biāo)題: 51單片機(jī)計(jì)算器程序狀態(tài)圖與Proteus仿真 [打印本頁]
作者: wmj123    時(shí)間: 2020-12-4 15:23
標(biāo)題: 51單片機(jī)計(jì)算器程序狀態(tài)圖與Proteus仿真
仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機(jī)源程序如下:
  1. #include "led_seg.h"
  2. #include "key.h"
  3. #include "mymath.h"

  5. typedef enum
  6. {
  7.         OPERATOR_EMPTY,
  8.         OPERATOR_PLUS,
  9.         OPERATOR_MINUS,
  10.         OPERATOR_MULTIPLY,
  11.         OPERATOR_DIVIDE,
  12.         OPERATOR_EQUAL
  13. } OPERATOR;


  16. typedef enum
  17. {
  18.         STATE_INIT,
  19.         STATE_INPUT_FIRST_NUM,
  20.         STATE_INPUT_SECOND_NUM,
  21.         STATE_CALC_SIGN,
  22.         STATE_EQUAL
  23. } STATE;

  25. u8 timer = 0;
  26. double show_number = 0;

  28. // 用來標(biāo)記小數(shù)點(diǎn)是否按下
  29. bit is_dot_press = 0;
  30. // 用來記錄小數(shù)點(diǎn)按下后鍵盤按下的數(shù)的數(shù)量
  31. u8 after_dot_press_number = 0;


  34. // (float) 等價(jià)于 (double) 6位有效數(shù)字
  35. void Timer0Init(void);
  36. void Timer0Interrupt(void);
  37. void update_show_number(u8);
  38. void update_calc_sign(OPERATOR);

  40. double first_number = 0;
  41. double second_number = 0;



  45. OPERATOR myoperator = OPERATOR_EMPTY;
  46. STATE state = STATE_INIT;
  47. void main()
  48. {
  49.         Timer0Init();
  50.         while(1)
  51.         {
  52.                
  53.                 keyscan();
  54.                
  55.                 if(NO_KEY_PRESS != key_state)
  56.                 {
  57.                         switch(key_state)
  58.                         {
  59.                                 // 1
  60.                                 case 0:
  61.                                         update_show_number(1);
  62.                                         break;
  63.                                 // 2
  64.                                 case 1:
  65.                                         update_show_number(2);
  66.                                         break;
  67.                                 // 3
  68.                                 case 2:
  69.                                         update_show_number(3);
  70.                                         break;
  71.                                 // +
  72.                                 case 3:
  73.                                         update_calc_sign(OPERATOR_PLUS);
  74.                                         break;
  75.                                 // 4
  76.                                 case 4:
  77.                                         update_show_number(4);
  78.                                         break;
  79.                                 // 5
  80.                                 case 5:
  81.                                         update_show_number(5);
  82.                                         break;
  83.                                 // 6
  84.                                 case 6:
  85.                                         update_show_number(6);
  86.                                         break;
  87.                                 // -
  88.                                 case 7:
  89.                                         update_calc_sign(OPERATOR_MINUS);
  90.                                         break;
  91.                                 // 7
  92.                                 case 8:
  93.                                         update_show_number(7);
  94.                                         break;
  95.                                 // 8
  96.                                 case 9:
  97.                                         update_show_number(8);
  98.                                         break;
  99.                                 // 9
  100.                                 case 10:
  101.                                         update_show_number(9);
  102.                                         break;
  103.                                 // ×
  104.                                 case 11:
  105.                                         update_calc_sign(OPERATOR_MULTIPLY);
  106.                                         break;
  107.                                 // .
  108.                                 case 12:
  109.                                         is_dot_press = 1;
  110.                                         break;
  111.                                 // 0
  112.                                 case 13:
  113.                                         update_show_number(0);
  114.                                         break;
  115.                                 // =
  116.                                 case 14:
  117.                                                 switch(state)
  118.                                                 {
  119.                                                         case STATE_INIT:
  120.                                                         case STATE_EQUAL:
  121.                                                         case STATE_INPUT_FIRST_NUM:
  122.                                                                 first_number = show_number;
  123.                                                                 state = STATE_EQUAL;
  124.                                                                 myoperator = OPERATOR_EMPTY;                                
  125.                                                                 break;
  126.                                                         case STATE_INPUT_SECOND_NUM:
  127.                                                                 second_number = show_number;
  128.                                                                 switch(myoperator)
  129.                                                                 {
  130.                                                                         case OPERATOR_PLUS:
  131.                                                                                 show_number = first_number + second_number;
  132.                                                                                 break;
  133.                                                                         case OPERATOR_MINUS:
  134.                                                                                 show_number = first_number - second_number;
  135.                                                                                 break;
  136.                                                                         case OPERATOR_MULTIPLY:
  137.                                                                                 show_number = first_number * second_number;
  138.                                                                                 break;
  139.                                                                         case OPERATOR_DIVIDE:
  140.                                                                                 
  141.                                                                                 if(0.000000 != second_number)
  142.                                                                                 {
  143.                                                                                         show_number = first_number / second_number;
  144.                                                                                 }
  145.                                                                                 else
  146.                                                                                 {
  147.                                                                                         // warning
  148.                                                                                         show_number = 0;

  150.                                                                                 }
  151.                                                                                        
  152.                                                                                 break;
  153.                                                                         default:
  154.                                                                                 break;
  155.                                                                 }
  156.                                                                 is_dot_press = 0;
  157.                                                                 after_dot_press_number = 0;
  158.                                                                 first_number = 0;
  159.                                                                 second_number = 0;
  160.                                                                 state = STATE_EQUAL;
  161.                                                                 myoperator = OPERATOR_EMPTY;
  162.                                                                 break;
  163.                                                         case STATE_CALC_SIGN:
  164.                                                                 break;
  165.                                                         default:
  166.                                                                 break;
  167.                                                 }
  168.                                         break;
  169.                                 // ÷
  170.                                 case 15:
  171.                                         update_calc_sign(OPERATOR_DIVIDE);
  172.                                         break;
  173.                                 //意外情況的處理
  174.                                 default:
  175.                                         break;
  176.                         }
  177.                         key_state = NO_KEY_PRESS;
  178.                 }
  179.         }
  180. }


  183. void Timer0Init(void)                //100微秒@12.000MHz
  184. {
  185.         TMOD &= 0xF0;                //設(shè)置定時(shí)器模式
  186.         TMOD |= 0x02;                //設(shè)置定時(shí)器模式
  187.         TL0 = 0x9C;                //設(shè)置定時(shí)初值
  188.         TH0 = 0x9C;                //設(shè)置定時(shí)重載值
  189.         TF0 = 0;                //清除TF0標(biāo)志
  190.         TR0 = 1;                //定時(shí)器0開始計(jì)時(shí)
  191.         ET0 = 1;
  192.         EA = 1;
  193. }

  195. void Timer0Interrupt(void) interrupt 1
  196. {
  197.         timer++;
  198.         if(10 == timer)
  199.         {
  200.                 LedShowByNum(show_number);
  201.                 timer = 0;
  202.         }
  203.         keyrescan();
  204. }


  207. void update_show_number(u8 number)
  208. {

  210.         switch(state)
  211.         {
  212.                 case STATE_INIT:
  213.                 case STATE_EQUAL:
  214.                         show_number = 0;
  215.                         first_number = 0;
  216.                         second_number = 0;
  217.                         myoperator = OPERATOR_EMPTY;
  218.                         state = STATE_INPUT_FIRST_NUM;
  219.                         break;
  220.                 case STATE_INPUT_FIRST_NUM:
  221.                         break;
  222.                 case STATE_INPUT_SECOND_NUM:
  223.                         break;
  224.                 case STATE_CALC_SIGN:
  225.                         second_number = show_number = 0;
  226.                         state = STATE_INPUT_SECOND_NUM;
  227.                         break;
  228.                 default:
  229.                         break;
  230.         }
  231.         if(is_dot_press)
  232.         {
  233.                 after_dot_press_number++;
  234.                 show_number += number / ((double)mypow(10,after_dot_press_number));
  235.         }
  236.         else
  237.         {
  238.                 show_number *= 10;
  239.                 show_number += number;
  240.         }
  241.         switch(state)
  242.         {
  243.                 case STATE_INPUT_FIRST_NUM:
  244.                         first_number = show_number;
  245.                         break;
  246.                 case STATE_INPUT_SECOND_NUM:
  247.                         second_number = show_number;
  248.                         break;
  249.                 default:
  250.                         break;
  251.         }
  252.         
  253. }

  255. void update_calc_sign(OPERATOR opr)
  256. {
  257.         switch(state)
  258.         {
  259.                 case STATE_INIT:
  260.                         first_number = 0;
  261.                         myoperator = opr;
  262.                         state = STATE_CALC_SIGN;
  263.                         break;
  264.                 case STATE_EQUAL:
  265.                 case STATE_INPUT_FIRST_NUM:
  266.                         first_number = show_number;
  267.                         state = STATE_CALC_SIGN;
  268.                         myoperator = opr;
  269.                         break;
  270.                 case STATE_INPUT_SECOND_NUM:
  271.                         second_number = show_number;
  272.                         is_dot_press = 0;
  273.                         after_dot_press_number = 0;
  274.                         switch(myoperator)
  275.                         {
  276.                                 case OPERATOR_PLUS:
  277.                                         show_number = first_number + second_number;
  278.                                         break;
  279.                                 case OPERATOR_MINUS:
  280.                                         show_number = first_number - second_number;
  281.                                         break;
  282.                                 case OPERATOR_MULTIPLY:
  283.                                         show_number = first_number * second_number;
  284.                                         break;
  285.                                 case OPERATOR_DIVIDE:
  286.                                         if(0.000000 != second_number)
  287.                                         {
  288.                                                 show_number = first_number / second_number;
  289.                                         }
  290.                                         else
  291.                                         {
  292.                                                 is_dot_press = 0;
  293.                                                 after_dot_press_number = 0;
  294.                                                 // warning
  295.                                                 show_number = 0;
  296.                                                 first_number = 0;
  297.                                                 second_number = 0;
  298.                                                 myoperator = OPERATOR_EMPTY;
  299.                                                 state = STATE_INIT;
  300.                                                 return;
  301.                                         }
  302.                                                 
  303.                                         break;
  304.                                 default:
  305.                                         break;
  306.                         }
  307.                         first_number = show_number;
  308.                         state = STATE_CALC_SIGN;
  309.                         myoperator = opr;
  310.                         break;
  311.                 case STATE_CALC_SIGN:
  312.                         break;
  313.         }
  314. }
復(fù)制代碼
全部資料51hei下載地址(仿真+程序)：
09-實(shí)現(xiàn)一個(gè)簡便的計(jì)算器.7z (116.72 KB, 下載次數(shù): 47)

作者: 泰興電子    時(shí)間: 2023-4-9 16:29
第一次輸入數(shù)不能帶小數(shù)，否則運(yùn)算符后的第二次輸入數(shù)出錯(cuò)。比如7.1+2＝9.2 。但是顯示為7.1+0.02＝7.12 。不知什么原因？樓主能不能查一下，更正后我再來下載一下。
作者: 泰興電子    時(shí)間: 2023-4-13 15:57
已解決了第一次輸入不能是小數(shù)的問題。但是出現(xiàn)了第二個(gè)問題，就是不能及時(shí)顯示小數(shù)點(diǎn)及小數(shù)點(diǎn)后面的零，只有小數(shù)點(diǎn)后面是除零外的數(shù)才能及時(shí)顯示。一直沒有找到原因，樓主幫一下，謝謝！



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