2019-04-22 16:05:21 liang507107 阅读数 3157
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3396 人正在学习 去看看 朱有鹏

能做计算器的单片机

单片机的出现是计算机制造技术高速发展的产物,它是嵌入式控制系统的核心,如今,它已广泛的应用到我们生活的各个领域,电子、科技、通信、汽车、工业等。本次设计是设计一个简易计算器,能够进行多位的加减乘除运算。它主要由51单片机的数码管,键盘等模块组成。本计算器是将键盘输入信息经处理通过缓存,送入数码管显示,数码管采用动态扫描方式,计算功能通过软件实现,用C语言对单片机可编芯片进行编程,实现计算器的设计。

把期中做的作业放上来哈哈

硬件电路描述

要进行数据的计算就必须先进行数据的输入,也就必须确定按键输入的数值是什么,这就需要对键盘进行扫描,从而确定究竟是哪个键按下。 对于键盘的扫描,这里采用行列扫描的方法来完成对键盘的扫描。原理就是先确定按键在哪一行,接着再确定是哪一列,这样就可以知道是哪个按键被按下了。我是将P3口作为按键扫描口的,比如,先使行线输出全“0”,读列线,再使列线输出全为“0”,读行线。两次结果再相与,则得到一个值为键值。同理,每个按键都会有一个对应的十六进制值,把它们列出来进行一一对应就行了。如下图。
在这里插入图片描述

程序设计描述

1.程序总流程图
在这里插入图片描述
2.编程思路
在单片机接通电源后,单片机就会一直重复检测键盘上的按钮是否被按下。如果有键被按下,就会进入选择判断,当按下数字键,相应数字计入变量keynum中并在数码管上移位显示;当按下运算符键和特殊功能键,也将对应的10到15数字计入到keynum中并进行第二次判断,如果keynum是0~9,则将数据变量dat×10加上keynum;如果是10(加号对应值),进入加法程序(加法标识变量加1,其他运算符标识变量归零,把dat赋值给另一变量datA;当法标识变量大于1时,就是连加,需要将dat等于dat加上datA的值)。其他运算符也是差不多的程序。keynum等于14,就进入等于运算程序。这个程序中也就是四个if语句,如果运算符变量为1就运行相应代码。如加法运算符为1,则使dat加上datA的值赋给dat。最后将dat放入显示程序中显示,而无论何时按下keynum等于15时,所有状态清零。这就是我写的代码的主要思路。

源代码及注释

#include <reg51.h>
#define long unsigned long
#define KEYPORT P3
sbit beep=P1^4;
bit dot;
typedef unsigned char byte;

long dat;       //数据
long datA;      //过度数据
byte addflag;   //加法标志位
byte subflag;   //减法标志位
byte mulflag;   //乘法标志位
byte divflag;   //除法标志位
byte clrflag;   //数据处理标志位
byte scanok;
int checkok;
int keynum;    //按键键值
static byte dispbuf[6];
//数码管字段表
sbit duan=P2^6;
sbit wela=P2^7;
unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,
                        0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
//变量定义

void delayms(int ms)//这个软件大约可以等待ms毫秒
{
	  int i,k;
	  for(k=0; k<ms;k++)	{   for(i=0;i<50;i++);  }
}


/*---------------------------------------------------------------
查询是否有键按下,有键按下返回键值,无键按下则返回0xff
---------------------------------------------------------------*/
byte keysearch(void)
{
	byte k;
 	KEYPORT=0xf0;
 	k=KEYPORT;
 	KEYPORT=0x0f;
 	k=KEYPORT|k;
 	scanok=1;return k;
}
void HEX_TO_BCD(int num)
{	dispbuf[5]  = num%1000000/100000;
    dispbuf[4]  = num%100000/10000;
    dispbuf[3]  = num%10000/1000;
    dispbuf[2]  = num%1000/100;
    dispbuf[1]  = num%100/10;
    dispbuf[0]  = num%10;
}
/*---------------------------------------------------------------
显示子程序
轮流导通各位数码管,再送出字段码
延时显示一段时间后再继续导通下一位
---------------------------------------------------------------*/
void scandisp(void)       
{
	byte posi=0x1f,i,temp;
	//posi,为position的缩写,指显示哪一个8字
	for(i=0;i<6;i++)
 	{
    	temp= dispbuf[i];         //显示缓存区数据查表
    	temp= table[temp];
    	if(i==2&&dot)temp|=0x80;  //i是小数点位置,变量dot=1,点亮小数点
    	P0 = 0;	     duan=1;   duan=0;//先关闭数码管,再切换
    	P0 = posi;   wela=1;   wela=0;  	
    	P0 = temp;   duan=1;   duan=0;
    	delayms(5);//延时 
    	posi>>=1;  posi|=0x20;    //循环右移
 	}
}

/*---------------------------------------------------------------
移位显示子程序
把显示数组中的最低3位赋给高3位,使最新输入的键盘值赋给数组的最低位
输入:键值
返回:无
---------------------------------------------------------------*/
void digitin(byte val)               
{ 
	dispbuf [3]= dispbuf [2];
 	dispbuf [2]= dispbuf [1];
	dispbuf [1]= dispbuf [0];
 	dispbuf [0]= val;
}

