inet::serializer::Ieee80211PhySerializer Class Reference

#include <Ieee80211PhySerializer.h>

Public Member Functions
bool	serialize (const inet::physicallayer::Ieee80211PLCPFrame *plcpHeader, BitVector *serializedPacket) const
inet::physicallayer::Ieee80211PLCPFrame *	deserialize (BitVector *serializedPacket) const

Protected Member Functions
void	writeToBitVector (unsigned char *buf, unsigned int bufSize, BitVector *bitVector) const

Member Function Documentation

Ieee80211PLCPFrame * inet::serializer::Ieee80211PhySerializer::deserialize

(

BitVector *

serializedPacket

)

const

Referenced by inet::physicallayer::Ieee80211LayeredOFDMReceiver::createCompletePacketModel().

{
    // TODO: Revise this code snippet and optimize
    // FIXME: We only have OFDM deserializer
    unsigned char *hdrBuf = new unsigned char[OFDM_PLCP_HEADER_LENGTH];
    const std::vector<uint8>& bitFields = serializedPacket->getBytes();
    for (int i = 0; i < OFDM_PLCP_HEADER_LENGTH; i++)
        hdrBuf[i] = bitFields[i];
    Ieee80211OFDMPLCPHeader *hdr = (Ieee80211OFDMPLCPHeader *) hdrBuf;
    Ieee80211OFDMPLCPFrame *plcpFrame = new Ieee80211OFDMPLCPFrame();
    plcpFrame->setRate(hdr->rate);
    plcpFrame->setLength(hdr->length);
    plcpFrame->setType(OFDM);
    unsigned char *buf = new unsigned char[hdr->length + OFDM_PLCP_HEADER_LENGTH];
    for (int i = 0; i < hdr->length + OFDM_PLCP_HEADER_LENGTH; i++)
        buf[i] = bitFields[i];
    Ieee80211Serializer serializer;
    Buffer subBuffer(buf + OFDM_PLCP_HEADER_LENGTH, hdr->length);
    Context c;
    cPacket *payload = serializer.deserializePacket(subBuffer, c);
    plcpFrame->setBitLength(OFDM_PLCP_HEADER_LENGTH);
    plcpFrame->encapsulate(payload);
//    ASSERT(plcpFrame->getBitLength() == OFDM_PLCP_HEADER_LENGTH + 8 * hdr->length);
    delete[] buf;
    delete[] hdrBuf;
    return plcpFrame;
}

bool inet::serializer::Ieee80211PhySerializer::serialize	(	const inet::physicallayer::Ieee80211PLCPFrame *	plcpHeader,
		BitVector *	serializedPacket
	)		const

Referenced by inet::physicallayer::Ieee80211LayeredOFDMTransmitter::serialize().

{
    if (plcpHeader->getType() == OFDM)
    {
        const Ieee80211OFDMPLCPFrame *ofdmPhyFrame = check_and_cast<const Ieee80211OFDMPLCPFrame *>(plcpHeader);
        unsigned int byteLength = ofdmPhyFrame->getByteLength(); // Byte length of the complete frame
        unsigned char *buf = new unsigned char[byteLength];
        for (unsigned int i = 0; i < byteLength; i++)
            buf[i] = 0;
        Buffer b(buf, byteLength);
        Ieee80211OFDMPLCPHeader *hdr = (Ieee80211OFDMPLCPHeader *) b.accessNBytes(OFDM_PLCP_HEADER_LENGTH);
        ASSERT(hdr);
        hdr->length = ofdmPhyFrame->getLength(); // Byte length of the payload
        hdr->rate = ofdmPhyFrame->getRate();
        hdr->parity = 0; // TODO What is the correct value for this? Check the reference.
        hdr->reserved = 0;
        hdr->service = 0;
        hdr->tail = 0;
        Ieee80211Frame *encapsulatedPacket = check_and_cast<Ieee80211Frame*>(ofdmPhyFrame->getEncapsulatedPacket());
        Ieee80211Serializer ieee80211Serializer;
        // Here we just write the header which is exactly 5 bytes in length.
        Buffer subBuffer(b, b.getRemainingSize());
        Context c;
        ieee80211Serializer.serializePacket(encapsulatedPacket, subBuffer, c);
        b.accessNBytes(subBuffer.getPos());
        unsigned int numOfWrittenBytes = b.getPos();
        // TODO: This assertion must hold!
//        ASSERT(numOfWrittenBytes == byteLength);
        writeToBitVector(buf, numOfWrittenBytes, serializedPacket);
        // KLUDGE: if numOfWrittenBytes != byteLength it causes runtime error at the physical layer
        int pad = byteLength - numOfWrittenBytes;
        if (pad > 0)
            serializedPacket->appendBit(false, pad * 8);
        serializedPacket->appendBit(0, 6); // tail bits
        delete[] buf;
        return true;
    }
    return false;
}

void inet::serializer::Ieee80211PhySerializer::writeToBitVector ( unsigned char *  buf, unsigned int  bufSize, BitVector *  bitVector  ) const

protected

{
    for (unsigned int i = 0; i < bufSize; i++)
    {
        unsigned int currentByte = buf[i];
        for (unsigned int j = 0; j < 8; j++)
        {
            bool currentBit = currentByte & (1 << j);
            bitVector->appendBit(currentBit);
        }
    }
}

---

The documentation for this class was generated from the following files:

• Ieee80211PhySerializer.h
• Ieee80211PhySerializer.cc