标题: STC单片机热敏电阻温度计程序编译不能通过,附STC12C5A.H头文件 [打印本页]
作者: ll13536121668    时间: 2019-4-29 11:04
标题: STC单片机热敏电阻温度计程序编译不能通过,附STC12C5A.H头文件
但是用   Keil uVision 4     编译  不能  通过,STC12C5A.H头文件加入    也不成功'劳烦各位师博看看那里 出错谢谢


单片机源程序如下:
  1. //****************************************/
  2. //*     基于STC12C5A60S2的NTC温度计      */
  3. //*       测温范围-40°～110°             */
  4. //****************************************/
  5. //4位共阳极数码管段码a-h接P27-P20，
  6. //位选端接P3高4位
  7. //NTC使用MF52-103/3435;10K±1％精度;B值:3435±1％
  8. //NTC温度输出端子接P1.0

  10. #include "STC12C5A.H"
  11. #include "intrins.h"
  12. #define u8 unsigned char
  13. #define u16 unsigned int
  14. #define u32 unsigned long int
  15. sbit GW=P2^1;                                     //数码管位码
  16. sbit SW=P2^4;                               
  17. sbit BW=P2^3;                                       
  18. sbit QW=P2^2;       
  19. u8 show[4];                         //显示四位数数组
  20. u32  Temp_Buf[9];        //采样数组
  21. u8 Ledcount,ADCcount;    //数码管显示计数变量，ADC采样次数变量
  22. u8 code smg0[12]={0x0a,0xfa,0x4c,0x68,0xb8,0x29,0x09,0x7a,0x08,0x28,0xfd,0xff};           //数码管段码表，不带小数点:0-9,-,灭
  23. u8 code smg1[11]={0x02,0xf2,0x44,0x60,0xb0,0x21,0x01,0x72,0x00,0x20,0xff};               //数码管段码表，带小数点:0-9,灭      
  24. u8 i,j,m,n;
  25. u32 WD;               //温度值
  26. /************************************************
  27.               NTC阻值与温度关系表
  28. ************************************************/
  29. u32 code NTCcode[] = {
  30. /***电阻值(扩大万倍)****温度值*******序号*******/   
  31.                                 1905562,      // -40.00       0
  32.                                 1834132,      // -39.00       1
  33.                                 1756140,      // -38.00       2
  34.                                 1676467,      // -37.00       3
  35.                                 1595647,      // -36.00       4
  36.                                 1515975,      // -35.00       5
  37.                                 1438624,      // -34.00       6
  38.                                 1364361,      // -33.00       7
  39.                                 1293641,      // -32.00       8
  40.                                 1226678,      // -31.00       9
  41.                                 1163519,      // -30.00       10
  42.                                 1104098,      // -29.00       11
  43.                                 1048272,      // -28.00       12
  44.                                 995847,       // -27.00       13
  45.                                 946608,       // -26.00       14
  46.                                 900326,       // -25.00       15
  47.                                 856778,       // -24.00       16
  48.                                 815747,       // -23.00       17
  49.                                 777031,       // -22.00       18
  50.                                 740442,       // -21.00       19
  51.                                 705811,       // -20.00       20
  52.                                 672987,       // -19.00       21
  53.                                 641834,       // -18.00       22
  54.                                 612233,       // -17.00       23
  55.                                 584080,       // -16.00       24
  56.                                 557284,       // -15.00       25
  57.                                 531766,       // -14.00       26
  58.                                 507456,       // -13.00       27
  59.                                 484294,       // -12.00       28
  60.                                 462224,       // -11.00       29
  61.                                 441201,       // -10.00       30
  62.                                 421180,       // -9.00        31
  63.                                 402121,       // -8.00        32
  64.                                 383988,       // -7.00        33
  65.                                 366746,       // -6.00        34
  66.                                 350362,       // -5.00        35
  67.                                 334802,       // -4.00        36
  68.                                 320035,       // -3.00        37
  69.                                 306028,       // -2.00        38
  70.                                 292750,       // -1.00        39
  71.                                 280170,       // 0.00         40
  72.                                 268255,       // 1.00         41
  73.                                 256972,       // 2.00         42
  74.                                 246290,       // 3.00         43
  75.                                 236176,       // 4.00         44
  76.                                 226597,       // 5.00         45
  77.                                 217522,       // 6.00         46
  78.                                 208916,       // 7.00         47
  79.                                 200749,       // 8.00         48
  80.                                 192988,       // 9.00         49
  81.                                 185600,       // 10.00        50
  82.                                 184818,       // 11.00        51
  83.                                 181489,       // 12.00        52
  84.                                 176316,       // 13.00        53
  85.                                 169917,       // 14.00        54
  86.                                 162797,       // 15.00        55
  87.                                 155350,       // 16.00        56
  88.                                 147867,       // 17.00        57
  89.                                 140551,       // 18.00        58
  90.                                 133536,       // 19.00        59
  91.                                 126900,       // 20.00        60
  92.                                 120684,       // 21.00        61
  93.                                 114900,       // 22.00        62
  94.                                 109539,       // 23.00        63
  95.                                 104582,       // 24.00        64
  96.                                 100000,       // 25.00        65
  97.                                 95762,        // 26.00        66
  98.                                 91835,        // 27.00        67
  99.                                 88186,        // 28.00        68
  100.                                 84784,        // 29.00        69
  101.                                 81600,        // 30.00        70
  102.                                 78608,        // 31.00        71
  103.                                 75785,        // 32.00        72
  104.                                 73109,        // 33.00        73
  105.                                 70564,        // 34.00        74
  106.                                 68133,        // 35.00        75
  107.                                 65806,        // 36.00        76
  108.                                 63570,        // 37.00        77
  109.                                 61418,        // 38.00        78
  110.                                 59343,        // 39.00        79
  111.                                 57340,        // 40.00        80
  112.                                 55405,        // 41.00        81
  113.                                 53534,        // 42.00        82
  114.                                 51725,        // 43.00        83
  115.                                 49976,        // 44.00        84
  116.                                 48286,        // 45.00        85
  117.                                 46652,        // 46.00        86
  118.                                 45073,        // 47.00        87
  119.                                 43548,        // 48.00        88
  120.                                 42075,        // 49.00        89
  121.                                 40650,        // 50.00        90
  122.                                 39271,        // 51.00        91
  123.                                 37936,        // 52.00        92
  124.                                 36639,        // 53.00        93
  125.                                 35377,        // 54.00        94
  126.                                 34146,        // 55.00        95
  127.                                 32939,        // 56.00        96
  128.                                 31752,        // 57.00        97
  129.                                 30579,        // 58.00        98
  130.                                 29414,        // 59.00        99
  131.                                 28250,        // 60.00        100
  132.                                 27762,        // 61.00        101
  133.                                 27179,        // 62.00        102
  134.                                 26523,        // 63.00        103
  135.                                 25817,        // 64.00        104
  136.                                 25076,        // 65.00        105
  137.                                 24319,        // 66.00        106
  138.                                 23557,        // 67.00        107
  139.                                 22803,        // 68.00        108
  140.                                 22065,        // 69.00        109
  141.                                 21350,        // 70.00        110
  142.                                 20661,        // 71.00        111
  143.                                 20004,        // 72.00        112
  144.                                 19378,        // 73.00        113
  145.                                 18785,        // 74.00        114
  146.                                 18225,        // 75.00        115
  147.                                 17696,        // 76.00        116
  148.                                 17197,        // 77.00        117
  149.                                 16727,        // 78.00        118
  150.                                 16282,        // 79.00        119
  151.                                 15860,        // 80.00        120
  152.                                 15458,        // 81.00        121
  153.                                 15075,        // 82.00        122
  154.                                 14707,        // 83.00        123
  155.                                 14352,        // 84.00        124
  156.                                 14006,        // 85.00        125
  157.                                 13669,        // 86.00        126
  158.                                 13337,        // 87.00        127
  159.                                 13009,        // 88.00        128
  160.                                 12684,        // 89.00        129
  161.                                 12360,        // 90.00        130
  162.                                 12037,        // 91.00        131
  163.                                 11714,        // 92.00        132
  164.                                 11390,        // 93.00        133
  165.                                 11067,        // 94.00        134
  166.                                 10744,        // 95.00        135
  167.                                 10422,        // 96.00        136
  168.                                 10104,        // 97.00        137
  169.                                 9789,         // 98.00        138
  170.                                 9481,         // 99.00        139
  171.                                 9180,         // 100.00       140
  172.                                 8889,         // 101.00       141
  173.                                 8610,         // 102.00       142
  174.                                 8346,         // 103.00       143
  175.                                 8099,         // 104.00       144
  176.                                 7870,         // 105.00       145
  177.                                 7665,         // 106.00       146
  178.                                 7485,         // 107.00       147
  179.                                 7334,         // 108.00       148
  180.                                 7214,         // 109.00       149
  181.                                 7130,         // 110.00       150
  182. };

  184. void ys1ms(u16 z)               //zms延时函数
  185. {
  186.    u8 x,y;
  187.    for(x=z;x>0;x--)
  188.             for(y=125;y>0;y--);
  189. }          

  191. void XS()                                     //数码管显示函数
  192. {
  193.          for(i=0;i<4;i++)
  194.          {
  195.                   switch(i)                                       
  196.                   {
  197.                            case(0):
  198.                                           GW=0;SW=1;BW=1;QW=1; P0=smg0[show[0]]; break;        //小数位
  199.                            case(1):
  200.                                           GW=1;SW=0;BW=1;QW=1; P0=smg1[show[1]]; break;        //个位带小数点
  201.                            case(2):
  202.                                           GW=1;SW=1;BW=0;QW=1; P0=smg0[show[2]]; break;        //十位
  203.                            case(3):                                                                  
  204.                                           GW=1;SW=1;BW=1;QW=0; P0=smg0[show[3]]; break;        //百位
  205.       }         
  206.                   ys1ms(10);                       
  207.                   GW=1;
  208.                   SW=1;
  209.                   BW=1;
  210.                   QW=1;       
  211.                   P0=0xff;                         
  212.                   ys1ms(10);
  213.    }               
  214. }

  216. void InitADC()                             //ADC初始化
  217. {
  218.          P1ASF=0x80;                             //1000 0000，设置P17作为AD使用
  219.          ADC_RES=0;                              //转换结果寄存器高8位清零
  220.          ADC_RESL=0;                             //转换结果寄存器低2位清零
  221.          ADC_CONTR=ADC_POWER | ADC_SPEEDLL;      //开启AD电源，AD转换速度
  222.          ys1ms(2);                               //延时1ms以上，等待电源稳定
  223. }

  225. u16 AD_GET(u8 ch)         //查询方式AD转换程序
  226. {
  227.          ADC_CONTR=ADC_POWER|ADC_SPEEDLL|ch|ADC_START;
  228.          _nop_();
  229.          _nop_();
  230.          _nop_();
  231.          _nop_();
  232.          while(!(ADC_CONTR & ADC_FLAG));         //等待转换结束
  233.          ADC_CONTR &= ~ADC_FLAG;                 //关闭ADC,AD_FLAG清零
  234.          return(ADC_RES*4+ADC_RESL);             //返回AD转换得到的10位数据（16进制）
  235. }

  237. void Get_Temp()          //读取电阻值
  238. {
  239.    u8 xx;
  240.    u32 sum,RT;
  241.          sum=0;
  242.          RT=0;
  243.          Temp_Buf[8]=(u32)102300000/AD_GET(7)-100000;  //将ADC转换结果换算为电阻值并扩大10000倍
  244.          if( ++ADCcount < 8)                           //采样初期不使用递推滤波算法
  245.    {   
  246.       for(xx=0;xx<8;xx++)                        //准备递推滤波算法的数据
  247.             {
  248.                Temp_Buf[xx]=Temp_Buf[xx+1];            //所有数据循环左移
  249.             }
  250.             RT=Temp_Buf[8];                            //采样初期使用当前采样值
  251.          }
  252.          else                                          //只有采样次数大于8次以后才使用递推滤波算法
  253.          {
  254.             ADCcount=8;                                //采样次数超过8次后，固定设置为8
  255.             for(xx=0;xx<8;xx++)                        //递推滤波算法
  256.             {
  257.                Temp_Buf[xx]=Temp_Buf[xx+1];            //所有数据循环左移
  258.                sum+=Temp_Buf[xx];                      //求和
  259.             }
  260.             RT=sum/8;                                  //求平均值      
  261.          }   
  262.          if (RT>=7130 && RT<=1905562)
  263.          {
  264.       xx=0;       
  265.       while( RT < NTCcode[xx] )                  //将当前电阻值与表对比，得到所在位置
  266.       {   
  267.                xx++;   
  268.             }
  269.             WD=xx*10-((RT+5-NTCcode[xx])*10/(NTCcode[xx-1]-NTCcode[xx])); //插值法计算，数据扩大10倍                                       
  270.       if (WD>400)                                //正温度(大于0度)
  271.       {
  272.                      WD=WD-400;                              //取得0°以上温度
  273.          if (WD>999)                             //大于100度显示最高位
  274.          {   
  275.                                     show[3]=WD/1000;
  276.                                  }
  277.          else                                    //小于100度不显示最高位
  278.          {
  279.                                     show[3]=11;                          //百位
  280.                   show[2]=WD%1000/100;                 //十位
  281.                   show[1]=WD%100/10;                   //个位加小数点
  282.                   show[0]=WD%10;                       //小数位
  283.                                  }
  284.       }
  285.       else                                       //负温度(小于0度)
  286.       {
  287.          WD=400-WD;                              //取得0°以下温度
  288.          show[3]=10;                             //显示负号-
  289.          show[2]=WD/100;
  290.          show[1]=WD%100/10;                      //加小数点
  291.          show[0]=WD%10;
  292.                         }
  293.    }
  294.          else if (RT>1905562)                          //温度低于-40℃,显示-0，表示超出量程（欠量程）
  295.          {
  296.                   show[3]=10;                                //显示负号-
  297.       show[2]=11;
  298.       show[1]=10;                                //加小数点
  299.       show[0]=0;
  300.          }
  301.          else if (RT<7130)                             //温度高于110℃，显示1，表示超量程
  302.          {
  303.                   show[3]=1;                                 //百位
  304.             show[2]=11;                                //十位
  305.             show[1]=10;                                //个位加小数点
  306.             show[0]=11;
  307.          }
  308. }

  310. void main()                                                                                          
  311. {                                      
  312.          InitADC();       
  313.          ADCcount=0;      //ADC采样次数   
  314.          while(1)                                                       
  315.          {                                       
  316.                   Get_Temp();
  317.                         XS();       
  318.    }               
  319. }
