network.h

#ifndef _AVRIO_WUSB_NETWORK_H_
#define _AVRIO_WUSB_NETWORK_H_

#include <avrio/task.h>
#include <avrio/state.h>
#include <avrio/wusb/net/device/device.h>
#include <avrio/wusb/net/packet.h>

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

#define WNET_MAJOR  1

#define WNET_MINOR  0

#define WNET_VERSION  "1.0"

/* == <API> == public application interface  ========class WusbNetwork======= */
#define WNET_BIND_PNCODE  0

#define WNET_BIND_CHANNEL 0

#define WNET_INVALID_DEVICEID 0xFFFF

typedef enum {

  WNET_SUCCESS  = 0, 
  WNET_TIMEOUT  = -1, 
  WNET_CORRUPTED_PACKET_ERROR = -2, 
  WNET_LAST_ERROR = WNET_CORRUPTED_PACKET_ERROR
} eWNetErrorCode;

typedef enum  {

  /* Etat  */
  WNET_EEPROMBLANK  = 0,  
  /* Contrôle  */
  WNET_SINGLEBYTE   = 1  
} eWNetStatusCode;

typedef struct xWNetConfig {

  uint8_t ucChannel;      
  uint8_t ucPnCode;       
  uint8_t ucChecksumSeed; 
  uint8_t ucCrcSeed;      
  uint8_t ucStatus;       
} xWNetConfig;

#if defined(__DOXYGEN__)

void vWNetInit(eWDevDataRate eDataRate);

inline const xWNetConfig * pxWNetCurrentConfig(void);

void vWNetSetConfig(const xWNetConfig * pxConfig);

void vWNetSaveConfigToEEPROM(void);

inline void vWNetTxPktSend(void);

void vWNetTxPktAddTrailer (void);

void vWNetTxPktNew (uint8_t ucPacketType);

inline void vWNetTxPktSetType (uint8_t ucPacketType);

inline void vWNetTxPktSetHeader (uint8_t ucHeader);

inline void vWNetTxPktSetFlag (uint8_t ucIndex, bool ucValue);

inline void vWNetTxPktToggleFlag (uint8_t ucIndex);

inline void vWNetTxPktSetAllFlags (uint8_t ucFlags);

void vWNetTxPktAddDeviceId (uint16_t usDeviceId);

inline void vWNetTxPktAddByte (uint8_t ucByte);

inline void vWNetTxPktAddWord (uint16_t usWord);

inline void vWNetTxPktAddBytes (const uint8_t * pucBytes, uint8_t ucLength);

inline void vWNetTxPktAddBytes_P (const uint8_t * pucBytes, uint8_t ucLength);

inline void vWNetTxPktAddStr (const char * pcStr);

inline void vWNetTxPktAddStr_P (const char * pcStr);

inline xWusbPacket * pxWNetTxPacket (void);

eWNetErrorCode eWNetRxPktWait(int16_t iTimeoutMs);

inline uint8_t ucWNetAckTimeout (void);

inline uint8_t ucWNetBindTimeout (void);

inline uint8_t ucWNetPingTimeout (void);

inline uint8_t ucWNetRxPktType (void);

inline uint8_t ucWNetRxPktHeader (void);

inline bool xWNetRxPktFlag (uint8_t ucIndex);

inline uint8_t ucWNetRxPktByte (uint8_t ucOffset);

inline uint16_t usWNetRxPktWord (uint8_t ucOffset);

inline uint32_t ulWNetRxPktDword (uint8_t ucOffset);

inline uint8_t * pucWNetRxPktBytes (uint8_t ucOffset);

uint16_t usWNetRxPktDeviceId (void);

inline uint8_t * pucWNetRxPktDataPayload (void);

inline uint8_t ucWNetRxPktDataPayloadLength (void);

inline xWusbPacket * pxWNetRxPacket (void);

inline uint8_t ucWNetChannel(void);

bool xWNetSetChannel(uint8_t ucIndex);

void vWNetGoToNextChannel(void);

inline uint8_t ucWNetNumberOfChannelsUsed (void);

inline uint8_t ucWNetNumberOfSubsets (void);

inline uint8_t ucWNetPnCode(void);

bool xWNetSetPnCode(uint8_t ucValue);

