49 #include "sys/clock.h" 55 #include <ti/devices/DeviceFamily.h> 56 #include DeviceFamily_constructPath(driverlib/rf_common_cmd.h) 57 #include DeviceFamily_constructPath(driverlib/rf_data_entry.h) 58 #include DeviceFamily_constructPath(driverlib/rf_mailbox.h) 67 #include <ti/drivers/rf/RF.h> 85 #define LOG_MODULE "Radio" 86 #define LOG_LEVEL LOG_LEVEL_NONE 89 #define IEEE_MODE_AUTOACK IEEE_MODE_CONF_AUTOACK 90 #define IEEE_MODE_PROMISCOUS IEEE_MODE_CONF_PROMISCOUS 91 #define IEEE_MODE_CCA_RSSI_THRESHOLD IEEE_MODE_CONF_CCA_RSSI_THRESHOLD 96 #define TIMEOUT_DATA_ENTRY_BUSY (RTIMER_SECOND / 250) 99 #define TIMEOUT_ENTER_RX_WAIT (RTIMER_SECOND >> 10) 101 #define RAT_RANGE (~(uint32_t)0) 102 #define RAT_ONE_QUARTER (RAT_RANGE / (uint32_t)4) 103 #define RAT_THREE_QUARTERS ((RAT_RANGE * (uint32_t)3) / (uint32_t)4) 106 #define RAT_TIMESTAMP_OFFSET -(USEC_TO_RAT(32 * 3) - 1) 108 #define STATUS_CORRELATION 0x3f 109 #define STATUS_REJECT_FRAME 0x40 110 #define STATUS_CRC_FAIL 0x80 112 #define FRAME_FCF_OFFSET 0 113 #define FRAME_SEQNUM_OFFSET 2 115 #define FRAME_ACK_REQUEST 0x20 118 #define TX_BUF_SIZE 180 121 typedef uint8_t lensz_t;
123 #define FRAME_OFFSET sizeof(lensz_t) 124 #define FRAME_SHAVE 8 130 CCA_STATE_INVALID = 2
134 typedef rfc_ieeeRxOutput_t rx_output_t;
135 typedef rfc_CMD_IEEE_MOD_FILT_t cmd_mod_filt_t;
136 typedef rfc_CMD_IEEE_CCA_REQ_t cmd_cca_req_t;
140 uint8_t tx_buf[TX_BUF_SIZE] CC_ALIGN(4);
143 rx_output_t rx_stats;
161 struct ctimer overflow_timer;
162 rtimer_clock_t last_overflow;
163 volatile uint32_t overflow_count;
170 static ieee_radio_t ieee_radio;
173 static cmd_mod_filt_t cmd_mod_filt;
176 #define cmd_radio_setup (*(volatile rfc_CMD_RADIO_SETUP_t *)&rf_cmd_ieee_radio_setup) 177 #define cmd_fs (*(volatile rfc_CMD_FS_t *) &rf_cmd_ieee_fs) 178 #define cmd_tx (*(volatile rfc_CMD_IEEE_TX_t *) &rf_cmd_ieee_tx) 179 #define cmd_rx (*(volatile rfc_CMD_IEEE_RX_t *) &rf_cmd_ieee_rx) 180 #define cmd_rx_ack (*(volatile rfc_CMD_IEEE_RX_ACK_t *)&rf_cmd_ieee_rx_ack) 185 return cmd_rx.status == ACTIVE;
189 static void check_rat_overflow(
void);
190 static uint32_t rat_to_timestamp(
const uint32_t);
193 static int init(
void);
194 static int prepare(
const void *,
unsigned short);
195 static int transmit(
unsigned short);
196 static int send(
const void *,
unsigned short);
197 static int read(
void *,
unsigned short);
202 static int off(
void);
205 static radio_result_t
get_object(radio_param_t,
void *,
size_t);
206 static radio_result_t
set_object(radio_param_t,
const void *,
size_t);
209 rat_overflow_cb(
void *arg)
211 check_rat_overflow();
213 const clock_time_t two_quarters = (2 * RAT_ONE_QUARTER *
CLOCK_SECOND) / RAT_SECOND;
214 ctimer_set(&ieee_radio.rat.overflow_timer, two_quarters, rat_overflow_cb, NULL);
220 cmd_radio_setup.config.frontEndMode = RF_2_4_GHZ_FRONT_END_MODE;
221 cmd_radio_setup.config.biasMode = RF_2_4_GHZ_BIAS_MODE;
223 data_queue_t *rx_q = data_queue_init(
sizeof(lensz_t));
226 cmd_rx.pOutput = &ieee_radio.rx_stats;
228 #if IEEE_MODE_PROMISCOUS 229 cmd_rx.frameFiltOpt.frameFiltEn = 0;
231 cmd_rx.frameFiltOpt.frameFiltEn = 1;
234 #if IEEE_MODE_AUTOACK 235 cmd_rx.frameFiltOpt.autoAckEn = 1;
237 cmd_rx.frameFiltOpt.autoAckEn = 0;
240 cmd_rx.ccaRssiThr = IEEE_MODE_CCA_RSSI_THRESHOLD;
242 cmd_tx.pNextOp = (RF_Op *)&cmd_rx_ack;
243 cmd_tx.condition.rule = COND_NEVER;
253 cmd_rx_ack.startTrigger.triggerType = TRIG_NOW;
254 cmd_rx_ack.endTrigger.triggerType = TRIG_REL_START;
255 cmd_rx_ack.endTime = RF_convertUsToRatTicks(700);
258 cmd_mod_filt.commandNo = CMD_IEEE_MOD_FILT;
266 if(!dot_15_4g_chan_in_range(channel)) {
267 LOG_WARN(
"Supplied hannel %d is illegal, defaults to %d\n",
268 (
int)channel, DOT_15_4G_DEFAULT_CHAN);
269 channel = DOT_15_4G_DEFAULT_CHAN;
277 if(channel == cmd_rx.channel) {
282 cmd_rx.channel = channel;
284 const uint32_t new_freq = dot_15_4g_freq(channel);
285 const uint16_t freq = (uint16_t)(new_freq / 1000);
286 const uint16_t frac = (uint16_t)(((new_freq - (freq * 1000)) * 0x10000) / 1000);
288 LOG_DBG(
"Set channel to %d, frequency 0x%04X.0x%04X (%lu)\n",
289 (
int)channel, freq, frac, new_freq);
291 cmd_fs.frequency = freq;
292 cmd_fs.fractFreq = frac;
294 return netstack_sched_fs();
298 set_send_on_cca(
bool enable)
300 ieee_radio.send_on_cca = enable;
304 check_rat_overflow(
void)
306 const bool was_off = !rx_is_active();
309 RF_runDirectCmd(ieee_radio.rf_handle, CMD_NOP);
312 const uint32_t current_value = RF_getCurrentTime();
314 static bool initial_iteration =
true;
315 static uint32_t last_value;
317 if(initial_iteration) {
319 initial_iteration =
false;
322 if((current_value + RAT_ONE_QUARTER) < last_value) {
325 ieee_radio.rat.overflow_count += 1;
329 last_value = current_value;
332 RF_yield(ieee_radio.rf_handle);
337 rat_to_timestamp(
const uint32_t rat_ticks)
339 check_rat_overflow();
341 uint64_t adjusted_overflow_count = ieee_radio.rat.overflow_count;
345 if(rat_ticks > RAT_THREE_QUARTERS) {
346 const rtimer_clock_t one_quarter = (RAT_ONE_QUARTER * RTIMER_SECOND) / RAT_SECOND;
347 if(RTIMER_CLOCK_LT(
RTIMER_NOW(), ieee_radio.rat.last_overflow + one_quarter)) {
348 adjusted_overflow_count -= 1;
353 const uint64_t rat_ticks_adjusted = (uint64_t)rat_ticks + (uint64_t)RAT_RANGE * adjusted_overflow_count;
356 return RAT_TO_RTIMER(rat_ticks_adjusted + RAT_TIMESTAMP_OFFSET);
362 if(ieee_radio.rf_handle) {
363 LOG_WARN(
"Radio already initialized\n");
368 ieee_radio.rf_is_on =
false;
374 RF_Params_init(&rf_params);
377 ieee_radio.rf_handle = netstack_open(&rf_params);
379 if(ieee_radio.rf_handle == NULL) {
380 LOG_ERR(
"Unable to open RF driver\n");
381 return RF_RESULT_ERROR;
386 int8_t max_tx_power = tx_power_max(rf_tx_power_table, rf_tx_power_table_size);
387 rf_set_tx_power(ieee_radio.rf_handle, rf_tx_power_table, max_tx_power);
389 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
392 check_rat_overflow();
393 clock_time_t two_quarters = (2 * RAT_ONE_QUARTER *
CLOCK_SECOND) / RAT_SECOND;
394 ctimer_set(&ieee_radio.rat.overflow_timer, two_quarters, rat_overflow_cb, NULL);
403 prepare(
const void *payload,
unsigned short payload_len)
405 if(payload_len > TX_BUF_SIZE || payload_len > NETSTACK_RADIO_MAX_PAYLOAD_LEN) {
408 memcpy(ieee_radio.tx_buf, payload, payload_len);
413 transmit(
unsigned short transmit_len)
417 if(transmit_len > NETSTACK_RADIO_MAX_PAYLOAD_LEN) {
418 LOG_ERR(
"Too long\n");
423 LOG_WARN(
"Channel is not clear for transmission\n");
424 return RADIO_TX_COLLISION;
431 const bool ack_request = (bool)(ieee_radio.tx_buf[FRAME_FCF_OFFSET] & FRAME_ACK_REQUEST);
434 cmd_tx.condition.rule = COND_STOP_ON_FALSE;
437 cmd_rx_ack.status = IDLE;
439 cmd_rx_ack.seqNo = ieee_radio.tx_buf[FRAME_SEQNUM_OFFSET];
442 cmd_tx.condition.rule = COND_NEVER;
446 cmd_tx.payloadLen = (uint8_t)transmit_len;
447 cmd_tx.pPayload = ieee_radio.tx_buf;
449 res = netstack_sched_ieee_tx(ack_request);
451 if(res != RF_RESULT_OK) {
456 switch(cmd_rx_ack.status) {
458 case IEEE_DONE_TIMEOUT:
return RADIO_TX_NOACK;
461 case IEEE_DONE_ACKPEND:
return RADIO_TX_OK;
463 default:
return RADIO_TX_ERR;
472 send(
const void *payload,
unsigned short payload_len)
479 read(
void *buf,
unsigned short buf_len)
481 volatile data_entry_t *data_entry = data_queue_current_entry();
485 while((data_entry->status == DATA_ENTRY_BUSY) &&
486 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + TIMEOUT_DATA_ENTRY_BUSY)) ;
488 if(data_entry->status != DATA_ENTRY_FINISHED) {
513 uint8_t *
const frame_ptr = (uint8_t *)&data_entry->data;
514 const lensz_t frame_len = *(lensz_t *)frame_ptr;
518 LOG_ERR(
"Received frame too short, len=%d\n", frame_len);
520 data_queue_release_entry();
524 const uint8_t *payload_ptr = frame_ptr +
sizeof(lensz_t);
525 const unsigned short payload_len = (
unsigned short)(frame_len -
FRAME_SHAVE);
528 if(payload_len > buf_len) {
529 LOG_ERR(
"MAC payload too large for buffer, len=%d buf_len=%d\n",
530 payload_len, buf_len);
532 data_queue_release_entry();
536 memcpy(buf, payload_ptr, payload_len);
539 ieee_radio.last.rssi = (int8_t)payload_ptr[payload_len + 2];
541 ieee_radio.last.corr_lqi = (uint8_t)(payload_ptr[payload_len + 3] & STATUS_CORRELATION);
543 const uint32_t rat_ticks = *(uint32_t *)(payload_ptr + payload_len + 4);
544 ieee_radio.last.timestamp = rat_to_timestamp(rat_ticks);
546 if(!ieee_radio.poll_mode) {
550 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, (packetbuf_attr_t)ieee_radio.last.rssi);
551 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, (packetbuf_attr_t)ieee_radio.last.corr_lqi);
554 data_queue_release_entry();
555 return (
int)payload_len;
559 cca_request(cmd_cca_req_t *cmd_cca_req)
561 RF_Stat stat = RF_StatRadioInactiveError;
563 bool stop_rx =
false;
566 if(!rx_is_active()) {
568 if(cmd_rx.status != PENDING) {
569 res = netstack_sched_rx(
false);
570 if(res != RF_RESULT_OK) {
571 LOG_ERR(
"CCA request failed to schedule RX\n");
582 if(!rx_is_active()) {
583 LOG_ERR(
"CCA request failed to turn on RX, RX status=0x%04X\n", cmd_rx.status);
584 return RF_RESULT_ERROR;
589 stat = RF_runImmediateCmd(ieee_radio.rf_handle, (uint32_t *)cmd_cca_req);
595 if(stat != RF_StatCmdDoneSuccess) {
596 LOG_ERR(
"CCA request command failed, stat=0x%02X\n", stat);
597 return RF_RESULT_ERROR;
606 cmd_cca_req_t cmd_cca_req;
607 memset(&cmd_cca_req, 0x0,
sizeof(cmd_cca_req_t));
608 cmd_cca_req.commandNo = CMD_IEEE_CCA_REQ;
610 if(cca_request(&cmd_cca_req) != RF_RESULT_OK) {
615 return cmd_cca_req.ccaInfo.ccaState == CCA_STATE_IDLE;
621 cmd_cca_req_t cmd_cca_req;
622 memset(&cmd_cca_req, 0x0,
sizeof(cmd_cca_req_t));
623 cmd_cca_req.commandNo = CMD_IEEE_CCA_REQ;
625 if(cca_request(&cmd_cca_req) != RF_RESULT_OK) {
630 if((cmd_cca_req.ccaInfo.ccaEnergy == CCA_STATE_BUSY) &&
631 (cmd_cca_req.ccaInfo.ccaCorr == CCA_STATE_BUSY) &&
632 (cmd_cca_req.ccaInfo.ccaSync == CCA_STATE_BUSY)) {
633 LOG_WARN(
"We are TXing ACK, therefore not receiving packets\n");
638 return cmd_cca_req.ccaInfo.ccaSync == CCA_STATE_BUSY;
644 const data_entry_t *
const read_entry = data_queue_current_entry();
645 volatile const data_entry_t *curr_entry = read_entry;
651 const uint8_t status = curr_entry->status;
652 if((status == DATA_ENTRY_FINISHED) ||
653 (status == DATA_ENTRY_BUSY)) {
658 curr_entry = (data_entry_t *)curr_entry->pNextEntry;
659 }
while(curr_entry != read_entry);
661 if((num_pending > 0) && !ieee_radio.poll_mode) {
674 if(ieee_radio.rf_is_on) {
675 LOG_WARN(
"Radio is already on\n");
681 res = netstack_sched_rx(
true);
683 if(res != RF_RESULT_OK) {
684 return RF_RESULT_ERROR;
687 ieee_radio.rf_is_on =
true;
694 if(!ieee_radio.rf_is_on) {
695 LOG_WARN(
"Radio is already off\n");
701 ieee_radio.rf_is_on =
false;
705 static radio_result_t
711 return RADIO_RESULT_INVALID_VALUE;
717 case RADIO_PARAM_POWER_MODE:
718 *value = (ieee_radio.rf_is_on)
719 ? RADIO_POWER_MODE_ON
720 : RADIO_POWER_MODE_OFF;
721 return RADIO_RESULT_OK;
724 case RADIO_PARAM_CHANNEL:
726 return RADIO_RESULT_OK;
729 case RADIO_PARAM_PAN_ID:
731 return RADIO_RESULT_OK;
734 case RADIO_PARAM_16BIT_ADDR:
736 return RADIO_RESULT_OK;
739 case RADIO_PARAM_RX_MODE:
741 if(cmd_rx.frameFiltOpt.frameFiltEn) {
744 if(cmd_rx.frameFiltOpt.autoAckEn) {
747 if(ieee_radio.poll_mode) {
750 return RADIO_RESULT_OK;
753 case RADIO_PARAM_TX_MODE:
755 return RADIO_RESULT_OK;
758 case RADIO_PARAM_TXPOWER:
759 res = rf_get_tx_power(ieee_radio.rf_handle, rf_tx_power_table, (int8_t *)&value);
760 return ((res == RF_RESULT_OK) &&
761 (*value != RF_TxPowerTable_INVALID_DBM))
763 : RADIO_RESULT_ERROR;
766 case RADIO_PARAM_CCA_THRESHOLD:
767 *value = cmd_rx.ccaRssiThr;
768 return RADIO_RESULT_OK;
771 case RADIO_PARAM_RSSI:
772 *value = RF_getRssi(ieee_radio.rf_handle);
773 return (*value == RF_GET_RSSI_ERROR_VAL)
778 case RADIO_CONST_CHANNEL_MIN:
780 return RADIO_RESULT_OK;
783 case RADIO_CONST_CHANNEL_MAX:
785 return RADIO_RESULT_OK;
787 case RADIO_CONST_TXPOWER_MIN:
789 return RADIO_RESULT_OK;
792 case RADIO_CONST_TXPOWER_MAX:
793 *value = (
radio_value_t)tx_power_max(rf_tx_power_table, rf_tx_power_table_size);
794 return RADIO_RESULT_OK;
797 case RADIO_PARAM_LAST_RSSI:
799 return RADIO_RESULT_OK;
802 case RADIO_PARAM_LAST_LINK_QUALITY:
804 return RADIO_RESULT_OK;
807 return RADIO_RESULT_NOT_SUPPORTED;
811 static radio_result_t
819 case RADIO_PARAM_POWER_MODE:
821 if(value == RADIO_POWER_MODE_ON) {
822 return (
on() == RF_RESULT_OK)
824 : RADIO_RESULT_ERROR;
825 }
else if(value == RADIO_POWER_MODE_OFF) {
827 return RADIO_RESULT_OK;
830 return RADIO_RESULT_INVALID_VALUE;
833 case RADIO_PARAM_CHANNEL:
834 if(!dot_15_4g_chan_in_range(value)) {
835 return RADIO_RESULT_INVALID_VALUE;
838 return RADIO_RESULT_OK;
841 case RADIO_PARAM_PAN_ID:
842 cmd_rx.localPanID = (uint16_t)value;
843 if(!ieee_radio.rf_is_on) {
844 return RADIO_RESULT_OK;
848 res = netstack_sched_rx(
false);
849 return (res == RF_RESULT_OK)
851 : RADIO_RESULT_ERROR;
854 case RADIO_PARAM_16BIT_ADDR:
855 cmd_rx.localShortAddr = (uint16_t)value;
856 if(!ieee_radio.rf_is_on) {
857 return RADIO_RESULT_OK;
861 res = netstack_sched_rx(
false);
862 return (res == RF_RESULT_OK)
864 : RADIO_RESULT_ERROR;
867 case RADIO_PARAM_RX_MODE: {
869 RADIO_RX_MODE_AUTOACK |
870 RADIO_RX_MODE_POLL_MODE)) {
871 return RADIO_RESULT_INVALID_VALUE;
875 cmd_rx.frameFiltOpt.frameFiltStop = 1;
876 cmd_rx.frameFiltOpt.autoAckEn = (value & RADIO_RX_MODE_AUTOACK) != 0;
877 cmd_rx.frameFiltOpt.slottedAckEn = 0;
878 cmd_rx.frameFiltOpt.autoPendEn = 0;
879 cmd_rx.frameFiltOpt.defaultPend = 0;
880 cmd_rx.frameFiltOpt.bPendDataReqOnly = 0;
881 cmd_rx.frameFiltOpt.bPanCoord = 0;
882 cmd_rx.frameFiltOpt.bStrictLenFilter = 0;
884 const bool old_poll_mode = ieee_radio.poll_mode;
885 ieee_radio.poll_mode = (value & RADIO_RX_MODE_POLL_MODE) != 0;
886 if(old_poll_mode == ieee_radio.poll_mode) {
889 const RF_Stat stat = RF_runImmediateCmd(ieee_radio.rf_handle, (uint32_t *)&cmd_mod_filt);
890 if(stat != RF_StatCmdDoneSuccess) {
891 LOG_ERR(
"Setting address filter failed, stat=0x%02X\n", stat);
892 return RADIO_RESULT_ERROR;
894 return RADIO_RESULT_OK;
896 if(!ieee_radio.rf_is_on) {
897 return RADIO_RESULT_OK;
901 res = netstack_sched_rx(
false);
902 return (res == RF_RESULT_OK)
904 : RADIO_RESULT_ERROR;
908 case RADIO_PARAM_TX_MODE:
910 return RADIO_RESULT_INVALID_VALUE;
913 return RADIO_RESULT_OK;
916 case RADIO_PARAM_TXPOWER:
917 if(!tx_power_in_range((int8_t)value, rf_tx_power_table, rf_tx_power_table_size)) {
918 return RADIO_RESULT_INVALID_VALUE;
920 res = rf_set_tx_power(ieee_radio.rf_handle, rf_tx_power_table, (int8_t)value);
921 return (res == RF_RESULT_OK)
923 : RADIO_RESULT_ERROR;
926 case RADIO_PARAM_CCA_THRESHOLD:
927 cmd_rx.ccaRssiThr = (int8_t)value;
928 if(!ieee_radio.rf_is_on) {
929 return RADIO_RESULT_OK;
933 res = netstack_sched_rx(
false);
934 return (res == RF_RESULT_OK)
936 : RADIO_RESULT_ERROR;
939 return RADIO_RESULT_NOT_SUPPORTED;
943 static radio_result_t
944 get_object(radio_param_t param,
void *dest,
size_t size)
947 return RADIO_RESULT_INVALID_VALUE;
952 case RADIO_PARAM_64BIT_ADDR: {
953 const size_t srcSize =
sizeof(cmd_rx.localExtAddr);
954 if(size != srcSize) {
955 return RADIO_RESULT_INVALID_VALUE;
958 const uint8_t *pSrc = (uint8_t *)&(cmd_rx.localExtAddr);
959 uint8_t *pDest = dest;
960 for(
size_t i = 0; i < srcSize; ++i) {
961 pDest[i] = pSrc[srcSize - 1 - i];
964 return RADIO_RESULT_OK;
967 case RADIO_PARAM_LAST_PACKET_TIMESTAMP:
968 if(size !=
sizeof(rtimer_clock_t)) {
969 return RADIO_RESULT_INVALID_VALUE;
972 *(rtimer_clock_t *)dest = ieee_radio.last.timestamp;
974 return RADIO_RESULT_OK;
977 return RADIO_RESULT_NOT_SUPPORTED;
981 static radio_result_t
982 set_object(radio_param_t param,
const void *src,
size_t size)
987 return RADIO_RESULT_INVALID_VALUE;
992 case RADIO_PARAM_64BIT_ADDR: {
993 const size_t destSize =
sizeof(cmd_rx.localExtAddr);
994 if(size != destSize) {
995 return RADIO_RESULT_INVALID_VALUE;
998 const uint8_t *pSrc = (
const uint8_t *)src;
999 volatile uint8_t *pDest = (uint8_t *)&(cmd_rx.localExtAddr);
1000 for(
size_t i = 0; i < destSize; ++i) {
1001 pDest[i] = pSrc[destSize - 1 - i];
1004 if(!rx_is_active()) {
1005 return RADIO_RESULT_OK;
1009 res = netstack_sched_rx(
false);
1010 return (res == RF_RESULT_OK)
1012 : RADIO_RESULT_ERROR;
1015 return RADIO_RESULT_NOT_SUPPORTED;
radio_result_t(* get_object)(radio_param_t param, void *dest, size_t size)
Get a radio parameter object.
Header file with descriptors for the various modes of operation defined in IEEE 802.15.4g.
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
static uint8_t rf_cmd_ieee_rx()
Set up radio in IEEE802.15.4 RX mode.
Header file of TX power functionality of CC13xx/CC26xx.
static uint8_t rf_is_on(void)
Checks whether the RFC domain is accessible and the RFC is in IEEE RX.
#define FRAME_SHAVE
RSSI (1) + Status (1)
Header file for the energy estimation mechanism
Header file for the link-layer address representation
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.
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.
int(* channel_clear)(void)
Perform a Clear-Channel Assessment (CCA) to find out if there is a packet in the air or not...
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
#define RTIMER_NOW()
Get the current clock time.
#define CLOCK_SECOND
A second, measured in system clock time.
Header file of the CC13xx/CC26xx RF scheduler.
Header file for the callback timer
int(* send)(const void *payload, unsigned short payload_len)
Prepare & transmit a packet.
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.
#define RF_CONF_INACTIVITY_TIMEOUT
2 ms
Header file for the real-time timer module.
void ctimer_set(struct ctimer *c, clock_time_t t, void(*f)(void *), void *ptr)
Set a callback timer.
#define RADIO_RX_MODE_ADDRESS_FILTER
The radio reception mode controls address filtering and automatic transmission of acknowledgements in...
Header file of the CC13xx/CC26xx RF data queue.
#define RADIO_TX_MODE_SEND_ON_CCA
The radio transmission mode controls whether transmissions should be done using clear channel assessm...
Header file of RF settings for CC13xx/CC26xx.
int(* read)(void *buf, unsigned short buf_len)
Read a received packet into a buffer.
Header file of common CC13xx/CC26xx RF functionality.
Header file for the Packet buffer (packetbuf) management
Include file for the Contiki low-layer network stack (NETSTACK)
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.
Header file for the logging system
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.