avrio/wusb/sensor.h

#ifndef _AVRIO_WUSB_SENSOR_H_
#define _AVRIO_WUSB_SENSOR_H_

#include <avrio/wusb/net/network.h>

__BEGIN_C_DECLS
/* ========================================================================== */
/* constants ================================================================ */
typedef enum {

  WSENSOR_EEPROMBLANK     = 0,  
  /* Mode */
  WSENSOR_AUTOSEEDEDBIND  = 1, 
  /* Bit 2 dispo. */
  /* Status */
  WSENSOR_NACK            = 3, 
  WSENSOR_CHANSEARCH      = 4, 
  WSENSOR_BACKDATA        = 5, 
  WSENSOR_BINDING         = 6, 
  WSENSOR_BOUND           = 7  
} eWSensorFlags;

typedef enum {

  WSENSOR_SUCCESS      =  WNET_SUCCESS,  
  /* Erreur < 0 */
  WSENSOR_NACK_TIMEOUT =  WNET_TIMEOUT, 
  WSENSOR_PACKET_ERROR =  WNET_CORRUPTED_PACKET_ERROR, 
  WSENSOR_NODE_UNBOUND   = (WNET_LAST_ERROR - 1), 
  WSENSOR_NODE_REBOUND   = (WNET_LAST_ERROR - 2), 
  WSENSOR_SEARCH_TIMEOUT = (WNET_LAST_ERROR - 3), 
  WSENSOR_BIND_TIMEOUT   = (WNET_LAST_ERROR - 4) 
} eWSensorError;

/* == <API> == public application interface  ========class xWusbSensor======== */

void vWSensorInit(eWDevDataRate DataRate);

void vWSensorBind(bool Seeded);

void vWSensorSleepCB (eWSensorError eError);

#if defined(__DOXYGEN__)

void vWSensorDataClear(void);

inline void vWSensorDataAddByte(uint8_t ucByte);

inline void vWSensorDataAddWord(uint16_t ucWord);

inline void vWSensorDataAddBytes(const uint8_t * pucData, uint8_t ucLength);

inline void vWSensorDataAddBytes_P(const uint8_t * pucData, uint8_t ucLength);

inline void vWSensorDataAddStr(const char * pcStr);

inline void vWSensorDataAddStr_P(const char * pcStr);

int iWSensorDataSend(bool Synchronous);

uint8_t * pucWSensorBackDataPayload (void);

uint8_t ucWSensorBackDataPayloadLength (void);

inline bool xWSensorBound (void);

inline void vWSensorSetAutoSeededBind (bool xEnable);

inline bool xWSensorAutoSeededBind (void);

inline bool xWSensorFlag(eWSensorFlags eFlag);

inline uint16_t usWSensorDeviceId(void);

inline void vWSensorSleep (bool xSleep);

/* == <API-END> == public application interface  ====class xWusbSensor======== */
#else /* __DOXYGEN__ defined */

/* structures =============================================================== */
/*
 * @struct xWSensorConfig
 * @brief Configuration d'un capteur
 */  
typedef struct xWSensorConfig {

  uint16_t usDeviceId; /*< Identifiant attribué par le hub */
  uint8_t ucFlags; /*< Bits d'états et de mode */
} xWSensorConfig;

/*
 * @struct xWusbSensor
 * @brief Classe capteur d'un réseau WirelessUSB&tm;
 */ 
typedef struct xWusbSensor {

  uint8_t ucPktBits; /*< Drapeaux transmis dans l'entête de paquet */
  xWSensorConfig xConfig;  /*< Configuration */
} xWusbSensor;

/* internal public functions ================================================ */
void vWSensorDataClear(void);
int iWSensorDataSend(bool Synchronous);
uint8_t * pucWSensorBackDataPayload (void);
uint8_t ucWSensorBackDataPayloadLength (void);

/* public variables ========================================================= */
extern xWusbSensor dSensor;

/* inline public functions ================================================== */
__STATIC_ALWAYS_INLINE (void 
vWSensorSleep (bool xSleep)) {

  vWDevSleep (xSleep);
}

__STATIC_ALWAYS_INLINE (bool 
xWSensorFlag (eWSensorFlags eFlag)) {

  return xWPktBit (dSensor.xConfig.ucFlags, eFlag);
}

__STATIC_ALWAYS_INLINE (bool 
xWSensorBound (void)) {
  
  return xWSensorFlag (WSENSOR_BOUND);
}

__STATIC_ALWAYS_INLINE (bool 
xWSensorAutoSeededBind (void)) {

  return xWSensorFlag (WSENSOR_AUTOSEEDEDBIND);
}

__STATIC_ALWAYS_INLINE (uint16_t 
usWSensorDeviceId(void)) {

  return  dSensor.xConfig.usDeviceId;
}

__STATIC_ALWAYS_INLINE (void 
vWSensorSetFlag (eWSensorFlags eFlag, bool xValue)) {

    vWPktSetBit (&dSensor.xConfig.ucFlags, eFlag, xValue);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorSetAutoSeededBind (bool xEnable)) {

  vWSensorSetFlag (xEnable, WSENSOR_AUTOSEEDEDBIND);
}

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

  vWNetTxPktAddByte (ucByte);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorDataAddWord(uint16_t usWord)) {

  vWNetTxPktAddWord (usWord);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorDataAddBytes(const uint8_t * pucData, uint8_t ucLength)) {

  vWNetTxPktAddBytes (pucData, ucLength);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorDataAddBytes_P(const uint8_t * pucData, uint8_t ucLength)) {

  vWNetTxPktAddBytes_P (pucData, ucLength);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorDataAddStr(const char * pcStr)) {

  vWNetTxPktAddStr (pcStr);
}

__STATIC_ALWAYS_INLINE (void 
vWSensorDataAddStr_P(const char * pcStr)) {

  vWNetTxPktAddStr_P (pcStr);
}

#ifdef WSENSOR_TEST
  int iSensorTestPing (uint16_t usCount, uint16_t usInterval, 
                        xWNetTestResult * pxResult);
#else   /* WSENSOR_TEST not defined */
# define iSensorTestPing(c,i,r) (0)
#endif  /* WSENSOR_TEST defined */

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