/* * Copyright (c) 2010, Swedish Institute of Computer Science. * 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. * * $Id: nullrdc.c,v 1.4 2010/11/23 18:11:00 nifi Exp $ */ /** * \file * A null RDC implementation that uses framer for headers. * \author * Adam Dunkels * Niclas Finne */ #include "net/mac/nullrdc.h" #include "net/packetbuf.h" #include "net/netstack.h" #include #define DEBUG 0 #if DEBUG #include #define PRINTF(...) printf(__VA_ARGS__) #else #define PRINTF(...) #endif #ifdef NULLRDC_CONF_ADDRESS_FILTER #define NULLRDC_ADDRESS_FILTER NULLRDC_CONF_ADDRESS_FILTER #else #define NULLRDC_ADDRESS_FILTER 1 #endif /* NULLRDC_CONF_ADDRESS_FILTER */ #ifndef NULLRDC_802154_AUTOACK #ifdef NULLRDC_CONF_802154_AUTOACK #define NULLRDC_802154_AUTOACK NULLRDC_CONF_802154_AUTOACK #else #define NULLRDC_802154_AUTOACK 0 #endif /* NULLRDC_CONF_802154_AUTOACK */ #endif /* NULLRDC_802154_AUTOACK */ #ifndef NULLRDC_802154_AUTOACK_HW #ifdef NULLRDC_CONF_802154_AUTOACK_HW #define NULLRDC_802154_AUTOACK_HW NULLRDC_CONF_802154_AUTOACK_HW #else #define NULLRDC_802154_AUTOACK_HW 0 #endif /* NULLRDC_CONF_802154_AUTOACK_HW */ #endif /* NULLRDC_802154_AUTOACK_HW */ #if NULLRDC_802154_AUTOACK #include "sys/rtimer.h" #include "dev/watchdog.h" #define ACK_WAIT_TIME RTIMER_SECOND / 2500 #define AFTER_ACK_DETECTED_WAIT_TIME RTIMER_SECOND / 1500 #define ACK_LEN 3 #endif /* NULLRDC_802154_AUTOACK */ #if NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW struct seqno { rimeaddr_t sender; uint8_t seqno; }; #ifdef NETSTACK_CONF_MAC_SEQNO_HISTORY #define MAX_SEQNOS NETSTACK_CONF_MAC_SEQNO_HISTORY #else /* NETSTACK_CONF_MAC_SEQNO_HISTORY */ #define MAX_SEQNOS 16 #endif /* NETSTACK_CONF_MAC_SEQNO_HISTORY */ static struct seqno received_seqnos[MAX_SEQNOS]; #endif /* NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW */ /*---------------------------------------------------------------------------*/ static void send_packet(mac_callback_t sent, void *ptr) { int ret; packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); #if NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1); #endif /* NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW */ if(NETSTACK_FRAMER.create() == 0) { /* Failed to allocate space for headers */ PRINTF("nullrdc: send failed, too large header\n"); ret = MAC_TX_ERR_FATAL; } else { #if NULLRDC_802154_AUTOACK int is_broadcast; uint8_t dsn; dsn = ((uint8_t *)packetbuf_hdrptr())[2] & 0xff; NETSTACK_RADIO.prepare(packetbuf_hdrptr(), packetbuf_totlen()); is_broadcast = rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null); if(NETSTACK_RADIO.receiving_packet() || (!is_broadcast && NETSTACK_RADIO.pending_packet())) { /* Currently receiving a packet over air or the radio has already received a packet that needs to be read before sending with auto ack. */ ret = MAC_TX_COLLISION; } else { switch(NETSTACK_RADIO.transmit(packetbuf_totlen())) { case RADIO_TX_OK: if(is_broadcast) { ret = MAC_TX_OK; } else { rtimer_clock_t wt; /* Check for ack */ wt = RTIMER_NOW(); watchdog_periodic(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + ACK_WAIT_TIME)); ret = MAC_TX_NOACK; if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet() || NETSTACK_RADIO.channel_clear() == 0) { int len; uint8_t ackbuf[ACK_LEN]; wt = RTIMER_NOW(); watchdog_periodic(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTED_WAIT_TIME)); if(NETSTACK_RADIO.pending_packet()) { len = NETSTACK_RADIO.read(ackbuf, ACK_LEN); if(len == ACK_LEN && ackbuf[2] == dsn) { /* Ack received */ ret = MAC_TX_OK; } else { /* Not an ack or ack not for us: collision */ ret = MAC_TX_COLLISION; } } } } break; case RADIO_TX_COLLISION: ret = MAC_TX_COLLISION; break; default: ret = MAC_TX_ERR; break; } } #else /* ! NULLRDC_802154_AUTOACK */ switch(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen())) { case RADIO_TX_OK: ret = MAC_TX_OK; break; case RADIO_TX_COLLISION: ret = MAC_TX_COLLISION; break; case RADIO_TX_NOACK: ret = MAC_TX_NOACK; break; default: ret = MAC_TX_ERR; break; } #endif /* ! NULLRDC_802154_AUTOACK */ } mac_call_sent_callback(sent, ptr, ret, 1); } /*---------------------------------------------------------------------------*/ static void packet_input(void) { #if NULLRDC_802154_AUTOACK if(packetbuf_datalen() == ACK_LEN) { /* Ignore ack packets */ /* PRINTF("nullrdc: ignored ack\n"); */ } else #endif /* NULLRDC_802154_AUTOACK */ if(NETSTACK_FRAMER.parse() == 0) { PRINTF("nullrdc: failed to parse %u\n", packetbuf_datalen()); #if NULLRDC_ADDRESS_FILTER } else if(!rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_node_addr) && !rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) { PRINTF("nullrdc: not for us\n"); #endif /* NULLRDC_ADDRESS_FILTER */ } else { #if NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW /* Check for duplicate packet by comparing the sequence number of the incoming packet with the last few ones we saw. */ int i; for(i = 0; i < MAX_SEQNOS; ++i) { if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno && rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER), &received_seqnos[i].sender)) { /* Drop the packet. */ PRINTF("nullrdc: drop duplicate link layer packet %u\n", packetbuf_attr(PACKETBUF_ATTR_PACKET_ID)); return; } } for(i = MAX_SEQNOS - 1; i > 0; --i) { memcpy(&received_seqnos[i], &received_seqnos[i - 1], sizeof(struct seqno)); } received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID); rimeaddr_copy(&received_seqnos[0].sender, packetbuf_addr(PACKETBUF_ADDR_SENDER)); #endif /* NULLRDC_802154_AUTOACK */ NETSTACK_MAC.input(); } } /*---------------------------------------------------------------------------*/ static int on(void) { return NETSTACK_RADIO.on(); } /*---------------------------------------------------------------------------*/ static int off(int keep_radio_on) { if(keep_radio_on) { return NETSTACK_RADIO.on(); } else { return NETSTACK_RADIO.off(); } } /*---------------------------------------------------------------------------*/ static unsigned short channel_check_interval(void) { return 0; } /*---------------------------------------------------------------------------*/ static void init(void) { on(); } /*---------------------------------------------------------------------------*/ const struct rdc_driver nullrdc_driver = { "nullrdc", init, send_packet, packet_input, on, off, channel_check_interval, }; /*---------------------------------------------------------------------------*/