/*---------------------------------------------------------------
扫描得到的键值和实际需要的键盘任务的转换函数
也叫键盘码散转程序
输入:键值,有0x00~0xff钟可能性,根据显示的键值可以修改此函数
返回:无
---------------------------------------------------------------*/
void keybranch(byte k)          
{	if(scanok)
   {scanok=0;
	switch(k)
 	{
 	    case 0x00:break;
     	case 0xee:keynum=1;break;
     	case 0xde:keynum=2;break;
     	case 0xbe:keynum=3;break;
     	case 0xed:keynum=4;break;
     	case 0xdd:keynum=5;break;
    	case 0xbd:keynum=6;break;
     	case 0xeb:keynum=7;break;
     	case 0xdb:keynum=8;break;
     	case 0xbb:keynum=9;break;
     	case 0xd7:keynum=0;break;
		case 0x7e:keynum=10;break;//加法
		case 0x7d:keynum=11;break;//减法
		case 0x7b:keynum=12;break;//乘法
		case 0x77:keynum=13;break;//除法
		case 0xb7:keynum=14;break;//等于
		case 0xe7:keynum=15;break;//清零
     	default:break;
 	 } checkok=1;
} }
/*---------------------------------------------------------------
处理程序,键值为15时或者清除标志为1时,数据清零
---------------------------------------------------------------*/
void datchuli(void)
{if(keynum==15)
  {
   dat=0;  datA=0;
   HEX_TO_BCD(dat);
  }
else if(clrflag)                    //清除标志为1,则执行以下。
  {        
   dat=0;
   clrflag=0;                 //为下次使用准备。
   HEX_TO_BCD(dat);
  }
  if(keynum<10)
  {
  digitin(keynum);
  dat=dat*10+keynum;
  }
}

void add(void)
{
   addflag++;                          //加法标志置1。。。
   subflag=mulflag=divflag=0;          //将其它运算标志清零。。(一次只能作一种运算)
   clrflag=1;                          //清零标标置1,(当按下加号后,再按第二个加数时,这时应该显示第二加数。。所以要清掉第一个加数。)
   if(addflag>1)
   {
   dat=datA+dat;
   datA=dat;
   }
   datA=dat;
}
void sub(void)						   //减法
{ subflag++;
  addflag=mulflag=divflag=0;
  clrflag=1;
  if(subflag>1)
  {
  dat=datA-dat;
  datA=dat;
  }
  datA=dat;
}
void mul(void)							//chengfa
{ mulflag++;
  addflag=subflag=divflag=0;
  clrflag=1;
  if(mulflag>1)
  {
  dat=dat*datA;
  datA=dat;
  }
  datA=dat;
}
void div(void)							//chufa
{ divflag++;
  addflag=subflag=mulflag=0;
  clrflag=1;
  if(divflag>1)
  {
  dat=datA/dat;
  datA=dat;
  }
  datA=dat;
}
void equ(void)
{
 
   if(addflag)                           //如果些时做加法运算。。
   {
   dat=dat+datA;                     //计算各存入dat(显示程序会将dat显示的。。)
   }
   if(subflag)
   {
   dat=datA-dat;
   }
   if(mulflag)
   {
   dat=datA*dat;
   }
   if(divflag)
   {
   dat=datA/dat;
   }
   addflag=subflag=mulflag=divflag=0;//运算一次完成后将所有运标志清零。为下次运算作准备。。
   HEX_TO_BCD(dat);	clrflag=1;
}
void calculate_handle(void)//计算函数。。
{	
 if(checkok)//如果检测键值完。则执行以下。
 {
  checkok=0;//检测完标志清零..
  switch (keynum)//如果是+,-,*,/,=则进入相应的函数。。
  {
   case 10 : {add();HEX_TO_BCD(dat);} break;    //如果是按了"+",则进入加法函数。
   case 11 : {sub();HEX_TO_BCD(dat);} break;    //如果是按了"-",则进入减法函数。
   case 12 : {mul();HEX_TO_BCD(dat);} break;    //如果是按了"*",则进入乘法函数。
   case 13 : {div();HEX_TO_BCD(dat);} break;    //如果是按了"/",则进入除法函数。
   case 14 : equ(); break;    //如果是按了"=",则进入等于函数。
   default : datchuli();       //如果不是,计算符(即为数字),则进入数据处理函数。
  }

 }}
/*---------------------------------------------------------------
主函数:将4X4键盘的键值显示在数码管上
---------------------------------------------------------------*/
void main(void)
{
	byte k;
	while(1)
 	{
 		k=keysearch();
		
		if(k!=0xff)   
    {
    	delayms(10);//有键按下
    	k=keysearch();
		keybranch(k);
  		do
		{
  			k=keysearch();
			scandisp();
  		} while(k!=0xff);      //等待键释放
     }
	 calculate_handle();
	 scandisp();
  }
}

设计体会

一开始只是会矩阵键盘和LCD扫描显示,所以当时是想做一个计算器应该还是挺容易的,但直到真正开始做的时候,才发现并不简单。一开始,想的就是,把运算键前输入的数值存到一个变量,后面的数值存到另一个变量内,然后再运算。但问题就来了,如何让单片机知道两次输入的数值要存到不同的变量去?如何把这些变量分别显示到显示管上?然后就要引入更多的变量、设计更多的函数。做出来的第一个版本,能实现加减乘除了,但还有一些问题。按下运算符时,数码管就会直接清零,不像真正计算器那样,按下运算符数码管上数值先不变,等下一数值输入时才变。还有不能实现连续运算的问题,最后还是修改好了。总的来说,这次设计的过程是很有挑战的,尤其对于我这种不善于编程的人来讲,遇到的问题,虽说比较麻烦,但还是车到山前必有路

2015-06-02 21:28:33 qq_23674297 阅读数 1002
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3396 人正在学习 去看看 朱有鹏


单片机——简单计算器
       
         最近喜欢看单片机,用C写了个简单的计算器,LCD作为
显示。在proteus上仿真和开发板上都可以运行。

         源代码及电路图: http://pan.baidu.com/s/1c0pmG0o


图片


图片
 


/*
  一个简单的整数计算器。

  从4*4矩阵键盘接收 0~9 组成的数字,做加减乘除运算,
  并将输入的键值和运算结果显示在LCD上。运算有效位好像只有6位。
*/

#include <reg51.h>   // 51系列单片机头文件
#include <math.h>
#include "LCD.h"       //  引入 自己编写的 LCD 文件

#define uchar unsigned char
#define uint unsigned int 

#define KEY P1  //   键盘 接口
#define LED P0  //   7段数码管用于显示 按下键盘的键值

