device.h

#ifndef _AVRIO_WUSB_DEVICE_H_
#define _AVRIO_WUSB_DEVICE_H_

#include <avrio/defs.h>

__BEGIN_C_DECLS
/* ========================================================================== */
/* macros =================================================================== */
#define WDEV_REGTABLE_SIZEOF(r) (sizeof(r)/sizeof(xWDevRegister))

/* constants ================================================================ */
#define WDEV_MID_SIZEOF 4
#define WDEV_RXSTAT 0
#define WDEV_RXDATA 1
#define WDEV_RXVALID 2

/* enum ===================================================================== */
typedef enum {
  WDEV_RATE_EEPROM = 0,
  WDEV_RATE_16KBPS = 1,
  WDEV_RATE_64KBPS = 2
} eWDevDataRate;

typedef enum {
  WDEV_IDLE   = 0x00,  
  WDEV_TX     = 0x01,  
  WDEV_RX     = 0x02,  
  WDEV_BUSY   = 0x04,  
  WDEV_TXBUSY = (WDEV_TX | WDEV_BUSY)  
} eWDevStatus;

/* structures =============================================================== */
typedef struct xWDevRegister {

  uint8_t Address;  
  uint8_t Value;  
} xWDevRegister;

typedef struct xWDevRegisterTable {

  const struct xWDevRegister * Regs; 
  uint8_t Size; 
} xWDevRegisterTable;

typedef struct xWDevConfig {

  eWDevDataRate pDataRate;  
  int8_t pXtalAdjust;  
} xWDevConfig;

/* == <API> == public application interface  ================================ */
void vWDevInit (eWDevDataRate DataRate);

void vWDevTransmit (const uint8_t * Data, uint8_t Length);

int iWDevReceive (uint8_t * ucUserPacket, uint8_t * ucUserValid, 
                    int iUserBufferSize, int usTimeout);
void vWDevRxCB (uint8_t * Data);

void vWDevEnable (uint8_t Tx);

void vWDevDisable (void);

void vWDevSleep (bool Sleep);

void vWDevSetup (const xWDevRegister * Regs, uint8_t Size);

void vWDevSetup_P (const xWDevRegister * Regs, uint8_t Size);

void vWDevSetupFromTable_P(const xWDevRegisterTable * SetupTable, uint8_t Index);

int8_t iWDevRssi (void);

void vWDevSetCrystal (uint8_t Capacitance);

void vWDevSetX13Out (uint8_t flag);

void vWDevSaveConfigToEEPROM (void);

const uint8_t * pucWDevGetPnCode (void);

#if defined(__DOXYGEN__)

inline void vWDevSetPnCode (const uint8_t * PnCode);

inline void vWDevSetPnCode_P (const uint8_t * PnCode);

inline const uint8_t * pucWDevMid (void);

inline void vWDevSetMid (const uint8_t * Mid);

inline uint8_t ucWDevRevId (void);

inline eWDevDataRate eWDevGetDataRate (void);

inline void vWDevSetDataRate (eWDevDataRate DataRate);

inline void vWDevSetChannel (uint8_t Value);

inline uint8_t ucWDevGetChannel (void);

inline void vWDevSetPaBias (uint8_t Value);

inline uint8_t ucWDevGetPaBias (void);

inline void vWDevSetThresholdLow (uint8_t Value);

inline uint8_t ucWDevGetThresholdLow (void);

inline void vWDevSetThresholdHigh (uint8_t Value);

inline uint8_t ucWDevGetThresholdHigh (void);

inline void vWDevSetSynthLockCount (uint8_t Value);

inline uint8_t ucWDevGetSynthLockCount (void);

inline eWDevStatus eWDevGetStatus (void);

inline void vWDevWaitStatus (eWDevStatus eStatus);

inline uint8_t ucWDevGetCrystal (void);

inline uint8_t ucWDevGetX13Out (void);

inline void vWDevSetReg (uint8_t Address, uint8_t Value);

inline uint8_t ucWDevGetReg (uint8_t Address);

