text: #include <Arduino.h>
  #include <NeoHWSerial.h>
  
  #include "radioTaiChi.h"
  
  
  //静态变量
  HandleMessageFunction Radio::hm_func;
  NeoHWSerial* Radio::NeoSerialX = &RADIO_SERIAL_NUM;
  
  
  Radio::Radio()
  {
      EnableReceiveInterrupt();
  }
  
  
  //打开串口
  void Radio::BeginTransmit(unsigned long baud_rate)
  {
      NeoSerialX->begin(baud_rate);
  }
  
  
  //发送
  void Radio::Send(const char* message, uint8_t send_type, uint8_t send_times)
  {
      //强制发送，禁用接收中断，防止发送被打断
      if (send_type == FORCE_SEND)
          DisableReceiveInterrupt();
  
      static unsigned char send_code = '0';
  
      //生成完整通信包
      char full_message[FULL_MESSAGE_SIZE];
      uint8_t message_length = strlen(message);
      char check_str[CHECK_STR_LENGTH + 1];
  
      message_length = message_length < MAX_REAL_MESSAGE_SIZE ? message_length : MAX_REAL_MESSAGE_SIZE;
  
      itoa(message_length, check_str, 10);
  
      for (uint8_t i = 0, j = 0, k = 0; i < FULL_MESSAGE_SIZE; i++)
      {
          if (i < BLANK_CHAR_LENGTH)
          {
              full_message[i] = BLANK_CHAR;
          }
          else if (i == BLANK_CHAR_LENGTH)
          {
              full_message[i] = CODE_CHAR;
  
              full_message[++i] = send_code++;
  
              if (send_code > '9')
                  send_code = '0';
  
              full_message[++i] = START_CHAR;
          }
          else if (j < message_length && j < MAX_REAL_MESSAGE_SIZE)
          {
              full_message[i] = message[j];
              j++;
          }
          else if (j == message_length || j == MAX_REAL_MESSAGE_SIZE)
          {
              full_message[i] = CHECK_CHAR;
              j++;
          }
          else if (k < CHECK_STR_LENGTH)
          {
              full_message[i] = check_str[k];
              k++;
              
              if (check_str[k] == '\0')
                  k = CHECK_STR_LENGTH;
          }
          else
          {
              full_message[i] = END_CHAR;
          }
      }
  
      //发送完整通信包
      for (uint8_t times = 0; times < send_times; times++)
      {
          NeoSerialX->print(full_message);
      }
  
      #ifdef RADIO_DEBUG
      NeoSerialDebug.print(F("#RADIO:  SEND: "));
      full_message[FULL_MESSAGE_SIZE - 1] = '\0';
      NeoSerialDebug.print(full_message);
      NeoSerialDebug.print(F(" TIMES: "));
      NeoSerialDebug.println(send_times);
      #endif
  
      if (send_type == FORCE_SEND)
          EnableReceiveInterrupt();
  }
  
  
  //设置接收回调函数
  void Radio::SetHandleMessageFunction(HandleMessageFunction hm_func)
  {
      Radio::hm_func = hm_func;
  }
  
  
  //禁用接收中断
  void Radio::DisableReceiveInterrupt() //禁用接收中断
  {
      NeoSerialX->detachInterrupt();
  }
  
  
  //恢复接收中断
  void Radio::EnableReceiveInterrupt() //恢复接收中断
  {
      NeoSerialX->attachInterrupt(Receive);
  }
  
  
  //接收，使用中断触发
  bool Radio::Receive(uint8_t ch, uint8_t status)
  {
      static bool is_code_record = false;
      static bool is_start_record = false;
      static bool is_check_record = false;
      static char message[FULL_MESSAGE_SIZE] = "";
      static char check_str[CHECK_STR_LENGTH + 1] = "";
      static unsigned char this_package_code = 0;
      static unsigned char last_package_code = 0;
      static uint8_t i = 0, j = 0;
  
      switch (ch)
      {
      case CODE_CHAR:
      {
          is_code_record = true;
          is_start_record = false;
          is_check_record = false;
          
          //重置字符串
          for (uint8_t k = 0; k < i; k++)
              message[k] = '\0';
          for (uint8_t k = 0; k < j; k++)
              check_str[k] = '\0';
  
          i = 0;
          j = 0;
      } break;
  
      case START_CHAR:
      {
          if (is_code_record == true)
          {
              is_code_record = false;
              is_start_record = true;
          }
      } break;
  
      case CHECK_CHAR:
      {
          if (is_start_record == true)
          {
              is_start_record = false;
              is_check_record = true;
          }
      } break;
  
      case END_CHAR:
      {
          if (is_check_record == true)
          {
              is_check_record = false;
  
              if (j <= CHECK_STR_LENGTH)
                  check_str[j] = '\0';
  
              if (atoi(check_str) == strlen(message)) //位数校验成功
              {   
                  if (this_package_code != last_package_code)
                  {
                      #ifdef RADIO_DEBUG
                      NeoSerialDebug.print(F("#RADIO:  RECEIVE: "));
                      NeoSerialDebug.println(message);
                      #endif
                      
                      hm_func(message);
  
                      last_package_code = this_package_code;
                  }
              }
              else //位数校验失败
              {                
                  #ifdef RADIO_DEBUG
                  NeoSerialDebug.println(F("#RADIO:  RECEIVE CHECK FAIL!"));
                  #endif
              }
          }
      } break;
  
      default:
      {
          if (is_code_record == true)
          {            
              this_package_code = ch;
          }
          else if (is_start_record == true)
          {
              if (i < FULL_MESSAGE_SIZE)
                  message[i] = ch;
              i++;
          }
          else if (is_check_record == true)
          {
              if (j <= CHECK_STR_LENGTH)
                  check_str[j] = ch;
              j++;
          }
      }
      }
  
      return false;
  }