43 #include "dev/watchdog.h" 47 #include "sys/clock.h" 48 #include "sys/critical.h" 60 #include "hw_rfc_dbell.h" 61 #include "hw_rfc_pwr.h" 64 #include "driverlib/rf_mailbox.h" 65 #include "driverlib/rf_common_cmd.h" 66 #include "driverlib/rf_data_entry.h" 67 #include "driverlib/rf_prop_mailbox.h" 68 #include "driverlib/rf_prop_cmd.h" 71 #include "rf_patches/rf_patch_cpe_genfsk.h" 72 #include "rf_patches/rf_patch_rfe_genfsk.h" 74 #include "rf-core/smartrf-settings.h" 83 #define PRINTF(...) printf(__VA_ARGS__) 89 #define DATA_ENTRY_STATUS_PENDING 0x00 90 #define DATA_ENTRY_STATUS_ACTIVE 0x01 91 #define DATA_ENTRY_STATUS_BUSY 0x02 92 #define DATA_ENTRY_STATUS_FINISHED 0x03 93 #define DATA_ENTRY_STATUS_UNFINISHED 0x04 96 #ifdef PROP_MODE_CONF_DW 97 #define PROP_MODE_DW PROP_MODE_CONF_DW 99 #define PROP_MODE_DW 0 102 #ifdef PROP_MODE_CONF_USE_CRC16 103 #define PROP_MODE_USE_CRC16 PROP_MODE_CONF_USE_CRC16 105 #define PROP_MODE_USE_CRC16 0 116 #define RF_RADIO_OP_GET_STATUS(a) GET_FIELD_V(a, radioOp, status) 118 #ifdef PROP_MODE_CONF_RSSI_THRESHOLD 119 #define PROP_MODE_RSSI_THRESHOLD PROP_MODE_CONF_RSSI_THRESHOLD 121 #define PROP_MODE_RSSI_THRESHOLD 0xA6 124 static int8_t rssi_threshold = PROP_MODE_RSSI_THRESHOLD;
126 #if MAC_CONF_WITH_TSCH 127 static volatile rfc_dataEntry_t *packet_being_received;
131 static int off(
void);
133 static rfc_propRxOutput_t rx_stats;
136 #define DOT_4G_PHR_LEN 2 139 #define DOT_4G_PHR_CRC16 0x10 140 #define DOT_4G_PHR_DW 0x08 142 #if PROP_MODE_USE_CRC16 144 #define DOT_4G_PHR_CRC_BIT DOT_4G_PHR_CRC16 148 #define DOT_4G_PHR_CRC_BIT 0 153 #define DOT_4G_PHR_DW_BIT DOT_4G_PHR_DW 155 #define DOT_4G_PHR_DW_BIT 0 174 #define MAX_PAYLOAD_LEN 125 177 #ifdef PROP_MODE_CONF_TX_POWER_431_527 178 #define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527 180 #define PROP_MODE_TX_POWER_431_527 prop_mode_tx_power_431_527 184 #ifdef PROP_MODE_CONF_TX_POWER_779_930 185 #define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930 187 #define PROP_MODE_TX_POWER_779_930 prop_mode_tx_power_779_930 191 #if DOT_15_4G_FREQUENCY_BAND_ID==DOT_15_4G_FREQUENCY_BAND_470 192 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_431_527 194 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930 197 extern const prop_mode_tx_power_config_t TX_POWER_DRIVER[];
200 #define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm) 201 #define OUTPUT_POWER_UNKNOWN 0xFFFF 204 static const prop_mode_tx_power_config_t *tx_power_current = &TX_POWER_DRIVER[1];
206 #ifdef PROP_MODE_CONF_LO_DIVIDER 207 #define PROP_MODE_LO_DIVIDER PROP_MODE_CONF_LO_DIVIDER 209 #define PROP_MODE_LO_DIVIDER 0x05 212 #ifdef PROP_MODE_CONF_RX_BUF_CNT 213 #define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT 215 #define PROP_MODE_RX_BUF_CNT 4 218 #define DATA_ENTRY_LENSZ_NONE 0 219 #define DATA_ENTRY_LENSZ_BYTE 1 220 #define DATA_ENTRY_LENSZ_WORD 2 223 #define RX_BUF_METADATA_SIZE \ 224 (CRC_LEN * RF_CORE_RX_BUF_INCLUDE_CRC \ 225 + RF_CORE_RX_BUF_INCLUDE_RSSI \ 226 + RF_CORE_RX_BUF_INCLUDE_CORR \ 227 + 4 * RF_CORE_RX_BUF_INCLUDE_TIMESTAMP) 230 #define RX_BUF_LENGTH_OFFSET sizeof(rfc_dataEntry_t) 232 #define RX_BUF_DATA_OFFSET (RX_BUF_LENGTH_OFFSET + DOT_4G_PHR_LEN) 234 #define ALIGN_TO_4(size) (((size) + 3) & ~3) 236 #define RX_BUF_SIZE ALIGN_TO_4(RX_BUF_DATA_OFFSET \ 238 + RX_BUF_METADATA_SIZE) 245 static uint8_t rx_buf[PROP_MODE_RX_BUF_CNT][RX_BUF_SIZE] CC_ALIGN(4);
248 static dataQueue_t rx_data_queue = { 0 };
251 volatile static uint8_t *rx_read_entry;
257 #define RAT_TIMESTAMP_OFFSET_SUB_GHZ USEC_TO_RADIO(160 * 6 - 240) 260 #define TX_BUF_PAYLOAD_LEN 180 261 #define TX_BUF_HDR_LEN 2 263 static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4);
272 return smartrf_settings_cmd_prop_rx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
278 return smartrf_settings_cmd_prop_tx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
286 uint8_t attempts = 0;
288 rfc_CMD_GET_RSSI_t cmd;
293 if(
on() != RF_CORE_CMD_OK) {
294 PRINTF(
"get_rssi: on() failed\n");
295 return RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
299 rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
301 while((rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) && ++attempts < 10) {
302 memset(&cmd, 0x00,
sizeof(cmd));
303 cmd.commandNo = CMD_GET_RSSI;
306 PRINTF(
"get_rssi: CMDSTA=0x%08lx\n", cmd_status);
310 rssi = (cmd_status >> 16) & 0xFF;
327 freq_khz = smartrf_settings_cmd_fs.frequency * 1000;
335 freq_khz += (((smartrf_settings_cmd_fs.fractFreq * 1000) + 65535) / 65536);
337 return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING;
346 new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING);
348 freq = (uint16_t)(new_freq / 1000);
349 frac = (new_freq - (freq * 1000)) * 65536 / 1000;
351 PRINTF(
"set_channel: %u = 0x%04x.0x%04x (%lu)\n", channel, freq, frac,
354 smartrf_settings_cmd_prop_radio_div_setup.centerFreq = freq;
355 smartrf_settings_cmd_fs.frequency = freq;
356 smartrf_settings_cmd_fs.fractFreq = frac;
360 get_tx_power_array_last_element(
void)
362 const prop_mode_tx_power_config_t *array = TX_POWER_DRIVER;
365 while(array->tx_power != OUTPUT_POWER_UNKNOWN) {
376 return tx_power_current->dbm;
388 for(i = get_tx_power_array_last_element(); i >= 0; --i) {
389 if(power <= TX_POWER_DRIVER[i].dbm) {
395 tx_power_current = &TX_POWER_DRIVER[i];
403 prop_div_radio_setup(
void)
406 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup;
408 rf_switch_select_path(RF_SWITCH_PATH_SUBGHZ);
411 smartrf_settings_cmd_prop_radio_div_setup.loDivider = PROP_MODE_LO_DIVIDER;
414 smartrf_settings_cmd_prop_radio_div_setup.txPower = tx_power_current->tx_power;
417 smartrf_settings_cmd_prop_radio_div_setup.config.frontEndMode =
418 RF_CORE_PROP_FRONT_END_MODE;
419 smartrf_settings_cmd_prop_radio_div_setup.config.biasMode =
420 RF_CORE_PROP_BIAS_MODE;
424 PRINTF(
"prop_div_radio_setup: DIV_SETUP, CMDSTA=0x%08lx, status=0x%04x\n",
425 cmd_status, cmd->status);
426 return RF_CORE_CMD_ERROR;
431 PRINTF(
"prop_div_radio_setup: DIV_SETUP wait, CMDSTA=0x%08lx," 432 "status=0x%04x\n", cmd_status, cmd->status);
433 return RF_CORE_CMD_ERROR;
436 return RF_CORE_CMD_OK;
443 volatile rfc_CMD_PROP_RX_ADV_t *cmd_rx_adv;
446 cmd_rx_adv = (rfc_CMD_PROP_RX_ADV_t *)&smartrf_settings_cmd_prop_rx_adv;
447 cmd_rx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
449 cmd_rx_adv->rxConf.bIncludeCrc = RF_CORE_RX_BUF_INCLUDE_CRC;
450 cmd_rx_adv->rxConf.bAppendRssi = RF_CORE_RX_BUF_INCLUDE_RSSI;
451 cmd_rx_adv->rxConf.bAppendTimestamp = RF_CORE_RX_BUF_INCLUDE_TIMESTAMP;
452 cmd_rx_adv->rxConf.bAppendStatus = RF_CORE_RX_BUF_INCLUDE_CORR;
457 cmd_rx_adv->maxPktLen = RADIO_PHY_OVERHEAD + MAX_PAYLOAD_LEN;
461 if(ret != RF_CORE_CMD_OK) {
462 PRINTF(
"rf_cmd_prop_rx: send_cmd ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
463 ret, cmd_status, cmd_rx_adv->status);
464 return RF_CORE_CMD_ERROR;
468 RF_CORE_ENTER_RX_TIMEOUT);
471 if(cmd_rx_adv->status != RF_CORE_RADIO_OP_STATUS_ACTIVE) {
472 PRINTF(
"rf_cmd_prop_rx: CMDSTA=0x%08lx, status=0x%04x\n",
473 cmd_status, cmd_rx_adv->status);
474 return RF_CORE_CMD_ERROR;
481 init_rx_buffers(
void)
483 rfc_dataEntry_t *entry;
486 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
487 entry = (rfc_dataEntry_t *)rx_buf[i];
488 entry->status = DATA_ENTRY_STATUS_PENDING;
489 entry->config.type = DATA_ENTRY_TYPE_GEN;
490 entry->config.lenSz = DATA_ENTRY_LENSZ_WORD;
491 entry->length = RX_BUF_SIZE - 8;
492 if(i == PROP_MODE_RX_BUF_CNT - 1) {
493 entry->pNextEntry = rx_buf[0];
495 entry->pNextEntry = rx_buf[i + 1];
506 PRINTF(
"rx_on_prop: We were on. PD=%u, RX=0x%04x\n",
508 return RF_CORE_CMD_OK;
512 ret = rf_cmd_prop_rx();
515 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
527 #if MAC_CONF_WITH_TSCH 529 packet_being_received = NULL;
534 return RF_CORE_CMD_OK;
541 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
542 PRINTF(
"rx_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
548 if(smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_STOPPED ||
549 smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_ABORT) {
551 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
552 ret = RF_CORE_CMD_OK;
554 PRINTF(
"rx_off_prop: status=0x%04x\n",
555 smartrf_settings_cmd_prop_rx_adv.status);
556 ret = RF_CORE_CMD_ERROR;
570 return LPM_MODE_SLEEP;
573 return LPM_MODE_MAX_SUPPORTED;
576 LPM_MODULE(prop_lpm_module, request, NULL, NULL, LPM_DOMAIN_NONE);
582 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_fs;
586 PRINTF(
"prop_fs: CMD_FS, CMDSTA=0x%08lx, status=0x%04x\n",
587 cmd_status, cmd->status);
588 return RF_CORE_CMD_ERROR;
593 PRINTF(
"prop_fs: CMD_FS wait, CMDSTA=0x%08lx, status=0x%04x\n",
594 cmd_status, cmd->status);
595 return RF_CORE_CMD_ERROR;
598 return RF_CORE_CMD_OK;
612 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
613 PRINTF(
"soft_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
618 RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING, RF_CORE_TURN_OFF_TIMEOUT);
624 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
625 PRINTF(
"soft_on_prop: prop_div_radio_setup() failed\n");
626 return RF_CORE_CMD_ERROR;
629 if(prop_fs() != RF_CORE_CMD_OK) {
630 PRINTF(
"soft_on_prop: prop_fs() failed\n");
631 return RF_CORE_CMD_ERROR;
641 RAT_TIMESTAMP_OFFSET_SUB_GHZ
649 if(ti_lib_chipinfo_chip_family_is_cc13xx() ==
false) {
650 return RF_CORE_CMD_ERROR;
654 memset(rx_buf, 0,
sizeof(rx_buf));
657 rx_data_queue.pCurrEntry = rx_buf[0];
658 rx_data_queue.pLastEntry = NULL;
661 rx_read_entry = rx_buf[0];
663 smartrf_settings_cmd_prop_rx_adv.pQueue = &rx_data_queue;
664 smartrf_settings_cmd_prop_rx_adv.pOutput = (uint8_t *)&rx_stats;
668 if(
on() != RF_CORE_CMD_OK) {
669 PRINTF(
"init: on() failed\n");
670 return RF_CORE_CMD_ERROR;
673 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
685 prepare(
const void *payload,
unsigned short payload_len)
687 if(payload_len > TX_BUF_PAYLOAD_LEN || payload_len > MAX_PAYLOAD_LEN) {
691 memcpy(&tx_buf[TX_BUF_HDR_LEN], payload, payload_len);
696 transmit(
unsigned short transmit_len)
701 volatile rfc_CMD_PROP_TX_ADV_t *cmd_tx_adv;
704 uint16_t total_length;
706 if(transmit_len > MAX_PAYLOAD_LEN) {
707 PRINTF(
"transmit: too long\n");
713 if(
on() != RF_CORE_CMD_OK) {
714 PRINTF(
"transmit: on() failed\n");
727 total_length = transmit_len + CRC_LEN;
729 tx_buf[0] = total_length & 0xFF;
730 tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT;
733 cmd_tx_adv = (rfc_CMD_PROP_TX_ADV_t *)&smartrf_settings_cmd_prop_tx_adv;
739 cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN;
740 cmd_tx_adv->pPkt = tx_buf;
752 ENERGEST_SWITCH(ENERGEST_TYPE_LISTEN, ENERGEST_TYPE_TRANSMIT);
755 while((cmd_tx_adv->status & RF_CORE_RADIO_OP_MASKED_STATUS)
756 == RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING) {
762 if(!rf_core_poll_mode) {
767 if(cmd_tx_adv->status == RF_CORE_RADIO_OP_STATUS_PROP_DONE_OK) {
772 PRINTF(
"transmit: Not Sent OK status=0x%04x\n",
778 PRINTF(
"transmit: PROP_TX_ERR ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
779 ret, cmd_status, cmd_tx_adv->status);
787 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
796 cmd_tx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
808 send(
const void *payload,
unsigned short payload_len)
815 release_data_entry(
void)
817 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
818 uint8_t *data_ptr = &entry->data;
826 entry->status = DATA_ENTRY_STATUS_PENDING;
827 rx_read_entry = entry->pNextEntry;
830 if(rf_core_rx_is_full) {
831 rf_core_rx_is_full =
false;
832 PRINTF(
"RXQ was full, re-enabling radio!\n");
840 read_frame(
void *buf,
unsigned short buf_len)
842 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
845 uint32_t rat_timestamp;
850 if(entry->status >= DATA_ENTRY_STATUS_BUSY) {
855 entry = (rfc_dataEntryGeneral_t *)entry->pNextEntry;
856 }
while(entry != (rfc_dataEntryGeneral_t *)rx_read_entry);
863 rx_read_entry = (
volatile uint8_t *)entry;
867 while(entry->status == DATA_ENTRY_STATUS_BUSY
868 && RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + RADIO_FRAME_DURATION(MAX_PAYLOAD_LEN)));
870 #if MAC_CONF_WITH_TSCH 872 packet_being_received = NULL;
875 if(entry->status != DATA_ENTRY_STATUS_FINISHED) {
886 data_ptr = &entry->data;
887 len = (*(uint16_t *)data_ptr);
889 if(len <= RX_BUF_METADATA_SIZE) {
890 PRINTF(
"RF: too short!");
892 release_data_entry();
897 len -= RX_BUF_METADATA_SIZE;
900 PRINTF(
"RF: too long\n");
902 release_data_entry();
906 memcpy(buf, data_ptr, len);
909 rf_core_last_rssi = (int8_t)data_ptr[len];
910 rf_core_last_corr_lqi = data_ptr[len + 5];
913 memcpy(&rat_timestamp, data_ptr + len + 1, 4);
917 if(!rf_core_poll_mode) {
921 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rf_core_last_rssi);
922 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, rf_core_last_corr_lqi);
925 release_data_entry();
935 int8_t rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
942 return RF_CORE_CCA_CLEAR;
947 if(
on() != RF_CORE_CMD_OK) {
948 PRINTF(
"channel_clear: on() failed\n");
952 return RF_CORE_CCA_CLEAR;
956 PRINTF(
"channel_clear: called while in TX\n");
957 return RF_CORE_CCA_CLEAR;
961 while(rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) {
967 rssi = (cmd_status >> 16) & 0xFF;
974 if(rssi >= rssi_threshold) {
975 return RF_CORE_CCA_BUSY;
978 return RF_CORE_CCA_CLEAR;
988 #if MAC_CONF_WITH_TSCH 996 if(packet_being_received == NULL) {
1000 if(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIFG) & RFC_DBELL_RFHWIFG_MDMSOFT) {
1001 packet_being_received = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
1005 if(packet_being_received->status >= DATA_ENTRY_FINISHED) {
1007 ti_lib_rfc_hw_int_clear(RFC_DBELL_RFHWIFG_MDMSOFT);
1008 packet_being_received = NULL;
1012 return packet_being_received != NULL;
1047 volatile rfc_dataEntry_t *entry = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
1051 if(entry->status >= DATA_ENTRY_STATUS_BUSY) {
1053 if(!rf_core_poll_mode) {
1058 entry = (rfc_dataEntry_t *)entry->pNextEntry;
1059 }
while(entry != (rfc_dataEntry_t *)rx_data_queue.pCurrEntry);
1073 return RF_CORE_CMD_OK;
1078 smartrf_settings_cmd_prop_rx_adv.status);
1079 return RF_CORE_CMD_OK;
1090 PRINTF(
"on: rf_core_power_up() failed\n");
1094 return RF_CORE_CMD_ERROR;
1101 rf_patch_cpe_genfsk();
1102 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1103 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1104 rf_patch_rfe_genfsk();
1107 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1108 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) =
1109 CMDR_DIR_CMD_1BYTE(CMD_BUS_REQUEST, 1);
1112 ti_lib_rfc_adi3vco_ldo_voltage_mode(
true);
1115 ti_lib_rfc_rtrim((rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup);
1118 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1119 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1122 PRINTF(
"on: rf_core_start_rat() failed\n");
1126 return RF_CORE_CMD_ERROR;
1141 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
1142 PRINTF(
"on: prop_div_radio_setup() failed\n");
1144 return RF_CORE_CMD_ERROR;
1147 if(prop_fs() != RF_CORE_CMD_OK) {
1148 PRINTF(
"on: prop_fs() failed\n");
1149 return RF_CORE_CMD_ERROR;
1152 if(rx_on_prop() != RF_CORE_CMD_OK) {
1154 if((
rf_core_cmd_status() & RF_CORE_CMDSTA_RESULT_MASK) != RF_CORE_CMDSTA_SCHEDULING_ERR) {
1156 return RF_CORE_CMD_ERROR;
1162 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &status) == RF_CORE_CMD_ERROR) {
1164 return RF_CORE_CMD_ERROR;
1168 if(soft_on_prop() != RF_CORE_CMD_OK) {
1170 return RF_CORE_CMD_ERROR;
1174 return RF_CORE_CMD_OK;
1181 rfc_dataEntry_t *entry;
1188 return RF_CORE_CMD_OK;
1194 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1196 #if !CC2650_FAST_RADIO_STARTUP 1202 smartrf_settings_cmd_prop_rx_adv.status = RF_CORE_RADIO_OP_STATUS_IDLE;
1208 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
1209 entry = (rfc_dataEntry_t *)rx_buf[i];
1210 if(entry->status == DATA_ENTRY_STATUS_BUSY) {
1211 entry->status = DATA_ENTRY_STATUS_PENDING;
1215 return RF_CORE_CMD_OK;
1220 set_send_on_cca(uint8_t enable)
1246 if(rf_core_poll_mode) {
1254 *value = get_tx_power();
1257 *value = rssi_threshold;
1260 *value = get_rssi();
1262 if(*value == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN) {
1271 *value = DOT_15_4G_CHANNEL_MAX;
1274 *value = TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm;
1277 *value = OUTPUT_POWER_MAX;
1280 *value = rf_core_last_rssi;
1283 *value = rf_core_last_corr_lqi;
1301 case RADIO_CONST_MAX_PAYLOAD_LEN:
1313 uint8_t old_poll_mode;
1318 if(
on() != RF_CORE_CMD_OK) {
1319 PRINTF(
"set_value: on() failed (1)\n");
1331 value > DOT_15_4G_CHANNEL_MAX) {
1349 old_poll_mode = rf_core_poll_mode;
1351 if(rf_core_poll_mode == old_poll_mode) {
1363 if(value < TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm ||
1364 value > OUTPUT_POWER_MAX) {
1370 set_tx_power(value);
1372 if(soft_on_prop() != RF_CORE_CMD_OK) {
1373 PRINTF(
"set_value: soft_on_prop() failed\n");
1380 rssi_threshold = (int8_t)value;
1392 if(rx_off_prop() != RF_CORE_CMD_OK) {
1393 PRINTF(
"set_value: rx_off_prop() failed\n");
1400 PRINTF(
"set_value: rf_core_restart_rat() failed\n");
1406 if(soft_on_prop() != RF_CORE_CMD_OK) {
1407 PRINTF(
"set_value: soft_on_prop() failed\n");
1415 get_object(radio_param_t param,
void *dest,
size_t size)
1418 if(size !=
sizeof(rtimer_clock_t) || !dest) {
1421 *(rtimer_clock_t *)dest = rf_core_last_packet_timestamp;
1430 set_object(radio_param_t param,
const void *src,
size_t size)
radio_result_t(* get_object)(radio_param_t param, void *dest, size_t size)
Get a radio parameter object.
void oscillators_request_hf_xosc(void)
Requests the HF XOSC as the source for the HF clock, but does not perform the actual switch...
static uint8_t transmitting(void)
Check the RF's TX status.
The delay in usec between turning on the radio and it being actually listening (able to hear a preamb...
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
static volatile uint64_t count
Num.
The parameter is not supported.
Header file with macros which rename TI CC26xxware functions.
static uint8_t rf_is_on(void)
Checks whether the RFC domain is accessible and the RFC is in IEEE RX.
Header file for the energy estimation mechanism
rfc_radioOp_t * rf_core_get_last_radio_op()
Returns a pointer to the most recent proto-dependent Radio Op.
Header file for the radio API
The delay in usec between a call to the radio API's transmit function and the end of SFD transmission...
The maximum transmission power in dBm.
static void critical_exit(int_master_status_t status)
Exit a critical section and restore the master interrupt.
int rf_core_power_up()
Turn on power to the RFC and boot it.
void rf_core_power_down()
Disable RFCORE clock domain in the MCU VD and turn off the RFCORE PD.
Received signal strength indicator in dBm.
int(* receiving_packet)(void)
Check if the radio driver is currently receiving a packet.
radio_result_t(* set_value)(radio_param_t param, radio_value_t value)
Set a radio parameter value.
int(* pending_packet)(void)
Check if a packet has been received and is available in the radio driver's buffers.
uint8_t rf_core_set_modesel()
Initialise RF APIs in the RF core.
The structure of a Contiki-NG radio device driver.
#define RTIMER_BUSYWAIT_UNTIL(cond, max_time)
Busy-wait until a condition for at most max_time.
static void set_channel(uint8_t channel)
Set the current operating channel.
Channel used for radio communication.
The value argument was incorrect.
The parameter was set/read successfully.
void lpm_sleep(void)
Enter sleep mode.
int(* channel_clear)(void)
Perform a Clear-Channel Assessment (CCA) to find out if there is a packet in the air or not...
Header file for the CC13xx/CC26xx RF core driver.
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
An error occurred when getting/setting the parameter, but the arguments were otherwise correct...
Radio transmission mode determines if the radio has send on CCA (RADIO_TX_MODE_SEND_ON_CCA) enabled o...
#define IEEE802154_DEFAULT_CHANNEL
The default channel for IEEE 802.15.4 networks.
static int_master_status_t critical_enter()
Enter a critical section.
#define RTIMER_NOW()
Get the current clock time.
Header file for the CC13xx/CC26xx oscillator control.
The RSSI value of the last received packet.
uint32_t rf_core_cmd_status(void)
Get the status of the last issued radio command.
The physical layer header (PHR) + MAC layer footer (MFR) overhead in bytes.
uint32_t rf_core_convert_rat_to_rtimer(uint32_t rat_timestamp)
Convert from RAT timestamp to rtimer ticks.
Clear channel assessment threshold in dBm.
Header file with descriptors for the various modes of operation defined in IEEE 802.15.4g.
void oscillators_switch_to_hf_rc(void)
Switches MF and HF clock source to be the HF RC OSC.
INT_MASTER_STATUS_DATATYPE int_master_status_t
Master interrupt state representation data type.
void rf_core_primary_mode_register(const rf_core_primary_mode_t *mode)
Register a primary mode for radio operation.
Header file for the CC13xx prop mode NETSTACK_RADIO driver.
int(* send)(const void *payload, unsigned short payload_len)
Prepare & transmit a packet.
A data strcuture representing the radio's primary mode of operation.
int(* transmit)(unsigned short transmit_len)
Send the packet that has previously been prepared.
void process_poll(struct process *p)
Request a process to be polled.
int(* off)(void)
Turn the radio off.
The lowest radio channel number.
Radio receiver mode determines if the radio has address filter (RADIO_RX_MODE_ADDRESS_FILTER) and aut...
Header file for the real-time timer module.
uint8_t rf_core_rat_init(void)
Initialize the RAT to RTC conversion machinery.
The highest radio channel number.
The air time of one byte in usec, e.g.
void rf_core_cmd_done_dis(void)
Disable the LAST_CMD_DONE and LAST_FG_CMD_DONE interrupts.
uint8_t rf_ble_is_active()
Check whether the BLE beacond is currently active.
When getting the value of this parameter, the radio driver should indicate whether the radio is on or...
Header file for the CC13xx/CC26xx BLE driver.
Header file with definitions related to RF switch support.
enum radio_result_e radio_result_t
Radio return values when setting or getting radio parameters.
#define RADIO_TX_MODE_SEND_ON_CCA
Radio TX mode control / retrieval.
uint8_t rf_core_is_accessible()
Check whether the RF core is accessible.
Header file for the CC13xx/CC26xx UART driver.
int(* init)(void)
Initialise the radio hardware.
The delay in usec between the end of SFD reception for an incoming frame and the radio API starting t...
#define RADIO_RX_MODE_POLL_MODE
Enable/disable/get the state of radio driver poll mode operation.
Link quality indicator of the last received packet.
void oscillators_switch_to_hf_xosc(void)
Performs the switch to the XOSC.
The minimum transmission power in dBm.
Radio powered on and able to receive frames.
Transmission power in dBm.
uint_fast8_t rf_core_send_cmd(uint32_t cmd, uint32_t *status)
Sends a command to the RF core.
Header file for the Packet buffer (packetbuf) management
#define LPM_MODULE(n, m, s, w, l)
Declare a variable to be used in order to get notifications from LPM.
void rf_core_setup_interrupts(void)
Setup RF core interrupts.
Include file for the Contiki low-layer network stack (NETSTACK)
uint8_t rf_core_start_rat(void)
Start the CM0 RAT.
uint8_t rf_core_restart_rat(void)
Restart the CM0 RAT.
radio_result_t(* get_value)(radio_param_t param, radio_value_t *value)
Get a radio parameter value.
Default definitions of C compiler quirk work-arounds.
Last packet timestamp, of type rtimer_clock_t.
An error occurred during transmission.
radio_result_t(* set_object)(radio_param_t param, const void *src, size_t size)
Set a radio parameter object.
Radio powered off and in the lowest possible power consumption state.
void rf_core_cmd_done_en(bool fg)
Enable interrupt on command done.
TX was successful and where an ACK was requested one was received.
uint8_t rf_core_check_rat_overflow(void)
Check if RAT overflow has occured and increment the overflow counter if so.
int(* on)(void)
Turn the radio on.
void process_start(struct process *p, process_data_t data)
Start a process.
void lpm_register_module(lpm_registered_module_t *module)
Register a module for LPM notifications.
uint_fast8_t rf_core_wait_cmd_done(void *cmd)
Block and wait for a Radio op to complete.
static uint8_t get_channel()
Get the current operating channel.