54 #include "AppHardwareApi.h" 58 #include "PeripheralRegs.h" 63 #define DEBUG DEBUG_NONE 66 #ifdef MICROMAC_CONF_RADIO_MAC 67 #define MICROMAC_RADIO_MAC MICROMAC_CONF_RADIO_MAC 69 #define MICROMAC_RADIO_MAC 0 72 #if MICROMAC_RADIO_MAC 73 #define MICROMAC_FRAME tsMacFrame 75 #define MICROMAC_FRAME tsPhyFrame 82 #define CHECKSUM_LEN 2 85 #define MAX_PACKET_DURATION US_TO_RTIMERTICKS((127 + 2) * 32 + RADIO_DELAY_BEFORE_TX) 87 #define MAX_ACK_DURATION US_TO_RTIMERTICKS((3 + 2) * 32 + RADIO_DELAY_BEFORE_TX) 90 #define RADIO_TEST_MODE_HIGH_PWR 1 91 #define RADIO_TEST_MODE_ADVANCED 2 92 #define RADIO_TEST_MODE_DISABLED 0 94 #ifndef RADIO_TEST_MODE 95 #define RADIO_TEST_MODE RADIO_TEST_MODE_DISABLED 99 #ifndef MIRCOMAC_CONF_BUF_NUM 100 #define MIRCOMAC_CONF_BUF_NUM 2 104 #ifndef MICROMAC_CONF_CCA_THR 105 #define MICROMAC_CONF_CCA_THR 39 108 #if (JENNIC_CHIP == JN5169) 109 #define OUTPUT_POWER_MAX 10 110 #define OUTPUT_POWER_MIN (-32) 111 #define ABS_OUTPUT_POWER_MIN (32) 113 #define OUTPUT_POWER_MAX 0 114 #define OUTPUT_POWER_MIN (-32) 118 #ifndef MICROMAC_CONF_TX_POWER 119 #define MICROMAC_CONF_TX_POWER 0 123 #ifndef MICROMAC_CONF_AUTOACK 124 #define MICROMAC_CONF_AUTOACK 1 129 #ifndef MICROMAC_CONF_ALWAYS_ON 130 #define MICROMAC_CONF_ALWAYS_ON 1 133 #define BUSYWAIT_UNTIL(cond, max_time) \ 137 while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) ; \ 141 static volatile signed char radio_last_rssi;
142 static volatile uint8_t radio_last_correlation;
145 static volatile uint8_t missed_radio_on_request = 0;
148 static uint8_t poll_mode = 0;
150 static uint8_t frame_filtering = 1;
152 static uint8_t autoack_enabled = MICROMAC_CONF_AUTOACK;
154 static uint8_t send_on_cca = 0;
161 static int current_tx_power = MICROMAC_CONF_TX_POWER;
164 static uint8_t cca_thershold = MICROMAC_CONF_CCA_THR;
167 static volatile uint8_t tx_in_progress = 0;
169 static volatile uint8_t listen_on = 0;
172 static uint8_t in_ack_transmission = 0;
175 static MICROMAC_FRAME tx_frame_buffer;
178 static MICROMAC_FRAME *rx_frame_buffer;
181 static MICROMAC_FRAME *input_frame_buffer = NULL;
184 static struct ringbufindex input_ringbuf;
185 static MICROMAC_FRAME input_array[MIRCOMAC_CONF_BUF_NUM];
188 static volatile uint32_t last_packet_timestamp = 0;
192 static int off(
void);
193 #if !MICROMAC_RADIO_MAC 194 static int is_packet_for_us(uint8_t *buf,
int len,
int do_send_ack);
196 static void set_frame_filtering(uint8_t enable);
197 static rtimer_clock_t get_packet_timestamp(
void);
198 static void set_txpower(int8_t power);
200 static void radio_interrupt_handler(uint32 mac_event);
201 static int get_detected_energy(
void);
202 static int get_rssi(
void);
203 static void read_last_rssi(
void);
206 PROCESS(micromac_radio_process,
"micromac_radio_driver");
210 #ifndef RADIO_RX_MODE_POLL_MODE 211 #define RADIO_PARAM_LAST_RSSI 0x80 212 #define RADIO_PARAM_LAST_PACKET_TIMESTAMP 0x81 213 #define RADIO_RX_MODE_POLL_MODE (1 << 2) 217 static rtimer_clock_t
218 get_packet_timestamp(
void)
221 uint32_t t = u32MMAC_GetTime();
222 while(u32MMAC_GetTime() == t);
225 RADIO_TO_RTIMER((uint32_t)(u32MMAC_GetTime() - (u32MMAC_GetRxTime() - 1)));
228 last_packet_timestamp -= US_TO_RTIMERTICKS(8);
229 return last_packet_timestamp;
240 if(put_index == -1) {
241 rx_frame_buffer = NULL;
242 printf(
"micromac_radio init:! no buffer available. Abort init.\n");
246 rx_frame_buffer = &input_array[put_index];
248 input_frame_buffer = rx_frame_buffer;
259 tsExtAddr node_long_address;
260 uint16_t node_short_address;
261 static uint8_t is_initialized;
270 vMMAC_EnableInterrupts(NULL);
271 vMMAC_ConfigureInterruptSources(0);
273 vMMAC_EnableInterrupts(&radio_interrupt_handler);
275 vMMAC_ConfigureRadio();
276 set_txpower(current_tx_power);
278 vMMAC_GetMacAddress(&node_long_address);
280 node_short_address = (uint16_t)node_long_address.u32L;
281 vMMAC_SetRxAddress(frame802154_get_pan_id(), node_short_address, &node_long_address);
284 vMMAC_SetTxParameters(1, 0, 0, 0);
285 vMMAC_SetCutOffTimer(0, FALSE);
287 #if RADIO_TEST_MODE == RADIO_TEST_MODE_HIGH_PWR 292 vREG_SysWrite(REG_SYS_PWR_CTRL,
293 u32REG_SysRead(REG_SYS_PWR_CTRL)
294 | REG_SYSCTRL_PWRCTRL_RFRXEN_MASK
295 | REG_SYSCTRL_PWRCTRL_RFTXEN_MASK);
296 #elif RADIO_TEST_MODE == RADIO_TEST_MODE_ADVANCED 299 vREG_SysWrite(REG_SYS_PWR_CTRL,
300 u32REG_SysRead(REG_SYS_PWR_CTRL) | (1UL << 26UL));
303 if(!is_initialized) {
305 ret = init_software();
315 if(rx_frame_buffer != NULL) {
316 #if MICROMAC_RADIO_MAC 317 vMMAC_StartMacReceive(rx_frame_buffer,
318 (uint16_t)(E_MMAC_RX_START_NOW
319 | E_MMAC_RX_USE_AUTO_ACK
320 | E_MMAC_RX_NO_MALFORMED
321 | E_MMAC_RX_NO_FCS_ERROR
322 | E_MMAC_RX_ADDRESS_MATCH
323 | E_MMAC_RX_ALIGN_NORMAL)
326 vMMAC_StartPhyReceive(rx_frame_buffer,
327 (uint16_t)(E_MMAC_RX_START_NOW
328 | E_MMAC_RX_NO_FCS_ERROR)
332 missed_radio_on_request = 1;
334 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
345 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
355 transmit(
unsigned short payload_len)
358 return RADIO_TX_COLLISION;
364 ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
366 ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
369 #if MICROMAC_RADIO_MAC 370 vMMAC_StartMacTransmit(&tx_frame_buffer,
371 E_MMAC_TX_START_NOW |
372 E_MMAC_TX_USE_AUTO_ACK |
373 (send_on_cca ? E_MMAC_TX_USE_CCA : E_MMAC_TX_NO_CCA));
375 vMMAC_StartPhyTransmit(&tx_frame_buffer,
376 E_MMAC_TX_START_NOW |
377 (send_on_cca ? E_MMAC_TX_USE_CCA : E_MMAC_TX_NO_CCA));
380 BUSYWAIT_UNTIL(u32MMAC_PollInterruptSource(E_MMAC_INT_TX_COMPLETE), MAX_PACKET_DURATION);
382 if(in_ack_transmission) {
384 BUSYWAIT_UNTIL(FALSE, MAX_ACK_DURATION);
387 BUSYWAIT_UNTIL(!tx_in_progress, MAX_PACKET_DURATION);
392 ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
394 ENERGEST_ON(ENERGEST_TYPE_LISTEN);
400 uint32_t tx_error = u32MMAC_GetTxErrors();
403 }
else if(tx_error & E_MMAC_TXSTAT_ABORTED) {
405 }
else if(tx_error & E_MMAC_TXSTAT_CCA_BUSY) {
406 ret = RADIO_TX_COLLISION;
407 }
else if(tx_error & E_MMAC_TXSTAT_NO_ACK) {
408 ret = RADIO_TX_NOACK;
416 prepare(
const void *payload,
unsigned short payload_len)
418 #if !MICROMAC_RADIO_MAC 426 if(payload_len > 127 || payload == NULL) {
429 #if MICROMAC_RADIO_MAC 431 int hdr_len =
frame802154_parse((
unsigned char *)payload, payload_len, &info154);
433 tx_frame_buffer.u8PayloadLength = payload_len - hdr_len;
434 tx_frame_buffer.u8SequenceNum = info154.
seq;
435 tx_frame_buffer.u16FCF = ((uint8_t*)payload)[0] | (((uint8_t*)payload)[1] << 8);
436 tx_frame_buffer.u16DestPAN = info154.
dest_pid;
437 tx_frame_buffer.u16SrcPAN = info154.
src_pid;
439 tx_frame_buffer.uDestAddr.u16Short = info154.
dest_addr[0] | (info154.
dest_addr[0] << 8);
441 tx_frame_buffer.uDestAddr.sExt.u32L = *(uint32_t*)(&info154.
dest_addr[4]);
442 tx_frame_buffer.uDestAddr.sExt.u32H = *(uint32_t*)(&info154.
dest_addr[0]);
445 tx_frame_buffer.uSrcAddr.u16Short = info154.
src_addr[0] | (info154.
src_addr[0] << 8);
447 tx_frame_buffer.uSrcAddr.sExt.u32L = *(uint32_t*)(&info154.
src_addr[4]);
448 tx_frame_buffer.uSrcAddr.sExt.u32H = *(uint32_t*)(&info154.
src_addr[0]);
450 tx_frame_buffer.u16FCS =
crc16_data(payload, payload_len, 0);
454 memcpy(tx_frame_buffer.uPayload.au8Byte, payload, payload_len);
458 checksum =
crc16_data(payload, payload_len, 0);
459 tx_frame_buffer.uPayload.au8Byte[i++] = checksum;
460 tx_frame_buffer.uPayload.au8Byte[i++] = (checksum >> 8) & 0xff;
461 tx_frame_buffer.u8PayloadLength = payload_len + CHECKSUM_LEN;
463 tx_frame_buffer.u8PayloadLength = payload_len;
471 send(
const void *payload,
unsigned short payload_len)
473 if(prepare(payload, payload_len) == 0) {
474 return transmit(payload_len);
483 return current_channel;
490 vMMAC_SetChannelAndPower(current_channel, current_tx_power);
493 #if !MICROMAC_RADIO_MAC 495 is_broadcast_addr(uint8_t mode, uint8_t *
addr)
497 int i = ((mode == FRAME802154_SHORTADDRMODE) ? 2 : 8);
499 if(addr[i] != 0xff) {
512 buffer[0] = FRAME802154_ACKFRAME;
515 buffer[2] = frame->
seq;
516 in_ack_transmission = 1;
517 send(&buffer,
sizeof(buffer));
518 in_ack_transmission = 0;
523 is_packet_for_us(uint8_t *buf,
int len,
int do_send_ack)
531 frame802154_has_panid(&frame.
fcf, NULL, &has_dest_panid);
533 && frame802154_get_pan_id() != FRAME802154_BROADCASTPANDID
534 && frame.
dest_pid != frame802154_get_pan_id()
535 && frame.
dest_pid != FRAME802154_BROADCASTPANDID) {
541 if(autoack_enabled && result && do_send_ack) {
556 read(
void *buf,
unsigned short bufsize)
559 #if MICROMAC_RADIO_MAC 561 uint8_t *p = (uint8_t*)buf;
566 p[len++] = input_frame_buffer->u16FCF & 0xff;
567 p[len++] = (input_frame_buffer->u16FCF >> 8) & 0xff;
568 frame802154_parse_fcf(p, &fcf);
569 p[len++] = input_frame_buffer->u8SequenceNum;
570 frame802154_has_panid(&fcf, &has_src_panid, &has_dest_panid);
572 p[len++] = input_frame_buffer->u16DestPAN & 0xff;
573 p[len++] = (input_frame_buffer->u16DestPAN >> 8) & 0xff;
576 p[len++] = input_frame_buffer->uDestAddr.u16Short & 0xff;
577 p[len++] = (input_frame_buffer->uDestAddr.u16Short >> 8) & 0xff;
579 for(c = 0; c < 4; c++) {
580 p[len + c] = ((uint8_t*)(&input_frame_buffer->uDestAddr.sExt.u32L))[3 - c];
582 for(c = 0; c < 4; c++) {
583 p[len + c + 4] = ((uint8_t*)(&input_frame_buffer->uDestAddr.sExt.u32H))[3 - c];
588 p[len++] = input_frame_buffer->u16SrcPAN & 0xff;
589 p[len++] = (input_frame_buffer->u16SrcPAN >> 8) & 0xff;
592 p[len++] = input_frame_buffer->uSrcAddr.u16Short & 0xff;
593 p[len++] = (input_frame_buffer->uSrcAddr.u16Short >> 8) & 0xff;
595 for(c = 0; c < 4; c++) {
596 p[len + c] = ((uint8_t*)(&input_frame_buffer->uSrcAddr.sExt.u32L))[3 - c];
598 for(c = 0; c < 4; c++) {
599 p[len + c + 4] = ((uint8_t*)(&input_frame_buffer->uSrcAddr.sExt.u32H))[3 - c];
603 memcpy(&p[len], input_frame_buffer->uPayload.au8Byte, input_frame_buffer->u8PayloadLength);
604 len += input_frame_buffer->u8PayloadLength;
606 uint16_t radio_last_rx_crc;
607 uint8_t radio_last_rx_crc_ok = 1;
609 len = input_frame_buffer->u8PayloadLength;
611 if(len <= CHECKSUM_LEN) {
612 input_frame_buffer->u8PayloadLength = 0;
618 uint16_t checksum =
crc16_data(input_frame_buffer->uPayload.au8Byte, len, 0);
620 (uint16_t)(input_frame_buffer->uPayload.au8Byte[len + 1] << (uint16_t)8)
621 | input_frame_buffer->uPayload.au8Byte[len];
622 radio_last_rx_crc_ok = (checksum == radio_last_rx_crc);
623 if(!radio_last_rx_crc_ok) {
626 if(radio_last_rx_crc_ok) {
629 if(frame_filtering &&
630 !is_packet_for_us(input_frame_buffer->uPayload.au8Byte, len, 0)) {
637 bufsize = MIN(len, bufsize);
638 memcpy(buf, input_frame_buffer->uPayload.au8Byte, bufsize);
641 packetbuf_set_attr(PACKETBUF_ATTR_RSSI, radio_last_rssi);
642 packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, radio_last_correlation);
649 input_frame_buffer->u8PayloadLength = 0;
656 set_txpower(int8_t power)
658 if(power > OUTPUT_POWER_MAX) {
659 current_tx_power = OUTPUT_POWER_MAX;
661 if(power < OUTPUT_POWER_MIN) {
662 current_tx_power = OUTPUT_POWER_MIN;
664 current_tx_power = power;
667 vMMAC_SetChannelAndPower(current_channel, current_tx_power);
674 #if (JENNIC_CHIP == JN5169) 676 const static int8 power_table [] = {
688 if(current_tx_power > OUTPUT_POWER_MAX) {
689 actual_tx_power = OUTPUT_POWER_MAX;
690 }
else if(current_tx_power < OUTPUT_POWER_MIN) {
691 actual_tx_power = OUTPUT_POWER_MIN;
693 actual_tx_power = power_table[current_tx_power + ABS_OUTPUT_POWER_MIN];
697 if(current_tx_power < (-24)) {
698 actual_tx_power = OUTPUT_POWER_MIN;
699 }
else if(current_tx_power < (-12)) {
700 actual_tx_power = (-20);
701 }
else if(current_tx_power < 0) {
702 actual_tx_power = (-9);
704 actual_tx_power = OUTPUT_POWER_MAX;
707 return (
int)actual_tx_power;
711 get_detected_energy(
void)
713 const uint32 u32Samples = 8;
714 return u8JPT_EnergyDetect(current_channel, u32Samples);
721 return (7 * get_detected_energy() - 1970) / 20;
727 uint8_t radio_last_rx_energy;
728 radio_last_rx_energy = u8MMAC_GetRxLqi((uint8_t *)&radio_last_correlation);
729 radio_last_rssi = i16JPT_ConvertEnergyTodBm(radio_last_rx_energy);
733 receiving_packet(
void)
735 return bMMAC_RxDetected();
744 return u32MMAC_PollInterruptSource(
745 E_MMAC_INT_RX_COMPLETE | E_MMAC_INT_RX_HEADER);
752 bool_t is_channel_busy = bJPT_CCA(current_channel,
753 E_JPT_CCA_MODE_CARRIER_OR_ENERGY,
755 return is_channel_busy == FALSE;
759 radio_interrupt_handler(uint32 mac_event)
762 uint8_t overflow = 0;
765 #if !MICROMAC_RADIO_MAC 766 int packet_for_me = 0;
769 if(mac_event & E_MMAC_INT_TX_COMPLETE) {
772 }
else if(mac_event & E_MMAC_INT_RX_COMPLETE) {
773 rx_status = u32MMAC_GetRxErrors();
777 last_packet_timestamp = get_packet_timestamp();
779 if(!poll_mode && (mac_event & E_MMAC_INT_RX_COMPLETE)) {
780 #if MICROMAC_RADIO_MAC 787 input_frame_buffer = &input_array[get_index];
794 if(put_index != -1) {
796 rx_frame_buffer = &input_array[put_index];
799 rx_frame_buffer = NULL;
802 if(rx_frame_buffer->u8PayloadLength > CHECKSUM_LEN) {
803 if(frame_filtering) {
805 packet_for_me = is_packet_for_us(rx_frame_buffer->uPayload.au8Byte, rx_frame_buffer->u8PayloadLength - CHECKSUM_LEN, 1);
806 }
else if(!frame_filtering) {
812 rx_frame_buffer->u8PayloadLength = 0;
820 input_frame_buffer = &input_array[get_index];
827 if(put_index != -1) {
829 rx_frame_buffer = &input_array[put_index];
832 rx_frame_buffer = NULL;
841 }
else if(MICROMAC_CONF_ALWAYS_ON
842 && (mac_event & (E_MMAC_INT_TX_COMPLETE | E_MMAC_INT_RX_COMPLETE))) {
858 input_frame_buffer = &input_array[read_index];
865 NETSTACK_MAC.
input();
870 input_frame_buffer->u8PayloadLength = 0;
874 if(rx_frame_buffer == NULL) {
878 if(put_index != -1) {
880 rx_frame_buffer = &input_array[put_index];
882 if(MICROMAC_CONF_ALWAYS_ON || missed_radio_on_request) {
883 missed_radio_on_request = 0;
887 rx_frame_buffer = NULL;
895 set_frame_filtering(uint8_t enable)
897 frame_filtering = enable;
901 set_autoack(uint8_t enable)
903 autoack_enabled = enable;
907 set_poll_mode(uint8_t enable)
912 vMMAC_EnableInterrupts(NULL);
913 vMMAC_ConfigureInterruptSources(0);
917 vMMAC_ConfigureInterruptSources(
918 E_MMAC_INT_RX_COMPLETE | E_MMAC_INT_TX_COMPLETE);
919 vMMAC_EnableInterrupts(&radio_interrupt_handler);
924 set_send_on_cca(uint8_t enable)
926 send_on_cca = enable;
929 static radio_result_t
933 return RADIO_RESULT_INVALID_VALUE;
936 case RADIO_PARAM_POWER_MODE:
937 *value = listen_on || tx_in_progress ? RADIO_POWER_MODE_ON : RADIO_POWER_MODE_OFF;
938 return RADIO_RESULT_OK;
939 case RADIO_PARAM_CHANNEL:
941 return RADIO_RESULT_OK;
942 case RADIO_PARAM_RX_MODE:
944 if(frame_filtering) {
947 if(autoack_enabled) {
948 *value |= RADIO_RX_MODE_AUTOACK;
951 *value |= RADIO_RX_MODE_POLL_MODE;
953 return RADIO_RESULT_OK;
954 case RADIO_PARAM_TX_MODE:
959 return RADIO_RESULT_OK;
960 case RADIO_PARAM_TXPOWER:
961 *value = get_txpower();
962 return RADIO_RESULT_OK;
963 case RADIO_PARAM_RSSI:
965 return RADIO_RESULT_OK;
966 case RADIO_PARAM_LAST_RSSI:
967 *value = radio_last_rssi;
968 return RADIO_RESULT_OK;
969 case RADIO_PARAM_CCA_THRESHOLD:
970 *value = cca_thershold;
971 return RADIO_RESULT_OK;
972 case RADIO_CONST_CHANNEL_MIN:
974 return RADIO_RESULT_OK;
975 case RADIO_CONST_CHANNEL_MAX:
977 return RADIO_RESULT_OK;
978 case RADIO_CONST_TXPOWER_MIN:
979 *value = OUTPUT_POWER_MIN;
980 return RADIO_RESULT_OK;
981 case RADIO_CONST_TXPOWER_MAX:
982 *value = OUTPUT_POWER_MAX;
983 return RADIO_RESULT_OK;
985 return RADIO_RESULT_NOT_SUPPORTED;
989 static radio_result_t
993 case RADIO_PARAM_POWER_MODE:
994 if(value == RADIO_POWER_MODE_ON) {
996 return RADIO_RESULT_OK;
998 if(value == RADIO_POWER_MODE_OFF) {
1000 return RADIO_RESULT_OK;
1002 return RADIO_RESULT_INVALID_VALUE;
1003 case RADIO_PARAM_CHANNEL:
1004 if(value < 11 || value > 26) {
1005 return RADIO_RESULT_INVALID_VALUE;
1008 return RADIO_RESULT_OK;
1009 case RADIO_PARAM_RX_MODE:
1011 RADIO_RX_MODE_AUTOACK | RADIO_RX_MODE_POLL_MODE)) {
1012 return RADIO_RESULT_INVALID_VALUE;
1015 set_autoack((value & RADIO_RX_MODE_AUTOACK) != 0);
1016 set_poll_mode((value & RADIO_RX_MODE_POLL_MODE) != 0);
1017 return RADIO_RESULT_OK;
1018 case RADIO_PARAM_TX_MODE:
1020 return RADIO_RESULT_INVALID_VALUE;
1023 return RADIO_RESULT_OK;
1024 case RADIO_PARAM_TXPOWER:
1025 if(value < OUTPUT_POWER_MIN || value > OUTPUT_POWER_MAX) {
1026 return RADIO_RESULT_INVALID_VALUE;
1030 return RADIO_RESULT_OK;
1031 case RADIO_PARAM_CCA_THRESHOLD:
1032 cca_thershold = value;
1033 return RADIO_RESULT_OK;
1035 return RADIO_RESULT_NOT_SUPPORTED;
1039 static radio_result_t
1040 get_object(radio_param_t param,
void *dest,
size_t size)
1042 if(param == RADIO_PARAM_LAST_PACKET_TIMESTAMP) {
1043 if(size !=
sizeof(rtimer_clock_t) || !dest) {
1044 return RADIO_RESULT_INVALID_VALUE;
1046 *(rtimer_clock_t *)dest = get_packet_timestamp();
1048 return RADIO_RESULT_OK;
1050 return RADIO_RESULT_NOT_SUPPORTED;
1053 static radio_result_t
1054 set_object(radio_param_t param,
const void *src,
size_t size)
1056 return RADIO_RESULT_NOT_SUPPORTED;
radio_result_t(* get_object)(radio_param_t param, void *dest, size_t size)
Get a radio parameter object.
uint16_t src_pid
Source PAN ID.
void * packetbuf_dataptr(void)
Get a pointer to the data in the packetbuf.
uint8_t dest_addr_mode
2 bit.
int(* prepare)(const void *payload, unsigned short payload_len)
Prepare the radio with a packet to be sent.
#define PROCESS(name, strname)
Declare a process.
void ringbufindex_init(struct ringbufindex *r, uint8_t size)
Initialize a ring buffer.
Header file for the ringbufindex library
frame802154_fcf_t fcf
Frame control field.
void packetbuf_clear(void)
Clear and reset the packetbuf.
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Header file for the energy estimation mechanism
int ringbufindex_peek_get(const struct ringbufindex *r)
Return the index of the first element which will be removed if calling ringbufindex_get.
#define PROCESS_YIELD_UNTIL(c)
Yield the currently running process until a condition occurs.
#define PROCESS_BEGIN()
Define the beginning of a process.
#define PROCESS_END()
Define the end of a process.
int frame802154_parse(uint8_t *data, int len, frame802154_t *pf)
Parses an input frame.
int(* receiving_packet)(void)
Check if the radio driver is currently receiving a packet.
Header file for the CRC16 calculcation
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.
int payload_len
Length of payload field.
A set of debugging macros for the IP stack
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
uint8_t src_addr[8]
Source address.
linkaddr_t linkaddr_node_addr
The link-layer address of the node.
#define IEEE802154_DEFAULT_CHANNEL
The default channel for IEEE 802.15.4 networks.
#define RTIMER_NOW()
Get the current clock time.
void(* input)(void)
Callback for getting notified of incoming packet.
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.
The IEEE 802.15.4 frame has a number of constant/fixed fields that can be counted to make frame const...
Header file for the real-time timer module.
unsigned short crc16_data(const unsigned char *data, int len, unsigned short acc)
Calculate the CRC16 over a data area.
uint8_t src_addr_mode
2 bit.
#define PACKETBUF_SIZE
The size of the packetbuf, in bytes.
MICROMAC_RADIO driver header file
802.15.4 frame creation and parsing functions
#define RADIO_RX_MODE_ADDRESS_FILTER
The radio reception mode controls address filtering and automatic transmission of acknowledgements in...
uint16_t dest_pid
Destination PAN ID.
Parameters used by the frame802154_create() function.
#define RADIO_TX_MODE_SEND_ON_CCA
The radio transmission mode controls whether transmissions should be done using clear channel assessm...
int linkaddr_cmp(const linkaddr_t *addr1, const linkaddr_t *addr2)
Compare two link-layer addresses.
static int8_t set_channel(uint8_t channel)
Set the current operating channel.
uint8_t seq
Sequence number.
int ringbufindex_get(struct ringbufindex *r)
Remove the first element and return its index.
int(* read)(void *buf, unsigned short buf_len)
Read a received packet into a buffer.
int ringbufindex_peek_put(const struct ringbufindex *r)
Check if there is space to put an element.
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.
PROCESS_THREAD(cc2538_rf_process, ev, data)
Implementation of the cc2538 RF driver process.
uint8_t * payload
Pointer to 802.15.4 payload.
uint8_t dest_addr[8]
Destination address.
radio_result_t(* set_object)(radio_param_t param, const void *src, size_t size)
Set a radio parameter object.
Header file for the LED HAL.
int ringbufindex_put(struct ringbufindex *r)
Put one element to the ring buffer.
void packetbuf_set_datalen(uint16_t len)
Set the length of the data in the packetbuf.
int(* on)(void)
Turn the radio on.
void process_start(struct process *p, process_data_t data)
Start a process.
static uint8_t get_channel()
Get the current operating channel.