51单片机简易计算器 (可算小数)

基于51单片机的简易计算器设计报告

基于51单片机的简易计算器设计【摘要】单片机的出现是计算机制造技术高速发展的产物，它是嵌入式控制系统的核心，如今，它已广泛的应用到我们生活的各个领域，电子、科技、通信、汽车、工业等。

本设计是基于51系列单片机来进行的数字计算器系统设计，可以完成计算器的键盘输入，进行加、减、乘、除八位数范围内的基本四则运算，并在LCD上显示相应的结果。

设计电路采用AT89S51单片机为主要控制电路，利用4*4矩阵键盘作为计算器的数字以及运算符的输入。

显示采用字符LCD静态显示。

软件方面使用C语言编程，并用开发板制作并演示。

【关键词】计算器，单片机，LCD，矩阵键盘AbstractThe emergence of computer chip manufacturing technology, rapid development of the product, which is the core of embedded control systems, and now, it has been widely applied to all areas of our lives, electronics, technology, communications, automotive, industrial and so on. The design is based on the 51 computers for digital system design calculator, you can complete the calculator keyboard, to add, subtract, multiply, and divide within the scope of the basic six-digit arithmetic, and the corresponding results on the LCD display . AT89C51 microcontroller circuit design as the main control circuit, use MM74C922 4 * 4 keypad as a calculator scan IC to read keyboard input. Character LCD display with a static display. Software using the C programming language, and use PROTUES simulation.Keywords：calculator，MCU,LCD,Matrix keyboard目录摘要 (1)一、系统总体设计 (1)1.1设计概述 (1)1.2设计思路 (1)1.3系统总体模块图： (2)1.4系统方案 (2)二、硬件系统设计 (2)2.1主控芯片A T89S52单片机 (2)2.2 LCD1602液晶显示屏 (3)2.3键盘接口电路 (4)2.4 清零、音乐开关、开方和多次方运算功能模块 (5)2.5电源模块设计 (6)三、软件系统设计 (6)3.1总体设计 (6)3.2子程序设计 (8)3.2.1液晶显示程序设计 (8)3.2.2 矩阵键盘扫描程序设计 (8)3.2.3 AC清零程序设计 (9)3.2.4 声音开关子程序设计 (10)四、系统功能测试 (10)4.1总体实物测试 (10)4.2 各项功能测试 (11)4.3 多次测试 (11)五、总结 (12)六、结束语 (12)参考文献 (13)附录 (14)附1：计算器原理图 (14)附2：主程序清单 (14)附3：键盘扫描子程序 (21)附4：LCD1602显示程序 (24)附5：LCD1602显示字符表 (28)附6： LCD接口信号说明 (29)附7： LCD写操作时序图 (29)一、系统总体设计1.1设计概述本设计使用AT89S52单片机作为主控芯片，通过计算机键盘进行数据输入，进行相应的加、减、乘、除的运算，并在LCD上显示相应的结果，主要功能特点如下：（1）LCD的第一行显示运算式子，第二行显示运算结果，在任何时候按下AC清零按键时候，都必须退出当前计算，返回初始状态，等下新的一次运算。

基于51单片机的简易计算器

基于51单片机的简易计算器51单片机是一种广泛应用于嵌入式系统中的常用微控制器。

我们可以利用51单片机的强大功能和丰富的外设资源，设计一个简易计算器。

这个计算器可以进行基本的加减乘除运算，并且具备显示结果的功能。

首先，我们需要准备一块51单片机开发板，一块1602液晶显示屏模块，以及一些按键开关和电阻。

我们可以将运算器主要分为以下几个模块：数码管显示模块、键盘输入模块、运算模块和存储模块。

数码管显示模块：我们使用1602液晶显示屏模块来显示计算器的结果。

我们可以通过51单片机的IO口，将计算结果发送给液晶显示屏模块，实现结果的显示。

键盘输入模块：我们可以使用几个按键开关来实现数字和运算符的输入。

通过对按键的检测，我们可以将用户输入的数字和运算符转化为字符形式，并保存到内存中。

运算模块：我们需要根据用户输入的数字和运算符，进行相应的运算。

我们可以使用栈来实现这个功能。

栈是一种常用的数据结构，具有"先进后出"的特点。

我们可以将用户输入的数字和运算符按照一定的规则入栈，然后按照相应的顺序进行出栈和运算。

最后将结果保存到内存中。

存储模块：我们可以使用内部RAM来保存运算结果。

51单片机的内部RAM具有一定的存储能力，可以满足我们的基本需求。

在编写程序时，我们可以使用汇编语言或者C语言。

通过合理的编程，我们可以实现计算器的各项功能。

总结一下，基于51单片机的简易计算器主要包括数码管显示模块、键盘输入模块、运算模块和存储模块。

我们可以通过合理的编程，将这些模块相互配合，实现一个功能完善的计算器。

这个计算器不仅可以进行基本的加减乘除运算，还可以显示结果，方便用户进行计算。

51单片机简易计算器论文

51单片机简易计算器论文摘要：本篇论文基于51单片机设计并实现了一款简易计算器。

该计算器具有基本的加、减、乘、除四则运算功能，并支持小数点运算和括号运算。

通过设计合理的菜单界面和使用者友好的操作方式，使得计算器更加易用。

本文介绍了计算器的硬件设计和软件设计，并对其进行了功能测试和性能评估。

实验结果表明，该计算器具有较好的计算精度和运算速度，能够满足一般计算需求。

关键词：51单片机，简易计算器，四则运算，菜单界面1.引言随着计算机技术的发展和普及，计算器作为一种便携式计算工具得到了广泛应用。

无论是学生、工程师还是商务人士，都离不开计算器的帮助。

本文旨在设计一款基于51单片机的简易计算器，以满足用户日常计算需求。

2.硬件设计本文采用51单片机作为计算器的主控芯片，搭配LCD显示屏、按键和外部存储器等外围电路。

通过合理的电路连接和引脚设置，实现计算器的功能。

3.软件设计3.1主程序设计计算器的主程序采用C语言编写。

主程序主要包括菜单界面设计、按键响应和运算处理等功能。

通过LCD显示屏输出菜单选项，并通过按键输入执行相应的功能。

3.2加法运算加法运算是计算器最基本的功能之一、在软件设计中，通过读取按键输入的数值，并使用加法运算符将数值累加，最后显示结果。

3.3减法运算减法运算与加法运算类似，通过读取按键输入的数值，并使用减法运算符将数值相减，最后显示结果。

3.4乘法运算乘法运算是计算器的扩展功能之一、在软件设计中，定义乘法运算函数，通过读取按键输入的数值，并使用乘法运算符将数值相乘，最后显示结果。

3.5除法运算除法运算也是计算器的扩展功能之一、在软件设计中，定义除法运算函数，通过读取按键输入的数值，并使用除法运算符将数值相除，最后显示结果。

3.6小数点运算和括号运算为了提高计算器的实用性，本文还添加了小数点运算和括号运算功能。

在软件设计中，通过读取按键输入的数值，并进行相应的运算处理和显示结果。

4.功能测试和性能评估为了验证计算器的功能和性能，本文进行了一系列的功能测试和性能评估。

51单片机双显示小数计算器

自己制作的单片机程序，既可以用数码管显示，也可以用1602显示,且可以显示小数~~~#include<reg52.h>#include <math.h>#define uint unsigned int#define uchar unsigned charuchar code tabledu[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71 };uchar code tabledu1[16]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef,0xf7,0xfc,0xb9,0xde,0xf9,0xf1}; uchar code tablewe[8]={0,1,2,3,4,5,6,7};uchar code table[]="0123456789";uchar dispbuf[4]={0,0,0,0};float dispbuf1[4]={0,0,0,0};uchar aa,temp,key,keypos,flag,fuhao,a0,b0,c0,d0,e0,flag1,flag2,a1,b1,c1,d1;float num1,num2,num3,flag3=1;int num5,num6,num7,n2;long n1;sbit RS=P2^5;sbit RW=P2^6;sbit E=P2^7;sbit key1=P3^2;sbit key2=P3^3;sbit key3=P3^4;void keyscan1();void ukeyscan1();void delay(uint z){uint x,y;for(x=z;x>0;x--)for(y=110;y>0;y--);}void change(uchar *p,uchar count){count=4-count;while(count<3){*(p+count)=*(p+count+1);count++;}}float jisuan(float x,char y,float z){float m;if(y==10)m=x+z;if(y==11)m=x-z;if(y==12)m=x*z;if(y==13)m=x/z;return m;}bit Busy(void){bit busy_flag = 0;RS = 0;RW = 1;E = 1;delay(1);busy_flag = (bit)(P0 & 0x80);E = 0;return busy_flag;}void wcmd(uchar del){while(Busy());RS=0;RW=0;E=0;P0=del;delay(1);E=1;delay(1);E=0;}void wdata(uchar del){while(Busy());RS=1;RW=0;E=0;P0=del;delay(1);E=1;delay(1);E=0;}void keyscan(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;break;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;break;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;break;case 0xbb:key=10;break;case 0x7b:key=11;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){fuhao=key;num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;while(1){keyscan1();if(key==15)break;}}if(key==15){dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;}}}P1=0xf7;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xe7:key=12;break;case 0xd7:key=13;break;case 0xb7:key=14;break;case 0x77:key=15;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){fuhao=key;num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;while(1){keyscan1();if(key==15)break;}}if(key==15){dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;}}}if(keypos==4)keypos=0;if(key1==0){delay(5);if(key1==0){while(key1==0);flag2=1;keypos=0;}}if(key2==0){delay(5);if(key2==0){while(key2==0);num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;num3=sqrt(num1);num6=num3;num5=(num3-num6)*10000;dispbuf[0]=num6/1000;dispbuf[1]=num6%1000/100;dispbuf[2]=num6%1000%100/10;dispbuf[3]=num6%1000%100%10;dispbuf1[0]=num5/1000;dispbuf1[1]=num5%1000/100;dispbuf1[2]=num5%1000%100/10;dispbuf1[3]=num5%1000%100%10;}}}void keyscan1(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;。

