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) 119 #define RF_CMD_CCA_REQ_RSSI_UNKNOWN -128 122 #define RF_CCA_CLEAR 1 123 #define RF_CCA_BUSY 0 126 #define RF_GET_CCA_INFO_ERROR 0xFF 132 #define RF_CMD_CCA_REQ_CCA_STATE_IDLE 0 133 #define RF_CMD_CCA_REQ_CCA_STATE_BUSY 1 134 #define RF_CMD_CCA_REQ_CCA_STATE_INVALID 2 136 #ifdef PROP_MODE_CONF_RSSI_THRESHOLD 137 #define PROP_MODE_RSSI_THRESHOLD PROP_MODE_CONF_RSSI_THRESHOLD 139 #define PROP_MODE_RSSI_THRESHOLD 0xA6 142 static int8_t rssi_threshold = PROP_MODE_RSSI_THRESHOLD;
145 static int off(
void);
147 static rfc_propRxOutput_t rx_stats;
150 #define DOT_4G_MAX_FRAME_LEN 2047 151 #define DOT_4G_PHR_LEN 2 154 #define DOT_4G_PHR_CRC16 0x10 155 #define DOT_4G_PHR_DW 0x08 157 #if PROP_MODE_USE_CRC16 159 #define DOT_4G_PHR_CRC_BIT DOT_4G_PHR_CRC16 163 #define DOT_4G_PHR_CRC_BIT 0 168 #define DOT_4G_PHR_DW_BIT DOT_4G_PHR_DW 170 #define DOT_4G_PHR_DW_BIT 0 174 #define TX_WAIT_TIMEOUT (RTIMER_SECOND >> 11) 177 #define ENTER_RX_WAIT_TIMEOUT (RTIMER_SECOND >> 10) 180 #ifdef PROP_MODE_CONF_TX_POWER_431_527 181 #define PROP_MODE_TX_POWER_431_527 PROP_MODE_CONF_TX_POWER_431_527 183 #define PROP_MODE_TX_POWER_431_527 prop_mode_tx_power_431_527 187 #ifdef PROP_MODE_CONF_TX_POWER_779_930 188 #define PROP_MODE_TX_POWER_779_930 PROP_MODE_CONF_TX_POWER_779_930 190 #define PROP_MODE_TX_POWER_779_930 prop_mode_tx_power_779_930 194 #if DOT_15_4G_FREQUENCY_BAND_ID==DOT_15_4G_FREQUENCY_BAND_470 195 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_431_527 197 #define TX_POWER_DRIVER PROP_MODE_TX_POWER_779_930 200 extern const prop_mode_tx_power_config_t TX_POWER_DRIVER[];
203 #define OUTPUT_POWER_MAX (TX_POWER_DRIVER[0].dbm) 204 #define OUTPUT_POWER_UNKNOWN 0xFFFF 207 static const prop_mode_tx_power_config_t *tx_power_current = &TX_POWER_DRIVER[1];
209 #ifdef PROP_MODE_CONF_LO_DIVIDER 210 #define PROP_MODE_LO_DIVIDER PROP_MODE_CONF_LO_DIVIDER 212 #define PROP_MODE_LO_DIVIDER 0x05 215 #ifdef PROP_MODE_CONF_RX_BUF_CNT 216 #define PROP_MODE_RX_BUF_CNT PROP_MODE_CONF_RX_BUF_CNT 218 #define PROP_MODE_RX_BUF_CNT 4 221 #define DATA_ENTRY_LENSZ_NONE 0 222 #define DATA_ENTRY_LENSZ_BYTE 1 223 #define DATA_ENTRY_LENSZ_WORD 2 230 #define RX_BUF_SIZE 140 231 static uint8_t rx_buf[PROP_MODE_RX_BUF_CNT][RX_BUF_SIZE] CC_ALIGN(4);
234 static dataQueue_t rx_data_queue = { 0 };
237 volatile static uint8_t *rx_read_entry;
240 #define TX_BUF_PAYLOAD_LEN 180 241 #define TX_BUF_HDR_LEN 2 243 static uint8_t tx_buf[TX_BUF_HDR_LEN + TX_BUF_PAYLOAD_LEN] CC_ALIGN(4);
252 return smartrf_settings_cmd_prop_rx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
258 return smartrf_settings_cmd_prop_tx_adv.status == RF_CORE_RADIO_OP_STATUS_ACTIVE;
266 uint8_t attempts = 0;
268 rfc_CMD_GET_RSSI_t cmd;
273 if(
on() != RF_CORE_CMD_OK) {
274 PRINTF(
"get_rssi: on() failed\n");
275 return RF_CMD_CCA_REQ_RSSI_UNKNOWN;
279 rssi = RF_CMD_CCA_REQ_RSSI_UNKNOWN;
281 while((rssi == RF_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) && ++attempts < 10) {
282 memset(&cmd, 0x00,
sizeof(cmd));
283 cmd.commandNo = CMD_GET_RSSI;
286 PRINTF(
"get_rssi: CMDSTA=0x%08lx\n", cmd_status);
290 rssi = (cmd_status >> 16) & 0xFF;
307 freq_khz = smartrf_settings_cmd_fs.frequency * 1000;
315 freq_khz += (((smartrf_settings_cmd_fs.fractFreq * 1000) + 65535) / 65536);
317 return (freq_khz - DOT_15_4G_CHAN0_FREQUENCY) / DOT_15_4G_CHANNEL_SPACING;
326 new_freq = DOT_15_4G_CHAN0_FREQUENCY + (channel * DOT_15_4G_CHANNEL_SPACING);
328 freq = (uint16_t)(new_freq / 1000);
329 frac = (new_freq - (freq * 1000)) * 65536 / 1000;
331 PRINTF(
"set_channel: %u = 0x%04x.0x%04x (%lu)\n", channel, freq, frac,
334 smartrf_settings_cmd_prop_radio_div_setup.centerFreq = freq;
335 smartrf_settings_cmd_fs.frequency = freq;
336 smartrf_settings_cmd_fs.fractFreq = frac;
340 get_tx_power_array_last_element(
void)
342 const prop_mode_tx_power_config_t *array = TX_POWER_DRIVER;
345 while(array->tx_power != OUTPUT_POWER_UNKNOWN) {
356 return tx_power_current->dbm;
368 for(i = get_tx_power_array_last_element(); i >= 0; --i) {
369 if(power <= TX_POWER_DRIVER[i].dbm) {
375 tx_power_current = &TX_POWER_DRIVER[i];
383 prop_div_radio_setup(
void)
386 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup;
388 rf_switch_select_path(RF_SWITCH_PATH_SUBGHZ);
391 smartrf_settings_cmd_prop_radio_div_setup.loDivider = PROP_MODE_LO_DIVIDER;
394 smartrf_settings_cmd_prop_radio_div_setup.txPower = tx_power_current->tx_power;
397 smartrf_settings_cmd_prop_radio_div_setup.config.frontEndMode =
398 RF_CORE_PROP_FRONT_END_MODE;
399 smartrf_settings_cmd_prop_radio_div_setup.config.biasMode =
400 RF_CORE_PROP_BIAS_MODE;
404 PRINTF(
"prop_div_radio_setup: DIV_SETUP, CMDSTA=0x%08lx, status=0x%04x\n",
405 cmd_status, cmd->status);
406 return RF_CORE_CMD_ERROR;
411 PRINTF(
"prop_div_radio_setup: DIV_SETUP wait, CMDSTA=0x%08lx," 412 "status=0x%04x\n", cmd_status, cmd->status);
413 return RF_CORE_CMD_ERROR;
416 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;
434 cmd_rx_adv->maxPktLen = DOT_4G_MAX_FRAME_LEN - cmd_rx_adv->lenOffset;
438 if(ret != RF_CORE_CMD_OK) {
439 PRINTF(
"rf_cmd_prop_rx: send_cmd ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
440 ret, cmd_status, cmd_rx_adv->status);
441 return RF_CORE_CMD_ERROR;
446 while(cmd_rx_adv->status != RF_CORE_RADIO_OP_STATUS_ACTIVE &&
447 (RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + ENTER_RX_WAIT_TIMEOUT)));
450 if(cmd_rx_adv->status != RF_CORE_RADIO_OP_STATUS_ACTIVE) {
451 PRINTF(
"rf_cmd_prop_rx: CMDSTA=0x%08lx, status=0x%04x\n",
452 cmd_status, cmd_rx_adv->status);
453 return RF_CORE_CMD_ERROR;
460 init_rx_buffers(
void)
462 rfc_dataEntry_t *entry;
465 for(i = 0; i < PROP_MODE_RX_BUF_CNT; i++) {
466 entry = (rfc_dataEntry_t *)rx_buf[i];
467 entry->status = DATA_ENTRY_STATUS_PENDING;
468 entry->config.type = DATA_ENTRY_TYPE_GEN;
469 entry->config.lenSz = DATA_ENTRY_LENSZ_WORD;
470 entry->length = RX_BUF_SIZE - 8;
471 entry->pNextEntry = rx_buf[i + 1];
474 ((rfc_dataEntry_t *)rx_buf[PROP_MODE_RX_BUF_CNT - 1])->pNextEntry = rx_buf[0];
483 PRINTF(
"rx_on_prop: We were on. PD=%u, RX=0x%04x\n",
485 return RF_CORE_CMD_OK;
489 ret = rf_cmd_prop_rx();
492 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
506 return RF_CORE_CMD_OK;
510 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
511 PRINTF(
"rx_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
517 if(smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_STOPPED ||
518 smartrf_settings_cmd_prop_rx_adv.status == PROP_DONE_ABORT) {
520 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
521 ret = RF_CORE_CMD_OK;
523 PRINTF(
"rx_off_prop: status=0x%04x\n",
524 smartrf_settings_cmd_prop_rx_adv.status);
525 ret = RF_CORE_CMD_ERROR;
539 return LPM_MODE_SLEEP;
542 return LPM_MODE_MAX_SUPPORTED;
545 LPM_MODULE(prop_lpm_module, request, NULL, NULL, LPM_DOMAIN_NONE);
551 rfc_radioOp_t *cmd = (rfc_radioOp_t *)&smartrf_settings_cmd_fs;
555 PRINTF(
"prop_fs: CMD_FS, CMDSTA=0x%08lx, status=0x%04x\n",
556 cmd_status, cmd->status);
557 return RF_CORE_CMD_ERROR;
562 PRINTF(
"prop_fs: CMD_FS wait, CMDSTA=0x%08lx, status=0x%04x\n",
563 cmd_status, cmd->status);
564 return RF_CORE_CMD_ERROR;
567 return RF_CORE_CMD_OK;
581 if(
rf_core_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CORE_CMD_OK) {
582 PRINTF(
"soft_off_prop: CMD_ABORT status=0x%08lx\n", cmd_status);
586 while((cmd->status & RF_CORE_RADIO_OP_MASKED_STATUS) ==
587 RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING);
593 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
594 PRINTF(
"soft_on_prop: prop_div_radio_setup() failed\n");
595 return RF_CORE_CMD_ERROR;
598 if(prop_fs() != RF_CORE_CMD_OK) {
599 PRINTF(
"soft_on_prop: prop_fs() failed\n");
600 return RF_CORE_CMD_ERROR;
616 if(ti_lib_chipinfo_chip_family_is_cc13xx() ==
false) {
617 return RF_CORE_CMD_ERROR;
621 memset(rx_buf, 0,
sizeof(rx_buf));
624 rx_data_queue.pCurrEntry = rx_buf[0];
625 rx_data_queue.pLastEntry = NULL;
628 rx_read_entry = rx_buf[0];
630 smartrf_settings_cmd_prop_rx_adv.pQueue = &rx_data_queue;
631 smartrf_settings_cmd_prop_rx_adv.pOutput = (uint8_t *)&rx_stats;
635 if(
on() != RF_CORE_CMD_OK) {
636 PRINTF(
"init: on() failed\n");
637 return RF_CORE_CMD_ERROR;
640 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
650 prepare(
const void *payload,
unsigned short payload_len)
652 int len = MIN(payload_len, TX_BUF_PAYLOAD_LEN);
654 memcpy(&tx_buf[TX_BUF_HDR_LEN], payload, len);
659 transmit(
unsigned short transmit_len)
664 volatile rfc_CMD_PROP_TX_ADV_t *cmd_tx_adv;
667 uint16_t total_length;
671 if(
on() != RF_CORE_CMD_OK) {
672 PRINTF(
"transmit: on() failed\n");
685 total_length = transmit_len + CRC_LEN;
687 tx_buf[0] = total_length & 0xFF;
688 tx_buf[1] = (total_length >> 8) + DOT_4G_PHR_DW_BIT + DOT_4G_PHR_CRC_BIT;
691 cmd_tx_adv = (rfc_CMD_PROP_TX_ADV_t *)&smartrf_settings_cmd_prop_tx_adv;
697 cmd_tx_adv->pktLen = transmit_len + DOT_4G_PHR_LEN;
698 cmd_tx_adv->pPkt = tx_buf;
710 ENERGEST_SWITCH(ENERGEST_TYPE_LISTEN, ENERGEST_TYPE_TRANSMIT);
715 while((cmd_tx_adv->status & RF_CORE_RADIO_OP_MASKED_STATUS)
716 == RF_CORE_RADIO_OP_MASKED_STATUS_RUNNING) {
720 if(cmd_tx_adv->status == RF_CORE_RADIO_OP_STATUS_PROP_DONE_OK) {
725 PRINTF(
"transmit: Not Sent OK status=0x%04x\n",
731 PRINTF(
"transmit: PROP_TX_ERR ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
732 ret, cmd_status, cmd_tx_adv->status);
740 ENERGEST_SWITCH(ENERGEST_TYPE_TRANSMIT, ENERGEST_TYPE_LISTEN);
749 cmd_tx_adv->status = RF_CORE_RADIO_OP_STATUS_IDLE;
761 send(
const void *payload,
unsigned short payload_len)
768 read_frame(
void *buf,
unsigned short buf_len)
771 rfc_dataEntryGeneral_t *entry = (rfc_dataEntryGeneral_t *)rx_read_entry;
772 uint8_t *data_ptr = &entry->data;
775 if(entry->status == DATA_ENTRY_STATUS_FINISHED) {
782 len = (*(uint16_t *)data_ptr);
788 memcpy(buf, data_ptr, len);
791 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, (int8_t)data_ptr[len]);
792 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, 0x7F);
796 rx_read_entry = entry->pNextEntry;
797 entry->status = DATA_ENTRY_STATUS_PENDING;
803 PRINTF(
"RXQ was full, re-enabling radio!\n");
816 int8_t rssi = RF_CMD_CCA_REQ_RSSI_UNKNOWN;
828 if(
on() != RF_CORE_CMD_OK) {
829 PRINTF(
"channel_clear: on() failed\n");
837 PRINTF(
"channel_clear: called while in TX\n");
842 while(rssi == RF_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) {
848 rssi = (cmd_status >> 16) & 0xFF;
855 if(rssi >= rssi_threshold) {
880 volatile rfc_dataEntry_t *entry = (rfc_dataEntry_t *)rx_data_queue.pCurrEntry;
884 if(entry->status == DATA_ENTRY_STATUS_FINISHED) {
889 entry = (rfc_dataEntry_t *)entry->pNextEntry;
890 }
while(entry != (rfc_dataEntry_t *)rx_data_queue.pCurrEntry);
904 return RF_CORE_CMD_OK;
915 smartrf_settings_cmd_prop_rx_adv.status);
916 return RF_CORE_CMD_OK;
921 PRINTF(
"on: rf_core_power_up() failed\n");
925 return RF_CORE_CMD_ERROR;
932 rf_patch_cpe_genfsk();
933 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
934 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
935 rf_patch_rfe_genfsk();
938 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
939 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) =
940 CMDR_DIR_CMD_1BYTE(CMD_BUS_REQUEST, 1);
943 ti_lib_rfc_adi3vco_ldo_voltage_mode(
true);
946 ti_lib_rfc_rtrim((rfc_radioOp_t *)&smartrf_settings_cmd_prop_radio_div_setup);
949 while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
950 HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0;
953 PRINTF(
"on: rf_core_start_rat() failed\n");
957 return RF_CORE_CMD_ERROR;
972 if(prop_div_radio_setup() != RF_CORE_CMD_OK) {
973 PRINTF(
"on: prop_div_radio_setup() failed\n");
974 return RF_CORE_CMD_ERROR;
977 if(prop_fs() != RF_CORE_CMD_OK) {
978 PRINTF(
"on: prop_fs() failed\n");
979 return RF_CORE_CMD_ERROR;
993 return RF_CORE_CMD_OK;
999 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
1005 smartrf_settings_cmd_prop_rx_adv.status = RF_CORE_RADIO_OP_STATUS_IDLE;
1007 return RF_CORE_CMD_OK;
1010 static radio_result_t
1014 return RADIO_RESULT_INVALID_VALUE;
1018 case RADIO_PARAM_POWER_MODE:
1020 *value =
rf_is_on() ? RADIO_POWER_MODE_ON : RADIO_POWER_MODE_OFF;
1021 return RADIO_RESULT_OK;
1022 case RADIO_PARAM_CHANNEL:
1024 return RADIO_RESULT_OK;
1025 case RADIO_PARAM_TXPOWER:
1026 *value = get_tx_power();
1027 return RADIO_RESULT_OK;
1028 case RADIO_PARAM_CCA_THRESHOLD:
1029 *value = rssi_threshold;
1030 return RADIO_RESULT_OK;
1031 case RADIO_PARAM_RSSI:
1032 *value = get_rssi();
1034 if(*value == RF_CMD_CCA_REQ_RSSI_UNKNOWN) {
1035 return RADIO_RESULT_ERROR;
1037 return RADIO_RESULT_OK;
1039 case RADIO_CONST_CHANNEL_MIN:
1041 return RADIO_RESULT_OK;
1042 case RADIO_CONST_CHANNEL_MAX:
1043 *value = DOT_15_4G_CHANNEL_MAX;
1044 return RADIO_RESULT_OK;
1045 case RADIO_CONST_TXPOWER_MIN:
1046 *value = TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm;
1047 return RADIO_RESULT_OK;
1048 case RADIO_CONST_TXPOWER_MAX:
1049 *value = OUTPUT_POWER_MAX;
1050 return RADIO_RESULT_OK;
1052 return RADIO_RESULT_NOT_SUPPORTED;
1056 static radio_result_t
1059 uint8_t was_off = 0;
1060 radio_result_t rv = RADIO_RESULT_OK;
1063 case RADIO_PARAM_POWER_MODE:
1064 if(value == RADIO_POWER_MODE_ON) {
1065 if(
on() != RF_CORE_CMD_OK) {
1066 PRINTF(
"set_value: on() failed (1)\n");
1067 return RADIO_RESULT_ERROR;
1069 return RADIO_RESULT_OK;
1071 if(value == RADIO_POWER_MODE_OFF) {
1073 return RADIO_RESULT_OK;
1075 return RADIO_RESULT_INVALID_VALUE;
1076 case RADIO_PARAM_CHANNEL:
1078 value > DOT_15_4G_CHANNEL_MAX) {
1079 return RADIO_RESULT_INVALID_VALUE;
1085 return RADIO_RESULT_OK;
1090 case RADIO_PARAM_TXPOWER:
1091 if(value < TX_POWER_DRIVER[get_tx_power_array_last_element()].dbm ||
1092 value > OUTPUT_POWER_MAX) {
1093 return RADIO_RESULT_INVALID_VALUE;
1098 set_tx_power(value);
1100 if(soft_on_prop() != RF_CORE_CMD_OK) {
1101 PRINTF(
"set_value: soft_on_prop() failed\n");
1102 rv = RADIO_RESULT_ERROR;
1105 return RADIO_RESULT_OK;
1106 case RADIO_PARAM_RX_MODE:
1107 return RADIO_RESULT_OK;
1108 case RADIO_PARAM_CCA_THRESHOLD:
1109 rssi_threshold = (int8_t)value;
1112 return RADIO_RESULT_NOT_SUPPORTED;
1118 if(
on() != RF_CORE_CMD_OK) {
1119 PRINTF(
"set_value: on() failed (2)\n");
1120 return RADIO_RESULT_ERROR;
1124 if(rx_off_prop() != RF_CORE_CMD_OK) {
1125 PRINTF(
"set_value: rx_off_prop() failed\n");
1126 rv = RADIO_RESULT_ERROR;
1129 if(soft_on_prop() != RF_CORE_CMD_OK) {
1130 PRINTF(
"set_value: rx_on_prop() failed\n");
1131 rv = RADIO_RESULT_ERROR;
1142 static radio_result_t
1143 get_object(radio_param_t param,
void *dest,
size_t size)
1145 return RADIO_RESULT_NOT_SUPPORTED;
1148 static radio_result_t
1149 set_object(radio_param_t param,
const void *src,
size_t size)
1151 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.
void rf_core_setup_interrupts(bool poll_mode)
Setup RF core interrupts.
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 with descriptors for the various modes of operation defined in IEEE 802.15.4g.
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.
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.
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.
uint8_t rf_ble_is_active()
Check whether the BLE beacond is currently active.
void rf_core_primary_mode_register(const rf_core_primary_mode_t *mode)
Register a primary mode for radio operation.
void rf_core_cmd_done_dis(bool poll_mode)
Disable the LAST_CMD_DONE and LAST_FG_CMD_DONE interrupts.
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 for the real-time timer module.
Header file for the CC13xx/CC26xx BLE driver.
Header file with definitions related to RF switch support.
uint8_t rf_core_is_accessible()
Check whether the RF core is accessible.
Header file for the CC13xx/CC26xx UART driver.
static int8_t set_channel(uint8_t channel)
Set the current operating channel.
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.
void rf_core_cmd_done_en(bool fg, bool poll_mode)
Enable interrupt on command done.
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.
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.
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.
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.