afsk.h

#ifndef _AVRIO_AFSK_H_
#define _AVRIO_AFSK_H_

#include <avrio/defs.h>

__BEGIN_C_DECLS
/* ========================================================================== */
#include <stdio.h>
#include <avrio/hdlc.h>

/* constants ================================================================ */
#define AFSK_RXFIFO_OVERRUN -2

#define AFSK_MODE_NOBLOCK 0x80

/* public variables ========================================================= */
extern FILE xAfskPort;

/* internal public functions ================================================ */

#if defined(__DOXYGEN__)
/*
 * __DOXYGEN__ defined
 * Partie documentation ne devant pas être compilée.
 * ===========================================================================*/


/* internal public functions ================================================ */

void vAfskInit (uint8_t ucMode);

bool bAfskSending (void);

bool bAfskReceiving (void);

bool bAfskDcd (void);

uint8_t ucAfskGetRssi (void);

void vAfskSetRssiTh (uint8_t ucRssi);

uint8_t ucAfskGetRssiTh (void);

void vAfskToneSet (uint16_t usTxPhaseInc);

void vAfskToneToggle (void);


#define CONFIG_AFSK_RX_BUFLEN

#define CONFIG_AFSK_TX_BUFLEN

#define CONFIG_AFSK_PREAMBLE_LEN

#define CONFIG_AFSK_TRAILER_LEN


/* constants ================================================================ */
#define AFSK_BAUDRATE 1200L

#define AFSK_MARK_FREQ     1200L

#define AFSK_SPACE_FREQ    2200L

#define AFSK_SAMPLES_PER_BIT 8L

#define AFSK_DAC_RESOLUTION 4

#define AFSK_TXONLY_vect

void vAfskHwInit (void);

void vAfskHwDacWrite (uint16_t usValue);

void vAfskHwTxEnable (void);

void vAfskHwTxDisable (void);


int8_t iAfskHwAdcRead (void);

void vAfskHwDcdOn (void);

void vAfskHwDcdOff (void);
 // Fin du Driver
/* ========================================================================== */
#else
/*
 * __DOXYGEN__ not defined
 * Partie ne devant pas être documentée.
 * =============================================================================
 */
#include <string.h>
#include <util/atomic.h>
#include <avrio/queue.h>
#include "avrio-board-afsk.h"

#if defined(AFSK_TX_DISABLE) && defined(AFSK_RX_DISABLE)
#error "AFSK_TX_DISABLE and AFSK_RX_DISABLE can not be defined at the same time !"
#endif

#if !defined(AFSK_RX_DISABLE) && (AFSK_SAMPLES_PER_BIT != 8)
#warning "AFSK_RX_DISABLE not defined: AFSK_SAMPLES_PER_BIT was redefined to 8"
#undef AFSK_SAMPLES_PER_BIT
#define AFSK_SAMPLES_PER_BIT 8L
#endif

/* constants ================================================================ */
// Nombre d'échantillon de la sinusoide par le module
#define AFSK_SINWAVE_LEN 512L

// Codage sinus entre 0 et 255
#define AFSK_SINWAVE_RESOLUTION  8

// Macro pour la mise à l'échelle de la valeur envoyée au DAC
#if  AFSK_SINWAVE_RESOLUTION > AFSK_DAC_RESOLUTION
#define AFSK_DAC_VALUE(_v)  ((_v)>>(AFSK_SINWAVE_RESOLUTION-AFSK_DAC_RESOLUTION))
#elif AFSK_SINWAVE_RESOLUTION < AFSK_DAC_RESOLUTION
#define AFSK_DAC_VALUE(_v)  ((_v)<<(AFSK_DAC_RESOLUTION-AFSK_SINWAVE_RESOLUTION))
#else
#define AFSK_DAC_VALUE(_v)  (_v)
#endif

/* macros =================================================================== */
#define AFSK_PHASE_INC(_freq) (((_freq)*AFSK_SINWAVE_LEN)/AFSK_BAUDRATE/AFSK_SAMPLES_PER_BIT)

// Incrément de phase pour la MARK
#define AFSK_MARK_INC   AFSK_PHASE_INC(AFSK_MARK_FREQ)

// Incrément de phase pour la SPACE
#define AFSK_SPACE_INC  AFSK_PHASE_INC(AFSK_SPACE_FREQ)

