AVR Freaks

TRXPR_struct._trxrst 
CSMA_SEED_1_struct._aack_set_pd 
CSMA_SEED_1_struct._aack_dis_ack 
IRQ_MASK_struct._rx_end_en 
PHY_CC_CCA_struct._channel 
TRX_CTRL_2_struct._rx_safe_mode 

TRXPR_struct.trxrst 
CSMA_SEED_1_struct.aack_set_pd 
CSMA_SEED_1_struct.aack_dis_ack  
IRQ_MASK_struct.rx_end_en 
PHY_CC_CCA_struct.channel 
TRX_CTRL_2_struct.rx_safe_mode 

#include 
#include 
#define REG_TRX_STATUS_TRX_STATUS_MASK 0x1F 
#define TRX_FRAME_BUFFER(index) (*(volatile uint8_t *)(0x180 + (index))) 

//#define DEVICE 0
#define DEVICE 1

#define BASIC 0

#define PANID (0x1234)
#define SADDR DEVICE
#define EADDR (0xaabbccdd00000000LL | SADDR)
#define TRX_CMD_NOP                         0 
#define TRX_CMD_TX_START                    2 
#define TRX_CMD_FORCE_TRX_OFF               3 
#define TRX_CMD_FORCE_PLL_ON                4 
#define TRX_CMD_RX_ON                       6 
#define TRX_CMD_TRX_OFF                     8 
#define TRX_CMD_PLL_ON                      9 
#define TRX_CMD_RX_AACK_ON                  22 
#define TRX_CMD_TX_ARET_ON                  25 
#define IRQ_STATUS_CLEAR_VALUE              0xff




//
// Types
//
typedef struct
{
  uint8_t phr;
  uint16_t fcf;
  uint8_t seq;
  uint16_t dpan;
  uint16_t daddr;
  uint16_t saddr;
  uint8_t data;
  uint16_t crc;
} Frame_t;

//
// Variables
//
uint8_t txCnt = 0;
uint8_t payload = 5;

volatile int rxReceived = 0;
volatile uint8_t rxPayload;

volatile int txWaitInt = 0;

//
// Functions
//
void infBlink(void)
{
  long i;

  cli();
  PORTE = 0;
  while (1)
  {
    PORTE ^= 0xff;
    for (i = 0; i< 20000; i++)
      asm("nop");
  }
}

void setState(uint8_t state)
{
  TRX_STATE = CMD_FORCE_TRX_OFF;
  TRX_STATE = state;
  while (state != (TRX_STATUS & REG_TRX_STATUS_TRX_STATUS_MASK));
}

void sendFrame(uint8_t payload)
{
  int i;
  Frame_t frame;

#if BASIC
  setState(TRX_CMD_PLL_ON);
#else
  setState(TRX_CMD_TX_ARET_ON);
#endif

  frame.phr = sizeof(Frame_t)-1;
  frame.fcf = (1 << 0) /*data*/ | (1<<5) /*ackReq*/ | (1<<6) /*panIdComp*/ | (2<<10) /*dstAddrMode*/ | (2<<14) /*srcAddrMode*/;
  frame.dpan = PANID;
  frame.saddr = SADDR;
  frame.daddr = 1-SADDR;
  frame.seq = txCnt++;
  frame.data = payload;

  for (i = 0; i < sizeof(Frame_t); i++)
    TRX_FRAME_BUFFER(i) = ((uint8_t *)&frame)[i];

  txWaitInt = 1;
  TRX_STATE = CMD_TX_START;
}

ISR(TRX24_RX_END_vect)
{
  setState(TRX_CMD_PLL_ON);

  PORTE ^= (1<<3);

  rxPayload = TRX_FRAME_BUFFER(9);
  rxReceived = 1;
}

ISR(TRX24_TX_END_vect)
{
  PORTE ^= (1<<2);

  if (txWaitInt)
    txWaitInt = 0;
  else
    infBlink();
}

void rfInit(void)
{
  TRXPR_struct.trxrst = 1;

  setState(TRX_CMD_TRX_OFF);

  CSMA_SEED_1_struct.aack_set_pd = 1;
  CSMA_SEED_1_struct.aack_dis_ack = 0;

  IRQ_STATUS = IRQ_STATUS_CLEAR_VALUE;
  IRQ_MASK_struct.rx_end_en = 1;
  IRQ_MASK_struct.tx_end_en = 1;
  sei();

  PHY_CC_CCA_struct.channel = 0x0b;
  TRX_CTRL_2_struct.rx_safe_mode = 1;

  CSMA_SEED_0 = (uint8_t)SADDR;

  {
    uint16_t vPanId = PANID;
    uint8_t *panId = (uint8_t *)&vPanId;
    PAN_ID_0 = panId[0];
    PAN_ID_1 = panId[1];
  }

  {
    uint16_t vShortAddr = SADDR;
    uint8_t *shortAddr = (uint8_t *)&vShortAddr;
    SHORT_ADDR_0 = shortAddr[0];
    SHORT_ADDR_1 = shortAddr[1];
  }

  {
    uint64_t vExtAddr = EADDR;
    uint8_t *extAddr = (uint8_t *)&vExtAddr;
    IEEE_ADDR_0 = extAddr[0];
    IEEE_ADDR_1 = extAddr[1];
    IEEE_ADDR_2 = extAddr[2];
    IEEE_ADDR_3 = extAddr[3];
    IEEE_ADDR_4 = extAddr[4];
    IEEE_ADDR_5 = extAddr[5];
    IEEE_ADDR_6 = extAddr[6];
    IEEE_ADDR_7 = extAddr[7];
  }
}

int main()
{
  long i;

  DDRE = 0xff;
  PORTE = 0xff;

  rfInit();

#if DEVICE == 0
  #if BASIC
    setState(TRX_CMD_RX_ON);
  #else
    setState(TRX_CMD_RX_AACK_ON);
  #endif

  while (1)
  {
    // Wait for frames
    if (rxReceived)
    {
      for (i = 0; i < 10000; i++) // Wait a bit
        asm("nop");

      rxReceived = 0;
      sendFrame(rxPayload);

      while (txWaitInt)
        asm("nop");

      #if BASIC
        setState(TRX_CMD_RX_ON);
      #else
        setState(TRX_CMD_RX_AACK_ON);
      #endif
    }
  }
#endif

#if DEVICE == 1
  while (1)
  {
    for (i = 0; i < 1000000; i++)
      asm("nop");

    // Send frame
    sendFrame(payload);
    while (txWaitInt)
      asm("nop");

    // Wait for response
    rxReceived = 0;
    #if BASIC
      setState(TRX_CMD_RX_ON);
    #else
      setState(TRX_CMD_RX_AACK_ON);
    #endif

    for (i = 0; i < 1000000; i++)
    {
      if (rxReceived)
      {
        if (payload == rxPayload)
          payload++;
        else
          infBlink();
        break;
      }
    }
  }
#endif

  while (1);

  return 0;
}