uint8_t ucWNetNumberOfPnCodes (void);

inline uint8_t ucWNetChecksumSeed(void);

inline void vWNetSetChecksumSeed(uint8_t ucValue);

inline uint8_t ucWNetCrcSeed(void);

inline void vWNetSetCrcSeed(uint8_t ucValue);

inline bool xWNetStatus (eWNetStatusCode eFlag);

void vWNetSetStatus (eWNetStatusCode eFlag, bool ucValue);

void vWNetToggleStatus (eWNetStatusCode eFlag);

inline bool xWNetSingleByteDeviceId (void);

inline void vWNetSetSingleByteDeviceId (bool xEnable);

inline eWNetErrorCode eWNetError(void);

inline void vWNetWaitIdle (void);

uint8_t ucWNetRand (void);

/* == <API-END> == public application interface  ====class WusbNetwork======= */
#else /* __DOXYGEN__ defined */
# include "wusb-config.h"

/* constants ================================================================ */
/*---- Channel configuration table -------------------------------------------*/
#if WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 1
 #define WNET_NUM_OF_SUBSETS          6
 #define WNET_NUM_OF_CH_PER_SUBSET    13
 #define WNET_NUM_OF_CH_USED          78
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 2
 #define WNET_NUM_OF_SUBSETS          7
 #define WNET_NUM_OF_CH_PER_SUBSET    11
 #define WNET_NUM_OF_CH_USED          77
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 3
 #define WNET_NUM_OF_SUBSETS          8
 #define WNET_NUM_OF_CH_PER_SUBSET    9
 #define WNET_NUM_OF_CH_USED          72
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 4
 #define WNET_NUM_OF_SUBSETS          9
 #define WNET_NUM_OF_CH_PER_SUBSET    8
 #define WNET_NUM_OF_CH_USED          72
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 5
 #define WNET_NUM_OF_SUBSETS          10
 #define WNET_NUM_OF_CH_PER_SUBSET    7
 #define WNET_NUM_OF_CH_USED          70
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 6
 #define WNET_NUM_OF_SUBSETS          11
 #define WNET_NUM_OF_CH_PER_SUBSET    7
 #define WNET_NUM_OF_CH_USED          77
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 7
 #define WNET_NUM_OF_SUBSETS          12
 #define WNET_NUM_OF_CH_PER_SUBSET    6
 #define WNET_NUM_OF_CH_USED          72
#elif WUSB_CONFIG_NETWORK_CHANNEL_CONFIG == 8
 #define WNET_NUM_OF_SUBSETS          13
 #define WNET_NUM_OF_CH_PER_SUBSET    6
 #define WNET_NUM_OF_CH_USED          78
#else
 #error Unsupported CHANNEL_CONFIG value
#endif

/* structures =============================================================== */
typedef struct WusbNetwork {

  xWusbPacket pxRxPacket;
  xWusbPacket pxRxValid;
  xWusbPacket pxTxPacket;
  uint16_t usCorruptError;
  xTaskHandle xTimeoutTask;
  xState xRxStatus;
  xState xError;
  xWNetConfig xConfig;
} WusbNetwork;

/* internal public functions ================================================ */
void vWNetInit(eWDevDataRate eDataRate);
void vWNetSetConfig(const xWNetConfig * pxConfig);
void vWNetSaveConfigToEEPROM(void);
bool xWNetSetChannel(uint8_t ucValue);
void vWNetGoToNextChannel(void);
bool xWNetSetPnCode(uint8_t ucValue);
void vWNetTxPktNew (uint8_t ucType);
void vWNetTxPktAddDeviceId (uint16_t usDeviceId);
void vWNetTxPktAddTrailer (void);
eWNetErrorCode eWNetRxPktWait(int16_t iTimeoutMs);
uint16_t usWNetRxPktDeviceId (void);
uint8_t ucWNetRand (void);
uint8_t ucWNetNumberOfPnCodes (void);

/* public variables ========================================================= */
extern WusbNetwork dNet;