/* == <API-END> == public application interface  ============================ */
#else   /* ! defined(__DOXYGEN__) */
#include <avrio/state.h>
#include <avrio/wusb/net/device/iface.h>

#ifdef AVRIO_WUSB_ENABLE
/* ========================================================================== */
/*                  Implémentation inline (non documentée)                    */
/* ========================================================================== */
#include <string.h>
#include <avr/eeprom.h>

/* structures =============================================================== */
typedef struct xWDevice {

/* private: */
  xState pState; /*< état du module */
  const uint8_t * pTxData; /*< pointeur sur les octets à envoyer */
  uint8_t pTxLength; /*< nombre d'octets pointés par \c pTxData */
  xWDevConfig xConfig; /*< config actuelle du module */
  uint8_t pMid[4]; /*< copie en ram du Mid du module */
} xWDevice;

/* internal public functions ================================================ */
extern void vWDevIdle (void);

/* public variables ========================================================= */
extern xWDevice dDevice;

/* inline public functions ================================================== */

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
vWDevSetReg (uint8_t Reg, uint8_t Value)) {

  vWIfcWrite (Reg, Value);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (uint8_t 
ucWDevGetReg (uint8_t Reg)) {

  return ucWIfcRead (Reg);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (eWDevStatus 
eWDevGetStatus (void)) {

  return (eWDevStatus) xStateGet (&dDevice.pState);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevWaitStatus (eWDevStatus Status)) {

  vStateWait (&dDevice.pState, Status);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (const uint8_t * 
pucWDevMid (void)) {

  return dDevice.pMid;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (eWDevDataRate 
eWDevGetDataRate (void)) {

  return dDevice.xConfig.pDataRate;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevSetDataRate (eWDevDataRate DataRate)) {

  vWDevInit (DataRate);
}

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

  return ucWDevGetReg (REG_CRYSTAL_ADJ) & mCRYSTAL_ADJ;
}

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

  return ucWDevGetReg (REG_CRYSTAL_ADJ) & bCLOCK_DISABLE;
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
vWDevSetPnCode_P (const uint8_t * PnCode)) {

  vWIfcBurstWrite_P (REG_PN_CODE, PnCode, 8);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
vWDevSetPnCode (const uint8_t * PnCode)) {

  vWIfcBurstWrite (REG_PN_CODE, PnCode, 8);
}

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

  return ucWDevGetReg (REG_ID);
}

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

  return ucWDevGetReg (REG_THRESHOLD_L) & mTHRESHOLD_L;
}

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

  return ucWDevGetReg (REG_THRESHOLD_H) & mTHRESHOLD_H;
}

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

  return ucWDevGetReg (REG_CHANNEL) & mCHANNEL;
}

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

  return ucWDevGetReg (REG_PA) & mPA_BIAS;
}

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

  return ucWDevGetReg (REG_SYN_LOCK_CNT);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevSetThresholdLow (uint8_t Value)) {

  vWDevSetReg (REG_THRESHOLD_L, Value & mTHRESHOLD_L);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevSetThresholdHigh (uint8_t Value)) {

  vWDevSetReg (REG_THRESHOLD_H, Value & mTHRESHOLD_H);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevSetChannel (uint8_t Value)) {

  vWDevIdle ();
  vWDevSetReg (REG_CHANNEL, Value & mCHANNEL);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void 
vWDevSetPaBias (uint8_t Value)) {

  vWDevSetReg (REG_PA, Value & mPA_BIAS);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
vWDevSetSynthLockCount (uint8_t Value)) {

  vWDevSetReg (REG_SYN_LOCK_CNT, Value);
}

// -----------------------------------------------------------------------------
__STATIC_ALWAYS_INLINE (void
vWDevSetMid (const uint8_t * Mid)) {

  memcpy (&dDevice.pMid, Mid, WDEV_MID_SIZEOF);
}
#endif /* AVRIO_WUSB_ENABLE defined */
#endif  /* __DOXYGEN__ not defined */

/* ========================================================================== */
__END_C_DECLS
#endif  /* _AVRIO_WUSB_DEVICE_H_ */