基于1602液晶的简易计算器

wu68aq

基于1602液晶的简易计算器
1 ~* ]1 ?' I8 F: L! Z

#include <reg52.h>
7 S" S& Z2 \# ~% Q, ^' q
0 M" X  J  `+ R/ s7 _; Munsigned char step = 0;  //操作步骤
unsigned char oprt = 0;  //运算类型
signed long num1 = 0;    //操作数1
signed long num2 = 0;    //操作数2
' e6 f, C' A% r$ v+ E7 bsigned long result = 0;  //运算结果
! \- G2 r2 x3 U; E. d/ ^unsigned char T0RH = 0;  //T0重载值的高字节
' ^7 t6 N% n$ z8 x0 ~2 |unsigned char T0RL = 0;  //T0重载值的低字节
7 q$ I7 K" I, V. f
6 i* a# X4 U6 x! ]( ]3 P* R4 dvoid ConfigTimer0(unsigned int ms);
" k. E; j6 W6 W9 Yextern void KeyScan();
! d& ?( t+ ~  `9 U. fextern void KeyDriver();
) |2 |  m% S( Rextern void InitLcd1602();
+ @  S2 d7 E- ^& cextern void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
extern void LcdAreaClear(unsigned char x, unsigned char y, unsigned char len);
& g2 ~( M9 w2 n9 e! z4 j' ^3 Gextern void LcdFullClear();
7 s9 N/ M  |! G3 L2 }3 ?
void main()
{
) P1 \1 P$ Q1 ^9 S; `    EA = 1;           //开总中断
    ConfigTimer0(1);  //配置T0定时1ms
        InitLcd1602();    //初始化液晶
    LcdShowStr(15, 1, "0");  //初始显示一个数字0

# h0 ]' \9 b9 F% J. N. N: G5 v    while (1)
    {
) S3 i" K. X4 I/ J5 d        KeyDriver();  //调用按键驱动
, N6 {  `, i0 V5 k# h# p2 V: p, n  L    }
}
$ _) L/ ?8 a" t! Z5 l/* 长整型数转换为字符串，str-字符串指针，dat-待转换数，返回值-字符串长度 */
unsigned char LongToString(unsigned char *str, signed long dat)
{
7 n6 H0 r, h. X, q) V( n    signed char i = 0;
    unsigned char len = 0;
    unsigned char buf[12];

    if (dat < 0)  //如果为负数，首先取绝对值，并在指针上添加负号
    {
" j+ ]' r3 T' U' ~1 G* M9 @" Z        dat = -dat;
8 _( H7 `1 G' N" a( o" z        *str++ = '-';
        len++;
    }
    do {          //先转换为低位在前的十进制数组
, ?' O$ }( [& I4 h6 v( k3 N        buf[i++] = dat % 10;
  N* }; K$ I: d( {6 k7 [6 x. }        dat /= 10;
    } while (dat > 0);
    len += i;     //i最后的值就是有效字符的个数
    while (i-- > 0)   //将数组值转换为ASCII码反向拷贝到接收指针上
    {
' W& q, J3 F6 O% E$ \: q+ @        *str++ = buf + '0';
    }
    *str = '\0';  //添加字符串结束符
* s; `/ D+ C. N' d9 W% n. x
, g$ l: B6 |1 l0 L" M7 V    return len;   //返回字符串长度
: r4 R: `% H; x5 K}
; \1 i( f! `, _- [' K/* 显示运算符，显示位置y，运算符类型type */
void ShowOprt(unsigned char y, unsigned char type)
{
    switch (type)
    {
        case 0: LcdShowStr(0, y, "+"); break;  //0代表+
' R# z( p9 _: d3 i8 o        case 1: LcdShowStr(0, y, "-"); break;  //1代表-
        case 2: LcdShowStr(0, y, "*"); break;  //2代表*
- v" Z6 p, N* M2 Z4 |3 [9 L7 D        case 3: LcdShowStr(0, y, "/"); break;  //3代表/
        default: break;
6 _; z7 F! ]! [6 g: |* H: w    }
}
/* 计算器复位，清零变量值，清除屏幕显示 */
/ R$ b) e/ I6 H+ h, X2 N9 dvoid Reset()
& w- h/ P$ d9 [: Z6 p: L& Z# s$ J8 N{
    num1 = 0;
    num2 = 0;
6 y( S5 s1 M$ u  i, p% e    step = 0;
6 C- C- G& K7 j    LcdFullClear();
}
/* 数字键动作函数，n-按键输入的数值 */
void NumKeyAction(unsigned char n)
6 K: U* k8 Z; K3 c; F7 }" m{
, [1 w3 l5 v2 z/ k: h3 Q7 B1 z4 t    unsigned char len;
    unsigned char str[12];

! V4 I: x( f! G( V! Q$ K6 K    if (step > 1)  //如计算已完成，则重新开始新的计算
) s5 B2 W! V& Q7 l2 d    {
        Reset();
    }
    if (step == 0)  //输入第一操作数
    {
, {; I4 [$ h/ P: u; ~' w2 O; U/ X        num1 = num1*10 + n;             //输入数值累加到原操作数上
        len = LongToString(str, num1);  //新数值转换为字符串
        LcdShowStr(16-len, 1, str);     //显示到液晶第二行上
    }
7 U9 P" _( ^6 e, k- v8 v& p    else            //输入第二操作数
    {
        num2 = num2*10 + n;             //输入数值累加到原操作数上
        len = LongToString(str, num2);  //新数值转换为字符串
* j" }; [( X6 r& ~) _( f        LcdShowStr(16-len, 1, str);     //显示到液晶第二行上
    }
}
. B( r9 n- Z2 u& \; ^; b" P* U/* 运算符按键动作函数，运算符类型type */
void OprtKeyAction(unsigned char type)
{
    unsigned char len;
$ e1 n6 N4 z8 K% w    unsigned char str[12];
6 o( t/ |+ Q+ M7 v0 K8 E9 i
    if (step == 0)  //第二操作数尚未输入时响应，即不支持连续操作
! k- t7 t8 p* \  a4 [& J    {
        len = LongToString(str, num1); //第一操作数转换为字符串
! W' O9 X  j& z9 L+ p' X7 h0 |# g0 o        LcdAreaClear(0, 0, 16-len);    //清除第一行左边的字符位
( }# @# V' e) Z7 {# M6 e        LcdShowStr(16-len, 0, str);    //字符串靠右显示在第一行
        ShowOprt(1, type);             //在第二行显示操作符
        LcdAreaClear(1, 1, 14);        //清除第二行中间的字符位
        LcdShowStr(15, 1, "0");        //在第二行最右端显示0
0 O$ P0 K: T" ]) X- c        oprt = type;                   //记录操作类型
9 y6 ^" \* [8 G1 c, Z        step = 1;
7 e$ X2 Q: \+ y8 W- P    }
}
/* 计算结果函数 */
4 l7 @, D6 F* p& O. evoid GetResult()
{
0 D  t+ k1 n/ C$ m8 f; n    unsigned char len;
    unsigned char str[12];
2 ^9 n; F. @- C6 d7 b  H0 x
    if (step == 1) //第二操作数已输入时才执行计算
9 [" m, F$ j# c    {
/ n& [6 i; e5 i3 C0 M7 l  `        step = 2;
        switch (oprt)  //根据运算符类型计算结果，未考虑溢出问题
' C# {1 k. A8 x  @        {
* m5 W2 A5 F' u# i$ n* p            case 0: result = num1 + num2; break;
            case 1: result = num1 - num2; break;
            case 2: result = num1 * num2; break;
% _$ m% K* N) l            case 3: result = num1 / num2; break;
+ D0 ^$ ~% q/ F( l  J            default: break;
1 c/ e% p! H2 z/ ~% k! x. ?        }
        len = LongToString(str, num2);  //原第二操作数和运算符显示到第一行
        ShowOprt(0, oprt);
8 A- [- `& n2 S        LcdAreaClear(1, 0, 16-1-len);
1 I. w7 Q7 k. X" v8 B4 R        LcdShowStr(16-len, 0, str);
% ?- Q) c- V7 L/ K6 m7 J        len = LongToString(str, result);  //计算结果和等号显示在第二行
! j3 Z. y% ?. S' w        LcdShowStr(0, 1, "=");
        LcdAreaClear(1, 1, 16-1-len);
; l+ @* _% P& L, {        LcdShowStr(16-len, 1, str);
    }
}
/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
$ ^9 B9 l7 u& u4 Z6 o( avoid KeyAction(unsigned char keycode)
: J9 |! g( w% D4 W8 J{
6 f* V# v1 V7 t9 O7 _1 Y    if  ((keycode>='0') && (keycode<='9'))  //输入字符
' }, Q: z* n. I    {
& i1 j7 i- V7 X6 ^$ |        NumKeyAction(keycode - '0');
" w8 E4 l. B7 r3 G% k    }
6 x+ u1 _3 P# g    else if (keycode == 0x26)  //向上键，+
    {
        OprtKeyAction(0);
  d; y8 c4 ]; `- ]3 @$ s2 [    }
# {$ V) B+ ^2 ]3 Z9 g. z    else if (keycode == 0x28)  //向下键，-
6 j% s+ \  \+ L  H/ B    {
        OprtKeyAction(1);
: X$ l& E% K4 _9 w$ c) z    }
* c4 A4 K* i) t+ S. o8 r% g    else if (keycode == 0x25)  //向左键，*
/ h3 s2 d& b7 ]  Z7 p3 Z( j    {
* |) P+ ]; y+ M4 m3 ]: m        OprtKeyAction(2);
+ n  J% i* T$ Q    }
1 M$ W, y3 f( N  M0 C" ?    else if (keycode == 0x27)  //向右键，÷
8 S4 w" g0 E& n  ^2 ^# H6 T% C    {
        OprtKeyAction(3);
3 g/ V& J: K1 U( d% g    }
    else if (keycode == 0x0D)  //回车键，计算结果
3 b" ]6 x4 d, g, r    {
        GetResult();
    }