复制代码

所有资料51hei提供下载:
STC热敏电阻温度计程序.rar (26.33 KB, 下载次数: 42)



作者: angmall    时间: 2019-4-29 19:07
STC单片机热敏电阻温度计程序编译能通过

linking...
Program Size: data=68.0 xdata=0 code=1943
creating hex file from "STC热敏电阻温度计"...
"STC热敏电阻温度计" - 0 Error(s), 0 Warning(s).


  1. //STC热敏电阻温度计程序  <----------错

  3. //****************************************/
  4. //*     基于STC12C5A60S2的NTC温度计      */
  5. //*       测温范围-40°～110°             */
  6. //****************************************/
  7. //4位共阳极数码管段码a-h接P27-P20，
  8. //位选端接P3高4位
  9. //NTC使用MF52-103/3435;10K±1％精度;B值:3435±1％
  10. //NTC温度输出端子接P1.0
复制代码
作者: cy002    时间: 2019-4-29 23:26
//STC热敏电阻温度计程序
作者: HC6800-ES-V2.0    时间: 2019-4-30 08:58
编译没问题啊，没错误，没警告。
作者: ll13536121668    时间: 2019-4-30 23:20
HC6800-ES-V2.0 发表于 2019-4-30 08:58
编译没问题啊，没错误，没警告。

