packet.h

#ifndef _AVRIO_WUSB_PACKET_H_
#define _AVRIO_WUSB_PACKET_H_

#include <avrio/defs.h>

__BEGIN_C_DECLS
/* ========================================================================== */
/* == <API> == public application interface  ========class xWusbPacket======== */
/* constants ================================================================ */

# define WPKT_BIND_CHECKSUM_SEED    0x00

# define WPKT_BIND_CRC_SEED         0x0000

/* types ==================================================================== */
typedef enum  {

  WPKT_SINGLE = 0,
  WPKT_ACK = 1,
  WPKT_SYNC = 2,
  WPKT_TOGGLE = 3,
  WPKT_VALID = 2,
  WPKT_RESP = 3,
  WPKT_BCAST = 2
} eWPktFlag;

typedef enum {

  WPKT_BIND_REQUEST_PACKET = 0x00,
  WPKT_BIND_RESPONSE_PACKET = 0x01,
  WPKT_PING_PACKET = 0x02,
  WPKT_ACK_PACKET = 0x03,
  WPKT_DATA_PACKET = 0x04,
  NO_PACKET = 0x0F
} eWPktType;

/* structures =============================================================== */
typedef struct xWusbPacket {

  uint8_t xSize;    
  uint8_t xLen;     
  uint8_t * pData;  
} xWusbPacket;
 
#if defined(__DOXYGEN__)
/* constants ================================================================ */
# define WPKT_PING_PACKET_SIZE

# define WPKT_BINDREQ_PACKET_SIZE

# define WPKT_DID_OFFSET

# define WPKT_MID_OFFSET

/* macros =================================================================== */
# define WPKT_DECLARE(xVarName, xBufferSize)

# define WPKT_STATIC_DECLARE(xVarName, xBufferSize)

inline void vWPktInit(xWusbPacket * pxPkt, uint8_t * pucBuffer, uint8_t ucBufferSize);

void vWPktPrepare(xWusbPacket * pxPkt, uint8_t ucHeader);

inline void vWPktClear(xWusbPacket * pxPkt);

uint8_t ucWPktByte(xWusbPacket * pxPkt, uint8_t Offset);

void vWPktSetByte(xWusbPacket * pxPkt, uint8_t Offset, uint8_t ucValue);

void vWPktAddByte(xWusbPacket * pxPkt, uint8_t ucValue);

void vWPktAddBytes(xWusbPacket * pxPkt, const uint8_t * pucBytes, uint8_t ucLength);

void vWPktAddBytes_P(xWusbPacket * pxPkt, const uint8_t * pucBytes, uint8_t ucLength);

void vWPktAddStr(xWusbPacket * pxPkt, const char* pcStr);

void vWPktAddStr_P(xWusbPacket * pxPkt, const char* pcStr);

uint16_t usWPktWord(xWusbPacket * pxPkt, uint8_t Offset);

void vWPktAddWord(xWusbPacket * pxPkt, uint16_t usValue);

uint32_t ulWPktDword(xWusbPacket * pxPkt, uint8_t Offset);

inline uint8_t ucWPktHeader(xWusbPacket * pxPkt);

inline void vWPktSetHeader(xWusbPacket * pxPkt, uint8_t ucValue);

uint8_t ucWPktType(xWusbPacket * pxPkt);

void vWPktSetType(xWusbPacket * pxPkt, uint8_t ucValue);

inline bool xWPktFlag(xWusbPacket * pxPkt, uint8_t ucIndex);

inline void vWPktSetFlag(xWusbPacket * pxPkt, uint8_t ucIndex, bool xValue);

bool xWPktSetAllFlags(xWusbPacket * pxPkt, uint8_t ucFlags);

inline void vWPktToggleFlag(xWusbPacket * pxPkt, uint8_t ucIndex);

void vWPktAddTrailer (xWusbPacket * pxPkt, uint8_t CrcSeed, uint8_t ChecksumSeed);

inline uint8_t * pucWPktRaw(xWusbPacket * pxPkt);

uint8_t * pucWPktDataPayload(xWusbPacket * pxPkt);

uint8_t xWPktDataPayloadLength(xWusbPacket * pxPkt);

inline bool xWPktIsFull(xWusbPacket * pxPkt);

inline bool xWPktIsEmpty(xWusbPacket * pxPkt);

inline uint8_t xWPktLength(xWusbPacket * pxPkt);

inline uint8_t xWPktSize(xWusbPacket * pxPkt);

