static void
powercycle_turn_radio_off(void)
{
if(we_are_sending == 0 &&
waiting_for_packet == 0) {
off();
}
#if XMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* XMAC_CONF_COMPOWER */
}
/**
* Send a probe packet.
*/
static void
send_probe(void)
{
struct lpp_hdr *hdr;
struct announcement_msg *adata;
struct announcement *a;
/* Set up the probe header. */
packetbuf_clear();
packetbuf_set_datalen(sizeof(struct lpp_hdr));
hdr = packetbuf_dataptr();
hdr->type = TYPE_PROBE;
rimeaddr_copy(&hdr->sender, &rimeaddr_node_addr);
/* rimeaddr_copy(&hdr->receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));*/
rimeaddr_copy(&hdr->receiver, &rimeaddr_null);
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null);
{
int hdrlen = NETSTACK_FRAMER.create();
if(hdrlen == 0) {
/* Failed to send */
return;
}
}
/* Construct the announcements */
adata = (struct announcement_msg *)((char *)hdr + sizeof(struct lpp_hdr));
adata->num = 0;
for(a = announcement_list(); a != NULL; a = list_item_next(a)) {
adata->data[adata->num].id = a->id;
adata->data[adata->num].value = a->value;
adata->num++;
}
packetbuf_set_datalen(sizeof(struct lpp_hdr) +
ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata->num);
/* PRINTF("Sending probe\n");*/
/* printf("probe\n");*/
if(NETSTACK_RADIO.channel_clear()) {
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
} else {
off_time_adjustment = random_rand() % (OFF_TIME / 2);
}
compower_accumulate(&compower_idle_activity);
}
/*---------------------------------------------------------------------------*/
static void
powercycle_turn_radio_off(void)
{
#if CONTIKIMAC_CONF_COMPOWER
uint8_t was_on = radio_is_on;
#endif /* CONTIKIMAC_CONF_COMPOWER */
if(we_are_sending == 0 && we_are_receiving_burst == 0) {
off();
#if CONTIKIMAC_CONF_COMPOWER
if(was_on && !radio_is_on) {
compower_accumulate(&compower_idle_activity);
}
#endif /* CONTIKIMAC_CONF_COMPOWER */
}
}
/**
* Send a probe packet.
*/
static void
send_probe(void)
{
struct lpp_hdr *hdr;
struct announcement_msg *adata;
struct announcement *a;
/* Set up the probe header. */
packetbuf_clear();
packetbuf_set_datalen(sizeof(struct lpp_hdr));
hdr = packetbuf_dataptr();
hdr->type = TYPE_PROBE;
rimeaddr_copy(&hdr->sender, &rimeaddr_node_addr);
rimeaddr_copy(&hdr->receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
/* Construct the announcements */
adata = (struct announcement_msg *)((char *)hdr + sizeof(struct lpp_hdr));
adata->num = 0;
for(a = announcement_list(); a != NULL; a = a->next) {
adata->data[adata->num].id = a->id;
adata->data[adata->num].value = a->value;
adata->num++;
}
packetbuf_set_datalen(sizeof(struct lpp_hdr) +
ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata->num);
/* PRINTF("Sending probe\n");*/
/* printf("probe\n");*/
/* XXX should first check access to the medium (CCA - Clear Channel
Assessment) and add LISTEN_TIME to off_time_adjustment if there
is a packet in the air. */
radio->send(packetbuf_hdrptr(), packetbuf_totlen());
compower_accumulate(&compower_idle_activity);
}
/*---------------------------------------------------------------------------*/
static void
remove_queued_packet(void *item)
{
struct queue_list_item *i = item;
PRINTF("%d.%d: removing queued packet\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
ctimer_stop(&i->removal_timer);
queuebuf_free(i->packet);
list_remove(pending_packets_list, i);
list_remove(queued_packets_list, i);
/* XXX potential optimization */
if(list_length(queued_packets_list) == 0 && is_listening == 0) {
turn_radio_off();
compower_accumulate(&i->compower);
}
memb_free(&queued_packets_memb, i);
}
/*---------------------------------------------------------------------------*/
static void
remove_queued_packet(struct queue_list_item *i, uint8_t tx_ok)
{
mac_callback_t sent;
void *ptr;
int num_transmissions = 0;
int status;
PRINTF("%d.%d: removing queued packet\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
queuebuf_to_packetbuf(i->packet);
ctimer_stop(&i->removal_timer);
queuebuf_free(i->packet);
list_remove(pending_packets_list, i);
list_remove(queued_packets_list, i);
/* XXX potential optimization */
if(list_length(queued_packets_list) == 0 && is_listening == 0) {
turn_radio_off();
compower_accumulate(&i->compower);
}
sent = i->sent_callback;
ptr = i->sent_callback_ptr;
num_transmissions = i->num_transmissions;
memb_free(&queued_packets_memb, i);
if(num_transmissions == 0 || tx_ok == 0) {
status = MAC_TX_NOACK;
} else {
status = MAC_TX_OK;
}
mac_call_sent_callback(sent, ptr, status, num_transmissions);
}
/**
* Read a packet from the underlying radio driver. If the incoming
* packet is a probe packet and the sender of the probe matches the
* destination address of the queued packet (if any), the queued packet
* is sent.
*/
static void
input_packet(void)
{
struct lpp_hdr hdr;
clock_time_t reception_time;
reception_time = clock_time();
if(!NETSTACK_FRAMER.parse()) {
printf("lpp input_packet framer error\n");
}
memcpy(&hdr, packetbuf_dataptr(), sizeof(struct lpp_hdr));;
packetbuf_hdrreduce(sizeof(struct lpp_hdr));
/* PRINTF("got packet type %d\n", hdr->type);*/
if(hdr.type == TYPE_PROBE) {
struct announcement_msg adata;
/* Register the encounter with the sending node. We now know the
neighbor's phase. */
register_encounter(&hdr.sender, reception_time);
/* Parse incoming announcements */
memcpy(&adata, packetbuf_dataptr(),
MIN(packetbuf_datalen(), sizeof(adata)));
#if 0
PRINTF("%d.%d: probe from %d.%d with %d announcements\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1], adata->num);
if(adata.num / sizeof(struct announcement_data) > sizeof(struct announcement_msg)) {
/* Sanity check. The number of announcements is too large -
corrupt packet has been received. */
return 0;
}
for(i = 0; i < adata.num; ++i) {
/* PRINTF("%d.%d: announcement %d: %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
adata->data[i].id,
adata->data[i].value);*/
announcement_heard(&hdr.sender,
adata.data[i].id,
adata.data[i].value);
}
#endif /* 0 */
/* Go through the list of packets to be sent to see if any of
them match the sender of the probe, or if they are a
broadcast packet that should be sent. */
if(list_length(queued_packets_list) > 0) {
struct queue_list_item *i;
for(i = list_head(queued_packets_list); i != NULL; i = list_item_next(i)) {
const rimeaddr_t *receiver;
uint8_t sent;
sent = 0;
receiver = queuebuf_addr(i->packet, PACKETBUF_ADDR_RECEIVER);
if(rimeaddr_cmp(receiver, &hdr.sender) ||
rimeaddr_cmp(receiver, &rimeaddr_null)) {
queuebuf_to_packetbuf(i->packet);
#if WITH_PENDING_BROADCAST
if(i->broadcast_flag == BROADCAST_FLAG_NONE ||
i->broadcast_flag == BROADCAST_FLAG_SEND) {
i->num_transmissions = 1;
NETSTACK_RADIO.send(queuebuf_dataptr(i->packet),
queuebuf_datalen(i->packet));
sent = 1;
PRINTF("%d.%d: got a probe from %d.%d, sent packet to %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1],
receiver->u8[0], receiver->u8[1]);
} else {
PRINTF("%d.%d: got a probe from %d.%d, did not send packet\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1]);
}
#else /* WITH_PENDING_BROADCAST */
i->num_transmissions = 1;
NETSTACK_RADIO.send(queuebuf_dataptr(i->packet),
queuebuf_datalen(i->packet));
PRINTF("%d.%d: got a probe from %d.%d, sent packet to %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1],
receiver->u8[0], receiver->u8[1]);
#endif /* WITH_PENDING_BROADCAST */
/* off();*/
/* Attribute the energy spent on listening for the probe
to this packet transmission. */
compower_accumulate(&i->compower);
/* If the packet was not a broadcast packet, we dequeue it
now. Broadcast packets should be transmitted to all
neighbors, and are dequeued by the dutycycling function
instead, after the appropriate time. */
if(!rimeaddr_cmp(receiver, &rimeaddr_null)) {
if(detect_ack()) {
remove_queued_packet(i, 1);
} else {
remove_queued_packet(i, 0);
}
#if WITH_PROBE_AFTER_TRANSMISSION
/* Send a probe packet to catch any reply from the other node. */
restart_dutycycle(PROBE_AFTER_TRANSMISSION_TIME);
#endif /* WITH_PROBE_AFTER_TRANSMISSION */
#if WITH_STREAMING
if(is_streaming) {
ctimer_set(&stream_probe_timer, STREAM_PROBE_TIME,
send_stream_probe, NULL);
}
#endif /* WITH_STREAMING */
}
if(sent) {
turn_radio_off();
}
#if WITH_ACK_OPTIMIZATION
if(packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE)) {
/* We're sending a packet that needs an ACK, so we keep
the radio on in anticipation of the ACK. */
turn_radio_on();
}
#endif /* WITH_ACK_OPTIMIZATION */
}
}
}
} else if(hdr.type == TYPE_DATA) {
turn_radio_off();
if(!rimeaddr_cmp(&hdr.receiver, &rimeaddr_null)) {
if(!rimeaddr_cmp(&hdr.receiver, &rimeaddr_node_addr)) {
/* Not broadcast or for us */
PRINTF("%d.%d: data not for us from %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1]);
return;
}
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &hdr.receiver);
}
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &hdr.sender);
PRINTF("%d.%d: got data from %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.sender.u8[0], hdr.sender.u8[1]);
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#if WITH_PENDING_BROADCAST
if(rimeaddr_cmp(&hdr.receiver, &rimeaddr_null)) {
/* This is a broadcast packet. Check the list of pending
packets to see if we are currently sending a broadcast. If
so, we refrain from sending our broadcast until one sleep
cycle period, so that the other broadcaster will have
finished sending. */
struct queue_list_item *i;
for(i = list_head(queued_packets_list); i != NULL; i = list_item_next(i)) {
/* If the packet is a broadcast packet that is not yet
ready to be sent, we do not send it. */
if(i->broadcast_flag == BROADCAST_FLAG_PENDING) {
PRINTF("Someone else is sending, pending -> waiting\n");
set_broadcast_flag(i, BROADCAST_FLAG_WAITING);
}
}
}
#endif /* WITH_PENDING_BROADCAST */
#if WITH_PROBE_AFTER_RECEPTION
/* XXX send probe after receiving a packet to facilitate data
streaming. We must first copy the contents of the packetbuf into
a queuebuf to avoid overwriting the data with the probe packet. */
if(rimeaddr_cmp(&hdr.receiver, &rimeaddr_node_addr)) {
struct queuebuf *q;
q = queuebuf_new_from_packetbuf();
if(q != NULL) {
send_probe();
queuebuf_to_packetbuf(q);
queuebuf_free(q);
}
}
#endif /* WITH_PROBE_AFTER_RECEPTION */
#if WITH_ADAPTIVE_OFF_TIME
off_time = LOWEST_OFF_TIME;
restart_dutycycle(off_time);
#endif /* WITH_ADAPTIVE_OFF_TIME */
NETSTACK_MAC.input();
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
static struct ctimer ct;
if(!we_are_receiving_burst) {
off();
}
/* printf("cycle_start 0x%02x 0x%02x\n", cycle_start, cycle_start % CYCLE_TIME);*/
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse() >= 0) {
if(packetbuf_datalen() > 0 &&
packetbuf_totlen() > 0 &&
(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr) ||
packetbuf_holds_broadcast())) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* If FRAME_PENDING is set, we are receiving a packets in a burst */
/* TODO To prevent denial-of-sleep attacks, the transceiver should
be disabled upon receipt of an unauthentic frame. */
we_are_receiving_burst = packetbuf_attr(PACKETBUF_ATTR_PENDING);
if(we_are_receiving_burst) {
on();
/* Set a timer to turn the radio off in case we do not receive
a next packet */
ctimer_set(&ct, INTER_PACKET_DEADLINE, recv_burst_off, NULL);
} else {
off();
ctimer_stop(&ct);
}
#if RDC_WITH_DUPLICATE_DETECTION
/* Check for duplicate packet. */
if(mac_sequence_is_duplicate()) {
/* Drop the packet. */
/* printf("Drop duplicate ContikiMAC layer packet\n");*/
return;
}
mac_sequence_register_seqno();
#endif /* RDC_WITH_DUPLICATE_DETECTION */
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("contikimac: data not for us\n");
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
static struct ctimer ct;
if(!we_are_receiving_burst) {
off();
}
/* printf("cycle_start 0x%02x 0x%02x\n", cycle_start, cycle_start % CYCLE_TIME);*/
#ifdef NETSTACK_DECRYPT
NETSTACK_DECRYPT();
#endif /* NETSTACK_DECRYPT */
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse() >= 0) {
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
chdr = packetbuf_dataptr();
if(chdr->id != CONTIKIMAC_ID) {
PRINTF("contikimac: failed to parse hdr (%u)\n", packetbuf_totlen());
return;
}
packetbuf_hdrreduce(sizeof(struct hdr));
packetbuf_set_datalen(chdr->len);
#endif /* WITH_CONTIKIMAC_HEADER */
if(packetbuf_datalen() > 0 &&
packetbuf_totlen() > 0 &&
(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null))) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
#if !RDC_CONF_HARDWARE_SEND_ACK
if (rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_node_addr))
{
we_are_acking = 1;
/* need to send an ack */
static uint8_t ackbuf[ACK_LEN] = { 0 };
ackbuf[ACK_LEN - 1] = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
NETSTACK_RADIO.send(ackbuf, ACK_LEN);
we_are_acking = 0;
}
#endif
/* If FRAME_PENDING is set, we are receiving a packets in a burst */
we_are_receiving_burst = packetbuf_attr(PACKETBUF_ATTR_PENDING);
if(we_are_receiving_burst) {
on();
/* Set a timer to turn the radio off in case we do not receive
a next packet */
ctimer_set(&ct, INTER_PACKET_DEADLINE, recv_burst_off, NULL);
} else {
off();
ctimer_stop(&ct);
}
/* Check for duplicate packet. */
if(mac_sequence_is_duplicate()) {
/* Drop the packet. */
/* printf("Drop duplicate ContikiMAC layer packet\n");*/
return;
}
mac_sequence_register_seqno();
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("contikimac: data not for us\n");
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static void
powercycle_turn_radio_off(void)
{
#if CONTIKIMAC_CONF_COMPOWER
uint8_t was_on = radio_is_on;
#endif /* CONTIKIMAC_CONF_COMPOWER */
#if RDC_CONF_HARDWARE_SEND_ACK
if(we_are_sending == 0 && we_are_receiving_burst == 0) {
#else
if(we_are_sending == 0 && we_are_receiving_burst == 0 && we_are_acking == 0) {
#endif
off();
#if CONTIKIMAC_CONF_COMPOWER
if(was_on && !radio_is_on) {
compower_accumulate(&compower_idle_activity);
}
#endif /* CONTIKIMAC_CONF_COMPOWER */
}
}
/*---------------------------------------------------------------------------*/
static void
powercycle_turn_radio_on(void)
{
#if RDC_CONF_HARDWARE_SEND_ACK
if(we_are_sending == 0 && we_are_receiving_burst == 0) {
#else
if(we_are_sending == 0 && we_are_receiving_burst == 0 && we_are_acking == 0) {
#endif
on();
}
}
/*---------------------------------------------------------------------------*/
static char
powercycle(struct rtimer *t, void *ptr)
{
#if SYNC_CYCLE_STARTS
static volatile rtimer_clock_t sync_cycle_start;
static volatile uint8_t sync_cycle_phase;
#endif
PT_BEGIN(&pt);
#if SYNC_CYCLE_STARTS
sync_cycle_start = RTIMER_NOW();
#else
cycle_start = RTIMER_NOW();
#endif
while(1) {
static uint8_t packet_seen;
static rtimer_clock_t t0;
static uint8_t count;
#if SYNC_CYCLE_STARTS
/* Compute cycle start when RTIMER_ARCH_SECOND is not a multiple
of CHANNEL_CHECK_RATE */
if(sync_cycle_phase++ == NETSTACK_RDC_CHANNEL_CHECK_RATE) {
sync_cycle_phase = 0;
sync_cycle_start += RTIMER_ARCH_SECOND;
cycle_start = sync_cycle_start;
} else {
#if (RTIMER_ARCH_SECOND * NETSTACK_RDC_CHANNEL_CHECK_RATE) > 65535
cycle_start = sync_cycle_start + ((unsigned long)(sync_cycle_phase*RTIMER_ARCH_SECOND))/NETSTACK_RDC_CHANNEL_CHECK_RATE;
#else
cycle_start = sync_cycle_start + (sync_cycle_phase*RTIMER_ARCH_SECOND)/NETSTACK_RDC_CHANNEL_CHECK_RATE;
#endif
}
#else
cycle_start += CYCLE_TIME;
#endif
packet_seen = 0;
for(count = 0; count < CCA_COUNT_MAX; ++count) {
t0 = RTIMER_NOW();
if(we_are_sending == 0 && we_are_receiving_burst == 0) {
powercycle_turn_radio_on();
/* Check if a packet is seen in the air. If so, we keep the
radio on for a while (LISTEN_TIME_AFTER_PACKET_DETECTED) to
be able to receive the packet. We also continuously check
the radio medium to make sure that we wasn't woken up by a
false positive: a spurious radio interference that was not
caused by an incoming packet. */
if(NETSTACK_RADIO.channel_clear() == 0) {
packet_seen = 1;
break;
}
powercycle_turn_radio_off();
}
schedule_powercycle_fixed(t, RTIMER_NOW() + CCA_SLEEP_TIME);
PT_YIELD(&pt);
}
if(packet_seen) {
static rtimer_clock_t start;
static uint8_t silence_periods, periods;
start = RTIMER_NOW();
periods = silence_periods = 0;
while(we_are_sending == 0 && radio_is_on &&
RTIMER_CLOCK_LT(RTIMER_NOW(),
(start + LISTEN_TIME_AFTER_PACKET_DETECTED))) {
/* Check for a number of consecutive periods of
non-activity. If we see two such periods, we turn the
radio off. Also, if a packet has been successfully
received (as indicated by the
NETSTACK_RADIO.pending_packet() function), we stop
snooping. */
#if !RDC_CONF_HARDWARE_CSMA
/* A cca cycle will disrupt rx on some radios, e.g. mc1322x, rf230 */
/*TODO: Modify those drivers to just return the internal RSSI when already in rx mode */
if(NETSTACK_RADIO.channel_clear()) {
++silence_periods;
} else {
silence_periods = 0;
}
#endif
++periods;
if(NETSTACK_RADIO.receiving_packet()) {
silence_periods = 0;
}
if(silence_periods > MAX_SILENCE_PERIODS) {
powercycle_turn_radio_off();
break;
}
if(WITH_FAST_SLEEP &&
periods > MAX_NONACTIVITY_PERIODS &&
!(NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet())) {
powercycle_turn_radio_off();
break;
}
if(NETSTACK_RADIO.pending_packet()) {
break;
}
schedule_powercycle(t, CCA_CHECK_TIME + CCA_SLEEP_TIME);
PT_YIELD(&pt);
}
if(radio_is_on) {
if(!(NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet()) ||
!RTIMER_CLOCK_LT(RTIMER_NOW(),
(start + LISTEN_TIME_AFTER_PACKET_DETECTED))) {
powercycle_turn_radio_off();
}
}
}
if(RTIMER_CLOCK_LT(RTIMER_NOW() - cycle_start, CYCLE_TIME - CHECK_TIME * 4)) {
/* Schedule the next powercycle interrupt, or sleep the mcu
until then. Sleeping will not exit from this interrupt, so
ensure an occasional wake cycle or foreground processing will
be blocked until a packet is detected */
#if RDC_CONF_MCU_SLEEP
static uint8_t sleepcycle;
if((sleepcycle++ < 16) && !we_are_sending && !radio_is_on) {
rtimer_arch_sleep(CYCLE_TIME - (RTIMER_NOW() - cycle_start));
} else {
sleepcycle = 0;
schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start);
PT_YIELD(&pt);
}
#else
schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start);
PT_YIELD(&pt);
#endif
}
}
PT_END(&pt);
}
/*---------------------------------------------------------------------------*/
static int
broadcast_rate_drop(void)
{
#if CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT
if(!timer_expired(&broadcast_rate_timer)) {
broadcast_rate_counter++;
if(broadcast_rate_counter < CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT) {
return 0;
} else {
return 1;
}
} else {
timer_set(&broadcast_rate_timer, CLOCK_SECOND);
broadcast_rate_counter = 0;
return 0;
}
#else /* CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT */
return 0;
#endif /* CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT */
}
/*---------------------------------------------------------------------------*/
static int
send_packet(mac_callback_t mac_callback, void *mac_callback_ptr,
struct rdc_buf_list *buf_list,
int is_receiver_awake)
{
rtimer_clock_t t0;
rtimer_clock_t encounter_time = 0;
int strobes;
uint8_t got_strobe_ack = 0;
int hdrlen, len;
uint8_t is_broadcast = 0;
uint8_t is_reliable = 0;
uint8_t is_known_receiver = 0;
uint8_t collisions;
int transmit_len;
int ret;
uint8_t contikimac_was_on;
uint8_t seqno;
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
#endif /* WITH_CONTIKIMAC_HEADER */
/* Exit if RDC and radio were explicitly turned off */
if(!contikimac_is_on && !contikimac_keep_radio_on) {
PRINTF("contikimac: radio is turned off\n");
return MAC_TX_ERR_FATAL;
}
if(packetbuf_totlen() == 0) {
PRINTF("contikimac: send_packet data len 0\n");
return MAC_TX_ERR_FATAL;
}
#if !NETSTACK_CONF_BRIDGE_MODE
/* If NETSTACK_CONF_BRIDGE_MODE is set, assume PACKETBUF_ADDR_SENDER is already set. */
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
#endif
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
is_broadcast = 1;
PRINTDEBUG("contikimac: send broadcast\n");
if(broadcast_rate_drop()) {
return MAC_TX_COLLISION;
}
} else {
#if UIP_CONF_IPV6
PRINTDEBUG("contikimac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]);
#else /* UIP_CONF_IPV6 */
PRINTDEBUG("contikimac: send unicast to %u.%u\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
#endif /* UIP_CONF_IPV6 */
}
is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE);
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
#if WITH_CONTIKIMAC_HEADER
hdrlen = packetbuf_totlen();
if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) {
/* Failed to allocate space for contikimac header */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
chdr = packetbuf_hdrptr();
chdr->id = CONTIKIMAC_ID;
chdr->len = hdrlen;
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen < 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
packetbuf_hdr_remove(sizeof(struct hdr));
return MAC_TX_ERR_FATAL;
}
hdrlen += sizeof(struct hdr);
#else
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen < 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
#endif
/* Make sure that the packet is longer or equal to the shortest
packet length. */
transmit_len = packetbuf_totlen();
if(transmit_len < SHORTEST_PACKET_SIZE) {
/* Pad with zeroes */
uint8_t *ptr;
ptr = packetbuf_dataptr();
memset(ptr + packetbuf_datalen(), 0, SHORTEST_PACKET_SIZE - packetbuf_totlen());
PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen());
transmit_len = SHORTEST_PACKET_SIZE;
}
packetbuf_compact();
#ifdef NETSTACK_ENCRYPT
NETSTACK_ENCRYPT();
#endif /* NETSTACK_ENCRYPT */
transmit_len = packetbuf_totlen();
NETSTACK_RADIO.prepare(packetbuf_hdrptr(), transmit_len);
/* Remove the MAC-layer header since it will be recreated next time around. */
packetbuf_hdr_remove(hdrlen);
if(!is_broadcast && !is_receiver_awake) {
#if WITH_PHASE_OPTIMIZATION
ret = phase_wait(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
CYCLE_TIME, GUARD_TIME,
mac_callback, mac_callback_ptr, buf_list);
if(ret == PHASE_DEFERRED) {
return MAC_TX_DEFERRED;
}
if(ret != PHASE_UNKNOWN) {
is_known_receiver = 1;
}
#endif /* WITH_PHASE_OPTIMIZATION */
}
/* By setting we_are_sending to one, we ensure that the rtimer
powercycle interrupt do not interfere with us sending the packet. */
we_are_sending = 1;
/* If we have a pending packet in the radio, we should not send now,
because we will trash the received packet. Instead, we signal
that we have a collision, which lets the packet be received. This
packet will be retransmitted later by the MAC protocol
instread. */
if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) {
we_are_sending = 0;
PRINTF("contikimac: collision receiving %d, pending %d\n",
NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet());
return MAC_TX_COLLISION;
}
/* Switch off the radio to ensure that we didn't start sending while
the radio was doing a channel check. */
off();
strobes = 0;
/* Send a train of strobes until the receiver answers with an ACK. */
collisions = 0;
got_strobe_ack = 0;
/* Set contikimac_is_on to one to allow the on() and off() functions
to control the radio. We restore the old value of
contikimac_is_on when we are done. */
contikimac_was_on = contikimac_is_on;
contikimac_is_on = 1;
#if !RDC_CONF_HARDWARE_CSMA
/* Check if there are any transmissions by others. */
/* TODO: why does this give collisions before sending with the mc1322x? */
if(is_receiver_awake == 0) {
int i;
for(i = 0; i < CCA_COUNT_MAX_TX; ++i) {
t0 = RTIMER_NOW();
on();
#if CCA_CHECK_TIME > 0
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) { }
#endif
if(NETSTACK_RADIO.channel_clear() == 0) {
collisions++;
off();
break;
}
off();
t0 = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME)) { }
}
}
if(collisions > 0) {
we_are_sending = 0;
off();
PRINTF("contikimac: collisions before sending\n");
contikimac_is_on = contikimac_was_on;
return MAC_TX_COLLISION;
}
#endif /* RDC_CONF_HARDWARE_CSMA */
#if !RDC_CONF_HARDWARE_ACK
if(!is_broadcast) {
/* Turn radio on to receive expected unicast ack. Not necessary
with hardware ack detection, and may trigger an unnecessary cca
or rx cycle */
on();
}
#endif
watchdog_periodic();
t0 = RTIMER_NOW();
seqno = packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO);
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + STROBE_TIME); strobes++) {
watchdog_periodic();
if(!is_broadcast && (is_receiver_awake || is_known_receiver) &&
!RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + MAX_PHASE_STROBE_TIME)) {
PRINTF("miss to %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0]);
break;
}
len = 0;
{
rtimer_clock_t wt;
rtimer_clock_t txtime;
int ret;
txtime = RTIMER_NOW();
ret = NETSTACK_RADIO.transmit(transmit_len);
#if RDC_CONF_HARDWARE_ACK
/* For radios that block in the transmit routine and detect the
ACK in hardware */
if(ret == RADIO_TX_OK) {
if(!is_broadcast) {
got_strobe_ack = 1;
encounter_time = txtime;
break;
}
} else if (ret == RADIO_TX_NOACK) {
} else if (ret == RADIO_TX_COLLISION) {
PRINTF("contikimac: collisions while sending\n");
collisions++;
}
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
#else /* RDC_CONF_HARDWARE_ACK */
/* Wait for the ACK packet */
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet() ||
NETSTACK_RADIO.channel_clear() == 0)) {
uint8_t ackbuf[ACK_LEN];
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { }
len = NETSTACK_RADIO.read(ackbuf, ACK_LEN);
//PRINTF("%u %u vs %u", len, ackbuf[ACK_LEN - 1], seqno);
if(len == ACK_LEN && seqno == ackbuf[ACK_LEN - 1]) {
got_strobe_ack = 1;
encounter_time = txtime;
break;
} else {
PRINTF("contikimac: collisions while sending\n");
collisions++;
}
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
off();
PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes,
packetbuf_totlen(),
got_strobe_ack ? "ack" : "no ack",
collisions ? "collision" : "no collision");
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the transmitted
packet to packet attributes so that the higher levels can keep
track of the amount of energy spent on transmitting the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
contikimac_is_on = contikimac_was_on;
we_are_sending = 0;
/* Determine the return value that we will return from the
function. We must pass this value to the phase module before we
return from the function. */
if(collisions > 0) {
ret = MAC_TX_COLLISION;
} else if(!is_broadcast && !got_strobe_ack) {
ret = MAC_TX_NOACK;
} else {
ret = MAC_TX_OK;
}
#if WITH_PHASE_OPTIMIZATION
if(is_known_receiver && got_strobe_ack) {
PRINTF("no miss %d wake-ups %d\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
strobes);
}
if(!is_broadcast) {
if(collisions == 0 && is_receiver_awake == 0) {
phase_update(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
encounter_time, ret);
}
}
#endif /* WITH_PHASE_OPTIMIZATION */
return ret;
}
/*---------------------------------------------------------------------------*/
static void
qsend_packet(mac_callback_t sent, void *ptr)
{
int ret = send_packet(sent, ptr, NULL, 0);
if(ret != MAC_TX_DEFERRED) {
mac_call_sent_callback(sent, ptr, ret, 1);
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
static struct ctimer ct;
int duplicate = 0;
#if CONTIKIMAC_SEND_SW_ACK
int original_datalen;
uint8_t *original_dataptr;
original_datalen = packetbuf_datalen();
original_dataptr = packetbuf_dataptr();
#endif
if(!we_are_receiving_burst) {
off();
}
if(packetbuf_datalen() == ACK_LEN) {
/* Ignore ack packets */
PRINTF("ContikiMAC: ignored ack\n");
return;
}
/* printf("cycle_start 0x%02x 0x%02x\n", cycle_start, cycle_start % CYCLE_TIME);*/
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse() >= 0) {
if(packetbuf_datalen() > 0 &&
packetbuf_totlen() > 0 &&
(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr) ||
packetbuf_holds_broadcast())) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* If FRAME_PENDING is set, we are receiving a packets in a burst */
we_are_receiving_burst = packetbuf_attr(PACKETBUF_ATTR_PENDING);
if(we_are_receiving_burst) {
on();
/* Set a timer to turn the radio off in case we do not receive
a next packet */
ctimer_set(&ct, INTER_PACKET_DEADLINE, recv_burst_off, NULL);
} else {
off();
ctimer_stop(&ct);
}
#if RDC_WITH_DUPLICATE_DETECTION
/* Check for duplicate packet. */
duplicate = mac_sequence_is_duplicate();
if(duplicate) {
/* Drop the packet. */
PRINTF("contikimac: Drop duplicate\n");
} else {
mac_sequence_register_seqno();
}
#endif /* RDC_WITH_DUPLICATE_DETECTION */
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
#if CONTIKIMAC_SEND_SW_ACK
{
frame802154_t info154;
frame802154_parse(original_dataptr, original_datalen, &info154);
if(info154.fcf.frame_type == FRAME802154_DATAFRAME &&
info154.fcf.ack_required != 0 &&
linkaddr_cmp((linkaddr_t *)&info154.dest_addr,
&linkaddr_node_addr)) {
uint8_t ackdata[ACK_LEN] = {0, 0, 0};
we_are_sending = 1;
ackdata[0] = FRAME802154_ACKFRAME;
ackdata[1] = 0;
ackdata[2] = info154.seq;
NETSTACK_RADIO.send(ackdata, ACK_LEN);
we_are_sending = 0;
}
}
#endif /* CONTIKIMAC_SEND_SW_ACK */
if(!duplicate) {
NETSTACK_MAC.input();
}
return;
} else {
PRINTDEBUG("contikimac: data not for us\n");
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
struct xmac_hdr *hdr;
printf("input packet!\n");
if(NETSTACK_FRAMER.parse() >= 0) {
hdr = packetbuf_dataptr();
if(hdr->dispatch != DISPATCH) {
someone_is_sending = 0;
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null)) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* We have received the final packet, so we can go back to being
asleep. */
off();
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
{
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno &&
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
return;
}
}
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
rimeaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
#if XMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* XMAC_CONF_COMPOWER */
waiting_for_packet = 0;
PRINTDEBUG("xmac: data(%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("xmac: data not for us\n");
}
} else if(hdr->type == TYPE_STROBE) {
someone_is_sending = 2;
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* This is a strobe packet for us. */
/* If the sender address is someone else, we should
acknowledge the strobe and wait for the packet. By using
the same address as both sender and receiver, we flag the
message is a strobe ack. */
waiting_for_packet = 1;
#if 0
hdr->type = TYPE_STROBE_ACK;
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
packetbuf_compact();
if(NETSTACK_FRAMER.create() >= 0) {
/* We turn on the radio in anticipation of the incoming
packet. */
someone_is_sending = 1;
waiting_for_packet = 1;
on();
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
PRINTDEBUG("xmac: send strobe ack %u\n", packetbuf_totlen());
} else {
PRINTF("xmac: failed to send strobe ack\n");
}
#endif /* 0 */
} else if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null)) {
/* If the receiver address is null, the strobe is sent to
prepare for an incoming broadcast packet. If this is the
case, we turn on the radio and wait for the incoming
broadcast packet. */
waiting_for_packet = 1;
on();
} else {
PRINTDEBUG("xmac: strobe not for us\n");
}
/* We are done processing the strobe and we therefore return
to the caller. */
return;
#if XMAC_CONF_ANNOUNCEMENTS
} else if(hdr->type == TYPE_ANNOUNCEMENT) {
packetbuf_hdrreduce(sizeof(struct xmac_hdr));
parse_announcements(packetbuf_addr(PACKETBUF_ADDR_SENDER));
#endif /* XMAC_CONF_ANNOUNCEMENTS */
} else if(hdr->type == TYPE_STROBE_ACK) {
PRINTDEBUG("xmac: stray strobe ack\n");
} else {
PRINTF("xmac: unknown type %u (%u/%u)\n", hdr->type,
packetbuf_datalen(), len);
}
} else {
PRINTF("xmac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static int
send_packet(void)
{
rtimer_clock_t t0;
rtimer_clock_t t;
rtimer_clock_t encounter_time = 0;
int strobes;
int ret;
#if 0
struct xmac_hdr *hdr;
#endif
uint8_t got_strobe_ack = 0;
uint8_t got_ack = 0;
uint8_t strobe[MAX_STROBE_SIZE];
int strobe_len, len;
int is_broadcast = 0;
/*int is_reliable; */
struct encounter *e;
struct queuebuf *packet;
int is_already_streaming = 0;
uint8_t collisions;
/* Create the X-MAC header for the data packet. */
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
is_broadcast = 1;
PRINTDEBUG("xmac: send broadcast\n");
} else {
#if UIP_CONF_IPV6
PRINTDEBUG("xmac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]);
#else
PRINTDEBUG("xmac: send unicast to %u.%u\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
#endif /* UIP_CONF_IPV6 */
}
/* is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE); */
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
len = NETSTACK_FRAMER.create();
strobe_len = len + sizeof(struct xmac_hdr);
if(len < 0 || strobe_len > (int)sizeof(strobe)) {
/* Failed to send */
PRINTF("xmac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
memcpy(strobe, packetbuf_hdrptr(), len);
strobe[len] = DISPATCH; /* dispatch */
strobe[len + 1] = TYPE_STROBE; /* type */
packetbuf_compact();
packet = queuebuf_new_from_packetbuf();
if(packet == NULL) {
/* No buffer available */
PRINTF("xmac: send failed, no queue buffer available (of %u)\n",
QUEUEBUF_CONF_NUM);
return MAC_TX_ERR;
}
#if WITH_STREAMING
if(is_streaming == 1 &&
(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&is_streaming_to) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&is_streaming_to_too))) {
is_already_streaming = 1;
}
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM) {
is_streaming = 1;
if(rimeaddr_cmp(&is_streaming_to, &rimeaddr_null)) {
rimeaddr_copy(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
} else if(!rimeaddr_cmp(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER))) {
rimeaddr_copy(&is_streaming_to_too, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
}
stream_until = RTIMER_NOW() + DEFAULT_STREAM_TIME;
}
#endif /* WITH_STREAMING */
off();
#if WITH_ENCOUNTER_OPTIMIZATION
/* We go through the list of encounters to find if we have recorded
an encounter with this particular neighbor. If so, we can compute
the time for the next expected encounter and setup a ctimer to
switch on the radio just before the encounter. */
for(e = list_head(encounter_list); e != NULL; e = list_item_next(e)) {
const rimeaddr_t *neighbor = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(rimeaddr_cmp(neighbor, &e->neighbor)) {
rtimer_clock_t wait, now, expected;
/* We expect encounters to happen every DEFAULT_PERIOD time
units. The next expected encounter is at time e->time +
DEFAULT_PERIOD. To compute a relative offset, we subtract
with clock_time(). Because we are only interested in turning
on the radio within the DEFAULT_PERIOD period, we compute the
waiting time with modulo DEFAULT_PERIOD. */
now = RTIMER_NOW();
wait = ((rtimer_clock_t)(e->time - now)) % (DEFAULT_PERIOD);
if(wait < 2 * DEFAULT_ON_TIME) {
wait = DEFAULT_PERIOD;
}
expected = now + wait - 2 * DEFAULT_ON_TIME;
#if WITH_ACK_OPTIMIZATION
/* Wait until the receiver is expected to be awake */
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) !=
PACKETBUF_ATTR_PACKET_TYPE_ACK &&
is_streaming == 0) {
/* Do not wait if we are sending an ACK, because then the
receiver will already be awake. */
while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected));
}
#else /* WITH_ACK_OPTIMIZATION */
/* Wait until the receiver is expected to be awake */
while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected));
#endif /* WITH_ACK_OPTIMIZATION */
}
}
#endif /* WITH_ENCOUNTER_OPTIMIZATION */
/* By setting we_are_sending to one, we ensure that the rtimer
powercycle interrupt do not interfere with us sending the packet. */
we_are_sending = 1;
t0 = RTIMER_NOW();
strobes = 0;
LEDS_ON(LEDS_BLUE);
/* Send a train of strobes until the receiver answers with an ACK. */
/* Turn on the radio to listen for the strobe ACK. */
// on();
collisions = 0;
if(!is_already_streaming) {
watchdog_stop();
got_strobe_ack = 0;
t = RTIMER_NOW();
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + xmac_config.strobe_time);
strobes++) {
while(got_strobe_ack == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t + xmac_config.strobe_wait_time)) {
#if 0
rtimer_clock_t now = RTIMER_NOW();
/* See if we got an ACK */
packetbuf_clear();
len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
if(NETSTACK_FRAMER.parse() >= 0) {
hdr = packetbuf_dataptr();
if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE_ACK) {
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* We got an ACK from the receiver, so we can immediately send
the packet. */
got_strobe_ack = 1;
encounter_time = now;
} else {
PRINTDEBUG("xmac: strobe ack for someone else\n");
}
} else /*if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE)*/ {
PRINTDEBUG("xmac: strobe from someone else\n");
collisions++;
}
} else {
PRINTF("xmac: send failed to parse %u\n", len);
}
}
#endif /* 0 */
}
t = RTIMER_NOW();
/* Send the strobe packet. */
if(got_strobe_ack == 0 && collisions == 0) {
if(is_broadcast) {
#if WITH_STROBE_BROADCAST
ret = NETSTACK_RADIO.send(strobe, strobe_len);
#else
/* restore the packet to send */
queuebuf_to_packetbuf(packet);
ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
#endif
off();
} else {
#if 0
rtimer_clock_t wt;
#endif
on();
ret = NETSTACK_RADIO.send(strobe, strobe_len);
#if 0
/* Turn off the radio for a while to let the other side
respond. We don't need to keep our radio on when we know
that the other side needs some time to produce a reply. */
off();
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + WAIT_TIME_BEFORE_STROBE_ACK));
#endif /* 0 */
#if RDC_CONF_HARDWARE_ACK
if(ret == RADIO_TX_OK) {
got_strobe_ack = 1;
} else {
off();
}
#else
if(detect_ack()) {
got_strobe_ack = 1;
} else {
off();
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
}
}
#if WITH_ACK_OPTIMIZATION
/* If we have received the strobe ACK, and we are sending a packet
that will need an upper layer ACK (as signified by the
PACKETBUF_ATTR_RELIABLE packet attribute), we keep the radio on. */
if(got_strobe_ack && (packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM)) {
on(); /* Wait for ACK packet */
waiting_for_packet = 1;
} else {
off();
}
#endif /* WITH_ACK_OPTIMIZATION */
/* restore the packet to send */
queuebuf_to_packetbuf(packet);
queuebuf_free(packet);
/* Send the data packet. */
if((is_broadcast || got_strobe_ack || is_streaming) && collisions == 0) {
ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
if(!is_broadcast) {
#if RDC_CONF_HARDWARE_ACK
if(ret == RADIO_TX_OK) {
got_ack = 1;
}
#else
if(detect_ack()) {
got_ack = 1;
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
off();
#if WITH_ENCOUNTER_OPTIMIZATION
if(got_strobe_ack && !is_streaming) {
register_encounter(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time);
}
#endif /* WITH_ENCOUNTER_OPTIMIZATION */
watchdog_start();
PRINTF("xmac: send (strobes=%u,len=%u,%s), done\n", strobes,
packetbuf_totlen(), got_strobe_ack ? "ack" : "no ack");
#if XMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the transmitted
packet to packet attributes so that the higher levels can keep
track of the amount of energy spent on transmitting the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(¤t_packet);
#endif /* XMAC_CONF_COMPOWER */
we_are_sending = 0;
LEDS_OFF(LEDS_BLUE);
if(collisions == 0) {
if(is_broadcast == 0 && got_ack == 0) {
return MAC_TX_NOACK;
} else {
return MAC_TX_OK;
}
} else {
someone_is_sending++;
return MAC_TX_COLLISION;
}
}
static char
powercycle(struct rtimer *t, void *ptr)
{
PT_BEGIN(&pt);
while(1) {
static uint8_t packet_seen;
static rtimer_clock_t t0;
static uint8_t count;
cycle_start = RTIMER_NOW();
if(WITH_STREAMING && is_streaming) {
#if NURTIMER
if(!RTIMER_CLOCK_LT(cycle_start, RTIMER_NOW(), stream_until))
#else
if(!RTIMER_CLOCK_LT(RTIMER_NOW(), stream_until))
#endif
{
is_streaming = 0;
rimeaddr_copy(&is_streaming_to, &rimeaddr_null);
rimeaddr_copy(&is_streaming_to_too, &rimeaddr_null);
}
}
packet_seen = 0;
do {
for(count = 0; count < CCA_COUNT_MAX; ++count) {
t0 = RTIMER_NOW();
if(we_are_sending == 0) {
powercycle_turn_radio_on();
#if 0
#if NURTIMER
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + CCA_CHECK_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME));
#endif
#endif /* 0 */
/* Check if a packet is seen in the air. If so, we keep the
radio on for a while (LISTEN_TIME_AFTER_PACKET_DETECTED) to
be able to receive the packet. We also continuously check
the radio medium to make sure that we wasn't woken up by a
false positive: a spurious radio interference that was not
caused by an incoming packet. */
if(NETSTACK_RADIO.channel_clear() == 0) {
packet_seen = 1;
break;
}
powercycle_turn_radio_off();
}
schedule_powercycle_fixed(t, RTIMER_NOW() + CCA_SLEEP_TIME);
/* COOJA_DEBUG_STR("yield\n");*/
PT_YIELD(&pt);
}
if(packet_seen) {
static rtimer_clock_t start;
static uint8_t silence_periods, periods;
start = RTIMER_NOW();
periods = silence_periods = 0;
while(we_are_sending == 0 && radio_is_on &&
RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) {
/* Check for a number of consecutive periods of
non-activity. If we see two such periods, we turn the
radio off. Also, if a packet has been successfully
received (as indicated by the
NETSTACK_RADIO.pending_packet() function), we stop
snooping. */
if(NETSTACK_RADIO.channel_clear()) {
++silence_periods;
} else {
silence_periods = 0;
}
++periods;
if(NETSTACK_RADIO.receiving_packet()) {
silence_periods = 0;
}
if(silence_periods > MAX_SILENCE_PERIODS) {
LEDS_ON(LEDS_RED);
powercycle_turn_radio_off();
#if CONTIKIMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* CONTIKIMAC_CONF_COMPOWER */
LEDS_OFF(LEDS_RED);
break;
}
#if 1
if(periods > MAX_NONACTIVITY_PERIODIC && !(NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet())) {
LEDS_ON(LEDS_GREEN);
powercycle_turn_radio_off();
#if CONTIKIMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* CONTIKIMAC_CONF_COMPOWER */
LEDS_OFF(LEDS_GREEN);
break;
}
#endif /* 0 */
if(NETSTACK_RADIO.pending_packet()) {
break;
}
schedule_powercycle(t, CCA_CHECK_TIME + CCA_SLEEP_TIME);
LEDS_ON(LEDS_BLUE);
PT_YIELD(&pt);
LEDS_OFF(LEDS_BLUE);
}
if(radio_is_on && !(NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet())) {
LEDS_ON(LEDS_RED + LEDS_GREEN);
powercycle_turn_radio_off();
#if CONTIKIMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* CONTIKIMAC_CONF_COMPOWER */
LEDS_OFF(LEDS_RED + LEDS_GREEN);
}
} else {
#if CONTIKIMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* CONTIKIMAC_CONF_COMPOWER */
}
} while(is_snooping &&
RTIMER_CLOCK_LT(RTIMER_NOW() - cycle_start, CYCLE_TIME - CHECK_TIME));
if(is_snooping) {
LEDS_ON(LEDS_RED);
}
if(RTIMER_CLOCK_LT(RTIMER_NOW() - cycle_start, CYCLE_TIME)) {
/* schedule_powercycle(t, CYCLE_TIME - (RTIMER_NOW() - cycle_start));*/
schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start);
/* printf("cycle_start 0x%02x now 0x%02x wait 0x%02x\n",
cycle_start, RTIMER_NOW(), CYCLE_TIME - (RTIMER_NOW() - cycle_start));*/
PT_YIELD(&pt);
}
LEDS_OFF(LEDS_RED);
}
PT_END(&pt);
}
/*---------------------------------------------------------------------------*/
static int
send_packet(mac_callback_t mac_callback, void *mac_callback_ptr,
struct rdc_buf_list *buf_list,
int is_receiver_awake)
{
rtimer_clock_t t0;
rtimer_clock_t encounter_time = 0;
int strobes;
uint8_t got_strobe_ack = 0;
int hdrlen, len;
uint8_t is_broadcast = 0;
uint8_t is_reliable = 0;
uint8_t is_known_receiver = 0;
uint8_t collisions;
int transmit_len;
int ret;
uint8_t contikimac_was_on;
uint8_t seqno;
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
#endif /* WITH_CONTIKIMAC_HEADER */
/* Exit if RDC and radio were explicitly turned off */
if(!contikimac_is_on && !contikimac_keep_radio_on) {
PRINTF("contikimac: radio is turned off\n");
return MAC_TX_ERR_FATAL;
}
if(packetbuf_totlen() == 0) {
PRINTF("contikimac: send_packet data len 0\n");
return MAC_TX_ERR_FATAL;
}
#if !NETSTACK_CONF_BRIDGE_MODE
/* If NETSTACK_CONF_BRIDGE_MODE is set, assume PACKETBUF_ADDR_SENDER is already set. */
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
#endif
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
is_broadcast = 1;
PRINTDEBUG("contikimac: send broadcast\n");
if(broadcast_rate_drop()) {
return MAC_TX_COLLISION;
}
} else {
#if UIP_CONF_IPV6
PRINTDEBUG("contikimac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]);
#else /* UIP_CONF_IPV6 */
PRINTDEBUG("contikimac: send unicast to %u.%u\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
#endif /* UIP_CONF_IPV6 */
}
is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE);
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
#if WITH_CONTIKIMAC_HEADER
hdrlen = packetbuf_totlen();
if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) {
/* Failed to allocate space for contikimac header */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
chdr = packetbuf_hdrptr();
chdr->id = CONTIKIMAC_ID;
chdr->len = hdrlen;
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen < 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
packetbuf_hdr_remove(sizeof(struct hdr));
return MAC_TX_ERR_FATAL;
}
hdrlen += sizeof(struct hdr);
#else
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen < 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
#endif
/* Make sure that the packet is longer or equal to the shortest
packet length. */
transmit_len = packetbuf_totlen();
if(transmit_len < SHORTEST_PACKET_SIZE) {
/* Pad with zeroes */
uint8_t *ptr;
ptr = packetbuf_dataptr();
memset(ptr + packetbuf_datalen(), 0, SHORTEST_PACKET_SIZE - packetbuf_totlen());
PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen());
transmit_len = SHORTEST_PACKET_SIZE;
}
packetbuf_compact();
#ifdef NETSTACK_ENCRYPT
NETSTACK_ENCRYPT();
#endif /* NETSTACK_ENCRYPT */
transmit_len = packetbuf_totlen();
NETSTACK_RADIO.prepare(packetbuf_hdrptr(), transmit_len);
/* Remove the MAC-layer header since it will be recreated next time around. */
packetbuf_hdr_remove(hdrlen);
if(!is_broadcast && !is_receiver_awake) {
#if WITH_PHASE_OPTIMIZATION
ret = phase_wait(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
CYCLE_TIME, GUARD_TIME,
mac_callback, mac_callback_ptr, buf_list);
if(ret == PHASE_DEFERRED) {
return MAC_TX_DEFERRED;
}
if(ret != PHASE_UNKNOWN) {
is_known_receiver = 1;
}
#endif /* WITH_PHASE_OPTIMIZATION */
}
/* By setting we_are_sending to one, we ensure that the rtimer
powercycle interrupt do not interfere with us sending the packet. */
we_are_sending = 1;
/* If we have a pending packet in the radio, we should not send now,
because we will trash the received packet. Instead, we signal
that we have a collision, which lets the packet be received. This
packet will be retransmitted later by the MAC protocol
instread. */
if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) {
we_are_sending = 0;
PRINTF("contikimac: collision receiving %d, pending %d\n",
NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet());
return MAC_TX_COLLISION;
}
/* Switch off the radio to ensure that we didn't start sending while
the radio was doing a channel check. */
off();
strobes = 0;
/* Send a train of strobes until the receiver answers with an ACK. */
collisions = 0;
got_strobe_ack = 0;
/* Set contikimac_is_on to one to allow the on() and off() functions
to control the radio. We restore the old value of
contikimac_is_on when we are done. */
contikimac_was_on = contikimac_is_on;
contikimac_is_on = 1;
#if !RDC_CONF_HARDWARE_CSMA
/* Check if there are any transmissions by others. */
/* TODO: why does this give collisions before sending with the mc1322x? */
if(is_receiver_awake == 0) {
int i;
for(i = 0; i < CCA_COUNT_MAX_TX; ++i) {
t0 = RTIMER_NOW();
on();
#if CCA_CHECK_TIME > 0
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) { }
#endif
if(NETSTACK_RADIO.channel_clear() == 0) {
collisions++;
off();
break;
}
off();
t0 = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME)) { }
}
}
if(collisions > 0) {
we_are_sending = 0;
off();
PRINTF("contikimac: collisions before sending\n");
contikimac_is_on = contikimac_was_on;
return MAC_TX_COLLISION;
}
#endif /* RDC_CONF_HARDWARE_CSMA */
#if !RDC_CONF_HARDWARE_ACK
if(!is_broadcast) {
/* Turn radio on to receive expected unicast ack. Not necessary
with hardware ack detection, and may trigger an unnecessary cca
or rx cycle */
on();
}
#endif
watchdog_periodic();
t0 = RTIMER_NOW();
seqno = packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO);
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + STROBE_TIME); strobes++) {
watchdog_periodic();
if(!is_broadcast && (is_receiver_awake || is_known_receiver) &&
!RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + MAX_PHASE_STROBE_TIME)) {
PRINTF("miss to %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0]);
break;
}
len = 0;
{
rtimer_clock_t wt;
rtimer_clock_t txtime;
int ret;
txtime = RTIMER_NOW();
ret = NETSTACK_RADIO.transmit(transmit_len);
#if RDC_CONF_HARDWARE_ACK
/* For radios that block in the transmit routine and detect the
ACK in hardware */
if(ret == RADIO_TX_OK) {
if(!is_broadcast) {
got_strobe_ack = 1;
encounter_time = txtime;
break;
}
} else if (ret == RADIO_TX_NOACK) {
} else if (ret == RADIO_TX_COLLISION) {
PRINTF("contikimac: collisions while sending\n");
collisions++;
}
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
#else /* RDC_CONF_HARDWARE_ACK */
/* Wait for the ACK packet */
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet() ||
NETSTACK_RADIO.channel_clear() == 0)) {
uint8_t ackbuf[ACK_LEN];
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { }
len = NETSTACK_RADIO.read(ackbuf, ACK_LEN);
if(len == ACK_LEN && seqno == ackbuf[ACK_LEN - 1]) {
got_strobe_ack = 1;
encounter_time = txtime;
break;
} else {
PRINTF("contikimac: collisions while sending\n");
collisions++;
}
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
off();
PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes,
packetbuf_totlen(),
got_strobe_ack ? "ack" : "no ack",
collisions ? "collision" : "no collision");
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the transmitted
packet to packet attributes so that the higher levels can keep
track of the amount of energy spent on transmitting the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
contikimac_is_on = contikimac_was_on;
we_are_sending = 0;
/* Determine the return value that we will return from the
function. We must pass this value to the phase module before we
return from the function. */
if(collisions > 0) {
ret = MAC_TX_COLLISION;
} else if(!is_broadcast && !got_strobe_ack) {
ret = MAC_TX_NOACK;
} else {
ret = MAC_TX_OK;
}
#if WITH_PHASE_OPTIMIZATION
if(is_known_receiver && got_strobe_ack) {
PRINTF("no miss %d wake-ups %d\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
strobes);
}
if(!is_broadcast) {
if(collisions == 0 && is_receiver_awake == 0) {
phase_update(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
encounter_time, ret);
}
}
#endif /* WITH_PHASE_OPTIMIZATION */
return ret;
}
/**
* Duty cycle the radio and send probes. This function is called
* repeatedly by a ctimer. The function restart_dutycycle() is used to
* (re)start the duty cycling.
*/
static int
dutycycle(void *ptr)
{
struct ctimer *t = ptr;
PT_BEGIN(&dutycycle_pt);
while(1) {
#if WITH_PENDING_BROADCAST
{
/* Before sending the probe, we mark all broadcast packets in
our output queue to be pending. This means that they are
ready to be sent, once we know that no neighbor is
currently broadcasting. */
for(p = list_head(queued_packets_list); p != NULL; p = list_item_next(p)) {
if(p->broadcast_flag == BROADCAST_FLAG_WAITING) {
PRINTF("wait -> pending\n");
set_broadcast_flag(p, BROADCAST_FLAG_PENDING);
}
}
}
#endif /* WITH_PENDING_BROADCAST */
/* Turn on the radio for sending a probe packet and
anticipating a data packet from a neighbor. */
turn_radio_on();
/* Send a probe packet. */
send_probe();
/* Set a timer so that we keep the radio on for LISTEN_TIME. */
ctimer_set(t, LISTEN_TIME, (void (*)(void *))dutycycle, t);
PT_YIELD(&dutycycle_pt);
#if WITH_PENDING_BROADCAST
{
struct queue_list_item *p;
/* Go through the list of packets we are waiting to send, and
check if there are any pending broadcasts in the list. If
there are pending broadcasts, and we did not receive any
broadcast packets from a neighbor in response to our probe,
we mark the broadcasts as being ready to send. */
for(p = list_head(queued_packets_list); p != NULL; p = list_item_next(p)) {
if(p->broadcast_flag == BROADCAST_FLAG_PENDING) {
PRINTF("pending -> send\n");
set_broadcast_flag(p, BROADCAST_FLAG_SEND);
turn_radio_on();
}
}
}
#endif /* WITH_PENDING_BROADCAST */
/* If we have no packets to send (indicated by the list length of
queued_packets_list being zero), we should turn the radio
off. Othersize, we keep the radio on. */
if(num_packets_to_send() == 0) {
/* If we are not listening for announcements, we turn the radio
off and wait until we send the next probe. */
if(is_listening == 0) {
int current_off_time;
if(!NETSTACK_RADIO.receiving_packet()) {
turn_radio_off();
compower_accumulate(&compower_idle_activity);
}
current_off_time = off_time - off_time_adjustment;
if(current_off_time < LISTEN_TIME * 2) {
current_off_time = LISTEN_TIME * 2;
}
off_time_adjustment = 0;
ctimer_set(t, current_off_time, (void (*)(void *))dutycycle, t);
PT_YIELD(&dutycycle_pt);
#if WITH_ADAPTIVE_OFF_TIME
off_time += LOWEST_OFF_TIME;
if(off_time > OFF_TIME) {
off_time = OFF_TIME;
}
#endif /* WITH_ADAPTIVE_OFF_TIME */
} else {
/* We are listening for annonucements, so we count down the
listen time, and keep the radio on. */
is_listening--;
ctimer_set(t, OFF_TIME, (void (*)(void *))dutycycle, t);
PT_YIELD(&dutycycle_pt);
}
} else {
/* We had pending packets to send, so we do not turn the radio off. */
ctimer_set(t, off_time, (void (*)(void *))dutycycle, t);
PT_YIELD(&dutycycle_pt);
}
}
PT_END(&dutycycle_pt);
}
/*---------------------------------------------------------------------------*/
static int
send_packet(mac_callback_t mac_callback, void *mac_callback_ptr)
{
rtimer_clock_t t0;
rtimer_clock_t t;
rtimer_clock_t encounter_time = 0, last_transmission_time = 0;
uint8_t first_transmission = 1;
int strobes;
uint8_t got_strobe_ack = 0;
int hdrlen, len;
uint8_t is_broadcast = 0;
uint8_t is_reliable = 0;
uint8_t is_known_receiver = 0;
uint8_t collisions;
int transmit_len;
int i;
int ret;
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
#endif /* WITH_CONTIKIMAC_HEADER */
if(packetbuf_totlen() == 0) {
PRINTF("contikimac: send_packet data len 0\n");
return MAC_TX_ERR_FATAL;
}
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
is_broadcast = 1;
PRINTDEBUG("contikimac: send broadcast\n");
if(broadcast_rate_drop()) {
return MAC_TX_COLLISION;
}
} else {
#if UIP_CONF_IPV6
PRINTDEBUG("contikimac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]);
#else /* UIP_CONF_IPV6 */
PRINTDEBUG("contikimac: send unicast to %u.%u\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
#endif /* UIP_CONF_IPV6 */
}
is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE);
if(WITH_STREAMING) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM) {
if(rimeaddr_cmp(&is_streaming_to, &rimeaddr_null)) {
rimeaddr_copy(&is_streaming_to,
packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
} else if(!rimeaddr_cmp
(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER))) {
rimeaddr_copy(&is_streaming_to_too,
packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
}
stream_until = RTIMER_NOW() + DEFAULT_STREAM_TIME;
is_streaming = 1;
} else {
is_streaming = 0;
}
}
if(is_streaming) {
packetbuf_set_attr(PACKETBUF_ATTR_PENDING, 1);
}
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
#if WITH_CONTIKIMAC_HEADER
hdrlen = packetbuf_totlen();
if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) {
/* Failed to allocate space for contikimac header */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
chdr = packetbuf_hdrptr();
chdr->id = CONTIKIMAC_ID;
chdr->len = hdrlen;
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen == 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
packetbuf_hdr_remove(sizeof(struct hdr));
return MAC_TX_ERR_FATAL;
}
hdrlen += sizeof(struct hdr);
#else /* WITH_CONTIKIMAC_HEADER */
/* Create the MAC header for the data packet. */
hdrlen = NETSTACK_FRAMER.create();
if(hdrlen == 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
#endif /* WITH_CONTIKIMAC_HEADER */
/* Make sure that the packet is longer or equal to the shortest
packet length. */
transmit_len = packetbuf_totlen();
if(transmit_len < SHORTEST_PACKET_SIZE) {
#if 0
/* Pad with zeroes */
uint8_t *ptr;
ptr = packetbuf_dataptr();
memset(ptr + packetbuf_datalen(), 0, SHORTEST_PACKET_SIZE - packetbuf_totlen());
#endif
PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen());
transmit_len = SHORTEST_PACKET_SIZE;
}
packetbuf_compact();
NETSTACK_RADIO.prepare(packetbuf_hdrptr(), transmit_len);
/* Remove the MAC-layer header since it will be recreated next time around. */
packetbuf_hdr_remove(hdrlen);
if(!is_broadcast && !is_streaming) {
#if WITH_PHASE_OPTIMIZATION
if(WITH_ACK_OPTIMIZATION) {
/* Wait until the receiver is expected to be awake */
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) !=
PACKETBUF_ATTR_PACKET_TYPE_ACK) {
ret = phase_wait(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
CYCLE_TIME, GUARD_TIME,
mac_callback, mac_callback_ptr);
if(ret == PHASE_DEFERRED) {
return MAC_TX_DEFERRED;
}
if(ret != PHASE_UNKNOWN) {
is_known_receiver = 1;
}
}
} else {
ret = phase_wait(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
CYCLE_TIME, GUARD_TIME,
mac_callback, mac_callback_ptr);
if(ret == PHASE_DEFERRED) {
return MAC_TX_DEFERRED;
}
if(ret != PHASE_UNKNOWN) {
is_known_receiver = 1;
}
}
#endif /* WITH_PHASE_OPTIMIZATION */
}
/* By setting we_are_sending to one, we ensure that the rtimer
powercycle interrupt do not interfere with us sending the packet. */
we_are_sending = 1;
/* If we have a pending packet in the radio, we should not send now,
because we will trash the received packet. Instead, we signal
that we have a collision, which lets the packet be received. This
packet will be retransmitted later by the MAC protocol
instread. */
if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) {
we_are_sending = 0;
PRINTF("contikimac: collision receiving %d, pending %d\n",
NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet());
return MAC_TX_COLLISION;
}
/* Switch off the radio to ensure that we didn't start sending while
the radio was doing a channel check. */
off();
strobes = 0;
/* Send a train of strobes until the receiver answers with an ACK. */
collisions = 0;
got_strobe_ack = 0;
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) !=
PACKETBUF_ATTR_PACKET_TYPE_ACK && is_streaming == 0) {
/* Check if there are any transmissions by others. */
for(i = 0; i < CCA_COUNT_MAX; ++i) {
t0 = RTIMER_NOW();
on();
#if NURTIMER
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + CCA_CHECK_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) { }
#endif
if(NETSTACK_RADIO.channel_clear() == 0) {
collisions++;
off();
break;
}
off();
t0 = RTIMER_NOW();
#if NURTIMER
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + CCA_SLEEP_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME)) { }
#endif
}
}
if(collisions > 0) {
we_are_sending = 0;
off();
PRINTF("contikimac: collisions before sending\n");
return MAC_TX_COLLISION;
}
if(!is_broadcast) {
on();
}
watchdog_periodic();
t0 = RTIMER_NOW();
t = RTIMER_NOW();
#if NURTIMER
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + STROBE_TIME); strobes++) {
#else
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + STROBE_TIME); strobes++) {
#endif
watchdog_periodic();
if(is_known_receiver && !RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + MAX_PHASE_STROBE_TIME)) {
break;
}
len = 0;
t = RTIMER_NOW();
{
rtimer_clock_t wt;
rtimer_clock_t now = RTIMER_NOW();
int ret;
ret = NETSTACK_RADIO.transmit(transmit_len);
wt = RTIMER_NOW();
#if NURTIMER
while(RTIMER_CLOCK_LT(wt, RTIMER_NOW(), wt + INTER_PACKET_INTERVAL));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
#endif
if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet() ||
NETSTACK_RADIO.channel_clear() == 0)) {
uint8_t ackbuf[ACK_LEN];
wt = RTIMER_NOW();
#if NURTIMER
while(RTIMER_CLOCK_LT(wt, RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { }
#endif
len = NETSTACK_RADIO.read(ackbuf, ACK_LEN);
if(len == ACK_LEN) {
got_strobe_ack = 1;
// encounter_time = last_transmission_time;
encounter_time = now;
break;
} else {
PRINTF("contikimac: collisions while sending\n");
collisions++;
}
}
last_transmission_time = now;
first_transmission = 0;
}
}
if(WITH_ACK_OPTIMIZATION) {
/* If we have received the strobe ACK, and we are sending a packet
that will need an upper layer ACK (as signified by the
PACKETBUF_ATTR_RELIABLE packet attribute), we keep the radio on. */
if(got_strobe_ack && is_reliable) {
on(); /* Wait for ACK packet */
} else {
off();
}
} else {
off();
}
PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes,
packetbuf_totlen(),
got_strobe_ack ? "ack" : "no ack",
collisions ? "collision" : "no collision");
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the transmitted
packet to packet attributes so that the higher levels can keep
track of the amount of energy spent on transmitting the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
we_are_sending = 0;
/* Determine the return value that we will return from the
function. We must pass this value to the phase module before we
return from the function. */
if(collisions > 0) {
ret = MAC_TX_COLLISION;
} else if(!is_broadcast && !got_strobe_ack) {
ret = MAC_TX_NOACK;
} else {
ret = MAC_TX_OK;
}
#if WITH_PHASE_OPTIMIZATION
/* if(!first_transmission)*/ {
/* COOJA_DEBUG_PRINTF("first phase 0x%02x\n", encounter_time % CYCLE_TIME);*/
if(WITH_ACK_OPTIMIZATION) {
if(collisions == 0 && packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) !=
PACKETBUF_ATTR_PACKET_TYPE_ACK && is_streaming == 0) {
phase_update(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time,
ret);
}
} else {
if(collisions == 0 && is_streaming == 0) {
phase_update(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time,
ret);
}
}
}
#endif /* WITH_PHASE_OPTIMIZATION */
return ret;
}
/*---------------------------------------------------------------------------*/
static void
qsend_packet(mac_callback_t sent, void *ptr)
{
int ret = send_packet(sent, ptr);
if(ret != MAC_TX_DEFERRED) {
// printf("contikimac qsend_packet %p\n", ptr);
mac_call_sent_callback(sent, ptr, ret, 1);
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
/* We have received the packet, so we can go back to being
asleep. */
off();
/* printf("cycle_start 0x%02x 0x%02x\n", cycle_start, cycle_start % CYCLE_TIME);*/
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse()) {
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
chdr = packetbuf_dataptr();
if(chdr->id != CONTIKIMAC_ID) {
PRINTF("contikimac: failed to parse hdr (%u)\n", packetbuf_totlen());
return;
}
packetbuf_hdrreduce(sizeof(struct hdr));
packetbuf_set_datalen(chdr->len);
#endif /* WITH_CONTIKIMAC_HEADER */
if(packetbuf_datalen() > 0 &&
packetbuf_totlen() > 0 &&
(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null))) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
#if WITH_PHASE_OPTIMIZATION
/* If the sender has set its pending flag, it has its radio
turned on and we should drop the phase estimation that we
have from before. */
if(packetbuf_attr(PACKETBUF_ATTR_PENDING)) {
phase_remove(&phase_list, packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
#endif /* WITH_PHASE_OPTIMIZATION */
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
{
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno &&
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
/* printf("Drop duplicate ContikiMAC layer packet\n");*/
return;
}
}
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
rimeaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("contikimac: data not for us\n");
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
static struct ctimer ct;
if(!we_are_receiving_burst) {
off();
}
/* printf("cycle_start 0x%02x 0x%02x\n", cycle_start, cycle_start % CYCLE_TIME);*/
#ifdef NETSTACK_DECRYPT
NETSTACK_DECRYPT();
#endif /* NETSTACK_DECRYPT */
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse() >= 0) {
#if WITH_CONTIKIMAC_HEADER
struct hdr *chdr;
chdr = packetbuf_dataptr();
if(chdr->id != CONTIKIMAC_ID) {
PRINTF("contikimac: failed to parse hdr (%u)\n", packetbuf_totlen());
return;
}
packetbuf_hdrreduce(sizeof(struct hdr));
packetbuf_set_datalen(chdr->len);
#endif /* WITH_CONTIKIMAC_HEADER */
if(packetbuf_datalen() > 0 &&
packetbuf_totlen() > 0 &&
(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null))) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* If FRAME_PENDING is set, we are receiving a packets in a burst */
we_are_receiving_burst = packetbuf_attr(PACKETBUF_ATTR_PENDING);
if(we_are_receiving_burst) {
on();
/* Set a timer to turn the radio off in case we do not receive
a next packet */
ctimer_set(&ct, INTER_PACKET_DEADLINE, recv_burst_off, NULL);
} else {
off();
ctimer_stop(&ct);
}
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
{
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno &&
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
/* printf("Drop duplicate ContikiMAC layer packet\n");*/
return;
}
}
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
rimeaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("contikimac: data not for us\n");
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
struct cxmac_hdr *hdr;
if(NETSTACK_FRAMER.parse() >= 0) {
hdr = packetbuf_dataptr();
if(hdr->dispatch != DISPATCH) {
someone_is_sending = 0;
if(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr) ||
linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_null)) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* We have received the final packet, so we can go back to being
asleep. */
off();
#if CXMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* CXMAC_CONF_COMPOWER */
waiting_for_packet = 0;
PRINTDEBUG("cxmac: data(%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("cxmac: data not for us\n");
}
} else if(hdr->type == TYPE_STROBE) {
someone_is_sending = 2;
if(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_node_addr)) {
/* This is a strobe packet for us. */
/* If the sender address is someone else, we should
acknowledge the strobe and wait for the packet. By using
the same address as both sender and receiver, we flag the
message is a strobe ack. */
hdr->type = TYPE_STROBE_ACK;
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &linkaddr_node_addr);
packetbuf_compact();
if(NETSTACK_FRAMER.create() >= 0) {
/* We turn on the radio in anticipation of the incoming
packet. */
someone_is_sending = 1;
waiting_for_packet = 1;
on();
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
PRINTDEBUG("cxmac: send strobe ack %u\n", packetbuf_totlen());
} else {
PRINTF("cxmac: failed to send strobe ack\n");
}
} else if(linkaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&linkaddr_null)) {
/* If the receiver address is null, the strobe is sent to
prepare for an incoming broadcast packet. If this is the
case, we turn on the radio and wait for the incoming
broadcast packet. */
waiting_for_packet = 1;
on();
} else {
PRINTDEBUG("cxmac: strobe not for us\n");
}
/* We are done processing the strobe and we therefore return
to the caller. */
return;
#if CXMAC_CONF_ANNOUNCEMENTS
} else if(hdr->type == TYPE_ANNOUNCEMENT) {
packetbuf_hdrreduce(sizeof(struct cxmac_hdr));
parse_announcements(packetbuf_addr(PACKETBUF_ADDR_SENDER));
#endif /* CXMAC_CONF_ANNOUNCEMENTS */
} else if(hdr->type == TYPE_STROBE_ACK) {
PRINTDEBUG("cxmac: stray strobe ack\n");
} else {
PRINTF("cxmac: unknown type %u (%u)\n", hdr->type,
packetbuf_datalen());
}
} else {
PRINTF("cxmac: failed to parse (%u)\n", packetbuf_totlen());
}
}