设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机控制4电机循环测试(数码管显示)构思与实现源代码
返回列表 发新帖
查看: 1230|回复: 1
打印 上一主题 下一主题
收起左侧

单片机控制4电机循环测试(数码管显示)构思与实现源代码

[复制链接]
跳转到指定楼层
楼主
ID:308173 发表于 2019-4-12 23:56 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
实验构思:
      一,  两位共阴数码管4个,要求显示范围0.0~9.9  分别对应4个电机运行时间;  开机无显示,
     当电机运行时,对应的数码管从0开始计时,设定的时间到电机停止运行,数码管保持停止时间上.当下个电机运行时熄灭.
      二 按键加减范围1~99  ,按设置键3秒进入电机1时间设置 ,(K_SET) 进入设置后,上次设置的数字闪烁, 用 K_UP和K_DN进行数字加减; 步进1,相当于时间0.1秒, 步数100个(0~99);进入设置后,再按设置键,每按一次,进行电机1,2,3,4,1.....循环,同时对应的数码管闪烁,分别显示AA,BB,CC,DD来区分,按下设置键,或者设置完成后3秒无任何按键操作;保存当前数据并退出设置状态. ,在设置的时候不得影响程序的正常运行,设置保存后,程序立即运行新设置的数据.                                                        
           P0               P0            P0            P0                                      
         P1^1  P1^0      P1^3 P1^2    P1^5  P1^4   P1^7  P1^6
         数码显示1       数码显示2     数码显示3    数码显示4                                                           
                                                                                      
开始----------->电机1-------------->电机2---------->电机3-------------电机4-------------->挡杆
PIN_POW   PIN_DJA      PIN_DJB      PIN_DJC      PIN_DJD        PIN_STOP
P2^2          P2^3          P2^4         P2^5          P2^6              P2^7                           
       控制1         控制2                                    控制3                             
     PA1   P3^0      PA2    P3^1                           PA3^2                 
K_POW按一次开机,再按一次停机.   K_POW=P3^4, K_SET=P3^5,   K_UP=P3^6,   K_DN=P3^7,
控制触发是低电平有效   输出为低电平            单片机STC89C52   程序C,不要汇编等.
工作过程:
        开始(PIN_POW=0,其他=1),等待控制1触发,
        控制1触发 (PIN_POW=1,PIN_STOP=0, PIN_DJA =0)
        电机1运转时间到,PIN_DJA =1,等待控制2触发.
        控制2触发.PIN_DJB =0,
        电机2运转时间到 PIN_DJB =1,PIN_DJC =0,电机3接着运行
        电机3运转时间到 PIN_DJC =1,PIN_DJD =0,电机4接着运行
        电机4运转时间到 PIN_DJD =1,等待控制3触发.
        控制3触发.PIN_STOP=1,PIN_POW=0,.
  整个过程无限循环,只有有开关机键控制;
按关机键后,等运行到PIN_POW=0时关机,不得在工作过程中途停机.

要求主程序和子程序分类;建立单独的.h文件.此设计中需要设置的数据保存,断电重新开机运行的是上次修改的参数.不得每次开机重新设定.
脚位功能在程序中直接定义,除数码管P0口外,其他单个脚位不得使用代码代替;