51单片机简易计算器设计报告

51单片机简易计算器设计报告
本文将介绍51单片机简易计算器的设计报告。

该计算器通过
16位的LCD显示屏实现了基本计算功能，包括加、减、乘、除、取反、开方等。

1. 硬件设计
该计算器的核心部件是STC89C52单片机。

STC89C52是一种
高性能、低功耗的8位单片机，拥有8KB的Flash程序存储器和128字节的内部RAM，可提供多种功能和通讯接口。

通过
I/O口与LCD模块通讯，实现输出功能。

该计算器使用16位的LCD显示屏，显示范围为-99.99~99.99，共有6个数字位。

显示屏使用了ST7920控制器，可通过串行、并行等多种方式控制。

2. 软件设计
该计算器的软件设计主要包括三部分：键盘扫描，计算功能和LCD显示。

键盘扫描：该计算器采用4x5矩阵键盘，通过程序对键盘进行扫描，实现对不同按键的检测。

计算功能：该计算器可以实现基本的四则运算、取反、开方等功能。

对于四则运算，通过栈来实现计算，将运算符压入栈中，然后将操作数从栈中取出进行计算。

LCD显示：该计算器使用16位的LCD显示屏，通过程序控制数据和命令的传输，将计算结果显示在LCD屏幕上。

3. 总结
通过对51单片机简易计算器的设计报告，可以看出该计算器实现了基本的计算功能，通过硬件设计和软件设计相结合，将计算器的功能实现得十分完整。

该计算器的设计初步掌握了51单片机的应用，有助于后续项目的开展。

基于51单片机的简易计算器c程序

/*...............菜鸟一枚，不好勿喷→_→............................【简易计算器的功能简介】【时间紧，先做个简易的吧，复杂的算法太难，没那么多时间写【现在也不太会→_→】，以后再研究→_→】此程序是完全基于开发板的，可在板子上直接测试【程序跑飞的概率比较大，还不太明白是哪的问题】可实现总数小于等于九位【long int】的数字的加减乘除运算【每次只能进行一项】，可清楚修改输入的数据，由于键盘等因素显示【4X4】，没有小数点键，故无法直接进行小数运算，进行除法运算时，小数点后最多可保留6位，第7位进行四舍五入。

显示器采用1602，输入或修改时开光标并闪烁，输入数据超出9位，有警告提示，加上运算符总的输入不超过15位【超过10输入逻辑已经错误】。

显示结果时关光标【重复按下时结果不变】，显示结果后，也可对输入端进行修改，按下等于键再次显示结果。

2015/1 qq:1036894850 */#include"reg52.h"#include"stdio.h"#define uchar unsigned charsbit rs=P2^4;//lcd的控制线口sbit rw=P2^5;sbit ep=P2^6;uchar ip[15];//存输入的数据,15位【理论上10位就够了】'$'记运算符'*'记为负号uchar sign;//存运算符int k=0,equ=0,sk=0,ksk=0,sg=0;void write_data(uchar dat); //给1602写数据void write_com(uchar com);void lcdinit();void delay(int z);void warn();void key_deal(uchar key);void sdeal(uchar i);void key_sub_deal();void key_equ_deal();void key_del_deal();uchar scankey();void main(){uchar key=0xff;lcdinit(); //1602初始化，结果输出位显示0，数据输入位光标闪烁。

基于C51单片机的简易计算器设计

基于单片机的简易设计原理专业：通信专业班级：通信1班姓名：刘民学号：1304041127摘要：按下键盘，通过键盘扫描程序，在LCD液晶显示屏上显示按键的操作过程，最终显示计算结果，实现计算器的基本功能。

本文详细介绍LCD显示屏、矩阵键盘与C51单片机接口的应用，并介绍如何通过C51单片机实现计算器的算法。

关键字：C51单片机，键盘，LCD液晶，计算器一、设计任务：本次实验是要以51系列单片机为核心实现一个简易计算器，它的结构简单，外部主要由4*4矩阵键盘和一个液晶显示屏构成，内部由一块STC90C51单片机构成，通过软件编程可实现简单加、减、乘、除、清除结果。

实现对计算器的设计，具体设计如下：1、采用6位显示，最大显示值为“999999”，设计16个按键的矩阵键盘，按键包括‘0～9’、‘+’、‘-’、‘*’、‘/’、‘=’、‘C’。

2、加减法做四字节运算；乘法做双字节运算；除法被除数为四字节，除数为两字节。

3、当运算结果超出显示范围时，显示ERROR！。

4、上述运算输入值均为整数，当结果带有小数时，可以采用四舍五入方式处理，也可以带小数显示。

二、方案论证经分析，计算器电路包括三个部分：显示电路、、4*4键扫描电路、单片机微控制电路。

具体如下：⒈）LCD显示电路LCD1602作为一个成熟的产品，使用简单，模式固定，便于移植到各种类型的程序，但是初学者往往要注意结合LCD本身的时序图来完善初始化程序。

又以其微功耗、体积小、显示内容丰富、超薄轻巧的诸多优点，故采用LCD.⒉）4*4键盘扫描电路(中断式，扫描式，反转式)用户设计行列键盘接口，一般常采用3 种方法读取键值。

一种是中断式，外两种是扫描法和反转法。

扫描法：对键盘上的某一行送低电平，其他行及列全为高电平，然后读取列值，检查各列线点评的变化，如果某列线电平为低电平，就可以确定此行此列交叉点处的按键被按下，采用延时去抖动。

⒊）单片机微控制电路微控制电路就是以AT89C51为核心的控制核心，主要注意晶振电路的接法和复位电路的接法。

基于51单片机的简易计算器设计

2013 - 2014 学年＿一＿学期山东科技大学电工电子实验教学中心创新性实验研究报告实验项目名称＿＿基于51单片机的简易计算器设计＿2013 年12 月27 日四、实验内容2、实验内容（一）、总体硬件设计本设计选用AT89C52单片机为主控单元。

显示部分：采用六位LED动态数码管显示。

按键部分：采用2*8键盘；利用2*8的键盘扫描子程序，读取输入的键值。

（二）、键盘接口电路计算器输入数字和其他功能按键要用到很多按键，如果采用独立按键的方式，在这种情况下，编程会很简单，但是会占用大量的I/O 口资源，因此在很多情况下都不采用这种方式，而是采用矩阵键盘的方案。

矩阵键盘采用两条I/O 线作为行线，八条I/O 线作为列线组成键盘，在行线和列线的每个交叉点上设置一个按键。

这样键盘上按键的个数就为2×8个。

这种行列式键盘结构能有效地提高单片机系统中I/O 口的利用率。

矩阵键盘的工作原理：计算器的键盘布局如图2所示：一般有16个键组成，在单片机中正好可以用一个P口和另一个P口的两个管脚实现16个按键功能，这种形式在单片机系统中也最常用。

矩阵键盘布局图：矩阵键盘内部电路图如下图所示：（三）、LED显示模块本设计采用LED数码显示来显示输出数据。

通过D0-D7引脚向LED写指令字或写数据以使LED实现不同的功能或显示相应数据。

（四）运算模块（单片机控制）MCS-51 单片机是在一块芯片中集成了CPU、RAM、ROM、定时器/计数器和多功能I/O等一台计算机所需要的基本功能部件。

如果按功能划分，它由如下功能部件组成，即微处理器（CPU）、数据存储器（RAM）、程序存储器（ROM/EPROM）、并行I/O 口、串行口、定时器/计数器、中断系统及特殊功能寄存器（SFR）。

单片机是靠程序运行的，并且可以修改。

