基于1602液晶的简易计算器

wu68aq

基于1602液晶的简易计算器
) v0 G2 l4 z: u2 [
9 W; ^1 q" E& j. T) _( u
#include <reg52.h>

unsigned char step = 0;  //操作步骤
+ j: k5 }% I: x$ u* T# v4 h* @- u/ ]unsigned char oprt = 0;  //运算类型
signed long num1 = 0;    //操作数1
4 g; [9 s! T: ~* ?signed long num2 = 0;    //操作数2
signed long result = 0;  //运算结果
unsigned char T0RH = 0;  //T0重载值的高字节
; F1 i# r/ p2 K/ F: ^unsigned char T0RL = 0;  //T0重载值的低字节
) m) a, e1 O" r
- n  @; m/ Y3 i1 Jvoid ConfigTimer0(unsigned int ms);
extern void KeyScan();
" c6 ]5 O1 T- s" ]9 S& Rextern void KeyDriver();
extern void InitLcd1602();
- O1 s+ M# k) J& Rextern void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
extern void LcdAreaClear(unsigned char x, unsigned char y, unsigned char len);
extern void LcdFullClear();
* s+ B3 u9 w4 S0 t( l
void main()
{
; `1 q$ k' V; W# i  n6 ]) }. v+ ?    EA = 1;           //开总中断
2 c, c) O2 h, g9 B# J    ConfigTimer0(1);  //配置T0定时1ms
+ Y5 D0 l6 s: [% g  c        InitLcd1602();    //初始化液晶
    LcdShowStr(15, 1, "0");  //初始显示一个数字0

$ {1 |4 I2 e8 @) D! `    while (1)
; V( E/ q/ i5 K) `* a0 ]- n1 n1 b    {
        KeyDriver();  //调用按键驱动
    }
}
$ d2 Z) P$ P6 R0 X! L# L! k$ _3 h2 W2 i/* 长整型数转换为字符串，str-字符串指针，dat-待转换数，返回值-字符串长度 */
9 C' W3 Z, ^8 s" ^. {  @unsigned char LongToString(unsigned char *str, signed long dat)
1 h! V8 x" P& ^( t7 S0 K{
    signed char i = 0;
    unsigned char len = 0;
    unsigned char buf[12];
# A% V# q( g) _) O- d% ~, l' I
    if (dat < 0)  //如果为负数，首先取绝对值，并在指针上添加负号
& S5 \% U2 ?& V; y) S, ]    {
        dat = -dat;
        *str++ = '-';
        len++;
    }
    do {          //先转换为低位在前的十进制数组
) t0 ^9 l+ h1 o4 Q" ]8 C2 y6 o0 D        buf[i++] = dat % 10;
        dat /= 10;
4 o# k( E+ V* ~& m' K$ F( ~    } while (dat > 0);
    len += i;     //i最后的值就是有效字符的个数
2 ^  A- l& F* J$ M! H8 r    while (i-- > 0)   //将数组值转换为ASCII码反向拷贝到接收指针上
0 y1 v% F$ d6 J  ?    {
3 c, F9 A7 K) p- ?: t/ x& m0 a        *str++ = buf + '0';
" M4 @0 ]. w- S- X, v6 M; r    }
    *str = '\0';  //添加字符串结束符

. \, H( \+ q* C5 h$ A    return len;   //返回字符串长度
}
/* 显示运算符，显示位置y，运算符类型type */
void ShowOprt(unsigned char y, unsigned char type)
  Y' w3 h5 j) G2 [* s- K{
, B. V1 c7 l+ p" g5 I    switch (type)
' \% b# \) h) y( f, K. g- ~( h- z' K    {
( @4 A1 K) |9 y/ `- t        case 0: LcdShowStr(0, y, "+"); break;  //0代表+
        case 1: LcdShowStr(0, y, "-"); break;  //1代表-
/ Q% _) Z7 k9 P0 F* B& I        case 2: LcdShowStr(0, y, "*"); break;  //2代表*
" n+ X$ E) t" j# m! }1 w3 S        case 3: LcdShowStr(0, y, "/"); break;  //3代表/
) @+ {9 v4 Z" ]1 z+ P6 Y: D6 D        default: break;
    }
