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 data_queue_t *rx_q = data_queue_init(
sizeof(lensz_t));
223 cmd_rx.pOutput = &ieee_radio.rx_stats;
225 #if IEEE_MODE_PROMISCOUS 226 cmd_rx.frameFiltOpt.frameFiltEn = 0;
228 cmd_rx.frameFiltOpt.frameFiltEn = 1;
231 #if IEEE_MODE_AUTOACK 232 cmd_rx.frameFiltOpt.autoAckEn = 1;
234 cmd_rx.frameFiltOpt.autoAckEn = 0;
237 cmd_rx.ccaRssiThr = IEEE_MODE_CCA_RSSI_THRESHOLD;
239 cmd_tx.pNextOp = (RF_Op *)&cmd_rx_ack;
240 cmd_tx.condition.rule = COND_NEVER;
250 cmd_rx_ack.startTrigger.triggerType = TRIG_NOW;
251 cmd_rx_ack.endTrigger.triggerType = TRIG_REL_START;
252 cmd_rx_ack.endTime = RF_convertUsToRatTicks(700);
255 cmd_mod_filt.commandNo = CMD_IEEE_MOD_FILT;
263 if(!dot_15_4g_chan_in_range(channel)) {
264 LOG_WARN(
"Supplied hannel %d is illegal, defaults to %d\n",
265 (
int)channel, DOT_15_4G_DEFAULT_CHAN);
266 channel = DOT_15_4G_DEFAULT_CHAN;
274 if(channel == cmd_rx.channel) {
279 cmd_rx.channel = channel;
281 const uint32_t new_freq = dot_15_4g_freq(channel);
282 const uint16_t freq = (uint16_t)(new_freq / 1000);
283 const uint16_t frac = (uint16_t)(((new_freq - (freq * 1000)) * 0x10000) / 1000);
285 LOG_DBG(
"Set channel to %d, frequency 0x%04X.0x%04X (%lu)\n",
286 (
int)channel, freq, frac, new_freq);
288 cmd_fs.frequency = freq;
289 cmd_fs.fractFreq = frac;
291 return netstack_sched_fs();
295 set_send_on_cca(
bool enable)
297 ieee_radio.send_on_cca = enable;
301 check_rat_overflow(
void)
303 const bool was_off = !rx_is_active();
306 RF_runDirectCmd(ieee_radio.rf_handle, CMD_NOP);
309 const uint32_t current_value = RF_getCurrentTime();
311 static bool initial_iteration =
true;
312 static uint32_t last_value;
314 if(initial_iteration) {
316 initial_iteration =
false;
319 if((current_value + RAT_ONE_QUARTER) < last_value) {
322 ieee_radio.rat.overflow_count += 1;
326 last_value = current_value;
329 RF_yield(ieee_radio.rf_handle);
334 rat_to_timestamp(
const uint32_t rat_ticks)
336 check_rat_overflow();
338 uint64_t adjusted_overflow_count = ieee_radio.rat.overflow_count;
342 if(rat_ticks > RAT_THREE_QUARTERS) {
343 const rtimer_clock_t one_quarter = (RAT_ONE_QUARTER * RTIMER_SECOND) / RAT_SECOND;
344 if(RTIMER_CLOCK_LT(
RTIMER_NOW(), ieee_radio.rat.last_overflow + one_quarter)) {
345 adjusted_overflow_count -= 1;
350 const uint64_t rat_ticks_adjusted = (uint64_t)rat_ticks + (uint64_t)RAT_RANGE * adjusted_overflow_count;
353 return RAT_TO_RTIMER(rat_ticks_adjusted + RAT_TIMESTAMP_OFFSET);
359 if(ieee_radio.rf_handle) {
360 LOG_WARN(
"Radio already initialized\n");
365 ieee_radio.rf_is_on =
false;
371 RF_Params_init(&rf_params);
374 ieee_radio.rf_handle = netstack_open(&rf_params);
376 if(ieee_radio.rf_handle == NULL) {
377 LOG_ERR(
"Unable to open RF driver\n");
378 return RF_RESULT_ERROR;
383 int8_t max_tx_power = tx_power_max(rf_tx_power_table, rf_tx_power_table_size);
384 rf_set_tx_power(ieee_radio.rf_handle, rf_tx_power_table, max_tx_power);
386 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
389 check_rat_overflow();
390 clock_time_t two_quarters = (2 * RAT_ONE_QUARTER *
CLOCK_SECOND) / RAT_SECOND;
391 ctimer_set(&ieee_radio.rat.overflow_timer, two_quarters, rat_overflow_cb, NULL);
400 prepare(
const void *payload,
unsigned short payload_len)
402 const size_t len = MIN((
size_t)payload_len,
403 (
size_t)TX_BUF_SIZE);
405 memcpy(ieee_radio.tx_buf, payload, len);
410 transmit(
unsigned short transmit_len)
415 LOG_WARN(
"Channel is not clear for transmission\n");
416 return RADIO_TX_COLLISION;
423 const bool ack_request = (bool)(ieee_radio.tx_buf[FRAME_FCF_OFFSET] & FRAME_ACK_REQUEST);
426 cmd_tx.condition.rule = COND_STOP_ON_FALSE;
429 cmd_rx_ack.status = IDLE;
431 cmd_rx_ack.seqNo = ieee_radio.tx_buf[FRAME_SEQNUM_OFFSET];
434 cmd_tx.condition.rule = COND_NEVER;
438 cmd_tx.payloadLen = (uint8_t)transmit_len;
439 cmd_tx.pPayload = ieee_radio.tx_buf;
441 res = netstack_sched_ieee_tx(ack_request);
443 if(res != RF_RESULT_OK) {
448 switch(cmd_rx_ack.status) {
450 case IEEE_DONE_TIMEOUT:
return RADIO_TX_NOACK;
453 case IEEE_DONE_ACKPEND:
return RADIO_TX_OK;
455 default:
return RADIO_TX_ERR;
464 send(
const void *payload,
unsigned short payload_len)
471 read(
void *buf,
unsigned short buf_len)
473 volatile data_entry_t *data_entry = data_queue_current_entry();
477 while((data_entry->status == DATA_ENTRY_BUSY) &&
478 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + TIMEOUT_DATA_ENTRY_BUSY)) ;
480 if(data_entry->status != DATA_ENTRY_FINISHED) {
505 uint8_t *
const frame_ptr = (uint8_t *)&data_entry->data;
506 const lensz_t frame_len = *(lensz_t *)frame_ptr;
510 LOG_ERR(
"Received frame too short, len=%d\n", frame_len);
512 data_queue_release_entry();
516 const uint8_t *payload_ptr = frame_ptr +
sizeof(lensz_t);
517 const unsigned short payload_len = (
unsigned short)(frame_len -
FRAME_SHAVE);
520 if(payload_len > buf_len) {
521 LOG_ERR(
"MAC payload too large for buffer, len=%d buf_len=%d\n",
522 payload_len, buf_len);
524 data_queue_release_entry();
528 memcpy(buf, payload_ptr, payload_len);
531 ieee_radio.last.rssi = (int8_t)payload_ptr[payload_len + 2];
533 ieee_radio.last.corr_lqi = (uint8_t)(payload_ptr[payload_len + 3] & STATUS_CORRELATION);
535 const uint32_t rat_ticks = *(uint32_t *)(payload_ptr + payload_len + 4);
536 ieee_radio.last.timestamp = rat_to_timestamp(rat_ticks);
538 if(!ieee_radio.poll_mode) {
542 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, (packetbuf_attr_t)ieee_radio.last.rssi);
543 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, (packetbuf_attr_t)ieee_radio.last.corr_lqi);
546 data_queue_release_entry();
547 return (
int)payload_len;
551 cca_request(cmd_cca_req_t *cmd_cca_req)
555 const bool rx_is_idle = !rx_is_active();
558 res = netstack_sched_rx(
false);
559 if(res != RF_RESULT_OK) {
560 return RF_RESULT_ERROR;
565 while((cmd_rx.status != ACTIVE) &&
566 RTIMER_CLOCK_LT(
RTIMER_NOW(), t0 + TIMEOUT_ENTER_RX_WAIT)) ;
568 RF_Stat stat = RF_StatRadioInactiveError;
570 stat = RF_runImmediateCmd(ieee_radio.rf_handle, (uint32_t *)&cmd_cca_req);
577 if(stat != RF_StatCmdDoneSuccess) {
578 LOG_ERR(
"CCA request failed, stat=0x%02X\n", stat);
579 return RF_RESULT_ERROR;
588 cmd_cca_req_t cmd_cca_req;
589 memset(&cmd_cca_req, 0x0,
sizeof(cmd_cca_req_t));
590 cmd_cca_req.commandNo = CMD_IEEE_CCA_REQ;
592 if(cca_request(&cmd_cca_req) != RF_RESULT_OK) {
597 return cmd_cca_req.ccaInfo.ccaState == CCA_STATE_IDLE;
603 cmd_cca_req_t cmd_cca_req;
604 memset(&cmd_cca_req, 0x0,
sizeof(cmd_cca_req_t));
605 cmd_cca_req.commandNo = CMD_IEEE_CCA_REQ;
607 if(cca_request(&cmd_cca_req) != RF_RESULT_OK) {
612 if((cmd_cca_req.ccaInfo.ccaEnergy == CCA_STATE_BUSY) &&
613 (cmd_cca_req.ccaInfo.ccaCorr == CCA_STATE_BUSY) &&
614 (cmd_cca_req.ccaInfo.ccaSync == CCA_STATE_BUSY)) {
615 LOG_WARN(
"We are TXing ACK, therefore not receiving packets\n");
620 return cmd_cca_req.ccaInfo.ccaSync == CCA_STATE_BUSY;
626 const data_entry_t *
const read_entry = data_queue_current_entry();
627 volatile const data_entry_t *curr_entry = read_entry;
633 const uint8_t status = curr_entry->status;
634 if((status == DATA_ENTRY_FINISHED) ||
635 (status == DATA_ENTRY_BUSY)) {
640 curr_entry = (data_entry_t *)curr_entry->pNextEntry;
641 }
while(curr_entry != read_entry);
643 if((num_pending > 0) && !ieee_radio.poll_mode) {
656 if(ieee_radio.rf_is_on) {
657 LOG_WARN(
"Radio is already on\n");
663 res = netstack_sched_rx(
true);
665 if(res != RF_RESULT_OK) {
666 return RF_RESULT_ERROR;
669 ieee_radio.rf_is_on =
true;
676 if(!ieee_radio.rf_is_on) {
677 LOG_WARN(
"Radio is already off\n");
683 ieee_radio.rf_is_on =
false;
687 static radio_result_t
693 return RADIO_RESULT_INVALID_VALUE;
699 case RADIO_PARAM_POWER_MODE:
700 *value = (ieee_radio.rf_is_on)
701 ? RADIO_POWER_MODE_ON
702 : RADIO_POWER_MODE_OFF;
703 return RADIO_RESULT_OK;
706 case RADIO_PARAM_CHANNEL:
708 return RADIO_RESULT_OK;
711 case RADIO_PARAM_PAN_ID:
713 return RADIO_RESULT_OK;
716 case RADIO_PARAM_16BIT_ADDR:
718 return RADIO_RESULT_OK;
721 case RADIO_PARAM_RX_MODE:
723 if(cmd_rx.frameFiltOpt.frameFiltEn) {
726 if(cmd_rx.frameFiltOpt.autoAckEn) {
729 if(ieee_radio.poll_mode) {
732 return RADIO_RESULT_OK;
735 case RADIO_PARAM_TX_MODE:
737 return RADIO_RESULT_OK;
740 case RADIO_PARAM_TXPOWER:
741 res = rf_get_tx_power(ieee_radio.rf_handle, rf_tx_power_table, (int8_t *)&value);
742 return ((res == RF_RESULT_OK) &&
743 (*value != RF_TxPowerTable_INVALID_DBM))
745 : RADIO_RESULT_ERROR;
748 case RADIO_PARAM_CCA_THRESHOLD:
749 *value = cmd_rx.ccaRssiThr;
750 return RADIO_RESULT_OK;
753 case RADIO_PARAM_RSSI:
754 *value = RF_getRssi(ieee_radio.rf_handle);
755 return (*value == RF_GET_RSSI_ERROR_VAL)
760 case RADIO_CONST_CHANNEL_MIN:
762 return RADIO_RESULT_OK;
765 case RADIO_CONST_CHANNEL_MAX:
767 return RADIO_RESULT_OK;
769 case RADIO_CONST_TXPOWER_MIN:
771 return RADIO_RESULT_OK;
774 case RADIO_CONST_TXPOWER_MAX:
775 *value = (
radio_value_t)tx_power_max(rf_tx_power_table, rf_tx_power_table_size);
776 return RADIO_RESULT_OK;
779 case RADIO_PARAM_LAST_RSSI:
781 return RADIO_RESULT_OK;
784 case RADIO_PARAM_LAST_LINK_QUALITY:
786 return RADIO_RESULT_OK;
789 return RADIO_RESULT_NOT_SUPPORTED;
793 static radio_result_t
801 case RADIO_PARAM_POWER_MODE:
803 if(value == RADIO_POWER_MODE_ON) {
804 return (
on() == RF_RESULT_OK)
806 : RADIO_RESULT_ERROR;
807 }
else if(value == RADIO_POWER_MODE_OFF) {
809 return RADIO_RESULT_OK;
812 return RADIO_RESULT_INVALID_VALUE;
815 case RADIO_PARAM_CHANNEL:
816 if(!dot_15_4g_chan_in_range(value)) {
817 return RADIO_RESULT_INVALID_VALUE;
820 return RADIO_RESULT_OK;
823 case RADIO_PARAM_PAN_ID:
824 cmd_rx.localPanID = (uint16_t)value;
825 if(!ieee_radio.rf_is_on) {
826 return RADIO_RESULT_OK;
830 res = netstack_sched_rx(
false);
831 return (res == RF_RESULT_OK)
833 : RADIO_RESULT_ERROR;
836 case RADIO_PARAM_16BIT_ADDR:
837 cmd_rx.localShortAddr = (uint16_t)value;
838 if(!ieee_radio.rf_is_on) {
839 return RADIO_RESULT_OK;
843 res = netstack_sched_rx(
false);
844 return (res == RF_RESULT_OK)
846 : RADIO_RESULT_ERROR;
849 case RADIO_PARAM_RX_MODE: {
851 RADIO_RX_MODE_AUTOACK |
852 RADIO_RX_MODE_POLL_MODE)) {
853 return RADIO_RESULT_INVALID_VALUE;
857 cmd_rx.frameFiltOpt.frameFiltStop = 1;
858 cmd_rx.frameFiltOpt.autoAckEn = (value & RADIO_RX_MODE_AUTOACK) != 0;
859 cmd_rx.frameFiltOpt.slottedAckEn = 0;
860 cmd_rx.frameFiltOpt.autoPendEn = 0;
861 cmd_rx.frameFiltOpt.defaultPend = 0;
862 cmd_rx.frameFiltOpt.bPendDataReqOnly = 0;
863 cmd_rx.frameFiltOpt.bPanCoord = 0;
864 cmd_rx.frameFiltOpt.bStrictLenFilter = 0;
866 const bool old_poll_mode = ieee_radio.poll_mode;
867 ieee_radio.poll_mode = (value & RADIO_RX_MODE_POLL_MODE) != 0;
868 if(old_poll_mode == ieee_radio.poll_mode) {
871 const RF_Stat stat = RF_runImmediateCmd(ieee_radio.rf_handle, (uint32_t *)&cmd_mod_filt);
872 if(stat != RF_StatCmdDoneSuccess) {
873 LOG_ERR(
"Setting address filter failed, stat=0x%02X\n", stat);
874 return RADIO_RESULT_ERROR;
876 return RADIO_RESULT_OK;
878 if(!ieee_radio.rf_is_on) {
879 return RADIO_RESULT_OK;
883 res = netstack_sched_rx(
false);
884 return (res == RF_RESULT_OK)
886 : RADIO_RESULT_ERROR;
890 case RADIO_PARAM_TX_MODE:
892 return RADIO_RESULT_INVALID_VALUE;
895 return RADIO_RESULT_OK;
898 case RADIO_PARAM_TXPOWER:
899 if(!tx_power_in_range((int8_t)value, rf_tx_power_table, rf_tx_power_table_size)) {
900 return RADIO_RESULT_INVALID_VALUE;
902 res = rf_set_tx_power(ieee_radio.rf_handle, rf_tx_power_table, (int8_t)value);
903 return (res == RF_RESULT_OK)
905 : RADIO_RESULT_ERROR;
908 case RADIO_PARAM_CCA_THRESHOLD:
909 cmd_rx.ccaRssiThr = (int8_t)value;
910 if(!ieee_radio.rf_is_on) {
911 return RADIO_RESULT_OK;
915 res = netstack_sched_rx(
false);
916 return (res == RF_RESULT_OK)
918 : RADIO_RESULT_ERROR;
921 return RADIO_RESULT_NOT_SUPPORTED;
925 static radio_result_t
926 get_object(radio_param_t param,
void *dest,
size_t size)
929 return RADIO_RESULT_INVALID_VALUE;
934 case RADIO_PARAM_64BIT_ADDR: {
935 const size_t srcSize =
sizeof(cmd_rx.localExtAddr);
936 if(size != srcSize) {
937 return RADIO_RESULT_INVALID_VALUE;
940 const uint8_t *pSrc = (uint8_t *)&(cmd_rx.localExtAddr);
941 uint8_t *pDest = dest;
942 for(
size_t i = 0; i < srcSize; ++i) {
943 pDest[i] = pSrc[srcSize - 1 - i];
946 return RADIO_RESULT_OK;
949 case RADIO_PARAM_LAST_PACKET_TIMESTAMP:
950 if(size !=
sizeof(rtimer_clock_t)) {
951 return RADIO_RESULT_INVALID_VALUE;
954 *(rtimer_clock_t *)dest = ieee_radio.last.timestamp;
956 return RADIO_RESULT_OK;
959 return RADIO_RESULT_NOT_SUPPORTED;
963 static radio_result_t
964 set_object(radio_param_t param,
const void *src,
size_t size)
969 return RADIO_RESULT_INVALID_VALUE;
974 case RADIO_PARAM_64BIT_ADDR: {
975 const size_t destSize =
sizeof(cmd_rx.localExtAddr);
976 if(size != destSize) {
977 return RADIO_RESULT_INVALID_VALUE;
980 const uint8_t *pSrc = (
const uint8_t *)src;
981 volatile uint8_t *pDest = (uint8_t *)&(cmd_rx.localExtAddr);
982 for(
size_t i = 0; i < destSize; ++i) {
983 pDest[i] = pSrc[destSize - 1 - i];
986 if(!rx_is_active()) {
987 return RADIO_RESULT_OK;
991 res = netstack_sched_rx(
false);
992 return (res == RF_RESULT_OK)
994 : RADIO_RESULT_ERROR;
997 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.
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.