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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机433M无线收发数据程序
返回列表 发新帖
查看: 2491|回复: 1
打印 上一主题 下一主题
收起左侧

单片机433M无线收发数据程序

[复制链接]
跳转到指定楼层
楼主
ID:613095 发表于 2023-10-24 22:22 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
# 433 发送和接收模块
## 1. 433发送

* 433发送过程：
（1）电平时间设置 **Witty433_Init()**
（2）发送内容和次数设置 **SendInput_433()**
（3）发送 **StartSend_433()**

* 433自定义内容：

    芯片类型、管脚操作、延时函数**delay_us_433**、**delay_ms_433**及芯片ID随芯片/操作系统不同由用户定义。

*             433的各个电平时间，433的地址码，433的控制码，433的发送次数由用户自定义。

## 2. 433接收
* 433接收过程：

  （1）电平时间设置，定时器初始化为PWM输入模式（注意CLK大小）

  （2）定时器pwm输入捕获低电平时长，接收传输的433数据

  （3）在433信号处理线程 **deal433_entry()** 中对接收的数据进行处理

* 433自定义内容：

  定时器PWM输入模式的初始化，各个电平时间初始化，接收校验次数，数据处理。

  1. #include <rtthread.h>
  2. #include <rtdevice.h>
  3. #include <board.h>
  4. #include <433_receive.h>

  6. /**
  7. * 遥控器使用说明：使用433遥控器前要进行配对，将遥控器的地址码获取到存在flash当中，每次控制时进行校验。
  8. * 配对时，设备上长按配对按键，配对遥控器的LED灯开始闪烁，此时连续按遥控器上的配对按键，直到设备上的配对灯灭
  9. * 则表示配对完成
  10. */

  12. /**
  13. * 程序名称：接收并处理433信号
  14. * 433接收过程：利用定时器的PWM捕获，捕获PWM信号，捕获完成后在deal433_entry(void *parameter)线程中进行处理
  15. * 433接收自定义内容：高低电平时长，地址码长度，控制码长度，控制指令处理相关内容
  16. * 其它：华泰自己的433信号没有结束码
  17. */



  21. TIM_HandleTypeDef htim2;
  22. int add_low_level(unsigned int low_level, unsigned int * re_Data);
  23. static unsigned int RxData = 0xFF;        //433接收数据
  24. static int RxOk = 0;                                //433接收标志位



  28. /* 433电平时长定义（自定义部分）*/
  29. #define start_high 4      //起始码高电平时长,单位CLK，CLK大小通过定时器分频系数来改,默认100us
  30. #define start_low  124    //起始码低电平时长
  31. #define one_high 4        //数字1的高电平时长
  32. #define one_low 4         //数字1的低电平时长
  33. #define zero_high 4       //数字0的高电平时长
  34. #define zero_low 12       //数字0的低电平时长
  35. //#define stop_high 10    //结束码的高电平时长
  36. //#define stop_low 0      //结束码的低电平时长
  37. #define time_range 2      //电平时长有效范围

  39. /* 数据长度定义（自定义部分）*/
  40. /* || 起始码 || 数据码（地址码和控制代码）（自定义部分）|| */
  41. #define data_full_len 32  //数据码总长（位）地址码和控制代码加起来的长度
  42. #define addr_len 24       //地址码长度（位）
  43. #define control_len 8     //控制代码（位）

  45. /* 已配对的433遥控器地址（自定义部分） */
  46. unsigned int remote_addr=0x000001;      



  50. /**
  51. * 捕获回调函数
  52. */
  53. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
  54. {
  55.         static uint32_t m_pulse;
  56.         if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
  57.     {               
  58.                 m_pulse = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_2);        //得到低电平的时间
  59.                 add_low_level(m_pulse, &RxData);                                                                        //获取数据
  60.     }
  61. }



  65. /**
  66. * 433输入信号处理
  67. * @parm1 出入参数,低电平时间
  68. * @parm2 传出参数,接收成功就是接收成功的数据
  69. * @return (0---没有一个完整的数据)(1---有一个完整的数据)
  70. */
  71. int add_low_level(unsigned int low_level, unsigned int * re_Data)
  72. {
  73.         static int Start = 0;
  74.         static unsigned int Num;
  75.         static unsigned int Data = 0;        //最新数据
  76.         static unsigned int Data1 = 0;        //上次数据
  77.         static unsigned int Data2 = 0;        //上上次数据
  78.        
  79.         if(low_level>start_low-time_range*2)                                // 确定起始码
  80.         {
  81.                 Start = 1;
  82.                 Data = 0;
  83.                 Num = 0;
  84.         }
  85.         else if((Start == 1)&&(low_level>zero_low-time_range)&&(low_level<zero_low+time_range))                //数据0
  86.         {
  87.                 Data = Data<<1;
  88.                 Num++;
  89.         }
  90.         else if((Start == 1)&&(low_level>one_low-time_range)&&(low_level<one_low+time_range))                        //数据1
  91.         {
  92.                 Data = Data<<1;
  93.                 Data = Data +1;
  94.                 Num++;
  95.         }
  96.         else                                                        //错误数据
  97.         {
  98.                 Start = 0;
  99.         }
  100.        
  101.         if((Num == data_full_len)&&(Start == 1))        //收到全部数据
  102.         {
  103.                 Start = 0;
  104.                 if(((Data == Data1)||(Data == Data2))&&(Data != 0xFF))        //收到两遍相同的
  105.                 {
  106.                         *re_Data = Data;                //得到数据
  107.                         RxOk = 1;
  108.                        
  109.                         Data = 0xFF;
  110.                         Data1 = 0xFF;
  111.                         Data2 = 0xFF;
  112.                 }
  113.                 else
  114.                 {
  115.                         Data2 = Data1;
  116.                         Data1 = Data;
  117.                 }
  118.         }
  119.         return 0;
  120. }


  123. /**
  124.   * 定时器初始化为pwm输入捕获（CLK为100us）
  125.   * @brief TIM2 Initialization Function
  126.   * @param None
  127.   * @retval None
  128.   */
  129. static void MX_TIM2_Init(void)
  130. {

  132.   /* USER CODE BEGIN TIM2_Init 0 */

  134.   /* USER CODE END TIM2_Init 0 */

  136.   TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  137.   TIM_IC_InitTypeDef sConfigIC = {0};
  138.   TIM_MasterConfigTypeDef sMasterConfig = {0};

  140.   /* USER CODE BEGIN TIM2_Init 1 */

  142.   /* USER CODE END TIM2_Init 1 */
  143.   htim2.Instance = TIM2;
  144.   htim2.Init.Prescaler = 7200-1;   //CLK大小改这里，现在为100us
  145.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  146.   htim2.Init.Period = 50000;
  147.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  148.   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  149.   if (HAL_TIM_IC_Init(&htim2) != HAL_OK)
  150.   {
  151.     Error_Handler();
  152.   }
  153.   sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
  154.   sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
  155.   sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  156.   sSlaveConfig.TriggerPrescaler = TIM_ICPSC_DIV1;
  157.   sSlaveConfig.TriggerFilter = 0;
  158.   if (HAL_TIM_SlaveConfigSynchronization(&htim2, &sSlaveConfig) != HAL_OK)
  159.   {
  160.     Error_Handler();
  161.   }
  162.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_FALLING;
  163.   sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  164.   sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  165.   sConfigIC.ICFilter = 0;
  166.   if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  167.   {
  168.     Error_Handler();
  169.   }
  170.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  171.   sConfigIC.ICSelection = TIM_ICSELECTION_INDIRECTTI;
  172.   if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
  173.   {
  174.     Error_Handler();
  175.   }
  176.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  177.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  178.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  179.   {
  180.     Error_Handler();
  181.   }
  182.   /* USER CODE BEGIN TIM2_Init 2 */
  183.   HAL_TIM_IC_Start_IT(&htim2,TIM_CHANNEL_2);      //打开定时器中断
  184.   /* USER CODE END TIM2_Init 2 */

  186. }





  192. /**
  193. * 433通信处理线程
  194. */
  195. void deal433_entry(void *parameter)
  196. {
  197.     unsigned int receive_addr;    //接收到433信号的地址
  198.         unsigned int receive_control; //接收到433信号的功能代码
  199.     MX_TIM2_Init();
  200.         while(1)
  201.         {
  202.                   if(RxOk == 1)                        //接收完成
  203.                   {
  204.                           RxOk = 0;
  205.                           /*接收到数据进行数据处理*/
  206.                           rt_kprintf("receive data is %#X\n",RxData);
  207.                           receive_addr = RxData >> control_len ;    //得到433信号地址
  208.                           receive_control = RxData & 0xFF ;         //得到433信号的功能代码（根据需要的功能码位数可能需要修改）
  209.                           /*对遥控器地址进行校验*/
  210.                           if(receive_addr==remote_addr)  //校验通过
  211.                           {
  212.                                   /********************（自定义部分）***********************/
  213.                                   /*执行相应的功能*/
  214.                                   switch(receive_control)
  215.                                   {
  216.                                           case 0x11:
  217.                                           {
  218.                                                   
  219.                                           }break ;
  220.                                           
  221.                                           
  222.                                           
  223.                                           
  224.                                           
  225.                                           
  226.                                           
  227.                                           
  228.                                           
  229.                                           
  230.                                   }
  231.                                   /*********************************************************/
  232.                           }
  233.                           
  234.                   }
  235.                   rt_thread_mdelay(1);
  236.         }

  238. }