bool xWPktCheckAndRepair(xWusbPacket * pxPkt, xWusbPacket * Valid, uint8_t CrcSeed, uint8_t ChecksumSeed);

uint16_t usWPktCrc (const uint8_t * pData, uint8_t ucLength, uint16_t Seed);

uint8_t ucWPktChecksum (const uint8_t * pData, uint8_t ucLength, uint8_t Seed);

bool xWPktBit(uint8_t Byte, uint8_t Bit);

void vWPktSetBit(uint8_t * Byte, uint8_t Bit, bool xValue);
/* == <API-END> == public application interface  ====class xWusbPacket======== */
#else  /* __DOXYGEN__ defined */
# include "wusb-config.h"
# include <avr/pgmspace.h>

/* constants ================================================================ */

/* Packet sizes */
# define WPKT_HEADER_SIZE           1 /* Type + ucFlags */
# define WPKT_MID_SIZE              4
# define WPKT_CRC_SIZE              2
# define WPKT_CS_SIZE               1
# define WPKT_TRAILER_SIZE          (WPKT_CRC_SIZE + WPKT_CS_SIZE)
# define WPKT_BROADCAST_PACKET_SIZE (WPKT_HEADER_SIZE + WPKT_TRAILER_SIZE)
# define WPKT_PING_PACKET_SIZE      (WPKT_BROADCAST_PACKET_SIZE)
# define WPKT_BINDREQ_PACKET_SIZE     (WPKT_BROADCAST_PACKET_SIZE + WPKT_MID_SIZE)

/* Offsets */
# define WPKT_DID_OFFSET             WPKT_HEADER_SIZE
# define WPKT_MID_OFFSET             WPKT_HEADER_SIZE  /* Pour BIND_REQUEST */

/* Tailles dépendantes de la taille du device id */
# define WPKT_DID_SIZE_MAX          2
# define WPKT_NULL_DATA_PACKET_SIZE_MAX (WPKT_BROADCAST_PACKET_SIZE + WPKT_DID_SIZE_MAX)
# define WPKT_WPKT_ACK_PACKET_SIZE_MAX        WPKT_NULL_DATA_PACKET_SIZE_MAX
# define WPKT_BIND_RESPONSE_SIZE_MAX    (WPKT_NULL_DATA_PACKET_SIZE_MAX + WPKT_MID_SIZE + 2)

/* macros =================================================================== */
# define WPKT_PACKET_SIZE_MAX(PayloadSize) ( \
                                      WPKT_NULL_DATA_PACKET_SIZE_MAX + \
                                      PayloadSize)


// -----------------------------------------------------------------------------
# define WPKT_DECLARE(__name,__size)                 \
  uint8_t __name ## Buffer[__size];                  \
  xWusbPacket __name = { .pData  = __name ## Buffer, \
                         .xSize  = __size,           \
                         .xLen   = 0 }