以上是题目，贴出全部单片机代码
  1. main.c

  3. #include<STC15F2K60S2.H>
  4. #include"delay.h"
  5. #include"dj.h"
  6. #include"key.h"
  7. #include "eeprom.h"

  9. uint  time_DJA=3000;
  10. uint  time_DJB=3000;
  11. uint  time_DJC=3000;
  12. uint  time_DJD=3000;
  13. extern bit flag_DJA1;
  14. extern bit flag_DJB1;
  15. extern bit flag_DJC1;
  16. extern bit flag_DJD1;
  17. extern bit flag_kaiguan;


  20. sbit PA1=P2^0;
  21. sbit PA2=P3^6;
  22. sbit PA3=P3^7;

  24. void main()
  25. {
  26.         Init_Timer0();
  27.         PA1=1;                 //测试的时候用的
  28.         PA2=1;                  //测试的时候用的
  29.         PA3=1;                //测试的时候用的
  30.         /*初始值从EEPROM 中读取*/
  31.         time_DJA=iap_READ(iap_ADDRESS)*1000+iap_READ(iap_ADDRESS+1)*100+iap_READ(iap_ADDRESS+2)*10+iap_READ(iap_ADDRESS+3);
  32.         time_DJB=iap_READ(iap_ADDRESS+4)*1000+iap_READ(iap_ADDRESS+5)*100+iap_READ(iap_ADDRESS+6)*10+iap_READ(iap_ADDRESS+7);
  33.         time_DJC=iap_READ(iap_ADDRESS+8)*1000+iap_READ(iap_ADDRESS+9)*100+iap_READ(iap_ADDRESS+10)*10+iap_READ(iap_ADDRESS+11);
  34.         time_DJD=iap_READ(iap_ADDRESS+12)*1000+iap_READ(iap_ADDRESS+13)*100+iap_READ(iap_ADDRESS+14)*10+iap_READ(iap_ADDRESS+15);
  35. while(1)
  36. {
  37.         Key();        // 检测开关是否按下，开关打开，开始执行下面的代码
  38.         if(flag_kaiguan==1)
  39.         {
  40.                 PIN_STOP=1;                           //停止指示灯
  41.                  PIN_POW=0;                           //开始指示灯
  42.                 delay_ms(50);//延时程序时间定义50ms,
  43.                 if(PA1==1)                  //PA1触发来到执行下面的代码，相当于开门
  44.                 {
  45.                         PIN_POW=1;
  46.                         PIN_STOP=0;
  47.                         DJA();                                        //电机1开始执行
  48.                         while(flag_DJA1==0)Key();        //等待电机1执行完毕
  49. //                        delay_ms(1000);                          //测试的时候用的，假设1秒后触发信号2来到了
  50.                         while(PA2==0);                          //等待触发信号2来
  51.                         if(PA2==1)
  52.                         {
  53.                                 DJB();                                           //电机B开始执行
  54.                                 while(flag_DJB1==0)Key();  //等待电机B执行结束
  55.                                 DJC();                                           //同理
  56.                                 while(flag_DJC1==0)Key();
  57.                                 DJD();
  58.                                 while(flag_DJD1==0)Key();
  59. //                                delay_ms(1000);                          //测试的时候用的假设1秒后触发信号3来到
  60.                                 while(PA3==0);
  61.                                 if(PA3==1)
  62.                                 {
  63.                                         PIN_STOP=1;
  64.                                         PIN_POW=0;
  65.                                 //        PA1=0;               
  66.                                 }               
  67.                         }        
  68.                 }
  69.     }
  70.         else TR0=0;P0=0X00;         //开关关闭的时候把定时器关闭，数码管再清空
  71. }

  73. ///*下面的代码可以用来第一次向EEPROM中写入数据,以后都不会用到所以注释掉*/
  74. //                        iap_ERASE(iap_ADDRESS);                                   
  75. //                        iap_PROGRAM(iap_ADDRESS,3000/1000);
  76. //                        iap_PROGRAM(iap_ADDRESS+1,3000/100%10);                        
  77. //                        iap_PROGRAM(iap_ADDRESS+2,3000/10%10);
  78. //                        iap_PROGRAM(iap_ADDRESS+3,3000%10);
  79. //                        
  80. //                        iap_PROGRAM(iap_ADDRESS+4,3000/1000);
  81. //                        iap_PROGRAM(iap_ADDRESS+5,3000/100%10);                        
  82. //                        iap_PROGRAM(iap_ADDRESS+6,3000/10%10);
  83. //                        iap_PROGRAM(iap_ADDRESS+7,3000%10);
  84. //                                
  85. //                        iap_PROGRAM(iap_ADDRESS+8,3000/1000);
  86. //                        iap_PROGRAM(iap_ADDRESS+9,3000/100%10);                        
  87. //                        iap_PROGRAM(iap_ADDRESS+10,3000/10%10);
  88. //                        iap_PROGRAM(iap_ADDRESS+11,3000%10);
  89. //
  90. //                        iap_PROGRAM(iap_ADDRESS+12,3000/1000);
  91. //                        iap_PROGRAM(iap_ADDRESS+13,3000/100%10);                        
  92. //                        iap_PROGRAM(iap_ADDRESS+14,3000/10%10);
  93. //                        iap_PROGRAM(iap_ADDRESS+15,3000%10);                                
  94. //                        while(1);
  95. }



  99. key.c

  101. #include"key.h"
  102. extern  uint  time_DJA;
  103. extern  uint  time_DJB;
  104. extern  uint  time_DJC;
  105. extern  uint  time_DJD;

  107. bit flag_key1=0;  //设置键被按下三秒
  108. bit flag_anjian=0;  // 用于标记有按键按下，三秒无按键按下则退出设置界面
  109. bit flag_kaiguan=0;  //开关键1是开机，0是关机
  110. uint key_num=1;

  112. void  Key()
  113. {
  114.                 if(K_SET ==0  && flag_key1==0)                         //检查P3.7端口是否为低电平，即检测S17是否被按下
  115.                 {                                                
  116.                         delay_ms(2000);                         //再次检测S17是否被按下
  117.                         if(K_SET ==0)
  118.                         {
  119.                                 while(K_SET == 0); //等待按键释放
  120.                                 flag_key1=1;
  121.                         }
  122.                 }
  123.         if(flag_key1==1)
  124.         {
  125.                 if(K_SET == 0)                         //检查P3.7端口是否为低电平，即检测S17是否被按下
  126.                 {                                                 //延时一定时间，去抖
  127.                         delay_ms(10);                         //再次检测S17是否被按下
  128.                         if(K_SET == 0)
  129.                         {
  130.                                 while(K_SET == 0); //等待按键释放
  131.                                 key_num++;
  132.                                 flag_anjian=1;
  133.                                 if(key_num==5)
  134.                                 {
  135.                                         key_num=1;        
  136.                                 }
  137.                         }
  138.                 }                        
  139.         }
  140.         
  141.         if(flag_key1==1)
  142.         {
  143.                 if(K_UP == 0)                         //检查P3.7端口是否为低电平，即检测S17是否被按下
  144.                 {                                                 //延时一定时间，去抖
  145.                         delay_ms(10);                         //再次检测S17是否被按下
  146.                         if(K_UP == 0)
  147.                         {
  148.                                 while(K_UP == 0); //等待按键释放
  149.                                 flag_anjian=1;
  150.                                 switch(key_num)
  151.                                 {
  152.                                         case 1:
  153.                                         time_DJA+=100;
  154.                                         break;
  155.                                         case 2:
  156.                                         time_DJB+=100;
  157.                                         break;
  158.                                         case 3:
  159.                                         time_DJC+=100;
  160.                                         break;
  161.                                         case 4:
  162.                                         time_DJD+=100;
  163.                                         break;        
  164.                                 }
  165.                         }
  166.                 }
  167.                
  168.                 if(K_DN == 0)                         //检查P3.7端口是否为低电平，即检测S17是否被按下
  169.                 {                                                 //延时一定时间，去抖
  170.                         delay_ms(10);                         //再次检测S17是否被按下
  171.                         if(K_DN == 0)
  172.                         {
  173.                                 while(K_DN == 0); //等待按键释放
  174.                                 flag_anjian=1;
  175.                                 switch(key_num)
  176.                                 {
  177.                                         case 1:
  178.                                         time_DJA-=100;
  179.                                         break;
  180.                                         case 2:
  181.                                         time_DJB-=100;
  182.                                         break;
  183.                                         case 3:
  184.                                         time_DJC-=100;
  185.                                         break;
  186.                                         case 4:
  187.                                         time_DJD-=100;
  188.                                         break;        
  189.                                 }
  190.                         }
  191.                 }                        
  192.         }
  193.         
  194.         
  195.         /*开关按键代码*/
  196.                 if(K_POW ==0 )                         //检查P3.7端口是否为低电平，即检测S17是否被按下
  197.                 {                                                
  198.                         delay_ms(10);                         //再次检测S17是否被按下
  199.                         if(K_POW ==0)
  200.                         {
  201.                                 while(K_POW == 0); //等待按键释放
  202.                                 flag_kaiguan=~flag_kaiguan;
  203.                         }
  204.                 }        
  205.                         
  206. }


  209. delay.c


  212. #include"delay.h"
  213. /*==========================================================
  214. 函数名称：void delayms(void)
  215. 形    参：无
  216. 返回值  ：无
  217. 功能描述：1ms延时
  218. 时    间：2015-11-19
  219. 使    用：delayms();
  220. ==========================================================*/
  221. void delayms(void)                //@11.0592MHz
  222. {
  223.         unsigned char i,j;
  224.         _nop_();
  225.         _nop_();
  226.         _nop_();
  227.         i = 11;
  228.         j = 190;
  229.         do
  230.         {
  231.                 while (--j);
  232.         }
  233.         while (--i);
  234. }

  236. void delay_ms(unsigned int time)
  237. {
  238.         unsigned int i;
  239.         for(i=0;i<time;i++)
  240.                 delayms();
  241. }


  244. dj.c

  246. #include"dj.h"
  247. #include"key.h"
  248. #include "eeprom.h"
  249. extern uint key_num;
  250. extern bit flag_key1;
  251. extern uint key_num;
  252. extern bit flag_anjian;
  253. extern uint  time_DJA;
  254. extern uint  time_DJB;
  255. extern uint  time_DJC;
  256. extern uint  time_DJD;

  258. bit flag_DJA=0;          //定时器运行电机A的代码
  259. bit flag_DJA1=0;  //电机进入一次DJA()后主模块就不第二次进去了

  261. bit flag_DJB=0;          //定时器运行电机B的代码
  262. bit flag_DJB1=0;  //电机进入一次DJB()后主模块就不第二次进去了

  264. bit flag_DJC=0;          //定时器运行电机C的代码
  265. bit flag_DJC1=0;  //电机进入一次DJC()后主模块就不第二次进去了

  267. bit flag_DJD=0;          //定时器运行电机D的代码
  268. bit flag_DJD1=0;  //电机进入一次DJD()后主模块就不第二次进去了

  270. uint num=0;
  271. uint num1=0;
  272. uint num2=0;  //用于在设置模式定时三秒，没有操作则退出设置模式
  273. uchar SMG_N[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};             // 共阴极数码管

  275. uchar shu_1,shu_2,shu_3,shu_4,shu_5,shu_6,shu_7,shu_8;

  277. void DJA()
  278. {
  279.         TR0=1;// 定时器0打开
  280.         num=0;
  281.         PIN_DJA=0;
  282.         flag_DJD=0;
  283.         flag_DJD1=0;
  284.         flag_DJA=1;
  285.                
  286. }

  288. void DJB()
  289. {
  290.         TR0=0;// 定时器0关闭                 //还原定时器0
  291.         TH0=(65536-45872)/256;                    //11.0592 晶振定时50ms还原定时器0
  292.         TL0=(65536-45872)%256;                 //还原定时器0
  293.         num=0;                                                 //还原定时器0
  294.         flag_DJA=0;                                         //还原A的标志位
  295.         flag_DJA1=0;                                         //还原A的标志位
  296.         PIN_DJB=0;                                         
  297.         flag_DJB=1;
  298.         TR0=1;
  299.                
  300. }

  302. void DJC()
  303. {
  304.         TR0=0;// 定时器0关闭
  305.         TH0=(65536-45872)/256;                    //11.0592 晶振定时50ms
  306.         TL0=(65536-45872)%256;
  307.         num=0;
  308.         flag_DJB=0;                                         //还原B的标志位
  309.         flag_DJB1=0;                                         //还原B的标志位
  310.         PIN_DJC=0;
  311.         flag_DJC=1;
  312.         TR0=1;
  313.                
  314. }

  316. void DJD()
  317. {
  318.         TR0=0;// 定时器0关闭
  319.         TH0=(65536-45872)/256;                    //11.0592 晶振定时50ms
  320.         TL0=(65536-45872)%256;
  321.         num=0;
  322.         flag_DJC=0;                                         //还原C的标志位
  323.         flag_DJC1=0;                                        //还原C的标志位
  324.         PIN_DJD=0;
  325.         flag_DJD=1;
  326.         TR0=1;        
  327. }


  330.   void time0() interrupt 1         
  331. {
  332.                   TH0=(65536-9216)/256;                    //11.0592 晶振定时50ms
  333.                 TL0=(65536-9216)%256;
  334.                 num++;num1++;                                 //num1控制数码管显示num控制电机什么时候停止

  336. /*电机A的代码******************************************************************/
  337.                 if(flag_DJA==1)
  338.                 {
  339.                         if(num>=(time_DJA/10))          //time_DJA是电机A转动的时间，单位为ms
  340.                         {
  341.                                 PIN_DJA=1;
  342.                                 flag_DJA1=1;
  343.                                 num=0;        
  344.                         }
  345.                         if(PIN_DJA==0)                                 //如果电机在运行则说明数码管数子还在跳动
  346.                         {
  347.                                 shu_1=(num/10)/10;
  348.                                 shu_2=(num/10)%10;
  349.                         }
  350.                         else
  351.                         {
  352.                                 shu_1=(time_DJA/100)/10;
  353.                                 shu_2=(time_DJA/100)%10;                                                        
  354.                         }
  355.                         if(num1==1 && flag_key1==0)
  356.                         {
  357.                                 P0=0X00;
  358.                                 P1=0xfe;
  359.                                 P0=SMG_N[shu_1]+128;
  360.                         }
  361.                         if(num1==2 && flag_key1==0 )
  362.                         {
  363.                                 num1=0;
  364.                                 P0=0X00;
  365.                                 P1=0xfd;
  366.                                 P0=SMG_N[shu_2];
  367.                         }
  368.                 }
  369. /******************************************************************************/

  371. /*********************************************************************************/
  372. /*d电机B的代码 *******************************************************************/
  373.                 if(flag_DJB==1)
  374.                 {
  375.                         if(num>=(time_DJB/10))          //time_DJA是电机A转动的时间，单位为ms
  376.                         {
  377.                                 PIN_DJB=1;
  378.                                 flag_DJB1=1;
  379.                                 num=0;        
  380.                         }
  381.                         if(PIN_DJB==0)                                 //如果电机在运行则说明数码管数子还在跳动
  382.                         {
  383.                                 shu_3=(num/10)/10;
  384.                                 shu_4=(num/10)%10;
  385.                         }
  386.                         else
  387.                         {
  388.                                 shu_1=(time_DJB/100)/10;
  389.                                 shu_2=(time_DJB/100)%10;                                                        
  390.                         }
  391.                         if(num1==1 && flag_key1==0  )
  392.                         {
  393.                                 P0=0X00;
  394.                                 P1=0xfb;
  395.                                 P0=SMG_N[shu_3]+128;
  396.                         }
  397.                         if(num1==2 && flag_key1==0 )
  398.                         {
  399.                                 num1=0;
  400.                                 P0=0X00;
  401.                                 P1=0xf7;
  402.                                 P0=SMG_N[shu_4];
  403.                         }

  405.                 }
  406. /****************************************************************************/



  410. /*d电机C的代码 *******************************************************************/
  411.                 if(flag_DJC==1)
  412.                 {
  413.                         if(num>=(time_DJC/10))          //time_DJA是电机A转动的时间，单位为ms
  414.                         {
  415.                                 PIN_DJC=1;
  416.                                 flag_DJC1=1;
  417.                                 num=0;        
  418.                         }
  419.                         if(PIN_DJC==0)                                 //如果电机在运行则说明数码管数子还在跳动
  420.                         {
  421.                                 shu_5=(num/10)/10;
  422.                                 shu_6=(num/10)%10;
  423.                         }
  424.                         else
  425.                         {
  426.                                 shu_5=(time_DJC/100)/10;
  427.                                 shu_6=(time_DJC/100)%10;                                                        
  428.                         }
  429.                         if(num1==1  && flag_key1==0 )
  430.                         {
  431.                                 P0=0X00;
  432.                                 P1=0xef;
  433.                                 P0=SMG_N[shu_5]+128;
  434.                         }
  435.                         if(num1==2  && flag_key1==0 )
  436.                         {
  437.                                 num1=0;
  438.                                 P0=0X00;
  439.                                 P1=0xdf;
  440.                                 P0=SMG_N[shu_6];
  441.                         }

  443.                 }
  444. /****************************************************************************/

  446.          /*d电机D的代码 *******************************************************************/
  447.                 if(flag_DJD==1)
  448.                 {
  449.                         if(num>=(time_DJD/10))          //time_DJA是电机A转动的时间，单位为ms
  450.                         {
  451.                                 PIN_DJD=1;
  452.                                 flag_DJD1=1;
  453.                                 num=0;        
  454.                         }
  455.                         if(PIN_DJD==0)                                 //如果电机在运行则说明数码管数子还在跳动
  456.                         {
  457.                                 shu_7=(num/10)/10;
  458.                                 shu_8=(num/10)%10;
  459.                         }
  460.                         else
  461.                         {
  462.                                 shu_7=(time_DJD/100)/10;
  463.                                 shu_8=(time_DJD/100)%10;                                                        
  464.                         }
  465.                         if(num1==1 && flag_key1==0 )
  466.                         {
  467.                                 P0=0X00;
  468.                                 P1=0xBf;
  469.                                 P0=SMG_N[shu_7]+128;
  470.                         }
  471.                         if(num1==2 && flag_key1==0 )
  472.                         {
  473.                                 num1=0;
  474.                                 P0=0X00;
  475.                                 P1=0x7f;
  476.                                 P0=SMG_N[shu_8];
  477.                         }

  479.                 }
  480. /****************************************************************************/

  482. /*按下设置键后数码管显示的代码*/
  483. if(flag_key1==1)
  484. {
  485.          switch(key_num)
  486.         {
  487.                 case 1:
  488.                         if(num1==1)
  489.                         {
  490.                                 P0=0X00;
  491.                                 P1=0xfe;
  492.                                 P0=SMG_N[(time_DJA/100)/10]+128;
  493.                         }
  494.                         if(num1==2)
  495.                         {
  496.                                 num1=0;
  497.                                 P0=0X00;
  498.                                 P1=0xfd;
  499.                                 P0=SMG_N[(time_DJA/100)%10];
  500.                         }break;
  501.                 case 2:
  502.                         if(num1==1)
  503.                         {
  504.                                 P0=0X00;
  505.                                 P1=0xfb;
  506.                                 P0=SMG_N[(time_DJB/100)/10]+128;
  507.                         }
  508.                         if(num1==2)
  509.                         {
  510.                                 num1=0;
  511.                                 P0=0X00;
  512.                                 P1=0xf7;
  513.                                 P0=SMG_N[(time_DJB/100)%10];
  514.                         }break;
  515.                 case 3:
  516.                         if(num1==1)
  517.                         {
  518.                                 P0=0X00;
  519.                                 P1=0xef;
  520.                                 P0=SMG_N[(time_DJC/100)/10]+128;
  521.                         }
  522.                         if(num1==2)
  523.                         {
  524.                                 num1=0;
  525.                                 P0=0X00;
  526.                                 P1=0xdf;
  527.                                 P0=SMG_N[(time_DJC/100)%10];
  528.                         }break;
  529.                 case 4:
  530.                         if(num1==1)
  531.                         {
  532.                                 P0=0X00;
  533.                                 P1=0xbf;
  534.                                 P0=SMG_N[(time_DJD/100)/10]+128;
  535.                         }
  536.                         if(num1==2)
  537.                         {
  538.                                 num1=0;
  539.                                 P0=0X00;
  540.                                 P1=0x7f;
  541.                                 P0=SMG_N[(time_DJD/100)%10];
  542.                         }break;                        
  543.         }
  544. }

  546. /* 进入设置后三秒没有操作自动退出并且把数据保存到EEPROM*/
  547.          if(flag_key1==1)
  548.         {
  549.                 num2++;
  550.                 if(num2==300)
  551.                 {
  552.                         flag_key1=0;
  553.                         iap_ERASE(iap_ADDRESS);
  554.                         iap_PROGRAM(iap_ADDRESS,time_DJA/1000);
  555.                         iap_PROGRAM(iap_ADDRESS+1,time_DJA/100%10);                        
  556.                         iap_PROGRAM(iap_ADDRESS+2,time_DJA/10%10);
  557.                         iap_PROGRAM(iap_ADDRESS+3,time_DJA%10);
  558.                         
  559.                         iap_PROGRAM(iap_ADDRESS+4,time_DJB/1000);
  560.                         iap_PROGRAM(iap_ADDRESS+5,time_DJB/100%10);                        
  561.                         iap_PROGRAM(iap_ADDRESS+6,time_DJB/10%10);
  562.                         iap_PROGRAM(iap_ADDRESS+7,time_DJB%10);
  563.                                 
  564.                         iap_PROGRAM(iap_ADDRESS+8,time_DJC/1000);
  565.                         iap_PROGRAM(iap_ADDRESS+9,time_DJC/100%10);                        
  566.                         iap_PROGRAM(iap_ADDRESS+10,time_DJC/10%10);
  567.                         iap_PROGRAM(iap_ADDRESS+11,time_DJC%10);

  569.                         iap_PROGRAM(iap_ADDRESS+12,time_DJD/1000);
  570.                         iap_PROGRAM(iap_ADDRESS+13,time_DJD/100%10);                        
  571.                         iap_PROGRAM(iap_ADDRESS+14,time_DJD/10%10);
  572.                         iap_PROGRAM(iap_ADDRESS+15,time_DJD%10);                        
  573.                 }

  575.                 if(flag_anjian==1)
  576.                 {
  577.                         flag_anjian=0;
  578.                         num2=0;        
  579.                 }
  580.                
  581.         }
  582. }

  584. void Init_Timer0(void)
  585. {
  586.                 AUXR=0X00;                                //定时器0 定时器 1工作在12分频  即1T
  587.                 TMOD=0x11;                        //定时器0 和定时器1 不可自动重装载模式
  588.                 TH0=(65536-9216)/256;                    //11.0592 晶振定时50ms
  589.                 TL0=(65536-9216)%256;
  590.                 TL1 = (65536-46080)/256;         //        11.0592 晶振定时20ms
  591.                 TH1 = (65536-46080)%256;        
  592.                 TR0=0;                         //定时器0关闭
  593.                 TR1 = 0;                //定时器1关闭
  594.                 ET0=1;                        //允许定时器0中断
  595.                 ET1=1;                        //允许定时器1中断
  596.                 EA=1;                           //开启总中断
  597. }


  600. eeprom.c


  603. #include "eeprom.h"

  605. //使硬件或软件操作停止

  607. void iap_IDLE()

  609. {

  611.     IAP_CONTR=0;  //禁止IAP读写擦除

  613.     IAP_CMD=0;  //等待

  615.     IAP_TRIG=0;  //命令未触发

  617.     IAP_ADDRH=0x80;  //高位数据地址

  619.     IAP_ADDRL=0;     //低位

  621. }

  623. //从数据里面读取数据

  625. uchar iap_READ(uint addr)

  627. {   uchar datas;

  629.     IAP_CONTR=IAP_EN; //控制允许位

  631.     IAP_CMD=CMD_READ;   //写入读命令

  633.     IAP_ADDRL=addr;  //自定义地址

  635.     IAP_ADDRH=addr>>8;

  637.     IAP_TRIG=0x5a;  //命令有效

  639.     IAP_TRIG=0xa5;

  641.     _nop_();

  643.     datas=IAP_DATA;

  645.     iap_IDLE();

  647.     return datas;  //返回读出的数据

  649. }

  651. //写一个比特ISP写到某个地方

  653. void iap_PROGRAM(uint addr,uchar datas)

  655. {

  657.     IAP_CONTR=IAP_EN;

  659.     IAP_CMD=CMD_PROGRAM;

  661.     IAP_ADDRL=addr;

  663.     IAP_ADDRH=addr>>8;

  665.     IAP_DATA=datas;

  667.     IAP_TRIG=0x5a;

  669.     IAP_TRIG=0xa5;

  671.     _nop_();

  673.     iap_IDLE();

  675. }

  677. //擦掉某个区域

  679. void iap_ERASE(uint addr)

  681. {

  683.     IAP_CONTR=IAP_EN;

  685.     IAP_CMD=CMD_ERASE;

  687.     IAP_ADDRL=addr;

  689.     IAP_ADDRH=addr>>8;

  691.     IAP_TRIG=0x5a;

  693.     IAP_TRIG=0xa5;

  695.     _nop_();

  697.     iap_IDLE();

  699. }
复制代码

评分

参与人数 1黑币 +100 收起 理由
admin + 100 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:308173 发表于 2019-4-12 23:58 | 只看该作者
新手，有更好的实现方式可以一起交流，一起进步
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表