Moved rudolph{0,1} from apps/ directory into core/net/rime
This commit is contained in:
adamdunkels
parent
e57126ed0e
commit
d9f0c89726
|
|
@ -3,4 +3,5 @@ CONTIKI_SOURCEFILES += rimebuf.c queuebuf.c rimeaddr.c ctimer.c rime.c \
|
|||
uibc.c mh.c \
|
||||
mesh.c route.c route-discovery.c \
|
||||
tree.c neighbor.c \
|
||||
trickle.c
|
||||
trickle.c \
|
||||
rudolph0.c rudolph1.c
|
||||
|
|
|
|||
|
|
@ -0,0 +1,231 @@
|
|||
/*
|
||||
* Copyright (c) 2007, 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: rudolph0.c,v 1.1 2007/03/25 11:56:59 adamdunkels Exp $
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file
|
||||
* Rudolph0: a simple block data flooding protocol
|
||||
* \author
|
||||
* Adam Dunkels <adam@sics.se>
|
||||
*/
|
||||
|
||||
#include "net/rime.h"
|
||||
#include "rudolph0.h"
|
||||
|
||||
#include <stddef.h> /* for offsetof */
|
||||
|
||||
#define SENDING_TIME CLOCK_SECOND / 2
|
||||
#define STEADY_TIME CLOCK_SECOND * 2
|
||||
|
||||
enum {
|
||||
TYPE_DATA,
|
||||
TYPE_NACK,
|
||||
};
|
||||
|
||||
enum {
|
||||
STATE_RECEIVER,
|
||||
STATE_SENDER,
|
||||
};
|
||||
|
||||
#define VERSION_LT(a, b) ((signed char)((a) - (b)) < 0)
|
||||
|
||||
#define DEBUG 0
|
||||
#if DEBUG
|
||||
#include <stdio.h>
|
||||
#define PRINTF(...) printf(__VA_ARGS__)
|
||||
#else
|
||||
#define PRINTF(...)
|
||||
#endif
|
||||
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
read_new_datapacket(struct rudolph0_conn *c)
|
||||
{
|
||||
int len = 0;
|
||||
|
||||
if(c->cb->read_chunk) {
|
||||
len = c->cb->read_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE,
|
||||
c->current.data, RUDOLPH0_DATASIZE);
|
||||
}
|
||||
c->current.datalen = len;
|
||||
|
||||
PRINTF("read_new_datapacket len %d\n", len);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
send_nack(struct rudolph0_conn *c)
|
||||
{
|
||||
struct rudolph0_hdr *hdr;
|
||||
rimebuf_clear();
|
||||
rimebuf_hdralloc(sizeof(struct rudolph0_hdr));
|
||||
hdr = rimebuf_hdrptr();
|
||||
|
||||
hdr->type = TYPE_NACK;
|
||||
hdr->version = c->current.h.version;
|
||||
hdr->chunk = c->current.h.chunk;
|
||||
|
||||
PRINTF("Sending nack for %d:%d\n", hdr->version, hdr->chunk);
|
||||
uabc_send(&c->nackc, CLOCK_SECOND / 4);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
sent(struct sabc_conn *sabc)
|
||||
{
|
||||
struct rudolph0_conn *c = (struct rudolph0_conn *)sabc;
|
||||
|
||||
if(c->current.datalen == RUDOLPH0_DATASIZE) {
|
||||
c->current.h.chunk++;
|
||||
PRINTF("Sending data chunk %d next time\n", c->current.h.chunk);
|
||||
read_new_datapacket(c);
|
||||
} else {
|
||||
sabc_set_timer(&c->c, STEADY_TIME);
|
||||
PRINTF("Steady: Sending the same data chunk next time datalen %d, %d\n",
|
||||
c->current.datalen, RUDOLPH0_DATASIZE);
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
recv(struct sabc_conn *sabc)
|
||||
{
|
||||
struct rudolph0_conn *c = (struct rudolph0_conn *)sabc;
|
||||
struct rudolph0_datapacket *p = rimebuf_dataptr();
|
||||
|
||||
/* if(rand() & 1) {
|
||||
return;
|
||||
}*/
|
||||
|
||||
if(p->h.type == TYPE_DATA) {
|
||||
if(c->current.h.version != p->h.version) {
|
||||
PRINTF("rudolph0 new version %d\n", p->h.version);
|
||||
c->current.h.version = p->h.version;
|
||||
c->current.h.chunk = 0;
|
||||
c->cb->write_chunk(c, 0, RUDOLPH0_FLAG_NEWFILE, p->data, 0);
|
||||
if(p->h.chunk != 0) {
|
||||
send_nack(c);
|
||||
} else {
|
||||
c->cb->write_chunk(c, 0, RUDOLPH0_FLAG_NONE, p->data, p->datalen);
|
||||
c->current.h.chunk++;
|
||||
}
|
||||
} else if(p->h.version == c->current.h.version) {
|
||||
if(p->h.chunk == c->current.h.chunk) {
|
||||
PRINTF("received chunk %d\n", p->h.chunk);
|
||||
if(p->datalen < RUDOLPH0_DATASIZE) {
|
||||
c->cb->write_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE,
|
||||
RUDOLPH0_FLAG_LASTCHUNK, p->data, p->datalen);
|
||||
} else {
|
||||
c->cb->write_chunk(c, c->current.h.chunk * RUDOLPH0_DATASIZE,
|
||||
RUDOLPH0_FLAG_NONE, p->data, p->datalen);
|
||||
}
|
||||
c->current.h.chunk++;
|
||||
|
||||
} else if(p->h.chunk > c->current.h.chunk) {
|
||||
PRINTF("received chunk %d > %d, sending NACK\n", p->h.chunk, c->current.h.chunk);
|
||||
send_nack(c);
|
||||
}
|
||||
} else { /* p->h.version < c->current.h.version */
|
||||
/* Ignore packets with old version */
|
||||
}
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
recv_nack(struct uabc_conn *uabc)
|
||||
{
|
||||
struct rudolph0_conn *c = (struct rudolph0_conn *)
|
||||
((char *)uabc - offsetof(struct rudolph0_conn,
|
||||
nackc));
|
||||
struct rudolph0_datapacket *p = rimebuf_dataptr();
|
||||
|
||||
if(p->h.type == TYPE_NACK && c->state == STATE_SENDER) {
|
||||
if(p->h.version == c->current.h.version) {
|
||||
PRINTF("Reseting chunk to %d\n", p->h.chunk);
|
||||
c->current.h.chunk = p->h.chunk;
|
||||
} else {
|
||||
PRINTF("Wrong version, reseting chunk to 0\n");
|
||||
c->current.h.chunk = 0;
|
||||
}
|
||||
read_new_datapacket(c);
|
||||
sabc_set_timer(&c->c, SENDING_TIME);
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static const struct uabc_callbacks uabc = { recv_nack, NULL, NULL };
|
||||
static const struct sabc_callbacks sabc = { recv, sent };
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph0_open(struct rudolph0_conn *c, u16_t channel,
|
||||
const struct rudolph0_callbacks *cb)
|
||||
{
|
||||
sabc_open(&c->c, channel, &sabc);
|
||||
uabc_open(&c->nackc, channel + 1, &uabc);
|
||||
c->cb = cb;
|
||||
c->current.h.version = 0;
|
||||
c->state = STATE_RECEIVER;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph0_close(struct rudolph0_conn *c)
|
||||
{
|
||||
sabc_close(&c->c);
|
||||
uabc_close(&c->nackc);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph0_send(struct rudolph0_conn *c)
|
||||
{
|
||||
c->state = STATE_SENDER;
|
||||
c->current.h.version++;
|
||||
c->current.h.chunk = 0;
|
||||
c->current.h.type = TYPE_DATA;
|
||||
read_new_datapacket(c);
|
||||
rimebuf_reference(&c->current, sizeof(struct rudolph0_datapacket));
|
||||
sabc_send_stubborn(&c->c, SENDING_TIME);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph0_stop(struct rudolph0_conn *c)
|
||||
{
|
||||
sabc_cancel(&c->c);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
int
|
||||
rudolph0_version(struct rudolph0_conn *c)
|
||||
{
|
||||
return c->current.h.version;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph0_set_version(struct rudolph0_conn *c, int version)
|
||||
{
|
||||
c->current.h.version = version;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
/*
|
||||
* Copyright (c) 2007, 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: rudolph0.h,v 1.1 2007/03/25 11:56:59 adamdunkels Exp $
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file
|
||||
* A brief description of what this file is.
|
||||
* \author
|
||||
* Adam Dunkels <adam@sics.se>
|
||||
*/
|
||||
|
||||
#ifndef __RUDOLPH0_H__
|
||||
#define __RUDOLPH0_H__
|
||||
|
||||
#include "net/rime.h"
|
||||
#include "net/rime/sabc.h"
|
||||
#include "net/rime/uabc.h"
|
||||
#include "contiki-net.h"
|
||||
|
||||
struct rudolph0_conn;
|
||||
|
||||
enum {
|
||||
RUDOLPH0_FLAG_NONE,
|
||||
RUDOLPH0_FLAG_NEWFILE,
|
||||
RUDOLPH0_FLAG_LASTCHUNK,
|
||||
};
|
||||
|
||||
struct rudolph0_callbacks {
|
||||
void (* write_chunk)(struct rudolph0_conn *c, int offset, int flag,
|
||||
char *data, int len);
|
||||
int (* read_chunk)(struct rudolph0_conn *c, int offset, char *to,
|
||||
int maxsize);
|
||||
};
|
||||
|
||||
#define RUDOLPH0_DATASIZE 64
|
||||
|
||||
struct rudolph0_hdr {
|
||||
u8_t type;
|
||||
u8_t version;
|
||||
u16_t chunk;
|
||||
};
|
||||
|
||||
struct rudolph0_datapacket {
|
||||
struct rudolph0_hdr h;
|
||||
u8_t datalen;
|
||||
u8_t data[RUDOLPH0_DATASIZE];
|
||||
};
|
||||
|
||||
struct rudolph0_conn {
|
||||
struct sabc_conn c;
|
||||
struct uabc_conn nackc;
|
||||
const struct rudolph0_callbacks *cb;
|
||||
u8_t state;
|
||||
struct rudolph0_datapacket current;
|
||||
};
|
||||
|
||||
void rudolph0_open(struct rudolph0_conn *c, u16_t channel,
|
||||
const struct rudolph0_callbacks *cb);
|
||||
void rudolph0_close(struct rudolph0_conn *c);
|
||||
void rudolph0_send(struct rudolph0_conn *c);
|
||||
void rudolph0_stop(struct rudolph0_conn *c);
|
||||
|
||||
void rudolph0_set_version(struct rudolph0_conn *c, int version);
|
||||
int rudolph0_version(struct rudolph0_conn *c);
|
||||
|
||||
#endif /* __RUDOLPH0_H__ */
|
||||
|
|
@ -0,0 +1,292 @@
|
|||
/*
|
||||
* Copyright (c) 2007, 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: rudolph1.c,v 1.1 2007/03/25 11:58:09 adamdunkels Exp $
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file
|
||||
* Rudolph1: a simple block data flooding protocol
|
||||
* \author
|
||||
* Adam Dunkels <adam@sics.se>
|
||||
*/
|
||||
|
||||
#include "net/rime.h"
|
||||
#include "net/rime/rudolph1.h"
|
||||
#include "cfs/cfs.h"
|
||||
|
||||
#include <stddef.h> /* for offsetof */
|
||||
|
||||
#define DATA_INTERVAL CLOCK_SECOND * 2
|
||||
#define TRICKLE_INTERVAL TRICKLE_SECOND
|
||||
#define NACK_TIMEOUT CLOCK_SECOND
|
||||
|
||||
struct rudolph1_hdr {
|
||||
u8_t type;
|
||||
u8_t version;
|
||||
u16_t chunk;
|
||||
};
|
||||
|
||||
#define RUDOLPH1_DATASIZE 32
|
||||
|
||||
struct rudolph1_datapacket {
|
||||
struct rudolph1_hdr h;
|
||||
u8_t datalen;
|
||||
u8_t data[RUDOLPH1_DATASIZE];
|
||||
};
|
||||
|
||||
enum {
|
||||
TYPE_DATA,
|
||||
TYPE_NACK,
|
||||
};
|
||||
|
||||
#define DEBUG 0
|
||||
#if DEBUG
|
||||
#include <stdio.h>
|
||||
#define PRINTF(...) printf(__VA_ARGS__)
|
||||
#else
|
||||
#define PRINTF(...)
|
||||
#endif
|
||||
|
||||
#define LT(a, b) ((signed char)((a) - (b)) < 0)
|
||||
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static int
|
||||
read_data(struct rudolph1_conn *c, char *dataptr, int chunk)
|
||||
{
|
||||
int len = 0;
|
||||
|
||||
if(c->cb->read_chunk) {
|
||||
len = c->cb->read_chunk(c, chunk * RUDOLPH1_DATASIZE,
|
||||
dataptr, RUDOLPH1_DATASIZE);
|
||||
}
|
||||
|
||||
/* cfs_seek(c->cfs_fd, chunk * RUDOLPH1_DATASIZE);
|
||||
len = cfs_read(c->cfs_fd, dataptr, RUDOLPH1_DATASIZE);*/
|
||||
return len;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static int
|
||||
format_data(struct rudolph1_conn *c, int chunk)
|
||||
{
|
||||
struct rudolph1_datapacket *p;
|
||||
|
||||
rimebuf_clear();
|
||||
p = rimebuf_dataptr();
|
||||
p->h.type = TYPE_DATA;
|
||||
p->h.version = c->version;
|
||||
p->h.chunk = chunk;
|
||||
p->datalen = read_data(c, p->data, chunk);
|
||||
rimebuf_set_datalen(sizeof(struct rudolph1_datapacket) -
|
||||
(RUDOLPH1_DATASIZE - p->datalen));
|
||||
|
||||
return p->datalen;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
write_data(struct rudolph1_conn *c, int chunk, u8_t *data, int datalen)
|
||||
{
|
||||
if(chunk == 0) {
|
||||
c->cb->write_chunk(c, 0, RUDOLPH1_FLAG_NEWFILE, data, 0);
|
||||
}
|
||||
|
||||
|
||||
/* cfs_seek(c->cfs_fd, chunk * RUDOLPH1_DATASIZE);
|
||||
cfs_write(c->cfs_fd, data, datalen);*/
|
||||
if(datalen < RUDOLPH1_DATASIZE) {
|
||||
PRINTF("%d: get %d bytes, file complete\n",
|
||||
rimeaddr_node_addr.u16, datalen);
|
||||
/* c->cb->received_file(c, c->cfs_fd);*/
|
||||
c->cb->write_chunk(c, chunk * RUDOLPH1_DATASIZE,
|
||||
RUDOLPH1_FLAG_LASTCHUNK, data, datalen);
|
||||
} else {
|
||||
c->cb->write_chunk(c, chunk * RUDOLPH1_DATASIZE,
|
||||
RUDOLPH1_FLAG_NONE, data, datalen);
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
send_nack(struct rudolph1_conn *c)
|
||||
{
|
||||
struct rudolph1_hdr *hdr;
|
||||
rimebuf_clear();
|
||||
rimebuf_hdralloc(sizeof(struct rudolph1_hdr));
|
||||
hdr = rimebuf_hdrptr();
|
||||
|
||||
hdr->type = TYPE_NACK;
|
||||
hdr->version = c->version;
|
||||
hdr->chunk = c->chunk;
|
||||
|
||||
PRINTF("Sending nack for %d:%d\n", hdr->version, hdr->chunk);
|
||||
uabc_send(&c->uabc, CLOCK_SECOND / 4);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
handle_data(struct rudolph1_conn *c, struct rudolph1_datapacket *p)
|
||||
{
|
||||
if(LT(c->version, p->h.version)) {
|
||||
PRINTF("rudolph1 new version %d\n", p->h.version);
|
||||
/* c->cfs_fd = c->cb->new_file(c);*/
|
||||
c->version = p->h.version;
|
||||
c->chunk = 1; /* Next chunk is 1. */
|
||||
/* if(c->cfs_fd != -1) {*/
|
||||
if(p->h.chunk != 0) {
|
||||
send_nack(c);
|
||||
} else {
|
||||
write_data(c, 0, p->data, p->datalen);
|
||||
}
|
||||
/* }*/
|
||||
} else if(p->h.version == c->version) {
|
||||
/* if(c->cfs_fd != -1) {*/
|
||||
if(p->h.chunk == c->chunk) {
|
||||
PRINTF("%d: received chunk %d\n",
|
||||
rimeaddr_node_addr.u16, p->h.chunk);
|
||||
write_data(c, p->h.chunk, p->data, p->datalen);
|
||||
c->chunk++;
|
||||
/* cfs_seek(c->cfs_fd, c->chunk * RUDOLPH1_DATASIZE);
|
||||
cfs_write(c->cfs_fd, p->data, p->datalen);
|
||||
c->chunk++;
|
||||
if(p->datalen < RUDOLPH1_DATASIZE) {
|
||||
c->cb->received_file(c, c->cfs_fd);
|
||||
}*/
|
||||
} else if(p->h.chunk > c->chunk) {
|
||||
PRINTF("%d: received chunk %d > %d, sending NACK\n",
|
||||
rimeaddr_node_addr.u16,
|
||||
p->h.chunk, c->chunk);
|
||||
send_nack(c);
|
||||
}
|
||||
/* } */
|
||||
} else { /* p->h.version < c->current.h.version */
|
||||
/* Ignore packets with old version */
|
||||
}
|
||||
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
recv_trickle(struct trickle_conn *trickle)
|
||||
{
|
||||
struct rudolph1_conn *c = (struct rudolph1_conn *)trickle;
|
||||
struct rudolph1_datapacket *p = rimebuf_dataptr();
|
||||
|
||||
/* if(rand() & 1) {
|
||||
return;
|
||||
}*/
|
||||
|
||||
if(p->h.type == TYPE_DATA) {
|
||||
handle_data(c, p);
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
recv_uabc(struct uabc_conn *uabc)
|
||||
{
|
||||
struct rudolph1_conn *c = (struct rudolph1_conn *)
|
||||
((char *)uabc - offsetof(struct rudolph1_conn, uabc));
|
||||
struct rudolph1_datapacket *p = rimebuf_dataptr();
|
||||
|
||||
/* if(rand() & 1) {
|
||||
return;
|
||||
}*/
|
||||
|
||||
c->nacks++;
|
||||
|
||||
if(p->h.type == TYPE_NACK) {
|
||||
if(p->h.version == c->version) {
|
||||
if(p->h.chunk < c->chunk) {
|
||||
format_data(c, p->h.chunk);
|
||||
uabc_send(&c->uabc, NACK_TIMEOUT);
|
||||
}
|
||||
} else if(LT(p->h.version, c->version)) {
|
||||
format_data(c, 0);
|
||||
uabc_send(&c->uabc, NACK_TIMEOUT);
|
||||
}
|
||||
} else if(p->h.type == TYPE_DATA) {
|
||||
handle_data(c, p);
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
send_next_packet(void *ptr)
|
||||
{
|
||||
struct rudolph1_conn *c = ptr;
|
||||
int len;
|
||||
if(c->nacks == 0) {
|
||||
c->chunk++;
|
||||
len = format_data(c, c->chunk);
|
||||
trickle_send(&c->trickle, c->trickle_interval);
|
||||
if(len == RUDOLPH1_DATASIZE) {
|
||||
ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c);
|
||||
}
|
||||
} else {
|
||||
ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c);
|
||||
}
|
||||
c->nacks = 0;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
static const struct uabc_callbacks uabc = { recv_uabc, NULL, NULL };
|
||||
static const struct trickle_callbacks trickle = { recv_trickle };
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph1_open(struct rudolph1_conn *c, u16_t channel,
|
||||
const struct rudolph1_callbacks *cb)
|
||||
{
|
||||
trickle_open(&c->trickle, channel, &trickle);
|
||||
uabc_open(&c->uabc, channel + 1, &uabc);
|
||||
c->cb = cb;
|
||||
c->version = 0;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph1_close(struct rudolph1_conn *c)
|
||||
{
|
||||
trickle_close(&c->trickle);
|
||||
uabc_close(&c->uabc);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph1_send(struct rudolph1_conn *c)
|
||||
{
|
||||
/* c->cfs_fd = cfs_fd;*/
|
||||
c->version++;
|
||||
c->chunk = 0;
|
||||
c->trickle_interval = TRICKLE_INTERVAL;
|
||||
format_data(c, 0);
|
||||
trickle_send(&c->trickle, c->trickle_interval);
|
||||
ctimer_set(&c->t, DATA_INTERVAL, send_next_packet, c);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
void
|
||||
rudolph1_stop(struct rudolph1_conn *c)
|
||||
{
|
||||
/* XXX */
|
||||
ctimer_stop(&c->t);
|
||||
printf("rudolph1_stop: not implemented\n");
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
/*
|
||||
* Copyright (c) 2007, 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: rudolph1.h,v 1.1 2007/03/25 11:58:09 adamdunkels Exp $
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file
|
||||
* A brief description of what this file is.
|
||||
* \author
|
||||
* Adam Dunkels <adam@sics.se>
|
||||
*/
|
||||
|
||||
#ifndef __RUDOLPH1_H__
|
||||
#define __RUDOLPH1_H__
|
||||
|
||||
#include "net/rime.h"
|
||||
#include "net/rime/trickle.h"
|
||||
#include "net/rime/uabc.h"
|
||||
#include "contiki-net.h"
|
||||
|
||||
struct rudolph1_conn;
|
||||
|
||||
enum {
|
||||
RUDOLPH1_FLAG_NONE,
|
||||
RUDOLPH1_FLAG_NEWFILE,
|
||||
RUDOLPH1_FLAG_LASTCHUNK,
|
||||
};
|
||||
|
||||
struct rudolph1_callbacks {
|
||||
void (* write_chunk)(struct rudolph1_conn *c, int offset, int flag,
|
||||
char *data, int len);
|
||||
int (* read_chunk)(struct rudolph1_conn *c, int offset, char *to,
|
||||
int maxsize);
|
||||
};
|
||||
|
||||
struct rudolph1_conn {
|
||||
struct trickle_conn trickle;
|
||||
struct uabc_conn uabc;
|
||||
const struct rudolph1_callbacks *cb;
|
||||
struct ctimer t;
|
||||
u16_t chunk;
|
||||
u8_t version;
|
||||
u8_t trickle_interval;
|
||||
u8_t nacks;
|
||||
};
|
||||
|
||||
void rudolph1_open(struct rudolph1_conn *c, u16_t channel,
|
||||
const struct rudolph1_callbacks *cb);
|
||||
void rudolph1_close(struct rudolph1_conn *c);
|
||||
void rudolph1_send(struct rudolph1_conn *c);
|
||||
void rudolph1_stop(struct rudolph1_conn *c);
|
||||
|
||||
#endif /* __RUDOLPH1_H__ */
|
||||
Loading…
Reference in New Issue