// -----------------------------------------------------------------------------
# define WPKT_STATIC_DECLARE(__name,__size)                 \
  static uint8_t __name ## Buffer[__size];                  \
  static xWusbPacket __name = { .pData  = __name ## Buffer, \
                                .xSize  = __size }

  /* Checked = Ok */ uint8_t   ucWPktByte(xWusbPacket *, uint8_t);
  /* Checked = Ok */ void      vWPktSetByte(xWusbPacket *, uint8_t, uint8_t);
  /* Checked = Ok */ void      vWPktAddByte(xWusbPacket * pxPkt, uint8_t ucValue);
  /* Checked = Ok */ void      vWPktAddBytes(xWusbPacket * pxPkt, const uint8_t * pucBytes, uint8_t ucLength);
  /* Checked = Ok */ void      vWPktAddStr(xWusbPacket * pxPkt, const char* pcStr);
  /* Checked = Ok */ void      vWPktAddBytes_P(xWusbPacket * pxPkt, const uint8_t * pucBytes, uint8_t ucLength);
  /* Checked = Ok */ void      vWPktAddStr_P(xWusbPacket * pxPkt, const char* pcStr);
  /* Checked = Ok */ uint8_t * pucWPktCurrentByte (xWusbPacket * pxPkt);

  /* Checked = Ok */ uint16_t  usWPktWord(xWusbPacket * pxPkt, uint8_t Offset);
  /* Checked = Ok */ void      vWPktAddWord(xWusbPacket * pxPkt, uint16_t usValue);

  /* Checked = Ok */ uint32_t  ulWPktDword(xWusbPacket * pxPkt, uint8_t Offset);

  /* Checked = Ok */ bool      xWPktBit(uint8_t Byte, uint8_t Bit);
  /* Checked = Ok */ void      vWPktSetBit(uint8_t * Byte, uint8_t Bit, bool xValue);

  /* Checked = Ok */ uint8_t   ucWPktType(xWusbPacket *);
  /* Checked = Ok */ void      vWPktSetType(xWusbPacket *, uint8_t);
  void      xWPktSetAllFlags(xWusbPacket *, uint8_t);

  uint8_t * pucWPktDataPayload(xWusbPacket * pxPkt);
  uint8_t   xWPktDataPayloadLength(xWusbPacket * pxPkt);

  /* Checked = Ok */ uint16_t  usWPktCrc (const uint8_t * pData, uint8_t ucLength, uint16_t Seed);
  /* Checked = Ok */ uint8_t   ucWPktChecksum (const uint8_t * pData, uint8_t ucLength, uint8_t Seed);
  /* Checked = Ok */ void      vWPktAddTrailer (xWusbPacket * pxPkt, uint8_t CrcSeed, uint8_t ChecksumSeed);
  /* Checked = Ok */ bool      xWPktCheckAndRepair(xWusbPacket * pxPkt, xWusbPacket * Valid, uint8_t CrcSeed, uint8_t ChecksumSeed);
  
  // ---------------------------------------------------------------------------
  __STATIC_ALWAYS_INLINE (void 
  vWPktInit(xWusbPacket * pxPkt, uint8_t * pucBuffer, uint8_t ucBufferSize)) {
  
    pxPkt->pData = pucBuffer;
    pxPkt->xSize = ucBufferSize;
    pxPkt->xLen  = 0;  
  }
  
  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (uint8_t * 
  pucWPktRaw(xWusbPacket * pxPkt)) {
  
    return pxPkt->pData;
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (uint8_t 
    xWPktLength(xWusbPacket * pxPkt)) {

    return pxPkt->xLen;
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (uint8_t 
    xWPktSize(xWusbPacket * pxPkt)) {

    return pxPkt->xSize;
  }

   // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (void 
    vWPktClear(xWusbPacket * pxPkt)) {

    pxPkt->xLen = 0;
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (void 
    vWPktPrepare(xWusbPacket * pxPkt, uint8_t ucHeader)) {

    vWPktClear (pxPkt);
    vWPktAddByte (pxPkt, ucHeader); 
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (bool 
    xWPktIsFull(xWusbPacket * pxPkt)) {

    return (pxPkt->xLen == pxPkt->xSize);
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (bool 
    xWPktIsEmpty(xWusbPacket * pxPkt)) {

    return (pxPkt->xLen == 0);
  }

  // ---------------------------------------------------------------------------
  __STATIC_ALWAYS_INLINE (void 
    vWPktSetHeader(xWusbPacket * pxPkt, uint8_t ucValue)) {

    vWPktSetByte (pxPkt, 0, ucValue); 
  }

  // ---------------------------------------------------------------------------
  __STATIC_ALWAYS_INLINE (uint8_t 
  ucWPktHeader(xWusbPacket * pxPkt)) {

    return ucWPktByte(pxPkt, 0);
  }

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (void 
    vWPktSetFlag(xWusbPacket * pxPkt, uint8_t ucIndex, bool xValue)) {
    
    vWPktSetBit (pxPkt->pData, ucIndex, xValue);
  } 

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (void 
    vWPktToggleFlag(xWusbPacket * pxPkt, uint8_t ucIndex)) {

    *pxPkt->pData ^= _BV(ucIndex);
  } 

  // ---------------------------------------------------------------------------
  /* Checked = Ok */ __STATIC_ALWAYS_INLINE (bool 
    xWPktFlag(xWusbPacket * pxPkt, uint8_t ucIndex)) {

    return (*pxPkt->pData & _BV(ucIndex)) != 0;
  } 

# ifdef DEBUG_ONUART
  void vWPktDbgDump (xWusbPacket * pxPkt);
# else
#  define vWPktDbgDump(p)
# endif  /* DEBUG_ONUART defined */

# ifdef WUSB_WPKT_TEST
  int iWPktTest(void);
# else   /* WUSB_WPKT_TEST defined */
#  define iWPktTest() (0)
# endif  /* WUSB_WPKT_TEST defined */

#endif  /* __DOXYGEN__ defined */
/* ========================================================================== */
__END_C_DECLS
#endif  /* _AVRIO_WUSB_PACKET_H_ */