师博你好，把编译好的代码打包上传看看
作者: ll13536121668    时间: 2019-4-30 23:28
angmall 发表于 2019-4-29 19:07
STC单片机热敏电阻温度计程序编译能通过

linking...

师博程序有问题吗，打包上传看看
作者: angmall    时间: 2019-5-1 08:09
ll13536121668 发表于 2019-4-30 23:28
师博程序有问题吗，打包上传看看

打包上传, 编译通过

STC热敏电阻温度计程序.zip

56.29 KB, 下载次数: 32

STC热敏电阻温度计程序
作者: ll13536121668    时间: 2019-5-1 09:50
ll13536121668 发表于 2019-4-30 23:28
师博程序有问题吗，打包上传看看

能通过，有看过程序还有其他问题吗？
作者: angmall    时间: 2019-5-1 14:05
ll13536121668 发表于 2019-5-1 09:50
能通过，有看过程序还有其他问题吗？

你好！这个要看你的硬件电路了，每种电路程序完全不一样
作者: ll13536121668    时间: 2019-5-3 16:32
angmall 发表于 2019-5-1 14:05
你好！这个要看你的硬件电路了，每种电路程序完全不一样

我还有一个程序须要师博看看,别人能用Keil uVision 4生成带有可用的代码,   自己都是编译 失败,看看这个程序你能编译通过吗？
作者: ll13536121668    时间: 2019-5-3 16:36
我试过这个是编译不通过的,