sbit BEEP = P3^7; //  蜂鸣
uchar code DSY_CODE[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0x00}; //  0~f
uchar  fuhao = '=', k = 0, KeyNO;    //  fuhao  用于 记录 最近 使用的 运算符
unsigned long  num, a[12], temp1 = 0, temp2 = 0;   //  temp1 记录 当前输入的数值  temp2 记录 上次输入的数值

 //===================================================================//

void delay_ms(uint x); //  微秒级延时函数
void Keys_Scan();       //  接收 从键盘输入的 键值
void Beep();     //   响铃函数
void fenjie (unsigned long n);  //  LCD数字显示函数
void LCD_Show();//  LCD键值显示函数


 //================== 调试主函数 ================================//
void main()
{
KEY = 0xf0;
LED = 0xff;  //  数码管 灭

IE=0X81;
TCON=0X01;  //  TCON=0X00;     电平触发时,会接收两次 ??

Init();
W_CMD(0x80+16);

while(1); //  主程序 停留   等待中断
}

//============= 微秒级延时函数 =======================//

void delay_ms(uint x)
{
uchar t;
while(x--)
{
for(t=0;t<120;t++);
}
}

//================== 键值接收函数 ================================//

void Keys_Scan()     //  接收 从键盘输入的 键值
{
KEY = 0xf0;    //  列置0,求行 
if(KEY!=0xf0)    //  若 有键按下
{
delay_ms(10);
if(KEY!=0xf0)  //  确认 是否键按下
{
switch(KEY)   //   求出 所在行 KeyN0按下,松开时显示
{
case 0xe0: KeyNO = 0; break;
case 0xd0: KeyNO = 4; break;
case 0xb0: KeyNO = 8; break;
case 0x70: KeyNO = 12; break;
 

KEY = 0x0f;     //  行置0,求列
switch(KEY)
{
case 0x0e: KeyNO = KeyNO + 0; break;
case 0x0d: KeyNO = KeyNO + 1; break;
case 0x0b: KeyNO = KeyNO + 2; break;
case 0x07: KeyNO = KeyNO + 3;break;
}
while(KEY!=0x0f) ;
}
}
}

//================== 响铃函数 ================================//
void Beep()  //   响铃函数
{
uchar i;
for(i=0;i<100;i++)
{
delay_ms(1);;
BEEP = ~BEEP;
}
BEEP = 1;
}

 //================== LCD数字显示函数 ================================//

void fenjie (unsigned long n) //  接收一个数,求出长度 k , 将其逐位分解,并存放在数组 a【】中  然后输出在 LCD上
{
unsigned long  t = n;
uchar  i = 1;
k = 0;
while(t >= 1)   //  计算 n 的位数  k
{
t = t / 10;
k++;
}

for(i=0;i<k-1;i++)
{
a[i]=0;  

while(n >= pow(10,k-i-1))  
a[i]++;  
n = n - pow(10,k-i-1); 
}
}

a[i]=n;
for(i=0;i<k;i++)
{
num = 48 + a[i];
W_DATA(num);
}
}

//================== LCD键值显示函数 ================================//

void LCD_Show()
{
if(KeyNO < 10)
{
num = 48 + KeyNO;
W_DATA(num);

a[k++] = KeyNO;
if(k==1) 
{
temp1 = a[0];
}
else
{
temp1 = temp1 * 10 + a[k-1];  //  记录 第一个 计算的数字
}
}

else if(KeyNO==10)     //  =
num = 61;
W_DATA(num);

if(fuhao == '=')
{
fenjie(temp1);
}
if(fuhao == '+')
{
temp1 = temp1 + temp2;
fenjie(temp1);
}
if(fuhao == '-')
{
temp1 = temp2 - temp1;
fenjie(temp1);
}
if(fuhao == '*')
{
temp1 = temp1 * temp2;
fenjie(temp1);
}
if(fuhao == '/')
{
temp1 = temp2 / temp1  ;
fenjie(temp1);
}

fuhao = '='; 
}  
   
else if(KeyNO==12)    //  +++++
fuhao = '+';
k = 0;

num = 43;  
W_DATA(num); 
temp2 = temp1;
}  
else if(KeyNO==13)   //  ----- 
fuhao = '-';
k = 0;

num = 45;  
W_DATA(num);
temp2 = temp1;  
}
else if(KeyNO==14)   //  *****
fuhao = '*';
k = 0;

num = 42;  
W_DATA(num); 

temp2 = temp1; 
}
else if(KeyNO==15)  //    ////
fuhao = '/';
k = 0;

num = 47;  
W_DATA(num); 

temp2 = temp1;
}

else if(KeyNO==11)  
{
W_CMD(0x01);   //  清屏
Init();
W_CMD(0x80+16);

temp1 = 0;
k = 0;
fuhao = '=';
}
}



 //=================== 外部中断0 =============================//


void Int0 ()  interrupt 0//  外部中断0  负 跳沿触发
{
Keys_Scan();
LED = DSY_CODE[KeyNO];
Beep();
LCD_Show(); 
KEY = 0xf0;
}
 

2019-06-26 09:38:09 weixin_42625444 阅读数 565
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3396 人正在学习 去看看 朱有鹏

 

关注【电子开发圈】微信公众号,一起学习吧!

电子DIY、Arduino、51单片机、STM32单片机、FPGA……
电子百科、开发技术、职业经验、趣味知识、科技头条、设备拆机……

点击链接,免费下载100G+电子设计学习资料!

http://mp.weixin.qq.com/mp/homepage?__biz=MzU3OTczMzk5Mg==&hid=7&sn=ad5d5d0f15df84f4a92ebf72f88d4ee8&scene=18#wechat_redirect

 

使用元件:

  • STC51单片机芯片
  • 51单片机核心板
  • LCD1602
  • 矩阵键盘
  • 11.0592MHz晶振

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

实现效果:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

实现原理:

