提问+stc12系列单片机如何实现计算器顺序输入

disguise2012

提问+stc12系列单片机如何实现计算器顺序输入 [复制链接]

最近 接触到 topway大的240160kcw 液晶屏，，，  想实现 如计算器一样的 顺序输入功能，，，即  按下第一个数 后 再按下 第二个数 第一个数进一位，，，，因为 液晶没有字库  所有的 显示 都是用 查表法 ，， 让显示的一个数 移位  实现起来 的确 不容易，，，请问 你们有没有 好的办法？

jishuaihu

没有什么好的办法。
你应该做成模块化的程序，显示只管显示，比如你要显示的一个16位数，最大是65535，你做一个显示16位数的函数。当然这个函数得做的比较全面，比如首个0不显示，像00123的时候前面两个0不显示，类似的东西提前做好，都做到显示函数里面。然后就是你对这个数的处理了，你对输入的数据进行计算，传递给要显示的那个数就行了。对输入的数处理的时候就跟简单了，第一次输入放入个位。第二次输入的时候前面的数乘10加上后面输入的数，第三次的时候一样乘10加上最新输入的数，依次下去就可以了。
我这儿没有现成的程序了，要不可以给你参考一下。自己试试吧

disguise2012

jishuaihu 发表于 2014-3-2 17:59
没有什么好的办法。
你应该做成模块化的程序，显示只管显示，比如你要显示的一个16位数，最大是65535，你 ...

你好，，，谢谢你的回答，，，你说的 这个思路  我也考虑过，，，可是没想通，，，，因为 我这是 用的 矩阵按键  每个按键 有自己的 所代表 的功能，，，，其实就如计算器 的 按键一样，，，你的意思是说 让 按键的输入 先后 让单片机 自己 判断 与运算，，，最后 处理完的 数据 让液晶 显示 就 完了，，，可是  我不懂得 就是 如何 让 单片机 判断按键 的 先后 顺序？ 因为 按键 多，，，只算 数字键 的话 是 0--9   如何有效地检测 按键输入 的确 得有 一个 高效率 的 程序，，，，，这段时间 遇到的 困难不小，，，思维 有些混乱 ，不知道 说明白没

huo_hu

以前做的12864+3key置数
//3按键从lcd输入一个数据。此函数适合输入位数比较多的大数.
//addr：从lcd输入的起始地址，length：数据长度。返回值为输入的数据u32
//需要在输入数据前起始地址已经显示当前设定值.
uint32 Key3_LCD_Input(uint8 addr,uint8 length) {
        uint8 buf[16],tmp=0,pos=0;
        uint16 chr16;                                //当前输入点字符
        uint32 ret;
        LCD_Command(0x0f);                          //开启光标闪烁和反白
        LCD_Command(0x80+addr);                        //光标去起点
        Read_LCD_Char(buf,length);                //12864显示在这里多一道转换成全角字符
        Chg_u8charTou16char(buf,length);
        LCD_Display_String(24,buf);                //全角显示
        LCD_Command(0x80+addr);                        //光标去起点
        while (tmp!=KEY_EXIT) {//按键退出
                switch (tmp) {
                        case KEY_UP:        //当前光标位置数值+
                                Read_LCD_Char((uint8 *)&chr16,2);
                                if (chr16 >= 0xa3b0        && chr16 <=0xa3b8)
                                        chr16++;
                                //else if (chr16 ==0xa3b9) chr16=0xa3b0;        //循环加
                                LCD_Display_16BChar(addr+pos,chr16);
                                LCD_Command(0x80+addr+pos);
                        break;
                        case KEY_DOWN:
                                Read_LCD_Char((uint8 *)&chr16,2);
                                if (chr16 >= 0xa3b1        && chr16 <=0xa3b9) chr16--;
                                //else if (chr16 ==0xa3b0) chr16=0xa3b9;        //循环减
                                LCD_Display_16BChar(addr+pos,chr16);
                                LCD_Command(0x80+addr+pos);
                        break;
                        case KEY_ENTER:
                                pos++;
                                if (pos==length) pos=0;
                                LCD_Command(0x80+addr+pos);                //光标重新定位
                        break;
                }
                Task_Run();
                tmp=Key_Get();
        }//end while
        LCD_Command(0x80+addr);                        //光标去起点
        Read_LCD_Char(buf,length*2);        //
        Chg_u16charTou8char(buf,length);
        ret=Chg_chr_to_uint32(buf);
        LCD_Command(0x0c);                          //关闭光标闪烁和反白
        return ret;
}

hahadiy

