/**
* \brief prepare a frame and the radio for immediate transmission
* \param payload Pointer to data to copy/send
* \param payload_len length of data to copy
* \return Returns success/fail, refer to radio.h for explanation
*/
int
rf233_prepare(const void *payload, unsigned short payload_len)
{
#if DEBUG_PRINTDATA
int i;
#endif /* DEBUG_PRINTDATA */
uint8_t templen;
uint8_t radio_status;
uint8_t data[130];
#if USE_HW_FCS_CHECK
/* Add length of the FCS (2 bytes) */
templen = payload_len + 2;
#else /* USE_HW_FCS_CHECK */
/* FCS is assumed to already be included in the payload */
templen = payload_len;
#endif /* USE_HW_FCS_CHECK */
//data = templen;
/*
for(i = 0; i < templen; i++) {
data++;
data =(uint8_t *)(payload + i);
}*/
//memcpy(data,&templen,1);
data[0] = templen;
memcpy(&data[1],payload,templen);
//data--;
#if DEBUG_PRINTDATA
PRINTF("RF233 prepare (%u/%u): 0x", payload_len, templen);
for(i = 0; i < templen; i++) {
PRINTF("%02x", *(uint8_t *)(payload + i));
}
PRINTF("\n");
#endif /* DEBUG_PRINTDATA */
PRINTF("RF233: prepare %u\n", payload_len);
if(payload_len > MAX_PACKET_LEN) {
PRINTF("RF233: error, frame too large to tx\n");
return RADIO_TX_ERR;
}
/* check that the FIFO is clear to access */
radio_status=rf233_status();
#if NULLRDC_CONF_802154_AUTOACK_HW
if(radio_status == STATE_BUSY_RX_AACK || radio_status == STATE_BUSY_TX_ARET) {
PRINTF("RF233: TRX buffer unavailable: prep when %s\n", radio_status == STATE_BUSY_RX_AACK ? "rx" : "tx");
#else
if(radio_status == STATE_BUSY_RX || radio_status == STATE_BUSY_TX) {
PRINTF("RF233: TRX buffer unavailable: prep when %s\n", radio_status == STATE_BUSY_RX? "rx" : "tx");
#endif
return RADIO_TX_ERR;
}
/* Write packet to TX FIFO. */
PRINTF("RF233 len = %u\n", payload_len);
trx_frame_write((uint8_t *)data, templen+1);
return RADIO_TX_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Transmit a frame already put in the radio with 'prepare'
* \param payload_len Length of the frame to send
* \return Returns success/fail, refer to radio.h for explanation
*/
int
rf233_transmit(unsigned short payload_len)
{
static uint8_t status_now;
PRINTF("RF233: tx %u\n", payload_len);
/* prepare for TX */
status_now = rf233_status();
//status_now = trx_reg_read(RF233_REG_TRX_RPC);
#if NULLRDC_CONF_802154_AUTOACK_HW
if(status_now == STATE_BUSY_RX_AACK || status_now == STATE_BUSY_TX_ARET) {
#else
if(status_now == STATE_BUSY_RX || status_now == STATE_BUSY_TX) {
#endif
PRINTF("RF233: collision, was receiving 0x%02X\n",status_now);
/* NOTE: to avoid loops */
return RADIO_TX_ERR;;
// return RADIO_TX_COLLISION;
}
if(status_now != STATE_PLL_ON) {
/* prepare for going to state TX, should take max 80 us */
//RF233_COMMAND(TRXCMD_PLL_ON);
trx_reg_write(RF233_REG_TRX_STATE,0x09);
// BUSYWAIT_UNTIL(trx_reg_read(RF233_REG_TRX_STATUS) == STATE_PLL_ON, 1 * RTIMER_SECOND/1000);
//delay_ms(10);
//status_now = trx_reg_read(RF233_REG_TRX_STATE);
do
{
status_now = trx_bit_read(0x01, 0x1F, 0);
} while (status_now == 0x1f);
}
if(rf233_status() != STATE_PLL_ON) {
/* failed moving into PLL_ON state, gracefully try to recover */
PRINTF("RF233: failed going to PLLON\n");
RF233_COMMAND(TRXCMD_PLL_ON); /* try again */
static uint8_t state;
state = rf233_status();
if(state != STATE_PLL_ON) {
/* give up and signal big fail (should perhaps reset radio core instead?) */
PRINTF("RF233: graceful recovery (in tx) failed, giving up. State: 0x%02X\n", rf233_status());
return RADIO_TX_ERR;
}
}
/* perform transmission */
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
#if NULLRDC_CONF_802154_AUTOACK_HW
RF233_COMMAND(TRXCMD_TX_ARET_ON);
#endif
RF233_COMMAND(TRXCMD_TX_START);
flag_transmit=1;
//delay_ms(5);
//printf("RTIMER value %d",RTIMER_NOW());
#if !NULLRDC_CONF_802154_AUTOACK_HW
BUSYWAIT_UNTIL(rf233_status() == STATE_BUSY_TX, RTIMER_SECOND/2000);
// printf("RTIMER value1 %d",RTIMER_NOW());
// printf("\r\nSTATE_BUSY_TX");
BUSYWAIT_UNTIL(rf233_status() != STATE_BUSY_TX, 10 * RTIMER_SECOND/1000);
// printf("RTIMER value2 %d",RTIMER_NOW());
#endif
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
#if !NULLRDC_CONF_802154_AUTOACK_HW
if(rf233_status() != STATE_PLL_ON) {
// something has failed
PRINTF("RF233: radio fatal err after tx\n");
radiocore_hard_recovery();
return RADIO_TX_ERR;
}
RF233_COMMAND(TRXCMD_RX_ON);
#else
BUSYWAIT_UNTIL(ack_status == 1, 10 * RTIMER_SECOND/1000);
if((ack_status))
{
// printf("\r\nrf233 sent\r\n ");
ack_status=0;
// printf("\nACK received");
return RADIO_TX_OK;
}
else
{
// printf("\nNOACK received");
return RADIO_TX_NOACK;
}
#endif
PRINTF("RF233: tx ok\n");
return RADIO_TX_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Send data: first prepares, then transmits
* \param payload Pointer to data to copy/send
* \param payload_len length of data to copy
* \return Returns success/fail, refer to radio.h for explanation
*/
int
rf233_send(const void *payload, unsigned short payload_len)
{
PRINTF("RF233: send %u\n", payload_len);
if(rf233_prepare(payload, payload_len) == RADIO_TX_ERR) {
return RADIO_TX_ERR;
}
return rf233_transmit(payload_len);
}
/*---------------------------------------------------------------------------*/
/**
* \brief read a received frame out of the radio buffer
* \param buf pointer to where to copy received data
* \param bufsize Maximum size we can copy into bufsize
* \return Returns length of data read (> 0) if successful
* \retval -1 Failed, was transmitting so FIFO is invalid
* \retval -2 Failed, rx timed out (stuck in rx?)
* \retval -3 Failed, too large frame for buffer
* \retval -4 Failed, CRC/FCS failed (if USE_HW_FCS_CHECK is true)
*/
int
rf233_read(void *buf, unsigned short bufsize)
{
// uint8_t radio_state;
uint8_t ed; /* frame metadata */
uint8_t frame_len = 0;
uint8_t len = 0;
int rssi;
#if DEBUG_PRINTDATA
uint8_t tempreadlen;
#endif /* DEBUG_PRINTDATA */
if(pending_frame == 0) {
return 0;
}
pending_frame = 0;
/* / * check that data in FIFO is valid * /
radio_state = RF233_STATUS();
if(radio_state == STATE_BUSY_TX) {
/ * data is invalid, bail out * /
PRINTF("RF233: read while in BUSY_TX ie invalid, dropping.\n");
return -1;
}
if(radio_state == STATE_BUSY_RX) {
/ * still receiving - data is invalid, wait for it to finish * /
PRINTF("RF233: read while BUSY_RX, waiting.\n");
BUSYWAIT_UNTIL(RF233_STATUS() != STATE_BUSY_RX, 10 * RTIMER_SECOND/1000);
if(RF233_STATUS() == STATE_BUSY_RX) {
PRINTF("RF233: timed out, still BUSY_RX, dropping.\n");
return -2;
}
}
*/
/* get length of data in FIFO */
trx_frame_read(&frame_len, 1);
#if DEBUG_PRINTDATA
tempreadlen = frame_len;
#endif /* DEBUG_PRINTDATA */
if(frame_len == 1) {
frame_len = 0;
}
len = frame_len;
#if USE_HW_FCS_CHECK
/* FCS has already been stripped */
len = frame_len - 2;
#endif /* USE_HW_FCS_CHECK */
if(frame_len == 0) {
return 0;
}
if(len > bufsize) {
/* too large frame for the buffer, drop */
PRINTF("RF233: too large frame for buffer, dropping (%u > %u).\n", frame_len, bufsize);
flush_buffer();
return -3;
}
PRINTF("RF233 read %u B\n", frame_len);
/* read out the data into the buffer, disregarding the length and metadata bytes */
trx_sram_read(1,(uint8_t *)buf, len);
#if DEBUG_PRINTDATA
{
int k;
PRINTF("RF233: Read frame (%u/%u): ", tempreadlen, frame_len);
for(k = 0; k < frame_len; k++) {
PRINTF("%02x", *((uint8_t *)buf + k));
}
PRINTF("\n");
}
#endif /* DEBUG_PRINTDATA */
/*
* Energy level during reception, ranges from 0x00 to 0x53 (=83d) with a
* resolution of 1dB and accuracy of +/- 5dB. 0xFF means invalid measurement.
* 0x00 means <= RSSI(base_val), which is -91dBm (typ). See datasheet 12.7.
* Ergo, real RSSI is (ed-91) dBm or less.
*/
#define RSSI_OFFSET (91)
ed = trx_reg_read(RF233_REG_PHY_ED_LEVEL);
rssi = (int) ed - RSSI_OFFSET;
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rssi);
flush_buffer();
/*
#if USE_HW_FCS_CHECK
{
uint8_t crc_ok; / * frame metadata * /
crc_ok = rf233_arch_read_reg(RF233_REG_PHY_RSSI) & PHY_RSSI_CRC_VALID;
if(crc_ok == 0) {
/ * CRC/FCS fail, drop * /
PRINTF("RF233: CRC/FCS fail, dropping.\n");
flush_buffer();
return -4;
}
}
#endif / * USE_HW_FCS_CHECK * /*/
return len;
}
/**
* \brief Init the radio
* \return Returns success/fail
* \retval 0 Success
*/
int
rf233_init(void)
{
volatile uint8_t regtemp;
volatile uint8_t radio_state; /* don't optimize this away, it's important */
PRINTF("RF233: init.\n");
/* init SPI and GPIOs, wake up from sleep/power up. */
//rf233_arch_init();
trx_spi_init();
/* reset will put us into TRX_OFF state */
/* reset the radio core */
port_pin_set_output_level(AT86RFX_RST_PIN, false);
delay_cycles_ms(1);
port_pin_set_output_level(AT86RFX_RST_PIN, true);
port_pin_set_output_level(AT86RFX_SLP_PIN, false); /*wakeup from sleep*/
/* before enabling interrupts, make sure we have cleared IRQ status */
regtemp = trx_reg_read(RF233_REG_IRQ_STATUS);
PRINTF("After wake from sleep\n");
radio_state = rf233_status();
PRINTF("After arch read reg: state 0x%04x\n", radio_state);
if(radio_state == STATE_P_ON) {
trx_reg_write(RF233_REG_TRX_STATE, TRXCMD_TRX_OFF);
}
/* Assign regtemp to regtemp to avoid compiler warnings */
regtemp = regtemp;
trx_irq_init((FUNC_PTR)rf233_interrupt_poll);
ENABLE_TRX_IRQ();
system_interrupt_enable_global();
/* Configure the radio using the default values except these. */
trx_reg_write(RF233_REG_TRX_CTRL_1, RF233_REG_TRX_CTRL_1_CONF);
trx_reg_write(RF233_REG_PHY_CC_CCA, RF233_REG_PHY_CC_CCA_CONF);
trx_reg_write(RF233_REG_PHY_TX_PWR, RF233_REG_PHY_TX_PWR_CONF);
trx_reg_write(RF233_REG_TRX_CTRL_2, RF233_REG_TRX_CTRL_2_CONF);
trx_reg_write(RF233_REG_IRQ_MASK, RF233_REG_IRQ_MASK_CONF);
// trx_reg_write(0x17, 0x02);
#if HW_CSMA_FRAME_RETRIES
trx_bit_write(SR_MAX_FRAME_RETRIES, 3);
trx_bit_write(SR_MAX_CSMA_RETRIES, 4);
#else
trx_bit_write(SR_MAX_FRAME_RETRIES, 0);
trx_bit_write(SR_MAX_CSMA_RETRIES, 7);
#endif
SetPanId(IEEE802154_CONF_PANID);
rf_generate_random_seed();
for(uint8_t i=0;i<8;i++)
{
regtemp =trx_reg_read(0x24+i);
}
/* 11_09_rel */
trx_reg_write(RF233_REG_TRX_RPC,0xFF); /* Enable RPC feature by default */
// regtemp = trx_reg_read(RF233_REG_PHY_TX_PWR);
/* start the radio process */
process_start(&rf233_radio_process, NULL);
return 0;
}
uint8_t rf233_status()
{
return (trx_reg_read(RF233_REG_TRX_STATUS) & TRX_STATUS);
}
/**
* \brief Get transmission power
* \return The transmission power
*/
int
rf233_get_txp(void)
{
PRINTF("RF233: get txp\n");
return trx_reg_read(RF233_REG_PHY_TX_PWR_CONF) & PHY_TX_PWR_TXP;
}
int main(void)
{
node_config_t nc = {.short_addr = 0, .pan_id = 0};
/* setup hardware */
app_init();
/* copy flash settings */
get_node_config(&nc);
TxFrame.src = nc.short_addr;
sei();
PRINTF("Simple Range Test\n\r This is node: 0x%04x TX-FRAME: %d\n\r",
nc.short_addr, sizeof(TxFrame));
PRINTF("PWR: 0x%x CHAN: %d\r\n",
trx_reg_read(RG_PHY_TX_PWR), trx_bit_read(SR_CHANNEL));
do_init = true;
timer_start(tmr_transmit,T_TX_PERIOD,0);
while(1)
{
DELAY_MS(10);
if( keys_debounced() )
{
LED_TOGGLE(0);
keycnt ++;
}
}
}