复制代码
  1. #include "433_send.h"
  2. #include <rtthread.h>
  3. #include <rtdevice.h>
  4. #include <board.h>
  5. //#include "delay.h"
  6. //#include "gpio.h"

  8. /**
  9. * 程序名称： 433信号发送
  10. * 433发送过程：1.电平时间设置 Witty433_Init(unsigned int set_level_buf[8]) -->
  11. *            2.发送内容和次数设置 SendInput_433(unsigned char *data,unsigned int dataBitNum,unsigned char sendNum) -->
  12. *                         3.发送 StartSend_433()
  13. * 433自定义内容：        芯片类型、管脚操作、延时函数delay_us_433、delay_ms_433及芯片ID随芯片/操作系统不同由用户定义。
  14. *             433的各个电平时间，433的地址码，433的控制码，433的发送次数由用户自定义。
  15. */


  18. /* 选择芯片类型（用户自定义） */
  19. #define STM32FL151       

  21. /* 433发射管脚操作函数（用户自定义） */               
  22. #define Pin_433_H        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8,GPIO_PIN_SET)
  23. #define Pin_433_L        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8,GPIO_PIN_RESET)

  25. /* 433延时函数 */
  26. static void (*delay_us_433)(unsigned int us);
  27. static void (*delay_ms_433)(unsigned short ms);
  28. static void delay_long_us(unsigned int long_us);

  30. /* 433地址码默认设置*/
  31. static unsigned int GetAddrFromChipID(unsigned char *addr);


  34. static Witty433 witty433;
  35. static unsigned char addr[3];
  36. static unsigned int addr_len = 24;


  39. void delay_long_us(unsigned int long_us)
  40. {
  41.         unsigned short ms = long_us/1000;
  42.         unsigned int us = long_us%1000;
  43.        
  44.         if(ms)delay_ms_433(ms);
  45.         if(us)delay_us_433(us);
  46. }

  48. unsigned int GetAddrFromChipID(unsigned char *addr)
  49. {
  50.         #ifdef STM32F10X
  51.                 addr[0]=*(unsigned char*)(0x1ffff7ed);                //芯片ID第5、6、7位作为addr
  52.                 addr[1]=*(unsigned char*)(0x1ffff7ee);
  53.                 addr[2]=*(unsigned char*)(0x1ffff7ef);
  54.         #elif defined STM32FL151
  55.                 addr[0]=*(unsigned char*)(0x1ff80055);
  56.                 addr[1]=*(unsigned char*)(0x1ff80056);
  57.                 addr[2]=*(unsigned char*)(0x1ff80057);
  58.         #elif defined ESP32                                                                //esp32用户自定义选择--默认随机数
  59.                 addr[0]=srand()%255;                                               
  60.                 addr[1]=srand()%255;
  61.                 addr[2]=srand()%255;
  62.         #else
  63.                 addr[0]=srand()%255;                                                //未选择芯片类型则随机指定地址
  64.                 addr[1]=srand()%255;
  65.                 addr[2]=srand()%255;
  66.         #endif
  67.        
  68.         return 3*8;                                     //地址码位数
  69. }

  71. /**********************************电平时间参数设置初始化（自定义部分）************************************/

  73. void Witty433_Init(unsigned int set_level_buf[8])     //这个set_level_buf[8]数组保存的是各个电平时间，单位是us
  74. {
  75.         SetStartLevelTime_433(set_level_buf[0],set_level_buf[1]);        //设置起始码 高 低 电平时间       
  76.         SetOneLevelTime_433(set_level_buf[2],set_level_buf[3]);                //设置bit1   高 低 电平时间
  77.         SetZeroLevelTime_433(set_level_buf[4],set_level_buf[5]);    //设置bit0   高 低 电平时间       
  78.         SetEndLevelTime_433(set_level_buf[6],set_level_buf[7]);                //设置结束码 高 低 电平时间
  79.        
  80.         addr_len = GetAddrFromChipID(addr);        //默认选择芯片ID的24Bit作为433地址码，用户可自行更改
  81.         SetAddr_433(addr,addr_len);
  82.        
  83.         delay_us_433 = delay_us;                        //设置433微秒延时函数（自定义部分）
  84.         delay_ms_433 = delay_ms;            //设置433毫秒延时函数（自定义部分）
  85.         witty433.delay_433 = delay_long_us;
  86. }




  91. /************************************* 433电平时间参数设置函数 ****************************************/

  93. /* 设置起始码电平时间 */
  94. void SetStartLevelTime_433(unsigned int time_H,unsigned int time_L)
  95. {
  96.         witty433.StartLevelTime_H = time_H;
  97.         witty433.StartLevelTime_L = time_L;
  98. }

  100. /* 设置结束码电平时间 */
  101. void SetEndLevelTime_433(unsigned int time_H,unsigned int time_L)
  102. {
  103.         witty433.EndLevelTime_H = time_H;
  104.         witty433.EndLevelTime_L = time_L;
  105. }

  107. /* 设置bit0电平时间 */
  108. void SetZeroLevelTime_433(unsigned int time_H,unsigned int time_L)
  109. {
  110.         witty433.ZeroLevelTime_H = time_H;
  111.         witty433.ZeroLevelTime_L = time_L;
  112. }

  114. /* 设置bit1电平时间 */
  115. void SetOneLevelTime_433(unsigned int time_H,unsigned int time_L)
  116. {
  117.         witty433.OneLevelTime_H = time_H;
  118.         witty433.OneLevelTime_L = time_L;
  119. }



  123. /******************************* 433发送参数设置函数 ****************************************/

  125. /* 设置地址码 */
  126. void SetAddr_433(unsigned char *addr,unsigned int addrBitNum)
  127. {
  128.         witty433.Addr = addr;
  129.         witty433.AddrBitNum = addrBitNum;
  130. }

  132. /* 设置数据域 */
  133. void SetSendData_433(unsigned char *sendData,unsigned int sendDataBitNum)
  134. {
  135.         witty433.SendData = sendData;
  136.         witty433.SendDataBitNum = sendDataBitNum;
  137. }

  139. /* 设置连续发送次数 */
  140. void SetSendNumber_433(unsigned char sendNumber)
  141. {
  142.         witty433.SendNumber = sendNumber;
  143. }




  148. /******************************* 发送初始化函数 ****************************************/

  150. /* 传入发送参数内容--数据域及发送次数 */
  151. void SendInput_433(unsigned char *data,unsigned int dataBitNum,unsigned char sendNum)
  152. {
  153.         SetSendNumber_433(sendNum);                                //设置sendNum连续发送次数,不同厂商的可能不一样，需要注意
  154.         SetSendData_433(data,dataBitNum);       //data数组是具体的控制数据,dataBitNum是数据的位数
  155. }

  157. /*******************************发送一次433信号***************************************/

  159. void StartSend_433()   //先传入发送参数，再发送
  160. {
  161.         int i = 0;
  162.        
  163.         for(i = 0; i < witty433.SendNumber; i++)
  164.         {
  165.                 SendStart_433();
  166.                 SendAddr();
  167.                 SendData();
  168.         }
  169.         SendEnd_433();
  170. }

  172. /************************************************************************************/





  178. /* 发送起始码 */
  179. void SendStart_433()
  180. {
  181.         Pin_433_H;
  182.         witty433.delay_433(witty433.StartLevelTime_H);
  183.        
  184.         Pin_433_L;
  185.         witty433.delay_433(witty433.StartLevelTime_L);
  186. }

  188. /* 发送地址码 */
  189. void SendAddr()
  190. {
  191.         unsigned char byteNum = witty433.AddrBitNum/8;
  192.         unsigned char bitNum = witty433.AddrBitNum%8;
  193.         unsigned char i = 0;
  194.        
  195.         for(i = 0; i < byteNum; i++)
  196.         {
  197.                 SendBit_433(witty433.Addr[i],8);
  198.         }
  199.        
  200.         SendBit_433(witty433.Addr[i],bitNum);
  201.        
  202. }

  204. /* 发送数据域 */
  205. void SendData()
  206. {
  207.         unsigned char byteNum = witty433.SendDataBitNum/8;
  208.         unsigned char bitNum = witty433.SendDataBitNum%8;
  209.         unsigned char i = 0;
  210.        
  211.         for(i = 0; i < byteNum; i++)
  212.         {
  213.                 SendBit_433(witty433.SendData[i],8);
  214.         }
  215.        
  216.         SendBit_433(witty433.SendData[i],bitNum);
  217.        
  218. }

  220. /* 发送结束码 */
  221. void SendEnd_433()
  222. {
  223.         Pin_433_H;
  224.         witty433.delay_433(witty433.EndLevelTime_H);
  225.        
  226.         Pin_433_L;
  227.         witty433.delay_433(witty433.EndLevelTime_L);
  228. }

  230. /* 发送bit0 */
  231. void SendBit0_433()
  232. {
  233.         Pin_433_H;
  234.         witty433.delay_433(witty433.ZeroLevelTime_H);
  235.        
  236.         Pin_433_L;
  237.         witty433.delay_433(witty433.ZeroLevelTime_L);
  238. }

  240. /* 发送bit1 */
  241. void SendBit1_433()
  242. {
  243.         Pin_433_H;
  244.         witty433.delay_433(witty433.OneLevelTime_H);
  245.        
  246.         Pin_433_L;
  247.         witty433.delay_433(witty433.OneLevelTime_L);
  248. }

  250. /* 发送16进制数据--1Byte */
  251. void SendHex_433(unsigned char byte)
  252. {
  253.         SendBit_433(byte,8);
  254. }

  256. /* 发送bit数据--待发送数据及待发送数据bit数0~8 */
  257. void SendBit_433(unsigned char byte,unsigned char bitNum)
  258. {
  259.         unsigned short data = (0x01<<bitNum)>>1;        //
  260.         unsigned char i = 0;
  261.         for(i = 0;i < bitNum;i++)
  262.         {
  263.                 if(byte & data)
  264.                 {
  265.                         SendBit1_433();
  266.                 }
  267.                 else
  268.                 {
  269.                         SendBit0_433();
  270.                 }
  271.                 data=data>>1;
  272.         }
  273. }

复制代码

程序不完整: deal433-master.zip (18.93 KB, 下载次数: 17)
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:277550 发表于 2023-10-25 13:20 | 只看该作者
直接当低速率的串口传输
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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