中缀表示法实现计算器正常情况下用栈实现,但由于51单片机内存小,无法使用malloc函数,以及一些莫名其妙的原因导致无法给指针赋值,所以在此处使用数组来模拟栈中情况,以两个int类型变量指示组中数量(模拟栈顶指针)

中缀表示法实现原理见

http://www.cnblogs.com/hughdong/p/6837247.html

http://www.cnblogs.com/hughdong/p/7088915.html

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

实现代码:

/********************************
实验箱实现计算器
*********************************
器件连接:
89C51 P0.0 - LCD D0
89C51 P0.1 - LCD D1
89C51 P0.2 - LCD D2
89C51 P0.3 - LCD D3
89C51 P0.4 - LCD D4
89C51 P0.5 - LCD D5
89C51 P0.6 - LCD D6
89C51 P0.7 - LCD D7
89C51 P2.0 - LCD RS
89C51 P2.1 - LCD RW
89C51 P2.2 - LCD EN
89C51 P3.0 - k1
89C51 P3.1 - k2
89C51 P3.2 - k3
89C51 P1.0 - BUTTON L1
89C51 P1.1 - BUTTON L2
89C51 P1.2 - BUTTON L3
89C51 P1.3 - BUTTON L4
89C51 P1.4 - BUTTON H1
89C51 P1.5 - BUTTON H2
89C51 P1.6 - BUTTON H3
89C51 P1.7 - BUTTON H4
*********************************
按键对应数值
1 2 3 +
4 5 6 -
7 8 9 *
. 0 # /
独立按键
k1: (
k2: )
k3: C
********************************/
#include <reg52.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define OK 1
#define ERROR 0
typedef unsigned char uchar;
typedef unsigned int uint;
typedef char Status;
sbit rs = P2 ^ 0; // LCD-RS
sbit rw = P2 ^ 1; // LCD-RW
sbit en = P2 ^ 2; // LCD-EN
sbit leftBracket = P3 ^ 0; // 右括号
sbit rightBracket = P3 ^ 1; // 左括号
sbit reset = P3 ^ 2; // 重置算式按键
/*******************************/
void Delay(uint z); // 延时函数
void UART_Init(); // 串口初始化
void UART_Send_Byte(uchar ucData); // 串口发送单字节
void UART_Send_Str(uchar *string); // 串口发送字符串
void UART_Send_Enter(); // 串口发送回车
void Init_LCD(); // 初始化LCD1602
void WriteData(uchar dat); // LCD写字节
void WriteCom(uchar com); // LCD写指令
void ClearScreen(); // LCD清屏
int InputJudge(char keyValue); // 判断按键是操作符还是操作数
char PriorityJudge(char optr1, char optr2); // 操作数比较
float Calc(char optr, float num1, float num2); // 四则运算
void LCD_Float(float f); // 测试函数,LCD第二行显示float
void LCD_Int(int dat); // 测试函数,LCD第二行显示int
void LCD_Char(char c); // 测试函数,根据指针显示char
/*******************************/
void main()
{
    /* 定义运算变量 */
    char arrayChar[20]; // 操作数存放数组
    float arrayFloat[20]; // 操作数存放数组
    int topChar; // 操作符数量
    int topFloat; // 操作数数量
    char tempChar; // 读取数组顶部存放的操作符
    float tempFloat; // 读取数组顶部存放的操作数
    char optr; // 四则运算操作符
    float num1, num2; // 四则运算操作数
    int i; // i作为临时循环使用
    int tenPower; // 参与小数点运算时被除数
    /* 定义硬件操作变量 */
    unsigned char temp; // 按键检索时存放临时值
    unsigned char key; // 按键值 16进制
    unsigned char keyValue; // 按键值 char类型
    unsigned int ipos; // LCD显示指针计数
    unsigned int flag; // flag标记,操作数为1 操作符为0 点运算为2

re: // 按下C键复位,重新输入计算式子

    /* 初始化变量 */
    for (i = 0; i < 20; ++i)
    {
        arrayChar[i] = '0';
        arrayFloat[20] = 0;
    }
    topChar = 0;
    topFloat = 0;
    tenPower = 1;
    ipos = 0;
    flag = 0;

    /* 压入# */
    arrayChar[topChar] = '#';
    topChar++;

    /* 初始化硬件 */
    UART_Init();
    Init_LCD();
    Delay(100);
    while(1)
    {
        P1 = 0xf0;
        leftBracket = 1;
        rightBracket = 1;
        reset = 1;

        /* 按键检测 */
        if (P1 != 0xf0 || !leftBracket || !rightBracket || !reset)
        {
            Delay(20);
            if (P1 != 0xf0)
            {
                temp = P1;
                P1 = 0x0f;
                key = temp | P1;
                while(P1 != 0x0f);
                ipos++;
                if (ipos == 16)
                {
                    ClearScreen();
                    ipos = 0;
                }

                /* 按键赋值 */
                switch(key)
                {
                case 0xEE:keyValue = '1';WriteData(keyValue);break;
                case 0xED:keyValue = '2';WriteData(keyValue);break;
                case 0xEB:keyValue = '3';WriteData(keyValue);break;
                case 0xDE:keyValue = '4';WriteData(keyValue);break;
                case 0xDD:keyValue = '5';WriteData(keyValue);break;
                case 0xDB:keyValue = '6';WriteData(keyValue);break;
                case 0xBE:keyValue = '7';WriteData(keyValue);break;
                case 0xBD:keyValue = '8';WriteData(keyValue);break;
                case 0xBB:keyValue = '9';WriteData(keyValue);break;
                case 0x7D:keyValue = '0';WriteData(keyValue);break;
                case 0xE7:keyValue = '+';WriteData(keyValue);break;
                case 0xD7:keyValue = '-';WriteData(keyValue);break;
                case 0xB7:keyValue = '*';WriteData(keyValue);break;
                case 0x77:keyValue = '/';WriteData(keyValue);break;
                case 0x7E:keyValue = '.';WriteData(keyValue);break;
                case 0x7B:keyValue = '#';WriteData('=');break;
                }
            }
            else if(!leftBracket)
            {
                Delay(20);
                if (!leftBracket)
                {
                    while(!leftBracket);
                    keyValue = '(';
                    WriteData(keyValue);
                }
            }
            else if(!rightBracket)
            {
                Delay(20);
                if (!rightBracket)
                {
                    while(!rightBracket);
                    keyValue = ')';
                    WriteData(keyValue);
                }
            }
            else if(!reset) // 当按下复位C键时,清屏并回到初始状态
            {
                Delay(20);
                if (!reset)
                {
                    while(!reset);
                    ClearScreen();
                    goto re;
                }
            }

            /* 运算过程 */
            if (keyValue == '.') // 当为点运算时,flag标识为2,后续输入的数字进行小数运算
            {
                flag = 2;
                tenPower = 1;
                continue;
            }
            if (InputJudge(keyValue)) //判断输入是否为数字
            {
                if (flag == 0) // <上次是操作符,本次是操作数> 压栈
                {
                    arrayFloat[topFloat] = (float)(keyValue - '0');
                    topFloat++;
                    flag = 1;
                    continue;
                }
                else if(flag == 1) // <输入10位以上数字> 弹栈值*10+本次值
                {
                    topFloat--;
                    tempFloat = arrayFloat[topFloat];
                    arrayFloat[topFloat] = (float)(tempFloat * 10 + (keyValue - '0'));
                    topFloat++;
                    flag = 1;
                    continue;
                }
                else if (flag == 2) // <输入小数> 弹栈值+本次值/(10的n次方)
                {
                    topFloat--;
                    tempFloat = arrayFloat[topFloat];
                    tenPower = tenPower * 10;
                    tempFloat = tempFloat + ((float)(keyValue - '0') / tenPower);
                    arrayFloat[topFloat] = tempFloat;
                    topFloat++;
                    flag = 2;
                    continue;
                }
            }
            /****************************************************
            当按键值为符号时,进行计算或压入运算符组
            优先级为 > 时,重复对比并计算
            ****************************************************/
            else
            {
reCalc:
                tempChar = arrayChar[topChar - 1];
                switch(PriorityJudge(tempChar, keyValue)) // 判断本次输入符号与操作符数组顶部元素优先级
                {
                /****************************************************
                本次输入压入操作符组顶部,完毕后重新获取按键
                ****************************************************/
                case '<':
                    arrayChar[topChar] = keyValue;
                    topChar++;
                    flag = 0;
                    continue;
                /****************************************************
                ()或#闭合时,弹出顶部元素
                ()闭合后重新获取按键
                #弹出说明公式计算完毕,LCD显示结果并进入死循环
                计算结束后,按下复位键代码回到Line 90,程序重置
                ****************************************************/
                case '=':
                    topChar--;
                    tempChar = arrayChar[topChar];
                    if (tempChar == '#')
                    {
                        LCD_Float(arrayFloat[topFloat - 1]);
                        /*
                        LCD_Int(topFloat);
                        UART_Send_Enter();
                        UART_Send_Str("End");
                        */
                        while(1)
                        {
                            if(!reset)
                            {
                                Delay(20);
                                if (!reset)
                                {
                                    while(!reset);
                                    ClearScreen();
                                    goto re; // line 90
                                }
                            }
                        }
                    }
                    flag = 0;
                    continue;
                /****************************************************
                弹出两个操作数和一个操作符进行四则运算
                运算结束后将结果操作数压入
                程序回到 reCalc处 Line231,继续弹出操作符对比
                ****************************************************/
                case '>':
                    topChar--;
                    optr = arrayChar[topChar];
                    topFloat--;
                    num2 = arrayFloat[topFloat];
                    topFloat--;
                    num1 = arrayFloat[topFloat];
                    arrayFloat[topFloat] = Calc(optr, num1, num2);
                    topFloat++;
                    flag = 0;
                    goto reCalc;
                }
            }
        }
        /*
        char串口打印测试 
        UART_Send_Enter();
        UART_Send_Str("optr:");
        UART_Send_Byte(optr);
        int串口打印测试 
        UART_Send_Enter();
        UART_Send_Byte(topFloat + '0');
        */
    }
}
void UART_Init()
{
    SCON = 0x50;
    TMOD = 0x20;
    PCON = 0x00;
    TH1 = 0xFD;
    TL1 = 0xFD;
    TR1 = 1;
    ES = 1;
    EA = 1;
    ET1 = 0;
}
void UART_Send_Byte(uchar ucData)
{
    SBUF = ucData;
    while(!TI);
    TI = 0;
}
void UART_Send_Str(uchar *string)
{
    while(*string)
        UART_Send_Byte(*string++);
}
void UART_Send_Enter()
{
    UART_Send_Byte(0x0d);
    UART_Send_Byte(0x0a);
}
void Init_LCD()
{
    en = 0;
    WriteCom(0x38);
    WriteCom(0x0e);
    WriteCom(0x06);
    WriteCom(0x01);
    WriteCom(0x80 + 0x1);
}
void WriteData(uchar dat)
{
    rs = 1;
    rw = 0;
    P0 = dat;
    Delay(5);
    en = 1;
    Delay(5);
    en = 0;
}
void WriteCom(uchar com)
{
    rs = 0;
    rw = 0;
    P0 = com;
    Delay(5);
    en = 1;
    Delay(5);
    en = 0;
}
void ClearScreen()
{
    WriteCom(0x01);
}
void Delay(uint z)
{
    uint x, y;
    for(x = z; x > 0; x--)
        for(y = 110; y > 0; y--);
}
int InputJudge(char keyValue)
{
    switch(keyValue)
    {
    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':return OK;break;
    case '+':case '-':case '*':case '/':case '(':case ')':case '#':return ERROR;break;
    default:break;
    }
}
char PriorityJudge(char optr1, char optr2)
{
    int i, j;
    char priorityTable[7][7] =
    {
        // +   -    *    /    (    )    #
        {'>', '>', '<', '<', '<', '>', '>'}, // +
        {'>', '>', '<', '<', '<', '>', '>'}, // -
        {'>', '>', '>', '>', '<', '>', '>'}, // *
        {'>', '>', '>', '>', '<', '>', '>'}, // /
        {'<', '<', '<', '<', '<', '=', '0'}, // (
        {'>', '>', '>', '>', '0', '>', '>'}, // )
        {'<', '<', '<', '<', '<', '0', '='}  // #
    };
    switch(optr1)
    {
    case '+':i = 0;break;
    case '-':i = 1;break;
    case '*':i = 2;break;
    case '/':i = 3;break;
    case '(':i = 4;break;
    case ')':i = 5;break;
    case '#':i = 6;break;
    }
    switch(optr2)
    {
    case '+':j = 0;break;
    case '-':j = 1;break;
    case '*':j = 2;break;
    case '/':j = 3;break;
    case '(':j = 4;break;
    case ')':j = 5;break;
    case '#':j = 6;break;
    }
    return priorityTable[i][j];
}
float Calc(char optr, float num1, float num2)
{
    switch(optr)
    {
    case '+':return (num1 + num2);break;
    case '-':return (num1 - num2);break;
    case '*':return (num1 * num2);break;
    case '/':return (num1 / num2);break;
    }
}
void LCD_Float(float f)
{
    char str[7];
    int i, length;
    for (i = 0; i < 7; ++i)
        str[i] = '0';
    length = sprintf(str, "%g", f);
    WriteCom(0x80 + 0x40);
    Delay(20);
    for (i = 0; i < length; ++i)
    {
        WriteData(str[i]);
        Delay(20);
    }
}
void LCD_Int(int dat)
{
    char str[7];
    int i, length;
    for (i = 0; i < 7; ++i)
        str[i] = '0';
    length = sprintf(str, "%d", dat);
    WriteCom(0x80 + 0x48);
    Delay(20);
    for (i = 0; i < length; ++i)
    {
        WriteData(str[i]);
        Delay(20);
    }
}
void LCD_Char(char c)
{
    WriteData(c);
    Delay(20);
}

 