/* inline public functions ================================================== */
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktSend(void)) {

  vWDevTransmit (pucWPktRaw (&dNet.pxTxPacket), xWPktLength (&dNet.pxTxPacket));
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t
  ucWNetAckTimeout (void)) {

  return (WUSB_CONFIG_NETWORK_DEFAULT_TIMEOUT_ACK * (3-eWDevGetDataRate()));
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetBindTimeout (void)) {

  return (WUSB_CONFIG_NETWORK_DEFAULT_TIMEOUT_BIND * (3-eWDevGetDataRate()));
}

__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetPingTimeout (void)) {

  return (WUSB_CONFIG_NETWORK_DEFAULT_TIMEOUT_PING * (3-eWDevGetDataRate()));
}

/*------------ Getters Net Config -------------*/
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetWaitIdle (void)) {

  vWDevWaitStatus (WDEV_IDLE);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (const xWNetConfig * 
  pxWNetCurrentConfig(void)) {

  return &dNet.xConfig;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetChannel(void)) {

  return dNet.xConfig.ucChannel;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetChecksumSeed(void)) {

  return dNet.xConfig.ucChecksumSeed;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetCrcSeed(void)) {

  return dNet.xConfig.ucCrcSeed;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetPnCode(void)) {

  return dNet.xConfig.ucPnCode;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (bool 
  xWNetStatus (eWNetStatusCode eFlag)) {

  return xWPktBit (dNet.xConfig.ucStatus, eFlag);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (bool 
  xWNetSingleByteDeviceId (void)) {

  return xWNetStatus (WNET_SINGLEBYTE);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t
  ucWNetNumberOfChannelsUsed (void)) {

  return WNET_NUM_OF_CH_USED;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t
  ucWNetNumberOfSubsets (void)) {

  return WNET_NUM_OF_SUBSETS;
}

/*------------ Getters Net Error -------------*/
__STATIC_ALWAYS_INLINE (eWNetErrorCode 
  eWNetError(void)) {

  return (eWNetErrorCode) xStateGet(&dNet.xError);
}

/*------------ Getters Net Tx Packet -------------*/
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (xWusbPacket * 
  pxWNetTxPacket(void)) {
  
  return &dNet.pxTxPacket;
}

/*------------ Getters Net Rx Packet -------------*/
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (xWusbPacket * 
  pxWNetRxPacket(void)) {

  return &dNet.pxRxPacket;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetRxPktType (void)) {

  return ucWPktType (pxWNetRxPacket());
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetRxPktHeader (void)) {

  return ucWPktHeader (pxWNetRxPacket());
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (bool 
  xWNetRxPktFlag (uint8_t ucIndex)) {

  return xWPktFlag (pxWNetRxPacket(), ucIndex);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetRxPktByte (uint8_t ucOffset)) {

  return ucWPktByte (pxWNetRxPacket(), ucOffset);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint16_t 
  usWNetRxPktWord (uint8_t ucOffset)) {

  return usWPktWord (pxWNetRxPacket(), ucOffset);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint32_t 
  ulWNetRxPktDword (uint8_t ucOffset)) {

  return ulWPktDword (pxWNetRxPacket(), ucOffset);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t * 
  pucWNetRxPktBytes (uint8_t ucOffset)) {

  return &pucWPktRaw(pxWNetRxPacket())[ucOffset];

}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t * 
  pucWNetRxPktDataPayload (void)) {

  return pucWPktDataPayload (pxWNetRxPacket());
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
  ucWNetRxPktDataPayloadLength (void)) {

  return xWPktDataPayloadLength (pxWNetRxPacket());
}

/*------------ Setters Net Config -------------*/
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
  vWNetSetChecksumSeed(uint8_t ucValue)) {

  dNet.xConfig.ucChecksumSeed = ucValue;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWNetSetCrcSeed(uint8_t ucValue)) {

  dNet.xConfig.ucCrcSeed = ucValue;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetSetStatus (eWNetStatusCode eFlag, bool ucValue)) {

  vWPktSetBit (&dNet.xConfig.ucStatus, eFlag, ucValue);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetSetSingleByteDeviceId (bool xEnable)) {

  vWNetSetStatus (WNET_SINGLEBYTE, xEnable);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetToggleStatus (eWNetStatusCode eFlag)) {

  dNet.xConfig.ucStatus ^= 1<<eFlag;
}

/*------------ Setters Net Tx Packet -------------*/
// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddByte (uint8_t ucByte)) {

  vWPktAddByte (pxWNetTxPacket(), ucByte);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddBytes (const uint8_t * pucBytes, uint8_t ucLength)) {

  vWPktAddBytes (pxWNetTxPacket(), pucBytes, ucLength);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddBytes_P (const uint8_t * pucBytes, uint8_t ucLength)) {

  vWPktAddBytes_P (pxWNetTxPacket(), pucBytes, ucLength);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddStr (const char * pcStr)) {

  vWPktAddStr (pxWNetTxPacket(), pcStr);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddStr_P (const char * pcStr)) {

  vWPktAddStr_P (pxWNetTxPacket(), pcStr);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktAddWord (uint16_t usWord)) {

  vWPktAddWord (pxWNetTxPacket(), usWord);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktSetAllFlags (uint8_t ucFlags)) {

  xWPktSetAllFlags (pxWNetTxPacket(), ucFlags);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktSetFlag (uint8_t ucIndex, bool ucValue)) {

  vWPktSetFlag (pxWNetTxPacket(), ucIndex, ucValue);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWNetTxPktSetHeader (uint8_t ucHeader)) {

  vWPktSetHeader (pxWNetTxPacket(), ucHeader);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktSetType (uint8_t ucPacketType)) {

  vWPktSetType (pxWNetTxPacket(), ucPacketType);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
  vWNetTxPktToggleFlag (uint8_t ucIndex)) {

  vWPktToggleFlag (pxWNetTxPacket(), ucIndex);
}

/* ========================================================================== */
/*                     Tests unitaires (non documentés)                       */
/* ========================================================================== */
/* structures =============================================================== */
  typedef struct xWNetTestResult {

    uint16_t usSended;
    uint16_t usReceived;
    uint16_t usCorrupted;
  } xWNetTestResult;

#ifdef WNET_TEST
/* internal public functions ================================================ */
  int iWNetTestSetup (void);
  
  /*
   * Attends un paquet:
   * - Si paquet correct reçu, vérifie le type:
   *  - Si le type est un WPKT_DATA_PACKET, un WPKT_ACK_PACKET est renvoyé (V=1)
   *  - Si le type est un WPKT_BIND_REQUEST_PACKET, un WPKT_BIND_RESPONSE_PACKET
   *   est renvoyé
   *  - Pour les autres types, ne renvoie rien   
   * - Si paquet incorrect, ne fait rien
   * @return true si paquet correct reçu     
   */   
  eWNetErrorCode eWNetTestHub (int16_t iTimeoutMs);
  /*
   * Envoi paquet DATA et attends la réponse HUB en recommancant tant que le HUB
   * n'a pas répondu correctement.
   */ 
  eWNetErrorCode eWNetTestSensorPing (uint16_t usCount, uint16_t usInterval, 
                                                  xWNetTestResult * pxResult);
  /*
   * Envoi paquet BIND_REQUEST et attends réponse HUB en recommancant tant que 
   * le HUB n'a pas répondu correctement.
   */ 
  eWNetErrorCode eWNetTestSensorBind (uint16_t usMaxRetries, uint16_t usInterval, 
                                                  xWNetTestResult * pxResult);
#else   /* WNET_TEST defined */
  #define iWNetTestSetup() (0)
  #define eWNetTestHub(t) (WNET_SUCCESS)
  #define eWNetTestSensorPing(c,i,r) (WNET_SUCCESS)
  #define eWNetTestSensorBind(m,i,r) (WNET_SUCCESS)
#endif  /* WNET_TEST defined */

#ifdef WNET_DEBUG_ONUART
  void vWNetDbgDumpConfig(void);
  void vWNetDbgDumpRxPacket(void);
  void vWNetDbgDumpTxPacket(void);
  void vWNetDbgNoResp(void);
  void vWNetDbgSend(void);
#else
  #define vWNetDbgDumpConfig()
  #define vWNetDbgDumpRxPacket()
  #define vWNetDbgDumpTxPacket()
  #define vWNetDbgNoResp()
  #define vWNetDbgSend()
#endif  /* WNET_DEBUG_ONUART defined */

#endif  /* __DOXYGEN__ not defined */
/* ========================================================================== */
__END_C_DECLS
#endif  /* _AVRIO_WUSB_NETWORK_H_ */