//关于数组的定义的问题2013年11月10日13:41
// 编写人 heiheidiy
//基于TX-1C开发板的简易计算器
// 可以实现四位数字的运算，比如  4567+1234         333*1000
// 最大可以输出6位结果
// 不能实现小数运算，数码管最开始的时候显示6个0.
#include
typedef unsigned int uint
typedef unsigned char uchar
sbit dula=P2^6;
sbit wela=P2^7;
//sbit key1=P3^4;
//char z;
double shu1;
int p[8],shu2,shu3;
long s1=0;         //  
uchar t1=0,i,jia,jian,cheng,chu,num0;
uchar code table[]={          // 0~e
0x3f,0x06,0x5b,0x4f,                   //0x3f  0
0x66,0x6d,0x7d,0x07,
0x7f,0x6f,0x77,0x7c,
0x39,0x5e,0x79,0x71};
uchar num,temp,num1;
void delay(uint z)
{
        uint x,y;
        for(x=z;x>0;x--)
                for(y=110;y>0;y--);
}
long keyscan();
void display(long aa);

void main()
{       

        p[0]=-1;
        p[1]=-1;
        p[2]=-1;
        p[3]=-1;
        p[4]=-1;
        p[5]=-1;
        p[6]=-1;
        p[7]=-1;
        num=0;                   //   
        dula=1;
        P0=0;
        dula=0;
        P0=0;
           wela=1;
        P0=0xff;
        wela=0;       
        while(1)
                {                           //76543
                display(keyscan());
                }
}
void display(long aa)                         //   显示函数
{        /*         if((aa/001000<0)&&(aa/10000)>0        )                //
                 else if((aa/10000)<0&&(aa/1000)>0)
                          else if((aa/1000)<0&&(aa/100)>0)
                                  else if((aa/100)<0&&(aa/10)>0)
                                          else if((aa/10)<0)
        */
               
                                         wela=1;
                                        P0=0xfe; //once error
                                        wela=0;       
                                        P0=0;
                               
                                        dula=1;
                                        P0=table[aa/100000];
                                        dula=0;          delay(3);

                                        wela=1;
                                        P0=0xfd;
                                        wela=0;
                                        P0=0;
                                        dula=1;
                                        P0=table[aa%100000/10000];
                                        dula=0;         delay(3);
                               
                                        wela=1;
                                        P0=0xfb;
                                        wela=0;
                                        P0=0;
                                        dula=1;
                                        P0=table[aa%10000/1000];
                                        dula=0;        delay(3);       
                                       
                                                wela=1;
                                        P0=0xf7;
                                        wela=0;
                                        P0=0;
                                        dula=1;
                                        P0=table[aa%1000/100];
                                        dula=0;        delay(3);
                                       
                                                wela=1;
                                        P0=0xef;
                                        wela=0;
                                        P0=0;
                                        dula=1;
                                        P0=table[aa%100/10];
                                        dula=0;        delay(3);
                                       
                                                wela=1;
                                        P0=0xdf;
                                        wela=0;
                                        P0=0;
                                        dula=1;
                                        P0=table[aa%10];
                                        dula=0;        delay(3);       
}
void jisuan()        //   计算输入的数值
{
        if( p[0]>0&&p[1]<0 )
                                                                                                  {
                                                                                                          p[1]=num;
                                                                                                        s1=(p[0]*10+p[1]);
                                                                                                  }
                                                                                                       
                                                                                                else
                                                                                                {
                                                                                                        if( p[0]>0&&p[1]>=0&&p[2]<0)
                                                                                                                {        p[2]=num;
                                                                                                               s1=(p[0]*100+p[1]*10+p[2]);
                                                                                                                }
                                                                                                        else
                                                                                                                  {
                                                                                                                                if(p[0]>0&&p[1]>=0&&p[2]>=0&&p[3]<0)
                                                                                                                         {
                                                                                                                                p[3]=num;
                                                                                                                s1=(p[0]*1000+p[1]*100+p[2]*10+p[3]);
                                                                                                                         }
                                                                                                                  }
                                                                                                }
                                                                                                                 
}