2018-05-19 10:52:42 zhuisaozhang1292 阅读数 498
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3396 人正在学习 去看看 朱有鹏

目的:实现简易计算器

实行功能:实现包含加减乘除括号在内的四则运算

在自学任何技能的过程中,一定要自己亲自做一遍,才能学习到真正的技能,走马观花的学习充其量只能了解,并不会应用,在此勉励自己,不忘初心 方得始终 ,断续续编了几天的计算器代码,终于把它完成了,可以接着往下学习了,加油奋斗

代码如下所示:

'''
Created on 

@author: hcl
'''
import re

def mult(str_test):
    '''
        功能:对字符串str_test内只含有  * / 时,进行从左到右运算,并返回运算结果
        输入:字符串
        输出:字符串
    '''
    if (str_test[0] == '('):
        str_test = str_test[1:-1]
    content = re.split('[*,/]', str_test)
    len_str_test = len(content)
    if len_str_test > 1 : 
        if str_test[len(content[0])] == '/':
            stemp =  float(content[0])/float(content[1])
        else:
            stemp =  float(content[0])*float(content[1])  
        str_test = str(stemp)+str_test[len(content[0])+len(content[1])+1:]
        return mult(str_test)
    else:
        return str_test

def pas(str_test):
    '''
        功能:对字符串str_test内只含有+ - 时,进行从左到右运算,并返回运算结果
        输入:字符串
        输出:字符串
    '''
    if (str_test[0] == '('):
        str_test = str_test[1:-1]
    content = re.split('[+,-]', str_test)
    if str_test[0] == '-':
        content[1] = '-' + content[1]
        content = content[1:]
    len_content = len(content)
    if len_content > 1 : 
        if str_test[len(content[0])] == '+':
            stemp =  float(content[0])+float(content[1])
        else:
            stemp =  float(content[0])-float(content[1])  
        str_test = str(stemp)+str_test[len(content[0])+len(content[1])+1:]
        return pas(str_test)
    else:
        return str_test

