static void RADIO_HandleStateMachine(void) {
uint8_t status;
for(;;) { /* will break/return */
switch (RADIO_AppStatus) {
case RADIO_INITIAL_STATE:
RF1_StopRxTx(); /* will send/receive data later */
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON; /* turn receive on */
break; /* process switch again */
case RADIO_RECEIVER_ALWAYS_ON: /* turn receive on */
RX_POWERUP();
RF1_StartRxTx(); /* Listening for packets */
RADIO_AppStatus = RADIO_READY_FOR_TX_RX_DATA;
break; /* process switch again */
case RADIO_READY_FOR_TX_RX_DATA: /* we are ready to receive/send data data */
if (RADIO_isrFlag) { /* Rx interrupt? */
RADIO_isrFlag = FALSE; /* reset interrupt flag */
(void)CheckRx(); /* get message */
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON; /* continue listening */
break; /* process switch again */
}
if (CheckTx()==ERR_OK) { /* there was data and it has been sent */
RADIO_AppStatus = RADIO_WAITING_DATA_SENT;
break; /* process switch again */
}
return;
case RADIO_WAITING_DATA_SENT:
if (RADIO_isrFlag) { /* check if we have received an interrupt: this is either timeout or low level ack */
RADIO_isrFlag = FALSE; /* reset interrupt flag */
status = RF1_GetStatus();
if (status&RF1_STATUS_RX_DR) { /* data received interrupt */
RF1_ResetStatusIRQ(RF1_STATUS_RX_DR); /* clear bit */
}
if (status&RF1_STATUS_TX_DS) { /* data sent interrupt */
RF1_ResetStatusIRQ(RF1_STATUS_TX_DS); /* clear bit */
}
if (status&RF1_STATUS_MAX_RT) { /* retry timeout interrupt */
RF1_ResetStatusIRQ(RF1_STATUS_MAX_RT); /* clear bit */
RF1_Write(RF1_FLUSH_TX); /* flush old data */
RADIO_AppStatus = RADIO_TIMEOUT; /* timeout */
} else {
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON; /* turn receive on */
}
break; /* process switch again */
}
return;
case RADIO_TIMEOUT:
Err((unsigned char*)"ERR: Timeout\r\n");
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON; /* turn receive on */
break; /* process switch again */
default: /* should not happen! */
return;
} /* switch */
} /* for */
}
/* called to check if we have something in the RX queue. If so, we queue it */
static uint8_t CheckRx(void) {
uint8_t res = ERR_OK;
uint8_t RxDataBuffer[RPHY_BUFFER_SIZE];
uint8_t status;
RPHY_PacketDesc packet;
bool hasRxData;
hasRxData = FALSE;
packet.flags = RPHY_PACKET_FLAGS_NONE;
packet.phyData = &RxDataBuffer[0];
packet.phySize = sizeof(RxDataBuffer);
#if NRF24_DYNAMIC_PAYLOAD
packet.rxtx = RPHY_BUF_PAYLOAD_START(packet.phyData);
#else
packet.rxtx = &RPHY_BUF_SIZE(packet.phyData); /* we transmit the data size too */
#endif
status = RF1_GetStatus();
if (status&RF1_STATUS_RX_DR) { /* data received interrupt */
hasRxData = TRUE;
#if NRF24_DYNAMIC_PAYLOAD
uint8_t payloadSize;
(void)RF1_ReadNofRxPayload(&payloadSize);
if (payloadSize>32) { /* packet with error? */
RF1_Write(RF1_FLUSH_RX); /* flush old data */
return ERR_FAILED;
} else {
RF1_RxPayload(packet.rxtx, payloadSize); /* get payload: note that we transmit <size> as payload! */
RPHY_BUF_SIZE(packet.phyData) = payloadSize;
}
#else
RF1_RxPayload(packet.rxtx, RPHY_PAYLOAD_SIZE); /* get payload: note that we transmit <size> as payload! */
#endif
RF1_ResetStatusIRQ(RF1_STATUS_RX_DR|RF1_STATUS_TX_DS|RF1_STATUS_MAX_RT); /* make sure we reset all flags. Need to have the pipe number too */
}
if (status&RF1_STATUS_TX_DS) { /* data sent interrupt */
RF1_ResetStatusIRQ(RF1_STATUS_TX_DS); /* clear bit */
}
if (status&RF1_STATUS_MAX_RT) { /* retry timeout interrupt */
RF1_ResetStatusIRQ(RF1_STATUS_MAX_RT); /* clear bit */
}
if (hasRxData) {
/* put message into Rx queue */
res = RMSG_QueueRxMsg(packet.phyData, packet.phySize, RPHY_BUF_SIZE(packet.phyData), packet.flags);
if (res!=ERR_OK) {
if (res==ERR_OVERFLOW) {
Err((unsigned char*)"ERR: Rx queue overflow!\r\n");
} else {
Err((unsigned char*)"ERR: Rx Queue full?\r\n");
}
}
}
return res;
}
/*!
* \brief Radio power-on initialization.
* \return Error code, ERR_OK if everything is ok.
*/
uint8_t RADIO_PowerUp(void) {
WAIT1_WaitOSms(100); /* the transceiver needs 100 ms power up time */
RF1_Init(); /* set CE and CSN to initialization value */
RF1_WriteRegister(RF1_RF_SETUP, RF1_RF_SETUP_RF_PWR_0|RF1_RF_SETUP_RF_DR_250);
#if NRF24_DYNAMIC_PAYLOAD
/* enable dynamic payload */
RF1_WriteFeature(RF1_FEATURE_EN_DPL|RF1_FEATURE_EN_ACK_PAY|RF1_FEATURE_EN_DYN_PAY); /* set EN_DPL for dynamic payload */
RF1_EnableDynanicPayloadLength(RF1_DYNPD_DPL_P0); /* set DYNPD register for dynamic payload for pipe0 */
#else
RF1_SetStaticPipePayload(0, RPHY_PAYLOAD_SIZE); /* static number of payload bytes we want to send and receive */
#endif
(void)RADIO_SetChannel(RADIO_CHANNEL_DEFAULT);
/* Set RADDR and TADDR as the transmit address since we also enable auto acknowledgment */
RF1_WriteRegisterData(RF1_RX_ADDR_P0, (uint8_t*)TADDR, sizeof(TADDR));
RF1_WriteRegisterData(RF1_TX_ADDR, (uint8_t*)TADDR, sizeof(TADDR));
/* Enable RX_ADDR_P0 address matching */
RF1_WriteRegister(RF1_EN_RXADDR, RF1_EN_RXADDR_ERX_P0); /* enable data pipe 0 */
/* clear interrupt flags */
RF1_ResetStatusIRQ(RF1_STATUS_RX_DR|RF1_STATUS_TX_DS|RF1_STATUS_MAX_RT);
/* rx/tx mode */
RF1_EnableAutoAck(RF1_EN_AA_ENAA_P0); /* enable auto acknowledge on pipe 0. RX_ADDR_P0 needs to be equal to TX_ADDR! */
RF1_WriteRegister(RF1_SETUP_RETR, RF1_SETUP_RETR_ARD_750|RF1_SETUP_RETR_ARC_15); /* Important: need 750 us delay between every retry */
RX_POWERUP(); /* Power up in receiving mode */
RF1_StartRxTx(); /* Listening for packets */
RADIO_AppStatus = RADIO_INITIAL_STATE;
/* init Rx descriptor */
radioRx.phyData = &radioRxBuf[0];
radioRx.phySize = sizeof(radioRxBuf);
radioRx.rxtx = &RPHY_BUF_SIZE(radioRx.phyData); /* we transmit the size too */
return ERR_OK;
}