通过不同的程序实现不同的功能，尤其是特殊的独特的一些功能，通过使用单片机编写的程序可以实现高智能，高效率，以及高可靠性！因此我们采用单片机作为计算器的主要功能部件，可以很快地实现运算功能。

简单计算器(51单片机程序)

{
for(i=0;i<8;i++)
{
con[i]=0;
tem[i]=0;
}
count=-1;
flag=0;
} break;
case 0x7b://equal
{
switch(flag)
count++;
switch(temp)
{
case 0xed:
{ num=4;
if(count<8)
con[count]=num;
} break;
case 0xdd:
{ num=5;
if(count<8)
}
for(j=0;j<8;j++)
{
con[j]=0;
tem[j]=0;
} break;
case 0xde:
{ num=1;
if(count<8)
con[count]=num;
} break;
case 0xbe:
{ num=2;
if(count<8)
con[count]=num;
for(i=0;i<8;i++)
{
tem1[i]=tem[i];
}
for(j=0;j<8;j++)
{
con[j]=0;
tem[j]=0;
}
count=-1;
} break;
}
}
}
P1=0xfd;
temp=P1;
temp=temp&0xf0;

51单片机双显示小数计算器

自己制作的单片机程序，既可以用数码管显示，也可以用1602显示,且可以显示小数~~~#include<reg52.h>#include <math.h>#define uint unsigned int#define uchar unsigned charuchar code tabledu[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71 };uchar code tabledu1[16]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef,0xf7,0xfc,0xb9,0xde,0xf9,0xf1}; uchar code tablewe[8]={0,1,2,3,4,5,6,7};uchar code table[]="0123456789";uchardispbuf[4]={0,0,0,0};float dispbuf1[4]={0,0,0,0};uchar aa,temp,key,keypos,flag,fuhao,a0,b0,c0,d0,e0,flag1,flag2,a1,b1,c1,d1;float num1,num2,num3,flag3=1;int num5,num6,num7,n2;long n1;sbit RS=P2^5;sbit RW=P2^6;sbit E=P2^7;sbit key1=P3^2;sbit key2=P3^3;sbit key3=P3^4;void keyscan1();void ukeyscan1();void delay(uint z){uintx,y;for(x=z;x>0;x--)for(y=110;y>0;y--);}void change(uchar *p,uchar count){count=4-count;while(count<3){*(p+count)=*(p+count+1);count++;}}float jisuan(float x,chary,float z){float m;if(y==10)m=x+z;if(y==11)m=x-z;if(y==12)m=x*z;if(y==13)m=x/z;return m;}bit Busy(void){bit busy_flag = 0;RS = 0;RW = 1;E = 1;delay(1);busy_flag = (bit)(P0 & 0x80);E = 0;return busy_flag;}void wcmd(uchar del){while(Busy());RS=0;RW=0;E=0;P0=del;delay(1);E=1;delay(1);E=0;}void wdata(uchar del){while(Busy());RS=1;RW=0;E=0;P0=del;delay(1);E=1;delay(1);E=0;}void keyscan(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;break;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;break;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;break;case 0xbb:key=10;break;case 0x7b:key=11;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){fuhao=key;num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;while(1){keyscan1();if(key==15)break;}}if(key==15){dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;}}}P1=0xf7;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xe7:key=12;break;case 0xd7:key=13;break;case 0xb7:key=14;break;case 0x77:key=15;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){fuhao=key;num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;while(1){keyscan1();if(key==15)break;}}if(key==15){dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;flag2=0;}}}if(keypos==4)keypos=0;if(key1==0){delay(5);if(key1==0){while(key1==0);flag2=1;keypos=0;}}if(key2==0){delay(5);if(key2==0){while(key2==0);num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;num3=sqrt(num1);num6=num3;num5=(num3-num6)*10000;dispbuf[0]=num6/1000;dispbuf[1]=num6%1000/100;dispbuf[2]=num6%1000%100/10;dispbuf[3]=num6%1000%100%10;dispbuf1[0]=num5/1000;dispbuf1[1]=num5%1000/100;dispbuf1[2]=num5%1000%100/10;dispbuf1[3]=num5%1000%100%10;}}}void keyscan1(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}}}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;break;case 0xbb:key=10;break;case 0x7b:key=11;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){num1=num3;fuhao=key;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;}}}P1=0xf7;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xe7:key=12;break;case 0xd7:key=13;break;case 0xb7:key=14;break;case 0x77:key=15;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>=0)&&(key<10)){keypos++;if(flag2==0){if(keypos<=4){change(dispbuf,keypos);dispbuf[3]=key;}}else dispbuf1[keypos-1]=key;}if ((key>9)&&(key<14)){num1=num3;fuhao=key;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;keypos=0;}if (key==14){num2=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;num3=jisuan(num1,fuhao,num2);num6=num3;num5=(num3-num6)*10000;dispbuf[0]=num6/1000;dispbuf[1]=num6%1000/100;dispbuf[2]=num6%1000%100/10;dispbuf[3]=num6%1000%100%10;dispbuf1[0]=num5/1000;dispbuf1[1]=num5%1000/100;dispbuf1[2]=num5%1000%100/10;dispbuf1[3]=num5%1000%100%10;flag2=0;}}}if(keypos==4)keypos=0;if(key1==0){delay(5);if(key1==0){while(key1==0);flag2=1;keypos=0;}}if(key2==0){delay(5);if(key2==0){while(key2==0);num1=1000*dispbuf[0]+100*dispbuf[1]+10*dispbuf[2]+dispbuf[3]+dispbuf1[0]/10+dispbuf 1[1]/100+dispbuf1[2]/1000+dispbuf1[3]/10000;num3=sqrt(num1);num6=num3;num5=(num3-num6)*10000;dispbuf[0]=num6/1000;dispbuf[1]=num6%1000/100;dispbuf[2]=num6%1000%100/10;dispbuf[3]=num6%1000%100%10;dispbuf1[0]=num5/1000;dispbuf1[1]=num5%1000/100;dispbuf1[2]=num5%1000%100/10;dispbuf1[3]=num5%1000%100%10;}}}void ukeyscan(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;break;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(flag1==0){wdata(table[key]);num1=num1*10+key;}else {flag3=flag3*10;num1=num1+key/flag3;wdata(table[key]);}}}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;break;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(flag1==0){wdata(table[key]);num1=num1*10+key;}else {flag3=flag3*10;num1=num1+key/flag3;wdata(table[key]);} }}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;break;case 0xbb:key=10;break;case 0x7b:key=11;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(key==0||key==9){if(flag1==0){wdata(table[key]);num1=num1*10+key;}else {flag3=flag3*10;num1=num1+key/flag3;wdata(table[key]);} }if ((key>9)&&(key<14)){fuhao=key;if(key==10)key=0x2B;else if(key==11)key=0x2d;else if(key==12)key=0x2a;else if(key==13)key=0x2f;flag1=0;flag3=1;wdata(key);while(1){ukeyscan1();if(key==15)break;}}if(key==15){wcmd(0x01);wcmd(0x0e);flag1=0;flag3=1;num1=0;num2=0;num3=0;fuhao=0;}}}P1=0xf7;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xe7:key=12;break;case 0xd7:key=13;break;case 0xb7:key=14;break;case 0x77:key=15;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>9)&&(key<14)){fuhao=key;if(key==10)key=0x2B;else if(key==11)key=0x2d;else if(key==12)key=0x2a;else if(key==13)key=0x2f;flag1=0;flag3=1;wdata(key);while(1){ukeyscan1();if(key==15)break;}}if(key==15){wcmd(0x01);wcmd(0x0e);flag1=0;flag3=1;num1=0;num2=0;num3=0;fuhao=0;}}}if(key1==0){delay(5);if(key1==0){while(key1==0);flag1=1;wdata(0x2e);}}}void ukeyscan1(){P1=0xfe;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xee:key=1;break;case 0xde:key=2;break;case 0xbe:key=3;break;case 0x7e:key=4;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(flag1==0){wdata(table[key]);num2=num2*10+key;}else {flag3=flag3*10;num2=num2+key/flag3;wdata(table[key]);} }}P1=0xfd;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xed:key=5;break;case 0xdd:key=6;break;case 0xbd:key=7;break;case 0x7d:key=8;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(flag1==0){wdata(table[key]);num2=num2*10+key;}else {flag3=flag3*10;num2=num2+key/flag3;wdata(table[key]);} }}P1=0xfb;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xeb:key=9;break;case 0xdb:key=0;break;case 0xbb:key=10;break;case 0x7b:key=11;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if(key==0||key==9){if(flag1==0){wdata(table[key]);num2=num2*10+key;}else {flag3=flag3*10;num2=num2+key/flag3;wdata(table[key]);}}if ((key>9)&&(key<14)){wcmd(0x01);wcmd(0x80);wcmd(0x0e);num1=num3;fuhao=key;if(key==10)key=0x2B;else if(key==11)key=0x2d;else if(key==12)key=0x2a;else if(key==13)key=0x2f;if(a0!=0)wdata(table[a0]);if(b0!=0)wdata(table[b0]);else {if(a0!=0)wdata(table[b0]);}if(c0!=0)wdata(table[c0]);else {if((a0!=0)||(b0!=0))wdata(table[c0]);}if(d0!=0)wdata(table[d0]);else {if((a0!=0)||(b0!=0)||(c0!=0))wdata(table[d0]);}wdata(table[e0]);wdata(0x2e);wdata(table[a1]);wdata(table[b1]);wdata(table[c1]);wdata(table[d1]);num2=0;wdata(key);}}}P1=0xf7;temp=P1;temp=temp&0xf0;while(temp!=0xf0){delay(5);temp=P1;temp=temp&0xf0;while(temp!=0xf0){temp=P1;switch(temp){case 0xe7:key=12;break;case 0xd7:key=13;break;case 0xb7:key=14;break;case 0x77:key=15;break;}while(temp!=0xf0){temp=P1;temp=temp&0xf0;}if ((key>9)&&(key<14)){wcmd(0x01);wcmd(0x80);wcmd(0x0e);num1=num3;fuhao=key;if(key==10)key=0x2B;else if(key==11)key=0x2d;else if(key==12)key=0x2a;else if(key==13)key=0x2f;if(a0!=0)wdata(table[a0]);if(b0!=0)wdata(table[b0]);else {if(a0!=0)wdata(table[b0]);}if(c0!=0)wdata(table[c0]);else {if((a0!=0)||(b0!=0))wdata(table[c0]);}if(d0!=0)wdata(table[d0]);else {if((a0!=0)||(b0!=0)||(c0!=0))wdata(table[d0]);} wdata(table[e0]);wdata(0x2e);wdata(table[a1]);wdata(table[b1]);wdata(table[c1]);wdata(table[d1]);num2=0;wdata(key);}if (key==14){wdata(0x3d);num3=jisuan(num1,fuhao,num2);wcmd(0x80+0x40);if(num3<0){wdata(0x2d);num3=-num3;}n1=num3;n2=(num3-n1)*10000;a0=n1/10000;b0=n1%10000/1000;c0=n1%10000%1000/100;d0=n1%10000%1000%100/10;e0=n1%10000%1000%100%10;a1=n2/1000;b1=n2%1000/100;c1=n2%1000%100/10;d1=n2%1000%100%10;if(a0!=0)wdata(table[a0]);if(b0!=0)wdata(table[b0]);else {if(a0!=0)wdata(table[b0]);}if(c0!=0)wdata(table[c0]);else {if((a0!=0)||(b0!=0))wdata(table[c0]);}if(d0!=0)wdata(table[d0]);else {if((a0!=0)||(b0!=0)||(c0!=0))wdata(table[d0]);}wdata(table[e0]);wdata(0x2e);wdata(0x30+a1);wdata(0x30+b1);wdata(0x30+c1);wdata(0x30+d1);wcmd(0x0c);flag1=0;flag3=1;}}}if(key1==0){delay(5);if(key1==0){while(key1==0);flag1=1;wdata(0x2e);}}}void init(){TMOD=0x01;TH0=(65536-9900)/256;TL0=(65536-9900)%256;EA=1;ET0=1;TR0=1;wcmd(0x38);wcmd(0x0e);wcmd(0x06);wcmd(0x01);wcmd(0x80);}void main(){init();while(1){if(key3==0){delay(5);if(key3==0){while(key3==0);flag=1-flag;flag1=0;flag2=0;flag3=1;keypos=0;num1=0;num2=0;fuhao=0;aa=0;a0=0;b0=0;c0=0;d0=0;e0=0;a1=0;b1=0;c1=0;d1=0;dispbuf[0]=0;dispbuf[1]=0;dispbuf[2]=0;dispbuf[3]=0;dispbuf1[0]=0;dispbuf1[1]=0;dispbuf1[ 2]=0;dispbuf1[3]=0;wcmd(0x01);if(flag==1){TR0=0;wcmd(0x38);wcmd(0x0e);wcmd(0x06);wcmd(0x01);wcmd(0x80);}else TR0=1;}}if(flag==0){keyscan();}else{ukeyscan();}}}void timer() interrupt 1{TH0=(65536-9900)/256;TL0=(65536-9900)%256;for(aa=0;aa<8;aa++){if(aa>=0&&aa<3){P0=tabledu[dispbuf[aa]];P2=tablewe[aa];}if(aa==3){P0=tabledu1[dispbuf[aa]];P2=tablewe[aa];}if(aa>3&&aa<8){num7=dispbuf1[aa-4];P0=tabledu[num7];P2=tablewe[aa];}delay(1);}}。

