信号板拼包：数组方式（bug长度只是截短，并未清空，若之后拷贝数据长度小于之前数据长度，老数据会接在后面）

class SignalobardMsgReadHandler : public SessionVectChar::ReadHandler
{
public:
  SignalobardMsgReadHandler() = delete;

SignalobardMsgReadHandler(SignalobardMsgReadHandler _in v) = delete;

SignalobardMsgReadHandler(sNetPack * _in data_ptr, size_t _in package_size = sizeof(sNetPack) )
    : last_time_(bzrobot::Now())
    , data_ptr_(data_ptr)
    , package_size_one_(package_size)
    , package_check_sum_(0)
    , cache_buffer_size_(0)
    , cache_buffer_()
  {
  }

virtual ~SignalobardMsgReadHandler()
  {
  }

inline int GetPackHeadFirstIndex( char buffer[], int one_package_size, unsigned char package_head_value )
  {
      int continue_equal_times = 0;
      for ( int i = 0; i < one_package_size; ++i )
      {
          if ( (unsigned char)buffer[i] == package_head_value )
          {
              ++continue_equal_times;
              if ( continue_equal_times == PackageHeadByte_ )
              {
                  return (i-(PackageHeadByte_-1));
              }
          }
          else
          {
              continue_equal_times = 0;
          }
      }
      return -1;
  }

unsigned short CalculateCheckSum ( char buffer_[], int package_size )
  {
      unsigned short check_sum = 0;
      for ( int i = 0; i < package_size-2; ++i )
      {
          check_sum += (unsigned char)buffer_[i];
      }
      return check_sum;
  }

bzrobot::Duration _rt BlankTime() const
  {
    return bzrobot::Now() - last_time_;
  }

protected:
  bzrobot::Result _rt RunMain(typename SessionVectChar::ReadHandler::OutputType _ut output,
                              typename SessionVectChar::ReadHandler::InputType _in input,
                              typename SessionVectChar::ReadHandler::OptionType _in option) final
  {
    last_time_ = bzrobot::Now();
    if(!data_ptr_)
    {
      return BZROBOT_SIGNAL_BOARD_MSG_ERROR;
    }
    TO_2_BYTE WORDtemp;

const std::vector<char>& input_data = input;
    //存包，然后根据包长决定是否取包，多包时取用最新包
    memcpy ( &cache_buffer_[cache_buffer_size_], input_data.data(), input_data.size() );
    cache_buffer_size_ = cache_buffer_size_ + input_data.size();
    //只要缓存长度大于单个包长度，即循环进行取包，以防缓存数据堆积
    while ( cache_buffer_size_ >= package_size_one_ )
    {
        //获取数据包头在缓存中的位置
        int pack_head_index = GetPackHeadFirstIndex ( cache_buffer_, package_size_one_, PackageHeadValue_ );
        //未找到包头，丢弃该部分，返回等待新的接收数据
        if ( pack_head_index == -1 )
        {
            BZROBOT_WARNNING("SiganlBoardMsg: Not find pack head index");
            cache_buffer_size_ = cache_buffer_size_ - ( pack_head_index + package_size_one_ );
            return BZROBOT_SIGNAL_BOARD_MSG_ERROR;
        }
        //找到包头，且缓存长度足够取包
        if ( pack_head_index + package_size_one_ <= cache_buffer_size_ )
        {
            memcpy( WORDtemp.b, &cache_buffer_[pack_head_index + package_size_one_ - 2], 2 );
            //确认包校验和是否相等：相等取出数据，将取出的包段及其之前的部分丢弃
            if ( CalculateCheckSum( cache_buffer_, package_size_one_ ) == WORDtemp.data16 )
            {
                memcpy(data_ptr_, &cache_buffer_[pack_head_index], package_size_one_);
                cache_buffer_size_ = cache_buffer_size_ - ( pack_head_index + package_size_one_ );
            }
            //确认包校验和是否相等：不相等取出数据，将该包段及其之前的部分丢弃
            else
            {
                BZROBOT_WARNNING("SiganlBoardMsg: Check sum not equal");
                cache_buffer_size_ = cache_buffer_size_ - ( pack_head_index + package_size_one_ );
            }
        }
        //找到包头，但缓存长度不够取包，丢弃包头之前的部分
        else
        {
            BZROBOT_WARNNING("SiganlBoardMsg: Not whole package");
            cache_buffer_size_ = cache_buffer_size_ - pack_head_index;
        }
    }
    return BZROBOT_SIGNAL_BOARD_MSG_SUCCEED;
  }

sNetPack * data_ptr_;
  size_t              package_size_one_;
  size_t              cache_buffer_size_;
  const unsigned char PackageHeadValue_ = 0xA5;
  const int           PackageHeadByte_ = 4;
  const static int    CacheBufferMaxSize_ = 1024;
  char                cache_buffer_[CacheBufferMaxSize_];
  unsigned short      package_check_sum_;
  bzrobot::Time       last_time_;
};