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 static volatile uint8_t is_receiving_packet;
129 static int off(
void);
131 static rfc_propRxOutput_t rx_stats;
134 #define DOT_4G_MAX_FRAME_LEN 2047 135 #define DOT_4G_PHR_LEN 2 138 #define DOT_4G_PHR_CRC16 0x10 139 #define DOT_4G_PHR_DW 0x08 141 #if PROP_MODE_USE_CRC16 143 #define DOT_4G_PHR_CRC_BIT DOT_4G_PHR_CRC16 147 #define DOT_4G_PHR_CRC_BIT 0 152 #define DOT_4G_PHR_DW_BIT DOT_4G_PHR_DW 154 #define DOT_4G_PHR_DW_BIT 0 158 #ifdef PROP_MODE_CONF_TX_POWER_431_527 159 #define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527 161 #define PROP_MODE_TX_POWER_431_527 prop_mode_tx_power_431_527 165 #ifdef PROP_MODE_CONF_TX_POWER_779_930 166 #define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930 168 #define PROP_MODE_TX_POWER_779_930 prop_mode_tx_power_779_930 172 #if DOT_15_4G_FREQUENCY_BAND_ID==DOT_15_4G_FREQUENCY_BAND_470 173 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_431_527 175 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930 178 extern const prop_mode_tx_power_config_t TX_POWER_DRIVER[];
181 #define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm) 182 #define OUTPUT_POWER_UNKNOWN 0xFFFF 185 static const prop_mode_tx_power_config_t *tx_power_current = &TX_POWER_DRIVER[1];
187 #ifdef PROP_MODE_CONF_LO_DIVIDER 188 #define PROP_MODE_LO_DIVIDER PROP_MODE_CONF_LO_DIVIDER 190 #define PROP_MODE_LO_DIVIDER 0x05 193 #ifdef PROP_MODE_CONF_RX_BUF_CNT 194 #define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT 196 #define PROP_MODE_RX_BUF_CNT 4 199 #define DATA_ENTRY_LENSZ_NONE 0 200 #define DATA_ENTRY_LENSZ_BYTE 1 201 #define DATA_ENTRY_LENSZ_WORD 2 204 #define RX_BUF_METADATA_SIZE \ 205 (CRC_LEN * RF_CORE_RX_BUF_INCLUDE_CRC \ 206 + RF_CORE_RX_BUF_INCLUDE_RSSI \ 207 + RF_CORE_RX_BUF_INCLUDE_CORR \ 208 + 4 * RF_CORE_RX_BUF_INCLUDE_TIMESTAMP) 211 #define RX_BUF_LENGTH_OFFSET sizeof(rfc_dataEntry_t) 213 #define RX_BUF_DATA_OFFSET (RX_BUF_LENGTH_OFFSET + DOT_4G_PHR_LEN) 215 #define ALIGN_TO_4(size) (((size) + 3) & ~3) 217 #define RX_BUF_SIZE ALIGN_TO_4(RX_BUF_DATA_OFFSET \ 218 + NETSTACK_RADIO_MAX_PAYLOAD_LEN \ 219 + RX_BUF_METADATA_SIZE) 226 static uint8_t rx_buf[PROP_MODE_RX_BUF_CNT][RX_BUF_SIZE] CC_ALIGN(4);
229 static dataQueue_t rx_data_queue = { 0 };
232 volatile static uint8_t *rx_read_entry;
238 #define RAT_TIMESTAMP_OFFSET_SUB_GHZ USEC_TO_RADIO(160 * 6 - 240) 241 #define TX_BUF_PAYLOAD_LEN 180 242 #define TX_BUF_HDR_LEN 2 244 static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4);
253 return smartrf_settings_cmd_prop_rx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
259 return smartrf_settings_cmd_prop_tx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
267 uint8_t attempts = 0;
269 rfc_CMD_GET_RSSI_t cmd;
274 if(
on() != RF_CORE_CMD_OK) {
275 PRINTF(
"get_rssi: on() failed\n");
276 return RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
280 rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
282 while((rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) && ++attempts < 10) {
283 memset(&cmd, 0x00,
sizeof(cmd));
284 cmd.commandNo = CMD_GET_RSSI;
287 PRINTF(
"get_rssi: CMDSTA=0x%08lx\n", cmd_status);
291 rssi = (cmd_status >> 16) & 0xFF;
308 freq_khz = smartrf_settings_cmd_fs.frequency * 1000;
316 freq_khz += (((smartrf_settings_cmd_fs.fractFreq * 1000) + 65535) / 65536);
318 return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING;
327 new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING);
329 freq = (uint16_t)(new_freq / 1000);
330 frac = (new_freq - (freq * 1000)) * 65536 / 1000;
332 PRINTF(
"set_channel: %u = 0x%04x.0x%04x (%lu)\n", channel, freq, frac,
335 smartrf_settings_cmd_prop_radio_div_setup.centerFreq = freq;
336 smartrf_settings_cmd_fs.frequency = freq;
337 smartrf_settings_cmd_fs.fractFreq = frac;
341 get_tx_power_array_last_element(
void)
343 const prop_mode_tx_power_config_t *array = TX_POWER_DRIVER;
346 while(array->tx_power != OUTPUT_POWER_UNKNOWN) {
357 return tx_power_current->dbm;
369 for(i = get_tx_power_array_last_element(); i >= 0; --i) {
370 if(power <= TX_POWER_DRIVER[i].dbm) {
376 tx_power_current = &TX_POWER_DRIVER[i];
384 prop_div_radio_setup(
void)
387 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup;
389 rf_switch_select_path(RF_SWITCH_PATH_SUBGHZ);
392 smartrf_settings_cmd_prop_radio_div_setup.loDivider = PROP_MODE_LO_DIVIDER;
395 smartrf_settings_cmd_prop_radio_div_setup.txPower = tx_power_current->tx_power;
398 smartrf_settings_cmd_prop_radio_div_setup.config.frontEndMode =
399 RF_CORE_PROP_FRONT_END_MODE;
400 smartrf_settings_cmd_prop_radio_div_setup.config.biasMode =
401 RF_CORE_PROP_BIAS_MODE;
405 PRINTF(
"prop_div_radio_setup: DIV_SETUP, CMDSTA=0x%08lx, status=0x%04x\n",
406 cmd_status, cmd->status);
407 return RF_CORE_CMD_ERROR;
412 PRINTF(
"prop_div_radio_setup: DIV_SETUP wait, CMDSTA=0x%08lx," 413 "status=0x%04x\n", cmd_status, cmd->status);
414 return RF_CORE_CMD_ERROR;
417 return RF_CORE_CMD_OK;
424 volatile rfc_CMD_PROP_RX_ADV_t *cmd_rx_adv;
427 cmd_rx_adv = (rfc_CMD_PROP_RX_ADV_t *)&smartrf_settings_cmd_prop_rx_adv;
428 cmd_rx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
430 cmd_rx_adv->rxConf.bIncludeCrc = RF_CORE_RX_BUF_INCLUDE_CRC;
431 cmd_rx_adv->rxConf.bAppendRssi = RF_CORE_RX_BUF_INCLUDE_RSSI;
432 cmd_rx_adv->rxConf.bAppendTimestamp = RF_CORE_RX_BUF_INCLUDE_TIMESTAMP;
433 cmd_rx_adv->rxConf.bAppendStatus = RF_CORE_RX_BUF_INCLUDE_CORR;
439 cmd_rx_adv->maxPktLen = DOT_4G_MAX_FRAME_LEN - cmd_rx_adv->lenOffset;
443 if(ret != RF_CORE_CMD_OK) {
444 PRINTF(
"rf_cmd_prop_rx: send_cmd ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
445 ret, cmd_status, cmd_rx_adv->status);
446 return RF_CORE_CMD_ERROR;
450 RF_CORE_ENTER_RX_TIMEOUT);
453 if(cmd_rx_adv->status != RF_CORE_RADIO_OP_STATUS_ACTIVE) {
454 PRINTF(
"rf_cmd_prop_rx: CMDSTA=0x%08lx, status=0x%04x\n",
455 cmd_status, cmd_rx_adv->status);
456 return RF_CORE_CMD_ERROR;
463 init_rx_buffers(
void)
465 rfc_dataEntry_t *entry;
468 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
469 entry = (rfc_dataEntry_t *)rx_buf[i];
470 entry->status = DATA_ENTRY_STATUS_PENDING;
471 entry->config.type = DATA_ENTRY_TYPE_GEN;
472 entry->config.lenSz = DATA_ENTRY_LENSZ_WORD;
473 entry->length = RX_BUF_SIZE - 8;
474 entry->pNextEntry = rx_buf[i + 1];
477 ((rfc_dataEntry_t *)rx_buf[PROP_MODE_RX_BUF_CNT - 1])->pNextEntry = rx_buf[0];
486 PRINTF(
"rx_on_prop: We were on. PD=%u, RX=0x%04x\n",
488 return RF_CORE_CMD_OK;
492 ret = rf_cmd_prop_rx();
495 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
509 return RF_CORE_CMD_OK;
516 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
517 PRINTF(
"rx_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
523 if(smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_STOPPED ||
524 smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_ABORT) {
526 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
527 ret = RF_CORE_CMD_OK;
529 PRINTF(
"rx_off_prop: status=0x%04x\n",
530 smartrf_settings_cmd_prop_rx_adv.status);
531 ret = RF_CORE_CMD_ERROR;
545 return LPM_MODE_SLEEP;
548 return LPM_MODE_MAX_SUPPORTED;
551 LPM_MODULE(prop_lpm_module, request, NULL, NULL, LPM_DOMAIN_NONE);
557 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_fs;
561 PRINTF(
"prop_fs: CMD_FS, CMDSTA=0x%08lx, status=0x%04x\n",
562 cmd_status, cmd->status);
563 return RF_CORE_CMD_ERROR;
568 PRINTF(
"prop_fs: CMD_FS wait, CMDSTA=0x%08lx, status=0x%04x\n",
569 cmd_status, cmd->status);
570 return RF_CORE_CMD_ERROR;
573 return RF_CORE_CMD_OK;
587 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
588 PRINTF(
"soft_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
593 RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING, RF_CORE_TURN_OFF_TIMEOUT);
599 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
600 PRINTF(
"soft_on_prop: prop_div_radio_setup() failed\n");
601 return RF_CORE_CMD_ERROR;
604 if(prop_fs() != RF_CORE_CMD_OK) {
605 PRINTF(
"soft_on_prop: prop_fs() failed\n");
606 return RF_CORE_CMD_ERROR;
616 RAT_TIMESTAMP_OFFSET_SUB_GHZ
624 if(ti_lib_chipinfo_chip_family_is_cc13xx() ==
false) {
625 return RF_CORE_CMD_ERROR;
629 memset(rx_buf, 0,
sizeof(rx_buf));
632 rx_data_queue.pCurrEntry = rx_buf[0];
633 rx_data_queue.pLastEntry = NULL;
636 rx_read_entry = rx_buf[0];
638 smartrf_settings_cmd_prop_rx_adv.pQueue = &rx_data_queue;
639 smartrf_settings_cmd_prop_rx_adv.pOutput = (uint8_t *)&rx_stats;
643 if(
on() != RF_CORE_CMD_OK) {
644 PRINTF(
"init: on() failed\n");
645 return RF_CORE_CMD_ERROR;
649 ti_lib_rfc_hw_int_enable(RFC_DBELL_RFHWIEN_MDMSOFT);
651 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
663 prepare(
const void *payload,
unsigned short payload_len)
665 int len = MIN(payload_len, TX_BUF_PAYLOAD_LEN);
667 memcpy(&tx_buf[TX_BUF_HDR_LEN], payload, len);
672 transmit(
unsigned short transmit_len)
677 volatile rfc_CMD_PROP_TX_ADV_t *cmd_tx_adv;
680 uint16_t total_length;
684 if(
on() != RF_CORE_CMD_OK) {
685 PRINTF(
"transmit: on() failed\n");
698 total_length = transmit_len + CRC_LEN;
700 tx_buf[0] = total_length & 0xFF;
701 tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT;
704 cmd_tx_adv = (rfc_CMD_PROP_TX_ADV_t *)&smartrf_settings_cmd_prop_tx_adv;
710 cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN;
711 cmd_tx_adv->pPkt = tx_buf;
723 ENERGEST_SWITCH(ENERGEST_TYPE_LISTEN, ENERGEST_TYPE_TRANSMIT);
728 while((cmd_tx_adv->status & RF_CORE_RADIO_OP_MASKED_STATUS)
729 == RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING) {
735 if(!rf_core_poll_mode) {
740 if(cmd_tx_adv->status == RF_CORE_RADIO_OP_STATUS_PROP_DONE_OK) {
745 PRINTF(
"transmit: Not Sent OK status=0x%04x\n",
751 PRINTF(
"transmit: PROP_TX_ERR ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
752 ret, cmd_status, cmd_tx_adv->status);
760 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
769 cmd_tx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
781 send(
const void *payload,
unsigned short payload_len)
788 release_data_entry(
void)
790 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
791 uint8_t *data_ptr = &entry->data;
799 entry->status = DATA_ENTRY_STATUS_PENDING;
800 rx_read_entry = entry->pNextEntry;
803 if(rf_core_rx_is_full) {
804 rf_core_rx_is_full =
false;
805 PRINTF(
"RXQ was full, re-enabling radio!\n");
813 read_frame(
void *buf,
unsigned short buf_len)
815 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
816 uint8_t *data_ptr = &entry->data;
818 uint32_t rat_timestamp;
822 while(entry->status == DATA_ENTRY_STATUS_BUSY
823 && RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + (RTIMER_SECOND / 50)));
826 is_receiving_packet = 0;
828 if(entry->status != DATA_ENTRY_STATUS_FINISHED) {
839 len = (*(uint16_t *)data_ptr);
841 if(len <= RX_BUF_METADATA_SIZE) {
842 PRINTF(
"RF: too short!");
844 release_data_entry();
849 len -= RX_BUF_METADATA_SIZE;
852 PRINTF(
"RF: too long\n");
854 release_data_entry();
858 memcpy(buf, data_ptr, len);
861 rf_core_last_rssi = (int8_t)data_ptr[len];
862 rf_core_last_corr_lqi = data_ptr[len + 5];
865 memcpy(&rat_timestamp, data_ptr + len + 1, 4);
869 if(!rf_core_poll_mode) {
873 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rf_core_last_rssi);
874 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, rf_core_last_corr_lqi);
877 release_data_entry();
887 int8_t rssi = RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN;
894 return RF_CORE_CCA_CLEAR;
899 if(
on() != RF_CORE_CMD_OK) {
900 PRINTF(
"channel_clear: on() failed\n");
904 return RF_CORE_CCA_CLEAR;
908 PRINTF(
"channel_clear: called while in TX\n");
909 return RF_CORE_CCA_CLEAR;
913 while(rssi == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) {
919 rssi = (cmd_status >> 16) & 0xFF;
926 if(rssi >= rssi_threshold) {
927 return RF_CORE_CCA_BUSY;
930 return RF_CORE_CCA_CLEAR;
940 if(!is_receiving_packet) {
944 if(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIFG) & RFC_DBELL_RFHWIFG_MDMSOFT) {
945 is_receiving_packet = 1;
950 if(!is_receiving_packet) {
952 ti_lib_rfc_hw_int_clear(RFC_DBELL_RFHWIFG_MDMSOFT);
956 return is_receiving_packet;
963 volatile rfc_dataEntry_t *entry = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
967 if(entry->status == DATA_ENTRY_STATUS_FINISHED
968 || entry->status == DATA_ENTRY_STATUS_BUSY) {
970 if(!rf_core_poll_mode) {
975 entry = (rfc_dataEntry_t *)entry->pNextEntry;
976 }
while(entry != (rfc_dataEntry_t *)rx_data_queue.pCurrEntry);
990 return RF_CORE_CMD_OK;
995 smartrf_settings_cmd_prop_rx_adv.status);
996 return RF_CORE_CMD_OK;
1007 PRINTF(
"on: rf_core_power_up() failed\n");
1011 return RF_CORE_CMD_ERROR;
1018 rf_patch_cpe_genfsk();
1019 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1020 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1021 rf_patch_rfe_genfsk();
1024 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1025 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) =
1026 CMDR_DIR_CMD_1BYTE(CMD_BUS_REQUEST, 1);
1029 ti_lib_rfc_adi3vco_ldo_voltage_mode(
true);
1032 ti_lib_rfc_rtrim((rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup);
1035 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
1036 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
1039 PRINTF(
"on: rf_core_start_rat() failed\n");
1043 return RF_CORE_CMD_ERROR;
1058 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
1059 PRINTF(
"on: prop_div_radio_setup() failed\n");
1060 return RF_CORE_CMD_ERROR;
1063 if(prop_fs() != RF_CORE_CMD_OK) {
1064 PRINTF(
"on: prop_fs() failed\n");
1065 return RF_CORE_CMD_ERROR;
1068 return rx_on_prop();
1075 rfc_dataEntry_t *entry;
1082 return RF_CORE_CMD_OK;
1088 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1090 #if !CC2650_FAST_RADIO_STARTUP 1096 smartrf_settings_cmd_prop_rx_adv.status = RF_CORE_RADIO_OP_STATUS_IDLE;
1102 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
1103 entry = (rfc_dataEntry_t *)rx_buf[i];
1104 if(entry->status == DATA_ENTRY_STATUS_BUSY) {
1105 entry->status = DATA_ENTRY_STATUS_PENDING;
1109 return RF_CORE_CMD_OK;
1113 static radio_result_t
1114 set_send_on_cca(uint8_t enable)
1118 return RADIO_RESULT_NOT_SUPPORTED;
1120 return RADIO_RESULT_OK;
1123 static radio_result_t
1127 return RADIO_RESULT_INVALID_VALUE;
1131 case RADIO_PARAM_POWER_MODE:
1133 *value =
rf_is_on() ? RADIO_POWER_MODE_ON : RADIO_POWER_MODE_OFF;
1134 return RADIO_RESULT_OK;
1135 case RADIO_PARAM_CHANNEL:
1137 return RADIO_RESULT_OK;
1138 case RADIO_PARAM_RX_MODE:
1140 if(rf_core_poll_mode) {
1141 *value |= RADIO_RX_MODE_POLL_MODE;
1143 return RADIO_RESULT_OK;
1144 case RADIO_PARAM_TX_MODE:
1146 return RADIO_RESULT_OK;
1147 case RADIO_PARAM_TXPOWER:
1148 *value = get_tx_power();
1149 return RADIO_RESULT_OK;
1150 case RADIO_PARAM_CCA_THRESHOLD:
1151 *value = rssi_threshold;
1152 return RADIO_RESULT_OK;
1153 case RADIO_PARAM_RSSI:
1154 *value = get_rssi();
1156 if(*value == RF_CORE_CMD_CCA_REQ_RSSI_UNKNOWN) {
1157 return RADIO_RESULT_ERROR;
1159 return RADIO_RESULT_OK;
1161 case RADIO_CONST_CHANNEL_MIN:
1163 return RADIO_RESULT_OK;
1164 case RADIO_CONST_CHANNEL_MAX:
1165 *value = DOT_15_4G_CHANNEL_MAX;
1166 return RADIO_RESULT_OK;
1167 case RADIO_CONST_TXPOWER_MIN:
1168 *value = TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm;
1169 return RADIO_RESULT_OK;
1170 case RADIO_CONST_TXPOWER_MAX:
1171 *value = OUTPUT_POWER_MAX;
1172 return RADIO_RESULT_OK;
1173 case RADIO_PARAM_LAST_RSSI:
1174 *value = rf_core_last_rssi;
1175 return RADIO_RESULT_OK;
1176 case RADIO_PARAM_LAST_LINK_QUALITY:
1177 *value = rf_core_last_corr_lqi;
1178 return RADIO_RESULT_OK;
1179 case RADIO_CONST_PHY_OVERHEAD:
1182 return RADIO_RESULT_OK;
1183 case RADIO_CONST_BYTE_AIR_TIME:
1185 return RADIO_RESULT_OK;
1186 case RADIO_CONST_DELAY_BEFORE_TX:
1188 return RADIO_RESULT_OK;
1189 case RADIO_CONST_DELAY_BEFORE_RX:
1191 return RADIO_RESULT_OK;
1192 case RADIO_CONST_DELAY_BEFORE_DETECT:
1194 return RADIO_RESULT_OK;
1196 return RADIO_RESULT_NOT_SUPPORTED;
1200 static radio_result_t
1203 radio_result_t rv = RADIO_RESULT_OK;
1204 uint8_t old_poll_mode;
1207 case RADIO_PARAM_POWER_MODE:
1208 if(value == RADIO_POWER_MODE_ON) {
1209 if(
on() != RF_CORE_CMD_OK) {
1210 PRINTF(
"set_value: on() failed (1)\n");
1211 return RADIO_RESULT_ERROR;
1213 return RADIO_RESULT_OK;
1215 if(value == RADIO_POWER_MODE_OFF) {
1217 return RADIO_RESULT_OK;
1219 return RADIO_RESULT_INVALID_VALUE;
1220 case RADIO_PARAM_CHANNEL:
1222 value > DOT_15_4G_CHANNEL_MAX) {
1223 return RADIO_RESULT_INVALID_VALUE;
1229 return RADIO_RESULT_OK;
1235 case RADIO_PARAM_RX_MODE:
1236 if(value & ~(RADIO_RX_MODE_POLL_MODE)) {
1237 return RADIO_RESULT_INVALID_VALUE;
1240 old_poll_mode = rf_core_poll_mode;
1241 rf_core_poll_mode = (value & RADIO_RX_MODE_POLL_MODE) != 0;
1242 if(rf_core_poll_mode == old_poll_mode) {
1243 return RADIO_RESULT_OK;
1247 case RADIO_PARAM_TX_MODE:
1249 return RADIO_RESULT_INVALID_VALUE;
1253 case RADIO_PARAM_TXPOWER:
1254 if(value < TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm ||
1255 value > OUTPUT_POWER_MAX) {
1256 return RADIO_RESULT_INVALID_VALUE;
1261 set_tx_power(value);
1263 if(soft_on_prop() != RF_CORE_CMD_OK) {
1264 PRINTF(
"set_value: soft_on_prop() failed\n");
1265 rv = RADIO_RESULT_ERROR;
1268 return RADIO_RESULT_OK;
1270 case RADIO_PARAM_CCA_THRESHOLD:
1271 rssi_threshold = (int8_t)value;
1274 return RADIO_RESULT_NOT_SUPPORTED;
1279 return RADIO_RESULT_OK;
1283 if(rx_off_prop() != RF_CORE_CMD_OK) {
1284 PRINTF(
"set_value: rx_off_prop() failed\n");
1285 rv = RADIO_RESULT_ERROR;
1291 PRINTF(
"set_value: rf_core_restart_rat() failed\n");
1297 if(soft_on_prop() != RF_CORE_CMD_OK) {
1298 PRINTF(
"set_value: soft_on_prop() failed\n");
1299 rv = RADIO_RESULT_ERROR;
1305 static radio_result_t
1306 get_object(radio_param_t param,
void *dest,
size_t size)
1308 if(param == RADIO_PARAM_LAST_PACKET_TIMESTAMP) {
1309 if(size !=
sizeof(rtimer_clock_t) || !dest) {
1310 return RADIO_RESULT_INVALID_VALUE;
1312 *(rtimer_clock_t *)dest = rf_core_last_packet_timestamp;
1314 return RADIO_RESULT_OK;
1317 return RADIO_RESULT_NOT_SUPPORTED;
1320 static radio_result_t
1321 set_object(radio_param_t param,
const void *src,
size_t size)
1323 return RADIO_RESULT_NOT_SUPPORTED;
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.
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
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
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.
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 the radio driver has just received a packet.
uint8_t rf_core_set_modesel()
Initialise RF APIs in the RF core.
The structure of a device driver for a radio in Contiki.
#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.
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...
#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.
uint32_t rf_core_convert_rat_to_rtimer(uint32_t rat_timestamp)
Convert from RAT timestamp to rtimer ticks.
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.
Header file with descriptors for the various modes of operation defined in IEEE 802.15.4g.
Header file for the real-time timer module.
uint8_t rf_core_rat_init(void)
Initialize the RAT to RTC conversion machinery.
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.
Header file for the CC13xx/CC26xx BLE driver.
Header file with definitions related to RF switch support.
#define RADIO_TX_MODE_SEND_ON_CCA
The radio transmission mode controls whether transmissions should be done using clear channel assessm...
uint8_t rf_core_is_accessible()
Check whether the RF core is accessible.
Header file for the CC13xx/CC26xx UART driver.
void oscillators_switch_to_hf_xosc(void)
Performs the switch to the XOSC.
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.
void watchdog_periodic(void)
Writes the WDT clear sequence.
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.
radio_result_t(* set_object)(radio_param_t param, const void *src, size_t size)
Set a radio parameter object.
void rf_core_cmd_done_en(bool fg)
Enable interrupt on command done.
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.