找回密码
 立即注册

QQ登录

只需一步,快速开始

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

STM32定时器中断解码433M无线遥控的源程序

  [复制链接]
跳转到指定楼层
楼主
stm32定时器中断解码433m无线信号,测试过可用直接用

单片机源程序如下:
  1. #include "rf433.h"
  2. #include "usart.h"
  3. #include "includes.h"
  4. #include "stm32f10x_tim.h"
  5. /* USER CODE BEGIN 0 */
  6. uint8_t rf_data[3] = {0};

  7. uint8_t RF;

  8. uint8_t decode_ok;                 //解码成功
  9. uint8_t  hh_w,ll_w;           //高,低电平宽度
  10. uint8_t  ma_x;                //接收到第几位编码了
  11. uint8_t  bma1,bma2,bma3,bma4; //用于接收过程存放遥控编码,编码比较两次,这是第一次
  12. uint8_t  mma1,mma2,mma3,mma4;
  13. uint8_t mmb1,mmb2,mmb3,mmb4; //        用于接收过程存放遥控编码,第二次
  14. //extern uint8_t mmb1,mmb2,mmb3,mmb4;

  15. uint8_t rf_ok1,rf_ok2,rf_ok;                 //解码过程中的临时接收成功标志,接收到一个完整的遥控命令后置1,通知解码程序可以解码了
  16. uint8_t old_rc5;             //保存上一次查询到的电平状态
  17. uint8_t tb_ok;               //接收到同步的马时置1   
  18. uint8_t D0,D1,D2,D3 ;
  19. uint16_t s ,s1;        
  20. uint8_t bt_auto;     //自动设置遥控接收波特率标志


  21. /*        存放学习数据 即存储在flash里的 */
  22. //u8 rf433_save_data[3] = { 0x6d, 0xab, 0x26 };
  23. u8 rf433_save_data[3] = {0};
  24. /*        433数据接收成功标志位  */
  25. u8 rf433_msg_rev_success = NO;

  26. /*        是否刚刚解析完数据 用于给应用层提供一次输出 滤除掉发送端多次发送数据 */
  27. u8 isJustParser = NO;

  28. /* 学习状态 */
  29. u8 isLearnStatus = NO;


  30. /*        433初始化 */
  31. void RF433_Init(void)
  32. {
  33.         GPIO_InitTypeDef GPIO_InitStructure;
  34. //        EXTI_InitTypeDef EXTI_InitStructure;
  35.             TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  36.          NVIC_InitTypeDef NVIC_InitStructure;
  37.         /* 开启时钟*/
  38.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOD,ENABLE);


  39.         /* RF433引脚功能定义 */        
  40.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  41.         GPIO_InitStructure.GPIO_Pin = RF433_PIN;      
  42.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         // 上拉输入

  43.         GPIO_Init(RF433_PORT, &GPIO_InitStructure);

  44.         /* learnKey引脚功能定义 */        
  45.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  46.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;      
  47.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;         // 上拉输入

  48.         GPIO_Init(GPIOC, &GPIO_InitStructure);
  49.         #if 0
  50.         /* EXTI line mode config */
  51.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3);
  52.   EXTI_InitStructure.EXTI_Line = EXTI_Line3;
  53.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  54.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿中断;
  55.   //EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling; //中断
  56.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  57.   EXTI_Init(&EXTI_InitStructure);
  58.         #endif


  59.                 /* ??TIM2CLK ? 72MHZ */
  60.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 , ENABLE);
  61.     //TIM_DeInit(TIM2);
  62.         
  63.         /* ????????????(???) */
  64.     TIM_TimeBaseStructure.TIM_Period=49;
  65.         
  66.     /* ?? TIM_Period?????????????? */
  67.           /* ???????72 */
  68.     TIM_TimeBaseStructure.TIM_Prescaler= 71;
  69.         
  70.                 /* ??????????????,?????? */
  71.     TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;
  72.         
  73.     TIM_TimeBaseStructure.TIM_CounterMode=TIM_CounterMode_Up;
  74.     TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
  75.         
  76.     TIM_ClearFlag(TIM2, TIM_FLAG_Update);
  77.         
  78.     TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
  79.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                        //ê1?ü°′?üWK_UP?ù?úμ?ía2??D??í¨μà
  80.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x03;        //?à??ó??è??2£?
  81.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x04;                                        //×óó??è??3
  82.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                                //ê1?üía2??D??í¨μà
  83.         NVIC_Init(&NVIC_InitStructure);                  
  84.     TIM_Cmd(TIM2, ENABLE);                                                                                                                                                
  85.    
  86.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 , ENABLE);                /*???????*/  
  87.         
  88. }
  89. /*        50us中断 */
  90. void TIM2_IRQHandler(void)
  91. {
  92.         /*        用于滤除 */
  93.         static u16 cnt = 0x0;
  94.         static u32 decode_ok_cnt = 0;

  95.         if ( TIM_GetITStatus(TIM2 , TIM_IT_Update) != RESET )                                 
  96.         {         
  97.                 /*        刚解析成功一次数据  则延时一定时间 再进行数据接收 */

  98.                 if( isJustParser == YES )
  99.                 {
  100.                                 /*        用于滤除 */
  101.                         decode_ok_cnt++;
  102.                         if( decode_ok_cnt < 18000 )        //        900ms
  103.                         {
  104.                                 /*        900ms之后 再进行判断 */
  105.                                 TIM_ClearITPendingBit( TIM2, TIM_FLAG_Update );
  106.                                 return;
  107.                         }
  108.                 }
  109.                 isJustParser = NO;
  110.                 decode_ok_cnt = 0;
  111.                 /*        读取电平 */
  112.                 RF = RF433_DATA;                        
  113.                 /*        硬件电路 三极管反向 */
  114.                 if( RF == 1 )
  115.                 {
  116.                                 ll_w++;
  117.                                 old_rc5=0;
  118.                 }                // 检测到低电平 低电平时间加1,记录本次电平状态old_rc5
  119.     else              // 检测到高电平
  120.     {
  121.                                 hh_w++;
  122.          if (!old_rc5)  // 检测到从低到高的跳变,已检测到一个完整(高-低)电平周期
  123.          {
  124.                                          //if (((hh_w>=2)&&(hh_w<=5))&&((ll_w>=60)&&(ll_w<=180))) //判同步码          2/5 100/130
  125.                                          if (((hh_w>=1)&&(hh_w<=20))&&((ll_w>=50)&&(ll_w<=190))) //判同步码          2/5 100/130
  126.                                          {
  127.                                                   tb_ok = 1 ;
  128.                                                         ma_x = 0;
  129.                                                         bma1=0; bma2=0; bma3=0; bma4=0;   

  130.                                          }
  131.            else if ((tb_ok)&&((ll_w>=12)&&(ll_w<=18)))         //   8/13
  132.                                         {         
  133.                                                 ma_x++;                                //已经接收到同步码,判0                        //        800us
  134.                                                 if(ma_x>23)
  135.                                                 {                        
  136.                                                          if(!rf_ok1)        //rf_ok1 临时接收成功
  137.                                                         {
  138.                                                                         mma1=bma1;
  139.                                                                         mma2=bma2;
  140.                                                                         mma3=bma3;
  141.                                                                         mma4=bma4;                   //将接收到的编码复制到解码寄存器中                             
  142.                                                                         rf_ok1=1;                    // 通知解码子程序可以解码了
  143.                                                                         tb_ok=0;
  144. //                                                                bt_auto=0;
  145.                                                                         s=800;                                                
  146.                         
  147.                                                         }
  148.                                                         else
  149.                                                         {
  150.                                                                         mmb1=bma1;
  151.                                                                         mmb2=bma2;
  152.                                                                         mmb3=bma3;
  153.                                                                         mmb4=bma4;                    //将接收到的编码复制到解码寄存器中                             
  154.                                                                         rf_ok2=1;                     // 通知解码子程序可以解码了
  155.                                                                         tb_ok=0;
  156.         //                                                        bt_auto=0;                                                                                                                                                        
  157.                                                         }
  158.                                                 }
  159.                                  }  
  160.             else if ((tb_ok)&&((ll_w>=2)&&(ll_w<=7)))                   //   2/7
  161.             {                                         
  162.                                                         /* 1 */                                        /*        200us */
  163.                                                                 switch (ma_x)
  164.                 {
  165.                                                                                         /*        合成数据位        */
  166.                                                                                  /*        同步头1 */
  167.                                                                                  case 0 : { bma1=bma1 | 0x80; break; }
  168.                                                                                  case 1 : { bma1=bma1 | 0x40; break; }
  169.                                                                                  case 2 : { bma1=bma1 | 0x20; break; }
  170.                                                                                  case 3 : { bma1=bma1 | 0x10; break; }
  171.                                                                                  case 4 : { bma1=bma1 | 0x08; break; }
  172.                                                                                  case 5 : { bma1=bma1 | 0x04; break; }
  173.                                                                                  case 6 : { bma1=bma1 | 0x02; break; }
  174.                                                                                  case 7 : { bma1=bma1 | 0x01; break; }
  175.                                                                                  /*        同步头2 */
  176.                                                                                  case 8 : { bma2=bma2 | 0x80; break; }
  177.                                                                                  case 9 : { bma2=bma2 | 0x40; break; }
  178.                                                                                  case 10: { bma2=bma2 | 0x20; break; }
  179.                                                                                  case 11: { bma2=bma2 | 0x10; break; }
  180.                                                                                  case 12: { bma2=bma2 | 0x08; break; }
  181.                                                                                  case 13: { bma2=bma2 | 0x04; break; }
  182.                                                                                  case 14: { bma2=bma2 | 0x02; break; }
  183.                                                                                  case 15: { bma2=bma2 | 0x01; break; }
  184.                                                                                  /*        同步头3 */
  185.                                                                                  case 16: { bma3=bma3 | 0x80; break; }
  186.                                                                                  case 17: { bma3=bma3 | 0x40; break; }
  187.                                                                                  case 18: { bma3=bma3 | 0x20; break; }
  188.                                                                                  case 19: { bma3=bma3 | 0x10; break; }
  189.                                                                                  case 20: { bma3=bma3 | 0x08; break; }
  190.                                                                                  case 21: { bma3=bma3 | 0x04; break; }
  191.                                                                                  case 22: { bma3=bma3 | 0x02; break; }
  192.                                                                                  case 23: { bma3=bma3 | 0x01;
  193.                                           
  194.                                                                      if(!rf_ok1)
  195.                                                                           {
  196.                                                                                         mma1=bma1;
  197.                                                                                         mma2=bma2;
  198.                                                                                         mma3=bma3;     
  199.                                                                                        
  200.                                                                                         rf_ok1=1;         // 通知解码子程序可以解码了
  201.                                                                                         tb_ok=0;
  202. //                                                                                        bt_auto=0;
  203.                                                                                         s=1000;
  204.                                                                                         break;                                                                        
  205.                                                                          }
  206.                                                                          else
  207.                                                                          {
  208.                                                                                         mmb1=bma1;
  209.                                                                                         mmb2=bma2;
  210.                                                                                         mmb3=bma3;   
  211.                                                                                                             
  212.                                                                                         rf_ok2=1; // 通知解码子程序可以解码了
  213.                                                                                         tb_ok=0;
  214.                                                                                         break;                                                                                                                                                        
  215.                                                                          }
  216.                                    
  217.                 }
  218.              }
  219.              ma_x++;
  220.             }
  221.             else {ma_x=0; tb_ok=0; bt_auto=0;bma1=0; bma2=0; bma3=0; hh_w=1;ll_w=0;}      //接收到不符合的高-低电平序列
  222.                                                 ll_w=0;hh_w=1;
  223.                                 }         
  224.        old_rc5=1;      // 记录本次电平状态
  225.     }
  226.                 if(rf_ok1)                //规定时间内接受到2帧相同的编码数据才有效
  227.                 {
  228.                         s--;
  229.                         if(!s) rf_ok1=0;
  230.                         if(rf_ok2)
  231.                                 {
  232.                                   if((mma1==mmb1)&&(mma2==mmb2)&&(mma3==mmb3))
  233.                                         {
  234.                                                 rf_ok=1;
  235.                                                 rf_ok1=0;
  236.                                                 rf_ok2=0;                                         
  237.                                         }
  238.                                         else
  239.                                  {
  240.                                                 rf_ok=0;
  241.                                                 rf_ok1=0;
  242.                                                 rf_ok2=0;
  243.                                  }                        
  244.                                 }                                       
  245.                 }
  246.                 #if 1
  247.             if((rf_ok))                 //判断是否接收成功
  248.                 {         
  249.                                 /*        关闭定时器 取出数据 */
  250.                                 TIM_ITConfig(TIM2, TIM_IT_Update, DISABLE);
  251.                                 rf_ok = 0;
  252.                                 rf_data[0] = mma1;
  253.                                 rf_data[1] = mma2;
  254.                                 rf_data[2] = mma3;        
  255.                                 
  256.                                 /*        接收433数据成功 */
  257.                                 rf433_msg_rev_success = YES;
  258.                                 /*        开启定时器 */
  259.                                 TIM_ITConfig(TIM2  , TIM_IT_Update, ENABLE);
  260.                 }
  261.                 #endif
  262.                 /*        清除标志位 */
  263.                 TIM_ClearITPendingBit(TIM2 , TIM_FLAG_Update);
  264.         }
  265.         #if SYSTEM_SUPPORT_OS         //??SYSTEM_SUPPORT_OS??,?????OS.
  266.         OSIntExit();                                                                                          
  267.         #endif
  268. }

  269. /*        内存块比较  */
  270. u8  memCompare( u8 *src, u8 *dsc, u8 length )
  271. {
  272.         while( length > 0 )
  273.         {
  274.                 if( *src == *dsc )
  275.                 {
  276.                         length--;
  277.                         src++;
  278.                         dsc++;
  279.                         continue;
  280.                 }
  281.                 return NO;
  282.         }
  283.         return YES;
  284. }


  285. /*        433数据解析 报警返回YES 1  否则  NO 0 */
  286. /*        调用这个函数时  如果是学习状态 这不是报警  在此之前 需定义一个学习状态  */
  287. u8 RF433_Data_Parser(void)
  288. {
  289.         /*        433数据接收成功 */
  290.         if( rf433_msg_rev_success == YES )
  291.         {
  292.                 /*        清除标志位 */
  293.                 rf433_msg_rev_success = NO;
  294.                 isJustParser = YES;
  295.                 printf("------> Have 433 msg!!!\n");
  296.                
  297.                 printf("------> rf_data[0] = 0x%2x\n",rf_data[0]);
  298.                 printf("------> rf_data[1] = 0x%2x\n",rf_data[1]);
  299.                 printf("------> rf_data[2] = 0x%2x\n",rf_data[2]);
  300.                 printf("\n");
  301.                 if( isLearnStatus == YES )
  302.                 {
  303.                         /*        学习状态 存储数据 */
  304.                         printf("-------> Is learn status,please save data!!\n");
  305.                         /*        此处调用flash存放函数 存储成功 需 isLearnStatus 清除 */
  306.                         
  307.                         /*        学习状态 非报警 */
  308.                         return 2;
  309.                 }
  310.                 /*        解析数据 */
  311.                 if( (rf433_save_data[0]==rf_data[0]) && \
  312.                                 (rf433_save_data[1]==rf_data[1]) && \
  313.                                 (rf433_save_data[2]==rf_data[2]) )
  314.                 {
  315.                         /*        烟感同步头与学习到存储的数据一致 */
  316.                         /*        即使烟感报警 */
  317.                         printf("------> The smoker sensor is alarming!!!!!!\n\n");
  318.                         return YES;
  319.                 }else
  320.                 {
  321.                         printf("------> The another smoker sensor's data!\n\n");
  322.                 }
  323.         }
  324.         return NO;
  325. }

  326. /*********************************************END OF FILE**********************/
复制代码

所有资料51hei提供下载:
433定时器中断解码.rar (4.66 KB, 下载次数: 173)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:495125 发表于 2019-4-28 14:37 | 只看该作者
正好需要,谢谢
回复

使用道具 举报

板凳
ID:507796 发表于 2019-4-29 00:38 来自手机 | 只看该作者
谢谢楼主分享~
回复

使用道具 举报

地板
ID:111843 发表于 2020-1-6 14:51 | 只看该作者
不错,感谢分享!
回复

使用道具 举报

5#
ID:101305 发表于 2023-6-9 06:31 | 只看该作者
这能用吗?
回复

使用道具 举报

6#
ID:101305 发表于 2023-7-19 06:14 | 只看该作者
这个能解所有433码吗?滚码的例子有没有
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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