51单片机简易计算器设计报告(一)

51单片机简易计算器设计报告(一)背景介绍在数字化时代，计算器作为一种简单易用的工具，越来越得到人们的关注和热爱。

而基于51单片机的简易计算器，不仅可以成为一种学习电子技术的手段，还具有满足简单计算需求的实用性。

设计思路本计算器采用键盘输入和数码管输出的电路设计，为用户提供加、减、乘、除、小数点、退位以及等于等功能。

1.键盘输入采用矩阵键盘的方式，将所有按键按行列排列，并利用51单片机中断方式来读取键值。

2.计算处理通过编写相应的程序代码，计算出用户输入的两个数值及操作符的结果，并将结果存储在数据缓存器中，最后将其输出至数码管。

3.数码管显示根据计算结果的数据类型，将其经过相应的转换处理后，通过数码管将结果输出至用户。

设计技术1.软件编写软件编写方面，采用汇编语言进行编写，代码总长度为2.2KB 左右。

其中，以中断方式读取键值、实现数值存储与判断、计算处理、数码管的结果输出等作为关键点进行编写。

2.硬件搭建硬件搭建方面，需要按照电路图进行搭建，并将51单片机与相关周边电路进行连接。

根据设计思路，将键盘、数码管、电源、指示灯等设备按照需求进行连接。

可改进之处虽然 51单片机的简易计算器的搭建能够满足基本计算需求，但其在以下几方面还有可改进之处：•添加计算科学函数，如三角函数、对数函数等。

•改进操作方式，使其更加符合人体工程学原理。

•添加储存器，使用户能够将计算结果进行存储和调用。

总结通过本次对基于51单片机的简易计算器的设计与实现，我们深入了解了电子技术的基本概念和硬件搭建原理，并了解到了简单嵌入式系统的工作原理。

虽然该计算器在功能和效率方面还有待改进，但对于初学者来说，其对于电子技术的学习和实验还是很有价值和意义的。

•编写的汇编代码过于繁琐，可考虑使用高级语言编写以提高效率和易读性。

•在电路搭建时需注意布线的合理性，尽量避免出现干扰和信号损失的问题。

综上所述，基于51单片机的简易计算器的设计和实现虽存在一些不足，但还是很有价值的。

基于51单片机的简易教学计算器设计

基于51单片机的简易教学计算器设计设计目的：本设计旨在基于51单片机实现一个简易的教学计算器，可以进行基本的四则运算，并具备一些辅助功能，帮助学生进行数学计算和学习。

设计要求：1.显示器：使用液晶显示器（LCD）来显示操作数和计算结果。

2.键盘输入：设计一个按键矩阵作为输入设备，用于输入数字和操作符。

3.四则运算：实现加法、减法、乘法和除法四种基本运算。

4.辅助功能：提供开平方、取倒数等辅助功能。

5.界面友好：界面清晰、操作简单。

硬件设计：1.51单片机（AT89C52）：作为计算器的核心芯片，控制程序运行和与外围设备的交互。

2.液晶显示器（LCD）：用于显示操作数和计算结果。

3.按键矩阵：用于输入数字和操作符。

4.运算模块：用于进行四则运算和辅助功能计算。

软件设计：1.系统初始化：初始化51单片机和LCD屏幕，设置键盘矩阵的引脚。

2.输入处理：通过按键矩阵检测用户输入，并将输入的字符存储在缓冲区中。

3.表达式计算：根据用户输入的表达式，通过逆波兰表达式算法将其转换为后缀表达式，并进行计算得到结果。

4.显示结果：将计算结果显示在LCD屏幕上。

5.辅助功能：根据用户选择的辅助功能，进行相应的计算，并显示结果。

6.重置功能：提供清零功能，将计算器的状态和显示结果重置。

操作流程：1.系统初始化：开机时，系统进行初始化，屏幕显示“计算器”字样。

2.输入操作数和操作符：用户通过按键矩阵输入操作数和操作符。

3.计算结果：用户输入“=”符号后，计算器根据输入的表达式进行计算，并将结果显示在LCD屏幕上。

4.辅助功能：在计算结果显示完成后，用户可选择进行辅助功能，如开平方、取倒数等操作。

