deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
osd-contiki/core/net/mac/contikimac.c

986 lines
29 KiB
C
Raw Normal View History

ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/*
A work-in-progress rework of the Contiki MAC and radio layers. The main ideas are: * Separates the Contiki low-layer network stack into four layers: network (e.g. sicslowpan / rime), Medium Access Control MAC (e.g. CSMA), Radio Duty Cycling RDC (e.g. ContikiMAC, X-MAC), and radio (e.g. cc2420). * Introduces a new way to configure the network stack. Four #defines that specify what mechanism/protocol/driver to use at the four layers: NETSTACK_CONF_NETWORK, NETSTACK_CONF_MAC, NETSTACK_CONF_RDC, NETSTACK_CONF_RADIO. * Adds a callback mechanism to inform the MAC and network layers about the fate of a transmitted packet: if the packet was not possible to transmit, the cause of the failure is reported, and if the packets was successfully transmitted, the number of tries before it was finally transmitted is reported. * NULL-protocols at both the MAC and RDC layers: nullmac and nullrdc, which can be used when MAC and RDC functionality is not needed. * Extends the radio API with three new functions that enable more efficient radio duty cycling protocols: channel check, pending packet, and receiving packet. * New initialization mechanism, which takes advantage of the NETSTACK #defines.
2010-02-18 22:48:39 +01:00
* Copyright (c) 2010, Swedish Institute of Computer Science.
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
* $Id: contikimac.c,v 1.13 2010/03/16 18:11:13 adamdunkels Exp $
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
*/
/**
* \file
A work-in-progress rework of the Contiki MAC and radio layers. The main ideas are: * Separates the Contiki low-layer network stack into four layers: network (e.g. sicslowpan / rime), Medium Access Control MAC (e.g. CSMA), Radio Duty Cycling RDC (e.g. ContikiMAC, X-MAC), and radio (e.g. cc2420). * Introduces a new way to configure the network stack. Four #defines that specify what mechanism/protocol/driver to use at the four layers: NETSTACK_CONF_NETWORK, NETSTACK_CONF_MAC, NETSTACK_CONF_RDC, NETSTACK_CONF_RADIO. * Adds a callback mechanism to inform the MAC and network layers about the fate of a transmitted packet: if the packet was not possible to transmit, the cause of the failure is reported, and if the packets was successfully transmitted, the number of tries before it was finally transmitted is reported. * NULL-protocols at both the MAC and RDC layers: nullmac and nullrdc, which can be used when MAC and RDC functionality is not needed. * Extends the radio API with three new functions that enable more efficient radio duty cycling protocols: channel check, pending packet, and receiving packet. * New initialization mechanism, which takes advantage of the NETSTACK #defines.
2010-02-18 22:48:39 +01:00
* The Contiki power-saving MAC protocol (ContikiMAC)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
* \author
* Adam Dunkels <adam@sics.se>
* Niclas Finne <nfi@sics.se>
* Joakim Eriksson <joakime@sics.se>
*/
#include "net/netstack.h"
#include "dev/leds.h"
#include "dev/radio.h"
#include "dev/watchdog.h"
#include "lib/random.h"
#include "net/mac/contikimac.h"
#include "net/rime.h"
#include "sys/compower.h"
#include "sys/pt.h"
#include "sys/rtimer.h"
#include "contiki-conf.h"
#ifdef EXPERIMENT_SETUP
#include "experiment-setup.h"
#endif
#include <string.h>
#ifndef WITH_ACK_OPTIMIZATION
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
#define WITH_ACK_OPTIMIZATION 1
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#endif
#ifndef WITH_PHASE_OPTIMIZATION
#define WITH_PHASE_OPTIMIZATION 1
#endif
#ifndef WITH_STREAMING
#define WITH_STREAMING 1
#endif
struct announcement_data {
uint16_t id;
uint16_t value;
};
/* The maximum number of announcements in a single announcement
message - may need to be increased in the future. */
#define ANNOUNCEMENT_MAX 10
/* The structure of the announcement messages. */
struct announcement_msg {
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
uint8_t announcement_magic[2];
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
uint16_t num;
struct announcement_data data[ANNOUNCEMENT_MAX];
};
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
#define ANNOUNCEMENT_MAGIC1 0xAD
#define ANNOUNCEMENT_MAGIC2 0xAD
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/* The length of the header of the announcement message, i.e., the
"num" field in the struct. */
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
#define ANNOUNCEMENT_MSG_HEADERLEN (sizeof(uint16_t) * 2)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#ifdef CONTIKIMAC_CONF_CYCLE_TIME
#define CYCLE_TIME (CONTIKIMAC_CONF_CYCLE_TIME)
#else
#define CYCLE_TIME (RTIMER_ARCH_SECOND / MAC_CHANNEL_CHECK_RATE)
#endif
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
#define MAX_PHASE_STROBES 8
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#define CCA_COUNT_MAX 2
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
#define CCA_CHECK_TIME RTIMER_ARCH_SECOND / 8192
#define CCA_SLEEP_TIME RTIMER_ARCH_SECOND / 2000 + CCA_CHECK_TIME
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
#define CHECK_TIME (CCA_COUNT_MAX * (CCA_CHECK_TIME + CCA_SLEEP_TIME))
#define STREAM_CCA_COUNT (CYCLE_TIME / (CCA_SLEEP_TIME + CCA_CHECK_TIME) - CCA_COUNT_MAX)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
#define INTER_PACKET_INTERVAL RTIMER_ARCH_SECOND / 2500
#define AFTER_ACK_DETECTECT_WAIT_TIME RTIMER_ARCH_SECOND / 1500
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
#define LISTEN_TIME_AFTER_PACKET_DETECTED RTIMER_ARCH_SECOND / 100
#define SHORTEST_PACKET_SIZE 18
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/* The cycle time for announcements. */
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
#define ANNOUNCEMENT_PERIOD 2 * CLOCK_SECOND
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/* The time before sending an announcement within one announcement
cycle. */
#define ANNOUNCEMENT_TIME (random_rand() % (ANNOUNCEMENT_PERIOD))
#define STROBE_WAIT_TIME (RTIMER_ARCH_SECOND / 600)
#define STROBE_TIME (CYCLE_TIME + 8 * CHECK_TIME)
#define ACK_LEN 3
#include <stdio.h>
static struct rtimer rt;
static struct pt pt;
static volatile uint8_t contikimac_is_on = 0;
static volatile unsigned char we_are_sending = 0;
static volatile unsigned char radio_is_on = 0;
#define DEBUG 0
#if DEBUG
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#define PRINTDEBUG(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#define PRINTDEBUG(...)
#endif
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
/* Timers for keeping track of when to send announcements. */
static struct ctimer announcement_cycle_ctimer, announcement_ctimer;
static int announcement_radio_txpower;
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
/* Flag that is used to keep track of whether or not we are listening
for announcements from neighbors. */
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
static volatile uint8_t is_listening;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#if CONTIKIMAC_CONF_COMPOWER
static struct compower_activity current_packet;
#endif /* CONTIKIMAC_CONF_COMPOWER */
#if WITH_PHASE_OPTIMIZATION
#include "net/mac/phase.h"
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
#define MAX_PHASE_NEIGHBORS 30
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
PHASE_LIST(phase_list, MAX_PHASE_NEIGHBORS);
#endif /* WITH_PHASE_OPTIMIZATION */
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
static volatile uint8_t is_streaming;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
static rimeaddr_t is_streaming_to, is_streaming_to_too;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
static volatile rtimer_clock_t stream_until;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
#define DEFAULT_STREAM_TIME (4 * CYCLE_TIME)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#ifndef MIN
#define MIN(a, b) ((a) < (b)? (a) : (b))
#endif /* MIN */
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/*---------------------------------------------------------------------------*/
static void
on(void)
{
if(contikimac_is_on && radio_is_on == 0) {
radio_is_on = 1;
NETSTACK_RADIO.on();
}
}
/*---------------------------------------------------------------------------*/
static void
off(void)
{
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
if(contikimac_is_on && radio_is_on != 0 /*&& is_listening == 0*/) {
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
radio_is_on = 0;
NETSTACK_RADIO.off();
}
}
/*---------------------------------------------------------------------------*/
static char powercycle(struct rtimer *t, void *ptr);
static void
schedule_powercycle(struct rtimer *t, rtimer_clock_t time)
{
int r;
if(contikimac_is_on) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
if(RTIMER_CLOCK_LT(RTIMER_TIME(t) + time, RTIMER_NOW())) {
time = RTIMER_NOW() - RTIMER_TIME(t);
}
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
while(RTIMER_TIME(t) + time == RTIMER_NOW() ||
RTIMER_TIME(t) + time == RTIMER_NOW() + 1) {
++time;
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#if NURTIMER
r = rtimer_reschedule(t, time, 1);
#else
r = rtimer_set(t, RTIMER_TIME(t) + time, 1,
(void (*)(struct rtimer *, void *))powercycle, NULL);
#endif
if(r != RTIMER_OK) {
printf("schedule_powercycle: could not set rtimer\n");
}
}
}
static void
powercycle_turn_radio_off(void)
{
if(we_are_sending == 0) {
off();
}
}
static void
powercycle_turn_radio_on(void)
{
if(we_are_sending == 0) {
on();
}
}
static char
powercycle(struct rtimer *t, void *ptr)
{
rtimer_clock_t start;
if(is_streaming) {
start = RTIMER_NOW();
#if NURTIMER
if(!RTIMER_CLOCK_LT(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);
}
}
PT_BEGIN(&pt);
while(1) {
static uint8_t packet_seen;
static rtimer_clock_t t0, cycle_start;
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
static uint8_t count;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
cycle_start = RTIMER_NOW();
packet_seen = 0;
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
do {
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
for(count = 0; count < CCA_COUNT_MAX; ++count) {
t0 = RTIMER_NOW();
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
if(we_are_sending == 0) {
powercycle_turn_radio_on();
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#if NURTIMER
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + CCA_CHECK_TIME));
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#else
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME));
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#endif
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
/* 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();
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
schedule_powercycle(t, CCA_SLEEP_TIME + CCA_CHECK_TIME);
PT_YIELD(&pt);
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
if(packet_seen) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
static rtimer_clock_t start;
static uint8_t silence_periods, periods;
start = RTIMER_NOW();
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
periods = silence_periods = 0;
while(we_are_sending == 0 && radio_is_on &&
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) {
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
/* 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
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
listening. */
if(NETSTACK_RADIO.channel_clear()) {
++silence_periods;
} else {
silence_periods = 0;
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
++periods;
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
if(NETSTACK_RADIO.receiving_packet()) {
silence_periods = 0;
}
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
if(silence_periods > 5) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
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;
}
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
if(periods > 10 && !(NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet())) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
leds_on(LEDS_GREEN);
powercycle_turn_radio_off();
#if CONTIKIMAC_CONF_COMPOWER
compower_accumulate(&compower_idle_activity);
#endif /* CONTIKIMAC_CONF_COMPOWER */
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
leds_off(LEDS_GREEN);
break;
}
if(NETSTACK_RADIO.pending_packet()) {
break;
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
schedule_powercycle(t, CCA_CHECK_TIME + CCA_SLEEP_TIME);
leds_on(LEDS_BLUE);
PT_YIELD(&pt);
leds_off(LEDS_BLUE);
}
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
if(radio_is_on && !(NETSTACK_RADIO.receiving_packet() ||
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
NETSTACK_RADIO.pending_packet())) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
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 */
}
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
} while((is_streaming || is_listening) &&
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
RTIMER_NOW() - cycle_start < CYCLE_TIME - CCA_CHECK_TIME * CCA_COUNT_MAX);
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
if(RTIMER_NOW() - cycle_start < CYCLE_TIME) {
schedule_powercycle(t, CYCLE_TIME - (RTIMER_NOW() - cycle_start));
PT_YIELD(&pt);
}
}
PT_END(&pt);
}
/*---------------------------------------------------------------------------*/
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
static int
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
parse_announcements(void)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
{
/* Parse incoming announcements */
struct announcement_msg adata;
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
const rimeaddr_t *from;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
int i;
memcpy(&adata, packetbuf_dataptr(),
MIN(packetbuf_datalen(), sizeof(adata)));
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
from = packetbuf_addr(PACKETBUF_ADDR_SENDER);
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/* printf("%d.%d: probe from %d.%d with %d announcements\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
from->u8[0], from->u8[1], adata.num); */
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
/* for(i = 0; i < packetbuf_datalen(); ++i) {
printf("%02x ", ((uint8_t *)packetbuf_dataptr())[i]);
}
printf("\n"); */
for(i = 0; i < adata.num; ++i) {
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
/* printf("%d.%d: announcement %d: %d\n",
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
adata.data[i].id,
adata.data[i].value); */
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
announcement_heard(from, adata.data[i].id, adata.data[i].value);
}
return i;
}
/*---------------------------------------------------------------------------*/
static int
format_announcement(char *hdr)
{
struct announcement_msg adata;
struct announcement *a;
/* Construct the announcements */
/* adata = (struct announcement_msg *)hdr; */
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
adata.announcement_magic[0] = ANNOUNCEMENT_MAGIC1;
adata.announcement_magic[1] = ANNOUNCEMENT_MAGIC2;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
adata.num = 0;
for(a = announcement_list();
a != NULL && adata.num < ANNOUNCEMENT_MAX; a = a->next) {
adata.data[adata.num].id = a->id;
adata.data[adata.num].value = a->value;
adata.num++;
}
memcpy(hdr, &adata, sizeof(struct announcement_msg));
if(adata.num > 0) {
return ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata.num;
} else {
return 0;
}
}
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
/*---------------------------------------------------------------------------*/
static int
Improved handling of neighbor phase estimation: instead of busy-waiting while waiting for neighbor's phase, the new code schedules a timer just before neighbor wakes up
2010-02-28 21:19:47 +01:00
send_packet(mac_callback_t mac_callback, void *mac_callback_ptr)
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
{
rtimer_clock_t t0;
rtimer_clock_t t;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
rtimer_clock_t encounter_time = 0, last_transmission_time = 0;
uint8_t first_transmission = 1;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
int strobes;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
uint8_t got_strobe_ack = 0;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
int len;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
uint8_t is_broadcast = 0;
uint8_t is_reliable = 0;
uint8_t is_known_receiver = 0;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
uint8_t collisions;
int transmit_len;
int i;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
int ret;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
if(packetbuf_totlen() == 0) {
PRINTF("contikimac: send_packet data len 0\n");
return MAC_TX_ERR_FATAL;
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
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");
} 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]);
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
#else /* UIP_CONF_IPV6 */
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
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);
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
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;
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
is_streaming = 1;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
}
}
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, 7 * CHECK_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, 7 * CHECK_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 */
}
/* Make sure that the packet is longer or equal to the shorest
packet length. */
if(packetbuf_totlen() < SHORTEST_PACKET_SIZE) {
PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen());
packetbuf_set_datalen(SHORTEST_PACKET_SIZE);
}
/* Create the MAC header for the data packet. */
Replaced old framer (framer_get/framer_set) with new NETSTACK style configuration. Added nullrdc-framer that is a nullrdc with framer support.
2010-03-01 14:30:21 +01:00
len = NETSTACK_FRAMER.create();
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
if(len == 0) {
/* Failed to send */
PRINTF("contikimac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
packetbuf_compact();
NETSTACK_RADIO.prepare(packetbuf_hdrptr(), packetbuf_totlen());
transmit_len = packetbuf_totlen();
/* 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;
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
PRINTF("contikimac: collision receiving %d, pending %d\n",
NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet());
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
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();
#if NURTIMER
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t0 + CCA_SLEEP_TIME + CCA_CHECK_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME + CCA_CHECK_TIME)) { }
#endif
}
}
if(collisions > 0) {
we_are_sending = 0;
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
off();
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
PRINTF("contikimac: collisions before sending\n");
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
return MAC_TX_COLLISION;
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
if(!is_broadcast) {
on();
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
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
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
if(is_known_receiver && strobes > MAX_PHASE_STROBES) {
break;
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
len = 0;
t = RTIMER_NOW();
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
{
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
rtimer_clock_t wt;
rtimer_clock_t now = RTIMER_NOW();
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
leds_on(LEDS_RED);
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
NETSTACK_RADIO.transmit(transmit_len);
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
leds_off(LEDS_RED);
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
wt = RTIMER_NOW();
#if NURTIMER
Avoid newlines in macro expansions as cc65 doesn't support them between the macro name and the open parenthesis of the arguments. There were btw other even longer lines with expansions of the same macro already present.
2010-03-14 13:13:54 +01:00
while(RTIMER_CLOCK_LT(wt, RTIMER_NOW(), wt + INTER_PACKET_INTERVAL));
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#else
Avoid newlines in macro expansions as cc65 doesn't support them between the macro name and the open parenthesis of the arguments. There were btw other even longer lines with expansions of the same macro already present.
2010-03-14 13:13:54 +01:00
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { }
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#endif
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() ||
NETSTACK_RADIO.pending_packet() ||
NETSTACK_RADIO.channel_clear() == 0)) {
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
uint8_t ackbuf[ACK_LEN];
wt = RTIMER_NOW();
#if NURTIMER
Avoid newlines in macro expansions as cc65 doesn't support them between the macro name and the open parenthesis of the arguments. There were btw other even longer lines with expansions of the same macro already present.
2010-03-14 13:13:54 +01:00
while(RTIMER_CLOCK_LT(wt, RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME));
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#else
Avoid newlines in macro expansions as cc65 doesn't support them between the macro name and the open parenthesis of the arguments. There were btw other even longer lines with expansions of the same macro already present.
2010-03-14 13:13:54 +01:00
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { }
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#endif
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
len = NETSTACK_RADIO.read(ackbuf, ACK_LEN);
if(len == ACK_LEN) {
got_strobe_ack = 1;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
encounter_time = last_transmission_time;
break;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
} else {
Rework of the timing conditions of ContikiMAC: the old timing did not work well on real hardware, the new one seems to work better
2010-03-09 14:19:05 +01:00
PRINTF("contikimac: collisions while sending\n");
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
collisions++;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
last_transmission_time = now;
first_transmission = 0;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
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();
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
} else {
off();
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes,
packetbuf_totlen(),
got_strobe_ack ? "ack" : "no ack",
collisions ? "collision" : "no collision");
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#if CONTIKIMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(&current_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(&current_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(&current_packet);
#endif /* CONTIKIMAC_CONF_COMPOWER */
we_are_sending = 0;
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
/* 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. */
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
if(collisions > 0) {
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
ret = MAC_TX_COLLISION;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
if(!is_broadcast && !got_strobe_ack) {
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
ret = MAC_TX_NOACK;
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
} else {
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
ret = MAC_TX_OK;
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
}
Two major changes: * Low-power streaming. Experimental support for a low-power mode which allows rapid exchange of packets with a 16% duty cycle. Does not seem to function correctly yet though. * Phase locking. When the phase of a neighbor has been detected, the sender assumes that the neighbor will keeps it phase and does not send more strobes than necessary to hit the receiver's channel check - even if the receiver does not acknowledge the reception of the strobes when it should have been awake. Instead, the sender stops strobing and tries again at a later time.
2010-03-14 23:59:23 +01:00
#if WITH_PHASE_OPTIMIZATION
if(!first_transmission) {
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;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
/*---------------------------------------------------------------------------*/
static void
qsend_packet(mac_callback_t sent, void *ptr)
{
Improved handling of neighbor phase estimation: instead of busy-waiting while waiting for neighbor's phase, the new code schedules a timer just before neighbor wakes up
2010-02-28 21:19:47 +01:00
int ret = send_packet(sent, ptr);
Don't call up the netstack if the transmission was deferred
2010-03-09 21:37:02 +01:00
if(ret != MAC_TX_DEFERRED) {
mac_call_sent_callback(sent, ptr, ret, 1);
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
/* We have received the packet, so we can go back to being
asleep. */
off();
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
Replaced old framer (framer_get/framer_set) with new NETSTACK style configuration. Added nullrdc-framer that is a nullrdc with framer support.
2010-03-01 14:30:21 +01:00
if(packetbuf_totlen() > 0 && NETSTACK_FRAMER.parse()) {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
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. */
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
{
struct announcement_msg *hdr = packetbuf_dataptr();
uint8_t magic[2];
memcpy(magic, hdr->announcement_magic, 2);
if(magic[0] == ANNOUNCEMENT_MAGIC1 &&
magic[1] == ANNOUNCEMENT_MAGIC2) {
parse_announcements();
}
}
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#if CONTIKIMAC_CONF_COMPOWER
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(&current_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(&current_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(&current_packet);
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
#endif /* CONTIKIMAC_CONF_COMPOWER */
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
PRINTDEBUG("contikimac: data (%u)\n", packetbuf_datalen());
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
NETSTACK_MAC.input();
return;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
} else {
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
PRINTDEBUG("contikimac: data not for us\n");
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
}
} else {
PRINTF("contikimac: failed to parse (%u)\n", packetbuf_totlen());
}
}
/*---------------------------------------------------------------------------*/
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
static void
send_announcement(void *ptr)
{
int announcement_len;
/* Set up the probe header. */
packetbuf_clear();
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
announcement_len = format_announcement(packetbuf_dataptr());
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
if(announcement_len > 0) {
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
packetbuf_set_datalen(announcement_len);
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null);
packetbuf_set_attr(PACKETBUF_ATTR_RADIO_TXPOWER,
announcement_radio_txpower);
Replaced old framer (framer_get/framer_set) with new NETSTACK style configuration. Added nullrdc-framer that is a nullrdc with framer support.
2010-03-01 14:30:21 +01:00
if(NETSTACK_FRAMER.create()) {
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
rtimer_clock_t t;
int i, collisions;
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
we_are_sending = 1;
Bugfixes in low-power streaming mode, and re-added support for announcements. These now use the low-power streaming mode so that active listening for announcments have a radio duty cycle of 16% rather than 100%
2010-03-16 19:11:13 +01:00
collisions = 0;
/* Check for collisions */
for(i = 0; i < CCA_COUNT_MAX; ++i) {
t = RTIMER_NOW();
on();
#if NURTIMER
while(RTIMER_CLOCK_LT(t, RTIMER_NOW(), t + CCA_CHECK_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t + CCA_CHECK_TIME));
#endif
if(NETSTACK_RADIO.channel_clear() == 0) {
collisions++;
off();
break;
}
off();
#if NURTIMER
while(RTIMER_CLOCK_LT(t0, RTIMER_NOW(), t + CCA_SLEEP_TIME + CCA_CHECK_TIME));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t + CCA_SLEEP_TIME + CCA_CHECK_TIME)) { }
#endif
}
if(collisions == 0) {
NETSTACK_RADIO.prepare(packetbuf_hdrptr(), packetbuf_totlen());
NETSTACK_RADIO.transmit(packetbuf_totlen());
t = RTIMER_NOW();
#if NURTIMER
while(RTIMER_CLOCK_LT(t, RTIMER_NOW(), t + INTER_PACKET_INTERVAL));
#else
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t + INTER_PACKET_INTERVAL)) { }
#endif
NETSTACK_RADIO.transmit(packetbuf_totlen());
}
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
we_are_sending = 0;
}
}
}
/*---------------------------------------------------------------------------*/
static void
cycle_announcement(void *ptr)
{
ctimer_set(&announcement_ctimer, ANNOUNCEMENT_TIME,
send_announcement, NULL);
ctimer_set(&announcement_cycle_ctimer, ANNOUNCEMENT_PERIOD,
cycle_announcement, NULL);
if(is_listening > 0) {
is_listening--;
/* printf("is_listening %d\n", is_listening); */
}
}
/*---------------------------------------------------------------------------*/
static void
listen_callback(int periods)
{
is_listening = periods + 1;
}
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
/*---------------------------------------------------------------------------*/
void
contikimac_set_announcement_radio_txpower(int txpower)
{
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
announcement_radio_txpower = txpower;
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
}
/*---------------------------------------------------------------------------*/
static void
init(void)
{
radio_is_on = 0;
PT_INIT(&pt);
#if NURTIMER
rtimer_setup(&rt, RTIMER_HARD,
(void (*)(struct rtimer *, void *, int status))powercycle,
NULL);
rtimer_schedule(&rt, CYCLE_TIME, 1);
#else
rtimer_set(&rt, RTIMER_NOW() + CYCLE_TIME, 1,
(void (*)(struct rtimer *, void *))powercycle, NULL);
#endif
contikimac_is_on = 1;
#if WITH_PHASE_OPTIMIZATION
phase_init(&phase_list);
#endif /* WITH_PHASE_OPTIMIZATION */
#if CONTIKIMAC_CONF_ANNOUNCEMENTS
announcement_register_listen_callback(listen_callback);
ctimer_set(&announcement_cycle_ctimer, ANNOUNCEMENT_TIME,
cycle_announcement, NULL);
#endif /* CONTIKIMAC_CONF_ANNOUNCEMENTS */
}
/*---------------------------------------------------------------------------*/
static int
turn_on(void)
{
contikimac_is_on = 1;
#if NURTIMER
rtimer_schedule(&rt, CYCLE_TIME, 1);
#else
rtimer_set(&rt, RTIMER_NOW() + CYCLE_TIME, 1,
(void (*)(struct rtimer *, void *))powercycle, NULL);
#endif
return 1;
}
/*---------------------------------------------------------------------------*/
static int
turn_off(int keep_radio_on)
{
contikimac_is_on = 0;
if(keep_radio_on) {
return NETSTACK_RADIO.on();
} else {
return NETSTACK_RADIO.off();
}
}
/*---------------------------------------------------------------------------*/
static unsigned short
duty_cycle(void)
{
return (1ul * CLOCK_SECOND * CYCLE_TIME) / RTIMER_ARCH_SECOND;
}
/*---------------------------------------------------------------------------*/
Changed the network stack to use different structures for the different layers (network_driver, mac_driver, rdc_driver, radio_driver). This helps to avoid incorrect configuration.
2010-02-23 21:09:11 +01:00
const struct rdc_driver contikimac_driver = {
ntikiMAC: a new radio duty cycling mechanism that uses a combination of link-layer and MAC-layer mechanisms to achieve a very low power consumption: during idle listening the radio is switched off between 99.2% and 99.6% of the time. One unicast transmission typically adds between 0.07% and 1.2% additional radio time, depending on packet size. ContikiMAC uses the standard IEEE 802.15.4 message format and adds no additional headers. ContikiMAC is simple: it uses periodic two-shot channel sampling during idle listening to keep the radio on-time down. Transmissions are done with repeated transmissions until a link-layer ACK is received.
2010-02-18 22:26:15 +01:00
"ContikiMAC",
init,
qsend_packet,
input_packet,
turn_on,
turn_off,
duty_cycle,
};
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
/*---------------------------------------------------------------------------*/
uint16_t
contikimac_debug_print(void)
{
Improved detection of link-layer ACKs; increased the time ContikiMAC waits when it has detected a link-layer ACK; increased the number of silence periods required to detect a CCA false positive
2010-02-28 09:33:21 +01:00
return 0;
Rework of parts of the ContikiMAC code based on input from experimental results. When channel check is triggered because of a false positive, the new version checks the radio several times to make sure that there really is an incoming packet. Otherwise, the radio is switched off. Cleaned up and removed old unused code. Added a few temporary debugging mechanisms and functions.
2010-02-23 19:49:05 +01:00
}
/*---------------------------------------------------------------------------*/
Reference in a new issue Copy permalink