找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2505|回复: 0
打印 上一主题 下一主题
收起左侧

单片机红外遥控智能电风扇设计资料

[复制链接]
跳转到指定楼层
楼主
红外遥控智能电风扇实物图纸程序共享
制作出来的实物图如下:


电路原理图如下:


单片机源程序如下:
  1. //宏定义
  2. #define uchar unsigned char
  3. #define uint  unsigned int

  4. //头函数
  5. #include <stc12c5a60s2.h>
  6. #include <AT24C02.h>
  7. //温度传感器标志变量
  8. uchar flag=1;
  9. #include <DS18B20.h>
  10. #include <Ds1302.h>
  11. #include <Lcd.h>
  12. #include <Data.h>
  13. //热释电传感器
  14. sbit RR=P3^4;

  15. //是否有人状态 闹铃状态  风速状态
  16. uchar R=1,L=1,FS=0;
  17. //读取温度
  18. uint TT=0;

  19. //开机时分秒
  20. uchar OS=0,OF=0,OM=0;

  21. //关机时分秒
  22. uchar ClS=0,ClF=0,ClM=0;

  23. //模式
  24. uchar Mode=0;
  25. //调整位光标
  26. uchar Modes=0;
  27. //暂时保存状态
  28. uchar Modetemp=0;

  29. //时间计算
  30. #define Imax 14000    //此处为晶振为11.0592时的取值,
  31. #define Imin 8000    //如用其它频率的晶振时,
  32. #define Inum1 145    //要改变相应的取值。
  33. #define Inum2 700
  34. #define Inum3 3000
  35. //解码变量
  36. unsigned char Im[4]={0x00,0x00,0x00,0x00};
  37. //全局变量
  38. uchar f;
  39. unsigned long m,Tc;
  40. uchar IrOK;


  41. //延时
  42. void delayHW(uchar i);
  43. //PWM脉冲占空比调节
  44. void pwm_set(uchar a);
  45. //PWM初始化
  46. void initpwm();
  47. //外部中断定时器0寄存器初始化
  48. void Init();



  49. //主函数
  50. void main()
  51. {
  52.         //PWM脉冲
  53.         initpwm();
  54.         //外部中断定时器0寄存器初始化
  55.         Init();
  56.         //屏幕初始化
  57.         Init_LCD();
  58.         //时钟初始化
  59.         Ds1302_Init();
  60.         //EEPROM初始化
  61.         initeeprom();
  62.         //写
  63. /*        write_add(0x00,L);
  64.         write_add(0x01,OS);
  65.         write_add(0x02,OF);
  66.         write_add(0x03,OM);
  67.         write_add(0x04,ClS);
  68.         write_add(0x05,ClF);
  69.         write_add(0x06,ClM);*/

  70.         //读
  71.         L=read_add(0x00);
  72.         OS=read_add(0x01);
  73.         OF=read_add(0x02);
  74.         OM=read_add(0x03);
  75.         ClS=read_add(0x04);
  76.         ClF=read_add(0x05);
  77.         ClM=read_add(0x06);

  78.         //发送温度转换
  79.         tmpchange();
  80.         //发送温度转换
  81.         tmpchange();
  82.         //读取温度
  83.         TT=tmp();        
  84.         //初始化
  85.         pwm_set(0xff);
  86.         //读取时间
  87.         while(1)
  88.         {
  89.                 //发送温度转换
  90.                 tmpchange();
  91.                 //读取温度
  92.                 TT=tmp();

  93.                 //读取人员状况
  94.                 //有人
  95.                 if(RR==1)
  96.                 {
  97.                         R=0;
  98.                 }
  99.                 //无人
  100.                 else
  101.                 {
  102.                         R=1;
  103.                 }
  104.                 //模式处理
  105.                 //自动开机
  106.                 if(Mode==2)
  107.                 {
  108.                         //有人开启风扇
  109.                         if(R==1)
  110.                         {
  111.                                 //温度调整0档关闭
  112.                                 if(TT<=300)
  113.                                 {
  114.                                         pwm_set(0xff);
  115.                                         FS=0;
  116.                                 }
  117.                                 //1档
  118.                                 else if(TT>300&&TT<=320)
  119.                                 {
  120.                                         pwm_set(50);
  121.                                         FS=1;
  122.                                 }
  123.                                 //2档
  124.                                 else if(TT>320&&TT<=340)
  125.                                 {
  126.                                         pwm_set(10);
  127.                                         FS=2;
  128.                                 }
  129.                                 //3档
  130.                                 else if(TT>340)
  131.                                 {
  132.                                         pwm_set(0);
  133.                                         FS=3;
  134.                                 }
  135.                         }
  136.                         //无人关闭风扇
  137.                         else        
  138.                         {
  139.                                 pwm_set(0xff);
  140.                                 FS=0;
  141.                         }
  142.                 }

  143.                 //读取时间
  144.                 Ds1302_Read_Time();
  145.                 //LCD实时刷新
  146.                 LCD_Write_Time(time_buf1,TT,R,L,FS,Mode);
  147.                 //延时不然芯片会发热
  148.                 delay_LCD(50);
  149.                 //如果开启定时 定时后转为自动模式
  150.                 if(L==1&&time_buf1[4]==OS&&time_buf1[5]==OF&&time_buf1[6]==OM)
  151.                 {
  152.                         Mode=2;               
  153.                 }
  154.                 else if(L==3&&time_buf1[0]==OS&&time_buf1[5]==OF&&time_buf1[6]==OM)
  155.                 {
  156.                         Mode=2;               
  157.                 }
  158.                 else if(L==2&&time_buf1[4]==ClS&&time_buf1[5]==ClF&&time_buf1[6]==ClM)
  159.                 {
  160.                         Mode=0;
  161.                         pwm_set(0xff);
  162.                 }
  163.                 else if(L==3&&time_buf1[4]==ClS&&time_buf1[5]==ClF&&time_buf1[6]==ClM)
  164.                 {
  165.                         Mode=0;
  166.                         pwm_set(0xff);
  167.                 }
  168.                 //红外命令处理
  169.                 if(IrOK==1)
  170.                 {
  171.                         //标志变量清空
  172.                         IrOK=0;
  173.                         //开机关机按键
  174.                         if(Im[2]==0x45)
  175.                         {
  176.                                 //关机变开机
  177.                                 if(Mode==0)
  178.                                 {
  179.                                         Mode=1;
  180.                                 }
  181.                                 //开机变关机 或自动变关机
  182.                                 else if(Mode==1||Mode==2)
  183.                                 {
  184.                                         Mode=0;
  185.                                         pwm_set(0xff);
  186.                                 }
  187.                         }
  188.                         //自动模式/手动模式切换
  189.                         else if(Im[2]==0x15)
  190.                         {
  191.                                 //手动切自动
  192.                                 if(Mode==1)
  193.                                 {
  194.                                         Mode=2;
  195.                                 }
  196.                                 //自动切手动
  197.                                 else if(Mode==2)
  198.                                 {
  199.                                         Mode=1;
  200.                                 }
  201.                         }
  202.                         //风速 手动调节0档
  203.                         else if(Im[2]==0x16)
  204.                         {
  205.                                 //手动模式
  206.                                 if(Mode==1)
  207.                                 {
  208.                                         pwm_set(0xff);                                       
  209.                                 }
  210.                         }
  211.                         //风速 手动调节1档
  212.                         else if(Im[2]==0x0c)
  213.                         {
  214.                                 //手动模式
  215.                                 if(Mode==1)
  216.                                 {
  217.                                         pwm_set(0x50);                                       
  218.                                 }
  219.                         }
  220.                         //风速 手动调节2档
  221.                         else if(Im[2]==0x18)
  222.                         {
  223.                                 //手动模式
  224.                                 if(Mode==1)
  225.                                 {
  226.                                         pwm_set(0x10);                                       
  227.                                 }
  228.                         }
  229.                         //风速 手动调节3档
  230.                         else if(Im[2]==0x5e)
  231.                         {
  232.                                 //手动模式
  233.                                 if(Mode==1)
  234.                                 {
  235.                                         pwm_set(0x00);                                       
  236.                                 }
  237.                         }
  238.                         //是否开启闹铃
  239.                         else if(Im[2]==0x0d)
  240.                         {
  241.                                 L++;
  242.                                 //开启到关闭
  243.                                 if(L==4)
  244.                                 {
  245.                                         L=0;                                       
  246.                                 }
  247.                                 //////////////////////保存
  248.                                 //写
  249.                                 delay_LCD(20);
  250.                                 write_add(0x00,L);
  251.                         }
  252.                         //调整开机时间
  253.                         else if(Im[2]==0x44)
  254.                         {
  255.                                 //屏幕初始化
  256.                                 Init_LCD_ONTime();
  257.                                 //时间调整
  258.                                 Modetemp=Mode;
  259.                                 Mode=4;
  260.                                 Modes=0;
  261.                                 //时间刷新
  262.                                 LCD_time(OS,OF,OM);
  263.                                 //开启光标
  264.                                 write_com(0x0F);
  265.                                 write_com(0x06);
  266.                                 write_com(0x80+40+11);
  267.         
  268.                                 //设置好跳出
  269.                                 while(Mode==4)
  270.                                 {
  271.                                         //红外命令处理
  272.                                         if(IrOK==1)
  273.                                         {
  274.                                                 //标志变量清空
  275.                                                 IrOK=0;
  276.                                                 //退出并保存
  277.                                                 if(Im[2]==0x44)
  278.                                                 {        
  279.                                                         Mode=Modetemp;        
  280.                                                         //保存
  281.                                                         //写
  282.                                                         delay_LCD(20);
  283.                                                         write_add(0x01,OS);
  284.                                                         delay_LCD(20);
  285.                                                         write_add(0x02,OF);
  286.                                                         delay_LCD(20);
  287.                                                         write_add(0x03,OM);               
  288.                                                 }
  289.                                                 //左移光标
  290.                                                 else if(Im[2]==0x07)
  291.                                                 {
  292.                                                         Modes++;
  293.                                                         if(Modes==3)
  294.                                                                 Modes=0;
  295.                                                 }
  296.                                                 //右移光标
  297.                                                 else if(Im[2]==0x09)
  298.                                                 {
  299.                                                         Modes--;
  300.                                                         if(Modes==0xff)
  301.                                                                 Modes=2;
  302.                                                 }
  303.                                                 //光标值+
  304.                                                 else if(Im[2]==0x40)
  305.                                                 {
  306.                                                         //秒++
  307.                                                         if(Modes==0)
  308.                                                         {
  309.                                                                 OM++;
  310.                                                                 if(OM==60)
  311.                                                                 {
  312.                                                                         OM=0;
  313.                                                                 }
  314.                                                         }
  315.                                                         //分++
  316.                                                         else if(Modes==1)
  317.                                                         {
  318.                                                                 OF++;
  319.                                                                 if(OF==60)
  320.                                                                 {
  321.                                                                         OF=0;
  322.                                                                 }
  323.                                                         }
  324.                                                         //时++
  325.                                                         else if(Modes==2)
  326.                                                         {
  327.                                                                 OS++;
  328.                                                                 if(OS==24)
  329.                                                                 {
  330.                                                                         OS=0;
  331.                                                                 }
  332.                                                         }
  333.                                                 }
  334.                                                 //光标值-
  335.                                                 else if(Im[2]==0x19)
  336.                                                 {
  337.                                                         //秒--
  338.                                                         if(Modes==0)
  339.                                                         {
  340.                                                                 OM--;
  341.                                                                 if(OM==0xff)
  342.                                                                 {
  343.                                                                         OM=59;
  344.                                                                 }
  345.                                                         }
  346.                                                         //分--
  347.                                                         else if(Modes==1)
  348.                                                         {
  349.                                                                 OF--;
  350.                                                                 if(OF==0xff)
  351.                                                                 {
  352.                                                                         OF=59;
  353.                                                                 }
  354.                                                         }
  355.                                                         //时--
  356.                                                         else if(Modes==2)
  357.                                                         {
  358.                                                                 OS--;
  359.                                                                 if(OS==0xff)
  360.                                                                 {
  361.                                                                         OS=23;
  362.                                                                 }
  363.                                                         }
  364.                                                 }


  365.                                                 //时间刷新
  366.                                                 LCD_time(OS,OF,OM);
  367.                                                 //光标设置
  368.                                                 switch(Modes)
  369.                                                 {
  370.                                                         case 0:
  371.                                                         {
  372.                                                                 write_com(0x80+0x40+11);
  373.                                                                 break;
  374.                                                         }
  375.                                                         case 1:
  376.                                                         {
  377.                                                                 write_com(0x80+0x40+8);
  378.                                                                 break;
  379.                                                         }
  380.                                                         case 2:
  381.                                                         {
  382.                                                                 write_com(0x80+0x40+5);
  383.                                                                 break;
  384.                                                         }
  385.                                                 }//Switch        
  386.                                         }
  387.                                 }//while end
  388.                                                 
  389.                                 //屏幕初始化
  390.                                 Init_LCD();
  391.                         }

  392.                         //调整关机时间
  393.                         else if(Im[2]==0x43)
  394.                         {
  395.                                 //屏幕初始化
  396.                                 Init_LCD_OFFTime();
  397.                                 //时间调整
  398.                                 Modetemp=Mode;
  399.                                 Mode=5;
  400.                                 Modes=0;                        
  401.                                 //时间刷新
  402.                                 LCD_time(ClS,ClF,ClM);
  403.                                 //开启光标
  404.                                 write_com(0x0F);
  405.                                 write_com(0x06);
  406.                                 write_com(0x80+40+11);
  407.         
  408.                                 //设置好跳出
  409.                                 while(Mode==5)
  410.                                 {
  411.                                         //红外命令处理
  412.                                         if(IrOK==1)
  413.                                         {
  414.                                                 //标志变量清空
  415.                                                 IrOK=0;
  416.                                                 //退出并保存
  417.                                                 if(Im[2]==0x43)
  418.                                                 {        
  419.                                                         Mode=Modetemp;        
  420.                                                         //保存
  421.                                                         //写
  422.                                                         delay_LCD(20);
  423.                                                         write_add(0x04,ClS);
  424.                                                         delay_LCD(20);
  425.                                                         write_add(0x05,ClF);
  426.                                                         delay_LCD(20);
  427.                                                         write_add(0x06,ClM);               
  428.                                                 }
  429.                                                 //左移光标
  430.                                                 else if(Im[2]==0x07)
  431.                                                 {
  432.                                                         Modes++;
  433.                                                         if(Modes==3)
  434.                                                                 Modes=0;
  435.                                                 }
  436.                                                 //右移光标
  437.                                                 else if(Im[2]==0x09)
  438.                                                 {
  439.                                                         Modes--;
  440.                                                         if(Modes==0xff)
  441.                                                                 Modes=2;
  442.                                                 }
  443.                                                 //光标值+
  444.                                                 else if(Im[2]==0x40)
  445.                                                 {
  446.                                                         //秒++
  447.                                                         if(Modes==0)
  448.                                                         {
  449.                                                                 ClM++;
  450.                                                                 if(ClM==60)
  451.                                                                 {
  452.                                                                         ClM=0;
  453.                                                                 }
  454.                                                         }
  455.                                                         //分++
  456.                                                         else if(Modes==1)
  457.                                                         {
  458.                                                                 ClF++;
  459.                                                                 if(ClF==60)
  460.                                                                 {
  461.                                                                         ClF=0;
  462.                                                                 }
  463.                                                         }
  464.                                                         //时++
  465.                                                         else if(Modes==2)
  466.                                                         {
  467.                                                                 ClS++;
  468.                                                                 if(ClS==24)
  469.                                                                 {
  470.                                                                         ClS=0;
  471.                                                                 }
  472.                                                         }
  473.                                                 }
  474.                                                 //光标值-
  475.                                                 else if(Im[2]==0x19)
  476.                                                 {
  477.                                                         //秒--
  478.                                                         if(Modes==0)
  479.                                                         {
  480.                                                                 ClM--;
  481.                                                                 if(ClM==0xff)
  482.                                                                 {
  483.                                                                         ClM=59;
  484.                                                                 }
  485.                                                         }
  486.                                                         //分--
  487.                                                         else if(Modes==1)
  488.                                                         {
  489.                                                                 ClF--;
  490.                                                                 if(ClF==0xff)
  491.                                                                 {
  492.                                                                         ClF=59;
  493.                                                                 }
  494.                                                         }
  495.                                                         //时--
  496.                                                         else if(Modes==2)
  497.                                                         {
  498.                                                                 ClS--;
  499.                                                                 if(ClS==0xff)
  500.                                                                 {
  501.                                                                         ClS=23;
  502.                                                                 }
  503.                                                         }
  504.                                                 }


  505.                                                 //时间刷新
  506.                                                 LCD_time(ClS,ClF,ClM);
  507.                                                 //光标设置
  508.                                                 switch(Modes)
  509.                                                 {
  510.                                                         case 0:
  511.                                                         {
  512.                                                                 write_com(0x80+40+11);
  513.                                                                 break;
  514.                                                         }
  515.                                                         case 1:
  516.                                                         {
  517.                                                                 write_com(0x80+40+8);
  518.                                                                 break;
  519.                                                         }
  520.                                                         case 2:
  521.                                                         {
  522.                                                                 write_com(0x80+40+5);
  523.                                                                 break;
  524.                                                         }
  525.                                                 }//Switch        
  526.                                         }
  527.                                 }//while end
  528.                                                 
  529.                                 //屏幕初始化
  530.                                 Init_LCD();
  531.                         }
  532.                         //时间调整
  533.                         else if(Im[2]==0x47)
  534.                         {
  535.                                 //屏幕初始化
  536.                                 Init_LCD();               
  537.                                 //读取时间
  538.                                 Ds1302_Read_Time();
  539.                                 //LCD实时刷新
  540.                                 LCD_Write_Time(time_buf1,TT,R,L,FS,Mode);
  541.                                 //延时不然芯片会发热
  542.                                 delay_LCD(50);
  543.                                 //时间调整
  544.                                 Modetemp=Mode;
  545.                                 Mode=3;
  546.                                 Modes=0;
  547.                                 //开启光标
  548.                                 write_com(0x0F);
  549.                                 write_com(0x06);
  550.                                 write_com(0x80+40+7);
  551.                                 //进入调整
  552.                                 while(Mode==3)
  553.                                 {
  554.                                         //红外命令处理
  555.                                         if(IrOK==1)
  556.                                         {
  557.                                                 //标志变量清空
  558.                                                 IrOK=0;        
  559.                                                 //跳出调整
  560.                                                 if(Im[2]==0x47)
  561.                                                 {
  562.                                                         Mode=Modetemp;
  563.                                                 }
  564.                                                 //左移光标
  565.                                                 else if(Im[2]==0x07)
  566.                                                 {
  567.                                                         Modes++;
  568.                                                         if(Modes==6)
  569.                                                                 Modes=0;
  570.                                                 }
  571.                                                 //右移光标
  572.                                                 else if(Im[2]==0x09)
  573.                                                 {
  574.                                                         Modes--;
  575.                                                         if(Modes==0xff)
  576.                                                                 Modes=5;
  577.                                                 }
  578.                                                 //光标值+
  579.                                                 else if(Im[2]==0x40)
  580.                                                 {
  581.                                                         //秒++
  582.                                                         if(Modes==0)
  583.                                                         {
  584.                                                                 time_buf1[6]++;
  585.                                                                 if(time_buf1[6]==60)
  586.                                                                 {
  587.                                                                         time_buf1[6]=0;
  588.                                                                 }
  589.                                                         }
  590.                                                         //分++
  591.                                                         else if(Modes==1)
  592.                                                         {
  593.                                                                 time_buf1[5]++;
  594.                                                                 if(time_buf1[5]==60)
  595.                                                                 {
  596.                                                                         time_buf1[5]=0;
  597.                                                                 }
  598.                                                         }
  599.                                                         //时++
  600.                                                         else if(Modes==2)
  601.                                                         {
  602.                                                                 time_buf1[4]++;
  603.                                                                 if(time_buf1[4]==24)
  604.                                                                 {
  605.                                                                         time_buf1[4]=0;
  606.                                                                 }
  607.                                                         }
  608.                                                         //年++
  609.                                                         else if(Modes==3)
  610.                                                         {
  611.                                                                 time_buf1[1]++;
  612.                                                                 if(time_buf1[1]==99)
  613.                                                                 {
  614.                                                                         time_buf1[1]=0;
  615.                                                                 }
  616.                                                         }
  617.                                                         //月++
  618.                                                         else if(Modes==4)
  619.                                                         {
  620.                                                                 time_buf1[2]++;
  621.                                                                 if(time_buf1[2]==13)
  622.                                                                 {
  623.                                                                         time_buf1[2]=1;
  624.                                                                 }
  625.                                                         }
  626.                                                         //日++
  627.                                                         else if(Modes==5)
  628.                                                         {
  629.                                                                 time_buf1[3]++;
  630.                                                                 if(time_buf1[3]==(YDay(time_buf1[1],time_buf1[2])+1))
  631.                                                                 {
  632.                                                                         time_buf1[3]=1;
  633.                                                                 }
  634.                                                                 time_buf1[7]=Conver_week(time_buf1[1],time_buf1[2],time_buf1[3]);
  635.                                                         }
  636.                                                 }
  637.                                                 //光标值-
  638.                                                 else if(Im[2]==0x19)
  639.                                                 {
  640.                                                         //秒--
  641.                                                         if(Modes==0)
  642.                                                         {
  643.                                                                 time_buf1[6]--;
  644.                                                                 if(time_buf1[6]==0xff)
  645.                                                                 {
  646.                                                                         time_buf1[6]=59;
  647.                                                                 }
  648.                                                         }
  649.                                                         //分--
  650.                                                         else if(Modes==1)
  651.                                                         {
  652.                                                                 time_buf1[5]--;
  653.                                                                 if(time_buf1[5]==0xff)
  654.                                                                 {
  655.                                                                         time_buf1[5]=59;
  656.                                                                 }
  657.                                                         }
  658.                                                         //时--
  659.                                                         else if(Modes==2)
  660.                                                         {
  661.                                                                 time_buf1[4]--;
  662.                                                                 if(time_buf1[4]==0xff)
  663.                                                                 {
  664.                                                                         time_buf1[4]=23;
  665.                                                                 }
  666.                                                         }
  667.                                                         //年--
  668.                                                         else if(Modes==3)
  669.                                                         {
  670.                                                                 time_buf1[1]--;
  671.                                                                 if(time_buf1[1]==0xff)
  672.                                                                 {
  673.                                                                         time_buf1[1]=99;
  674.                                                                 }
  675.                                                         }
  676.                                                         //月--
  677.                                                         else if(Modes==4)
  678.                                                         {
  679.                                                                 time_buf1[2]--;
  680.                                                                 if(time_buf1[2]==0)
  681.                                                                 {
  682.                                                                         time_buf1[2]=12;
  683.                                                                 }
  684.                                                         }
  685.                                                         //日--
  686.                                                         else if(Modes==5)
  687.                                                         {
  688.                                                                 time_buf1[3]--;
  689.                                                                 if(time_buf1[3]==0)
  690.                                                                 {
  691.                                                                         time_buf1[3]=YDay(time_buf1[1],time_buf1[2]);
  692.                                                                 }
  693.                                                                 time_buf1[7]=Conver_week(time_buf1[1],time_buf1[2],time_buf1[3]);
  694.                                                         }
  695.                                                 }



  696.                                                 //LCD实时刷新
  697.                                                 LCD_Write_Time(time_buf1,TT,R,L,FS,Mode);
  698.                                                 //光标设置
  699.                                                 switch(Modes)
  700.                                                 {
  701.                                                         case 0:
  702.                                                         {
  703.                                                                 write_com(0x80+40+7);
  704.                                                                 break;
  705.                                                         }
  706.                                                         case 1:
  707.                                                         {
  708.                                                                 write_com(0x80+40+4);
  709.                                                                 break;
  710.                                                         }
  711.                                                         case 2:
  712.                                                         {
  713.                                                                 write_com(0x80+40+1);
  714.                                                                 break;
  715.                                                         }
  716.                                                         case 3:
  717.                                                         {
  718.                                                                 write_com(0x80+3);
  719.                                                                 break;
  720.                                                         }
  721.                                                         case 4:
  722.                                                         {
  723.                                                                 write_com(0x80+6);
  724.                                                                 break;
  725.                                                         }
  726.                                                         case 5:
  727.                                                         {
  728.                                                                 write_com(0x80+9);
  729.                                                                 break;
  730.                                                         }
  731.                                                 }//Switch
  732.                                         }//if               
  733.                                 }//while
  734.                                 //屏幕初始化
  735.                                 Init_LCD();
  736.                                 //保存时间
  737.                                 Ds1302_Write_Time();
  738.                         }

  739.                 }

  740.         }//while end
  741. }



  742. //延时
  743. void delayHW(uchar i)
  744. {
  745.   uchar j,k;
  746.   for(j=i;j>0;j--)
  747.     for(k=125;k>0;k--);
  748. }
  749. //外部中断定时器0寄存器初始化
  750. void Init()
  751. {
  752.         m=0;
  753.         f=0;
  754.         EA=1;//开启总中断        
  755.         IT1=1;//下降沿有效
  756.         EX1=1;//外部中断1开        
  757.         TMOD=0x01;//定时器初始化  
  758.         TH0=0;//T0赋初值
  759.         TL0=0;
  760.         TR0=0;//t0开始计时
  761. }
  762. //外部中断解码程序_外部中断1
  763. void intersvr1(void) interrupt 2 using 1
  764. {
  765. TR0=1;
  766. Tc=TH0*256+TL0/256;//提取中断时间间隔时长
  767. TH0=0;
  768. TL0=0;         //定时中断重新置零
  769. if((Tc>Imin)&&(Tc<Imax))
  770. {
  771.         m=0;
  772.         f=1;
  773.         return;
  774. }       //找到启始码
  775. if(f==1)
  776. {
  777.     if(Tc>Inum1&&Tc<Inum3)
  778.     {
  779.            Im[m/8]=Im[m/8]>>1|0x80; m++;
  780.     }
  781.     if(Tc>Inum2&&Tc<Inum1)
  782.     {
  783.       Im[m/8]=Im[m/8]>>1; m++; //取码
  784.            }
  785.            if(m==32)
  786.     {
  787.       m=0;  
  788.       f=0;
  789.       if(Im[2]==~Im[3])
  790.       {
  791.            IrOK=1;
  792.                           TR0=1;
  793.                           delayHW(200);
  794.            }
  795.       else IrOK=0;   //取码完成后判断读码是否正确
  796.     }
  797.                //准备读下一码
  798. }
  799. }
  800. //PWM脉冲初始化
  801. void initpwm()
  802. {
  803. CCON=0;
  804. CL=0;
  805. CH=0;
  806. CMOD=0X00;//设定Pwm时钟频率11.0592/12

  807. CCAPM0=0X42;
  808. PCA_PWM0=0X00;
  809. CCAP0H=0;
  810. CCAP0L=0xff;
  811. CR=1;
  812. }
  813. //PWM占空比设置
  814. void pwm_set(uchar a)
  815. {
  816. CCAP0H=a;
  817. }
复制代码

所有资料51hei提供下载:
程序--原理图.rar (2.45 MB, 下载次数: 46)

评分

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

查看全部评分

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

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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