5.重置功能：用户可通过按下“C”键进行重置，将计算器状态和显示结果清零。

总结：本设计基于51单片机实现了一个简易的教学计算器，具备基本的四则运算功能和一些辅助功能。

其使用液晶显示器作为显示设备，利用按键矩阵进行输入操作，通过逆波兰表达式算法进行计算，并将结果显示在屏幕上。

51单片机简易计算器可算小数

51单片机简易计算器#include<reg51.h>#include<math.h>#define uchar unsigned char #define uint unsigned int sbit beep=P2^3;sbit dula=P2^6;sbit wela=P2^7;sbit rw=P1^1;sbit rs=P1^0;sbit lcden=P2^5;void yunsuan();void keyinput(char s);void write_data(char ddata);void write_com(char command);void display(long a);void init();void dealerror();void dataoverflow();void welcome();char code table1[]={0xee,0xde,0xbe,0x7e,0xed,0xdd,0xbd,0x7d,0xeb,0xdb,0xbb,0x7b,0xe7,0xd7,0xb7,0x77};char code table2[]="789/456*123-.0=+";char j,k,temp,temp1,temp2,key,mchar,m,flag2=0,flag3=0; long x,y,num;int operators,input,iny;char error[5]="error";char overflow[8]="overflow";char welcome_[16]="welcome to use !";void delay(uint x)//延时{uint a,b;for(a=x;a>0;a--)for(b=10;b>0;b--);}void delay_ms(uint x)//延时{uint a,b;for(a=x;a>0;a--)for(b=110;b>0;b--);}void write_com(uchar com)//写命令{P0=com;rs=0;lcden=0;delay(10);lcden=1;delay(10);lcden=0;}void write_data(uchar date)//写数据{P0=date;rs=1;lcden=0;delay(10);lcden=1;delay(10);lcden=0;}long ming(int x){long m;switch(x){case 9:m=1000000000;return m;break; case 8:m=100000000;return m;break; case 7:m=10000000;return m;break; case 6:m=1000000;return m;break; case 5:m=100000;return m;break; case 4:m=10000;return m;break; case 3:m=1000;return m;break;case 2:m=100;return m;break;case 1:m=10;return m;break; case 0:m=1;return m;break; }}void display(long a){long d;int i,flag1=0,temp,c=-1;init();if(a<0){a=a*c;write_data('-');}for(i=9;i>=0;i--){d=ming(i);temp=a/d;a=a%d;if((temp==0)&&(flag1==0)) ;else{write_data(0x30+temp);flag1=1;}if(i==2){write_data('.');flag1=1;}}}void init()//LCD初始化{rw=0;dula=0;wela=0;write_com(0x38); //显示模式设置：16×2显示，5×7点阵，8位数据接口delay(20);write_com(0x0e); //显示模式设置delay(20);write_com(0x06); //显示模式设置：光标右移，字符不移delay(20);write_com(0x01); //清屏幕指令，将以前的显示内容清除delay(20);}void yunsuan() // 运算{if (iny){switch(operators){case 1:x=x+y;num=x;if(num<10000000000&&num>-10000000000){display(num);}elsedataoverflow();break;case 2:x=x-y;num=x;if(num<10000000000&&num>-10000000000) {display(num);}elsedataoverflow();break;case 3:x=x*y;num=x/100;if(num<10000000000&&num>-10000000000) {display(num);}elsedataoverflow();break;case 4:if (y==0)dealerror();else{if(y<100){x=x*100;y=y*100;}y=y/100;x=x/y;num=x;if(num<10000000000&&num>-10000000000) {display(num);}elsedataoverflow();}break;}y=0;}}void dealerror()//除数为0{int i=0;write_com(0x01);for(i=0;i<5;i++)write_data(error[i]);}void dataoverflow()//数值溢出{int i=0;write_com(0x01);for(i=0;i<8;i++)write_data(overflow[i]);}void welcome()//欢迎界面{int i=0;write_com(0x01);for(i=0;i<16;i++)write_data(welcome_[i]);}void keyinput(char s) //键盘输入{if(s<='9'&&s>='0') //判断按下的键是否为数值{if(flag3==0)num=num*10+100*(s-'0');elsenum=num*10+10*(s-'0');if(flag2==1){num=num/10;flag3=1;}if (operators>0){y=num;iny=1;}elsex=num;if(num<10000000000&&num>-10000000000) //当前数值是否超出限定范围display(num);elsedataoverflow();}elseswitch(s){case '.':/*iny=0;operators=0;*/flag2=1;break;case '=':write_data(table2[14]); delay(10);yunsuan();iny=0;operators=0;num=0;flag2=0;flag3=0;break;case '+':if (operators) yunsuan();operators=1;write_data(table2[15]); num=0;flag2=0;flag3=0;break;case '-':if (operators) yunsuan(); operators=2;write_data(table2[11]); num=0;flag2=0;flag3=0;break;case '*':if (operators) yunsuan(); operators=3;write_data(table2[7]); num=0;flag2=0;flag3=0;break;case '/':if (operators) yunsuan(); operators=4;write_data(table2[3]); num=0;flag2=0;flag3=0;break;}}void main() //主函数{char i;char flag0=1;init();welcome();for(i=0;i<10;i++) delay_ms(100);init();while(1){P3=0xf0;temp1=P3;P3=0x0f;temp2=P3;temp=temp1|temp2; while(P3!=0x0f) {beep=0;}beep=1;for(i=0;i<16;i++) {if(temp==table1[i]) {m=table2[i];flag0=0;}}if(flag0==0) {keyinput(m); flag0=1;}}}。

51单片机简易计算器设计

51单片机简易计算器设计一、引言计算器是一种通过输入和输出数字信号进行数学运算的电子设备。

在现代社会，人们对计算器有着广泛的需求，因此设计一款简单而实用的计算器对于我们理解计算器的工作原理和学习单片机编程非常有帮助。

本文将介绍一种基于51单片机的简易计算器设计，涵盖了相关的硬件设计和软件编程。

二、设计思路本计算器设计的主要思路如下：1.使用数码管显示输入的数字和计算结果。

2.使用按键输入数字和操作符。

3.通过软件编程实现数字的输入、运算和结果的显示。

三、硬件设计1.数码管：使用4位共阴数码管，通过BCD-7段译码器将数字信号转化为数码管显示。

2.按键：使用独立按键输入数字和操作符。

3.电源：使用适当的电源电路提供电压和电流。

四、软件设计1.初始化：设置数码管显示方式、按键输入方式和端口状态。

2.输入数字：通过按键输入数字，并将数字显示在数码管上。

可以采用按键扫描的方式实现，每次按键触发时读取按键值，并将对应的数字显示在数码管上。

3.输入操作符：通过按键输入操作符，并将操作符显示在数码管上。

同样采用按键扫描的方式实现。

4.数字运算：根据输入的操作符和数字进行相应的运算，得出结果。

5.显示结果：将运算结果显示在数码管上。

五、程序流程图具体的程序流程图如下：六、程序实现以下是51单片机计算器的简单代码实现：```C#include<reg51.h>sbit LED=P1^0;sbit KEY=P3^0;void delay(int n)int i=0, j=0;for(i=0; i<n; i++)for(j=0; j<123; j++);void mainwhile(1)if(KEY==0)LED=0;elseLED=1;delay(10);}```七、测试和结果在硬件设计完成并烧录完程序后，我们可以进行测试。

通过按下按键，观察数码管是否正确显示输入的数字和运算结果。

如果显示正确，则说明程序设计成功。

51单片机实现的简易计算器

51单片机实现的简易计算器1. 4X4键盘输入，点阵字符型液晶显示。

2. 由于所采用的浮点程序库的限制（MCU平台只找到这个……），浮点运算采用3字节二进制补码表示，有效数字6位。

对于输入输出，采用3字节BCD码浮点数格式，有效数字只有4位，因此最终有效数字只有4位。

3. 可进行连续输入，例如：1.23+4.56*8.23/234.8 ，但是运算结果为从左到右，这也是8位简易计算器的方式。

4. 可进行错误判断，溢出、除零等错误将显示一个字符E 。

5. 由于键盘只有16个按键，安排如下：+---------------+| 7 | 8 | 9 | + || 4 | 5 | 6 | - || 1 | 2 | 3 | * || 0 | . | = | / |+---------------+6. 按键的缺少导致取消了一些特殊函数，即开根号，三角函数(sin, cos, tan, ctg)的实现，由于这些函数在浮点程序库中均已提供，如果硬件允许，在原来的框架上添加这些附加功能是很容易的（可以看作和+, -, *, /等价的按键操作，调用不同的子程序进行运算即可）7. 按两次= 等于清灵。

因为按键实在太少，才采用了这个做法。