12864计算器仿真 代码.rar

61.12 KB, 下载次数: 10
作者: wulin    时间: 2019-5-3 21:07
ll13536121668 发表于 2019-5-3 16:36
我试过这个是编译不通过的,

把<zm.h>内ASCII字模的数据表复制到computer.c文件中，在computer.c文件中注释掉//#include<zm.h>即可

  1. #include<reg52.h>
  2. #include<intrins.h>
  3. //#include<zm.h>
  4. #define uint unsigned int
  5. #define uchar unsigned char
  6. sbit en=P3^0;
  7. sbit rw=P3^1;
  8. sbit rs=P3^2;
  9. sbit cs2=P3^3;
  10. sbit cs1=P3^4;
  11. sbit rst=P3^5;
  12. // ------------------  ASCII字模的数据表 ------------------------ //
  13. // 码表从0x20~0x7e                                                //
  14. // 字库: F:\BaiduNetdiskDownload\常用辅助开发工具\lcd汉字取模软   //
  15. // 件\Asc5x8E.dot 纵向取模下高位                                  //
  16. // -------------------------------------------------------------- //
  17. uchar code nAsciiDot[] =              // ASCII
  18. {
  19.         0x3E,0x51,0x49,0x45,0x3E,0x00, // -0-
  20.         0x00,0x42,0x7F,0x40,0x00,0x00, // -1-
  21.         0x62,0x51,0x49,0x49,0x46,0x00, // -2-
  22.         0x21,0x41,0x49,0x4D,0x33,0x00, // -3-
  23.         0x18,0x14,0x12,0x7F,0x10,0x00, // -4-
  24.         0x27,0x45,0x45,0x45,0x39,0x00, // -5-
  25.         0x3C,0x4A,0x49,0x49,0x31,0x00, // -6-
  26.         0x01,0x71,0x09,0x05,0x03,0x00, // -7-
  27.         0x36,0x49,0x49,0x49,0x36,0x00, // -8-
  28.         0x46,0x49,0x49,0x29,0x1E,0x00, // -9-
  29.         0x22,0x14,0x08,0x14,0x22,0x00, // -*-
  30.         0x08,0x08,0x7F,0x08,0x08,0x00, // -+-
  31.         0x08,0x08,0x08,0x08,0x08,0x00, // ---
  32.         0x08,0x08,0x2a,0x08,0x08,0x00, // -/-
  33.         0x14,0x14,0x14,0x14,0x14,0x00, // -=-
  34.         0x02,0x01,0x59,0x05,0x02,0x00, // -?-
  35. };
  36. uchar key,wei=4,hang=0,k=0;
  37. unsigned long a1=0,a2=0,count=0;
  38. void wc(uchar cmd)
  39. {
  40.         _nop_();
  41.         rs=0;
  42.         rw=0;
  43.         en=1;
  44.         P2=cmd;
  45.         _nop_();
  46.         en=0;
  47. }
  48. void wd(uchar dat)
  49. {
  50.         _nop_();
  51.         rs=1;
  52.         rw=0;
  53.         en=1;
  54.         P2=dat;
  55.         _nop_();
  56.         en=0;
  57. }
  58. void delay(uchar ms)
  59. {
  60.         uchar i,j;
  61.         for(i=ms;i>0;i--)
  62.                 for(j=113;j>0;j--);
  63. }
  64. void set(uchar line,uchar col)
  65. {
  66.         line=line|0xb8;
  67.         col=col|0x40;
  68.         wc(col);
  69.         wc(line);
  70. }
  71. void clean()
  72. {
  73.         uchar i,j,k=0;
  74.         rst=0;
  75.         delay(10);
  76.         rst=1;
  77.         wc(0xc0);//设置显示起始行11xxxxxx
  78.         wc(0x3f);//00111111显示开，00111110显示关
  79.         cs1=0,cs2=0;
  80.         set(0,0);
  81.         for(i=0;i<8;i++)
  82.                 {for(j=0;j<64;j++)
  83.                         wd(0x00);
  84.                         k++;
  85.                         set(k,0);
  86.                         }
  87.         a1=0;a2=0;count=0;k=0;
  88.         wei=4;
  89.         hang=0;
  90. }
  91. void write(uchar zi)
  92. {
  93.         uchar i;
  94.         if(wei<63)
  95.         {
  96.         cs1=0,cs2=1;
  97.         set(hang,wei);
  98.         for(i=0;i<6;i++)
  99.                 wd(nAsciiDot[zi++]);
  100.         wei=wei+6;
  101.         if(wei>59)
  102.         {cs1=1;
  103.         cs2=0;}
  104.         if(hang>7)
  105.         hang=0;
  106.         }
  107.         else
  108.         {
  109.         set(hang,wei-64);
  110.         for(i=0;i<6;i++)
  111.                 wd(nAsciiDot[zi++]);
  112.         wei=wei+6;
  113.         if(wei>123)
  114.         {wei=4;
  115.         hang++;
  116.         cs1=0;
  117.         cs2=1;}
  118.         if(hang>7)
  119.         hang=0;
  120.         }
  121. }
  122. void jis()
  123. {
  124.         switch(k)
  125.         {
  126.                 case 0:
  127.                         break;
  128.                 case 1:
  129.                         count=a2*a1;a1=count;break;
  130.                 case 2:
  131.                         count=a2+a1;a1=count;break;       
  132.                 case 3:
  133.                         count=a2-a1;a1=count;break;
  134.                 case 4:
  135.                         count=a2/a1;a1=count;break;
  136.                 default:
  137.                         break;
  138.         }
  139. }
  140.                        
  141. void rel()
  142. {       
  143.         uchar a=P1;
  144.         write(key);
  145.         while((a&0x0f)!=0x0f)
  146.         {
  147.                 a=P1;
  148.         }       
  149.         switch(key/6)
  150.         {
  151.                 case 0:
  152.                 case 1:
  153.                 case 2:
  154.                 case 3:
  155.                 case 4:
  156.                 case 5:
  157.                 case 6:
  158.                 case 7:
  159.                 case 8:
  160.                 case 9:
  161.                         a1=a1*10+key/6;break;
  162.                 case 10:
  163.                         jis();a2=a1;a1=0;k=1;break;
  164.                 case 11:
  165.                         jis();a2=a1;a1=0;k=2;break;
  166.                 case 12:
  167.                         jis();a2=a1;a1=0;k=3;break;
  168.                 case 13:
  169.                         jis();                                                                                                                        a2=a1;a1=0;k=4;break;
  170.                 case 14:
  171.                         {
  172.                                 switch(k)
  173.                                 {
  174.                                         case 1:
  175.                                                 count=a2*a1;break;
  176.                                         case 2:
  177.                                                 count=a2+a1;break;       
  178.                                         case 3:
  179.                                                 count=a2-a1;break;
  180.                                         case 4:
  181.                                                 count=a2/a1;break;
  182.                                         default:
  183.                                                 break;
  184.                                 }
  185.                                 if(count>999999999)
  186.                                         write(90);
  187.                                 else
  188.                                         if(count>99999999)
  189.                                                 {
  190.                                                  write(count/100000000*6);
  191.                                                  write(count%100000000/10000000*6);
  192.                                                  write(count%10000000/1000000*6);
  193.                                                  write(count%1000000/100000*6);
  194.                                                  write(count%100000/10000*6);
  195.                                                  write(count%10000/1000*6);
  196.                                                  write(count%1000/100*6);
  197.                                                  write(count%100/10*6);
  198.                                                  write(count%10*6);
  199.                                                  }
  200.                                         else
  201.                                         if(count>9999999)
  202.                                                 {
  203.                                                  write(count%100000000/10000000*6);
  204.                                                  write(count%10000000/1000000*6);
  205.                                                  write(count%1000000/100000*6);
  206.                                                  write(count%100000/10000*6);
  207.                                                  write(count%10000/1000*6);
  208.                                                  write(count%1000/100*6);
  209.                                                  write(count%100/10*6);
  210.                                                  write(count%10*6);
  211.                                                  }
  212.                                                  else
  213.                                         if(count>999999)
  214.                                                 {
  215.                                                  write(count%10000000/1000000*6);
  216.                                                  write(count%1000000/100000*6);
  217.                                                  write(count%100000/10000*6);
  218.                                                  write(count%10000/1000*6);
  219.                                                  write(count%1000/100*6);
  220.                                                  write(count%100/10*6);
  221.                                                  write(count%10*6);
  222.                                                  }
  223.                                                  else
  224.                                         if(count>99999)
  225.                                                 {
  226.                                                  write(count%1000000/100000*6);
  227.                                                  write(count%100000/10000*6);
  228.                                                  write(count%10000/1000*6);
  229.                                                  write(count%1000/100*6);
  230.                                                  write(count%100/10*6);
  231.                                                  write(count%10*6);
  232.                                                  }
  233.                                                  else
  234.                                         if(count>9999)
  235.                                                 {

  237.                                                  write(count%100000/10000*6);
  238.                                                  write(count%10000/1000*6);
  239.                                                  write(count%1000/100*6);
  240.                                                  write(count%100/10*6);
  241.                                                  write(count%10*6);
  242.                                                  }
  243.                                                  else
  244.                                         if(count>999)
  245.                                                 {
  246.                                                  write(count%10000/1000*6);
  247.                                                  write(count%1000/100*6);
  248.                                                  write(count%100/10*6);
  249.                                                  write(count%10*6);
  250.                                                  }
  251.                                                  else
  252.                                         if(count>99)
  253.                                                 {
  254.                                                  write(count%1000/100*6);
  255.                                                  write(count%100/10*6);
  256.                                                  write(count%10*6);
  257.                                                  }
  258.                                                  else
  259.                                         if(count>9)
  260.                                                 {
  261.                                                  write(count%100/10*6);
  262.                                                  write(count%10*6);
  263.                                                  }
  264.                                                  else
  265.                                                 {
  266.                                                  write(count%10*6);
  267.                                                  }
  268.                                         a1=count;k=0;
  269.                         }break;                       
  270.                 default:
  271.                         break;
  272.         }
  273. }

  275. void keyscan()
  276. {
  277.         uchar a;
  278.         P1=0xef;
  279.         a=P1;
  280.         a=a&0x0f;
  281.         switch(a)
  282.         {case 7:
  283.                 key=90;clean();break;
  284.         case 11:
  285.                 key=0;rel();break;
  286.         case 13:
  287.                 key=84;rel();break;
  288.         case 14:
  289.                 key=66;rel();break;
  290.         default:
  291.                 break;}
  292.        
  293.         P1=0xdf;
  294.         a=P1;
  295.         a=a&0x0f;
  296.         switch(a)
  297.         {case 7:
  298.                 key=6;rel();break;
  299.         case 11:
  300.                 key=12;rel();break;
  301.         case 13:
  302.                 key=18;rel();break;
  303.         case 14:
  304.                 key=72;rel();break;
  305.         default:
  306.                 break;}
  307.        
  308.         P1=0xbf;
  309.         a=P1;
  310.         a=a&0x0f;
  311.         switch(a)
  312.         {case 7:
  313.                 key=24;rel();break;
  314.         case 11:
  315.                 key=30;rel();break;
  316.         case 13:
  317.                 key=36;rel();break;
  318.         case 14:
  319.                 key=60;rel();break;
  320.         default:
  321.                 break;}
  322.        
  323.         P1=0x7f;
  324.         a=P1;
  325.         a=a&0x0f;
  326.         switch(a)
  327.         {case 7:
  328.                 key=42;rel();break;
  329.         case 11:
  330.                 key=48;rel();break;
  331.         case 13:
  332.                 key=54;rel();break;
  333.         case 14:
  334.                 key=78;rel();break;
  335.         default:
  336.                 break;}
  337. }
  338. void main()
  339. {
  340.         cs1=0;
  341.         cs2=0;
  342.         clean();
  343.         cs1=0;
  344.         while(1)
  345.         {keyscan();
  346.         delay(2);
  347.         }
  348.         }
  349.        
