USB解码更新0.1.8

ProtocolUSB/usb_packet.cc

@@ -13,580 +13,592 @@
 
 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
-                         , const bool polarity, const 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(const 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, const 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->end_index < start_index)
-            {
-                node++;
-                continue;
-            }
-
-            ////fix
-            if (node->end_index - 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->start_index > single_bit_timing_length_threshold)
-                {
-                    last_nrbz_data_bit_ = node->current_level == TwoLevelEdgePulseStatusType::High;
-                }
-                else
-                {
-                    //不用改
-                    //last_NRBZ_data_bit = (node - 1)->CurrentLevel == TwoLevelEdgePulseStatusType::High;
-                }
-
-                get_last_nrzi_bit_polarity = true;
-            }
-            if (node->end_index - start_index >= single_bit_timing_length_threshold)
-            {
-                const int bits_count = static_cast<int>((node->end_index - 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->start_index)
-            {
-                start_index = node->start_index;
-            }
-        }
-        //待提取下个位标_位移数
-        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->start_index)
-                {
-                    //退回多抽的点位标
-                    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,
-                                     const 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, const 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, const 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->end_index;
-        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->start_index - packet_sync_.singleBitTimingLength /2;
-            }
-            while (CheckNodeValid(node) && node->start_index < end_index)
-            {
-                uint8_t data;
-                bool result = DecodeNextByteByDataField(node, data);
-                if (!result)
-                {
-                    WriteLog(LogLevel::Level2, "DecodeFieldsByData DecodeNextByte fail:StartIndex:%d", node->start_index);
-                    break;
-                }
-                get_data_tmp.push_back(data);
-            }
-            if (get_data_tmp.size() > 3)
-            {
-                //data
-                for (uint64_t i = 0; i < get_data_tmp.size() - 3; 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() - 3]);
-                uint8_t crc16_l = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 2]);
-                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
+		, const bool polarity, const 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(const 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_ = !polarity_;
+		last_nrbz_data_bit_ = true;
+		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, const 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 = polarity_ ?
+		// 	packet_sync_.nodePtr->edge == Edge::Rise
+		// 	: packet_sync_.nodePtr->edge == Edge::Falling;
+		auto actual_level_edge = polarity_ ? Edge::Rise : 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->end_index < start_index)
+			{
+				node++;
+				continue;
+			}
+
+			////fix
+			if (node->end_index - 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->start_index > single_bit_timing_length_threshold)
+				{
+					last_nrbz_data_bit_ = node->current_level == TwoLevelEdgePulseStatusType::Low;
+					if (polarity_)
+					{
+						last_nrbz_data_bit_ = !last_nrbz_data_bit_;
+					}
+				}
+				else
+				{
+					//不用改
+					//last_NRBZ_data_bit = (node - 1)->CurrentLevel == TwoLevelEdgePulseStatusType::High;
+				}
+
+				get_last_nrzi_bit_polarity = true;
+			}
+
+			if (node->end_index - start_index >= single_bit_timing_length_threshold)
+			{
+				const int bits_count = static_cast<int>((node->end_index - 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 ==
+						actual_level_edge);*/
+					nrzi_data[last_gotbit_count + i] = node->edge ==
+						actual_level_edge;
+					getbit_count++;
+					start_index += packet_sync_.singleBitTimingLength;
+				}
+			}
+			else
+			{
+				nrzi_data[getbit_count] = node->edge == actual_level_edge;
+				getbit_count++;
+			}
+			if (getbit_count == pre_complement_need_bit_count)
+			{
+				break;
+			}
+			node++;
+			if (start_index < node->start_index)
+			{
+				start_index = node->start_index;
+			}
+		}
+		//待提取下个位标_位移数
+		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->start_index)
+				{
+					//退回多抽的点位标
+					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,
+		const 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, const 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, const 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->end_index;
+		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->start_index - packet_sync_.singleBitTimingLength / 2;
+			}
+			while (CheckNodeValid(node) && node->start_index < end_index)
+			{
+				uint8_t data;
+				bool result = DecodeNextByteByDataField(node, data);
+				if (!result)
+				{
+					WriteLog(LogLevel::Level2, "DecodeFieldsByData DecodeNextByte fail:StartIndex:%d", node->start_index);
+					break;
+				}
+				get_data_tmp.push_back(data);
+			}
+			if (get_data_tmp.size() > 3)
+			{
+				//data
+				for (uint64_t i = 0; i < get_data_tmp.size() - 3; i++)
+				{
+					datas_.push_back(get_data_tmp[i]);
+				}
+				//crc16
+				/* for (uint64_t i = (get_data_tmp.size() - 2); i < get_data_tmp.size(); i++)
+				 {
+				 }*/
+				const uint8_t crc16_h = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 3]);
+				const uint8_t crc16_l = CommonHelper::ReverseOrderBits(get_data_tmp[get_data_tmp.size() - 2]);
+				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;
+	}
 }

protocol_decode_base.h

@@ -20,8 +20,8 @@
 #include "BaseEnums/protocol_enums.h"
 #include "BaseHelper/Loger.h"
 
-// DLL_VERSION "0.1.7"
-const std::string DLL_VERSION = "0.1.7";
+// DLL_VERSION "x.x.x"
+const std::string DLL_VERSION = "0.1.8";
 
 namespace Protocol
 {