( n2 Z# Z; M3 x9 R8 `# y    else if (keycode == 0x1B)  //Esc键，清除
. |/ s7 i6 c, v1 i2 y+ X9 ?6 B/ Z    {
! O' b  m* n7 t        Reset();
; Q' J, L) o5 L        LcdShowStr(15, 1, "0");
    }
}
/* 配置并启动T0，ms-T0定时时间 */
void ConfigTimer0(unsigned int ms)
{
: d- S' W* Q  I1 W8 K    unsigned long tmp;  //临时变量

    tmp = 11059200 / 12;      //定时器计数频率
    tmp = (tmp * ms) / 1000;  //计算所需的计数值
    tmp = 65536 - tmp;        //计算定时器重载值
8 @. F% G7 O$ Q. H    tmp = tmp + 28;           //补偿中断响应延时造成的误差
- }- ?8 v, v  N, g    T0RH = (unsigned char)(tmp>>8);  //定时器重载值拆分为高低字节
    T0RL = (unsigned char)tmp;
  M/ f* M8 j) V- y- \/ l    TMOD &= 0xF0;   //清零T0的控制位
: _# _" D3 G" j  U* \/ z    TMOD |= 0x01;   //配置T0为模式1
; ?8 R3 U0 X1 b. j    TH0 = T0RH;     //加载T0重载值
7 W: W2 T$ s5 y9 L" A  M& \3 h/ T    TL0 = T0RL;
- `& [4 b- m6 F7 A. ]7 z: `* O7 v$ e    ET0 = 1;        //使能T0中断
    TR0 = 1;        //启动T0
8 G# H3 P' ~) U! o}
( {+ {" s- _  @9 f: I/* T0中断服务函数，执行按键扫描 */
void InterruptTimer0() interrupt 1
  A3 K+ g$ e  M0 _; w3 @  ~{
    TH0 = T0RH;  //重新加载重载值
    TL0 = T0RL;
" T8 {1 M3 D9 A7 E, i$ w5 N2 C    KeyScan();   //按键扫描
}
$ Z3 R  Q  m$ J  M# e

sunygd

谢谢分享