2 t' n* x) ~- |8 I" C% L# s}
/* 计算器复位，清零变量值，清除屏幕显示 */
void Reset()
{
    num1 = 0;
3 b) _8 I& r9 Y8 F5 L7 _    num2 = 0;
    step = 0;
$ T% C! x2 y5 M+ A    LcdFullClear();
- u. R; |3 h/ t' Y2 i' H}
' y; s6 X  [: Y! n& O/ n, Z# Y/* 数字键动作函数，n-按键输入的数值 */
void NumKeyAction(unsigned char n)
; b3 h3 n7 X- Q# [; f{
    unsigned char len;
    unsigned char str[12];
  x  R  [6 \" |4 V! d8 m4 @4 W) ^
1 C9 S5 W: u+ E2 S  U3 k    if (step > 1)  //如计算已完成，则重新开始新的计算
    {
        Reset();
    }
; H" U: U# y  v6 O  s4 F3 y' p    if (step == 0)  //输入第一操作数
    {
        num1 = num1*10 + n;             //输入数值累加到原操作数上
: o, G  ^7 J; s        len = LongToString(str, num1);  //新数值转换为字符串
        LcdShowStr(16-len, 1, str);     //显示到液晶第二行上
8 {8 P$ Z/ K# u6 g2 G    }
    else            //输入第二操作数
    {
        num2 = num2*10 + n;             //输入数值累加到原操作数上
6 ^3 q' l) m3 y. q        len = LongToString(str, num2);  //新数值转换为字符串
7 u( w$ A) v/ A1 k4 @) i8 [: h        LcdShowStr(16-len, 1, str);     //显示到液晶第二行上
9 Q* b) ~( p" H& C    }
}
/* 运算符按键动作函数，运算符类型type */
void OprtKeyAction(unsigned char type)
{
; J9 |; m3 d) g7 ^7 b+ C# n    unsigned char len;
    unsigned char str[12];
! V6 Z  o& j  `4 Z, j
5 R* R  Y4 r" N; ]3 z' r    if (step == 0)  //第二操作数尚未输入时响应，即不支持连续操作
    {
        len = LongToString(str, num1); //第一操作数转换为字符串
" ]* ?; q) n6 |        LcdAreaClear(0, 0, 16-len);    //清除第一行左边的字符位
$ Z. ~2 \: W# }* F5 S& |        LcdShowStr(16-len, 0, str);    //字符串靠右显示在第一行
        ShowOprt(1, type);             //在第二行显示操作符
        LcdAreaClear(1, 1, 14);        //清除第二行中间的字符位
        LcdShowStr(15, 1, "0");        //在第二行最右端显示0
  ~: \/ K% o5 V. y3 L1 m7 M& [        oprt = type;                   //记录操作类型
. o. I5 I. ]- F/ t& c  U        step = 1;
7 B; N$ ?" d" n3 N9 r0 T: }    }
}
/* 计算结果函数 */
void GetResult()
# h/ h9 [7 a! B4 E# k9 [3 a: r{
    unsigned char len;
    unsigned char str[12];
5 v: V4 M( N5 M: l! j& L4 d
" {# c* C8 |+ Q/ C$ m    if (step == 1) //第二操作数已输入时才执行计算
    {
2 p# S, L& c* F" A        step = 2;
        switch (oprt)  //根据运算符类型计算结果，未考虑溢出问题
! _3 d2 ~) Y) e- K; F. N. u        {
. w2 l$ s" s7 R! V" v/ a            case 0: result = num1 + num2; break;
+ x# v5 o  s7 h% i! O            case 1: result = num1 - num2; break;
& _0 d6 I, J7 ^( }0 v! o            case 2: result = num1 * num2; break;
  b. R( }  I1 Q* l- t            case 3: result = num1 / num2; break;
            default: break;
        }
% H) v# J& C2 B2 _2 q7 v# {) a        len = LongToString(str, num2);  //原第二操作数和运算符显示到第一行
9 J8 f3 [: D& \7 {        ShowOprt(0, oprt);
) S0 H0 i! P: u* b4 p        LcdAreaClear(1, 0, 16-1-len);
        LcdShowStr(16-len, 0, str);
4 L" l4 O! ]$ x8 Q: T        len = LongToString(str, result);  //计算结果和等号显示在第二行
        LcdShowStr(0, 1, "=");
' K# F+ V5 a, w* P' r1 ?" s        LcdAreaClear(1, 1, 16-1-len);
# l$ a: @2 N- V  r        LcdShowStr(16-len, 1, str);
    }
3 D% e1 n0 V; Y}
6 {( U8 ]) k/ b  t  ?& I' |) n4 m* {/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
void KeyAction(unsigned char keycode)
{
0 i6 E6 X4 C) a" e    if  ((keycode>='0') && (keycode<='9'))  //输入字符
    {
2 I- G$ _# ]2 C" M  S        NumKeyAction(keycode - '0');
    }
5 o% g2 Q: j$ B& \3 d# W1 |    else if (keycode == 0x26)  //向上键，+
1 V! a* E# s  l7 T7 L8 |# D    {
        OprtKeyAction(0);
4 f( i5 W( l; `, H! v/ x! C! R    }
/ l5 S7 ?; c- F+ n    else if (keycode == 0x28)  //向下键，-
    {
0 ~& h5 i5 D+ o        OprtKeyAction(1);
- ^7 Z4 O! z, [# i+ N: }" |    }
    else if (keycode == 0x25)  //向左键，*
' [3 q$ o1 K$ H8 I. u    {
        OprtKeyAction(2);
6 T0 N' V- Q4 C5 x/ P; Z    }
    else if (keycode == 0x27)  //向右键，÷
- e% x+ U# Y- X$ z* _5 _    {
        OprtKeyAction(3);
    }
0 z  x3 _4 W: |* K* D( B    else if (keycode == 0x0D)  //回车键，计算结果
    {
& _4 r2 P4 y! E6 X- z, i8 p1 m( `        GetResult();
    }
    else if (keycode == 0x1B)  //Esc键，清除
) W& \/ o6 f; G4 v    {
; H1 s. E6 Q, K# v        Reset();
6 u$ }- m8 F: d6 [. k9 q        LcdShowStr(15, 1, "0");
0 u: I5 [2 ?9 w1 }    }
}
( q7 ]; [& p3 M5 A  \5 {1 h/* 配置并启动T0，ms-T0定时时间 */
% `3 Y$ K  _6 hvoid ConfigTimer0(unsigned int ms)
5 K+ [  N! F1 |+ i$ h! R3 d{
    unsigned long tmp;  //临时变量

% T" X. P, G/ b' y: p$ W    tmp = 11059200 / 12;      //定时器计数频率
    tmp = (tmp * ms) / 1000;  //计算所需的计数值
7 J% Z8 r# w' o/ {- O# F    tmp = 65536 - tmp;        //计算定时器重载值
2 Y) M3 D% V6 {/ Y# I    tmp = tmp + 28;           //补偿中断响应延时造成的误差
8 ]. a1 ~" B6 d    T0RH = (unsigned char)(tmp>>8);  //定时器重载值拆分为高低字节
    T0RL = (unsigned char)tmp;
: W( c3 B/ b, O; F' l5 N( K& r+ ]3 Q# R    TMOD &= 0xF0;   //清零T0的控制位
- @$ o0 p+ i$ B' X) ]5 B2 H    TMOD |= 0x01;   //配置T0为模式1
2 J& j* n! [; }; f% i; Q    TH0 = T0RH;     //加载T0重载值
  Q4 |3 K+ w( k) l& L1 e# M    TL0 = T0RL;
. b  t+ u' }2 ~. S# d1 r) C    ET0 = 1;        //使能T0中断
) ?. S/ e5 Q: c  F) E8 H    TR0 = 1;        //启动T0
}
/* T0中断服务函数，执行按键扫描 */
" J; S  r1 O% N- D# B2 x! E, e% mvoid InterruptTimer0() interrupt 1
: E" i9 S; E0 S6 o' z1 b6 f- K{
    TH0 = T0RH;  //重新加载重载值
3 x( T8 m% U. S) H* B- p    TL0 = T0RL;
9 x$ e  C6 p/ b- t    KeyScan();   //按键扫描
' k- |) X* g/ Z7 C7 R; D* a' }}

sunygd

谢谢分享