|
|
@@ -13,580 +13,580 @@
|
|
|
|
|
|
namespace Protocol
|
|
|
{
|
|
|
- USBPacket::USBPacket() : PacketTitle(), pid_(0), last_nrbz_data_bit_(false), polarity_(false), end_point_(0),
|
|
|
- crc_sign_num_(0),
|
|
|
- crc16_(0), is_valid_(false),
|
|
|
- is_crc_checked_(false),
|
|
|
- to_extracted_next_data_start_index_(-1),
|
|
|
- to_nrzi_decode_next_data_start_index_(-1),
|
|
|
- max_possible_data_length_(-1)
|
|
|
-
|
|
|
-
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- USBPacket::USBPacket(TwoLevelEdgePulse* pid_node, int32_t& left_over_size, const SYNC& sync
|
|
|
- , bool polarity, int32_t max_data_length)
|
|
|
- {
|
|
|
- this->polarity_ = polarity;
|
|
|
- packet_sync_ = sync;
|
|
|
- if (max_data_length >= 0)
|
|
|
- {
|
|
|
- max_possible_data_length_ = max_data_length;
|
|
|
- }
|
|
|
-
|
|
|
- //this->pidType = nullptr;
|
|
|
- TwoLevelEdgePulse* tmp_pid_node = pid_node;
|
|
|
- /*if (tmp_pid_node->startIndex < sync.endIndex && tmp_pid_node->startIndex < sync.nodePtr->startIndex + sync.Length())
|
|
|
- {
|
|
|
- while (tmp_pid_node->startIndex < sync.endIndex && tmp_pid_node->startIndex < sync.nodePtr->startIndex + sync.Length())
|
|
|
- {
|
|
|
- tmp_pid_node += 1;
|
|
|
- }
|
|
|
- tmp_pid_node -= 2;
|
|
|
- }*/
|
|
|
-
|
|
|
- if (!GetPID(tmp_pid_node))
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- is_valid_ = true;
|
|
|
-
|
|
|
- if (this->packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
- //解码域内容
|
|
|
- DecodeFields(tmp_pid_node);
|
|
|
- }
|
|
|
-
|
|
|
- bool USBPacket::CheckNibblesInverse(uint8_t value)
|
|
|
- {
|
|
|
- const uint8_t high_nibble = static_cast<uint8_t>(value >> 4);
|
|
|
- const uint8_t low_nibble = static_cast<uint8_t>(value & 0x0F);
|
|
|
- return high_nibble == (~low_nibble & 0x0F);
|
|
|
- }
|
|
|
-
|
|
|
- bool USBPacket::GetPID(TwoLevelEdgePulse*& pid_node)
|
|
|
- {
|
|
|
- if (!CheckNodeValid(static_cast<EdgePulse>(*pid_node)))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "node check fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (packet_sync_.singleBitTimingLength <= 0)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
- last_nrbz_data_bit_ = false;
|
|
|
- uint8_t data;
|
|
|
- int32_t pid_start_index = packet_sync_.endIndex + 2;
|
|
|
-
|
|
|
- if (!DecodeNextByte(pid_node, pid_start_index, data))
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- pid_ = data;
|
|
|
- auto handshake_type = USBEnums::HandshakePackageType::NAK;
|
|
|
- if (IsTokenPackageType())
|
|
|
- {
|
|
|
- packet_type_ = USBEnums::USBPacketType::TOKEN;
|
|
|
- }
|
|
|
- else if (IsDataPackageType())
|
|
|
- {
|
|
|
- packet_type_ = USBEnums::USBPacketType::DATA;
|
|
|
- }
|
|
|
- else if (IsHandshakePackageType(handshake_type))
|
|
|
- {
|
|
|
- packet_type_ = USBEnums::USBPacketType::HAND_SHAKE;
|
|
|
- switch (handshake_type)
|
|
|
- {
|
|
|
- case USBEnums::HandshakePackageType::ACK:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::ACK;
|
|
|
- break;
|
|
|
- case USBEnums::HandshakePackageType::NAK:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::NAK;
|
|
|
- break;
|
|
|
- case USBEnums::HandshakePackageType::STALL:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::STALL;
|
|
|
- break;
|
|
|
- case USBEnums::HandshakePackageType::NYET:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::NYET;
|
|
|
- break;
|
|
|
- default: // NOLINT(clang-diagnostic-covered-switch-default)
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- else if (IsSpecialPacketType())
|
|
|
- {
|
|
|
- packet_type_ = USBEnums::USBPacketType::SPECIAL;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- bool USBPacket::GetNRZIData(TwoLevelEdgePulse*& node, int32_t need_bit_count, int32_t start_index,
|
|
|
- std::vector<bool>& out_data)
|
|
|
- {
|
|
|
- if (!CheckNodeValid(node))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "node check fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- const int32_t get_data_start_index = start_index;
|
|
|
- //const int32_t get_data_start_index = node->StartIndex;
|
|
|
- const bool high_polarity_edge = packet_sync_.nodePtr->edge == Edge::Falling;
|
|
|
- const double single_bit_timing_length_threshold = packet_sync_.singleBitTimingLength * USB_SYNC_BIT_TOL;
|
|
|
- out_data = {};
|
|
|
- //nrzi 补位个数
|
|
|
- const int32_t pre_complement_number = need_bit_count / USB_NRZI_COMPLEMENT_PER_NUM;
|
|
|
- const int32_t pre_complement_need_bit_count = need_bit_count + pre_complement_number;
|
|
|
- std::vector<bool> nrzi_data(pre_complement_need_bit_count, false);
|
|
|
- int32_t getbit_count = 0;
|
|
|
- bool get_last_nrzi_bit_polarity = false;
|
|
|
- while (getbit_count < pre_complement_need_bit_count)
|
|
|
- {
|
|
|
- if (!CheckNodeValid(node))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "GetNRZIData node check fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (node->endIndex < start_index)
|
|
|
- {
|
|
|
- node++;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- ////fix
|
|
|
- if (node->endIndex - start_index < packet_sync_.singleBitTimingLength / 2)
|
|
|
- {
|
|
|
- node++;
|
|
|
- if (!CheckNodeValid(node))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "GetNRZIData node check fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!get_last_nrzi_bit_polarity && CheckNodeValid(node - 1))
|
|
|
- {
|
|
|
- if (start_index - node->startIndex > single_bit_timing_length_threshold)
|
|
|
- {
|
|
|
- last_nrbz_data_bit_ = node->CurrentLevel == TwoLevelEdgePulseStatusType::High;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- //不用改
|
|
|
- //last_NRBZ_data_bit = (node - 1)->CurrentLevel == TwoLevelEdgePulseStatusType::High;
|
|
|
- }
|
|
|
-
|
|
|
- get_last_nrzi_bit_polarity = true;
|
|
|
- }
|
|
|
- if (node->endIndex - start_index >= single_bit_timing_length_threshold)
|
|
|
- {
|
|
|
- const int bits_count = static_cast<int>((node->endIndex - start_index) /
|
|
|
- single_bit_timing_length_threshold);
|
|
|
-
|
|
|
- const int last_gotbit_count = getbit_count;
|
|
|
-
|
|
|
- for (int i = 0; i < bits_count; i++)
|
|
|
- {
|
|
|
- if (last_gotbit_count + i >= pre_complement_need_bit_count)
|
|
|
- {
|
|
|
- break;
|
|
|
- }
|
|
|
- if ((last_gotbit_count + i) >= static_cast<int32_t>(nrzi_data.size()))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "GetNRZIData error: last_gotbit_count + i > nrzi_data.size()");
|
|
|
- break;
|
|
|
- }
|
|
|
- nrzi_data[last_gotbit_count + i] = high_polarity_edge == (node->edge ==
|
|
|
- Edge::Rise);
|
|
|
- getbit_count++;
|
|
|
- start_index += packet_sync_.singleBitTimingLength;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- nrzi_data[getbit_count] = node->edge == Edge::Rise;
|
|
|
- getbit_count++;
|
|
|
- }
|
|
|
- if (getbit_count == pre_complement_need_bit_count)
|
|
|
- {
|
|
|
- break;
|
|
|
- }
|
|
|
- node++;
|
|
|
- if (start_index < node->startIndex)
|
|
|
- {
|
|
|
- start_index = node->startIndex;
|
|
|
- }
|
|
|
- }
|
|
|
- //待提取下个位标_位移数
|
|
|
- int32_t move_bit_count = 0;
|
|
|
-
|
|
|
- //lastNRBZDataBit = node->Edge == Edge::Rise;
|
|
|
- //处理连续 输出结果
|
|
|
-
|
|
|
- int32_t continuous_count = 0;
|
|
|
- bool last_value = false;
|
|
|
- for (bool data : nrzi_data)
|
|
|
- {
|
|
|
- move_bit_count++;
|
|
|
-
|
|
|
- //6个连续下一个翻转，必然是插入的bit
|
|
|
- if (continuous_count == USB_NRZI_COMPLEMENT_PER_NUM && data != last_value)
|
|
|
- {
|
|
|
- continuous_count = 0;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (last_value == data)
|
|
|
- {
|
|
|
- continuous_count++;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- last_value = data;
|
|
|
- continuous_count = 0;
|
|
|
- }
|
|
|
-
|
|
|
- out_data.push_back(data);
|
|
|
- if (static_cast<int32_t>(out_data.size()) == need_bit_count)
|
|
|
- {
|
|
|
- // if (get_data_start_index == packetSYNC.NodePtr->StartIndex)
|
|
|
- // {
|
|
|
- // to_extracted_next_data_start_index = packetSYNC.EndIndex;
|
|
|
- // }
|
|
|
- // else
|
|
|
- // {
|
|
|
- to_extracted_next_data_start_index_ = get_data_start_index + (move_bit_count * packet_sync_.
|
|
|
- singleBitTimingLength);
|
|
|
- //}
|
|
|
- //while (pre_complement_number > 0 && to_extracted_next_data_start_index > 0 && to_extracted_next_data_start_index
|
|
|
- // < node->StartIndex)
|
|
|
- //{
|
|
|
- // //退回多抽的点位标
|
|
|
- // pre_complement_number--;
|
|
|
- // node--;
|
|
|
- //}
|
|
|
- while (to_extracted_next_data_start_index_ > 0 && to_extracted_next_data_start_index_
|
|
|
- < node->startIndex)
|
|
|
- {
|
|
|
- //退回多抽的点位标
|
|
|
- node--;
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- WriteLog(LogLevel::LevelDebug, "GetNRZIData return fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- //NRZI解码下个字节
|
|
|
- bool USBPacket::DecodeNextByteByDataField(TwoLevelEdgePulse*& node, uint8_t& out_data)
|
|
|
- {
|
|
|
- return DecodeNextByte(node, to_extracted_next_data_start_index_, out_data);
|
|
|
- }
|
|
|
-
|
|
|
- void USBPacket::NRBZToNormalData(const TwoLevelEdgePulse* node,
|
|
|
- int32_t need_bit_count, std::vector<bool> nrzi_data, uint8_t& out_data)
|
|
|
- {
|
|
|
- //lastNRBZDataBit = node->Edge == Edge::Rise;
|
|
|
- for (int i = 0; i < need_bit_count; i++)
|
|
|
- {
|
|
|
- //信号不变，就是数据1
|
|
|
- if (last_nrbz_data_bit_ == nrzi_data[i])
|
|
|
- {
|
|
|
- out_data |= (1 << i);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- //信号变了就是数据0
|
|
|
- }
|
|
|
- last_nrbz_data_bit_ = nrzi_data[i];
|
|
|
- }
|
|
|
- //out_data = CommonHelper::ReverseOrderBits(out_data);
|
|
|
- }
|
|
|
- //NRZI解码下个字节
|
|
|
- bool USBPacket::DecodeNextByte(TwoLevelEdgePulse*& node, int32_t start_index, uint8_t& out_data)
|
|
|
- {
|
|
|
- out_data = 0;
|
|
|
- constexpr int32_t need_bit_count = 8;
|
|
|
- std::vector<bool> nrzi_data = {};
|
|
|
- if (!GetNRZIData(node, need_bit_count, start_index, nrzi_data))
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "DecodeNextByte GetNRZIData fail");
|
|
|
- return false;
|
|
|
- }
|
|
|
- NRBZToNormalData(node, need_bit_count, nrzi_data, out_data);
|
|
|
- return true;
|
|
|
- }
|
|
|
- bool USBPacket::DecodeTokenBytes(TwoLevelEdgePulse*& node, USBEnums::TokenPackageType type)
|
|
|
- {
|
|
|
- bool is_sof_type = type == USBEnums::TokenPackageType::SOF;
|
|
|
- bool result;
|
|
|
- if (!is_sof_type)
|
|
|
- {
|
|
|
- //7addr-4enp-5crc bit
|
|
|
- //////////////////////////// addr ////////////////////////////
|
|
|
- std::vector<bool> addr_data = {};
|
|
|
- uint8_t addr = 0;
|
|
|
- result = GetNRZIData(node, USB_ADDR_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
- addr_data);
|
|
|
- if (!result)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
- NRBZToNormalData(node, USB_ADDR_BIT_COUNT, addr_data
|
|
|
- , addr);
|
|
|
- address_.push_back(addr);
|
|
|
- //////////////////////////// endpoint ////////////////////////////
|
|
|
- std::vector<bool> endpoint_data = {};
|
|
|
-
|
|
|
- result = GetNRZIData(node, USB_ENDPOINT_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
- endpoint_data);
|
|
|
- if (!result)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
- NRBZToNormalData(node, USB_ENDPOINT_BIT_COUNT, endpoint_data
|
|
|
- , end_point_);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- //11frame-5bitcrc
|
|
|
- //////////////////////////// frame ////////////////////////////
|
|
|
- std::vector<bool> frame_data = {};
|
|
|
- uint8_t frame_id_tmp = 0;
|
|
|
- datas_ = {};
|
|
|
- result = GetNRZIData(node, USB_FRAMEID_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
- frame_data);
|
|
|
- if (!result)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- NRBZToNormalData(node, USB_FRAMEID_BIT_COUNT, frame_data
|
|
|
- , frame_id_tmp);
|
|
|
- datas_.push_back(frame_id_tmp);
|
|
|
- frame_id_tmp = 0;
|
|
|
- for (int i = 8; i < USB_FRAMEID_BIT_COUNT - 8; i++)
|
|
|
- {
|
|
|
- if (last_nrbz_data_bit_ != frame_data[i])
|
|
|
- {
|
|
|
- last_nrbz_data_bit_ = frame_data[i];
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- frame_id_tmp |= (1 << i);
|
|
|
- }
|
|
|
- }
|
|
|
- datas_.push_back(frame_id_tmp);
|
|
|
- }
|
|
|
-
|
|
|
- //////////////////////////// CRC5 ////////////////////////////
|
|
|
- std::vector<bool> crc_data = {};
|
|
|
- uint8_t crc = 0;
|
|
|
- result = GetNRZIData(node, USB_CRC5_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
- crc_data);
|
|
|
- if (!result)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- NRBZToNormalData(node, USB_CRC5_BIT_COUNT, crc_data
|
|
|
- , crc);
|
|
|
- crc_sign_num_ = USB_CRC5_BIT_COUNT;
|
|
|
- crc16_ = crc;
|
|
|
- WriteLog(LogLevel::LevelDebug, "DecodeTokenBytes = true,crc_sign_num=%d,crc=0x%x"
|
|
|
- , crc_sign_num_, crc16_);
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- void USBPacket::DecodeFields(TwoLevelEdgePulse*& node)
|
|
|
- {
|
|
|
- switch (packet_type_) // NOLINT(clang-diagnostic-switch-enum)
|
|
|
- {
|
|
|
- case USBEnums::USBPacketType::TOKEN:
|
|
|
- DecodeFieldsByToken(node);
|
|
|
- break;
|
|
|
- case USBEnums::USBPacketType::DATA:
|
|
|
-
|
|
|
- DecodeFieldsByData(node);
|
|
|
- break;
|
|
|
- case USBEnums::USBPacketType::HAND_SHAKE:
|
|
|
- break;
|
|
|
- case USBEnums::USBPacketType::SPECIAL:
|
|
|
- DecodeFieldsBySpecial(node);
|
|
|
- break;
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- void USBPacket::DecodeFieldsByToken(TwoLevelEdgePulse*& node)
|
|
|
- {
|
|
|
- if (packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "DecodeFieldsByToken error:packetType is NO_DEFINE");
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- switch (static_cast<
|
|
|
- USBEnums::TokenPackageType>(RealPID()))
|
|
|
- {
|
|
|
- case USBEnums::TokenPackageType::SOF:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::SOF;
|
|
|
- DecodeTokenBytes(node, USBEnums::TokenPackageType::SOF);
|
|
|
- break;
|
|
|
- case USBEnums::TokenPackageType::SETUP:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::SETUP;
|
|
|
- DecodeTokenBytes(node, USBEnums::TokenPackageType::SETUP);
|
|
|
- break;
|
|
|
- case USBEnums::TokenPackageType::IN_TYPE:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::TIN;
|
|
|
- DecodeTokenBytes(node, USBEnums::TokenPackageType::IN_TYPE);
|
|
|
- break;
|
|
|
- case USBEnums::TokenPackageType::OUT_TYPE:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::TOUT;
|
|
|
- DecodeTokenBytes(node, USBEnums::TokenPackageType::OUT_TYPE);
|
|
|
- break;
|
|
|
- // default:
|
|
|
- // return;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- void USBPacket::DecodeFieldsByData(TwoLevelEdgePulse*& node)
|
|
|
- {
|
|
|
- if (packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "DecodeFieldsByToken error:packetType is NO_DEFINE");
|
|
|
- return;
|
|
|
- }
|
|
|
- int32_t end_index = packet_sync_.nodePtr->endIndex;
|
|
|
- std::vector<uint8_t> get_data_tmp = {};
|
|
|
- switch (auto package_type = static_cast<USBEnums::DataPackageType>(RealPID()))
|
|
|
- {
|
|
|
- case USBEnums::DataPackageType::DATA0:
|
|
|
- case USBEnums::DataPackageType::DATA1:
|
|
|
- PacketTitle = package_type == USBEnums::DataPackageType::DATA0
|
|
|
- ? USBEnums::EventInfoTitles::DATA0
|
|
|
- : USBEnums::EventInfoTitles::DATA1;
|
|
|
- datas_.clear();
|
|
|
-
|
|
|
- if (max_possible_data_length_ >= 0 && max_possible_data_length_
|
|
|
- > packet_sync_.Length())
|
|
|
- {
|
|
|
- end_index = max_possible_data_length_ + packet_sync_.nodePtr->startIndex;
|
|
|
- }
|
|
|
- while (CheckNodeValid(node) && node->startIndex < end_index)
|
|
|
- {
|
|
|
- uint8_t data;
|
|
|
- bool result = DecodeNextByteByDataField(node, data);
|
|
|
- if (!result)
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "DecodeFieldsByData DecodeNextByte fail:StartIndex:%d", node->startIndex);
|
|
|
- break;
|
|
|
- }
|
|
|
- get_data_tmp.push_back(data);
|
|
|
- }
|
|
|
- if (get_data_tmp.size() > 2)
|
|
|
- {
|
|
|
- //data
|
|
|
- for (uint64_t i = 0; i < get_data_tmp.size() - 2; i++)
|
|
|
- {
|
|
|
- datas_.push_back(get_data_tmp[i]);
|
|
|
- }
|
|
|
- //crc16
|
|
|
- /* for (uint64_t i = (get_data_tmp.size() - 2); i < get_data_tmp.size(); i++)
|
|
|
- {
|
|
|
- }*/
|
|
|
- uint8_t crc16_h = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 2]);
|
|
|
- uint8_t crc16_l = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 1]);
|
|
|
- crc16_ = (static_cast<uint16_t>(crc16_h) << 8) + static_cast<uint16_t>(crc16_l);
|
|
|
-
|
|
|
- crc_sign_num_ = 16;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- WriteLog(LogLevel::Level2, "Waring:DecodeFieldsByData Decode DataSize < 2 (%d)", get_data_tmp.size());
|
|
|
- datas_ = std::move(get_data_tmp);
|
|
|
- }
|
|
|
- get_data_tmp.clear();
|
|
|
- break;
|
|
|
- case USBEnums::DataPackageType::DATA2:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::DATA2;
|
|
|
- break;
|
|
|
- case USBEnums::DataPackageType::M_DATA:
|
|
|
- PacketTitle = USBEnums::EventInfoTitles::MDATA;
|
|
|
- break;
|
|
|
- // default:
|
|
|
- // break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- void USBPacket::DecodeFieldsBySpecial(TwoLevelEdgePulse*& node) const
|
|
|
- {
|
|
|
- //todo
|
|
|
- if (packet_type_ != USBEnums::USBPacketType::SPECIAL)
|
|
|
- {
|
|
|
- }
|
|
|
- }
|
|
|
- bool USBPacket::IsTokenPackageType() const
|
|
|
- {
|
|
|
- int32_t real_pid = RealPID();
|
|
|
- if (static_cast<int32_t>(USBEnums::TokenPackageType::IN_TYPE) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::TokenPackageType::OUT_TYPE) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::TokenPackageType::SETUP) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::TokenPackageType::SOF) == real_pid
|
|
|
- )
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- bool USBPacket::IsSpecialPacketType() const
|
|
|
- {
|
|
|
- int32_t real_pid = RealPID();
|
|
|
- if (static_cast<int32_t>(USBEnums::SpecialPacketType::ERR) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::SpecialPacketType::PING) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::SpecialPacketType::REMAIN) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::SpecialPacketType::SPLIT) == real_pid
|
|
|
- )
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- bool USBPacket::IsHandshakePackageType(USBEnums::HandshakePackageType& type) const
|
|
|
- {
|
|
|
- int32_t real_pid = RealPID();
|
|
|
- if (static_cast<int32_t>(USBEnums::HandshakePackageType::NYET) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::HandshakePackageType::STALL) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::HandshakePackageType::ACK) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::HandshakePackageType::NAK) == real_pid
|
|
|
- )
|
|
|
- {
|
|
|
- type = static_cast<USBEnums::HandshakePackageType>(real_pid);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- bool USBPacket::IsDataPackageType()
|
|
|
- {
|
|
|
- int32_t real_pid = RealPID();
|
|
|
- if (static_cast<int32_t>(USBEnums::DataPackageType::DATA0) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::DataPackageType::DATA1) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::DataPackageType::DATA2) == real_pid
|
|
|
- || static_cast<int32_t>(USBEnums::DataPackageType::M_DATA) == real_pid
|
|
|
- )
|
|
|
- {
|
|
|
- to_nrzi_decode_next_data_start_index_ = packet_sync_.endIndex + (packet_sync_.oneByteTimingLength);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
+ USBPacket::USBPacket() : PacketTitle(), pid_(0), last_nrbz_data_bit_(false), polarity_(false), end_point_(0),
|
|
|
+ crc_sign_num_(0),
|
|
|
+ crc16_(0), is_valid_(false),
|
|
|
+ is_crc_checked_(false),
|
|
|
+ to_extracted_next_data_start_index_(-1),
|
|
|
+ to_nrzi_decode_next_data_start_index_(-1),
|
|
|
+ max_possible_data_length_(-1)
|
|
|
+
|
|
|
+
|
|
|
+ {
|
|
|
+ }
|
|
|
+
|
|
|
+ USBPacket::USBPacket(TwoLevelEdgePulse* pid_node, int32_t& left_over_size, const SYNC& sync
|
|
|
+ , bool polarity, int32_t max_data_length)
|
|
|
+ {
|
|
|
+ this->polarity_ = polarity;
|
|
|
+ packet_sync_ = sync;
|
|
|
+ if (max_data_length >= 0)
|
|
|
+ {
|
|
|
+ max_possible_data_length_ = max_data_length;
|
|
|
+ }
|
|
|
+
|
|
|
+ //this->pidType = nullptr;
|
|
|
+ TwoLevelEdgePulse* tmp_pid_node = pid_node;
|
|
|
+ /*if (tmp_pid_node->startIndex < sync.endIndex && tmp_pid_node->startIndex < sync.nodePtr->startIndex + sync.Length())
|
|
|
+ {
|
|
|
+ while (tmp_pid_node->startIndex < sync.endIndex && tmp_pid_node->startIndex < sync.nodePtr->startIndex + sync.Length())
|
|
|
+ {
|
|
|
+ tmp_pid_node += 1;
|
|
|
+ }
|
|
|
+ tmp_pid_node -= 2;
|
|
|
+ }*/
|
|
|
+
|
|
|
+ if (!GetPID(tmp_pid_node))
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ is_valid_ = true;
|
|
|
+
|
|
|
+ if (this->packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ //解码域内容
|
|
|
+ DecodeFields(tmp_pid_node);
|
|
|
+ }
|
|
|
+
|
|
|
+ bool USBPacket::CheckNibblesInverse(uint8_t value)
|
|
|
+ {
|
|
|
+ const uint8_t high_nibble = static_cast<uint8_t>(value >> 4);
|
|
|
+ const uint8_t low_nibble = static_cast<uint8_t>(value & 0x0F);
|
|
|
+ return high_nibble == (~low_nibble & 0x0F);
|
|
|
+ }
|
|
|
+
|
|
|
+ bool USBPacket::GetPID(TwoLevelEdgePulse*& pid_node)
|
|
|
+ {
|
|
|
+ if (!CheckNodeValid(static_cast<EdgePulse>(*pid_node)))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "node check fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (packet_sync_.singleBitTimingLength <= 0)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ last_nrbz_data_bit_ = false;
|
|
|
+ uint8_t data;
|
|
|
+ int32_t pid_start_index = packet_sync_.endIndex + 2;
|
|
|
+
|
|
|
+ if (!DecodeNextByte(pid_node, pid_start_index, data))
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ pid_ = data;
|
|
|
+ auto handshake_type = USBEnums::HandshakePackageType::NAK;
|
|
|
+ if (IsTokenPackageType())
|
|
|
+ {
|
|
|
+ packet_type_ = USBEnums::USBPacketType::TOKEN;
|
|
|
+ }
|
|
|
+ else if (IsDataPackageType())
|
|
|
+ {
|
|
|
+ packet_type_ = USBEnums::USBPacketType::DATA;
|
|
|
+ }
|
|
|
+ else if (IsHandshakePackageType(handshake_type))
|
|
|
+ {
|
|
|
+ packet_type_ = USBEnums::USBPacketType::HAND_SHAKE;
|
|
|
+ switch (handshake_type)
|
|
|
+ {
|
|
|
+ case USBEnums::HandshakePackageType::ACK:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::ACK;
|
|
|
+ break;
|
|
|
+ case USBEnums::HandshakePackageType::NAK:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::NAK;
|
|
|
+ break;
|
|
|
+ case USBEnums::HandshakePackageType::STALL:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::STALL;
|
|
|
+ break;
|
|
|
+ case USBEnums::HandshakePackageType::NYET:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::NYET;
|
|
|
+ break;
|
|
|
+ default: // NOLINT(clang-diagnostic-covered-switch-default)
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (IsSpecialPacketType())
|
|
|
+ {
|
|
|
+ packet_type_ = USBEnums::USBPacketType::SPECIAL;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool USBPacket::GetNRZIData(TwoLevelEdgePulse*& node, int32_t need_bit_count, int32_t start_index,
|
|
|
+ std::vector<bool>& out_data)
|
|
|
+ {
|
|
|
+ if (!CheckNodeValid(node))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "node check fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ const int32_t get_data_start_index = start_index;
|
|
|
+ //const int32_t get_data_start_index = node->StartIndex;
|
|
|
+ const bool high_polarity_edge = packet_sync_.nodePtr->edge == Edge::Falling;
|
|
|
+ const double single_bit_timing_length_threshold = packet_sync_.singleBitTimingLength * USB_SYNC_BIT_TOL;
|
|
|
+ out_data = {};
|
|
|
+ //nrzi 补位个数
|
|
|
+ const int32_t pre_complement_number = need_bit_count / USB_NRZI_COMPLEMENT_PER_NUM;
|
|
|
+ const int32_t pre_complement_need_bit_count = need_bit_count + pre_complement_number;
|
|
|
+ std::vector<bool> nrzi_data(pre_complement_need_bit_count, false);
|
|
|
+ int32_t getbit_count = 0;
|
|
|
+ bool get_last_nrzi_bit_polarity = false;
|
|
|
+ while (getbit_count < pre_complement_need_bit_count)
|
|
|
+ {
|
|
|
+ if (!CheckNodeValid(node))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "GetNRZIData node check fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (node->endIndex < start_index)
|
|
|
+ {
|
|
|
+ node++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ ////fix
|
|
|
+ if (node->endIndex - start_index < packet_sync_.singleBitTimingLength / 2)
|
|
|
+ {
|
|
|
+ node++;
|
|
|
+ if (!CheckNodeValid(node))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "GetNRZIData node check fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!get_last_nrzi_bit_polarity && CheckNodeValid(node - 1))
|
|
|
+ {
|
|
|
+ if (start_index - node->startIndex > single_bit_timing_length_threshold)
|
|
|
+ {
|
|
|
+ last_nrbz_data_bit_ = node->CurrentLevel == TwoLevelEdgePulseStatusType::High;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ //不用改
|
|
|
+ //last_NRBZ_data_bit = (node - 1)->CurrentLevel == TwoLevelEdgePulseStatusType::High;
|
|
|
+ }
|
|
|
+
|
|
|
+ get_last_nrzi_bit_polarity = true;
|
|
|
+ }
|
|
|
+ if (node->endIndex - start_index >= single_bit_timing_length_threshold)
|
|
|
+ {
|
|
|
+ const int bits_count = static_cast<int>((node->endIndex - start_index) /
|
|
|
+ single_bit_timing_length_threshold);
|
|
|
+
|
|
|
+ const int last_gotbit_count = getbit_count;
|
|
|
+
|
|
|
+ for (int i = 0; i < bits_count; i++)
|
|
|
+ {
|
|
|
+ if (last_gotbit_count + i >= pre_complement_need_bit_count)
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if ((last_gotbit_count + i) >= static_cast<int32_t>(nrzi_data.size()))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "GetNRZIData error: last_gotbit_count + i > nrzi_data.size()");
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ nrzi_data[last_gotbit_count + i] = high_polarity_edge == (node->edge ==
|
|
|
+ Edge::Rise);
|
|
|
+ getbit_count++;
|
|
|
+ start_index += packet_sync_.singleBitTimingLength;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ nrzi_data[getbit_count] = node->edge == Edge::Rise;
|
|
|
+ getbit_count++;
|
|
|
+ }
|
|
|
+ if (getbit_count == pre_complement_need_bit_count)
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ node++;
|
|
|
+ if (start_index < node->startIndex)
|
|
|
+ {
|
|
|
+ start_index = node->startIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //待提取下个位标_位移数
|
|
|
+ int32_t move_bit_count = 0;
|
|
|
+
|
|
|
+ //lastNRBZDataBit = node->Edge == Edge::Rise;
|
|
|
+ //处理连续 输出结果
|
|
|
+
|
|
|
+ int32_t continuous_count = 0;
|
|
|
+ bool last_value = false;
|
|
|
+ for (bool data : nrzi_data)
|
|
|
+ {
|
|
|
+ move_bit_count++;
|
|
|
+
|
|
|
+ //6个连续下一个翻转，必然是插入的bit
|
|
|
+ if (continuous_count == USB_NRZI_COMPLEMENT_PER_NUM && data != last_value)
|
|
|
+ {
|
|
|
+ continuous_count = 0;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (last_value == data)
|
|
|
+ {
|
|
|
+ continuous_count++;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ last_value = data;
|
|
|
+ continuous_count = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ out_data.push_back(data);
|
|
|
+ if (static_cast<int32_t>(out_data.size()) == need_bit_count)
|
|
|
+ {
|
|
|
+ // if (get_data_start_index == packetSYNC.NodePtr->StartIndex)
|
|
|
+ // {
|
|
|
+ // to_extracted_next_data_start_index = packetSYNC.EndIndex;
|
|
|
+ // }
|
|
|
+ // else
|
|
|
+ // {
|
|
|
+ to_extracted_next_data_start_index_ = get_data_start_index + (move_bit_count * packet_sync_.
|
|
|
+ singleBitTimingLength);
|
|
|
+ //}
|
|
|
+ //while (pre_complement_number > 0 && to_extracted_next_data_start_index > 0 && to_extracted_next_data_start_index
|
|
|
+ // < node->StartIndex)
|
|
|
+ //{
|
|
|
+ // //退回多抽的点位标
|
|
|
+ // pre_complement_number--;
|
|
|
+ // node--;
|
|
|
+ //}
|
|
|
+ while (to_extracted_next_data_start_index_ > 0 && to_extracted_next_data_start_index_
|
|
|
+ < node->startIndex)
|
|
|
+ {
|
|
|
+ //退回多抽的点位标
|
|
|
+ node--;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ WriteLog(LogLevel::LevelDebug, "GetNRZIData return fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ //NRZI解码下个字节
|
|
|
+ bool USBPacket::DecodeNextByteByDataField(TwoLevelEdgePulse*& node, uint8_t& out_data)
|
|
|
+ {
|
|
|
+ return DecodeNextByte(node, to_extracted_next_data_start_index_, out_data);
|
|
|
+ }
|
|
|
+
|
|
|
+ void USBPacket::NRBZToNormalData(const TwoLevelEdgePulse* node,
|
|
|
+ int32_t need_bit_count, std::vector<bool> nrzi_data, uint8_t& out_data)
|
|
|
+ {
|
|
|
+ //lastNRBZDataBit = node->Edge == Edge::Rise;
|
|
|
+ for (int i = 0; i < need_bit_count; i++)
|
|
|
+ {
|
|
|
+ //信号不变，就是数据1
|
|
|
+ if (last_nrbz_data_bit_ == nrzi_data[i])
|
|
|
+ {
|
|
|
+ out_data |= (1 << i);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ //信号变了就是数据0
|
|
|
+ }
|
|
|
+ last_nrbz_data_bit_ = nrzi_data[i];
|
|
|
+ }
|
|
|
+ //out_data = CommonHelper::ReverseOrderBits(out_data);
|
|
|
+ }
|
|
|
+ //NRZI解码下个字节
|
|
|
+ bool USBPacket::DecodeNextByte(TwoLevelEdgePulse*& node, int32_t start_index, uint8_t& out_data)
|
|
|
+ {
|
|
|
+ out_data = 0;
|
|
|
+ constexpr int32_t need_bit_count = 8;
|
|
|
+ std::vector<bool> nrzi_data = {};
|
|
|
+ if (!GetNRZIData(node, need_bit_count, start_index, nrzi_data))
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "DecodeNextByte GetNRZIData fail");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ NRBZToNormalData(node, need_bit_count, nrzi_data, out_data);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ bool USBPacket::DecodeTokenBytes(TwoLevelEdgePulse*& node, USBEnums::TokenPackageType type)
|
|
|
+ {
|
|
|
+ bool is_sof_type = type == USBEnums::TokenPackageType::SOF;
|
|
|
+ bool result;
|
|
|
+ if (!is_sof_type)
|
|
|
+ {
|
|
|
+ //7addr-4enp-5crc bit
|
|
|
+ //////////////////////////// addr ////////////////////////////
|
|
|
+ std::vector<bool> addr_data = {};
|
|
|
+ uint8_t addr = 0;
|
|
|
+ result = GetNRZIData(node, USB_ADDR_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
+ addr_data);
|
|
|
+ if (!result)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ NRBZToNormalData(node, USB_ADDR_BIT_COUNT, addr_data
|
|
|
+ , addr);
|
|
|
+ address_.push_back(addr);
|
|
|
+ //////////////////////////// endpoint ////////////////////////////
|
|
|
+ std::vector<bool> endpoint_data = {};
|
|
|
+
|
|
|
+ result = GetNRZIData(node, USB_ENDPOINT_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
+ endpoint_data);
|
|
|
+ if (!result)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ NRBZToNormalData(node, USB_ENDPOINT_BIT_COUNT, endpoint_data
|
|
|
+ , end_point_);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ //11frame-5bitcrc
|
|
|
+ //////////////////////////// frame ////////////////////////////
|
|
|
+ std::vector<bool> frame_data = {};
|
|
|
+ uint8_t frame_id_tmp = 0;
|
|
|
+ datas_ = {};
|
|
|
+ result = GetNRZIData(node, USB_FRAMEID_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
+ frame_data);
|
|
|
+ if (!result)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ NRBZToNormalData(node, USB_FRAMEID_BIT_COUNT, frame_data
|
|
|
+ , frame_id_tmp);
|
|
|
+ datas_.push_back(frame_id_tmp);
|
|
|
+ frame_id_tmp = 0;
|
|
|
+ for (int i = 8; i < USB_FRAMEID_BIT_COUNT - 8; i++)
|
|
|
+ {
|
|
|
+ if (last_nrbz_data_bit_ != frame_data[i])
|
|
|
+ {
|
|
|
+ last_nrbz_data_bit_ = frame_data[i];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ frame_id_tmp |= (1 << i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ datas_.push_back(frame_id_tmp);
|
|
|
+ }
|
|
|
+
|
|
|
+ //////////////////////////// CRC5 ////////////////////////////
|
|
|
+ std::vector<bool> crc_data = {};
|
|
|
+ uint8_t crc = 0;
|
|
|
+ result = GetNRZIData(node, USB_CRC5_BIT_COUNT, to_extracted_next_data_start_index_,
|
|
|
+ crc_data);
|
|
|
+ if (!result)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ NRBZToNormalData(node, USB_CRC5_BIT_COUNT, crc_data
|
|
|
+ , crc);
|
|
|
+ crc_sign_num_ = USB_CRC5_BIT_COUNT;
|
|
|
+ crc16_ = crc;
|
|
|
+ WriteLog(LogLevel::LevelDebug, "DecodeTokenBytes = true,crc_sign_num=%d,crc=0x%x"
|
|
|
+ , crc_sign_num_, crc16_);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ void USBPacket::DecodeFields(TwoLevelEdgePulse*& node)
|
|
|
+ {
|
|
|
+ switch (packet_type_) // NOLINT(clang-diagnostic-switch-enum)
|
|
|
+ {
|
|
|
+ case USBEnums::USBPacketType::TOKEN:
|
|
|
+ DecodeFieldsByToken(node);
|
|
|
+ break;
|
|
|
+ case USBEnums::USBPacketType::DATA:
|
|
|
+
|
|
|
+ DecodeFieldsByData(node);
|
|
|
+ break;
|
|
|
+ case USBEnums::USBPacketType::HAND_SHAKE:
|
|
|
+ break;
|
|
|
+ case USBEnums::USBPacketType::SPECIAL:
|
|
|
+ DecodeFieldsBySpecial(node);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void USBPacket::DecodeFieldsByToken(TwoLevelEdgePulse*& node)
|
|
|
+ {
|
|
|
+ if (packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "DecodeFieldsByToken error:packetType is NO_DEFINE");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (static_cast<
|
|
|
+ USBEnums::TokenPackageType>(RealPID()))
|
|
|
+ {
|
|
|
+ case USBEnums::TokenPackageType::SOF:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::SOF;
|
|
|
+ DecodeTokenBytes(node, USBEnums::TokenPackageType::SOF);
|
|
|
+ break;
|
|
|
+ case USBEnums::TokenPackageType::SETUP:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::SETUP;
|
|
|
+ DecodeTokenBytes(node, USBEnums::TokenPackageType::SETUP);
|
|
|
+ break;
|
|
|
+ case USBEnums::TokenPackageType::IN_TYPE:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::TIN;
|
|
|
+ DecodeTokenBytes(node, USBEnums::TokenPackageType::IN_TYPE);
|
|
|
+ break;
|
|
|
+ case USBEnums::TokenPackageType::OUT_TYPE:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::TOUT;
|
|
|
+ DecodeTokenBytes(node, USBEnums::TokenPackageType::OUT_TYPE);
|
|
|
+ break;
|
|
|
+ // default:
|
|
|
+ // return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void USBPacket::DecodeFieldsByData(TwoLevelEdgePulse*& node)
|
|
|
+ {
|
|
|
+ if (packet_type_ == USBEnums::USBPacketType::NO_DEFINE)
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "DecodeFieldsByToken error:packetType is NO_DEFINE");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int32_t end_index = packet_sync_.nodePtr->endIndex;
|
|
|
+ std::vector<uint8_t> get_data_tmp = {};
|
|
|
+ switch (auto package_type = static_cast<USBEnums::DataPackageType>(RealPID()))
|
|
|
+ {
|
|
|
+ case USBEnums::DataPackageType::DATA0:
|
|
|
+ case USBEnums::DataPackageType::DATA1:
|
|
|
+ PacketTitle = package_type == USBEnums::DataPackageType::DATA0
|
|
|
+ ? USBEnums::EventInfoTitles::DATA0
|
|
|
+ : USBEnums::EventInfoTitles::DATA1;
|
|
|
+ datas_.clear();
|
|
|
+
|
|
|
+ if (max_possible_data_length_ >= 0 && max_possible_data_length_
|
|
|
+ > packet_sync_.Length())
|
|
|
+ {
|
|
|
+ end_index = max_possible_data_length_ + packet_sync_.nodePtr->startIndex;
|
|
|
+ }
|
|
|
+ while (CheckNodeValid(node) && node->startIndex < end_index)
|
|
|
+ {
|
|
|
+ uint8_t data;
|
|
|
+ bool result = DecodeNextByteByDataField(node, data);
|
|
|
+ if (!result)
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "DecodeFieldsByData DecodeNextByte fail:StartIndex:%d", node->startIndex);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ get_data_tmp.push_back(data);
|
|
|
+ }
|
|
|
+ if (get_data_tmp.size() > 2)
|
|
|
+ {
|
|
|
+ //data
|
|
|
+ for (uint64_t i = 0; i < get_data_tmp.size() - 2; i++)
|
|
|
+ {
|
|
|
+ datas_.push_back(get_data_tmp[i]);
|
|
|
+ }
|
|
|
+ //crc16
|
|
|
+ /* for (uint64_t i = (get_data_tmp.size() - 2); i < get_data_tmp.size(); i++)
|
|
|
+ {
|
|
|
+ }*/
|
|
|
+ uint8_t crc16_h = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 2]);
|
|
|
+ uint8_t crc16_l = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 1]);
|
|
|
+ crc16_ = (static_cast<uint16_t>(crc16_h) << 8) + static_cast<uint16_t>(crc16_l);
|
|
|
+
|
|
|
+ crc_sign_num_ = 16;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ WriteLog(LogLevel::Level2, "Waring:DecodeFieldsByData Decode DataSize < 2 (%d)", get_data_tmp.size());
|
|
|
+ datas_ = std::move(get_data_tmp);
|
|
|
+ }
|
|
|
+ get_data_tmp.clear();
|
|
|
+ break;
|
|
|
+ case USBEnums::DataPackageType::DATA2:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::DATA2;
|
|
|
+ break;
|
|
|
+ case USBEnums::DataPackageType::M_DATA:
|
|
|
+ PacketTitle = USBEnums::EventInfoTitles::MDATA;
|
|
|
+ break;
|
|
|
+ // default:
|
|
|
+ // break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void USBPacket::DecodeFieldsBySpecial(TwoLevelEdgePulse*& node) const
|
|
|
+ {
|
|
|
+ //todo
|
|
|
+ if (packet_type_ != USBEnums::USBPacketType::SPECIAL)
|
|
|
+ {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ bool USBPacket::IsTokenPackageType() const
|
|
|
+ {
|
|
|
+ int32_t real_pid = RealPID();
|
|
|
+ if (static_cast<int32_t>(USBEnums::TokenPackageType::IN_TYPE) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::TokenPackageType::OUT_TYPE) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::TokenPackageType::SETUP) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::TokenPackageType::SOF) == real_pid
|
|
|
+ )
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ bool USBPacket::IsSpecialPacketType() const
|
|
|
+ {
|
|
|
+ int32_t real_pid = RealPID();
|
|
|
+ if (static_cast<int32_t>(USBEnums::SpecialPacketType::ERR) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::SpecialPacketType::PING) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::SpecialPacketType::REMAIN) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::SpecialPacketType::SPLIT) == real_pid
|
|
|
+ )
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ bool USBPacket::IsHandshakePackageType(USBEnums::HandshakePackageType& type) const
|
|
|
+ {
|
|
|
+ int32_t real_pid = RealPID();
|
|
|
+ if (static_cast<int32_t>(USBEnums::HandshakePackageType::NYET) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::HandshakePackageType::STALL) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::HandshakePackageType::ACK) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::HandshakePackageType::NAK) == real_pid
|
|
|
+ )
|
|
|
+ {
|
|
|
+ type = static_cast<USBEnums::HandshakePackageType>(real_pid);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ bool USBPacket::IsDataPackageType()
|
|
|
+ {
|
|
|
+ int32_t real_pid = RealPID();
|
|
|
+ if (static_cast<int32_t>(USBEnums::DataPackageType::DATA0) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::DataPackageType::DATA1) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::DataPackageType::DATA2) == real_pid
|
|
|
+ || static_cast<int32_t>(USBEnums::DataPackageType::M_DATA) == real_pid
|
|
|
+ )
|
|
|
+ {
|
|
|
+ to_nrzi_decode_next_data_start_index_ = packet_sync_.endIndex + (packet_sync_.oneByteTimingLength);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
}
|