def find_kh(str_test):
    """
       功能:寻找字符串str_test中的最里层括号
    
    """
    try:
        itm = re.search("\([^()]*\)", str_test).group() #截取最底层括号及其包含内容 如 (2+4)
        n = re.search("\([^()]*\)", str_test).span() #截取内容的序号
        return itm,n[0],n[1]
    except AttributeError :
        pass
        
def replaceStr(str_test,start,end,new_str_test):
    """
       功能:替换字符串,str_test为原字符串,new_str_test为经过加减乘除以后的结果
    
    """
    return str_test.replace(str_test[start:end],new_str_test)

def change_sign(str_test):
    """
       功能:处理str_test中的符号
    
    """
    str_test = re.sub(r'--','+',str_test)
    str_test = re.sub(r'\+-','-',str_test)
    str_test = re.sub(r'\+\+','+',str_test)
    str_test = re.sub(r'-\+','-',str_test)
    while re.findall(r'\*-',str_test):              #处理特殊字符 *-
        if re.search(r'\*-',str_test):
            start,end = re.search(r'\*-',str_test).span()
            str_test= str_test[0:start+1]+str_test[start+2:]
            while start > 0:
                pattern = re.compile(r'-')
                if pattern.search(str_test,start-1,start):              
                    str_test= str_test[:start-1] + '+' + str_test[start:]
                    break
                    
                pattern2 = re.compile(r'\+')
                if pattern2.search(str_test,start-1,start):           
                    str_test= str_test[:start-1] + '-' + str_test[start:]
                    break                
                start = start - 1 
    while re.findall(r'/-',str_test):               #处理特殊字符 /-
        if re.search(r'/-',str_test):
            start,end = re.search(r'/-',str_test).span()
            str_test= str_test[0:start+1]+str_test[start+2:]
            while start > 0:
                pattern = re.compile(r'-')
                if pattern.search(str_test,start-1,start):              
                    str_test= str_test[:start-1] + '+' + str_test[start:]
                    break                    
                pattern2 = re.compile(r'\+')
                if pattern2.search(str_test,start-1,start):           
                    str_test= str_test[:start-1] + '-' + str_test[start:]
                    break               
                start = start - 1      
    return str_test

