用单片机做测试，定义了ulong类型，直接目标板运行只能到...

只看该作者 · 2017-12-28 14:27

         在程序起始位置定义了一些32位变量，不是说好ulong类型可以0  -  4294967295么？
            ulong       X_Data,Y_Data;             //XY当前值
            ulong       D_Data;                //点动输入值
            ulong       XRun_Data;                //X设定值
            ulong       YRun_Data;                //Y设定值
            ulong       DRun_Data;                //点动运行值

目标板输入超过65535就出错，
然后直接在主程序中给变量赋值，
0
显示
111111
显示
222222
显示
333333
显示
444444
显示
555555
显示
666666
显示
777777
显示
888888
显示
999999
显示
能够正确显示666666
到777777就出错了。
按键最多只能显示到65536不出错，
主程序可以显示6个数字 111111-666666.
奇怪。

1万 · 2017-12-28 14:36

过程不明不白的，怎么能说明问题

只看该作者 · 2017-12-28 14:43

ayb_ice 发表于 2017-12-28 14:36
过程不明不白的，怎么能说明问题

在单片机控制板通过按键输入数据再显示，输入数据超过65535就出错，但是在主程序直接给变量赋值，
就可以显示到666666.这样说可以不？

1万 · 2017-12-28 15:20

czdpj 发表于 2017-12-28 14:43
在单片机控制板通过按键输入数据再显示，输入数据超过65535就出错，但是在主程序直接给变量赋值，
就可以 ...

这充分说明你的输入程序处理有问题，其它地方也有问题，不是ulong自身的问题

只看该作者 · 2017-12-28 15:32

ayb_ice 发表于 2017-12-28 15:20
这充分说明你的输入程序处理有问题，其它地方也有问题，不是ulong自身的问题
...

等一下串口仿真试试，什么都不好说。
我倒希望程序有问题，那样好解决。
谢谢。

只看该作者 · 2017-12-28 15:59

只看该作者 · 2017-12-28 16:01

scanf可不知道你的变量是什么类型，它只知道一个变量的地址，和你给它的格式串。
格式串里面要用“%ld”或"%lu"。

只看该作者 · 2017-12-28 16:44

QuakeGod 发表于 2017-12-28 16:01
scanf可不知道你的变量是什么类型，它只知道一个变量的地址，和你给它的格式串。
格式串里面要用“%ld”或" ...

#include <reg51.h>
      #include <intrins.h>
      #include<stdio.h>
      #define             uint unsigned int
      #define             uchar unsigned char
      #define ulong       unsigned long
      ulong Buff_Data;
      uint                B_Data;                // 个位
      uint                T_Data;                // 十位
      uint                H_Data;                // 百位
      uint                K_Data;                // 千位
      uint                TK_Data;                // 万位
      uint                M_Data;                // 十万位
      uint                i,j,k,l,m,n;          // 显示存储缓冲
      void JogData_dealwith(ulong Buff_Data1)//ijklmn
      {
      i=Buff_Data1/100000;
      j=(Buff_Data1-i*100000)/10000;
      k=(Buff_Data1-i*100000-j*10000)/1000;
      l=(Buff_Data1-i*100000-j*10000-k*1000)/100;
      m=(Buff_Data1-i*100000-j*10000-k*1000-l*100)/10;
      n=Buff_Data1-i*100000-j*10000-k*1000-l*100-m*10;
      }
      void main()
      {
         ulong Buff_Data;
         SCON=0x50;       //串口工作方式
         TMOD|=0x20;       //确定定时器工作模式
         TH1=0xF3;
         TR1=1;          //开启定时器1
         TI=1;             //
         i=2;j=3;k=6;l=0;m=2,n=7;
         printf("%d%d%d%d%d%d\n",i,j,k,l,m,n);
         while(1)
         {
         Buff_Data=800000;
         JogData_dealwith(Buff_Data);
         printf("%d%d%d%d%d%d\n",i,j,k,l,m,n);
         Buff_Data=987654;
         JogData_dealwith(Buff_Data);
         printf("%d%d%d%d%d%d\n",i,j,k,l,m,n);
         Buff_Data=897652;
         JogData_dealwith(Buff_Data);
         printf("%d%d%d%d%d%d\n",i,j,k,l,m,n);

         }
      }

