43#include "dev/watchdog.h"
59#include "hw_rfc_dbell.h"
60#include "hw_rfc_pwr.h"
63#include "driverlib/rf_mailbox.h"
64#include "driverlib/rf_common_cmd.h"
65#include "driverlib/rf_data_entry.h"
66#include "driverlib/rf_prop_mailbox.h"
67#include "driverlib/rf_prop_cmd.h"
70#include "rf_patches/rf_patch_cpe_genfsk.h"
71#include "rf_patches/rf_patch_rfe_genfsk.h"
73#include "rf-core/smartrf-settings.h"
82#define PRINTF(...) printf(__VA_ARGS__)
88#define DATA_ENTRY_STATUS_PENDING 0x00
89#define DATA_ENTRY_STATUS_ACTIVE 0x01
90#define DATA_ENTRY_STATUS_BUSY 0x02
91#define DATA_ENTRY_STATUS_FINISHED 0x03
92#define DATA_ENTRY_STATUS_UNFINISHED 0x04
95#ifdef PROP_MODE_CONF_DW
96#define PROP_MODE_DW PROP_MODE_CONF_DW
101#ifdef PROP_MODE_CONF_USE_CRC16
102#define PROP_MODE_USE_CRC16 PROP_MODE_CONF_USE_CRC16
104#define PROP_MODE_USE_CRC16 0
115#define RF_RADIO_OP_GET_STATUS(a) GET_FIELD_V(a, radioOp, status)
117#ifdef PROP_MODE_CONF_RSSI_THRESHOLD
118#define PROP_MODE_RSSI_THRESHOLD PROP_MODE_CONF_RSSI_THRESHOLD
120#define PROP_MODE_RSSI_THRESHOLD 0xA6
123static int8_t rssi_threshold = PROP_MODE_RSSI_THRESHOLD;
125#if MAC_CONF_WITH_TSCH
126static volatile rfc_dataEntry_t *packet_being_received;
132static bool rf_setup_is_completed =
false;
134static rfc_propRxOutput_t rx_stats;
137#define DOT_4G_PHR_LEN 2
140#define DOT_4G_PHR_CRC16 0x10
141#define DOT_4G_PHR_DW 0x08
143#if PROP_MODE_USE_CRC16
145#define DOT_4G_PHR_CRC_BIT DOT_4G_PHR_CRC16
149#define DOT_4G_PHR_CRC_BIT 0
154#define DOT_4G_PHR_DW_BIT DOT_4G_PHR_DW
156#define DOT_4G_PHR_DW_BIT 0
175#define MAX_PAYLOAD_LEN 125
178#ifdef PROP_MODE_CONF_TX_POWER_431_527
179#define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527
181#define PROP_MODE_TX_POWER_431_527 prop_mode_tx_power_431_527
185#ifdef PROP_MODE_CONF_TX_POWER_779_930
186#define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930
188#define PROP_MODE_TX_POWER_779_930 prop_mode_tx_power_779_930
192#if DOT_15_4G_FREQUENCY_BAND_ID==DOT_15_4G_FREQUENCY_BAND_470
193#define TX_POWER_DRIVER PROP_MODE_TX_POWER_431_527
195#define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930
198extern const prop_mode_tx_power_config_t TX_POWER_DRIVER[];
201#define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm)
202#define OUTPUT_POWER_UNKNOWN 0xFFFF
205static const prop_mode_tx_power_config_t *tx_power_current = &TX_POWER_DRIVER[1];
207#ifdef PROP_MODE_CONF_LO_DIVIDER
208#define PROP_MODE_LO_DIVIDER PROP_MODE_CONF_LO_DIVIDER
210#define PROP_MODE_LO_DIVIDER 0x05
213#ifdef PROP_MODE_CONF_RX_BUF_CNT
214#define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT
216#define PROP_MODE_RX_BUF_CNT 4
219#define DATA_ENTRY_LENSZ_NONE 0
220#define DATA_ENTRY_LENSZ_BYTE 1
221#define DATA_ENTRY_LENSZ_WORD 2
224#define RX_BUF_METADATA_SIZE \
225 (CRC_LEN * RF_CORE_RX_BUF_INCLUDE_CRC \
226 + RF_CORE_RX_BUF_INCLUDE_RSSI \
227 + RF_CORE_RX_BUF_INCLUDE_CORR \
228 + 4 * RF_CORE_RX_BUF_INCLUDE_TIMESTAMP)
231#define RX_BUF_LENGTH_OFFSET sizeof(rfc_dataEntry_t)
233#define RX_BUF_DATA_OFFSET (RX_BUF_LENGTH_OFFSET + DOT_4G_PHR_LEN)
235#define ALIGN_TO_4(size) (((size) + 3) & ~3)
237#define RX_BUF_SIZE ALIGN_TO_4(RX_BUF_DATA_OFFSET \
239 + RX_BUF_METADATA_SIZE)
246static uint8_t rx_buf[PROP_MODE_RX_BUF_CNT][RX_BUF_SIZE] CC_ALIGN(4);
249static dataQueue_t rx_data_queue = { 0 };
252volatile static uint8_t *rx_read_entry;
258#define RAT_TIMESTAMP_OFFSET_SUB_GHZ USEC_TO_RADIO(160 * 6 - 240)
261#define TX_BUF_PAYLOAD_LEN 180
262#define TX_BUF_HDR_LEN 2
264static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4);
273 return smartrf_settings_cmd_prop_rx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
283 return rf_setup_is_completed;
289 return smartrf_settings_cmd_prop_tx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
297 uint8_t attempts = 0;
299 rfc_CMD_GET_RSSI_t cmd;
304 if(on() != RF_CORE_CMD_OK) {
305 PRINTF(
"get_rssi: on() failed\n");
306 return RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
310 rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
312 while((rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) && ++attempts < 10) {
313 memset(&cmd, 0x00,
sizeof(cmd));
314 cmd.commandNo = CMD_GET_RSSI;
317 PRINTF(
"get_rssi: CMDSTA=0x%08lx\n", cmd_status);
321 rssi = (cmd_status >> 16) & 0xFF;
338 freq_khz = smartrf_settings_cmd_fs.frequency * 1000;
346 freq_khz += (((smartrf_settings_cmd_fs.fractFreq * 1000) + 65535) / 65536);
348 return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING;
352set_channel(uint8_t channel)
357 new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING);
359 freq = (uint16_t)(new_freq / 1000);
360 frac = (new_freq - (freq * 1000)) * 65536 / 1000;
362 PRINTF(
"set_channel: %u = 0x%04x.0x%04x (%lu)\n", channel, freq, frac,
365 smartrf_settings_cmd_prop_radio_div_setup.centerFreq = freq;
366 smartrf_settings_cmd_fs.frequency = freq;
367 smartrf_settings_cmd_fs.fractFreq = frac;
371get_tx_power_array_last_element(
void)
373 const prop_mode_tx_power_config_t *array = TX_POWER_DRIVER;
376 while(array->tx_power != OUTPUT_POWER_UNKNOWN) {
387 return tx_power_current->dbm;
399 for(i = get_tx_power_array_last_element(); i >= 0; --i) {
400 if(power <= TX_POWER_DRIVER[i].dbm) {
406 tx_power_current = &TX_POWER_DRIVER[i];
414prop_div_radio_setup(
void)
417 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup;
419 rf_switch_select_path(RF_SWITCH_PATH_SUBGHZ);
422 smartrf_settings_cmd_prop_radio_div_setup.loDivider = PROP_MODE_LO_DIVIDER;
425 smartrf_settings_cmd_prop_radio_div_setup.txPower = tx_power_current->tx_power;
428 smartrf_settings_cmd_prop_radio_div_setup.config.frontEndMode =
429 RF_CORE_PROP_FRONT_END_MODE;
430 smartrf_settings_cmd_prop_radio_div_setup.config.biasMode =
431 RF_CORE_PROP_BIAS_MODE;
435 PRINTF(
"prop_div_radio_setup: DIV_SETUP, CMDSTA=0x%08lx, status=0x%04x\n",
436 cmd_status, cmd->status);
437 return RF_CORE_CMD_ERROR;
442 PRINTF(
"prop_div_radio_setup: DIV_SETUP wait, CMDSTA=0x%08lx,"
443 "status=0x%04x\n", cmd_status, cmd->status);
444 return RF_CORE_CMD_ERROR;
447 return RF_CORE_CMD_OK;
454 volatile rfc_CMD_PROP_RX_ADV_t *cmd_rx_adv;
457 cmd_rx_adv = (rfc_CMD_PROP_RX_ADV_t *)&smartrf_settings_cmd_prop_rx_adv;
458 cmd_rx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
460 cmd_rx_adv->rxConf.bIncludeCrc = RF_CORE_RX_BUF_INCLUDE_CRC;
461 cmd_rx_adv->rxConf.bAppendRssi = RF_CORE_RX_BUF_INCLUDE_RSSI;
462 cmd_rx_adv->rxConf.bAppendTimestamp = RF_CORE_RX_BUF_INCLUDE_TIMESTAMP;
463 cmd_rx_adv->rxConf.bAppendStatus = RF_CORE_RX_BUF_INCLUDE_CORR;
468 cmd_rx_adv->maxPktLen = RADIO_PHY_OVERHEAD + MAX_PAYLOAD_LEN;
472 if(ret != RF_CORE_CMD_OK) {
473 PRINTF(
"rf_cmd_prop_rx: send_cmd ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
474 ret, cmd_status, cmd_rx_adv->status);
475 return RF_CORE_CMD_ERROR;
479 RF_CORE_ENTER_RX_TIMEOUT);
482 if(cmd_rx_adv->status != RF_CORE_RADIO_OP_STATUS_ACTIVE) {
483 PRINTF(
"rf_cmd_prop_rx: CMDSTA=0x%08lx, status=0x%04x\n",
484 cmd_status, cmd_rx_adv->status);
485 return RF_CORE_CMD_ERROR;
494 rfc_dataEntry_t *entry;
497 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
498 entry = (rfc_dataEntry_t *)rx_buf[i];
499 entry->status = DATA_ENTRY_STATUS_PENDING;
500 entry->config.type = DATA_ENTRY_TYPE_GEN;
501 entry->config.lenSz = DATA_ENTRY_LENSZ_WORD;
502 entry->length = RX_BUF_SIZE - 8;
503 if(i == PROP_MODE_RX_BUF_CNT - 1) {
504 entry->pNextEntry = rx_buf[0];
506 entry->pNextEntry = rx_buf[i + 1];
517 PRINTF(
"rx_on_prop: We were on. PD=%u, RX=0x%04x\n",
519 return RF_CORE_CMD_OK;
523 ret = rf_cmd_prop_rx();
526 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
538#if MAC_CONF_WITH_TSCH
540 packet_being_received = NULL;
545 return RF_CORE_CMD_OK;
552 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
553 PRINTF(
"rx_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
559 if(smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_STOPPED ||
560 smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_ABORT) {
562 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
563 ret = RF_CORE_CMD_OK;
565 PRINTF(
"rx_off_prop: status=0x%04x\n",
566 smartrf_settings_cmd_prop_rx_adv.status);
567 ret = RF_CORE_CMD_ERROR;
581 return LPM_MODE_SLEEP;
584 return LPM_MODE_MAX_SUPPORTED;
587LPM_MODULE(prop_lpm_module, request, NULL, NULL, LPM_DOMAIN_NONE);
593 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_fs;
597 PRINTF(
"prop_fs: CMD_FS, CMDSTA=0x%08lx, status=0x%04x\n",
598 cmd_status, cmd->status);
599 return RF_CORE_CMD_ERROR;
604 PRINTF(
"prop_fs: CMD_FS wait, CMDSTA=0x%08lx, status=0x%04x\n",
605 cmd_status, cmd->status);
606 return RF_CORE_CMD_ERROR;
609 return RF_CORE_CMD_OK;
623 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
624 PRINTF(
"soft_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
629 RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING, RF_CORE_TURN_OFF_TIMEOUT);
635 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
636 PRINTF(
"soft_on_prop: prop_div_radio_setup() failed\n");
637 return RF_CORE_CMD_ERROR;
640 if(prop_fs() != RF_CORE_CMD_OK) {
641 PRINTF(
"soft_on_prop: prop_fs() failed\n");
642 return RF_CORE_CMD_ERROR;
652 RAT_TIMESTAMP_OFFSET_SUB_GHZ
660 if(ti_lib_chipinfo_chip_family_is_cc13xx() ==
false) {
661 return RF_CORE_CMD_ERROR;
665 memset(rx_buf, 0,
sizeof(rx_buf));
668 rx_data_queue.pCurrEntry = rx_buf[0];
669 rx_data_queue.pLastEntry = NULL;
672 rx_read_entry = rx_buf[0];
674 smartrf_settings_cmd_prop_rx_adv.pQueue = &rx_data_queue;
675 smartrf_settings_cmd_prop_rx_adv.pOutput = (uint8_t *)&rx_stats;
679 if(on() != RF_CORE_CMD_OK) {
680 PRINTF(
"init: on() failed\n");
681 return RF_CORE_CMD_ERROR;
684 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
696prepare(
const void *payload,
unsigned short payload_len)
698 if(payload_len > TX_BUF_PAYLOAD_LEN || payload_len > MAX_PAYLOAD_LEN) {
702 memcpy(&tx_buf[TX_BUF_HDR_LEN], payload, payload_len);
707transmit(
unsigned short transmit_len)
712 volatile rfc_CMD_PROP_TX_ADV_t *cmd_tx_adv;
715 uint16_t total_length;
717 if(transmit_len > MAX_PAYLOAD_LEN) {
718 PRINTF(
"transmit: too long\n");
724 if(on() != RF_CORE_CMD_OK) {
725 PRINTF(
"transmit: on() failed\n");
738 total_length = transmit_len + CRC_LEN;
740 tx_buf[0] = total_length & 0xFF;
741 tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT;
744 cmd_tx_adv = (rfc_CMD_PROP_TX_ADV_t *)&smartrf_settings_cmd_prop_tx_adv;
750 cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN;
751 cmd_tx_adv->pPkt = tx_buf;
763 ENERGEST_SWITCH(ENERGEST_TYPE_LISTEN, ENERGEST_TYPE_TRANSMIT);
766 while((cmd_tx_adv->status & RF_CORE_RADIO_OP_MASKED_STATUS)
767 == RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING) {
773 if(!rf_core_poll_mode) {
778 if(cmd_tx_adv->status == RF_CORE_RADIO_OP_STATUS_PROP_DONE_OK) {
783 PRINTF(
"transmit: Not Sent OK status=0x%04x\n",
789 PRINTF(
"transmit: PROP_TX_ERR ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
790 ret, cmd_status, cmd_tx_adv->status);
798 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
807 cmd_tx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
819send(
const void *payload,
unsigned short payload_len)
821 prepare(payload, payload_len);
822 return transmit(payload_len);
826release_data_entry(
void)
828 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
829 uint8_t *data_ptr = &entry->data;
836 entry->status = DATA_ENTRY_STATUS_PENDING;
837 rx_read_entry = entry->pNextEntry;
840 PRINTF(
"RX was off, re-enabling rx!\n");
847read_frame(
void *buf,
unsigned short buf_len)
849 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
852 uint32_t rat_timestamp;
857 if(entry->status >= DATA_ENTRY_STATUS_BUSY) {
862 entry = (rfc_dataEntryGeneral_t *)entry->pNextEntry;
863 }
while(entry != (rfc_dataEntryGeneral_t *)rx_read_entry);
870 rx_read_entry = (
volatile uint8_t *)entry;
874 while(entry->status == DATA_ENTRY_STATUS_BUSY
875 && RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + RADIO_FRAME_DURATION(MAX_PAYLOAD_LEN)));
877#if MAC_CONF_WITH_TSCH
879 packet_being_received = NULL;
882 if(entry->status != DATA_ENTRY_STATUS_FINISHED) {
893 data_ptr = &entry->data;
894 len = (*(uint16_t *)data_ptr);
896 if(len <= RX_BUF_METADATA_SIZE) {
897 PRINTF(
"RF: too short!");
899 release_data_entry();
904 len -= RX_BUF_METADATA_SIZE;
907 PRINTF(
"RF: too long\n");
909 release_data_entry();
913 memcpy(buf, data_ptr, len);
916 rf_core_last_rssi = (int8_t)data_ptr[len];
917 rf_core_last_corr_lqi = data_ptr[len + 5];
920 memcpy(&rat_timestamp, data_ptr + len + 1, 4);
924 if(!rf_core_poll_mode) {
928 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rf_core_last_rssi);
929 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, rf_core_last_corr_lqi);
932 release_data_entry();
942 int8_t rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
949 return RF_CORE_CCA_CLEAR;
954 if(on() != RF_CORE_CMD_OK) {
955 PRINTF(
"channel_clear: on() failed\n");
959 return RF_CORE_CCA_CLEAR;
963 PRINTF(
"channel_clear: called while in TX\n");
964 return RF_CORE_CCA_CLEAR;
968 while(rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) {
974 rssi = (cmd_status >> 16) & 0xFF;
981 if(rssi >= rssi_threshold) {
982 return RF_CORE_CCA_BUSY;
985 return RF_CORE_CCA_CLEAR;
989receiving_packet(
void)
995#if MAC_CONF_WITH_TSCH
1003 if(packet_being_received == NULL) {
1007 if(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIFG) & RFC_DBELL_RFHWIFG_MDMSOFT) {
1008 packet_being_received = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
1012 if(packet_being_received->status >= DATA_ENTRY_FINISHED) {
1014 ti_lib_rfc_hw_int_clear(RFC_DBELL_RFHWIFG_MDMSOFT);
1015 packet_being_received = NULL;
1019 return packet_being_received != NULL;
1041 if(channel_clear() == RF_CORE_CCA_CLEAR) {
1054 volatile rfc_dataEntry_t *entry = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
1058 if(entry->status >= DATA_ENTRY_STATUS_BUSY) {
1060 if(!rf_core_poll_mode) {
1065 entry = (rfc_dataEntry_t *)entry->pNextEntry;
1066 }
while(entry != (rfc_dataEntry_t *)rx_data_queue.pCurrEntry);
1080 return RF_CORE_CMD_OK;
1085 smartrf_settings_cmd_prop_rx_adv.status);
1086 return RF_CORE_CMD_OK;
1097 PRINTF(
"on: rf_core_power_up() failed\n");
1101 return RF_CORE_CMD_ERROR;
1108 rf_patch_cpe_genfsk();
1109 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1110 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1111 rf_patch_rfe_genfsk();
1114 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1115 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) =
1116 CMDR_DIR_CMD_1BYTE(CMD_BUS_REQUEST, 1);
1119 ti_lib_rfc_adi3vco_ldo_voltage_mode(
true);
1122 ti_lib_rfc_rtrim((rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup);
1125 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1126 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1129 PRINTF(
"on: rf_core_start_rat() failed\n");
1133 return RF_CORE_CMD_ERROR;
1148 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
1149 PRINTF(
"on: prop_div_radio_setup() failed\n");
1151 return RF_CORE_CMD_ERROR;
1154 if(prop_fs() != RF_CORE_CMD_OK) {
1155 PRINTF(
"on: prop_fs() failed\n");
1156 return RF_CORE_CMD_ERROR;
1159 if(rx_on_prop() != RF_CORE_CMD_OK) {
1161 if((
rf_core_cmd_status() & RF_CORE_CMDSTA_RESULT_MASK) != RF_CORE_CMDSTA_SCHEDULING_ERR) {
1163 return RF_CORE_CMD_ERROR;
1169 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &status) == RF_CORE_CMD_ERROR) {
1171 return RF_CORE_CMD_ERROR;
1175 if(soft_on_prop() != RF_CORE_CMD_OK) {
1177 return RF_CORE_CMD_ERROR;
1180 rf_setup_is_completed =
true;
1181 return RF_CORE_CMD_OK;
1188 rfc_dataEntry_t *entry;
1192 smartrf_settings_cmd_prop_rx_adv.status);
1193 return RF_CORE_CMD_OK;
1201 return RF_CORE_CMD_OK;
1207 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1209#if !CC2650_FAST_RADIO_STARTUP
1215 smartrf_settings_cmd_prop_rx_adv.status = RF_CORE_RADIO_OP_STATUS_IDLE;
1221 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
1222 entry = (rfc_dataEntry_t *)rx_buf[i];
1223 if(entry->status == DATA_ENTRY_STATUS_BUSY) {
1224 entry->status = DATA_ENTRY_STATUS_PENDING;
1228 rf_setup_is_completed =
false;
1230 return RF_CORE_CMD_OK;
1235set_send_on_cca(uint8_t enable)
1261 if(rf_core_poll_mode) {
1269 *value = get_tx_power();
1272 *value = rssi_threshold;
1275 *value = get_rssi();
1277 if(*value == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN) {
1286 *value = DOT_15_4G_CHANNEL_MAX;
1289 *value = TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm;
1292 *value = OUTPUT_POWER_MAX;
1295 *value = rf_core_last_rssi;
1298 *value = rf_core_last_corr_lqi;
1316 case RADIO_CONST_MAX_PAYLOAD_LEN:
1328 uint8_t old_poll_mode;
1333 if(on() != RF_CORE_CMD_OK) {
1334 PRINTF(
"set_value: on() failed (1)\n");
1346 value > DOT_15_4G_CHANNEL_MAX) {
1350 if(get_channel() == (uint8_t)value) {
1356 set_channel((uint8_t)value);
1364 old_poll_mode = rf_core_poll_mode;
1366 if(rf_core_poll_mode == old_poll_mode) {
1378 if(value < TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm ||
1379 value > OUTPUT_POWER_MAX) {
1385 set_tx_power(value);
1387 if(soft_on_prop() != RF_CORE_CMD_OK) {
1388 PRINTF(
"set_value: soft_on_prop() failed\n");
1395 rssi_threshold = (int8_t)value;
1407 if(rx_off_prop() != RF_CORE_CMD_OK) {
1408 PRINTF(
"set_value: rx_off_prop() failed\n");
1415 PRINTF(
"set_value: rf_core_restart_rat() failed\n");
1421 if(soft_on_prop() != RF_CORE_CMD_OK) {
1422 PRINTF(
"set_value: soft_on_prop() failed\n");
1430get_object(radio_param_t param,
void *dest,
size_t size)
1433 if(size !=
sizeof(rtimer_clock_t) || !dest) {
1436 *(rtimer_clock_t *)dest = rf_core_last_packet_timestamp;
1445set_object(radio_param_t param,
const void *src,
size_t size)
Header file with descriptors for the various modes of operation defined in IEEE 802....
Header file for the CC13xx/CC26xx UART driver.
Default definitions of C compiler quirk work-arounds.
Header file for the energy estimation mechanism.
#define LPM_MODULE(n, m, s, w, l)
Declare a variable to be used in order to get notifications from LPM.
void lpm_sleep(void)
Enter sleep mode.
void lpm_register_module(lpm_registered_module_t *module)
Register a module for LPM notifications.
void oscillators_switch_to_hf_xosc(void)
Performs the switch to the XOSC.
void oscillators_request_hf_xosc(void)
Requests the HF XOSC as the source for the HF clock, but does not perform the actual switch.
void oscillators_switch_to_hf_rc(void)
Switches MF and HF clock source to be the HF RC OSC.
static volatile uint64_t count
Num.
void process_start(struct process *p, process_data_t data)
Start a process.
void process_poll(struct process *p)
Request a process to be polled.
#define RADIO_RX_MODE_POLL_MODE
Enable/disable/get the state of radio driver poll mode operation.
#define RADIO_TX_MODE_SEND_ON_CCA
Radio TX mode control / retrieval.
enum radio_result_e radio_result_t
Radio return values when setting or getting radio parameters.
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio.
@ RADIO_RESULT_ERROR
An error occurred when getting/setting the parameter, but the arguments were otherwise correct.
@ RADIO_RESULT_NOT_SUPPORTED
The parameter is not supported.
@ RADIO_RESULT_INVALID_VALUE
The value argument was incorrect.
@ RADIO_RESULT_OK
The parameter was set/read successfully.
@ RADIO_PARAM_POWER_MODE
When getting the value of this parameter, the radio driver should indicate whether the radio is on or...
@ RADIO_CONST_PHY_OVERHEAD
The physical layer header (PHR) + MAC layer footer (MFR) overhead in bytes.
@ RADIO_PARAM_RSSI
Received signal strength indicator in dBm.
@ RADIO_PARAM_LAST_PACKET_TIMESTAMP
Last packet timestamp, of type rtimer_clock_t.
@ RADIO_PARAM_LAST_RSSI
The RSSI value of the last received packet.
@ RADIO_CONST_BYTE_AIR_TIME
The air time of one byte in usec, e.g.
@ RADIO_PARAM_RX_MODE
Radio receiver mode determines if the radio has address filter (RADIO_RX_MODE_ADDRESS_FILTER) and aut...
@ RADIO_PARAM_CHANNEL
Channel used for radio communication.
@ RADIO_PARAM_LAST_LINK_QUALITY
Link quality indicator of the last received packet.
@ RADIO_CONST_DELAY_BEFORE_RX
The delay in usec between turning on the radio and it being actually listening (able to hear a preamb...
@ RADIO_PARAM_TXPOWER
Transmission power in dBm.
@ RADIO_CONST_DELAY_BEFORE_TX
The delay in usec between a call to the radio API's transmit function and the end of SFD transmission...
@ RADIO_CONST_CHANNEL_MAX
The highest radio channel number.
@ RADIO_PARAM_CCA_THRESHOLD
Clear channel assessment threshold in dBm.
@ RADIO_CONST_TXPOWER_MIN
The minimum transmission power in dBm.
@ RADIO_CONST_CHANNEL_MIN
The lowest radio channel number.
@ RADIO_CONST_TXPOWER_MAX
The maximum transmission power in dBm.
@ RADIO_CONST_DELAY_BEFORE_DETECT
The delay in usec between the end of SFD reception for an incoming frame and the radio API starting t...
@ RADIO_PARAM_TX_MODE
Radio transmission mode determines if the radio has send on CCA (RADIO_TX_MODE_SEND_ON_CCA) enabled o...
@ RADIO_POWER_MODE_OFF
Radio powered off and in the lowest possible power consumption state.
@ RADIO_POWER_MODE_ON
Radio powered on and able to receive frames.
@ RADIO_TX_ERR
An error occurred during transmission.
@ RADIO_TX_OK
TX was successful and where an ACK was requested one was received.
uint8_t rf_ble_is_active()
Check whether the BLE beacond is currently active.
void rf_core_cmd_done_dis(void)
Disable the LAST_CMD_DONE and LAST_FG_CMD_DONE interrupts.
void rf_core_power_down()
Disable RFCORE clock domain in the MCU VD and turn off the RFCORE PD.
uint32_t rf_core_cmd_status(void)
Get the status of the last issued radio command.
uint_fast8_t rf_core_send_cmd(uint32_t cmd, uint32_t *status)
Sends a command to the RF core.
uint8_t rf_core_is_accessible()
Check whether the RF core is accessible.
rfc_radioOp_t * rf_core_get_last_radio_op()
Returns a pointer to the most recent proto-dependent Radio Op.
int rf_core_power_up()
Turn on power to the RFC and boot it.
uint8_t rf_core_set_modesel()
Initialise RF APIs in the RF core.
uint_fast8_t rf_core_wait_cmd_done(void *cmd)
Block and wait for a Radio op to complete.
uint32_t rf_core_convert_rat_to_rtimer(uint32_t rat_timestamp)
Convert from RAT timestamp to rtimer ticks.
void rf_core_cmd_done_en(bool fg)
Enable interrupt on command done.
uint8_t rf_core_restart_rat(void)
Restart the CM0 RAT.
void rf_core_primary_mode_register(const rf_core_primary_mode_t *mode)
Register a primary mode for radio operation.
void rf_core_setup_interrupts(void)
Setup RF core interrupts.
uint8_t rf_core_rat_init(void)
Initialize the RAT to RTC conversion machinery.
uint8_t rf_core_check_rat_overflow(void)
Check if RAT overflow has occured and increment the overflow counter if so.
uint8_t rf_core_start_rat(void)
Start the CM0 RAT.
#define RTIMER_BUSYWAIT_UNTIL(cond, max_time)
Busy-wait until a condition for at most max_time.
#define RTIMER_NOW()
Get the current clock time.
#define IEEE802154_DEFAULT_CHANNEL
The default channel for IEEE 802.15.4 networks.
Include file for the Contiki low-layer network stack (NETSTACK)
Header file for the CC13xx/CC26xx oscillator control.
Header file for the Packet buffer (packetbuf) management.
Header file for the CC13xx prop mode NETSTACK_RADIO driver.
Header file for the radio API.
Header file for the CC13xx/CC26xx BLE driver.
Header file for the CC13xx/CC26xx RF core driver.
Header file with definitions related to RF switch support.
Header file for the real-time timer module.
The structure of a Contiki-NG radio device driver.
radio_result_t(* get_object)(radio_param_t param, void *dest, size_t size)
Get a radio parameter object.
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
radio_result_t(* set_value)(radio_param_t param, radio_value_t value)
Set a radio parameter value.
int(* off)(void)
Turn the radio off.
int(* init)(void)
Initialise the radio hardware.
int(* send)(const void *payload, unsigned short payload_len)
Prepare & transmit a packet.
int(* receiving_packet)(void)
Check if the radio driver is currently receiving a packet.
radio_result_t(* set_object)(radio_param_t param, const void *src, size_t size)
Set a radio parameter object.
int(* on)(void)
Turn the radio on.
int(* transmit)(unsigned short transmit_len)
Send the packet that has previously been prepared.
int(* pending_packet)(void)
Check if a packet has been received and is available in the radio driver's buffers.
radio_result_t(* get_value)(radio_param_t param, radio_value_t *value)
Get a radio parameter value.
int(* channel_clear)(void)
Perform a Clear-Channel Assessment (CCA) to find out if there is a packet in the air or not.
A data strcuture representing the radio's primary mode of operation.
Header file with macros which rename TI CC26xxware functions.