def lTor(str_test):
    """
       功能:处理无括号的加减乘除操作
       输入:字符串
       输出:字符串
    
    """
    str_test = change_sign(str_test)
    matchObj = re.search('[*,/]', str_test)
    if matchObj:
        content = re.split('[+,-]', str_test)
        while re.search('[*,/]', str_test):
            start = 0
            content = re.split('[+,-]', str_test)
            for item in content:
                if re.search('[*,/]', item): 
                    stemp = mult(item)    
                    str_test = str_test.replace(str_test[start:start+len(item)],stemp)
                    break
                start += len(item)+1
        else:
            str_test = change_sign(str_test)
            str_test = pas(str_test)
            return str_test  
    else:
        str_test = change_sign(str_test)
        str_test = pas(str_test)
        return str_test  
    
def cac(str_test):
    """
        功能:计算主入口
        输入:待计算的字符串
        输出:返回计算结果字符串
    """
    str_test = change_sign(str_test)   
    if find_kh(str_test):
        itm,start,end = find_kh(str_test)
#         if itm[0] == '(':
#             itm = itm[1:-1]
        if itm[0:2] == '(+':
            itm = itm[2:-1]
        if itm[0] == '(':
            itm = itm[1:-1]    
        str_test = replaceStr(str_test,start,end,lTor(itm))
        return cac(str_test)
    else:
        str_test = lTor(str_test)
        return str_test
     
test123 = "2-4*(3*2)"
test = "3-5-5"
test11 = "1-2*((-40/-5)-5+5*2+3/2)+(-40*-5)"
t = "1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))"

ttttt = "1-2*-1.5+1+2*-1.5-1-2*-1.5"
#print(cac(test11))
#print(cac(test123))
#print(cac(test))

#change_sign(test11)

print(cac(t))

#print(cac(t))

计算结果:2776672.6952380957
2019-01-08 21:17:44 lin5103151 阅读数 4454
  • 51单片机综合小项目-第2季第4部分

    本课程是《朱有鹏老师单片机完全学习系列课程》第2季第4个课程,也是51单片机学完之后的一个综合小项目,该项目运用了开发板上大多数外设设备,并将之结合起来实现了一个时间、温度显示以及报警功能、时间调整功能等单片机控制常见的功能,有一定代码量,需要一定调试技巧和编程能力来完成,对大家是个很好的总结和锻炼,并且能拓展项目经验。

    3396 人正在学习 去看看 朱有鹏

1.简介
本计算器是以MCS-51系列AT89C51单片机为核心构成的简易计算器系统。该系统通过单片机控制,实现对4*4键盘扫描进行实时的按键检测,并由LCD1602显示屏将过程与结果显示出来。
2.硬件原理图
在这里插入图片描述
硬件主要由四部分组成

  • 单片机最小系统
  • 4*4矩阵键盘
  • LCD1602显示屏
  • 系统电源

3.程序设计
(1)矩阵键盘驱动程序

/*------------------------------------------------
         矩阵键盘按键值
  			| 1 | 2 | 3 | + |  
  			| 4 | 5 | 6 | - |  
  			| 7 | 8 | 9 | * |  
  			| 0 | . | = | / | 
  #define KeyPort P1

/*------------------------------------------------
按键扫描函数,返回扫描键值
------------------------------------------------*/
unsigned char KeyScan(void)  //键盘扫描函数,使用行列反转扫描法
{
 unsigned char cord_h,cord_l;//行列值中间变量
 KeyPort=0x0f;            //行线输出全为0
 cord_h=KeyPort&0x0f;     //读入列线值
 if(cord_h!=0x0f)    //先检测有无按键按下
 {
  DelayMs(10);        //去抖
  if((KeyPort&0x0f)!=0x0f)
  {
    cord_h=KeyPort&0x0f;  //读入列线值
    KeyPort=cord_h|0xf0;  //输出当前列线值
    cord_l=KeyPort&0xf0;  //读入行线值

    while((KeyPort&0xf0)!=0xf0);//等待松开并输出

    return(cord_h+cord_l);//键盘最后组合码值
   }
  }return(0xff);     //返回该值
}
/*------------------------------------------------
          按键值处理函数,返回扫键值
           可以根据需要改变返回值
------------------------------------------------*/
unsigned char KeyPro(void)
{
 switch(KeyScan())
 {
  case 0x7e:return '1';break;//0 按下相应的键显示相对应的码值
  case 0x7d:return '2';break;//1
  case 0x7b:return '3';break;//2
  case 0x77:return '+';break;//3

  case 0xbe:return '4';break;//4
  case 0xbd:return '5';break;//5
  case 0xbb:return '6';break;//6
  case 0xb7:return '-';break;//7

  case 0xde:return '7';break;//8
  case 0xdd:return '8';break;//9
  case 0xdb:return '9';break;//a
  case 0xd7:return 'x';break;//b

  case 0xee:return '0';break;//c
  case 0xed:return '.';break;//d
  case 0xeb:return '=';break;//e
  case 0xe7:return '/';break;//f
  default:return 0xff;break;
 }
}

(2)LCD1602驱动程序

#define CHECK_BUSY

sbit RS = P2^4;   //定义端口 
sbit RW = P2^5;
sbit EN = P2^6;

#define RS_CLR RS=0 
#define RS_SET RS=1

#define RW_CLR RW=0 
#define RW_SET RW=1 

#define EN_CLR EN=0
#define EN_SET EN=1

#define DataPort P0