8. 相应举例：按键结果说明- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -123+= 123 按下等号而没有第二个操作数，保留第一个操作数并认为此次运算结束（等号的功能）123+321/111 4.0 等价于(123+321) / 1112.3+5.4=/0.1+ 77 等号后直接按/ ，则将前面的运算结果作为第一个操作数1/0= E 错误显示9. 不足使用3字节的浮点数表示，不可避免的带来了数表示的不精确，加上有效数字比较少，因此计算结果很容易产生误差，尤其是进行连续多次运算后，结果和精度较高的科学计算器的误差会很快达到0.01以上，当然这个差距和所测试的用例也有关系，4位有效数字导致了数字123456只能表示为123400，最后两位有效数字被摒弃了。

基于51单片机的数码管简易计算器

基于51/52单片机的简易计算器制作一、题目利用单片机芯片STC89C52、四位八段共阳数码管及已制作好的电路板等器件设计制作一个计算器。

二、任务与要求要求计算器能实现加减乘除四种运算具体如下1. 加法：四位整数加法计算结果若超过八位则显示计算错误2. 减法：四位整数减法计算结果若超过八位则显示计算错误3. 乘法：多位整数乘法计算结果若超过四位则显示计算错误4. 除法：整数除法5. 有清除功能三、课程设计简述总体设计思路简述1.按照系统设计的功能的要求初步确定设计系统由主控模块、显示模块、键扫描接口电路共三个模块组成。

主控芯片使用STC89C52单片机。

2.键盘电路采用4*4矩阵键盘电路。

3.显示模块采用共阳极数码管构成。

四、硬件电路五、软件编程部份#include<reg52.h>#define uchar unsigned char#define uint unsigned int//uchar code num[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00,0x40};//共阴极// 0 1 2 3 4 5 6 7 8 9 熄灭-//uchar code loc[]={0xff,0xfe,0xfd,0xfb,0xf7};//uchar code ero[]={0x79,0x50,0x5c};uchar code num[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0x40};//共阳极uchar code loc[]={0x00,0x80,0x40,0x20,0x10};uchar code ero[]={~0x79,~0x50,~0x5c};uint n=0,n1=0,n2=0; //赋初值uchar flag=0; //计算类型选择关键字void delay(int t);void display(int n);void error();main(){while(1){uchar temp;//第一行检测P3=0xfe;temp=P3;temp=temp&0xf0;if(temp!=0xf0){delay(10);temp=P3;temp=temp&0xfe;if(temp!=0xfe){temp=P3;switch(temp){case 0xee:n1=0;n2=0;n=0;flag=0;break; //清零//0case 0xbe: if(flag==1)n=n2+n1; //=if(flag==2)n=n2-n1;if(flag==3)n=n2*n1;if(flag==4)n=n2/n1;n1=0;break;case 0x7e: // +n2=n1;n1=0;flag=1;break;}while(temp!=0xf0){temp=P3;temp=temp&0xf0;}}}//扫描第二行P3=0xfd;temp=P3;temp=temp&0xf0;if(temp!=0xf0){delay(10);temp=P3;temp=temp&0xf0;if(temp!=0xf0){temp=P3;switch(temp){case 0xed:n1=10*n1+1;n=n1;break; //4case 0xdd:n1=10*n1+2;n=n1;break; //5case 0xbd:n1=10*n1+3;n=n1;break; //6case 0x7d:// -n2=n1;n1=0;flag=2;break;}while(temp!=0xf0){temp=P3;temp=temp&0xf0;}}}//扫描第三行P3=0xfb;temp=P3;temp=temp&0xf0;if(temp!=0xf0){delay(10);temp=P3;temp=temp&0xf0;if(temp!=0xf0){temp=P3;switch(temp){case 0xeb:n1=10*n1+4;n=n1;break;case 0xdb:n1=10*n1+5;n=n1;break;case 0xbb:n1=10*n1+6;n=n1;break;case 0x7b: // *n2=n1;n1=0;flag=3;break;}while(temp!=0xf0){temp=P3;temp=temp&0xf0;}}}//扫描第四行P3=0xf7;temp=P3;temp=temp&0xf0;if(temp!=0xf0){delay(10);temp=P3;temp=temp&0xf0;if(temp!=0xf0){temp=P3;switch(temp){case 0xe7:n1=10*n1+7;n=n1;break; //7case 0xd7:n1=10*n1+8;n=n1;break; //8case 0xb7:n1=10*n1+9;n=n1;break; //9case 0x77: // /n2=n1;n1=0;flag=4;break;}while(temp!=0xf0){temp=P3;temp=temp&0xf0;}}}display(n);}}//延时函数void delay(int t){int x,y;for(x=0;x<t;x++)for(y=0;y<t;y++);}//数码管显示void display(int n){//溢出处理uchar g,s,b,q;int abs;if((n>9999)||(n<-999))error();//正数if((n>=0)&&(n<=9999)) {g=n%10;s=n/10%10;b=n/100%10;q=n/1000%10;P0=num[g];delay(5);P2=loc[4];delay(2);P2=loc[0];delay(3);if(n>=10){P0=num[s];P2=loc[3];delay(2);P2=loc[0];delay(3);}if(n>=100){P0=num[b];P2=loc[2];delay(2);P2=loc[0];delay(3);}if(n>=1000){P0=num[q];P2=loc[1];delay(2);P2=loc[0];delay(3);}}//负数if((n<0)&&(n>=-999)){abs=-n;g=abs%10;s=abs/10%10;b=abs/100%10;q=abs/1000%10;P0=num[g];P2=loc[4];delay(2);P2=loc[0];delay(2);if((abs/10%10>0)||(abs/100%10>0)){P0=num[s];P2=loc[3];;delay(2);P2=loc[0];delay(2);if((abs/100%10>0)){P0=num[b];P2=loc[2];delay(2);P2=loc[0];delay(2);if((abs/1000%10>0)){P0=num[q];P2=loc[1];delay(2);P2=loc[0];delay(2);}else{P0=num[11];P2=loc[1];delay(2);P2=loc[0];delay(2);}}else{P0=num[11];P2=loc[2];delay(2);P2=loc[0];delay(2);}}else{P0=num[11];P2=loc[3];delay(2);P2=loc[0];delay(2);}}}//溢出显示void error(){P2=loc[1];P0=ero[0];delay(2);P2=loc[0];delay(3);P2=loc[2];P0=ero[1];delay(2);P2=loc[0];delay(3);P2=loc[3];P0=ero[1];delay(2);P2=loc[0];delay(3);P2=loc[4];P0=ero[2];delay(2);P2=loc[0];delay(3); }。

51单片机计算器（包括三角函数指数函数等）