/*
                 
                1 2 3 4
                5 6 7 8
                9 0          =
                * / + -


*/
long keyscan()//键盘扫描程序
{
//t :
                P3=0xfe;
                        temp=P3;
                        temp=temp&0xf0;
                        while(temp!=0xf0)
                                {
                                        delay(5);//沿时去抖
                                        temp=P3;
                                        temp=temp&0xf0;//再次检测
                                        while(temp!=0xf0)
                                        {
                                                temp=P3;//赋值
                                        switch(temp)
                                                {
                                                        case 0xee:
                                                                num=1;
                                                                  if(p[0]<0)
                                                                        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();
                                                                                          }
                                                                break;
                                                        case 0xde:num=2;
                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();                 
                                                                                          }
                                                                break;
                                                        case 0xbe:num=3;
                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();
                                                                                          }
                                                                break;
                                                        case 0x7e:num=4;
                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                                  jisuan();
                                                                                          }
                                                                break;
                                                }
                                        while(temp!=0xf0)//松手检测
                                                {
                                                        temp=P3;
                                                        temp=temp&0xf0;
                                                }
                                        }
                                }

                        P3=0xfd;
                        temp=P3;
                        temp=temp&0xf0;
                        while(temp!=0xf0)
                                {
                                        delay(5);
                                        temp=P3;
                                        temp=temp&0xf0;
                                        while(temp!=0xf0)
                                        {
                                                temp=P3;
                                        switch(temp)
                                                {
                                                        case 0xed:        num=5;
                                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();
                                                                                          }
                                                                break;
                                                        case 0xdd:num=6;
                                                                                        if(p[0]<0)        s1=p[0]=num;        
                                                                            else {       
                                                                                                jisuan();
                                                                                          }
                                                                break;
                                                        case 0xbd:num=7;
                                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();
                                                                                          }
                                                                break;
                                                        case 0x7d:num=8;
                                                                if(p[0]<0)        s1=p[0]=num;        
                                                                            else {
                                                                                         
                                                                                                  jisuan();
                                                                                          
                                                                                         }
                                                                break;
                                                }
                                                                                               
                                        while(temp!=0xf0)
                                                {
                                                        temp=P3;
                                                        temp=temp&0xf0;
                                                }
                                        }
                                }
                               
                        P3=0xfb;
                        temp=P3;
                        temp=temp&0xf0;
                        while(temp!=0xf0)
                                {
                                        delay(5);
                                        temp=P3;
                                        temp=temp&0xf0;
                                        while(temp!=0xf0)
                                        {
                                                temp=P3;
                                        switch(temp)
                                                {
                                                        case 0xeb:           //   s14
                                                        num=9;
                                                        if(p[0]<0)
                                                                s1=p[0]=num;        
                                                                            else
                                                                                        {
                                                                                                        jisuan();         
                                                                                        }
                                                        break;
                                                        case 0xdb:
                                                                num=0;
                                                        
                                                                                                 if( p[0]>0&&p[1]<0 )
                                                                                                  {
                                                                                                          p[1]=num;
                                                                                                        s1=(p[0]*10+p[1]);
                                                                                                  }
                                                                                                       
                                                                                                else
                                                                                                {
                                                                                                        jisuan();
                                                                                                }
                                                                break;
                                                        case 0xbb://goto z;
                                                                        break;
                                                        case 0x7b:
                                                        if(cheng==1)
                                                                          s1=shu1*s1;

                                                        else
                                                        {       
                                                         if(jia==1)
                                                                          s1=shu1+s1;       
                                                                 else
                                                                 { if(jian==1)
                                                                                  s1=shu1-s1;
                                                                 else
                                                                         {
                                                                         if(chu==1)
                                                                                s1=shu1/s1;
                                                                        }
                                                                }
                                                        }
                                                                break;

                                        }
                                        while(temp!=0xf0)
                                                {
                                                        temp=P3;
                                                        temp=temp&0xf0;
                                                }
                                        }
                                }

                        P3=0xf7;
                        temp=P3;
                        temp=temp&0xf0;
                        while(temp!=0xf0)
                                {
                                        delay(5);
                                        temp=P3;
                                        temp=temp&0xf0;
                                        while(temp!=0xf0)
                                        {
                                                temp=P3;
                                        switch(temp)
                                                {
                                                        case 0xe7:                               
                                                                        cheng=1;
                                                                break;
                                                        case 0xd7:
                                                                        chu=1;   //   s18
                                                                break;
                                                        case 0xb7:
                                                                        jia=1;
                                                                break;
                                                        case 0x77:
                                                                        jian=1;
                                                                break;
                                                }               
                                                  t1++;                          //统计数字的次数
                                                        if(t1==1)
                                                        {
                                                                 shu1=s1; t1=0;
                                                        }               
                                                         s1=0;
                                                        p[0]=-1;
                                                        p[1]=-1;
                                                        p[2]=-1;
                                                        p[3]=-1;
                                                        p[4]=-1;
                                                        p[5]=-1;
                                                        p[6]=-1;
                                                        p[7]=-1;
                                        while(temp!=0xf0)
                                                {
                                                        temp=P3;
                                                        temp=temp&0xf0;
                                                }
                                        }
                                }         
return s1;//  猜测将在此处出现10,100之类的数字

}



这是基于TX-1C开发板写的，主要是利用： if(p[0]<0)
                                                                        s1=p[0]=num;        
                                                                            else {
                                                                                                 jisuan();
                                                                                          }

来实现输入数值的计算。以前写的，希望能帮到你。

yuj210

不错不错