/*------------------------------------------------
              判忙函数
------------------------------------------------*/
 bit LCD_Check_Busy(void) 
 { 
#ifdef CHECK_BUSY
 DataPort= 0xFF; 
 RS_CLR; 
 RW_SET; 
 EN_CLR; 
 _nop_(); 
 EN_SET;
 return (bit)(DataPort & 0x80);
#else
 return 0;
#endif
 }
/*------------------------------------------------
              写入命令函数
------------------------------------------------*/
 void LCD_Write_Com(unsigned char com) 
 {  
 while(LCD_Check_Busy()); //忙则等待
 RS_CLR; 
 RW_CLR; 
 EN_SET; 
 DataPort= com; 
 _nop_(); 
 EN_CLR;
 }
/*------------------------------------------------
              写入数据函数
------------------------------------------------*/
 void LCD_Write_Data(unsigned char Data) 
 { 
 while(LCD_Check_Busy()); //忙则等待
 RS_SET; 
 RW_CLR; 
 EN_SET; 
 DataPort= Data; 
 _nop_();
 EN_CLR;
 }

/*------------------------------------------------
                清屏函数
------------------------------------------------*/
 void LCD_Clear(void) 
 { 
 LCD_Write_Com(0x01); 
 DelayMs(5);
 }
/*------------------------------------------------
              写入字符串函数
------------------------------------------------*/
 void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s) 
 {     
       
 while (*s) 
 	{     
 LCD_Write_Char(x,y,*s);     
 s ++;  x++;   
 	}
 }
/*------------------------------------------------
              写入字符函数
------------------------------------------------*/
void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data) 
 {     
 if (y == 0) 
 	{     
 	LCD_Write_Com(0x80 + x);     
 	}    
 else 
 	{     
 	LCD_Write_Com(0xC0 + x);     
 	}        
 LCD_Write_Data( Data);  
 }
/*------------------------------------------------
              初始化函数
------------------------------------------------*/
void LCD_Init(void) 
{
	 LCD_Write_Com(0x38);    /*显示模式设置*/ 
	 DelayMs(5); 
	 LCD_Write_Com(0x38); 
	 DelayMs(5); 
	 LCD_Write_Com(0x38); 
	 DelayMs(5); 
	 LCD_Write_Com(0x38);  
	 LCD_Write_Com(0x08);    /*显示关闭*/ 
	 LCD_Write_Com(0x01);    /*显示清屏*/ 
	 LCD_Write_Com(0x06);    /*显示光标移动设置*/ 
	 DelayMs(5); 
	 LCD_Write_Com(0x0C);    /*显示开及光标设置*/
} 

(3)主函数

/*------------------------------------------------
                    主程序
------------------------------------------------*/
main()
{
 unsigned char num,i,sign;                  
 unsigned char temp[16];        //最大输入16个
 bit firstflag;
 float a=0,b=0;
 unsigned char s;

 
 LCD_Init();         //初始化液晶屏
 DelayMs(10);        //延时用于稳定,可以去掉
 LCD_Clear();
 LCD_Write_String(0,0," LCD calculator");    //写入第一行信息,主循环中不再更改此信息,所以在while之前写入
 LCD_Write_String(0,1," Fun: + - x / ");    //写入第二行信息,提示输入密码
 while (1)         //主循环
 {
   num=KeyPro();  //扫描键盘
   if(num!=0xff)  //如果扫描是按键有效值则进行处理
   { 
      if(i==0)    //输入是第一个字符的时候需要把改行清空,方便观看
	  LCD_Clear();
	 if(('+'==num)|| (i==16) || ('-'==num) || ('x'==num)|| ('/'==num) || ('='==num))//输入数字最大值16,输入符号表示输入结束
	  {
	     i=0;  //计数器复位
	     if(firstflag==0)  //如果是输入的第一个数据,赋值给a,并把标志位置1,到下一个数据输入时可以跳转赋值给b
	     {
	       sscanf(temp,"%f",&a);
           firstflag=1;
		 }
	     else  
	       sscanf(temp,"%f",&b);
	     for(s=0;s<16;s++) //赋值完成后把缓冲区清零,防止下次输入影响结果
		    temp[s]=0;
         LCD_Write_Char(0,1,num); 
	  ///////////////////////
	     if(num!='=')      //判断当前符号位并做相应处理
	       sign=num;      //如果不是等号记下标志位
	     else
	     {  
		    firstflag=0;   //检测到输入=号,判断上次读入的符合
            switch(sign)
	       {
		     case '+':a=a+b;
			 break;
			 case '-':a=a-b;
			 break;
			 case 'x':a=a*b;
			 break;
			 case '/':a=a/b;
			 break;
			 default:break;
		   }
		   sprintf(temp,"%g",a);    //输出浮点型,无用的0不输出
           LCD_Write_String(1,1,temp);//显示到液晶屏
		   sign=0;a=b=0;            //用完后所有数据清零
		   for(s=0;s<16;s++)
		      temp[s]=0;
		 }
	  }
     else	if(i<16)
	 {
	    if((1==i)&& (temp[0]=='0') )//如果第一个字符是0,判读第二个字符
	    {
		  if(num=='.')  //如果是小数点则正常输入,光标位置加1
		  {
		    temp[1]='.';
			LCD_Write_Char(1,0,num);//输出数据
			i++;
          }           //这里没有判断连续按小数点,如0.0.0 
		 else
		 {
		   temp[0]=num; //如果是1-9数字,说明0没有用,则直接替换第一位0
		   LCD_Write_Char(0,0,num);//输出数据
		 }
	   }
	   else
	   {
         temp[i]=num; 
         LCD_Write_Char(i,0,num);//输出数据
	     i++;   //输入数值累加
	   }
	 }
    }	
  }
}

源码+AD电路图 下载:关注公众号,首页回复“计算器”获取资料
在这里插入图片描述

简易计算器

阅读数 986

没有更多推荐了,返回首页