51单片机计算器（包括三角函数指数函数等）#include "REG51.h"#include "oled.h"#include"math.h"#include"string.h"#define pi 3.141592654#define e 2.718281828#define KeyPort P0//定义变量unsigned char code tables[]={0xee,0xde,0xbe,0x7e,0xed,0xdd,0xbd,0x7d,0xeb, 0xdb,0xbb,0x7b,0xe7,0xd7 ,0xb7,0x77};char code nub[]={'1','2','3','+','4','5','6','-','7','8','9','*','0','.','=','/'};char temp[105];char ac[105];char txt[20];double ans;char flg;unsigned char tmp;static char table[]={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};unsigned long atof_A( char *sptr);unsigned long atof_C( char *sptr);unsigned long arr(int a,int b);unsigned long crr(int a,int b);double abst(double nb);double my_(char str[]);void num2char(char str[], float number, u8 g, u8 l); int isdigit(char c);int strlen( char str[]);int priority(char c);float atof( char *sptr);double cal(char str[],int len);int keyscan() ;void DelayUs2x(unsigned char t);void DelayMs(unsigned char t);void main(void){ //float tt;// int pre;double ans_pe[10];int lens,i,j,nn,count=0,f,cls,as,jisuan,k=0,TO; OLED_Init(); //初始化OLEDdelay_ms(100);OLED_Clear();for(i=0;i<10;i++)ans_pe[i]=0;while(1) {/*nn=keyscan();if(nn>=0 &&nn<=15){ac[count++]=nub[nn-1];ac[count]='\0';}*/nn=keyscan();// pre =count;//-----------------------输入算式----------------------------------------if(nn>0 && nn<=36){if(cls==1){OLED_Clear();cls=0;}TO=1;switch(nn){case 1: ac[count++]='1';break; //1case 2: ac[count++]='2';break; //2case 3: ac[count++]='3';break; //3case 4: ac[count++]='+';break; //+case 5: ac[count++]='s'; ac[count++]='i'; ac[count++]='n';break; //sincase 6: ac[--count]='\0';OLED_Clear();break; //DELcase 7: ac[count++]='4';break; //4case 8: ac[count++]='5';break; //5case 9: ac[count++]='6';break; //6case 10: ac[count++]='-';break; //-case 11: ac[count++]='c'; ac[count++]='o'; ac[count++]='s';break; //coscase 12: ac[0]='\0';OLED_Clear();break; //rstcase 13: ac[count++]='7';break; //7case 14: ac[count++]='8';break; //8case 15: ac[count++]='9';break; //9case 16: ac[count++]='*';break;//*case 17: ac[count++]='t'; ac[count++]='a'; ac[count++]='n';break; //tancase 18: ac[count++]='l';ac[count++]='n';break; //lncase 19: ac[count++]='0';break; //0case 20: ac[count++]='.';break; //.case 21: ac[count++]='p';ac[count++]='i';break; //picase 22: ac[count++]='/';break; //÷case 23: ac[count++]='a';ac[count++]='s'; ac[count++]='i'; ac[count++]='n';break; //asincase 24: ac[count++]='l'; ac[count++]='o'; ac[count++]='g';break; //logcase 25: ac[count++]='e';break; //ecase 26: ac[count++]='(';break; //)case 27: ac[count++]='s';ac[count++]='q'; ac[count++]='r'; ac[count++]='t';break; //√case 28: ac[count++]='^';break; //^case 29: ac[count++]='a';ac[count++]='c'; ac[count++]='o'; ac[count++]='s';break; //acoscase 30: ac[count++]='%';break; //%case 31: ac[count++]='1';ac[count++]='0';ac[count++]='^';break; //10^ case 32: ac[count++]=')';break; //)case 33: ac[count++]='A';break; //Acase 34: ac[count++]='C';break; //Ccase 35: ac[count++]='a';ac[count++]='t'; ac[count++]='a'; ac[count++]='n';break; //atancase 36: ac[count++]='=';break; //=default: break;}}ac[count]='\0';if(ac[count-1]=='A' &&TO){k++;TO=0;if(k>10) k=0;num2char(txt,ans_pe[k],10,5);for(i=0;i<strlen(txt);i++){OLED_ShowChar(i*6,4,txt[i]); //OLED_ShowString(0,4,txt); );}}if(ac[count-1]=='C'&&T0){TO=0;k--;if(k<0) k=9;num2char(txt,ans_pe[k],10,5);for(i=0;i<strlen(txt);i++){OLED_ShowChar(i*6,4,txt[i]); //OLED_ShowString(0,4,txt); );}}lens = strlen(ac);if(ac[count-1]=='=')jisuan=1;if(jisuan){// ac[count]='\0';count=0;jisuan=0;//ac[0]='l';ac[1]='o';ac[2]='g';ac[3]='(';ac[4]='e';ac[5]='+';ac[6]='2'; ac[7]='*';ac[8]='3';ac[9]='-';ac[10]='4';ac[11]='+';ac[12]='e';ac[13]=')';// ac[14]='=';ac[15]='\0';ans=cal(ac,lens);as=1;cls=1;for(i=1;i<10;i++)ans_pe[i]=ans_pe[i-1];ans_pe[0]=ans;}//-----------------显示答案----------------------- // ans=456-(double)41*8/6+3*59*0.54;num2char(txt,ans,10,5);f=1;if(as=1){as=0;for(i=0;i<strlen(txt);i++)OLED_ShowChar(i*6,6,' ');}for(i=0;i<strlen(txt);i++){if(flg=='-' && txt[i+1]!='0'){OLED_ShowChar</strlen(txt);i++)</strlen(txt);i++)</strlen(txt);i++)</strlen(txt);i++)(i*6,6,'-');flg='+';continue;}if(txt[i]=='.'){if(txt[i-1]=='0')OLED_ShowChar((i-1)*6,6,'0');}if(f==1 && txt[i]=='0')continue;else{OLED_ShowChar(i*6,6,txt[i]); //OLED_ShowString(0,4,txt); ); f=0;}}//-----------------显示算式-----------------------for(i=0;i<lens;i++){j=i/20;OLED_ShowChar(i*6%120,j,ac[i]);}// num2char(txt,lens,8,5);delay_ms(70);//}}int isdigit(char c)if(c>='0' && c<='9') return 1;else return 0;}int strlen( char str[]) {int len=0;while(*(str+len)!='\0') len++;return len;}int priority(char c) {if(c == '=') return 0;if(c == '+') return 1;if(c == '-') return 1;if(c == '*') return 2;if(c == '/') return 2;if(c == '^') return 3; return 0;}double atof( char *sptr) {double tem=10.0;// char ispnum=1;int flg_p=1;double ans=0;while(*sptr!='\0')//寻找小数点之前的数{if(*sptr=='.'){sptr++;flg_p=0;// break;continue;}if(*sptr<'0' || *sptr>'9' ) break;if( flg_p)ans=ans*10+(*sptr-'0');else{ans=ans+(double)(*sptr-'0')/( double)tem; tem=tem*10;}sptr++;}/* while(*sptr!='\0')//寻找小数点之后的数{if(*sptr<'0' || *sptr>'9' ) break;ans=ans+(float)(*sptr-'0')/tem;tem=tem*10;sptr++;}num2char(txt,ans,12,6);OLED_ShowString(0,3,txt);*/return ans;}double cal(char str[],int len) {int i;int numk=0,opj=0;float num[50];int left,right;float a=0,b=0,n=0;char op[20];int k,te;;//int len=4;for(i=0;i<len;i++){k=0;te=0;if(str[i]=='e')num[numk++]=e;else if(str[i]=='p'&&str[i+1]=='i') {num[numk++]=pi;i++;}/////////////////////////////////////////////////////////////////// ////////////else if(str[i]=='l'&&str[i+1]=='o'&&str[i+2]=='g'){ //处理log函数left = 0;right = 0;// left++;for(k=i+3;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=log10(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}else if(str[i]=='l'&&str[i+1]=='</len;k++)</len;i++)</lens;i++)n'){ //处理ln函数left = 0;right = 0;// left++;for(k=i+2;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=log(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}else if(str[i]=='s'&&str[i+1]=='i'&&str[i+2]=='n') { //处理sin函数left = 0;right = 0;// left++;for(k=i+3;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=sin(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}else if(str[i]=='c'&&str[i+1]=='o'&&str[i+2]=='s') { //处cos函数left = 0;right = 0;// left++;for(k=i+3;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;}}temp[te]='\0';num[numk++]=cos(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}else if(str[i]=='t'&&str[i+1]=='a'&&str[i+2]=='n') { //处理tan函数left = 0;right = 0;// left++;for(k=i+3;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=tan(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}if(str[i]=='s'&&str[i+1]=='q'&&str[i+2]=='r'&&str[i+3]=='t') { //处理sqrt函数 (开方)left = 0;right = 0;// left++;for(k=i+4;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){</len;k++)</len;k++)</len;k++)</len;k++)</len;k++)left =0;right=0;break;}}temp[te]='\0';num[numk++]=sqrt(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}elseif(str[i]=='a'&&str[i+1]=='s'&&str[i+2]=='i'&&str[i+3]=='n') { //处理sqrt函数 (开方)left = 0;right = 0;// left++;for(k=i+4;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=asin(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}elseif(str[i]=='a'&&str[i+1]=='c'&&str[i+2]=='o'&&str[i+3]=='s') { //处理sqrt函数 (开方)left = 0;right = 0;// left++;for(k=i+4;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=acos(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}elseif(str[i]=='a'&&str[i+1]=='t'&&str[i+2]=='a'&&str[i+3]=='n') { //处理sqrt函数 (开方)left = 0;right = 0;// left++;for(k=i+4;k<len;k++){if(str[k]=='(')left++;if(str[k]==')')right++;temp[te++]=str[k];if(left == right){left =0;right=0;break;}}temp[te]='\0';num[numk++]=atan(my_(temp));//printf("%llf , %d %d\n",cal(temp),numk,opj);i=k;}/////////////////////////////////////////////////////////////////// ////////////else if(isdigit(str[i])){n=atof(&str[i]);while(i < len && (isdigit(str[i]) || str[i] == '.'))i++;i--;num[numk++]=n;}else{if(str[i] == '(')op[opj++]=str[i];else if(str[i] == ')'){while(op[opj-1] != '('){b=num[numk-1];numk--;a=num[numk-1];</len;k++)</len;k++)</len;k++)numk--;switch(op[opj-1]){case '+': num[numk++]=a+b;break;case '-': num[numk++]=a-b;break;case '*': num[numk++]=a*b;break;case '/': num[numk++]=a/b;break;case '^': num[numk++]=(double)pow(a,b);break;}opj--;}opj--;}else if(opj==0 || priority(str[i]) > priority(op[opj-1])) op[opj++]=str[i];else{while(opj!=0 && priority(str[i])<= priority(op[opj-1])) {b=num[numk-1];numk--;a=num[numk-1];numk--;switch(op[opj-1])case '+': num[numk++]=a+b;break; case '-': num[numk++]=a-b;break; case '*': num[numk++]=a*b;break; case '/': num[numk++]=a/b;break; case '^': num[numk++]=pow(a,b);break; }opj--;}op[opj++]=str[i];}}}//opj--;// opj=strlen(str);// num2char(txt,b,8,5);// OLED_ShowString(0,2,txt);return (num[numk-1]);// numk--;}double abst(double nb){if(nb<0) return (-nb);return nb;}void num2char(char str[], double number, u8 g, u8 l) {u8 i;unsigned long te ,te1;double t2, t3;t3=number;if(number<0)flg='-';else flg='+';number=abst(number);te = (unsigned long)number/1;te1=te;for (i = 1; i<=g; i++){if (te==0)str[g-i] = table[0];elsestr[g-i] = table[te%10];te = te/10;}str[g] = '.';t2 =t3;//-te1 ;// t2=0.1234567;te = 0;for(i=1; i<=l; i++){te =t2*10;str[g+i] = table[te%10];t2 = (double)(t2*10);//-te);}str[g+l+1] = '\0';}void DelayUs2x(unsigned char t){while(--t);}/*------------------------------------------------mS延时函数，含有输入参数 unsigned char t，无返回值unsigned char 是定义无符号字符变量，其值的范围是0~255 这里使用晶振12M，精确延时请使用汇编------------------------------------------------*/void DelayMs(unsigned char t){while(t--){//大致延时1mSDelayUs2x(245);DelayUs2x(245);}}/*int keyscan(void){unsigned char i,Val;KeyPort=0xf0;//高四位置高，低四位拉低if(KeyPort!=0xf0)//表示有按键按下{DelayMs(10); //去抖if(KeyPort!=0xf0){ //表示有按键按下KeyPort=0xfe; //检测第一行if(KeyPort!=0xfe){DelayMs(10); //去抖Val=KeyPort&0xf0;Val+=0x0e;}KeyPort=0xfd; //检测第二行if(KeyPort!=0xfd){DelayMs(10); //去抖Val=KeyPort&0xf0;Val+=0x0d;}KeyPort=0xfb; //检测第三行if(KeyPort!=0xfb){DelayMs(10); //去抖Val=KeyPort&0xf0;Val+=0x0b;}KeyPort=0xf7; //检测第四行if(KeyPort!=0xf7){DelayMs(10); //去抖Val=KeyPort&0xf0;Val+=0x07;}}}for(i=0;i<16;i++){if(Val==tables[i]) //通过查表得出n的值return i;}return(-1);}*/int keyscan(){P0=0xfe; //扫描第1行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 1; //第1行第1个按键按下case 0xfd: return 2; //第1行第2个按键按下case 0xfb: return 3; //第1行第3个按键按下case 0xf7: return 4; //第1行第4个按键按下case 0xef: return 5; //第1行第5个按键按下case 0xdf: return 6; //第1行第6个按键按下// case 0xbf: keynum=7;break; //第1行第7个按键按下// case 0x7f: keynum=8;break; //第1行第8个按键按下}}}DelayMs(5); //去抖P0=0xfd; //扫描第2行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 7; //第2行第1个按键按下case 0xfd: return 8; //第2行第2个按键按下case 0xfb: return 9; //第2行第3个按键按下case 0xf7: return 10; //第2行第4个按键按下case 0xef: return 11; //第2行第5个按键按下case 0xdf: return 12; //第2行第6个按键按下// case 0xbf: keynum=15;break; //第2行第7个按键按下// case 0x7f: keynum=16;break; //第2行第8个按键按下}}}// DelayMs(5); //去抖P0=0xfb; //扫描第3行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 13; //第3行第1个按键按下case 0xfd: return 14; //第3行第2个按键按下case 0xfb: return 15; //第3行第3个按键按下case 0xf7: return 16; //第3行第4个按键按下case 0xef: return 17; //第3行第5个按键按下case 0xdf: return 18; //第3行第6个按键按下// case 0xbf: keynum=23;break; //第3行第7个按键按下// case 0x7f: keynum=24;break; //第3行第8个按键按下}}}//DelayMs(10); //去抖P0=0xf7; //扫描第4行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 19; //第4行第1个按键按下case 0xfd: return 20; //第4行第2个按键按下case 0xfb: return 21; //第4行第3个按键按下case 0xf7: return 22; //第4行第4个按键按下case 0xef: return 23; //第4行第5个按键按下case 0xdf: return 24; //第4行第6个按键按下// case 0xbf: keynum=31; //第4行第7个按键按下// case 0x7f: keynum=32; //第4行第8个按键按下}}}// DelayMs(10); //去抖P0=0xef; //扫描第5行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 25; //第5行第1个按键按下case 0xfd: return 26; //第5行第2个按键按下case 0xfb: return 27; //第5行第3个按键按下case 0xf7: return 28; //第5行第4个按键按下case 0xef: return 29; //第5行第5个按键按下case 0xdf: return 30; //第5行第6个按键按下//case 0xbf: keynum=39;break; //第5行第7个按键按下// case 0x7f: keynum=40;break; //第5行第8个按键按下}}}//DelayMs(5); //去抖P0=0xdf; //扫描第6行if(P2!=0xff) //有按键按下{tmp = P2;DelayMs(10); //去抖if(P2!=0xff) //延时后确定有按键按下{switch(tmp){case 0xfe: return 31; //第6行第1个按键按下case 0xfd: return 32; //第6行第2个按键按下case 0xfb: return 33; //第6行第3个按键按下case 0xf7: return 34; //第6行第4个按键按下case 0xef: return 35; //第6行第5个按键按下case 0xdf: return 36; //第6行第6个按键按下//case 0xbf: keynum=47;break; //第6行第7个按键按下// case 0x7f: keynum=48;break; //第6行第8个按键按下}}}// DelayMs(5); //去抖return 0;}double my_(char str[]){int i;int numk=0,opj=0;float num[50];// int left,right;float a=0,b=0,n=0;char op[20];int k,te;int le = strlen(str);for(i=0;i<le;i++){k=0;te=0;if(str[i]=='e')num[numk++]=e;else if(str[i]=='p'&&str[i+1]=='i') {num[numk++]=pi;i++;}else if(isdigit(str[i])){n=atof(&str[i]);while(i < le && (isdigit(str[i]) || str[i </le;i++)] == '.'))i++;i--;num[numk++]=n;}else{if(str[i] == '(')op[opj++]=str[i];else if(str[i] == ')'){while(op[opj-1] != '('){b=num[numk-1];numk--;a=num[numk-1];numk--;switch(op[opj-1]){case '+': num[numk++]=a+b;break;case '-': num[numk++]=a-b;break;case '*': num[numk++]=a*b;break;case '/': num[numk++]=a/b;break;case '^': num[numk++]=pow(a,b);break;}opj--;}opj--;}else if(opj==0 || priority(str[i]) > priority(op[opj-1])) op[opj++]=str[i];else{while(opj!=0 && priority(str[i])<= priority(op[opj-1])) {b=num[numk-1];numk--;a=num[numk-1];numk--;switch(op[opj-1]){case '+': num[numk++]=a+b;break;case '-': num[numk++]=a-b;break; case '*': num[numk++]=a*b;break; case '/': num[numk++]=a/b;break; case '^': num[numk++]=pow(a,b);break; }opj--;}op[opj++]=str[i];}}}//opj--;// opj=strlen(str);// num2char(txt,num[numk-1],8,5);// OLED_ShowString(0,2,txt);return (num[numk-1]);// numk--;}unsigned long arr(int a,int b) //a>=b {unsigned long ans,ans1=1,ans2=1;int i;if(afor(i=2;i<=a;i++)ans1*=i;for(i=2;i<=a-b;i++)ans2*=i;ans = ans1/ans2;return ans;}unsigned long crr(int a,int b) //a>=b {unsigned long ans,ans1=1,ans2=1; int i;if(afor(i=2;i<=a;i++)ans1*=i;for(i=2;i<=a-b;i++)ans2*=i;for(i=2;i<=b;i++)ans2*=i;ans = ans1/ans2;return ans;}unsigned long atof_A( char *sptr) {unsigned long a=0,b=0;// char ispnum=1;int flg_p=1;unsigned long ans;while(*sptr!='\0')//寻找小数点之前的数{if(*sptr=='.'){sptr++;flg_p=0;// break;continue;}if(*sptr<'0' || *sptr>'9' ) continu e;if( flg_p)a=a*10+(*sptr-'0');else{b=b*10+(*sptr-'0');}sptr++;}ans=arr(a,b);return ans;}unsigned long atof_C( char *sptr) {unsigned long a=0,b=0;// char ispnum=1;int flg_p=1;unsigned long ans=0;while(*sptr!='\0')//寻找小数点之前的数{if(*sptr=='.'){sptr++;flg_p=0;// break;continue;}if(*sptr<'0' || *sptr>'9' ) continue;if( flg_p)a=a*10+(*sptr-'0');else{b=b*10+(*sptr-'0');}sptr++;}ans=crr(a,b);return ans;}。