/* structures =============================================================== */
typedef struct xAfsk {

#ifndef AFSK_TX_DISABLE
  // Transmetteur
  uint16_t usTxPhase;    // Phase de la sinusoide
  uint16_t usTxPhaseInc; // Incrément de phase de la sinusoide
  uint8_t ucTxSampleCnt; // Compteur du nombre d'échantillons par temps de bit
  uint8_t ucTxByte;      // Octet en cours de transmission
  uint8_t ucTxBit;       // Masque sur le bit en cours de transmission
  uint8_t ucTxStuffCnt;  // Compteur du nombre de bit successifs à 1
  uint8_t ucPreambleCnt; // Compteur du nombre de HDLC_FLAG à tramsmettre avant la trame
  uint8_t ucTrailerCnt;  // Compteur du nombre de HDLC_FLAG à tramsmettre après la trame

  xQueue xTxFifo; // Pile des octets à transmettre
  uint8_t ucTxBuffer[CONFIG_AFSK_TX_BUFLEN]; // Buffer de la pile de transmission
#endif

#ifndef AFSK_RX_DISABLE
  // Récepteur
  uint8_t ucRxBitCnt;
  uint8_t ucRxBitStream;
  uint8_t ucRxByte;
  uint8_t ucCarrierCnt;
  /*
   * Accumulateur de phase actuelle
   * Permet de savoir quand le bit doit être échantillonné
   */
  int8_t iRxPhaseAcc;

  /*
   * Bits trouvés à la vitesse de modulation correcte
   */
  uint8_t ucDataBits;

  xQueue xRxFifo; // Pile des octets reçus
  uint8_t ucRxBuffer[CONFIG_AFSK_RX_BUFLEN]; // Buffer de la pile de réception

  /*
   * Buffer circulaires des échantillons du signal audio et son index
   * Utilisé pour la démodulation du signal par filtrage numérique
   */
  int8_t iSample[AFSK_SAMPLES_PER_BIT];
  uint8_t ucSampleIdx;
  /*
   * Bits échantilloné par le discriminateur
   * Comme la fréquence d'échantillonage de l'ADC est plus grande que la vitesse
   * de transmission, il faut pouvoir stocker AFSK_SAMPLES_PER_BIT ucLastBits.
   * TODO: modifier la taille en fonction de AFSK_SAMPLES_PER_BIT
   */
  uint8_t ucSampleBits;

#ifdef AVRIO_AFSK_USE_RSSI
  uint8_t ucSampleCnt;
  // Dernière qualité de signal mesurée
  uint8_t ucRssi;
  // Seuil de qualité satisfaisante du signal
  uint8_t ucRssiTh;
#endif /* AVRIO_AFSK_USE_RSSI defined */
#endif /* AFSK_RX_DISABLE not defined */

  // Common
  int iError;
  uint8_t ucMode;
  union {
    volatile uint8_t ucFlag;
    struct {
      volatile uint8_t bTxEnable      : 1; // Transmission en cours
      volatile uint8_t bStuffEnable   : 1; // Le bit stuffing est activé
      volatile uint8_t bFrameStarted  : 1; // Début de trame détectée
      volatile uint8_t bDcd           : 1; // La porteuse correcte a été détectée
      volatile uint8_t bTestEnable    : 1; // Le mode test est activé
    };
  };

} xAfsk;

/* public variables ========================================================= */
extern xAfsk af; // for inline funcs only !

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

// -----------------------------------------------------------------------------
INLINE void
vAfskInit (uint8_t ucMode) {

  memset (&af, 0, sizeof (af));
  af.ucMode = ucMode;
  vAfskDebugInit();
  vAfskHwInit();

#ifndef AFSK_TX_DISABLE
  vQueueSetBuffer (&af.xTxFifo, af.ucTxBuffer, sizeof (af.ucTxBuffer));
  af.usTxPhaseInc = AFSK_MARK_INC;
  vAfskHwDacWrite (AFSK_DAC_VALUE (128)); // sin(0) -> VREF_DAC/2
#endif

#ifndef AFSK_RX_DISABLE

#ifdef AVRIO_AFSK_USE_RSSI
// Seuil de qualité satisfaisante du signal
  af.ucRssiTh = AFSK_RSSI_DEFAULT_TH;
#endif

  vQueueSetBuffer (&af.xRxFifo, af.ucRxBuffer, sizeof (af.ucRxBuffer));
#endif
}

#ifndef AFSK_RX_DISABLE
// -----------------------------------------------------------------------------
INLINE bool
bAfskReceiving (void) {

  bool bValue;

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    bValue = (af.bFrameStarted ? true : false);
  }
  return bValue;
}

// -----------------------------------------------------------------------------
INLINE bool
bAfskDcd (void) {
  bool bValue;

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    bValue = (af.bFrameStarted ? true : false);
  }
  return bValue;
}

#ifdef AVRIO_AFSK_USE_RSSI
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
INLINE uint8_t
ucAfskGetRssi (void) {
  uint8_t ucRssi;

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    ucRssi = af.ucRssi;
  }
  return ucRssi;
}

// -----------------------------------------------------------------------------
INLINE void
vAfskSetRssiTh (uint8_t ucRssi) {

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    af.ucRssiTh = ucRssi;
  }
}

// -----------------------------------------------------------------------------
INLINE uint8_t
ucAfskGetRssiTh (void) {
  uint8_t ucRssi;

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    ucRssi = af.ucRssiTh;
  }
  return ucRssi;
}

#endif /* AVRIO_AFSK_USE_RSSI defined */
#endif /* AFSK_RX_DISABLE not defined */

#ifndef AFSK_TX_DISABLE
// -----------------------------------------------------------------------------
INLINE bool
bAfskSending (void) {

  bool bValue;

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    bValue = (af.bTxEnable ? true : false);
  }
  return bValue;
}

// -----------------------------------------------------------------------------
INLINE void
vAfskToneSet (uint16_t usTxPhaseInc) {

  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {

    af.usTxPhaseInc = usTxPhaseInc;
    af.bTestEnable = 1;
    af.bTxEnable = 1;
  }
}

// -----------------------------------------------------------------------------
INLINE void
vAfskToneToggle (void) {

  (af.usTxPhaseInc == AFSK_MARK_INC) ?  vAfskToneSet (AFSK_SPACE_INC) :
  vAfskToneSet (AFSK_MARK_INC);
}
#endif // AFSK_TX_DISABLE not defined

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

/* ========================================================================== */
__END_C_DECLS
#endif  /* _AVRIO_AFSK_H_ not defined */