/*---------------------------------------------------------------------------*/
static int
on(void)
{
lpp_is_on = 1;
turn_radio_on();
return 1;
}
/*---------------------------------------------------------------------------*/
static int
off(int keep_radio_on)
{
lpp_is_on = 0;
if(keep_radio_on) {
turn_radio_on();
} else {
turn_radio_off();
}
return 1;
}
/*---------------------------------------------------------------------------*/
static void
turn_radio_on_callback(void *packet)
{
struct queue_list_item *p = packet;
list_remove(pending_packets_list, p);
list_add(queued_packets_list, p);
turn_radio_on();
/* printf("enc\n");*/
}
/*---------------------------------------------------------------------------*/
static void
send_stream_probe(void *dummy)
{
/* 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();
is_streaming = 1;
}
/**
* 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();
}
}
/**
* 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 void
listen_callback(int periods)
{
is_listening = periods;
turn_radio_on();
}
/* This function goes through all encounters to see if it finds a
matching neighbor. If so, we set a ctimer that will turn on the
radio just before we expect the neighbor to send a probe packet. If
we cannot find a matching encounter, we just turn on the radio.
The outbound packet is put on either the pending_packets_list or
the queued_packets_list, depending on if the packet should be sent
immediately.
*/
static void
turn_radio_on_for_neighbor(rimeaddr_t *neighbor, struct queue_list_item *i)
{
#if WITH_STREAMING
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM) {
is_streaming = 1;
turn_radio_on();
list_add(queued_packets_list, i);
ctimer_set(&stream_off_timer, STREAM_OFF_TIME,
stream_off, NULL);
return;
}
#endif /* WITH_STREAMING */
if(rimeaddr_cmp(neighbor, &rimeaddr_null)) {
#if ! WITH_PENDING_BROADCAST
/* We have been asked to turn on the radio for a broadcast, so we
just turn on the radio. */
turn_radio_on();
#endif /* ! WITH_PENDING_BROADCAST */
list_add(queued_packets_list, i);
return;
}
#if WITH_ENCOUNTER_OPTIMIZATION
struct encounter *e;
/* 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)) {
if(rimeaddr_cmp(neighbor, &e->neighbor)) {
clock_time_t wait, now;
/* We expect encounters to happen roughly every OFF_TIME time
units. The next expected encounter is at time e->time +
OFF_TIME. To compute a relative offset, we subtract with
clock_time(). Because we are only interested in turning on
the radio within the OFF_TIME period, we compute the waiting
time with modulo OFF_TIME. */
now = clock_time();
wait = (((clock_time_t)(e->time - now)) % (OFF_TIME + LISTEN_TIME)) -
2 * LISTEN_TIME;
/* printf("now %d e %d e-n %d w %d %d\n", now, e->time, e->time - now, (e->time - now) % (OFF_TIME), wait);
printf("Time now %lu last encounter %lu next expected encouter %lu wait %lu/%d (%lu)\n",
(1000ul * (unsigned long)now) / CLOCK_SECOND,
(1000ul * (unsigned long)e->time) / CLOCK_SECOND,
(1000ul * (unsigned long)(e->time + OFF_TIME)) / CLOCK_SECOND,
(1000ul * (unsigned long)wait) / CLOCK_SECOND, wait,
(1000ul * (unsigned long)(wait + now)) / CLOCK_SECOND);*/
/* printf("Neighbor %d.%d found encounter, waiting %d ticks\n",
neighbor->u8[0], neighbor->u8[1], wait);*/
ctimer_set(&e->turn_on_radio_timer, wait, turn_radio_on_callback, i);
list_add(pending_packets_list, i);
return;
}
}
#endif /* WITH_ENCOUNTER_OPTIMIZATION */
/* We did not find the neighbor in the list of recent encounters, so
we just turn on the radio. */
/* printf("Neighbor %d.%d not found in recent encounters\n",
neighbor->u8[0], neighbor->u8[1]);*/
turn_radio_on();
list_add(queued_packets_list, i);
return;
}
