43#include "dev/watchdog.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
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
124static int8_t rssi_threshold = PROP_MODE_RSSI_THRESHOLD;
126#if MAC_CONF_WITH_TSCH
127static volatile rfc_dataEntry_t *packet_being_received;
133static 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
197extern 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
204static 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)
245static uint8_t rx_buf[PROP_MODE_RX_BUF_CNT][RX_BUF_SIZE] CC_ALIGN(4);
248static dataQueue_t rx_data_queue = { 0 };
251volatile 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
263static 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;
360get_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];
403prop_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;
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;
576LPM_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);
685prepare(
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);
696transmit(
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;
808send(
const void *payload,
unsigned short payload_len)
810 prepare(payload, payload_len);
811 return transmit(payload_len);
815release_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");
840read_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;
982receiving_packet(
void)
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;
1034 if(channel_clear() == RF_CORE_CCA_CLEAR) {
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;
1220set_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");
1415get_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;
1430set_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.
static uint8_t get_channel()
Get the current operating channel.
static void set_channel(uint8_t channel)
Set the current operating channel.
#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.
static void critical_exit(int_master_status_t status)
Exit a critical section and restore the master interrupt.
static int_master_status_t critical_enter()
Enter a critical section.
INT_MASTER_STATUS_DATATYPE int_master_status_t
Master interrupt state representation data type.
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.
static uint8_t transmitting(void)
Check the RF's TX status.
static uint8_t rf_is_on(void)
Checks whether the RFC domain is accessible and the RFC is in IEEE RX.
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.