好像还有问题，接小孩去了回来再试。谢谢

只看该作者 · 2017-12-28 21:34

         uint                B_Data;                // 个位
      uint                T_Data;                // 十位
      uint                H_Data;                // 百位
      uint                K_Data;                // 千位
      uint                TK_Data;                // 万位
      uint                M_Data;                // 十万位
uint改ulong似乎没问题了。
            ulong       Key_val;                // 个位存储缓冲
            ulong       B_Data;                // 个位
            ulong       T_Data;                // 十位
            ulong       H_Data;                // 百位
            ulong       K_Data;                // 千位
            ulong       TK_Data;                // 万位
            ulong       M_Data;                // 十万位
/*************显示点动输入数据*******************************/
            void Dis_JogData()
            {
            display_graphic_16x8(21,33,xsadd[i],tab0);//
            display_graphic_16x8(22,33,xsadd[j],tab0);//
            display_graphic_16x8(23,33,xsadd[k],tab0);//
            display_graphic_16x8(24,33,xsadd[l],tab0);//
            display_graphic_16x8(25,33,xsadd[m],tab0);//
            display_graphic_16x8(26,33,xsadd[n],tab0);//
            display_graphic_16x8(15,33,xsadd[counter],tab0);//显示数据
            }
/*************点动输入数据处理***********************/
            void JogData_dealwith()//ijklmn
            {
            i=Buff_Data/100000;
            j=(Buff_Data/10000)%10;
            k=(Buff_Data/1000)%10;
            l=(Buff_Data/100)%10;
            m=(Buff_Data/10)%10;
            n=Buff_Data%10;
            }
/*************点动输入数据计算***********************/
            void JogData_calculate (uchar Key_Counter,val)
            {
            if(Key_Counter==1)
            {
            B_Data=val;                      //个位等于按键值
            D_Data=B_Data;                   //点动缓冲器等于个位值
            }
            if(Key_Counter==2)
            {
            T_Data=B_Data;                   //十位等于个位
            B_Data=val;                         //个位等于按键值
            D_Data=10*T_Data+B_Data;             //点动缓冲器等于
            }
            if(Key_Counter==3)
            {
            H_Data=T_Data;                   //百位等于十位
            T_Data=B_Data;                   //十位等于个位
            B_Data=val;                         //个位等于按键值
            D_Data=100*H_Data+10*T_Data+B_Data;//点动缓冲器等于
            }
            if(Key_Counter==4)
            {
            K_Data=H_Data;                   //千位等于百位
            H_Data=T_Data;                   //百位等于十位
            T_Data=B_Data;                   //十位等于个位
            B_Data=val;                         //个位等于按键值
            D_Data=1000*K_Data+100*H_Data+10*T_Data+B_Data;
            }
            if(Key_Counter==5)
            {
            TK_Data=K_Data;                   //万位等于千位
            K_Data=H_Data;                   //千位等于百位
            H_Data=T_Data;                   //百位等于十位
            T_Data=B_Data;                   //十位等于个位
            B_Data=val;                         //个位等于按键值
            D_Data=10000*TK_Data+1000*K_Data+100*H_Data+10*T_Data+B_Data;
            }
            if(Key_Counter==6)
            {
            M_Data=TK_Data;                      //兆位等于万位
            TK_Data=K_Data;                      //万位等于千位
            K_Data=H_Data;                      //千位等于百位
            H_Data=T_Data;                      //百位等于十位
            T_Data=B_Data;                      //十位等于个位
            B_Data=val;                         //个位等于按键值
            D_Data=100000*M_Data+10000*TK_Data+1000*K_Data+100*H_Data+10*T_Data+B_Data;
            }
            if(Key_Counter>6)
            {
            D_Data=0;
            counter=0;
            }
            Buff_Data=D_Data;                   //数据缓冲等于点动缓冲器
            JogData_dealwith();                   //个位十位百位千位万位十万位兆位分离
            }