复制代码

作者: ll13536121668    时间: 2019-5-3 23:01
wulin 发表于 2019-5-3 21:07
把内ASCII字模的数据表复制到computer.c文件中，在computer.c文件中注释掉//#include即可

师傅修改好用压缩包上传好吗，谢谢
作者: wulin    时间: 2019-5-4 08:42
ll13536121668 发表于 2019-5-3 23:01
师傅修改好用压缩包上传好吗，谢谢

12864计算器.zip (20.09 KB, 下载次数: 17)
作者: 5201312    时间: 2019-5-4 11:07
你好！这个要看你的硬件电路了，每种电路程序完全不一样
回
作者: ll13536121668    时间: 2019-5-5 10:34
wulin 发表于 2019-5-4 08:42

#include<AT89X51.H>   //装入AT89X51头文件
#include<ir.h>                        //装入红外解码程序
#include<24c02.H>                //装入24c02读写程序
sbit key=P1^0;                        //定义按键IO
sbit led=P0^0;       //定义指示led
sbit rel=P0^1;                        //定义输出控制脚

unsigned char kaver;  //定义kaver为输出口状态缓存
unsigned char iccdate,irdate;  //定义24c02数据和解码数据

//延时10ms函数，用于开关消抖等
delay10ms()   
{
        unsigned char i,j;        
        for(i=20;i>0;i--)        
        for(j=248;j>0;j--);        
}

