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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 基于机智云的一主机多从机的程序结构设计
返回列表 发新帖
查看: 810|回复: 0
打印 上一主题 下一主题
收起左侧

基于机智云的一主机多从机的程序结构设计

[复制链接]
跳转到指定楼层
楼主
ID:334435 发表于 2022-10-3 19:39 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
之前在学习做的设计里面使用了一主机多从机的结构设计。

  1. #include "main.h"
  2. uint8_t UIflag=0;
  3. uint8_t UIflag2=0;
  4. //对机智云设备进行初始化
  5. void GizWitsInit(void )  
  6. {
  7.   BASIC_TIM_Init();  //利用定时器给设备提供一个1MS的精确时钟
  8.   TIM_RCC_APB1PeriphClockCmd(TIM_RCC_APB1Periph_TIMX,ENABLE); //开定时器时钟
  9.   esp_usartx_init(); // wifi初始化 波特率必须为9600    //WIFI串口初始化 波特率9600
  10.   userInit();       //设备状态结构体初始化,用来跟ESP8266进行接收发送的通信
  11.   memset((uint8_t*)¤tDataPoint, 0, sizeof(dataPoint_t));  //初始化内存
  12.   gizwitsInit();    //缓冲区初始化        
  13. //        //初始化RTC时钟
  14. //        RTC_NVIC_Config();  // 配置RTC秒中断优先级
  15. //        RTC_CheckAndConfig(&systmtime);
  16. }
  17. /*
  18.   主板使用的模块功能进行初始化（不包括机智云要使用的设备）
  19. */
  20. void Hardware_Init(void )
  21. {
  22.   DHT11_Init();         //温湿度传感器初始化
  23.         Init_BH1750();        //光照传感器初始化
  24.         ADCx_Init();          //ADC采样初始化，进行烟雾的AD数值采样
  25.         LED_GPIO_Config();    //LED灯初始化
  26.         USART_Config();       //串口通信初始化
  27.         GOIO_PWM_MONE_Init();  //利用PWM控制舵机以及风扇转速
  28.   JLX12864G_086_GPIOInit();
  29.         initial_lcd();
  30.         clear_screen();
  31.         //TimeInit();
  32.   StepperMotor4_2();     //步进电机初始化  
  33. }


  36. /**
  37.   * @brief  主函数
  38.   * @param  无  
  39.   * @retval 无
  40.   */
  41. int main ( void )
  42. {
  43.         volatile int  key=0;
  44. //        char YearDate[100];
  45.         volatile int ty=0;
  46.         volatile int xz=0;   
  47.         UInum=1;
  48.         protocolTime_t *ptime=(protocolTime_t *)(uint8_t *)&gizwitsProtocol.TimeNTP;  //获取网络时间结构体
  49.         Hardware_Init();//对板卡硬件初始化
  50.         GizWitsInit();   //对云协议进行初始化
  51.   IWDG_Config(IWDG_Prescaler_256 ,10000);  
  52.         while ( 1 )
  53.         {        
  54.                 TIM_Cmd(TIM3, ENABLE);
  55.                 gizwitsnetwork();  //按键配网
  56.                 user_bh1750();     //开启BH1750工作，并获取数据
  57.                 userHandle();      //用户采集
  58.                 gizwitsHandle((dataPoint_t *)¤tDataPoint);//协议处理
  59. //          Manual_mode();
  60.                 Main_function();   
  61.                 ClockCalculate();
  62.                

  64. /***解析语音模块的串口数据***/               
  65.         if (usartdataflag==1)
  66.         {
  67.                 Uart5ReceiveEndDetection();
  68.                 usartdataflag=0;
  69.           DisposeUart5ReceiveData(); //数据解析
  70.         }
  71. /***解析台灯模块的串口数据***/                        
  72.         if(usart4dataflag==1)
  73.         {
  74.           Uart4ReceiveEndDetection();
  75.                 usart4dataflag=0;
  76.           DisposeUart4ReceiveData(); //数据解析
  77.         }
  78.                
  79.                 if (UInum==1) //自动模式
  80.                 {
  81.                   Automatic_mode();
  82.                 }

  84.                 if(timer>=100)  
  85.                 {
  86.                         timer=0;
  87.                   Displayinterface();
  88.                 }        

  90. /******************************RTC时钟*****************************/        
  91.          /* 每过1s 更新一次时间*/
  92.                 if (TimeDisplay == 1)
  93.                 {
  94.                         /* 当前时间 */
  95.                         Time_Display( RTC_GetCounter(),&systmtime);         
  96.      // Timedistributionfunction(&systmtime);                        
  97.                         TimeDisplay = 0;
  98.                         ty++;
  99.                   doortime++;
  100.                         worktime++;        
  101.                         if(ty==120)  //120秒，两分钟
  102.                         {
  103.                                 xz=1; //时间校准标志位
  104.                                 ty=0;
  105.                         }
  106.                 }        
  107. /*************从机时间校准***************/        
  108.                

  110. /******************运行保护**************************/                                
  111.     if (dooropen==1)  //门锁保护
  112.      {
  113.                         if (doortime==1)
  114.                                 {
  115.                                         dooropen=0;
  116.                                         GPIO_ResetBits(room_GPIO_PORT,room_GPIO_PIN);
  117.                                 }        
  118.                  }
  119.                  
  120.                 if ((closeflag1==1)&&(worktime>=1))  //窗帘保护
  121.                  {        
  122.                          closeflag1=0;
  123.                          closeflag=1;                                         
  124. //                         GPIO_SetBits(GPIOE,GPIO_Pin_4);
  125.                          TIM_Cmd(TIM2, DISABLE);
  126.                  }                 
  127.                 if((openflag1==1)&&(worktime>=1))
  128.                  {        
  129.                          openflag1=0;
  130.                          openflag=1;
  131. //                         GPIO_SetBits(GPIOE,GPIO_Pin_4);
  132.                          TIM_Cmd(TIM2, DISABLE);
  133.                  }        
  134. //                   sprintf (information3,"%d  %d  ",closeflag1,worktime);
  135. //             display_string_5x8_1(7,5,information3);
  136.                  
  137. /*******************************************************/
  138.                 if(wifi_link==1)
  139.                 {
  140.                         if (usartoneflag==0)  //网络链接成功下发一次时间同步     
  141.                         {
  142.                           usartoneflag=1;
  143.                                 Timedistributionfunction(); //下发给从机校准时间
  144.                         }
  145.                   if (alinghourflag2==1)
  146.                   {
  147.                         alinghourflag2=0;
  148.                   Timedistributionfunction(); //下发给从机校准时间
  149.                   }

  151.                         
  152.                         key=KEY_Scan(1);
  153.                         if( key == 16 )  //网络时间同步按键
  154.                         {
  155. //                         /*用接收到的时间设置RTC*/
  156. //                          Time_Adjust(&networktime);
  157. //                        //向备份寄存器写入标志
  158. //                          BKP_WriteBackupRegister(RTCC_BKP_DRX, RTc_BKP_DATA);
  159.                                 Timedistributionfunction(); //下发给从机校准时间
  160.                         }
  161. //                        else if( xz==1)  //网络时间校准
  162. //                        {
  163. //                         /*用接收到的时间设置RTC*/
  164. //                          Time_Adjust(&networktime);
  165. //                        //向备份寄存器写入标志
  166. //                          BKP_WriteBackupRegister(RTCC_BKP_DRX, RTc_BKP_DATA);
  167. //                                xz=0; //时间校准标志位清零
  168. //                                Timedistributionfunction(); //下发给从机校准时间
  169. //                        }                        
  170.    }
  171.                 IWDG_Feed();  //喂狗防止复位
  172. }
  173. }

  175. /************************************************
  176. 显示屏显示UI界面控制函数
  177. *************************************************/
  178. void Displayinterface(void)
  179. {
  180. if (UInum==1) //默认
  181. {
  182.         if(Manualflagbit2==0)
  183.         {        
  184.    if (UI1flag1==0)
  185.          {
  186.     UI1flag1=1;
  187.                 UI1flag2=0;
  188.                 UI2flag1=0;
  189.                 UI2flag2=0;
  190.                 clear_screen();
  191.           Manualflagbit=0;
  192.          }               
  193.    display_string_5x8_1(1,0,information1);
  194.    display_string_5x8_1(3,0,information3);
  195.    display_string_5x8_1(5,0,information4);        
  196.          display_string_5x8_1(7,0,information2);         
  197.    display_string_5x8_1(8,5,"M：A");        
  198.         }
  199.          else
  200.          {
  201.     if (UI1flag2==0)
  202.           {
  203.      UI1flag2=1;
  204.                  UI1flag1=0;
  205.                  UI2flag1=0;
  206.                  UI2flag2=0;
  207.                  clear_screen();
  208.            Manualflagbit=0;
  209.           }               
  210.                 display_string_5x8_1(1,0,information1);
  211.     display_string_5x8_1(3,0,UIBUFF1);
  212.     display_string_5x8_1(5,0,UIBUFF2);
  213.     display_string_5x8_1(7,0,UIBUFF3);         
  214. //  display_string_5x8_1(8,0,"                          ");        
  215.          }
  216. }

  218. if (UInum==2)  //手动档界面
  219. {
  220.          if(Manualflagbit==0)
  221.          {
  222.                 if (UI2flag1==0)  
  223.          {
  224.     UI1flag1=0;
  225.                 UI1flag2=0;
  226.                 UI2flag2=0;
  227.                 UI2flag1=1;
  228.                 clear_screen();
  229.           Manualflagbit2=0;
  230.          }               
  231.    display_string_5x8_1(1,0,information1);
  232.    display_string_5x8_1(3,0,information3);
  233.    display_string_5x8_1(5,0,information4);        
  234.          display_string_5x8_1(7,0,information2);         
  235.    display_string_5x8_1(8,5,"M：H");
  236.          }
  237.          else
  238.          {
  239.                  if (UI2flag2==0)
  240.           {
  241.      UI1flag1=0;
  242.                  UI1flag2=0;
  243.                  UI2flag2=1;
  244.                  UI2flag1=0;
  245.            clear_screen();
  246.                  Manualflagbit2=0; //清除自动设置
  247.          }
  248.          display_string_5x8_1(1,2,"Manual control mode");
  249.          sprintf (information6,"valueLED2:%d      ",currentDataPoint.valueLED2);
  250.          display_string_5x8_1(2,2,information6);
  251.          sprintf (information7,"valuefan:%d      ",currentDataPoint.valuefan);
  252.          display_string_5x8_1(3,2,information7);
  253.          sprintf (information7,"valueventilator:%d  ",currentDataPoint.valueventilator);
  254.          display_string_5x8_1(4,2,information7);
  255.          sprintf (information7,"valuewidow:%d      ",currentDataPoint.valuewidow);
  256.          display_string_5x8_1(5,2,information7);
  257.          sprintf (information7,"valuedoor:%d      ",currentDataPoint.valuedoor);
  258.          display_string_5x8_1(6,2,information7);
  259.          sprintf (information5,"valueLED1:%d     ",currentDataPoint.valueLED1);
  260.          display_string_5x8_1(7,2,information5);
  261.          }
  262. }
  263. if (UInum==3)  
  264. {
  265.   clear_screen();
  266.         UIflag=0;
  267.         UIflag2=0;
  268. }
  269. }

  271. /************************************************
  272. 对模块进行配网
  273. KEY1按下为：  WIFI复位
  274. *************************************************/
  275. void gizwitsnetwork(void )
  276. {
  277.           volatile int network_key=0;        
  278.                 network_key=KEY_Scan(1);   
  279.         
  280.                 if(network_key==1)//KEY1按键
  281.                 {
  282. //                        printf("WIFI进入AirLink连接模式\r\n");
  283.                         gizwitsSetMode(WIFI_AIRLINK_MODE);//Air-link模式接入
  284.                 }
  285. }


  288. /**
  289.   * @brief  用户获取光照强度数据接口
  290.   * @param  无
  291.   * @retval result_lx 光照强度
  292.   */
  293. void user_bh1750(void)
  294. {
  295.           float  light=0;  //光强度缓存区
  296.                 //获取光照
  297.     Start_BH1750();
  298.     delay_ms(180);
  299.     Read_BH1750();
  300.     light=Convert_BH1750();
  301.     //delay_ms(1000);
  302.          // printf("light:%f\n",light);
  303. }



  307. /*USART4数据帧超时检测*/
  308. void Uart4ReceiveEndDetection(void)                                                     //数据帧结束检测
  309. {                                                                                               //每一毫秒执行一次
  310.     if(Uart4ReceiveTimeout > 0)
  311.     {
  312.         Uart4ReceiveTimeout--;
  313.         if((Uart4ReceiveTimeout >= 0) && (usart4_rcvd_len > 4))                                    //判断通讯接收是否超时
  314.         {        
  315.             // Uart3ReceiveDataLength = 0;                                                   //将接收地址偏移寄存器清零
  316.             usart4_rcvd_flag = 1;
  317.         }
  318.     }  
  319. }

  321. void DisposeUart4ReceiveData(void)
  322. {
  323. //        uint8_t i;
  324.         uint8_t i=0,j=0,len;
  325.         char* pData1 = 0;
  326.         unsigned int usart4_data_hex[50];
  327.         if(usart4_rcvd_flag == 1)   
  328.          {
  329.                 //printf ("1\r\n");        
  330.                 /*对串口接收到的数据进行解析提前处理*/
  331.                 len=15;
  332.                 pData1 = strstr((const char*)usart4_rcvd_buf,"55AA01");
  333.                 for(i=0;i<=len;i++)
  334.                  {
  335.                         usart4_data_hex[i]=str2hex(pData1 + j, 2);                        //从条码开始接收解析
  336.                         j+=2;
  337.                  }                                 
  338.                         if(usart4_data_hex[2] == 0x01)  //地址码
  339.                         {                                       
  340.                
  341.                                 if(usart4_data_hex[3] == 0x01)  //功能码
  342.                                 {
  343.                                         switch(usart4_data_hex[4])          //        分类码
  344.                                         {                                         
  345.                                           case 0x02:  //台灯
  346.                                                 if(usart4_data_hex[6]==65535) break;
  347.                                                 else
  348.                                                 {
  349.                                                  currentDataPoint.valueLED2=usart4_data_hex[6];
  350.                                                  printf("台灯：%d\r\n",currentDataPoint.valueLED2);        
  351.                                                         break;        
  352.                                                 }
  353.                                                 default :break;
  354.                                         }
  355.                                 }
  356.                                 if(usart4_data_hex[3] == 0x02)  //功能码  查询时间
  357.                                         {
  358.                                           switch(usart4_data_hex[4])          //        分类码
  359.                                                 {
  360.                                                         case 0x01:Timedistributionfunction();break;
  361.                                                         default :break;
  362.                                                 }
  363.                                         }
  364.                         }
  365.                 memset(usart5_rcvd_buf, 0, sizeof(usart5_rcvd_buf));
  366.         usart5_rcvd_len = 0;                                                                   //将接收地址偏移寄存器清零               
  367.                 usart4_rcvd_flag = 0;
  368.         }
  369. }






  376. /*处理蓝牙音响和核心板直接的数据处理*/
  377. /*数据帧超时检测*/
  378. void Uart5ReceiveEndDetection(void)                                                     //数据帧结束检测
  379. {                                                                                               //每一毫秒执行一次
  380.     if(Uart5ReceiveTimeout > 0)
  381.     {
  382.         Uart5ReceiveTimeout--;
  383.         if((Uart5ReceiveTimeout >= 0) && (usart5_rcvd_len > 4))                                    //判断通讯接收是否超时
  384.         {        
  385.             // Uart3ReceiveDataLength = 0;                                                   //将接收地址偏移寄存器清零
  386.             usart5_rcvd_flag = 1;
  387.         }
  388.     }
  389.         //        printf ("U:%d,UL%d",Uart5ReceiveTimeout,usart5_rcvd_len);   
  390. }



  394. void DisposeUart5ReceiveData(void)
  395. {
  396. //        uint8_t i;
  397.         uint8_t i=0,j=0,len;
  398.         char* pData1 = 0;
  399.         unsigned int usart5_data_hex[50];
  400.         if(usart5_rcvd_flag == 1)   
  401.          {
  402.                 //printf ("1\r\n");        
  403.                 /*对串口接收到的数据进行解析提前处理*/
  404.                 len=15;
  405.                 pData1 = strstr((const char*)usart5_rcvd_buf,"55AA01");
  406.                 for(i=0;i<=len;i++)
  407.                  {
  408.                         usart5_data_hex[i]=str2hex(pData1 + j, 2);                        //从条码开始接收解析
  409.                         j+=2;
  410.                         //printf ("DATA:%d",usart5_data_hex[i]);
  411.                  }               
  412. //         if(usart4_data_hex[usart4_data_hex[5] + 6] == BCC_CheckSum(&usart4_rcvd_buf[2], (length + 4)))
  413. //                {               
  414.                  /*对接收的数据进行判断处理  55AA0101***DB */
  415.     //  printf ("2\r\n");                        
  416.                         if(usart5_data_hex[2] == 0x01)  //地址码
  417.                         {                                       
  418.        // printf ("3\r\n");                                
  419.                                 if(usart5_data_hex[3] == 0x01)  //功能码
  420.                                 {
  421.                                 //        printf ("4\r\n");
  422.                                         switch(usart5_data_hex[4])          //        分类码
  423.                                         {                                         
  424.                                                 case 0x01:  //灯光
  425.                                                                  currentDataPoint.valueLED1=usart5_data_hex[6];
  426.                                                      printf("灯光：%d\r\n",currentDataPoint.valueLED1);
  427.                                                    break;        
  428.                                           case 0x02:  //台灯
  429.                                                            currentDataPoint.valueLED2=usart5_data_hex[6];
  430.                                                      if (currentDataPoint.valueLED2==1)
  431.                                                                  {
  432.                                                       Usart_SendString(DEBUG_USART4,"55AA020102090100DB0D\r\n"); //开台灯
  433.                                                                  }
  434.                                                                  else
  435.                  {
  436.                                                                   Usart_SendString(DEBUG_USART4,"55AA020102090000DB0D\r\n");//关台灯
  437.                                                                  }
  438.                                                                         
  439.                                                      printf("台灯：%d\r\n",currentDataPoint.valueLED2);        
  440.                                                    break;        
  441.                                                 case 0x03:  //风扇
  442.                                                          currentDataPoint.valuefan=usart5_data_hex[6];
  443.                                                    printf("风扇：%d\r\n",currentDataPoint.valuefan);
  444.                                                    break;        
  445.                                                 case 0x05:  //窗帘
  446.                                                          currentDataPoint.valuewidow=usart5_data_hex[6];
  447.                                                     printf("窗帘：%d\r\n",currentDataPoint.valuewidow);

  449.                                                    break;        
  450.                                                 case 0x06:  //排烟机
  451.                                                          currentDataPoint.valueventilator=usart5_data_hex[6];
  452.                                                    printf("排烟机：%d\r\n", currentDataPoint.valueventilator);
  453.                                                    break;        
  454.                                                 default :break;
  455.                                         }
  456.                                 }

  458.                         }
  459.                 memset(usart5_rcvd_buf, 0, sizeof(usart5_rcvd_buf));
  460.         usart5_rcvd_len = 0;                                                                   //将接收地址偏移寄存器清零               
  461.                 usart5_rcvd_flag = 0;
  462.         }
  463. }


  466. unsigned int str2hex(char * start,char length)                                                               //字符串起始地址， length 字符长度
  467. {         
  468.         char i = 0;
  469.         unsigned char res_tem= 0x00;
  470.         unsigned int res = 0x0000;
  471.         res_tem = 0;
  472.         res = 0;

  474.     for(i = 0; i < length; i++)        
  475.         {
  476.                 if((*(start+i)>='0')&&(*(start+i)<='9'))
  477.                 {
  478.                         res_tem = *(start+i)-'0';
  479.                         res = res+res_tem*pow(16,length-i-1);                                
  480.                 }
  481.                 else if((*(start+i)>='A')&&(*(start+i)<='F'))                                                    //约定只用大写
  482.                 {
  483.                         res_tem = *(start+i)-'A'+10;
  484.                         res = res+res_tem*pow(16,length-i-1);
  485.                 }
  486.                 else
  487.                 {                                 
  488.                         res = 0xFFFF;                                                                          //错误数值就返回默认值
  489.                         break;                                 
  490.                 }
  491.         }
  492.         
  493.         return res & 0xFFFF;
  494. }

  496. /*将字符串s转换成相应的整数*/  
  497. // int atoi(char s[])  
  498. // {  
  499. //     int i;  
  500. //     int n = 0;  
  501. //     for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)  
  502. //     {  
  503. //         n = 10 * n + (s[i] - '0');  
  504. //     }  
  505. //     return n;  
  506. // }  

  508. unsigned int str2dec(char * start,char length)                                                               //字符转10进制, 字符串其实地址， length 字符长度
  509. {        
  510.         char i = 0;
  511.         unsigned char res_tem= 0x00;
  512.         unsigned int res = 0x0000;
  513.         res_tem = 0;
  514.         res = 0;

  516.         for(i = 0;i<length;i++)        
  517.         {
  518.                 if((*(start+i)>='0')&&(*(start+i)<='9'))
  519.                 {
  520.                         res_tem = *(start+i)-'0';
  521.                         res = res+res_tem*pow(10,length-i-1);
  522.                 }
  523.                 else
  524.                 {                                
  525.                         res = 0xFFFF;                                                                          //错误数值就返回默认值
  526.                         break;                                
  527.                 }
  528.         }
  529.         return res & 0xFFFF;
  530. }

  532. /* 将无符号十进制数拆分并转换为字符形式，返回字符串长度 */
  533. char uBinaryToAscii(unsigned int value, char *str)
  534. {
  535.     char i;
  536.     char num_str[10] = { 0 };
  537.     unsigned int quotient;
  538.     unsigned char len;

  540.     len = 0;

  542.     quotient = value / 10;
  543.     while (quotient != 0)
  544.     {
  545.         num_str[len] = value % 10 + '0';
  546.         len++;
  547.         value = quotient;
  548.         quotient = value / 10;
  549.     }

  551.     if (value != 0)
  552.     {
  553.         num_str[len] = value + '0';
  554.         len++;
  555.     }

  557.     for (i = 0; i < len; i++)
  558.     {
  559.         *str = num_str[len-i-1];
  560.         str++;
  561.     }

  563.     return len;
  564. }

  566. /* 将有符号十进制数拆分并转换为字符形式，返回字符串长度 */
  567. /* 调用了uBinaryToAscii函数 */
  568. char sBinaryToAscii(int value, char *str)
  569. {
  570.     char len;

  572.     if (value < 0)
  573.     {
  574.         *str = '-';
  575.         str++;
  576.         len = uBinaryToAscii(-value, str);
  577.         return len + 1;
  578.     }
  579.     else
  580.     {
  581.         len = uBinaryToAscii(value, str);
  582.         return len;
  583.     }
  584. }
  585. void Timedistributionfunction(void )  //用于接收网络时间
  586. {
  587.                  //时间
  588.                 if (networktime.tm_mon<10) networktime.tm_mon=networktime.tm_mon+60;
  589.           if (networktime.tm_mday<10) networktime.tm_mday=networktime.tm_mday+60;
  590.                 if (networktime.tm_hour<10) networktime.tm_hour=networktime.tm_hour+60;
  591.           if (networktime.tm_min<10) networktime.tm_min=networktime.tm_min+60;
  592.                  sBinaryToAscii(networktime.tm_year,timedata); //年
  593.                  sBinaryToAscii(networktime.tm_mon,timedata+4); //月
  594.                  sBinaryToAscii(networktime.tm_mday,timedata+6);  //日
  595.                  sBinaryToAscii(networktime.tm_hour,timedata+8); //时
  596.                  sBinaryToAscii(networktime.tm_min,timedata+10);  //分
  597.                  //sBinaryToAscii(networktime.tm_sec,timedata+7);  //秒
  598.                  sprintf(Timedatabuff,"%s%c%c%c%c%c%c%c%c%c%c%c%c%s\r\n",Timedata,timedata[0],timedata[1],timedata[2],timedata[3],timedata[4],timedata[5],timedata[6],\
  599.                                                      timedata[7],timedata[8],timedata[9],timedata[10],timedata[11],enddatabuff);     
  600.                 // printf("%s\r\n",Timedatabuff);        
  601.           Usart_SendString(DEBUG_USART4,Timedatabuff);
  602. }



  606. /*-------------------------------------------------------
  607. 内部通讯协议的CRC16计算函数。
  608. -------------------------------------------------------*/
  609. uint32_t  ecbm_databuff_rtu_crc=0xFFFF;                    //初始化CRC变量各位为1。
  610. void ecbm_databuff_rtu_crc16(uint8_t buf)
  611. {
  612.         uint8_t j;
  613.         ecbm_databuff_rtu_crc^=buf;                                   //当前数据异或CRC低字节，在C51里可以直接处理。
  614.         for(j=0;j<8;j++)
  615.                 {                                           //计算每个字节的每一位。
  616.                         if(ecbm_databuff_rtu_crc&0x01)
  617.                                 {                           //判断右移前最低位是否为1。
  618.                                         ecbm_databuff_rtu_crc=(ecbm_databuff_rtu_crc>>1)^0xA001;//如果为1则右移并异或表达式。
  619.                                 }
  620.                                 else
  621.                                 {
  622.                                  ecbm_databuff_rtu_crc>>=1;                            //否则直接右移一位。
  623.                                 }           
  624.          }
  625. }
复制代码


本人初学,仅供参考,存在错误和不足之处,请大家回帖多多指教,切勿照搬,代码下载:
代码.7z (554.77 KB, 下载次数: 10)

评分

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

查看全部评分

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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