deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

A work-in-progress rework of the Contiki MAC and radio layers. The

Browse source 
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.
This commit is contained in:
adamdunkels 2010-02-18 21:48:39 +00:00
parent 1817acae15
commit e34eb54960
29 changed files with 1176 additions and 768 deletions
Download patch file Download diff file Expand all files Collapse all files

137
core/net/mac/sicslowmac.c
View file

@ -28,7 +28,7 @@
*
* This file is part of the Contiki operating system.
*
* $Id: sicslowmac.c,v 1.4 2009/09/18 16:37:17 nifi Exp $
* $Id: sicslowmac.c,v 1.5 2010/02/18 21:48:39 adamdunkels Exp $
*/
@ -48,6 +48,7 @@
#include "net/mac/sicslowmac.h"
#include "net/mac/frame802154.h"
#include "net/rime/packetbuf.h"
#include "net/netstack.h"
#include "lib/random.h"
#define DEBUG 0
@ -79,8 +80,6 @@ static uint16_t mac_dst_pan_id = IEEE802154_PANID;
*/
static uint16_t mac_src_pan_id = IEEE802154_PANID;
static const struct radio_driver *radio;
static void (* receiver_callback)(const struct mac_driver *);
/*---------------------------------------------------------------------------*/
static int
is_broadcast_addr(uint8_t mode, uint8_t *addr)
@ -94,8 +93,8 @@ is_broadcast_addr(uint8_t mode, uint8_t *addr)
return 1;
}
/*---------------------------------------------------------------------------*/
static int
send_packet(void)
static void
send_packet(mac_callback_t sent, void *ptr)
{
frame802154_t params;
uint8_t len;
@ -131,11 +130,12 @@ send_packet(void)
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
/* Broadcast requires short address mode. */
params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE;
params.dest_addr.u8[0] = 0xFF;
params.dest_addr.u8[1] = 0xFF;
params.dest_addr[0] = 0xFF;
params.dest_addr[1] = 0xFF;
} else {
rimeaddr_copy(&params.dest_addr, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
rimeaddr_copy((rimeaddr_t *)&params.dest_addr,
packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
params.fcf.dest_addr_mode = FRAME802154_LONGADDRMODE;
}
@ -146,115 +146,104 @@ send_packet(void)
* Set up the source address using only the long address mode for
* phase 1.
*/
rimeaddr_copy(&params.src_addr, &rimeaddr_node_addr);
rimeaddr_copy((rimeaddr_t *)&params.src_addr, &rimeaddr_node_addr);
params.payload = packetbuf_dataptr();
params.payload_len = packetbuf_datalen();
len = frame802154_hdrlen(&params);
if(packetbuf_hdralloc(len)) {
int ret;
frame802154_create(&params, packetbuf_hdrptr(), len);
PRINTF("6MAC-UT: %2X", params.fcf.frame_type);
PRINTADDR(params.dest_addr.u8);
PRINTF("%u %u (%u)\n", len, packetbuf_datalen(), packetbuf_totlen());
return radio->send(packetbuf_hdrptr(), packetbuf_totlen());
ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
if(sent) {
switch(ret) {
case RADIO_TX_OK:
sent(ptr, MAC_TX_OK, 1);
break;
case RADIO_TX_ERR:
sent(ptr, MAC_TX_ERR, 1);
break;
}
}
} else {
PRINTF("6MAC-UT: too large header: %u\n", len);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void
input_packet(const struct radio_driver *d)
{
if(receiver_callback) {
receiver_callback(&sicslowmac_driver);
}
}
/*---------------------------------------------------------------------------*/
static int
read_packet(void)
input_packet(void)
{
frame802154_t frame;
int len;
packetbuf_clear();
len = radio->read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
if(frame802154_parse(packetbuf_dataptr(), len, &frame) &&
packetbuf_hdrreduce(len - frame.payload_len)) {
if(frame.fcf.dest_addr_mode) {
if(frame.dest_pid != mac_src_pan_id &&
frame.dest_pid != FRAME802154_BROADCASTPANDID) {
/* Not broadcast or for our PAN */
PRINTF("6MAC: for another pan %u\n", frame.dest_pid);
return 0;
}
if(!is_broadcast_addr(frame.fcf.dest_addr_mode, frame.dest_addr.u8)) {
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &frame.dest_addr);
if(!rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* Not for this node */
PRINTF("6MAC: not for us\n");
return 0;
}
len = packetbuf_datalen();
if(frame802154_parse(packetbuf_dataptr(), len, &frame) &&
packetbuf_hdrreduce(len - frame.payload_len)) {
if(frame.fcf.dest_addr_mode) {
if(frame.dest_pid != mac_src_pan_id &&
frame.dest_pid != FRAME802154_BROADCASTPANDID) {
/* Not broadcast or for our PAN */
PRINTF("6MAC: for another pan %u\n", frame.dest_pid);
return;
}
if(!is_broadcast_addr(frame.fcf.dest_addr_mode, frame.dest_addr)) {
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, (rimeaddr_t *)&frame.dest_addr);
if(!rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* Not for this node */
PRINTF("6MAC: not for us\n");
return;
}
}
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &frame.src_addr);
PRINTF("6MAC-IN: %2X", frame.fcf.frame_type);
PRINTADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER));
PRINTADDR(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
PRINTF("%u\n", packetbuf_datalen());
return packetbuf_datalen();
} else {
PRINTF("6MAC: failed to parse hdr\n");
}
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, (rimeaddr_t *)&frame.src_addr);
PRINTF("6MAC-IN: %2X", frame.fcf.frame_type);
PRINTADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER));
PRINTADDR(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
PRINTF("%u\n", packetbuf_datalen());
NETSTACK_MAC.input();
} else {
PRINTF("6MAC: failed to parse hdr\n");
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void
set_receive_function(void (* recv)(const struct mac_driver *))
{
receiver_callback = recv;
}
/*---------------------------------------------------------------------------*/
static int
on(void)
{
return radio->on();
return NETSTACK_RADIO.on();
}
/*---------------------------------------------------------------------------*/
static int
off(int keep_radio_on)
{
if(keep_radio_on) {
return radio->on();
return NETSTACK_RADIO.on();
} else {
return radio->off();
return NETSTACK_RADIO.off();
}
}
/*---------------------------------------------------------------------------*/
static void
init(void)
{
mac_dsn = random_rand() % 256;
NETSTACK_RADIO.on();
}
/*---------------------------------------------------------------------------*/
const struct mac_driver sicslowmac_driver = {
"sicslowmac",
sicslowmac_init,
init,
send_packet,
read_packet,
set_receive_function,
input_packet,
on,
off,
};
/*---------------------------------------------------------------------------*/
const struct mac_driver *
sicslowmac_init(const struct radio_driver *d)
{
mac_dsn = random_rand() % 256;
radio = d;
radio->set_receive_function(input_packet);
radio->on();
return &sicslowmac_driver;
}
/*---------------------------------------------------------------------------*/