//学习红外解码并写入24c02的函数
study()
{
    IR_IN();
        irdate=IRCOM[3];
    iccdate=ReadIIC(W_cmd,0x00,R_cmd);
        if(irdate!=iccdate)        //只在解码结果与读取结果不同时写入24C02
        {
                if(irdate!=0)                        //防止没有接收到红外信号，IRCOM[3]置零时，误写入0
                {
                WP=0;
                WriIIC(W_cmd,0x00,irdate);
                delay10ms();
                WP=1;
                led=0;
                while(key==0);                //学习成功等待按键释放，led停止闪动作为指示
                }
         }
}
//进入学习状态时的led闪动函数
flash()
{
    unsigned char i;
          while(key==0)
          {
             led=~led;
                  for(i=50;i>0;i--)
                                  study();                 
          }
}
//按键模式识别函数
keymod()
{
        unsigned char m=0;
        while(key==0)                          //如果按键按下，开始对按键时间进行计数
        {               
                        delay10ms();                        //计数时间延时
                        m++;
                        delay10ms();                        //计数时间延时
                        if(m>=90)                                //如果计数次数大于90次，等于按键按下时间大于约5秒后，进入led闪动学习模式
                        {
                                m=0;
                                flash();
                        }
        }

         if(m<90)              //如果计数次数小于90，则按键作为开关使用
         {
                 m=0;
                kaver=~kaver;
         }

}
////////////////////主函数////////////////////////////////////
main()
{
        WP=1;                        //24c02写保护
        while(1)
        {
                IRCOM[3]=0;
            IR_IN();                                // 读4字节32位按键编码 ，前16位用户码为IRCOM[1]+IRCOM[2]，8位键值码为IRCOM[3]
                irdate=IRCOM[3];                                        //8位键值反码为IRCOM[4] 这里只调用 IRCOM[3]键值码作为数据码
                iccdate=ReadIIC(W_cmd,0x00,R_cmd);
                if(irdate==iccdate)                                                //如果解码结果与24C读取码相同，kaver翻转一次
                {
                        irdate=0;
                        kaver=~kaver;
                }

      if(key==0)        
                        keymod();
                rel=~kaver;
                led=kaver;
        }
}

作者: ll13536121668    时间: 2019-5-5 10:36
师博你好看看这个学习型红外遥控开关是一个c程序,少了<ir.h> <24c02.H>   看看能用Keil uVision 4编译   通过生成代码吗？    修改好用压缩包上传，谢谢

学习型红外遥控开关.rar

1.14 KB, 下载次数: 8



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1