ProtocolDecoderStatic/ProtocolUSB/USBPacket.cpp

// // ******************************************************************
// //       /\ /|       @File         USBPacket.cpp
// //       \ V/        @Brief
// //       | "")       @Author        lijinwen, ghz005@uni-trend.com.cn
// //       /  |        @Creation      2024-1-3
// //      /  \\        @Modified      2024-1-15
// //    *(__\_\
// // ******************************************************************

#include "USBPacket.h"
#include "../BaseHelper/CommonHelper.h"
 
namespace Protocol
{
    USBPacket::USBPacket(): pid(0), lastNRBZDataBit(false), polarity(false), endPoint(0), crc5(0), isValid(false),
                            isCRCChecked(false)
    {
    }

    USBPacket::USBPacket(Protocol::TwoLevelEdgePulse* pidNode, int32_t& leftOverSize, SYNC sync, bool polarity)
    {
        this->polarity = polarity;
        this->packetSYNC = sync;
        //this->pidType = nullptr;

        if (!GetPID(pidNode, leftOverSize))
        {
            return;
        }

        isValid = true;

        if (this->type == Enums::USBPacketType::NoDefine)
        {
            return;
        }

        DecodeFields(pidNode, leftOverSize, sync);
    }

    bool USBPacket::CheckNibblesInverse(uint8_t value)
    {
        uint8_t highNibble = static_cast<uint8_t>(value >> 4);
        uint8_t lowNibble = static_cast<uint8_t>(value & 0x0F);
        return highNibble == (~lowNibble & 0x0F);
    }

    bool USBPacket::GetPID(Protocol::TwoLevelEdgePulse* pidNode, int32_t& leftOverSize)
    {
        if (pidNode == nullptr || leftOverSize <= 0 || packetSYNC.SingleBitTimingLength <= 0)
        {
            return false;
        }
        lastNRBZDataBit = true;
        uint8_t data;
        if (!DecodeNextByte(pidNode, leftOverSize, data))
        {
            return false;
        }
        // if (pidNode != nullptr) {
        //     pidEndIndex = pidNode.Parent().StartIndex();
        // }

        pid = data;

        if (CommonHelper::EnumIsDefined<Enums::TokenPackageType>(
            static_cast<int>(RealPID())))
        {
            type = Enums::USBPacketType::Token;
        }
        else if (CommonHelper::EnumIsDefined<Enums::DataPackageType>(
            static_cast<int>(RealPID())))
        {
            type = Enums::USBPacketType::Data;
        }
        else if (CommonHelper::EnumIsDefined<Enums::HandshakePackageType>(
            static_cast<int>(RealPID())))
        {
            type = Enums::USBPacketType::HandShake;
        }
        else if (CommonHelper::EnumIsDefined<Enums::SpecialPacketType>(
            static_cast<int>(RealPID())))
        {
            type = Enums::USBPacketType::Special;
        }
        else
        {
            return false;
        }
        return true;
    }

    bool USBPacket::DecodeNextByte(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, uint8_t& outData)
    {
        outData = 0;
        const bool highPolarityEdge = polarity;
        const double singleBitTimingLengthThreshold = packetSYNC.SingleBitTimingLength * 0.95;
        int gotbitCount = 0;
        std::vector<bool> nrzi_data(8, false);

        while (gotbitCount < 8)
        {
            if (node == nullptr || leftOverSize <= 0 || (*node).Edge == Protocol::Edge::None)
            {
                return false;
            }

            if ((*node).EndIndex - (*node).StartIndex >= singleBitTimingLengthThreshold)
            {
                const int bitsCount = static_cast<int>(((*node).EndIndex - (*node).StartIndex) /
                    singleBitTimingLengthThreshold);

                const int lastGotbitCount = gotbitCount;
                for (int i = 0; i < bitsCount; i++)
                {
                    if (lastGotbitCount + i >= 8)
                    {
                        continue;
                    }
                    nrzi_data[lastGotbitCount + i] = highPolarityEdge == ((*node).Edge ==
                        Protocol::Edge::Rise);

                    gotbitCount++;
                }
            }
            leftOverSize--;
            node++;
        }

        for (int i = 0; i < 8; i++)
        {
            if (lastNRBZDataBit != nrzi_data[i])
            {
                lastNRBZDataBit = nrzi_data[i];
            }
            else
            {
                outData |= (1 << i);
            }
        }

        return true;
    }

    void USBPacket::DecodeFields(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, const SYNC& sync)
    {
        if (leftOverSize <= 0)
        {
            return;
        }
        switch (type)
        {
        case Enums::USBPacketType::Token:
            DecodeFieldsByToken(node, leftOverSize, sync);
            break;
        case Enums::USBPacketType::Data:
            DecodeFieldsByData(node, leftOverSize, sync);
            break;
        case Enums::USBPacketType::HandShake:
            DecodeFieldsByHandShake(node, leftOverSize, sync);
            break;
        case Enums::USBPacketType::Special:
            DecodeFieldsBySpecial(node, leftOverSize, sync);
            break;
        default:
            break;
        }
    }

    void USBPacket::DecodeFieldsByToken(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, const SYNC& sync)
    {
        if (type == Enums::USBPacketType::NoDefine)
        {
            return;
        }

        //todo
        auto packageType = static_cast<
            Enums::TokenPackageType>(RealPID());
        switch (packageType)
        {
        case Enums::TokenPackageType::Out:
            break;
        case Enums::TokenPackageType::SOF:
            break;
        case Enums::TokenPackageType::IN:
            break;
        case Enums::TokenPackageType::SETUP:
            break;
        default:
            break;
        }
    }

    void USBPacket::DecodeFieldsByData(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, const SYNC sync)
    {
        if (type == Enums::USBPacketType::NoDefine)
        {
            return;
        }
        auto packageType = static_cast<Enums::DataPackageType>
            (RealPID());
        switch (packageType)
        {
        case Enums::DataPackageType::Data0:
        case Enums::DataPackageType::Data1:
            datas.clear();
            while (node != nullptr && (*node).StartIndex < sync.PacketEndIndex())
            {
                uint8_t data;
                DecodeNextByte(node, leftOverSize, data);
                datas.push_back(data);
            }
            break;
        case Enums::DataPackageType::Data2:
            break;
        case Enums::DataPackageType::MData:
            break;
        default:
            break;
        }
    }

    void USBPacket::DecodeFieldsByHandShake(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, SYNC sync)
    {
        //todo
        if (type != Enums::USBPacketType::HandShake)
        {
            return;
        }
    }

    void USBPacket::DecodeFieldsBySpecial(Protocol::TwoLevelEdgePulse* node, int32_t& leftOverSize, SYNC sync)
    {
        //todo
        if (type != Enums::USBPacketType::Special)
        {
            return;
        }
    }
}