Cleanup trailing spaces and convert tabs to spaces
This commit removes trailing spaces and converts tabs to spaces in all files affected by fix-doxygen PR.
This commit is contained in:
Tommy Sparber
parent
9bb3a3a235
commit
938a425949
|
|
@ -1,19 +1,19 @@
|
|||
/*
|
||||
* Copyright (c) 2003, Adam Dunkels.
|
||||
* All rights reserved.
|
||||
* 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.
|
||||
* 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.
|
||||
* with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote
|
||||
* products derived from this software without specific prior
|
||||
* written permission.
|
||||
* written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
||||
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
* 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.
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* This file is part of the Contiki desktop OS
|
||||
*
|
||||
|
|
@ -35,7 +35,7 @@
|
|||
/**
|
||||
* \file
|
||||
* The program handler, used for loading programs and starting the
|
||||
* screensaver.
|
||||
* screensaver.
|
||||
* \author Adam Dunkels <adam@dunkels.com>
|
||||
*
|
||||
* The Contiki program handler is responsible for the Contiki menu and
|
||||
|
|
@ -45,7 +45,7 @@
|
|||
* The program handler also is responsible for starting the
|
||||
* screensaver when the CTK detects that it should be started.
|
||||
*/
|
||||
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ char program_handler_screensaver[20];
|
|||
/*-----------------------------------------------------------------------------------*/
|
||||
void
|
||||
program_handler_add(struct dsc *dsc, char *menuname,
|
||||
unsigned char desktop)
|
||||
unsigned char desktop)
|
||||
{
|
||||
contikidsc[contikidsclast++] = dsc;
|
||||
ctk_menuitem_add(&contikimenu, menuname);
|
||||
|
|
@ -228,7 +228,7 @@ program_handler_load(char *name, char *arg)
|
|||
{
|
||||
#ifdef WITH_LOADER_ARCH
|
||||
struct pnarg *pnarg;
|
||||
|
||||
|
||||
pnarg = pnarg_copy(name, arg);
|
||||
if(pnarg != NULL) {
|
||||
process_post(&program_handler_process, LOADER_EVENT_DISPLAY_NAME, pnarg);
|
||||
|
|
@ -272,17 +272,17 @@ static void
|
|||
make_windows(void)
|
||||
{
|
||||
ctk_window_new(&runwindow, 16, 3, "Run");
|
||||
|
||||
|
||||
CTK_WIDGET_ADD(&runwindow, &namelabel);
|
||||
CTK_WIDGET_ADD(&runwindow, &nameentry);
|
||||
CTK_WIDGET_ADD(&runwindow, &loadbutton);
|
||||
|
||||
|
||||
CTK_WIDGET_FOCUS(&runwindow, &nameentry);
|
||||
|
||||
|
||||
ctk_dialog_new(&loadingdialog, 25, 1);
|
||||
CTK_WIDGET_ADD(&loadingdialog, &loadingmsg);
|
||||
CTK_WIDGET_ADD(&loadingdialog, &loadingname);
|
||||
|
||||
|
||||
ctk_dialog_new(&errordialog, 22, 8);
|
||||
CTK_WIDGET_ADD(&errordialog, &errormsg);
|
||||
CTK_WIDGET_ADD(&errordialog, &errorfilelabel);
|
||||
|
|
@ -302,20 +302,20 @@ PROCESS_THREAD(program_handler_process, ev, data)
|
|||
struct dsc **dscp;
|
||||
|
||||
PROCESS_BEGIN();
|
||||
|
||||
|
||||
/* Create the menus */
|
||||
ctk_menu_add(&contikimenu);
|
||||
#if WITH_LOADER_ARCH
|
||||
runmenuitem = ctk_menuitem_add(&contikimenu, "Run program...");
|
||||
|
||||
|
||||
make_windows();
|
||||
#endif /* WITH_LOADER_ARCH */
|
||||
#if QUIT_MENU
|
||||
quitmenuitem = ctk_menuitem_add(&contikimenu, "Quit");
|
||||
#endif /* QUIT_MENU */
|
||||
|
||||
|
||||
displayname = NULL;
|
||||
|
||||
|
||||
#if CTK_CONF_SCREENSAVER
|
||||
program_handler_screensaver[0] = 0;
|
||||
#endif /* CTK_CONF_SCREENSAVER */
|
||||
|
|
@ -325,106 +325,106 @@ PROCESS_THREAD(program_handler_process, ev, data)
|
|||
if(ev == ctk_signal_button_activate) {
|
||||
#ifdef WITH_LOADER_ARCH
|
||||
if(data == (process_data_t)&loadbutton) {
|
||||
ctk_window_close(&runwindow);
|
||||
program_handler_load(name, NULL);
|
||||
ctk_window_close(&runwindow);
|
||||
program_handler_load(name, NULL);
|
||||
} else if(data == (process_data_t)&errorokbutton) {
|
||||
ctk_dialog_close();
|
||||
ctk_dialog_close();
|
||||
}
|
||||
#endif /* WITH_LOADER_ARCH */
|
||||
#if QUIT_MENU
|
||||
if(data == (process_data_t)&quityesbutton) {
|
||||
ctk_draw_init();
|
||||
exit(EXIT_SUCCESS);
|
||||
ctk_draw_init();
|
||||
exit(EXIT_SUCCESS);
|
||||
} else if(data == (process_data_t)&quitnobutton) {
|
||||
ctk_dialog_close();
|
||||
ctk_dialog_close();
|
||||
}
|
||||
#endif /* QUIT_MENU */
|
||||
dscp = &contikidsc[0];
|
||||
for(i = 0; i < CTK_MAXMENUITEMS; ++i) {
|
||||
if(*dscp != NULL
|
||||
for(i = 0; i < CTK_MAXMENUITEMS; ++i) {
|
||||
if(*dscp != NULL
|
||||
#if CTK_CONF_ICONS
|
||||
&& data == (process_data_t)(*dscp)->icon
|
||||
&& data == (process_data_t)(*dscp)->icon
|
||||
#endif /* CTK_CONF_ICONS */
|
||||
) {
|
||||
RUN((*dscp)->prgname, (*dscp)->process, NULL);
|
||||
break;
|
||||
}
|
||||
++dscp;
|
||||
) {
|
||||
RUN((*dscp)->prgname, (*dscp)->process, NULL);
|
||||
break;
|
||||
}
|
||||
++dscp;
|
||||
}
|
||||
} else if(ev == ctk_signal_menu_activate) {
|
||||
if((struct ctk_menu *)data == &contikimenu) {
|
||||
#if WITH_LOADER_ARCH
|
||||
dsc = contikidsc[contikimenu.active];
|
||||
if(dsc != NULL) {
|
||||
RUN(dsc->prgname, dsc->process, NULL);
|
||||
} else if(contikimenu.active == runmenuitem) {
|
||||
make_windows();
|
||||
ctk_window_close(&runwindow);
|
||||
ctk_window_open(&runwindow);
|
||||
CTK_WIDGET_FOCUS(&runwindow, &nameentry);
|
||||
}
|
||||
dsc = contikidsc[contikimenu.active];
|
||||
if(dsc != NULL) {
|
||||
RUN(dsc->prgname, dsc->process, NULL);
|
||||
} else if(contikimenu.active == runmenuitem) {
|
||||
make_windows();
|
||||
ctk_window_close(&runwindow);
|
||||
ctk_window_open(&runwindow);
|
||||
CTK_WIDGET_FOCUS(&runwindow, &nameentry);
|
||||
}
|
||||
#else /* WITH_LOADER_ARCH */
|
||||
if(contikidsc[contikimenu.active] != NULL) {
|
||||
RUN(contikidsc[contikimenu.active]->prgname,
|
||||
contikidsc[contikimenu.active]->process,
|
||||
NULL);
|
||||
}
|
||||
if(contikidsc[contikimenu.active] != NULL) {
|
||||
RUN(contikidsc[contikimenu.active]->prgname,
|
||||
contikidsc[contikimenu.active]->process,
|
||||
NULL);
|
||||
}
|
||||
#endif /* WITH_LOADER_ARCH */
|
||||
#if QUIT_MENU
|
||||
if(contikimenu.active == quitmenuitem) {
|
||||
ctk_dialog_new(&quitdialog, 24, 5);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quitdialoglabel);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quityesbutton);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quitnobutton);
|
||||
CTK_WIDGET_FOCUS(&quitdialog, &quitnobutton);
|
||||
ctk_dialog_open(&quitdialog);
|
||||
}
|
||||
if(contikimenu.active == quitmenuitem) {
|
||||
ctk_dialog_new(&quitdialog, 24, 5);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quitdialoglabel);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quityesbutton);
|
||||
CTK_WIDGET_ADD(&quitdialog, &quitnobutton);
|
||||
CTK_WIDGET_FOCUS(&quitdialog, &quitnobutton);
|
||||
ctk_dialog_open(&quitdialog);
|
||||
}
|
||||
#endif /* QUIT_MENU */
|
||||
}
|
||||
#if CTK_CONF_SCREENSAVER
|
||||
} else if(ev == ctk_signal_screensaver_start) {
|
||||
#if WITH_LOADER_ARCH
|
||||
if(program_handler_screensaver[0] != 0) {
|
||||
program_handler_load(program_handler_screensaver, NULL);
|
||||
program_handler_load(program_handler_screensaver, NULL);
|
||||
}
|
||||
#endif /* WITH_LOADER_ARCH */
|
||||
#endif /* CTK_CONF_SCREENSAVER */
|
||||
} else if(ev == LOADER_EVENT_DISPLAY_NAME) {
|
||||
#if WITH_LOADER_ARCH
|
||||
if(displayname == NULL) {
|
||||
make_windows();
|
||||
|
||||
ctk_label_set_text(&loadingname, ((struct pnarg *)data)->name);
|
||||
ctk_dialog_open(&loadingdialog);
|
||||
process_post(&program_handler_process, LOADER_EVENT_LOAD, data);
|
||||
displayname = data;
|
||||
make_windows();
|
||||
|
||||
ctk_label_set_text(&loadingname, ((struct pnarg *)data)->name);
|
||||
ctk_dialog_open(&loadingdialog);
|
||||
process_post(&program_handler_process, LOADER_EVENT_LOAD, data);
|
||||
displayname = data;
|
||||
} else {
|
||||
/* Try again. */
|
||||
process_post(&program_handler_process, LOADER_EVENT_DISPLAY_NAME, data);
|
||||
/* Try again. */
|
||||
process_post(&program_handler_process, LOADER_EVENT_DISPLAY_NAME, data);
|
||||
}
|
||||
#endif /* WITH_LOADER_ARCH */
|
||||
} else if(ev == LOADER_EVENT_LOAD) {
|
||||
#if WITH_LOADER_ARCH
|
||||
if(displayname == data) {
|
||||
ctk_dialog_close();
|
||||
displayname = NULL;
|
||||
log_message("Loading ", ((struct pnarg *)data)->name);
|
||||
err = LOADER_LOAD(((struct pnarg *)data)->name,
|
||||
((struct pnarg *)data)->arg);
|
||||
if(err != LOADER_OK) {
|
||||
make_windows();
|
||||
errorfilename[0] = '"';
|
||||
strncpy(errorfilename + 1, ((struct pnarg *)data)->name,
|
||||
sizeof(errorfilename) - 2);
|
||||
errorfilename[1 + strlen(((struct pnarg *)data)->name)] = '"';
|
||||
ctk_label_set_text(&errortype, (char *)errormsgs[err]);
|
||||
ctk_dialog_open(&errordialog);
|
||||
log_message((char *)errormsgs[err], errorfilename);
|
||||
}
|
||||
pnarg_free(data);
|
||||
ctk_dialog_close();
|
||||
displayname = NULL;
|
||||
log_message("Loading ", ((struct pnarg *)data)->name);
|
||||
err = LOADER_LOAD(((struct pnarg *)data)->name,
|
||||
((struct pnarg *)data)->arg);
|
||||
if(err != LOADER_OK) {
|
||||
make_windows();
|
||||
errorfilename[0] = '"';
|
||||
strncpy(errorfilename + 1, ((struct pnarg *)data)->name,
|
||||
sizeof(errorfilename) - 2);
|
||||
errorfilename[1 + strlen(((struct pnarg *)data)->name)] = '"';
|
||||
ctk_label_set_text(&errortype, (char *)errormsgs[err]);
|
||||
ctk_dialog_open(&errordialog);
|
||||
log_message((char *)errormsgs[err], errorfilename);
|
||||
}
|
||||
pnarg_free(data);
|
||||
} else {
|
||||
/* Try again. */
|
||||
process_post(&program_handler_process, LOADER_EVENT_DISPLAY_NAME, data);
|
||||
/* Try again. */
|
||||
process_post(&program_handler_process, LOADER_EVENT_DISPLAY_NAME, data);
|
||||
}
|
||||
#endif /* WITH_LOADEER_ARCH */
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,17 +64,11 @@
|
|||
#define UIP_TCPH_LEN 20 /* Size of TCP header */
|
||||
#define UIP_ICMPH_LEN 4 /* Size of ICMP header */
|
||||
|
||||
#define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN) /* Size of IP +
|
||||
* UDP
|
||||
* header */
|
||||
#define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN) /* Size of IP +
|
||||
* TCP
|
||||
* header */
|
||||
#define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN) /* Size of IP + UDP header */
|
||||
#define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN) /* Size of IP + TCP header */
|
||||
#define UIP_TCPIP_HLEN UIP_IPTCPH_LEN
|
||||
#define UIP_IPICMPH_LEN (UIP_IPH_LEN + UIP_ICMPH_LEN) /* size of ICMP
|
||||
+ IP header */
|
||||
#define UIP_LLIPH_LEN (UIP_LLH_LEN + UIP_IPH_LEN) /* size of L2
|
||||
+ IP header */
|
||||
#define UIP_IPICMPH_LEN (UIP_IPH_LEN + UIP_ICMPH_LEN) /* Size of ICMP + IP header */
|
||||
#define UIP_LLIPH_LEN (UIP_LLH_LEN + UIP_IPH_LEN) /* Size of L2 + IP header */
|
||||
#if NETSTACK_CONF_WITH_IPV6
|
||||
/**
|
||||
* The sums below are quite used in ND. When used for uip_buf, we
|
||||
|
|
@ -99,12 +93,12 @@
|
|||
*
|
||||
*/
|
||||
typedef union uip_ip4addr_t {
|
||||
uint8_t u8[4]; /* Initializer, must come first. */
|
||||
uint8_t u8[4]; /* Initializer, must come first. */
|
||||
uint16_t u16[2];
|
||||
} uip_ip4addr_t;
|
||||
|
||||
typedef union uip_ip6addr_t {
|
||||
uint8_t u8[16]; /* Initializer, must come first. */
|
||||
uint8_t u8[16]; /* Initializer, must come first. */
|
||||
uint16_t u16[8];
|
||||
} uip_ip6addr_t;
|
||||
|
||||
|
|
@ -1057,7 +1051,7 @@ struct uip_udp_conn *uip_udp_new(const uip_ipaddr_t *ripaddr, uint16_t rport);
|
|||
* \hideinitializer
|
||||
*/
|
||||
#define uip_ip4addr_cmp(addr1, addr2) ((addr1)->u16[0] == (addr2)->u16[0] && \
|
||||
(addr1)->u16[1] == (addr2)->u16[1])
|
||||
(addr1)->u16[1] == (addr2)->u16[1])
|
||||
#define uip_ip6addr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
|
||||
|
||||
#if NETSTACK_CONF_WITH_IPV6
|
||||
|
|
@ -1358,26 +1352,21 @@ struct uip_conn {
|
|||
|
||||
uint16_t lport; /**< The local TCP port, in network byte order. */
|
||||
uint16_t rport; /**< The local remote TCP port, in network byte
|
||||
order. */
|
||||
order. */
|
||||
|
||||
uint8_t rcv_nxt[4]; /**< The sequence number that we expect to
|
||||
receive next. */
|
||||
uint8_t snd_nxt[4]; /**< The sequence number that was last sent by
|
||||
us. */
|
||||
receive next. */
|
||||
uint8_t snd_nxt[4]; /**< The sequence number that was last sent by us. */
|
||||
uint16_t len; /**< Length of the data that was previously sent. */
|
||||
uint16_t mss; /**< Current maximum segment size for the
|
||||
connection. */
|
||||
uint16_t initialmss; /**< Initial maximum segment size for the
|
||||
connection. */
|
||||
uint8_t sa; /**< Retransmission time-out calculation state
|
||||
variable. */
|
||||
uint8_t sv; /**< Retransmission time-out calculation state
|
||||
variable. */
|
||||
uint16_t mss; /**< Current maximum segment size for the connection. */
|
||||
uint16_t initialmss; /**< Initial maximum segment size for the connection. */
|
||||
uint8_t sa; /**< Retransmission time-out calculation state variable. */
|
||||
uint8_t sv; /**< Retransmission time-out calculation state variable. */
|
||||
uint8_t rto; /**< Retransmission time-out. */
|
||||
uint8_t tcpstateflags; /**< TCP state and flags. */
|
||||
uint8_t timer; /**< The retransmission timer. */
|
||||
uint8_t nrtx; /**< The number of retransmissions for the last
|
||||
segment sent. */
|
||||
segment sent. */
|
||||
|
||||
/** The application state. */
|
||||
uip_tcp_appstate_t appstate;
|
||||
|
|
@ -1431,9 +1420,9 @@ struct uip_fallback_interface {
|
|||
void (*init)(void);
|
||||
/**
|
||||
* \retval >=0
|
||||
* in case of success
|
||||
* in case of success
|
||||
* \retval <0
|
||||
* in case of failure
|
||||
* in case of failure
|
||||
*/
|
||||
int (*output)(void);
|
||||
};
|
||||
|
|
@ -1464,51 +1453,43 @@ extern struct uip_stats uip_stat;
|
|||
*/
|
||||
struct uip_stats {
|
||||
struct {
|
||||
uip_stats_t recv; /**< Number of received packets at the IP
|
||||
layer. */
|
||||
uip_stats_t sent; /**< Number of sent packets at the IP
|
||||
layer. */
|
||||
uip_stats_t forwarded;/**< Number of forwarded packets at the IP
|
||||
layer. */
|
||||
uip_stats_t drop; /**< Number of dropped packets at the IP
|
||||
layer. */
|
||||
uip_stats_t recv; /**< Number of received packets at the IP layer. */
|
||||
uip_stats_t sent; /**< Number of sent packets at the IP layer. */
|
||||
uip_stats_t forwarded;/**< Number of forwarded packets at the IP layer. */
|
||||
uip_stats_t drop; /**< Number of dropped packets at the IP layer. */
|
||||
uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
|
||||
IP version or header length. */
|
||||
IP version or header length. */
|
||||
uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
|
||||
IP length, high byte. */
|
||||
IP length, high byte. */
|
||||
uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
|
||||
IP length, low byte. */
|
||||
IP length, low byte. */
|
||||
uip_stats_t fragerr; /**< Number of packets dropped because they
|
||||
were IP fragments. */
|
||||
were IP fragments. */
|
||||
uip_stats_t chkerr; /**< Number of packets dropped due to IP
|
||||
checksum errors. */
|
||||
checksum errors. */
|
||||
uip_stats_t protoerr; /**< Number of packets dropped because they
|
||||
were neither ICMP, UDP nor TCP. */
|
||||
were neither ICMP, UDP nor TCP. */
|
||||
} ip; /**< IP statistics. */
|
||||
struct {
|
||||
uip_stats_t recv; /**< Number of received ICMP packets. */
|
||||
uip_stats_t sent; /**< Number of sent ICMP packets. */
|
||||
uip_stats_t drop; /**< Number of dropped ICMP packets. */
|
||||
uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
|
||||
type. */
|
||||
uip_stats_t chkerr; /**< Number of ICMP packets with a bad
|
||||
checksum. */
|
||||
uip_stats_t typeerr; /**< Number of ICMP packets with a wrong type. */
|
||||
uip_stats_t chkerr; /**< Number of ICMP packets with a bad checksum. */
|
||||
} icmp; /**< ICMP statistics. */
|
||||
#if UIP_TCP
|
||||
struct {
|
||||
uip_stats_t recv; /**< Number of recived TCP segments. */
|
||||
uip_stats_t sent; /**< Number of sent TCP segments. */
|
||||
uip_stats_t drop; /**< Number of dropped TCP segments. */
|
||||
uip_stats_t chkerr; /**< Number of TCP segments with a bad
|
||||
checksum. */
|
||||
uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
|
||||
number. */
|
||||
uip_stats_t chkerr; /**< Number of TCP segments with a bad checksum. */
|
||||
uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK number. */
|
||||
uip_stats_t rst; /**< Number of received TCP RST (reset) segments. */
|
||||
uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
|
||||
uip_stats_t syndrop; /**< Number of dropped SYNs because too few
|
||||
connections were available. */
|
||||
connections were available. */
|
||||
uip_stats_t synrst; /**< Number of SYNs for closed ports,
|
||||
triggering a RST. */
|
||||
triggering a RST. */
|
||||
} tcp; /**< TCP statistics. */
|
||||
#endif
|
||||
#if UIP_UDP
|
||||
|
|
@ -1517,7 +1498,7 @@ struct uip_stats {
|
|||
uip_stats_t recv; /**< Number of recived UDP segments. */
|
||||
uip_stats_t sent; /**< Number of sent UDP segments. */
|
||||
uip_stats_t chkerr; /**< Number of UDP segments with a bad
|
||||
checksum. */
|
||||
checksum. */
|
||||
} udp; /**< UDP statistics. */
|
||||
#endif /* UIP_UDP */
|
||||
#if NETSTACK_CONF_WITH_IPV6
|
||||
|
|
@ -1554,33 +1535,33 @@ CCIF extern uint8_t uip_flags;
|
|||
functions/macros. */
|
||||
|
||||
#define UIP_ACKDATA 1 /* Signifies that the outstanding data was
|
||||
acked and the application should send
|
||||
out new data instead of retransmitting
|
||||
the last data. */
|
||||
acked and the application should send
|
||||
out new data instead of retransmitting
|
||||
the last data. */
|
||||
#define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
|
||||
us new data. */
|
||||
us new data. */
|
||||
#define UIP_REXMIT 4 /* Tells the application to retransmit the
|
||||
data that was last sent. */
|
||||
data that was last sent. */
|
||||
#define UIP_POLL 8 /* Used for polling the application, to
|
||||
check if the application has data that
|
||||
it wants to send. */
|
||||
check if the application has data that
|
||||
it wants to send. */
|
||||
#define UIP_CLOSE 16 /* The remote host has closed the
|
||||
connection, thus the connection has
|
||||
gone away. Or the application signals
|
||||
that it wants to close the
|
||||
connection. */
|
||||
connection, thus the connection has
|
||||
gone away. Or the application signals
|
||||
that it wants to close the
|
||||
connection. */
|
||||
#define UIP_ABORT 32 /* The remote host has aborted the
|
||||
connection, thus the connection has
|
||||
gone away. Or the application signals
|
||||
that it wants to abort the
|
||||
connection. */
|
||||
connection, thus the connection has
|
||||
gone away. Or the application signals
|
||||
that it wants to abort the
|
||||
connection. */
|
||||
#define UIP_CONNECTED 64 /* We have got a connection from a remote
|
||||
host and have set up a new connection
|
||||
for it, or an active connection has
|
||||
been successfully established. */
|
||||
|
||||
#define UIP_TIMEDOUT 128 /* The connection has been aborted due to
|
||||
too many retransmissions. */
|
||||
too many retransmissions. */
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -1606,16 +1587,16 @@ void uip_process(uint8_t flag);
|
|||
the macros defined in this file. */
|
||||
|
||||
#define UIP_DATA 1 /* Tells uIP that there is incoming
|
||||
data in the uip_buf buffer. The
|
||||
length of the data is stored in the
|
||||
global variable uip_len. */
|
||||
data in the uip_buf buffer. The
|
||||
length of the data is stored in the
|
||||
global variable uip_len. */
|
||||
#define UIP_TIMER 2 /* Tells uIP that the periodic timer
|
||||
has fired. */
|
||||
has fired. */
|
||||
#define UIP_POLL_REQUEST 3 /* Tells uIP that a connection should
|
||||
be polled. */
|
||||
be polled. */
|
||||
#define UIP_UDP_SEND_CONN 4 /* Tells uIP that a UDP datagram
|
||||
should be constructed in the
|
||||
uip_buf buffer. */
|
||||
should be constructed in the
|
||||
uip_buf buffer. */
|
||||
#if UIP_UDP
|
||||
#define UIP_UDP_TIMER 5
|
||||
#endif /* UIP_UDP */
|
||||
|
|
|
|||
|
|
@ -52,9 +52,9 @@
|
|||
* FOR HC-06 COMPLIANCE TODO:
|
||||
* -Add compression options to UDP, currently only supports
|
||||
* both ports compressed or both ports elided
|
||||
*
|
||||
*
|
||||
* -Verify TC/FL compression works
|
||||
*
|
||||
*
|
||||
* -Add stateless multicast option
|
||||
*/
|
||||
|
||||
|
|
@ -317,7 +317,7 @@ set_packet_attrs()
|
|||
|
||||
/** Addresses contexts for IPHC. */
|
||||
#if SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0
|
||||
static struct sicslowpan_addr_context
|
||||
static struct sicslowpan_addr_context
|
||||
addr_contexts[SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS];
|
||||
#endif
|
||||
|
||||
|
|
@ -381,7 +381,7 @@ addr_context_lookup_by_prefix(uip_ipaddr_t *ipaddr)
|
|||
static struct sicslowpan_addr_context*
|
||||
addr_context_lookup_by_number(uint8_t number)
|
||||
{
|
||||
/* Remove code to avoid warnings and save flash if no context is used */
|
||||
/* Remove code to avoid warnings and save flash if no context is used */
|
||||
#if SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0
|
||||
int i;
|
||||
for(i = 0; i < SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS; i++) {
|
||||
|
|
@ -540,11 +540,11 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
* We have to process both in the same time as the offset of traffic class
|
||||
* depends on the presence of version and flow label
|
||||
*/
|
||||
|
||||
|
||||
/* hc06 format of tc is ECN | DSCP , original is DSCP | ECN */
|
||||
tmp = (UIP_IP_BUF->vtc << 4) | (UIP_IP_BUF->tcflow >> 4);
|
||||
tmp = ((tmp & 0x03) << 6) | (tmp >> 2);
|
||||
|
||||
|
||||
if(((UIP_IP_BUF->tcflow & 0x0F) == 0) &&
|
||||
(UIP_IP_BUF->flow == 0)) {
|
||||
/* flow label can be compressed */
|
||||
|
|
@ -585,7 +585,7 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
iphc0 |= SICSLOWPAN_IPHC_NH_C;
|
||||
}
|
||||
#endif /*UIP_CONF_UDP*/
|
||||
#ifdef SICSLOWPAN_NH_COMPRESSOR
|
||||
#ifdef SICSLOWPAN_NH_COMPRESSOR
|
||||
if(SICSLOWPAN_NH_COMPRESSOR.is_compressable(UIP_IP_BUF->proto)) {
|
||||
iphc0 |= SICSLOWPAN_IPHC_NH_C;
|
||||
}
|
||||
|
|
@ -627,7 +627,7 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
!= NULL) {
|
||||
/* elide the prefix - indicate by CID and set context + SAC */
|
||||
PRINTF("IPHC: compressing src with context - setting CID & SAC ctx: %d\n",
|
||||
context->number);
|
||||
context->number);
|
||||
iphc1 |= SICSLOWPAN_IPHC_CID | SICSLOWPAN_IPHC_SAC;
|
||||
PACKETBUF_IPHC_BUF[2] |= context->number << 4;
|
||||
/* compession compare with this nodes address (source) */
|
||||
|
|
@ -636,9 +636,9 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
&UIP_IP_BUF->srcipaddr, &uip_lladdr);
|
||||
/* No context found for this address */
|
||||
} else if(uip_is_addr_linklocal(&UIP_IP_BUF->srcipaddr) &&
|
||||
UIP_IP_BUF->destipaddr.u16[1] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[2] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[3] == 0) {
|
||||
UIP_IP_BUF->destipaddr.u16[1] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[2] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[3] == 0) {
|
||||
iphc1 |= compress_addr_64(SICSLOWPAN_IPHC_SAM_BIT,
|
||||
&UIP_IP_BUF->srcipaddr, &uip_lladdr);
|
||||
} else {
|
||||
|
|
@ -684,12 +684,13 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
/* compession compare with link adress (destination) */
|
||||
|
||||
iphc1 |= compress_addr_64(SICSLOWPAN_IPHC_DAM_BIT,
|
||||
&UIP_IP_BUF->destipaddr, (uip_lladdr_t *)link_destaddr);
|
||||
&UIP_IP_BUF->destipaddr,
|
||||
(uip_lladdr_t *)link_destaddr);
|
||||
/* No context found for this address */
|
||||
} else if(uip_is_addr_linklocal(&UIP_IP_BUF->destipaddr) &&
|
||||
UIP_IP_BUF->destipaddr.u16[1] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[2] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[3] == 0) {
|
||||
UIP_IP_BUF->destipaddr.u16[1] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[2] == 0 &&
|
||||
UIP_IP_BUF->destipaddr.u16[3] == 0) {
|
||||
iphc1 |= compress_addr_64(SICSLOWPAN_IPHC_DAM_BIT,
|
||||
&UIP_IP_BUF->destipaddr, (uip_lladdr_t *)link_destaddr);
|
||||
} else {
|
||||
|
|
@ -706,7 +707,7 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
/* UDP header compression */
|
||||
if(UIP_IP_BUF->proto == UIP_PROTO_UDP) {
|
||||
PRINTF("IPHC: Uncompressed UDP ports on send side: %x, %x\n",
|
||||
UIP_HTONS(UIP_UDP_BUF->srcport), UIP_HTONS(UIP_UDP_BUF->destport));
|
||||
UIP_HTONS(UIP_UDP_BUF->srcport), UIP_HTONS(UIP_UDP_BUF->destport));
|
||||
/* Mask out the last 4 bits can be used as a mask */
|
||||
if(((UIP_HTONS(UIP_UDP_BUF->srcport) & 0xfff0) == SICSLOWPAN_UDP_4_BIT_PORT_MIN) &&
|
||||
((UIP_HTONS(UIP_UDP_BUF->destport) & 0xfff0) == SICSLOWPAN_UDP_4_BIT_PORT_MIN)) {
|
||||
|
|
@ -714,10 +715,10 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
*hc06_ptr = SICSLOWPAN_NHC_UDP_CS_P_11;
|
||||
PRINTF("IPHC: remove 12 b of both source & dest with prefix 0xFOB\n");
|
||||
*(hc06_ptr + 1) =
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->srcport) -
|
||||
SICSLOWPAN_UDP_4_BIT_PORT_MIN) << 4) +
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->destport) -
|
||||
SICSLOWPAN_UDP_4_BIT_PORT_MIN));
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->srcport) -
|
||||
SICSLOWPAN_UDP_4_BIT_PORT_MIN) << 4) +
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->destport) -
|
||||
SICSLOWPAN_UDP_4_BIT_PORT_MIN));
|
||||
hc06_ptr += 2;
|
||||
} else if((UIP_HTONS(UIP_UDP_BUF->destport) & 0xff00) == SICSLOWPAN_UDP_8_BIT_PORT_MIN) {
|
||||
/* we can compress 8 bits of dest, leave source. */
|
||||
|
|
@ -725,16 +726,16 @@ compress_hdr_hc06(linkaddr_t *link_destaddr)
|
|||
PRINTF("IPHC: leave source, remove 8 bits of dest with prefix 0xF0\n");
|
||||
memcpy(hc06_ptr + 1, &UIP_UDP_BUF->srcport, 2);
|
||||
*(hc06_ptr + 3) =
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->destport) -
|
||||
SICSLOWPAN_UDP_8_BIT_PORT_MIN));
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->destport) -
|
||||
SICSLOWPAN_UDP_8_BIT_PORT_MIN));
|
||||
hc06_ptr += 4;
|
||||
} else if((UIP_HTONS(UIP_UDP_BUF->srcport) & 0xff00) == SICSLOWPAN_UDP_8_BIT_PORT_MIN) {
|
||||
/* we can compress 8 bits of src, leave dest. Copy compressed port */
|
||||
*hc06_ptr = SICSLOWPAN_NHC_UDP_CS_P_10;
|
||||
PRINTF("IPHC: remove 8 bits of source with prefix 0xF0, leave dest. hch: %i\n", *hc06_ptr);
|
||||
*(hc06_ptr + 1) =
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->srcport) -
|
||||
SICSLOWPAN_UDP_8_BIT_PORT_MIN));
|
||||
(uint8_t)((UIP_HTONS(UIP_UDP_BUF->srcport) -
|
||||
SICSLOWPAN_UDP_8_BIT_PORT_MIN));
|
||||
memcpy(hc06_ptr + 2, &UIP_UDP_BUF->destport, 2);
|
||||
hc06_ptr += 4;
|
||||
} else {
|
||||
|
|
@ -811,13 +812,13 @@ uncompress_hdr_hc06(uint16_t ip_len)
|
|||
SICSLOWPAN_IP_BUF->vtc = 0x60 | ((tmp >> 2) & 0x0f);
|
||||
/* ECN rolled down two steps + lowest DSCP bits at top two bits */
|
||||
SICSLOWPAN_IP_BUF->tcflow = ((tmp >> 2) & 0x30) | (tmp << 6) |
|
||||
(SICSLOWPAN_IP_BUF->tcflow & 0x0f);
|
||||
(SICSLOWPAN_IP_BUF->tcflow & 0x0f);
|
||||
} else {
|
||||
/* Traffic class is compressed (set version and no TC)*/
|
||||
SICSLOWPAN_IP_BUF->vtc = 0x60;
|
||||
/* highest flow label bits + ECN bits */
|
||||
SICSLOWPAN_IP_BUF->tcflow = (*hc06_ptr & 0x0F) |
|
||||
((*hc06_ptr >> 2) & 0x30);
|
||||
((*hc06_ptr >> 2) & 0x30);
|
||||
memcpy(&SICSLOWPAN_IP_BUF->flow, hc06_ptr + 1, 2);
|
||||
hc06_ptr += 3;
|
||||
}
|
||||
|
|
@ -908,14 +909,13 @@ uncompress_hdr_hc06(uint16_t ip_len)
|
|||
/* no multicast */
|
||||
/* Context based */
|
||||
if(iphc1 & SICSLOWPAN_IPHC_DAC) {
|
||||
uint8_t dci = (iphc1 & SICSLOWPAN_IPHC_CID) ?
|
||||
PACKETBUF_IPHC_BUF[2] & 0x0f : 0;
|
||||
uint8_t dci = (iphc1 & SICSLOWPAN_IPHC_CID) ? PACKETBUF_IPHC_BUF[2] & 0x0f : 0;
|
||||
context = addr_context_lookup_by_number(dci);
|
||||
|
||||
/* all valid cases below need the context! */
|
||||
if(context == NULL) {
|
||||
PRINTF("sicslowpan uncompress_hdr: error context not found\n");
|
||||
return;
|
||||
PRINTF("sicslowpan uncompress_hdr: error context not found\n");
|
||||
return;
|
||||
}
|
||||
uncompress_addr(&SICSLOWPAN_IP_BUF->destipaddr, context->prefix,
|
||||
unc_ctxconf[tmp],
|
||||
|
|
@ -939,56 +939,56 @@ uncompress_hdr_hc06(uint16_t ip_len)
|
|||
PRINTF("IPHC: Incoming header value: %i\n", *hc06_ptr);
|
||||
switch(*hc06_ptr & SICSLOWPAN_NHC_UDP_CS_P_11) {
|
||||
case SICSLOWPAN_NHC_UDP_CS_P_00:
|
||||
/* 1 byte for NHC, 4 byte for ports, 2 bytes chksum */
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->srcport, hc06_ptr + 1, 2);
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->destport, hc06_ptr + 3, 2);
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+5): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 5;
|
||||
break;
|
||||
/* 1 byte for NHC, 4 byte for ports, 2 bytes chksum */
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->srcport, hc06_ptr + 1, 2);
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->destport, hc06_ptr + 3, 2);
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+5): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 5;
|
||||
break;
|
||||
|
||||
case SICSLOWPAN_NHC_UDP_CS_P_01:
|
||||
/* 1 byte for NHC + source 16bit inline, dest = 0xF0 + 8 bit inline */
|
||||
PRINTF("IPHC: Decompressing destination\n");
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->srcport, hc06_ptr + 1, 2);
|
||||
SICSLOWPAN_UDP_BUF->destport = UIP_HTONS(SICSLOWPAN_UDP_8_BIT_PORT_MIN + (*(hc06_ptr + 3)));
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+4): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 4;
|
||||
break;
|
||||
PRINTF("IPHC: Decompressing destination\n");
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->srcport, hc06_ptr + 1, 2);
|
||||
SICSLOWPAN_UDP_BUF->destport = UIP_HTONS(SICSLOWPAN_UDP_8_BIT_PORT_MIN + (*(hc06_ptr + 3)));
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+4): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 4;
|
||||
break;
|
||||
|
||||
case SICSLOWPAN_NHC_UDP_CS_P_10:
|
||||
/* 1 byte for NHC + source = 0xF0 + 8bit inline, dest = 16 bit inline*/
|
||||
PRINTF("IPHC: Decompressing source\n");
|
||||
SICSLOWPAN_UDP_BUF->srcport = UIP_HTONS(SICSLOWPAN_UDP_8_BIT_PORT_MIN +
|
||||
(*(hc06_ptr + 1)));
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->destport, hc06_ptr + 2, 2);
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+4): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 4;
|
||||
break;
|
||||
PRINTF("IPHC: Decompressing source\n");
|
||||
SICSLOWPAN_UDP_BUF->srcport = UIP_HTONS(SICSLOWPAN_UDP_8_BIT_PORT_MIN +
|
||||
(*(hc06_ptr + 1)));
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->destport, hc06_ptr + 2, 2);
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+4): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 4;
|
||||
break;
|
||||
|
||||
case SICSLOWPAN_NHC_UDP_CS_P_11:
|
||||
/* 1 byte for NHC, 1 byte for ports */
|
||||
SICSLOWPAN_UDP_BUF->srcport = UIP_HTONS(SICSLOWPAN_UDP_4_BIT_PORT_MIN +
|
||||
(*(hc06_ptr + 1) >> 4));
|
||||
SICSLOWPAN_UDP_BUF->destport = UIP_HTONS(SICSLOWPAN_UDP_4_BIT_PORT_MIN +
|
||||
((*(hc06_ptr + 1)) & 0x0F));
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+2): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 2;
|
||||
break;
|
||||
/* 1 byte for NHC, 1 byte for ports */
|
||||
SICSLOWPAN_UDP_BUF->srcport = UIP_HTONS(SICSLOWPAN_UDP_4_BIT_PORT_MIN +
|
||||
(*(hc06_ptr + 1) >> 4));
|
||||
SICSLOWPAN_UDP_BUF->destport = UIP_HTONS(SICSLOWPAN_UDP_4_BIT_PORT_MIN +
|
||||
((*(hc06_ptr + 1)) & 0x0F));
|
||||
PRINTF("IPHC: Uncompressed UDP ports (ptr+2): %x, %x\n",
|
||||
UIP_HTONS(SICSLOWPAN_UDP_BUF->srcport), UIP_HTONS(SICSLOWPAN_UDP_BUF->destport));
|
||||
hc06_ptr += 2;
|
||||
break;
|
||||
|
||||
default:
|
||||
PRINTF("sicslowpan uncompress_hdr: error unsupported UDP compression\n");
|
||||
return;
|
||||
PRINTF("sicslowpan uncompress_hdr: error unsupported UDP compression\n");
|
||||
return;
|
||||
}
|
||||
if(!checksum_compressed) { /* has_checksum, default */
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->udpchksum, hc06_ptr, 2);
|
||||
hc06_ptr += 2;
|
||||
PRINTF("IPHC: sicslowpan uncompress_hdr: checksum included\n");
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->udpchksum, hc06_ptr, 2);
|
||||
hc06_ptr += 2;
|
||||
PRINTF("IPHC: sicslowpan uncompress_hdr: checksum included\n");
|
||||
} else {
|
||||
PRINTF("IPHC: sicslowpan uncompress_hdr: checksum *NOT* included\n");
|
||||
PRINTF("IPHC: sicslowpan uncompress_hdr: checksum *NOT* included\n");
|
||||
}
|
||||
uncomp_hdr_len += UIP_UDPH_LEN;
|
||||
}
|
||||
|
|
@ -1000,7 +1000,7 @@ uncompress_hdr_hc06(uint16_t ip_len)
|
|||
}
|
||||
|
||||
packetbuf_hdr_len = hc06_ptr - packetbuf_ptr;
|
||||
|
||||
|
||||
/* IP length field. */
|
||||
if(ip_len == 0) {
|
||||
int len = packetbuf_datalen() - packetbuf_hdr_len + uncomp_hdr_len - UIP_IPH_LEN;
|
||||
|
|
@ -1012,7 +1012,7 @@ uncompress_hdr_hc06(uint16_t ip_len)
|
|||
SICSLOWPAN_IP_BUF->len[0] = (ip_len - UIP_IPH_LEN) >> 8;
|
||||
SICSLOWPAN_IP_BUF->len[1] = (ip_len - UIP_IPH_LEN) & 0x00FF;
|
||||
}
|
||||
|
||||
|
||||
/* length field in UDP header */
|
||||
if(SICSLOWPAN_IP_BUF->proto == UIP_PROTO_UDP) {
|
||||
memcpy(&SICSLOWPAN_UDP_BUF->udplen, &SICSLOWPAN_IP_BUF->len[0], 2);
|
||||
|
|
@ -1144,7 +1144,7 @@ compress_hdr_hc1(linkaddr_t *link_destaddr)
|
|||
UIP_HTONS(UIP_UDP_BUF->destport) < SICSLOWPAN_UDP_PORT_MAX) {
|
||||
/* HC1 encoding */
|
||||
PACKETBUF_HC1_HC_UDP_PTR[PACKETBUF_HC1_HC_UDP_HC1_ENCODING] = 0xFB;
|
||||
|
||||
|
||||
/* HC_UDP encoding, ttl, src and dest ports, checksum */
|
||||
PACKETBUF_HC1_HC_UDP_PTR[PACKETBUF_HC1_HC_UDP_UDP_ENCODING] = 0xE0;
|
||||
PACKETBUF_HC1_HC_UDP_PTR[PACKETBUF_HC1_HC_UDP_TTL] = UIP_IP_BUF->ttl;
|
||||
|
|
@ -1192,17 +1192,17 @@ uncompress_hdr_hc1(uint16_t ip_len)
|
|||
SICSLOWPAN_IP_BUF->vtc = 0x60;
|
||||
SICSLOWPAN_IP_BUF->tcflow = 0;
|
||||
SICSLOWPAN_IP_BUF->flow = 0;
|
||||
|
||||
|
||||
/* src and dest ip addresses */
|
||||
uip_ip6addr(&SICSLOWPAN_IP_BUF->srcipaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0);
|
||||
uip_ds6_set_addr_iid(&SICSLOWPAN_IP_BUF->srcipaddr,
|
||||
(uip_lladdr_t *)packetbuf_addr(PACKETBUF_ADDR_SENDER));
|
||||
(uip_lladdr_t *)packetbuf_addr(PACKETBUF_ADDR_SENDER));
|
||||
uip_ip6addr(&SICSLOWPAN_IP_BUF->destipaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0);
|
||||
uip_ds6_set_addr_iid(&SICSLOWPAN_IP_BUF->destipaddr,
|
||||
(uip_lladdr_t *)packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
|
||||
|
||||
(uip_lladdr_t *)packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
|
||||
|
||||
uncomp_hdr_len += UIP_IPH_LEN;
|
||||
|
||||
|
||||
/* Next header field */
|
||||
switch(PACKETBUF_HC1_PTR[PACKETBUF_HC1_ENCODING] & 0x06) {
|
||||
case SICSLOWPAN_HC1_NH_ICMP6:
|
||||
|
|
@ -1248,7 +1248,7 @@ uncompress_hdr_hc1(uint16_t ip_len)
|
|||
/* this shouldn't happen, drop */
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* IP length field. */
|
||||
if(ip_len == 0) {
|
||||
int len = packetbuf_datalen() - packetbuf_hdr_len + uncomp_hdr_len - UIP_IPH_LEN;
|
||||
|
|
@ -1412,7 +1412,7 @@ output(const uip_lladdr_t *localdest)
|
|||
} else {
|
||||
linkaddr_copy(&dest, (const linkaddr_t *)localdest);
|
||||
}
|
||||
|
||||
|
||||
PRINTFO("sicslowpan output: sending packet len %d\n", uip_len);
|
||||
|
||||
if(uip_len >= COMPRESSION_THRESHOLD) {
|
||||
|
|
@ -1512,7 +1512,7 @@ output(const uip_lladdr_t *localdest)
|
|||
|
||||
/* set processed_ip_out_len to what we already sent from the IP payload*/
|
||||
processed_ip_out_len = packetbuf_payload_len + uncomp_hdr_len;
|
||||
|
||||
|
||||
/*
|
||||
* Create following fragments
|
||||
* Datagram tag is already in the buffer, we need to set the
|
||||
|
|
@ -1527,7 +1527,7 @@ output(const uip_lladdr_t *localdest)
|
|||
while(processed_ip_out_len < uip_len) {
|
||||
PRINTFO("sicslowpan output: fragment ");
|
||||
PACKETBUF_FRAG_PTR[PACKETBUF_FRAG_OFFSET] = processed_ip_out_len >> 3;
|
||||
|
||||
|
||||
/* Copy payload and send */
|
||||
if(uip_len - processed_ip_out_len < packetbuf_payload_len) {
|
||||
/* last fragment */
|
||||
|
|
@ -1759,8 +1759,8 @@ input(void)
|
|||
PACKETBUF_HC1_PTR[PACKETBUF_HC1_DISPATCH]);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#if SICSLOWPAN_CONF_FRAG
|
||||
copypayload:
|
||||
#endif /*SICSLOWPAN_CONF_FRAG*/
|
||||
|
|
@ -1791,7 +1791,7 @@ input(void)
|
|||
}
|
||||
|
||||
memcpy((uint8_t *)SICSLOWPAN_IP_BUF + uncomp_hdr_len + (uint16_t)(frag_offset << 3), packetbuf_ptr + packetbuf_hdr_len, packetbuf_payload_len);
|
||||
|
||||
|
||||
/* update processed_ip_in_len if fragment, sicslowpan_len otherwise */
|
||||
|
||||
#if SICSLOWPAN_CONF_FRAG
|
||||
|
|
@ -1873,13 +1873,13 @@ sicslowpan_init(void)
|
|||
* The platform contiki-conf.h file can override this using e.g.
|
||||
* #define SICSLOWPAN_CONF_ADDR_CONTEXT_0 {addr_contexts[0].prefix[0]=0xbb;addr_contexts[0].prefix[1]=0xbb;}
|
||||
*/
|
||||
#if SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0
|
||||
#if SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0
|
||||
addr_contexts[0].used = 1;
|
||||
addr_contexts[0].number = 0;
|
||||
#ifdef SICSLOWPAN_CONF_ADDR_CONTEXT_0
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_0;
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_0;
|
||||
#else
|
||||
addr_contexts[0].prefix[0] = 0xaa;
|
||||
addr_contexts[0].prefix[0] = 0xaa;
|
||||
addr_contexts[0].prefix[1] = 0xaa;
|
||||
#endif
|
||||
#endif /* SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 0 */
|
||||
|
|
@ -1889,23 +1889,22 @@ sicslowpan_init(void)
|
|||
int i;
|
||||
for(i = 1; i < SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS; i++) {
|
||||
#ifdef SICSLOWPAN_CONF_ADDR_CONTEXT_1
|
||||
if (i==1) {
|
||||
addr_contexts[1].used = 1;
|
||||
addr_contexts[1].number = 1;
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_1;
|
||||
if (i==1) {
|
||||
addr_contexts[1].used = 1;
|
||||
addr_contexts[1].number = 1;
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_1;
|
||||
#ifdef SICSLOWPAN_CONF_ADDR_CONTEXT_2
|
||||
} else if (i==2) {
|
||||
addr_contexts[2].used = 1;
|
||||
addr_contexts[2].number = 2;
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_2;
|
||||
addr_contexts[2].used = 1;
|
||||
addr_contexts[2].number = 2;
|
||||
SICSLOWPAN_CONF_ADDR_CONTEXT_2;
|
||||
#endif
|
||||
} else {
|
||||
addr_contexts[i].used = 0;
|
||||
}
|
||||
}
|
||||
#else
|
||||
addr_contexts[i].used = 0;
|
||||
#endif /* SICSLOWPAN_CONF_ADDR_CONTEXT_1 */
|
||||
|
||||
}
|
||||
}
|
||||
#endif /* SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS > 1 */
|
||||
|
|
|
|||
|
|
@ -203,18 +203,18 @@ uip_ds6_link_neighbor_callback(int status, int numtx)
|
|||
#if UIP_DS6_LL_NUD
|
||||
/* From RFC4861, page 72, last paragraph of section 7.3.3:
|
||||
*
|
||||
* "In some cases, link-specific information may indicate that a path to
|
||||
* a neighbor has failed (e.g., the resetting of a virtual circuit). In
|
||||
* such cases, link-specific information may be used to purge Neighbor
|
||||
* Cache entries before the Neighbor Unreachability Detection would do
|
||||
* so. However, link-specific information MUST NOT be used to confirm
|
||||
* the reachability of a neighbor; such information does not provide
|
||||
* end-to-end confirmation between neighboring IP layers."
|
||||
* "In some cases, link-specific information may indicate that a path to
|
||||
* a neighbor has failed (e.g., the resetting of a virtual circuit). In
|
||||
* such cases, link-specific information may be used to purge Neighbor
|
||||
* Cache entries before the Neighbor Unreachability Detection would do
|
||||
* so. However, link-specific information MUST NOT be used to confirm
|
||||
* the reachability of a neighbor; such information does not provide
|
||||
* end-to-end confirmation between neighboring IP layers."
|
||||
*
|
||||
* However, we assume that receiving a link layer ack ensures the delivery
|
||||
* of the transmitted packed to the IP stack of the neighbour. This is a
|
||||
* fair assumption and allows battery powered nodes save some battery by
|
||||
* not re-testing the state of a neighbour periodically if it
|
||||
* of the transmitted packed to the IP stack of the neighbour. This is a
|
||||
* fair assumption and allows battery powered nodes save some battery by
|
||||
* not re-testing the state of a neighbour periodically if it
|
||||
* acknowledges link packets. */
|
||||
if(status == MAC_TX_OK) {
|
||||
uip_ds6_nbr_t *nbr;
|
||||
|
|
|
|||
|
|
@ -297,9 +297,9 @@ uip_ds6_prefix_t *
|
|||
uip_ds6_prefix_lookup(uip_ipaddr_t *ipaddr, uint8_t ipaddrlen)
|
||||
{
|
||||
if(uip_ds6_list_loop((uip_ds6_element_t *)uip_ds6_prefix_list,
|
||||
UIP_DS6_PREFIX_NB, sizeof(uip_ds6_prefix_t),
|
||||
ipaddr, ipaddrlen,
|
||||
(uip_ds6_element_t **)&locprefix) == FOUND) {
|
||||
UIP_DS6_PREFIX_NB, sizeof(uip_ds6_prefix_t),
|
||||
ipaddr, ipaddrlen,
|
||||
(uip_ds6_element_t **)&locprefix) == FOUND) {
|
||||
return locprefix;
|
||||
}
|
||||
return NULL;
|
||||
|
|
@ -489,8 +489,8 @@ uip_ds6_aaddr_lookup(uip_ipaddr_t *ipaddr)
|
|||
{
|
||||
#if UIP_DS6_AADDR_NB
|
||||
if(uip_ds6_list_loop((uip_ds6_element_t *)uip_ds6_if.aaddr_list,
|
||||
UIP_DS6_AADDR_NB, sizeof(uip_ds6_aaddr_t), ipaddr, 128,
|
||||
(uip_ds6_element_t **)&locaaddr) == FOUND) {
|
||||
UIP_DS6_AADDR_NB, sizeof(uip_ds6_aaddr_t), ipaddr, 128,
|
||||
(uip_ds6_element_t **)&locaaddr) == FOUND) {
|
||||
return locaaddr;
|
||||
}
|
||||
#endif /* UIP_DS6_AADDR_NB */
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ void uip_log(char *msg);
|
|||
/** \name Pointers to the header structures.
|
||||
* All pointers except UIP_IP_BUF depend on uip_ext_len, which at
|
||||
* packet reception, is the total length of the extension headers.
|
||||
*
|
||||
*
|
||||
* The pointer to ND6 options header also depends on nd6_opt_offset,
|
||||
* which we set in each function.
|
||||
*
|
||||
|
|
@ -143,7 +143,7 @@ extract_lladdr_aligned(uip_lladdr_t *dest) {
|
|||
}
|
||||
#endif /* UIP_ND6_SEND_NA || UIP_ND6_SEND_RA || !UIP_CONF_ROUTER */
|
||||
/*------------------------------------------------------------------*/
|
||||
/* create a llao */
|
||||
/* create a llao */
|
||||
static void
|
||||
create_llao(uint8_t *llao, uint8_t type) {
|
||||
llao[UIP_ND6_OPT_TYPE_OFFSET] = type;
|
||||
|
|
@ -361,7 +361,7 @@ uip_nd6_ns_output(uip_ipaddr_t * src, uip_ipaddr_t * dest, uip_ipaddr_t * tgt)
|
|||
UIP_IP_BUF->len[0] = 0; /* length will not be more than 255 */
|
||||
/*
|
||||
* check if we add a SLLAO option: for DAD, MUST NOT, for NUD, MAY
|
||||
* (here yes), for Address resolution , MUST
|
||||
* (here yes), for Address resolution , MUST
|
||||
*/
|
||||
if(!(uip_ds6_is_my_addr(tgt))) {
|
||||
if(src != NULL) {
|
||||
|
|
@ -378,7 +378,7 @@ uip_nd6_ns_output(uip_ipaddr_t * src, uip_ipaddr_t * dest, uip_ipaddr_t * tgt)
|
|||
UIP_ICMPH_LEN + UIP_ND6_NS_LEN + UIP_ND6_OPT_LLAO_LEN;
|
||||
|
||||
create_llao(&uip_buf[uip_l2_l3_icmp_hdr_len + UIP_ND6_NS_LEN],
|
||||
UIP_ND6_OPT_SLLAO);
|
||||
UIP_ND6_OPT_SLLAO);
|
||||
|
||||
uip_len =
|
||||
UIP_IPH_LEN + UIP_ICMPH_LEN + UIP_ND6_NS_LEN + UIP_ND6_OPT_LLAO_LEN;
|
||||
|
|
@ -437,9 +437,9 @@ na_input(void)
|
|||
PRINTF("\n");
|
||||
UIP_STAT(++uip_stat.nd6.recv);
|
||||
|
||||
/*
|
||||
/*
|
||||
* booleans. the three last one are not 0 or 1 but 0 or 0x80, 0x40, 0x20
|
||||
* but it works. Be careful though, do not use tests such as is_router == 1
|
||||
* but it works. Be careful though, do not use tests such as is_router == 1
|
||||
*/
|
||||
is_llchange = 0;
|
||||
is_router = ((UIP_ND6_NA_BUF->flagsreserved & UIP_ND6_NA_FLAG_ROUTER));
|
||||
|
|
@ -505,7 +505,7 @@ na_input(void)
|
|||
goto discard;
|
||||
}
|
||||
memcpy(lladdr, &nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
|
||||
UIP_LLADDR_LEN);
|
||||
UIP_LLADDR_LEN);
|
||||
if(is_solicited) {
|
||||
nbr->state = NBR_REACHABLE;
|
||||
nbr->nscount = 0;
|
||||
|
|
@ -528,7 +528,7 @@ na_input(void)
|
|||
|| nd6_opt_llao == 0) {
|
||||
if(nd6_opt_llao != 0) {
|
||||
memcpy(lladdr, &nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
|
||||
UIP_LLADDR_LEN);
|
||||
UIP_LLADDR_LEN);
|
||||
}
|
||||
if(is_solicited) {
|
||||
nbr->state = NBR_REACHABLE;
|
||||
|
|
@ -564,7 +564,7 @@ na_input(void)
|
|||
uip_packetqueue_free(&nbr->packethandle);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
#endif /*UIP_CONF_IPV6_QUEUE_PKT */
|
||||
|
||||
discard:
|
||||
|
|
@ -590,7 +590,7 @@ rs_input(void)
|
|||
|
||||
#if UIP_CONF_IPV6_CHECKS
|
||||
/*
|
||||
* Check hop limit / icmp code
|
||||
* Check hop limit / icmp code
|
||||
* target address must not be multicast
|
||||
* if the NA is solicited, dest must not be multicast
|
||||
*/
|
||||
|
|
@ -796,7 +796,7 @@ uip_nd6_rs_output(void)
|
|||
UIP_ICMPH_LEN + UIP_ND6_RS_LEN + UIP_ND6_OPT_LLAO_LEN;
|
||||
|
||||
create_llao(&uip_buf[uip_l2_l3_icmp_hdr_len + UIP_ND6_RS_LEN],
|
||||
UIP_ND6_OPT_SLLAO);
|
||||
UIP_ND6_OPT_SLLAO);
|
||||
}
|
||||
|
||||
UIP_ICMP_BUF->icmpchksum = 0;
|
||||
|
|
@ -877,9 +877,9 @@ ra_input(void)
|
|||
nbr->state = NBR_STALE;
|
||||
}
|
||||
if(memcmp(&nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
|
||||
lladdr, UIP_LLADDR_LEN) != 0) {
|
||||
lladdr, UIP_LLADDR_LEN) != 0) {
|
||||
memcpy(lladdr, &nd6_opt_llao[UIP_ND6_OPT_DATA_OFFSET],
|
||||
UIP_LLADDR_LEN);
|
||||
UIP_LLADDR_LEN);
|
||||
nbr->state = NBR_STALE;
|
||||
}
|
||||
nbr->isrouter = 1;
|
||||
|
|
@ -937,7 +937,7 @@ ra_input(void)
|
|||
if((nd6_opt_prefix_info->flagsreserved1 & UIP_ND6_RA_FLAG_AUTONOMOUS)
|
||||
&& (nd6_opt_prefix_info->validlt != 0)
|
||||
&& (nd6_opt_prefix_info->preflen == UIP_DEFAULT_PREFIX_LEN)) {
|
||||
|
||||
|
||||
uip_ipaddr_copy(&ipaddr, &nd6_opt_prefix_info->prefix);
|
||||
uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr);
|
||||
addr = uip_ds6_addr_lookup(&ipaddr);
|
||||
|
|
|
|||
|
|
@ -128,9 +128,9 @@
|
|||
#endif
|
||||
|
||||
#ifdef UIP_CONF_ND6_RETRANS_TIMER
|
||||
#define UIP_ND6_RETRANS_TIMER UIP_CONF_ND6_RETRANS_TIMER
|
||||
#define UIP_ND6_RETRANS_TIMER UIP_CONF_ND6_RETRANS_TIMER
|
||||
#else
|
||||
#define UIP_ND6_RETRANS_TIMER 1000
|
||||
#define UIP_ND6_RETRANS_TIMER 1000
|
||||
#endif
|
||||
|
||||
#define UIP_ND6_DELAY_FIRST_PROBE_TIME 5
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ void uip_log(char *msg);
|
|||
#if UIP_STATISTICS == 1
|
||||
struct uip_stats uip_stat;
|
||||
#endif /* UIP_STATISTICS == 1 */
|
||||
|
||||
|
||||
|
||||
/*---------------------------------------------------------------------------*/
|
||||
/**
|
||||
|
|
@ -299,15 +299,15 @@ uip_add32(uint8_t *op32, uint16_t op16)
|
|||
uip_acc32[2] = op32[2] + (op16 >> 8);
|
||||
uip_acc32[1] = op32[1];
|
||||
uip_acc32[0] = op32[0];
|
||||
|
||||
|
||||
if(uip_acc32[2] < (op16 >> 8)) {
|
||||
++uip_acc32[1];
|
||||
if(uip_acc32[1] == 0) {
|
||||
++uip_acc32[0];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
if(uip_acc32[3] < (op16 & 0xff)) {
|
||||
++uip_acc32[2];
|
||||
if(uip_acc32[2] == 0) {
|
||||
|
|
@ -332,7 +332,7 @@ chksum(uint16_t sum, const uint8_t *data, uint16_t len)
|
|||
|
||||
dataptr = data;
|
||||
last_byte = data + len - 1;
|
||||
|
||||
|
||||
while(dataptr < last_byte) { /* At least two more bytes */
|
||||
t = (dataptr[0] << 8) + dataptr[1];
|
||||
sum += t;
|
||||
|
|
@ -341,7 +341,7 @@ chksum(uint16_t sum, const uint8_t *data, uint16_t len)
|
|||
}
|
||||
dataptr += 2;
|
||||
}
|
||||
|
||||
|
||||
if(dataptr == last_byte) {
|
||||
t = (dataptr[0] << 8) + 0;
|
||||
sum += t;
|
||||
|
|
@ -386,11 +386,11 @@ upper_layer_chksum(uint8_t proto)
|
|||
*/
|
||||
volatile uint16_t upper_layer_len;
|
||||
uint16_t sum;
|
||||
|
||||
|
||||
upper_layer_len = (((uint16_t)(UIP_IP_BUF->len[0]) << 8) + UIP_IP_BUF->len[1] - uip_ext_len);
|
||||
|
||||
|
||||
PRINTF("Upper layer checksum len: %d from: %d\n", upper_layer_len,
|
||||
UIP_IPH_LEN + UIP_LLH_LEN + uip_ext_len);
|
||||
UIP_IPH_LEN + UIP_LLH_LEN + uip_ext_len);
|
||||
|
||||
/* First sum pseudoheader. */
|
||||
/* IP protocol and length fields. This addition cannot carry. */
|
||||
|
|
@ -401,7 +401,7 @@ upper_layer_chksum(uint8_t proto)
|
|||
/* Sum TCP header and data. */
|
||||
sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN + uip_ext_len],
|
||||
upper_layer_len);
|
||||
|
||||
|
||||
return (sum == 0) ? 0xffff : uip_htons(sum);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
|
@ -409,7 +409,7 @@ uint16_t
|
|||
uip_icmp6chksum(void)
|
||||
{
|
||||
return upper_layer_chksum(UIP_PROTO_ICMP6);
|
||||
|
||||
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
#if UIP_TCP
|
||||
|
|
@ -432,7 +432,7 @@ uip_udpchksum(void)
|
|||
void
|
||||
uip_init(void)
|
||||
{
|
||||
|
||||
|
||||
uip_ds6_init();
|
||||
uip_icmp6_init();
|
||||
uip_nd6_init();
|
||||
|
|
@ -466,7 +466,7 @@ struct uip_conn *
|
|||
uip_connect(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
||||
{
|
||||
register struct uip_conn *conn, *cconn;
|
||||
|
||||
|
||||
/* Find an unused local port. */
|
||||
again:
|
||||
++lastport;
|
||||
|
|
@ -503,7 +503,7 @@ uip_connect(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
if(conn == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
conn->tcpstateflags = UIP_SYN_SENT;
|
||||
|
||||
conn->snd_nxt[0] = iss[0];
|
||||
|
|
@ -517,7 +517,7 @@ uip_connect(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
conn->rcv_nxt[3] = 0;
|
||||
|
||||
conn->initialmss = conn->mss = UIP_TCP_MSS;
|
||||
|
||||
|
||||
conn->len = 1; /* TCP length of the SYN is one. */
|
||||
conn->nrtx = 0;
|
||||
conn->timer = 1; /* Send the SYN next time around. */
|
||||
|
|
@ -527,7 +527,7 @@ uip_connect(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
conn->lport = uip_htons(lastport);
|
||||
conn->rport = rport;
|
||||
uip_ipaddr_copy(&conn->ripaddr, ripaddr);
|
||||
|
||||
|
||||
return conn;
|
||||
}
|
||||
#endif /* UIP_TCP && UIP_ACTIVE_OPEN */
|
||||
|
|
@ -538,14 +538,14 @@ remove_ext_hdr(void)
|
|||
/* Remove ext header before TCP/UDP processing. */
|
||||
if(uip_ext_len > 0) {
|
||||
PRINTF("Cutting ext-header before processing (extlen: %d, uiplen: %d)\n",
|
||||
uip_ext_len, uip_len);
|
||||
uip_ext_len, uip_len);
|
||||
if(uip_len < UIP_IPH_LEN + uip_ext_len) {
|
||||
PRINTF("ERROR: uip_len too short compared to ext len\n");
|
||||
uip_clear_buf();
|
||||
return;
|
||||
}
|
||||
memmove(((uint8_t *)UIP_TCP_BUF), (uint8_t *)UIP_TCP_BUF + uip_ext_len,
|
||||
uip_len - UIP_IPH_LEN - uip_ext_len);
|
||||
uip_len - UIP_IPH_LEN - uip_ext_len);
|
||||
|
||||
uip_len -= uip_ext_len;
|
||||
|
||||
|
|
@ -561,7 +561,7 @@ struct uip_udp_conn *
|
|||
uip_udp_new(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
||||
{
|
||||
register struct uip_udp_conn *conn;
|
||||
|
||||
|
||||
/* Find an unused local port. */
|
||||
again:
|
||||
++lastport;
|
||||
|
|
@ -569,7 +569,7 @@ uip_udp_new(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
if(lastport >= 32000) {
|
||||
lastport = 4096;
|
||||
}
|
||||
|
||||
|
||||
for(c = 0; c < UIP_UDP_CONNS; ++c) {
|
||||
if(uip_udp_conns[c].lport == uip_htons(lastport)) {
|
||||
goto again;
|
||||
|
|
@ -587,7 +587,7 @@ uip_udp_new(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
if(conn == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
conn->lport = UIP_HTONS(lastport);
|
||||
conn->rport = rport;
|
||||
if(ripaddr == NULL) {
|
||||
|
|
@ -596,7 +596,7 @@ uip_udp_new(const uip_ipaddr_t *ripaddr, uint16_t rport)
|
|||
uip_ipaddr_copy(&conn->ripaddr, ripaddr);
|
||||
}
|
||||
conn->ttl = uip_ds6_if.cur_hop_limit;
|
||||
|
||||
|
||||
return conn;
|
||||
}
|
||||
#endif /* UIP_UDP */
|
||||
|
|
@ -668,7 +668,7 @@ uip_reass(void)
|
|||
uint16_t offset=0;
|
||||
uint16_t len;
|
||||
uint16_t i;
|
||||
|
||||
|
||||
/* If ip_reasstmr is zero, no packet is present in the buffer */
|
||||
/* We first write the unfragmentable part of IP header into the reassembly
|
||||
buffer. The reset the other reassembly variables. */
|
||||
|
|
@ -710,9 +710,9 @@ uip_reass(void)
|
|||
PRINTF("dest ");
|
||||
PRINT6ADDR(&FBUF->destipaddr);
|
||||
PRINTF("next %d\n", UIP_IP_BUF->proto);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/* If the offset or the offset + fragment length overflows the
|
||||
reassembly buffer, we discard the entire packet. */
|
||||
if(offset > UIP_REASS_BUFSIZE ||
|
||||
|
|
@ -744,12 +744,12 @@ uip_reass(void)
|
|||
return uip_len;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Copy the fragment into the reassembly buffer, at the right
|
||||
offset. */
|
||||
memcpy((uint8_t *)FBUF + UIP_IPH_LEN + uip_ext_len + offset,
|
||||
(uint8_t *)UIP_FRAG_BUF + UIP_FRAGH_LEN, len);
|
||||
|
||||
|
||||
/* Update the bitmap. */
|
||||
if(offset >> 6 == (offset + len) >> 6) {
|
||||
uip_reassbitmap[offset >> 6] |=
|
||||
|
|
@ -760,18 +760,18 @@ uip_reass(void)
|
|||
bytes in the endpoints and fill the stuff inbetween with
|
||||
0xff. */
|
||||
uip_reassbitmap[offset >> 6] |= bitmap_bits[(offset >> 3) & 7];
|
||||
|
||||
|
||||
for(i = (1 + (offset >> 6)); i < ((offset + len) >> 6); ++i) {
|
||||
uip_reassbitmap[i] = 0xff;
|
||||
}
|
||||
uip_reassbitmap[(offset + len) >> 6] |=
|
||||
~bitmap_bits[((offset + len) >> 3) & 7];
|
||||
}
|
||||
|
||||
|
||||
/* Finally, we check if we have a full packet in the buffer. We do
|
||||
this by checking if we have the last fragment and if all bits
|
||||
in the bitmap are set. */
|
||||
|
||||
|
||||
if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
|
||||
/* Check all bytes up to and including all but the last byte in
|
||||
the bitmap. */
|
||||
|
|
@ -798,9 +798,9 @@ uip_reass(void)
|
|||
UIP_IP_BUF->len[1] = ((uip_reasslen - UIP_IPH_LEN) & 0xff);
|
||||
PRINTF("REASSEMBLED PAQUET %d (%d)\n", uip_reasslen,
|
||||
(UIP_IP_BUF->len[0] << 8) | UIP_IP_BUF->len[1]);
|
||||
|
||||
|
||||
return uip_reasslen;
|
||||
|
||||
|
||||
}
|
||||
} else {
|
||||
PRINTF("Already reassembling another paquet\n");
|
||||
|
|
@ -831,7 +831,7 @@ uip_reass_over(void)
|
|||
memcpy(UIP_IP_BUF, FBUF, UIP_IPH_LEN); /* copy the header for src
|
||||
and dest address*/
|
||||
uip_icmp6_error_output(ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_REASSEMBLY, 0);
|
||||
|
||||
|
||||
UIP_STAT(++uip_stat.ip.sent);
|
||||
uip_flags = 0;
|
||||
}
|
||||
|
|
@ -881,14 +881,14 @@ ext_hdr_options_process(void)
|
|||
uip_ext_opt_offset += UIP_EXT_HDR_OPT_PADN_BUF->opt_len + 2;
|
||||
break;
|
||||
case UIP_EXT_HDR_OPT_RPL:
|
||||
/* Fixes situation when a node that is not using RPL
|
||||
* joins a network which does. The received packages will include the
|
||||
* RPL header and processed by the "default" case of the switch
|
||||
* (0x63 & 0xC0 = 0x40). Hence, the packet is discarded as the header
|
||||
* is considered invalid.
|
||||
* Using this fix, the header is ignored, and the next header (if
|
||||
* present) is processed.
|
||||
*/
|
||||
/* Fixes situation when a node that is not using RPL
|
||||
* joins a network which does. The received packages will include the
|
||||
* RPL header and processed by the "default" case of the switch
|
||||
* (0x63 & 0xC0 = 0x40). Hence, the packet is discarded as the header
|
||||
* is considered invalid.
|
||||
* Using this fix, the header is ignored, and the next header (if
|
||||
* present) is processed.
|
||||
*/
|
||||
#if UIP_CONF_IPV6_RPL
|
||||
PRINTF("Processing RPL option\n");
|
||||
if(rpl_verify_header(uip_ext_opt_offset)) {
|
||||
|
|
@ -949,7 +949,7 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
#endif /* UIP_UDP */
|
||||
uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
|
||||
|
||||
|
||||
/* Check if we were invoked because of a poll request for a
|
||||
particular connection. */
|
||||
if(flag == UIP_POLL_REQUEST) {
|
||||
|
|
@ -974,7 +974,7 @@ uip_process(uint8_t flag)
|
|||
#if UIP_TCP
|
||||
uip_clear_buf();
|
||||
uip_slen = 0;
|
||||
|
||||
|
||||
/* Increase the initial sequence number. */
|
||||
if(++iss[3] == 0) {
|
||||
if(++iss[2] == 0) {
|
||||
|
|
@ -983,7 +983,7 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Check if the connection is in a state in which we simply wait
|
||||
* for the connection to time out. If so, we increase the
|
||||
|
|
@ -1009,7 +1009,7 @@ uip_process(uint8_t flag)
|
|||
uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
|
||||
uip_connr->nrtx == UIP_MAXSYNRTX)) {
|
||||
uip_connr->tcpstateflags = UIP_CLOSED;
|
||||
|
||||
|
||||
/*
|
||||
* We call UIP_APPCALL() with uip_flags set to
|
||||
* UIP_TIMEDOUT to inform the application that the
|
||||
|
|
@ -1017,18 +1017,18 @@ uip_process(uint8_t flag)
|
|||
*/
|
||||
uip_flags = UIP_TIMEDOUT;
|
||||
UIP_APPCALL();
|
||||
|
||||
|
||||
/* We also send a reset packet to the remote host. */
|
||||
UIP_TCP_BUF->flags = TCP_RST | TCP_ACK;
|
||||
goto tcp_send_nodata;
|
||||
}
|
||||
|
||||
|
||||
/* Exponential backoff. */
|
||||
uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
|
||||
4:
|
||||
uip_connr->nrtx);
|
||||
++(uip_connr->nrtx);
|
||||
|
||||
|
||||
/*
|
||||
* Ok, so we need to retransmit. We do this differently
|
||||
* depending on which state we are in. In ESTABLISHED, we
|
||||
|
|
@ -1042,14 +1042,14 @@ uip_process(uint8_t flag)
|
|||
case UIP_SYN_RCVD:
|
||||
/* In the SYN_RCVD state, we should retransmit our SYNACK. */
|
||||
goto tcp_send_synack;
|
||||
|
||||
|
||||
#if UIP_ACTIVE_OPEN
|
||||
case UIP_SYN_SENT:
|
||||
/* In the SYN_SENT state, we retransmit out SYN. */
|
||||
UIP_TCP_BUF->flags = 0;
|
||||
goto tcp_send_syn;
|
||||
#endif /* UIP_ACTIVE_OPEN */
|
||||
|
||||
|
||||
case UIP_ESTABLISHED:
|
||||
/*
|
||||
* In the ESTABLISHED state, we call upon the application
|
||||
|
|
@ -1060,7 +1060,7 @@ uip_process(uint8_t flag)
|
|||
uip_flags = UIP_REXMIT;
|
||||
UIP_APPCALL();
|
||||
goto apprexmit;
|
||||
|
||||
|
||||
case UIP_FIN_WAIT_1:
|
||||
case UIP_CLOSING:
|
||||
case UIP_LAST_ACK:
|
||||
|
|
@ -1096,12 +1096,12 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
#endif /* UIP_UDP */
|
||||
|
||||
|
||||
|
||||
/* This is where the input processing starts. */
|
||||
UIP_STAT(++uip_stat.ip.recv);
|
||||
|
||||
|
||||
/* Start of IP input header processing code. */
|
||||
|
||||
|
||||
/* Check validity of the IP header. */
|
||||
if((UIP_IP_BUF->vtc & 0xf0) != 0x60) { /* IP version and header length. */
|
||||
UIP_STAT(++uip_stat.ip.drop);
|
||||
|
|
@ -1117,7 +1117,7 @@ uip_process(uint8_t flag)
|
|||
* the packet has been padded and we set uip_len to the correct
|
||||
* value..
|
||||
*/
|
||||
|
||||
|
||||
if((UIP_IP_BUF->len[0] << 8) + UIP_IP_BUF->len[1] <= uip_len) {
|
||||
uip_len = (UIP_IP_BUF->len[0] << 8) + UIP_IP_BUF->len[1] + UIP_IPH_LEN;
|
||||
/*
|
||||
|
|
@ -1135,7 +1135,7 @@ uip_process(uint8_t flag)
|
|||
UIP_LOG("ip: packet shorter than reported in IP header.");
|
||||
goto drop;
|
||||
}
|
||||
|
||||
|
||||
PRINTF("IPv6 packet received from ");
|
||||
PRINT6ADDR(&UIP_IP_BUF->srcipaddr);
|
||||
PRINTF(" to ");
|
||||
|
|
@ -1168,11 +1168,11 @@ uip_process(uint8_t flag)
|
|||
uip_ext_len += (UIP_EXT_BUF->len << 3) + 8;
|
||||
break;
|
||||
case 1:
|
||||
PRINTF("Dropping packet after extension header processing\n");
|
||||
PRINTF("Dropping packet after extension header processing\n");
|
||||
/* silently discard */
|
||||
goto drop;
|
||||
case 2:
|
||||
PRINTF("Sending error message after extension header processing\n");
|
||||
PRINTF("Sending error message after extension header processing\n");
|
||||
/* send icmp error message (created in ext_hdr_options_process)
|
||||
* and discard*/
|
||||
goto send;
|
||||
|
|
@ -1417,7 +1417,7 @@ uip_process(uint8_t flag)
|
|||
UIP_LOG("ip6: unrecognized header");
|
||||
goto send;
|
||||
/* End of headers processing */
|
||||
|
||||
|
||||
icmp6_input:
|
||||
/* This is IPv6 ICMPv6 processing code. */
|
||||
PRINTF("icmp6_input: length %d type: %d \n", uip_len, UIP_ICMP_BUF->type);
|
||||
|
|
@ -1459,14 +1459,14 @@ uip_process(uint8_t flag)
|
|||
UIP_LOG("icmp6: unknown ICMPv6 message.");
|
||||
uip_clear_buf();
|
||||
}
|
||||
|
||||
|
||||
if(uip_len > 0) {
|
||||
goto send;
|
||||
} else {
|
||||
goto drop;
|
||||
}
|
||||
/* End of IPv6 ICMP processing. */
|
||||
|
||||
|
||||
|
||||
#if UIP_UDP
|
||||
/* UDP input processing. */
|
||||
|
|
@ -1475,7 +1475,7 @@ uip_process(uint8_t flag)
|
|||
remove_ext_hdr();
|
||||
|
||||
PRINTF("Receiving UDP packet\n");
|
||||
|
||||
|
||||
/* UDP processing is really just a hack. We don't do anything to the
|
||||
UDP/IP headers, but let the UDP application do all the hard
|
||||
work. If the application sets uip_slen, it has a packet to
|
||||
|
|
@ -1538,7 +1538,7 @@ uip_process(uint8_t flag)
|
|||
udp_found:
|
||||
PRINTF("In udp_found\n");
|
||||
UIP_STAT(++uip_stat.udp.recv);
|
||||
|
||||
|
||||
uip_conn = NULL;
|
||||
uip_flags = UIP_NEWDATA;
|
||||
uip_sappdata = uip_appdata = &uip_buf[UIP_IPUDPH_LEN + UIP_LLH_LEN];
|
||||
|
|
@ -1597,7 +1597,7 @@ uip_process(uint8_t flag)
|
|||
UIP_STAT(++uip_stat.tcp.recv);
|
||||
PRINTF("Receiving TCP packet\n");
|
||||
/* Start of TCP input header processing code. */
|
||||
|
||||
|
||||
if(uip_tcpchksum() != 0xffff) { /* Compute and check the TCP
|
||||
checksum. */
|
||||
UIP_STAT(++uip_stat.tcp.drop);
|
||||
|
|
@ -1632,7 +1632,7 @@ uip_process(uint8_t flag)
|
|||
if((UIP_TCP_BUF->flags & TCP_CTL) != TCP_SYN) {
|
||||
goto reset;
|
||||
}
|
||||
|
||||
|
||||
tmp16 = UIP_TCP_BUF->destport;
|
||||
/* Next, check listening connections. */
|
||||
for(c = 0; c < UIP_LISTENPORTS; ++c) {
|
||||
|
|
@ -1640,7 +1640,7 @@ uip_process(uint8_t flag)
|
|||
goto found_listen;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* No matching connection found, so we send a RST packet. */
|
||||
UIP_STAT(++uip_stat.tcp.synrst);
|
||||
|
||||
|
|
@ -1652,7 +1652,7 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
|
||||
UIP_STAT(++uip_stat.tcp.rst);
|
||||
|
||||
|
||||
UIP_TCP_BUF->flags = TCP_RST | TCP_ACK;
|
||||
uip_len = UIP_IPTCPH_LEN;
|
||||
UIP_TCP_BUF->tcpoffset = 5 << 4;
|
||||
|
|
@ -1661,15 +1661,15 @@ uip_process(uint8_t flag)
|
|||
c = UIP_TCP_BUF->seqno[3];
|
||||
UIP_TCP_BUF->seqno[3] = UIP_TCP_BUF->ackno[3];
|
||||
UIP_TCP_BUF->ackno[3] = c;
|
||||
|
||||
|
||||
c = UIP_TCP_BUF->seqno[2];
|
||||
UIP_TCP_BUF->seqno[2] = UIP_TCP_BUF->ackno[2];
|
||||
UIP_TCP_BUF->ackno[2] = c;
|
||||
|
||||
|
||||
c = UIP_TCP_BUF->seqno[1];
|
||||
UIP_TCP_BUF->seqno[1] = UIP_TCP_BUF->ackno[1];
|
||||
UIP_TCP_BUF->ackno[1] = c;
|
||||
|
||||
|
||||
c = UIP_TCP_BUF->seqno[0];
|
||||
UIP_TCP_BUF->seqno[0] = UIP_TCP_BUF->ackno[0];
|
||||
UIP_TCP_BUF->ackno[0] = c;
|
||||
|
|
@ -1684,12 +1684,12 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Swap port numbers. */
|
||||
tmp16 = UIP_TCP_BUF->srcport;
|
||||
UIP_TCP_BUF->srcport = UIP_TCP_BUF->destport;
|
||||
UIP_TCP_BUF->destport = tmp16;
|
||||
|
||||
|
||||
/* Swap IP addresses. */
|
||||
uip_ipaddr_copy(&UIP_IP_BUF->destipaddr, &UIP_IP_BUF->srcipaddr);
|
||||
uip_ds6_select_src(&UIP_IP_BUF->srcipaddr, &UIP_IP_BUF->destipaddr);
|
||||
|
|
@ -1730,7 +1730,7 @@ uip_process(uint8_t flag)
|
|||
goto drop;
|
||||
}
|
||||
uip_conn = uip_connr;
|
||||
|
||||
|
||||
/* Fill in the necessary fields for the new connection. */
|
||||
uip_connr->rto = uip_connr->timer = UIP_RTO;
|
||||
uip_connr->sa = 0;
|
||||
|
|
@ -1771,7 +1771,7 @@ uip_process(uint8_t flag)
|
|||
(uint16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
|
||||
uip_connr->initialmss = uip_connr->mss =
|
||||
tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
|
||||
|
||||
|
||||
/* And we are done processing options. */
|
||||
break;
|
||||
} else {
|
||||
|
|
@ -1786,19 +1786,19 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Our response will be a SYNACK. */
|
||||
#if UIP_ACTIVE_OPEN
|
||||
tcp_send_synack:
|
||||
UIP_TCP_BUF->flags = TCP_ACK;
|
||||
|
||||
|
||||
tcp_send_syn:
|
||||
UIP_TCP_BUF->flags |= TCP_SYN;
|
||||
#else /* UIP_ACTIVE_OPEN */
|
||||
tcp_send_synack:
|
||||
UIP_TCP_BUF->flags = TCP_SYN | TCP_ACK;
|
||||
#endif /* UIP_ACTIVE_OPEN */
|
||||
|
||||
|
||||
/* We send out the TCP Maximum Segment Size option with our
|
||||
SYNACK. */
|
||||
UIP_TCP_BUF->optdata[0] = TCP_OPT_MSS;
|
||||
|
|
@ -1839,9 +1839,9 @@ uip_process(uint8_t flag)
|
|||
receive a SYN, in which case we should retransmit our SYNACK
|
||||
(which is done futher down). */
|
||||
if(!((((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
|
||||
((UIP_TCP_BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))) ||
|
||||
((UIP_TCP_BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK))) ||
|
||||
(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_RCVD) &&
|
||||
((UIP_TCP_BUF->flags & TCP_CTL) == TCP_SYN)))) {
|
||||
((UIP_TCP_BUF->flags & TCP_CTL) == TCP_SYN)))) {
|
||||
if((uip_len > 0 || ((UIP_TCP_BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
|
||||
(UIP_TCP_BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
|
||||
UIP_TCP_BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
|
||||
|
|
@ -1875,7 +1875,7 @@ uip_process(uint8_t flag)
|
|||
uip_connr->snd_nxt[1] = uip_acc32[1];
|
||||
uip_connr->snd_nxt[2] = uip_acc32[2];
|
||||
uip_connr->snd_nxt[3] = uip_acc32[3];
|
||||
|
||||
|
||||
/* Do RTT estimation, unless we have done retransmissions. */
|
||||
if(uip_connr->nrtx == 0) {
|
||||
signed char m;
|
||||
|
|
@ -1899,7 +1899,7 @@ uip_process(uint8_t flag)
|
|||
/* Reset length of outstanding data. */
|
||||
uip_connr->len = 0;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
/* Do different things depending on in what state the connection is. */
|
||||
|
|
@ -1927,7 +1927,7 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
/* We need to retransmit the SYNACK */
|
||||
if((UIP_TCP_BUF->flags & TCP_CTL) == TCP_SYN) {
|
||||
goto tcp_send_synack;
|
||||
goto tcp_send_synack;
|
||||
}
|
||||
goto drop;
|
||||
#if UIP_ACTIVE_OPEN
|
||||
|
|
@ -1991,7 +1991,7 @@ uip_process(uint8_t flag)
|
|||
uip_conn->tcpstateflags = UIP_CLOSED;
|
||||
goto reset;
|
||||
#endif /* UIP_ACTIVE_OPEN */
|
||||
|
||||
|
||||
case UIP_ESTABLISHED:
|
||||
/* In the ESTABLISHED state, we call upon the application to feed
|
||||
data into the uip_buf. If the UIP_ACKDATA flag is set, the
|
||||
|
|
@ -2093,7 +2093,7 @@ uip_process(uint8_t flag)
|
|||
UIP_APPCALL();
|
||||
|
||||
appsend:
|
||||
|
||||
|
||||
if(uip_flags & UIP_ABORT) {
|
||||
uip_slen = 0;
|
||||
uip_connr->tcpstateflags = UIP_CLOSED;
|
||||
|
|
@ -2145,7 +2145,7 @@ uip_process(uint8_t flag)
|
|||
uip_connr->nrtx = 0;
|
||||
apprexmit:
|
||||
uip_appdata = uip_sappdata;
|
||||
|
||||
|
||||
/* If the application has data to be sent, or if the incoming
|
||||
packet had new data in it, we must send out a packet. */
|
||||
if(uip_slen > 0 && uip_connr->len > 0) {
|
||||
|
|
@ -2174,7 +2174,7 @@ uip_process(uint8_t flag)
|
|||
UIP_APPCALL();
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case UIP_FIN_WAIT_1:
|
||||
/* The application has closed the connection, but the remote host
|
||||
hasn't closed its end yet. Thus we do nothing but wait for a
|
||||
|
|
@ -2203,7 +2203,7 @@ uip_process(uint8_t flag)
|
|||
goto tcp_send_ack;
|
||||
}
|
||||
goto drop;
|
||||
|
||||
|
||||
case UIP_FIN_WAIT_2:
|
||||
if(uip_len > 0) {
|
||||
uip_add_rcv_nxt(uip_len);
|
||||
|
|
@ -2223,7 +2223,7 @@ uip_process(uint8_t flag)
|
|||
|
||||
case UIP_TIME_WAIT:
|
||||
goto tcp_send_ack;
|
||||
|
||||
|
||||
case UIP_CLOSING:
|
||||
if(uip_flags & UIP_ACKDATA) {
|
||||
uip_connr->tcpstateflags = UIP_TIME_WAIT;
|
||||
|
|
@ -2231,7 +2231,7 @@ uip_process(uint8_t flag)
|
|||
}
|
||||
}
|
||||
goto drop;
|
||||
|
||||
|
||||
/* We jump here when we are ready to send the packet, and just want
|
||||
to set the appropriate TCP sequence numbers in the TCP header. */
|
||||
tcp_send_ack:
|
||||
|
|
@ -2249,12 +2249,12 @@ uip_process(uint8_t flag)
|
|||
packet. */
|
||||
tcp_send:
|
||||
PRINTF("In tcp_send\n");
|
||||
|
||||
|
||||
UIP_TCP_BUF->ackno[0] = uip_connr->rcv_nxt[0];
|
||||
UIP_TCP_BUF->ackno[1] = uip_connr->rcv_nxt[1];
|
||||
UIP_TCP_BUF->ackno[2] = uip_connr->rcv_nxt[2];
|
||||
UIP_TCP_BUF->ackno[3] = uip_connr->rcv_nxt[3];
|
||||
|
||||
|
||||
UIP_TCP_BUF->seqno[0] = uip_connr->snd_nxt[0];
|
||||
UIP_TCP_BUF->seqno[1] = uip_connr->snd_nxt[1];
|
||||
UIP_TCP_BUF->seqno[2] = uip_connr->snd_nxt[2];
|
||||
|
|
@ -2288,7 +2288,7 @@ uip_process(uint8_t flag)
|
|||
UIP_IP_BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
|
||||
|
||||
UIP_TCP_BUF->urgp[0] = UIP_TCP_BUF->urgp[1] = 0;
|
||||
|
||||
|
||||
/* Calculate TCP checksum. */
|
||||
UIP_TCP_BUF->tcpchksum = 0;
|
||||
UIP_TCP_BUF->tcpchksum = ~(uip_tcpchksum());
|
||||
|
|
@ -2304,7 +2304,7 @@ uip_process(uint8_t flag)
|
|||
send:
|
||||
PRINTF("Sending packet with length %d (%d)\n", uip_len,
|
||||
(UIP_IP_BUF->len[0] << 8) | UIP_IP_BUF->len[1]);
|
||||
|
||||
|
||||
UIP_STAT(++uip_stat.ip.sent);
|
||||
/* Return and let the caller do the actual transmission. */
|
||||
uip_flags = 0;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -49,7 +49,7 @@
|
|||
#define RADIO_SPI_CLK_FREQ 4000000 // 4 MHz SPI CLK for radio interface
|
||||
#define SYSTEM_UCLK 16000000 // 16 MHz UCLK
|
||||
// Default Radio Parameters
|
||||
#define DEFAULT_CHNL_FREQ 915000000
|
||||
#define DEFAULT_CHNL_FREQ 915000000
|
||||
#define FREQ_CNVRT_VAL 0.00252061538
|
||||
// Defines for radio memory mapped areas
|
||||
#define PACKETRAM_START 0x10
|
||||
|
|
@ -68,14 +68,14 @@
|
|||
#define MCR_rssi_readback_Adr 0x312
|
||||
#define MCR_gpio_configure_Adr 0x3fa
|
||||
#define MCR_ext_uc_clk_divide_Adr 0x32e
|
||||
#define MCR_interrupt_source_0_Adr 0x336
|
||||
#define MCR_interrupt_source_0_Adr 0x336
|
||||
#define MCR_interrupt_source_1_Adr 0x337
|
||||
|
||||
// Macros for manual GPIO checking of Radio MISO pin P2.0 (SPI0)
|
||||
#define RADIO_MISO_IN GP2IN_IN0_BBA
|
||||
#define RADIO_MISO_IN GP2IN_IN0_BBA
|
||||
// Macros for manual GPIO control of P2.3 (Radio SPI CS) (SPI0)
|
||||
#define RADIO_CSN_DEASSERT (pADI_GP2->GPSET = GP2SET_SET3)
|
||||
#define RADIO_CSN_ASSERT (pADI_GP2->GPCLR = GP2CLR_CLR3)
|
||||
#define RADIO_CSN_DEASSERT (pADI_GP2->GPSET = GP2SET_SET3)
|
||||
#define RADIO_CSN_ASSERT (pADI_GP2->GPCLR = GP2CLR_CLR3)
|
||||
// Macros for Sending\Receiving single bytes via SPI
|
||||
#define SEND_SPI(x) pADI_SPI0->SPITX = x
|
||||
#define WAIT_SPI_RX while((pADI_SPI0->SPISTA & SPISTA_RXFSTA_MSK) == 0x0);
|
||||
|
|
@ -92,7 +92,7 @@
|
|||
/*************************************************************************/
|
||||
/* Radio Command Codes */
|
||||
/*************************************************************************/
|
||||
typedef enum
|
||||
typedef enum
|
||||
{
|
||||
CMD_SYNC = 0xA2, // Synchronizatio
|
||||
CMD_PHY_OFF = 0xB0, // Transition to state PHY_OFF
|
||||
|
|
@ -137,54 +137,54 @@ typedef enum
|
|||
/*************************************************************************/
|
||||
/* Radio Configuration Structure */
|
||||
/*************************************************************************/
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\var TyRadioConfiguration
|
||||
**/
|
||||
typedef struct
|
||||
{
|
||||
RIE_U8 interrupt_mask_0_r; // 0x100
|
||||
RIE_U8 cfg_101_r; // 0x101
|
||||
RIE_U8 cfg_102_r; // 0x102
|
||||
RIE_U8 cfg_103_r; // 0x103
|
||||
RIE_U8 cfg_104_r; // 0x104
|
||||
RIE_U8 cfg_105_r; // 0x105
|
||||
RIE_U8 cfg_106_r; // 0x106
|
||||
RIE_U8 cfg_107_r; // 0x107
|
||||
RIE_U8 cfg_108_r; // 0x108
|
||||
RIE_U8 channel_freq_0_r; // 0x109
|
||||
RIE_U8 channel_freq_1_r; // 0x10A
|
||||
RIE_U8 channel_freq_2_r; // 0x10B
|
||||
RIE_U8 cfg_10C_r; // 0x10C
|
||||
RIE_U8 cfg_10D_r; // 0x10D
|
||||
RIE_U8 cfg_10E_r; // 0x10E
|
||||
RIE_U8 cfg_10F_r; // 0x10F
|
||||
RIE_U8 cfg_110_r; // 0x110
|
||||
RIE_U8 cfg_111_r; // 0x111
|
||||
RIE_U8 cfg_112_r; // 0x112
|
||||
RIE_U8 cfg_113_r; // 0x113
|
||||
RIE_U8 radio_cfg_8_r; // 0x114
|
||||
RIE_U8 radio_cfg_9_r; // 0x115
|
||||
RIE_U8 cfg_116_r; // 0x116
|
||||
RIE_U8 cfg_117_r; // 0x117
|
||||
RIE_U8 image_reject_cal_phase_r; // 0x118
|
||||
RIE_U8 image_reject_cal_amplitude_r; // 0x119
|
||||
RIE_U8 cfg_11A_r; // 0x11A
|
||||
RIE_U8 cfg_11B_r; // 0x11B
|
||||
RIE_U8 symbol_mode_r; // 0x11C
|
||||
RIE_U8 cfg_11D_r; // 0x11D
|
||||
RIE_U8 cfg_11E_r; // 0x11E
|
||||
RIE_U8 cfg_11F_r; // 0x11F
|
||||
RIE_U8 cfg_120_r; // 0x120
|
||||
RIE_U8 cfg_121_r; // 0x121
|
||||
RIE_U8 cfg_122_r; // 0x122
|
||||
RIE_U8 cfg_123_r; // 0x123
|
||||
RIE_U8 tx_base_adr_r; // 0x124
|
||||
RIE_U8 rx_base_adr_r; // 0x125
|
||||
RIE_U8 packet_length_control_r; // 0x126
|
||||
RIE_U8 packet_length_max_r; // 0x127
|
||||
RIE_U8 cfg_128_r; // 0x128
|
||||
RIE_U8 cfg_129_r; // 0x129
|
||||
RIE_U8 interrupt_mask_0_r; // 0x100
|
||||
RIE_U8 cfg_101_r; // 0x101
|
||||
RIE_U8 cfg_102_r; // 0x102
|
||||
RIE_U8 cfg_103_r; // 0x103
|
||||
RIE_U8 cfg_104_r; // 0x104
|
||||
RIE_U8 cfg_105_r; // 0x105
|
||||
RIE_U8 cfg_106_r; // 0x106
|
||||
RIE_U8 cfg_107_r; // 0x107
|
||||
RIE_U8 cfg_108_r; // 0x108
|
||||
RIE_U8 channel_freq_0_r; // 0x109
|
||||
RIE_U8 channel_freq_1_r; // 0x10A
|
||||
RIE_U8 channel_freq_2_r; // 0x10B
|
||||
RIE_U8 cfg_10C_r; // 0x10C
|
||||
RIE_U8 cfg_10D_r; // 0x10D
|
||||
RIE_U8 cfg_10E_r; // 0x10E
|
||||
RIE_U8 cfg_10F_r; // 0x10F
|
||||
RIE_U8 cfg_110_r; // 0x110
|
||||
RIE_U8 cfg_111_r; // 0x111
|
||||
RIE_U8 cfg_112_r; // 0x112
|
||||
RIE_U8 cfg_113_r; // 0x113
|
||||
RIE_U8 radio_cfg_8_r; // 0x114
|
||||
RIE_U8 radio_cfg_9_r; // 0x115
|
||||
RIE_U8 cfg_116_r; // 0x116
|
||||
RIE_U8 cfg_117_r; // 0x117
|
||||
RIE_U8 image_reject_cal_phase_r; // 0x118
|
||||
RIE_U8 image_reject_cal_amplitude_r; // 0x119
|
||||
RIE_U8 cfg_11A_r; // 0x11A
|
||||
RIE_U8 cfg_11B_r; // 0x11B
|
||||
RIE_U8 symbol_mode_r; // 0x11C
|
||||
RIE_U8 cfg_11D_r; // 0x11D
|
||||
RIE_U8 cfg_11E_r; // 0x11E
|
||||
RIE_U8 cfg_11F_r; // 0x11F
|
||||
RIE_U8 cfg_120_r; // 0x120
|
||||
RIE_U8 cfg_121_r; // 0x121
|
||||
RIE_U8 cfg_122_r; // 0x122
|
||||
RIE_U8 cfg_123_r; // 0x123
|
||||
RIE_U8 tx_base_adr_r; // 0x124
|
||||
RIE_U8 rx_base_adr_r; // 0x125
|
||||
RIE_U8 packet_length_control_r; // 0x126
|
||||
RIE_U8 packet_length_max_r; // 0x127
|
||||
RIE_U8 cfg_128_r; // 0x128
|
||||
RIE_U8 cfg_129_r; // 0x129
|
||||
RIE_U8 cfg_12A_r; // 0x12A
|
||||
RIE_U8 cfg_12B_r; // 0x12B
|
||||
RIE_U8 cfg_12C_r; // 0x12C
|
||||
|
|
@ -205,14 +205,14 @@ typedef struct
|
|||
RIE_U8 cfg_13B_r; // 0x13B
|
||||
RIE_U8 cfg_13C_r; // 0x13C
|
||||
RIE_U8 cfg_13D_r; // 0x13D
|
||||
RIE_U8 cfg_13E_r; // 0x13E
|
||||
RIE_U8 cfg_13F_r; // 0x13F
|
||||
RIE_U8 cfg_13E_r; // 0x13E
|
||||
RIE_U8 cfg_13F_r; // 0x13F
|
||||
} TyRadioConfiguration;
|
||||
/*************************************************************************/
|
||||
/* Radio Configuration Constants */
|
||||
/*************************************************************************/
|
||||
#define interrupt_mask_0_interrupt_tx_eof (0x1 << 4)
|
||||
#define interrupt_mask_0_interrupt_crc_correct (0x1 << 2)
|
||||
#define interrupt_mask_0_interrupt_tx_eof (0x1 << 4)
|
||||
#define interrupt_mask_0_interrupt_crc_correct (0x1 << 2)
|
||||
|
||||
#define packet_length_control_length_offset_offset (0)
|
||||
#define packet_length_control_length_offset_minus0 (0x4 << packet_length_control_length_offset_offset)
|
||||
|
|
@ -237,7 +237,7 @@ typedef struct
|
|||
#define radio_cfg_8_pa_power_setting_63 (0xF << radio_cfg_8_pa_power_offset)
|
||||
#define radio_cfg_8_pa_ramp_numbits (3)
|
||||
#define radio_cfg_8_pa_ramp_offset (0)
|
||||
#define radio_cfg_8_pa_ramp_16 (0x5 << radio_cfg_8_pa_ramp_offset)
|
||||
#define radio_cfg_8_pa_ramp_16 (0x5 << radio_cfg_8_pa_ramp_offset)
|
||||
|
||||
#define radio_cfg_9_demod_scheme_offset (0)
|
||||
#define radio_cfg_9_demod_scheme_FSK (0x0 << radio_cfg_9_demod_scheme_offset)
|
||||
|
|
@ -256,13 +256,13 @@ typedef struct
|
|||
/* Local Variables */
|
||||
/*************************************************************************/
|
||||
static TyRadioConfiguration RadioConfiguration;
|
||||
static RIE_BOOL bRadioConfigurationChanged = RIE_FALSE;
|
||||
static RIE_BOOL bTestModeEnabled = RIE_FALSE;
|
||||
static RIE_U32 DataRate = 38400;
|
||||
static RIE_BOOL bRadioConfigurationChanged = RIE_FALSE;
|
||||
static RIE_BOOL bTestModeEnabled = RIE_FALSE;
|
||||
static RIE_U32 DataRate = 38400;
|
||||
static volatile RIE_BOOL bPacketTx = RIE_FALSE;
|
||||
static volatile RIE_BOOL bPacketRx = RIE_FALSE;
|
||||
|
||||
const RIE_U8 DR_38_4kbps_Dev20kHz_Configuration[] =
|
||||
const RIE_U8 DR_38_4kbps_Dev20kHz_Configuration[] =
|
||||
{
|
||||
0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
|
||||
|
||||
|
|
@ -272,11 +272,11 @@ const RIE_U8 DR_38_4kbps_Dev20kHz_Configuration[] =
|
|||
|
||||
0x40,0x0C,0x00,0x0C,0x00,0x00,
|
||||
0x10,0x00,0xC3,0x36,0x10,0x10,0x24,0xF0,0x2A,0x00,0x2F,0x19,0x5E,0x46,0x5F,0x78,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
|
||||
};
|
||||
|
||||
|
||||
const RIE_U8 DR_300_0kbps_Dev75_0kHz_Configuration[] =
|
||||
const RIE_U8 DR_300_0kbps_Dev75_0kHz_Configuration[] =
|
||||
{
|
||||
0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
|
||||
|
||||
|
|
@ -291,7 +291,7 @@ const RIE_U8 DR_300_0kbps_Dev75_0kHz_Configuration[] =
|
|||
|
||||
|
||||
|
||||
const RIE_U8 DR_1_0kbps_Dev10_0kHz_Configuration[] =
|
||||
const RIE_U8 DR_1_0kbps_Dev10_0kHz_Configuration[] =
|
||||
{
|
||||
0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
|
||||
// 0 1 2 3 4 5 6 7 8 9 A B
|
||||
|
|
@ -312,8 +312,8 @@ static RIE_Responses RadioSendCommandBytes (RIE_U8 * pCmdBytes,
|
|||
RIE_U8 NumBytes);
|
||||
static RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode);
|
||||
static RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode);
|
||||
static RIE_Responses RadioMMapRead (RIE_U32 ulAdr,
|
||||
RIE_U32 ulLen,
|
||||
static RIE_Responses RadioMMapRead (RIE_U32 ulAdr,
|
||||
RIE_U32 ulLen,
|
||||
RIE_U8 * pData);
|
||||
static RIE_Responses RadioMMapWrite (RIE_U32 ulAdr,
|
||||
RIE_U32 ulLen,
|
||||
|
|
@ -337,7 +337,7 @@ static RIE_Responses RadioWaitOnCmdLdr (void);
|
|||
@brief Return the Radio Interface Engine API Version
|
||||
@param pVersion :{}
|
||||
pVersion Storage for Radio Interface Engine API version.
|
||||
@code
|
||||
@code
|
||||
RIE_U32 Version;
|
||||
Response = RadioGetAPIVersion(&Version);
|
||||
@endcode
|
||||
|
|
@ -361,8 +361,8 @@ RIE_Responses RadioGetAPIVersion(RIE_U32 *pVersion)
|
|||
- DR_1_0kbps_Dev10_0kHz Base configuration of 1 kbps datarate, 10.0 kHz frequency deviation.
|
||||
- DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
|
||||
- DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
|
||||
@pre
|
||||
RadioInit() must be called before this function is called.
|
||||
@pre
|
||||
RadioInit() must be called before this function is called.
|
||||
@return RIE_Responses Error code.
|
||||
**/
|
||||
|
||||
|
|
@ -388,7 +388,7 @@ RIE_Responses RadioSwitchConfig(RIE_BaseConfigs BaseConfig)
|
|||
- DR_1_0kbps_Dev10_0kHz Base configuration of 1 kbps datarate, 10.0 kHz frequency deviation.
|
||||
- DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
|
||||
- DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
|
||||
@note
|
||||
@note
|
||||
This must be called before any other function is called.
|
||||
@return RIE_Responses Error code.
|
||||
**/
|
||||
|
|
@ -401,13 +401,13 @@ RIE_Responses RadioInit(RIE_BaseConfigs BaseConfig)
|
|||
NVIC_DisableIRQ(UHFTRX_IRQn);
|
||||
|
||||
// Initialise GPIO Port 2 for Radio Use
|
||||
pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
|
||||
GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
|
||||
pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
|
||||
GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
|
||||
GP2CON_CON4_IRQ8 | GP2CON_CON5_GPIO |
|
||||
GP2CON_CON6_GPIO | GP2CON_CON7_GPIOIRQ7;
|
||||
|
||||
pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
|
||||
GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
|
||||
pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
|
||||
GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
|
||||
GP2OEN_OEN4_IN | GP2OEN_OEN5_IN |
|
||||
GP2OEN_OEN6_IN | GP2OEN_OEN7_IN;
|
||||
|
||||
|
|
@ -435,8 +435,8 @@ RIE_Responses RadioInit(RIE_BaseConfigs BaseConfig)
|
|||
// we enable the Cortex interrupt handling of it
|
||||
if(Response == RIE_Success)
|
||||
Response = RadioPowerOff();
|
||||
// Configure a "high level" radio interrupt ...
|
||||
pADI_INTERRUPT->EI2CFG = EI2CFG_IRQ8MDE_HIGHLEVEL | EI2CFG_IRQ8EN;
|
||||
// Configure a "high level" radio interrupt ...
|
||||
pADI_INTERRUPT->EI2CFG = EI2CFG_IRQ8MDE_HIGHLEVEL | EI2CFG_IRQ8EN;
|
||||
// ... and set it up in the NVIC so that our interrupt handler is called
|
||||
// when the radio wants our attention. Clear any pre-existing condition
|
||||
// before enabling the interrupt.
|
||||
|
|
@ -463,7 +463,7 @@ RIE_Responses RadioInit(RIE_BaseConfigs BaseConfig)
|
|||
/**
|
||||
@fn RIE_U32 RadioDeInit(void)
|
||||
@brief Deinitialise the Radio, and power it down.
|
||||
@note
|
||||
@note
|
||||
This can be called independently of all other functions to power down
|
||||
the radio
|
||||
@return RIE_Responses Error code.
|
||||
|
|
@ -477,13 +477,13 @@ RIE_Responses RadioDeInit(void)
|
|||
NVIC_DisableIRQ(UHFTRX_IRQn);
|
||||
|
||||
// Initialise GPIO Port 2 for Radio Use
|
||||
pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
|
||||
GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
|
||||
pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
|
||||
GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
|
||||
GP2CON_CON4_IRQ8 | GP2CON_CON5_GPIO |
|
||||
GP2CON_CON6_GPIO | GP2CON_CON7_GPIOIRQ7;
|
||||
|
||||
pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
|
||||
GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
|
||||
pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
|
||||
GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
|
||||
GP2OEN_OEN4_IN | GP2OEN_OEN5_IN |
|
||||
GP2OEN_OEN6_IN | GP2OEN_OEN7_IN;
|
||||
|
||||
|
|
@ -512,8 +512,8 @@ RIE_Responses RadioDeInit(void)
|
|||
|
||||
/**
|
||||
@fn RIE_Responses RadioPowerOff(void)
|
||||
@brief Shutdown the radio and place it in its lowest power sleep mode.
|
||||
@pre
|
||||
@brief Shutdown the radio and place it in its lowest power sleep mode.
|
||||
@pre
|
||||
RadioInit() must be called before this function is called.
|
||||
@return RIE_Response Error code.
|
||||
**/
|
||||
|
|
@ -532,14 +532,14 @@ RIE_Responses RadioPowerOff(void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioTerminateRadioOp(void)
|
||||
@brief Terminate a currently running radio RX or TX operation.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioRxPacketFixedLen(12);
|
||||
// Delay for a while waiting for a packet
|
||||
// Delay for a while waiting for a packet
|
||||
if (RIE_Response == RIE_Success)
|
||||
{
|
||||
// Abort the waiting
|
||||
|
|
@ -557,15 +557,15 @@ RIE_Responses RadioTerminateRadioOp (void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
|
||||
@brief Set frequency for radio communications
|
||||
@param Frequency :{431000000-928000000}
|
||||
- This must be within the available bands of the radio:
|
||||
- 431000000Hz to 464000000Hz and
|
||||
@param Frequency :{431000000-928000000}
|
||||
- This must be within the available bands of the radio:
|
||||
- 431000000Hz to 464000000Hz and
|
||||
- 862000000Hz to 928000000Hz.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioSetFrequency(915000000);
|
||||
@endcode
|
||||
|
|
@ -584,18 +584,18 @@ RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
|
|||
RadioConfiguration.channel_freq_2_r = (EncodedFrequency >> 16)& 0xFF;
|
||||
if (Frequency >= 862000000)
|
||||
{
|
||||
RadioConfiguration.image_reject_cal_amplitude_r = 0x07;
|
||||
RadioConfiguration.image_reject_cal_amplitude_r = 0x07;
|
||||
RadioConfiguration.image_reject_cal_phase_r = 0x16;
|
||||
}
|
||||
else
|
||||
{
|
||||
RadioConfiguration.image_reject_cal_amplitude_r = 0x03;
|
||||
RadioConfiguration.image_reject_cal_amplitude_r = 0x03;
|
||||
RadioConfiguration.image_reject_cal_phase_r = 0x08;
|
||||
}
|
||||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioSetModulationType(RIE_ModulationTypes ModulationType)
|
||||
@brief Set the Radio Transmitter Modulation Type. Can be FSK_Modulation or GFSK_Modulation.
|
||||
@param ModulationType :{DR_1_0kbps_Dev10_0kHz , DR_38_4kbps_Dev20kHz ,DR_300_0kbps_Dev75_0kHz }
|
||||
|
|
@ -603,7 +603,7 @@ RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
|
|||
- DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
|
||||
- DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioSetModulationType(GFSK_Modulation);
|
||||
@endcode
|
||||
@note FSK_Modulation is used by default.
|
||||
|
|
@ -636,31 +636,31 @@ RIE_Responses RadioSetModulationType(RIE_ModulationTypes ModulationType)
|
|||
if (ucNewRegVal != RadioConfiguration.radio_cfg_9_r )
|
||||
{
|
||||
bRadioConfigurationChanged = RIE_TRUE;
|
||||
RadioConfiguration.radio_cfg_9_r = ucNewRegVal;
|
||||
RadioConfiguration.radio_cfg_9_r = ucNewRegVal;
|
||||
}
|
||||
|
||||
}
|
||||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
|
||||
/**
|
||||
@fn RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
|
||||
@brief Enable or Disable Manchester Encoding of payload data.
|
||||
|
||||
Manchester encoding can be used to ensure a dc-free (zero mean)
|
||||
transmission.
|
||||
Manchester encoding can be used to ensure a dc-free (zero mean)
|
||||
transmission.
|
||||
|
||||
A Binary 0 is mapped to 10, and a Binary 1 is mapped to 01.
|
||||
A Binary 0 is mapped to 10, and a Binary 1 is mapped to 01.
|
||||
|
||||
Manchester encoding and decoding are applied to the payload data
|
||||
and the CRC.
|
||||
|
||||
Manchester encoding and decoding are applied to the payload data
|
||||
and the CRC.
|
||||
|
||||
@param bEnable :{RIE_FALSE,RIE_TRUE}
|
||||
- RIE_TRUE if Manchester Encoding is to be enabled.
|
||||
- RIE_TRUE if Manchester Encoding is to be enabled.
|
||||
- RIE_FALSE if disabled.
|
||||
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioPayldManchesterEncode(RIE_TRUE);
|
||||
|
||||
@endcode
|
||||
|
|
@ -689,37 +689,37 @@ RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
|
|||
if (ucNewRegVal != RadioConfiguration.symbol_mode_r )
|
||||
{
|
||||
bRadioConfigurationChanged = RIE_TRUE;
|
||||
RadioConfiguration.symbol_mode_r = ucNewRegVal;
|
||||
RadioConfiguration.symbol_mode_r = ucNewRegVal;
|
||||
}
|
||||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioPayldDataWhitening(RIE_BOOL bEnable)
|
||||
@brief Enable or Disable Data Whitening of payload data.
|
||||
@brief Enable or Disable Data Whitening of payload data.
|
||||
|
||||
Data whitening can be employed to avoid long runs of 1s or 0s
|
||||
in the transmitted data stream.
|
||||
in the transmitted data stream.
|
||||
|
||||
This ensures sufficient bit transitions in the packet, which
|
||||
aids in receiver clock and data recovery because the encoding
|
||||
breaks up long runs of 1s or 0s in the transmit packet.
|
||||
This ensures sufficient bit transitions in the packet, which
|
||||
aids in receiver clock and data recovery because the encoding
|
||||
breaks up long runs of 1s or 0s in the transmit packet.
|
||||
|
||||
The data, excluding the preamble and sync word, is automatically
|
||||
whitened before transmission by XORing the data with an 8-bit
|
||||
pseudorandom sequence.
|
||||
whitened before transmission by XORing the data with an 8-bit
|
||||
pseudorandom sequence.
|
||||
|
||||
At the receiver, the data is XORed with the same pseudorandom
|
||||
sequence, thereby reversing the whitening.
|
||||
At the receiver, the data is XORed with the same pseudorandom
|
||||
sequence, thereby reversing the whitening.
|
||||
|
||||
The linear feedback shift register polynomial used is x7 + x1 + 1.
|
||||
|
||||
@param bEnable :{RIE_FALSE, RIE_TRUE}
|
||||
- RIE_TRUE if Manchester Encoding is to be enabled.
|
||||
- RIE_TRUE if Manchester Encoding is to be enabled.
|
||||
- RIE_FALSE if disabled.
|
||||
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioPayldDataWhitening(RIE_TRUE);
|
||||
|
||||
@endcode
|
||||
|
|
@ -748,19 +748,19 @@ RIE_Responses RadioPayldDataWhitening(RIE_BOOL bEnable)
|
|||
if (ucNewRegVal != RadioConfiguration.symbol_mode_r )
|
||||
{
|
||||
bRadioConfigurationChanged = RIE_TRUE;
|
||||
RadioConfiguration.symbol_mode_r = ucNewRegVal;
|
||||
RadioConfiguration.symbol_mode_r = ucNewRegVal;
|
||||
}
|
||||
}
|
||||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
|
||||
@brief Transmit a fixed length packet.
|
||||
/**
|
||||
@fn RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
|
||||
@brief Transmit a fixed length packet.
|
||||
@param Len :{1-240} Length of packet to be transmitted.
|
||||
@param pData :{} Data bytes to be transmitted.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
|
||||
if (RIE_Response == RIE_Success)
|
||||
|
|
@ -795,13 +795,13 @@ RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
|
||||
@brief Transmit a Variable length packet.
|
||||
/**
|
||||
@fn RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
|
||||
@brief Transmit a Variable length packet.
|
||||
@param Len :{1-240} Length of packet to be transmitted.
|
||||
@param pData :{} Data bytes to be transmitted.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
|
||||
if (RIE_Response == RIE_Success)
|
||||
|
|
@ -841,12 +841,12 @@ RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
|
|||
}
|
||||
|
||||
|
||||
/**
|
||||
@fn RIE_BOOL RadioTxPacketComplete(void)
|
||||
/**
|
||||
@fn RIE_BOOL RadioTxPacketComplete(void)
|
||||
@brief Checks if a packet has finished transmitting
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@pre RadioRxPacketFixedLen() or equivalent should be called first.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
|
||||
if (RIE_Response == RIE_Success)
|
||||
|
|
@ -860,16 +860,16 @@ RIE_BOOL RadioTxPacketComplete (void)
|
|||
return bPacketTx;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_Responses RadioTxSetPA(RIE_PATypes PAType,RIE_PAPowerLevel Power)
|
||||
@brief Set PA Type and the Transmit Power Level for Radio Transmission.
|
||||
/**
|
||||
@fn RIE_Responses RadioTxSetPA(RIE_PATypes PAType,RIE_PAPowerLevel Power)
|
||||
@brief Set PA Type and the Transmit Power Level for Radio Transmission.
|
||||
@param PAType :{DifferentialPA, SingleEndedPA} Select Single Ended or Differential PA Type
|
||||
@param Power :{PowerLevel0 ,PowerLevel1 ,PowerLevel2 ,PowerLevel3,
|
||||
PowerLevel4 ,PowerLevel5 ,PowerLevel6 ,PowerLevel7,
|
||||
PowerLevel8 ,PowerLevel9 ,PowerLevel10,PowerLevel11,
|
||||
PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
|
||||
PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioTxSetPA(SingleEndedPA,PowerLevel8);
|
||||
@endcode
|
||||
@note Differential PA is enabled by default.
|
||||
|
|
@ -940,17 +940,17 @@ RIE_Responses RadioTxSetPA(RIE_PATypes PAType,RIE_PAPowerLevel Power)
|
|||
if (ucNewRegVal != RadioConfiguration.radio_cfg_8_r )
|
||||
{
|
||||
bRadioConfigurationChanged = RIE_TRUE;
|
||||
RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
|
||||
RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
|
||||
}
|
||||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioTxCarrier(void)
|
||||
@brief Transmit a carrier tone
|
||||
using the current radio configuration.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioTxCarrier();
|
||||
@endcode
|
||||
@note Terminate this mode by calling RadioTerminateRadioOp();
|
||||
|
|
@ -973,12 +973,12 @@ RIE_Responses RadioTxCarrier (void)
|
|||
Response = RadioSendCommandWait(CMD_PHY_TX);
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioTxPreamble(void)
|
||||
@brief Transmit a pre-amble (alternating ones and zeros)
|
||||
using the current radio configuration.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioTxPreamble();
|
||||
@endcode
|
||||
@note Terminate this mode by calling RadioTerminateRadioOp();
|
||||
|
|
@ -1002,14 +1002,14 @@ RIE_Responses RadioTxPreamble (void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioRxPacketFixedLen(RIE_U8 Len)
|
||||
@brief Enter receive mode and wait for a packet to be received.
|
||||
|
||||
Radio will stay in Receive Mode until
|
||||
1) A packet is received.
|
||||
Radio will stay in Receive Mode until
|
||||
1) A packet is received.
|
||||
2) User manually exits Receive Mode with a call to RadioTerminateRadioOp()
|
||||
|
||||
|
||||
@param Len :{1-240} Fixed Length of packet to be received.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@return RIE_Responses Error code
|
||||
|
|
@ -1036,14 +1036,14 @@ RIE_Responses RadioRxPacketFixedLen(RIE_U8 Len)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioRxPacketVariableLen(void)
|
||||
@brief Enter receive mode and wait for a packet to be received.
|
||||
|
||||
Radio will stay in Receive Mode until
|
||||
1) A packet is received.
|
||||
Radio will stay in Receive Mode until
|
||||
1) A packet is received.
|
||||
2) User manually exits Receive Mode with a call to RadioTerminateRadioOp()
|
||||
|
||||
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@return RIE_Responses Error code
|
||||
**/
|
||||
|
|
@ -1067,12 +1067,12 @@ RIE_Responses RadioRxPacketVariableLen(void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_BOOL RadioRxPacketAvailable(void)
|
||||
@brief Checks if a packet has been received.
|
||||
/**
|
||||
@fn RIE_BOOL RadioRxPacketAvailable(void)
|
||||
@brief Checks if a packet has been received.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@pre RadioRxPacketFixedLen() or equivalent should be called first.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioRxPacketFixedLen(12);
|
||||
if (RIE_Response == RIE_Success)
|
||||
|
|
@ -1095,7 +1095,7 @@ RIE_BOOL RadioRxPacketAvailable(void)
|
|||
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioRxPacketRead(RIE_U8 BufferLen,RIE_U8 *pPktLen,RIE_U8 *pData,RIE_S8 *pRSSIdBm)
|
||||
@brief Read the packet that was received by the radio.
|
||||
@param BufferLen :{1-240} Size of passed in buffer
|
||||
|
|
@ -1104,7 +1104,7 @@ RIE_BOOL RadioRxPacketAvailable(void)
|
|||
@param pRSSIdBm :{} RSSI of received packet in dBm.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@pre RadioRxPacketFixedLen() or equivalent should be called first.
|
||||
@code
|
||||
@code
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioRxPacketFixedLen(12);
|
||||
if (RIE_Response == RIE_Success)
|
||||
|
|
@ -1170,13 +1170,13 @@ RIE_Responses RadioRxPacketRead(RIE_U8 BufferLen,RIE_U8 *pPktLen,RIE_U8 *pData,R
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioRxBERTestMode(void)
|
||||
@brief Enter receiver Bit Error Rate (BER) test mode where the
|
||||
clock and data appear on GPIO pins.
|
||||
Clock on P0.6 and Data on P2.6
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioRxBERTestMode();
|
||||
@endcode
|
||||
@note Terminate this mode by calling RadioTerminateRadioOp();
|
||||
|
|
@ -1187,7 +1187,7 @@ RIE_Responses RadioRxBERTestMode(void)
|
|||
RIE_Responses Response = RIE_Success;
|
||||
RIE_U8 Data;
|
||||
// Enables internal radio signals on external pins
|
||||
// but overrides some of the standard GPIO muxed
|
||||
// but overrides some of the standard GPIO muxed
|
||||
// functionality (UART?)
|
||||
pADI_MISC->RFTST = 0x7E1;
|
||||
|
||||
|
|
@ -1211,7 +1211,7 @@ RIE_Responses RadioRxBERTestMode(void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@internal Hide from Doxegen
|
||||
@fn RIE_Responses RadioCommitRadioConfig(void)
|
||||
@brief Configures the radio if any changes were made
|
||||
|
|
@ -1247,7 +1247,7 @@ static RIE_Responses RadioCommitRadioConfig(void)
|
|||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioReadState(RadioState *pState)
|
||||
@brief Read the current state
|
||||
@param pState Pointer to return storage of state
|
||||
|
|
@ -1271,7 +1271,7 @@ static RIE_Responses RadioReadState(RadioState *pState)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioWaitOnState(RadioState FinalState)
|
||||
@brief Wait for Final State to be reached
|
||||
@param FinalState State to wait on
|
||||
|
|
@ -1289,7 +1289,7 @@ static RIE_Responses RadioWaitOnState(RadioState FinalState)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioWaitOnCmdLdr(void)
|
||||
@brief Wait for Final State to be reached
|
||||
@param FinalState State to wait on
|
||||
|
|
@ -1307,7 +1307,7 @@ static RIE_Responses RadioWaitOnCmdLdr(void)
|
|||
Response = RadioSPIXferByte(SPI_NOP,NULL);
|
||||
if (Response == RIE_Success)
|
||||
Response = RadioSPIXferByte(SPI_NOP,&StatusByte);
|
||||
RADIO_CSN_DEASSERT;
|
||||
RADIO_CSN_DEASSERT;
|
||||
NVIC_EnableIRQ (UHFTRX_IRQn);
|
||||
if ((Response == RIE_Success))
|
||||
if(StatusByte & STATUS_BYTE_CMD_READY)
|
||||
|
|
@ -1317,13 +1317,13 @@ static RIE_Responses RadioWaitOnCmdLdr(void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
@internal Hide from Doxegen
|
||||
@fn RIE_Responses RadioToOnMode(void)
|
||||
@brief Transition to On Mode
|
||||
|
||||
Handle all possible states that the radio could be in
|
||||
and brings it back to PHY_ON state
|
||||
Handle all possible states that the radio could be in
|
||||
and brings it back to PHY_ON state
|
||||
@param None
|
||||
@return RIE_Responses Error code
|
||||
**/
|
||||
|
|
@ -1365,12 +1365,12 @@ static RIE_Responses RadioToOnMode(void)
|
|||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@internal Hide from Doxegen
|
||||
@fn RIE_Responses RadioToOffMode(void)
|
||||
@brief Transition to Off Mode
|
||||
|
||||
Handle all possible states that the radio could be in
|
||||
Handle all possible states that the radio could be in
|
||||
and bring it back to PHY_OFF state.
|
||||
|
||||
@param None
|
||||
|
|
@ -1414,7 +1414,7 @@ static RIE_Responses RadioToOffMode(void)
|
|||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@internal Hide from Doxegen
|
||||
@fn RIE_Responses RadioSyncComms (void)
|
||||
@brief Sync comms with the radio
|
||||
|
|
@ -1430,7 +1430,7 @@ static RIE_Responses RadioSyncComms (void)
|
|||
Response = RadioWaitOnCmdLdr();
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioWaitForPowerUp(void)
|
||||
@brief Wake Up the Part
|
||||
|
||||
|
|
@ -1444,7 +1444,7 @@ static RIE_Responses RadioWaitForPowerUp(void)
|
|||
RIE_Responses Response = RIE_Success;
|
||||
int i = 0x0;
|
||||
RADIO_CSN_ASSERT;
|
||||
while (!RADIO_MISO_IN && (i < 1000))
|
||||
while (!RADIO_MISO_IN && (i < 1000))
|
||||
i++;
|
||||
if (1000 == i)// Timed out waiting for MISO high?
|
||||
Response = RIE_RadioSPICommsFail;
|
||||
|
|
@ -1452,7 +1452,7 @@ static RIE_Responses RadioWaitForPowerUp(void)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn void Ext_Int8_Handler(void)
|
||||
\brief Radio Interrupt Handler
|
||||
|
|
@ -1482,7 +1482,7 @@ void Ext_Int8_Handler (void)
|
|||
// Clear the interrupt
|
||||
pADI_INTERRUPT->EICLR = EICLR_IRQ8;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn void RadioSPIXferByte(RIE_U8 ucByte,RIE_U8 *pData)
|
||||
\brief Transfer a byte via SPI to the radio and optionally return
|
||||
|
|
@ -1504,13 +1504,13 @@ static RIE_Responses RadioSPIXferByte(RIE_U8 ucByte,RIE_U8 *pData)
|
|||
(void)READ_SPI;
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn RIE_Responses RadioSendCommandBytes(RIE_U8 *pCmdBytes,RIE_U8 NumBytes)
|
||||
\brief Send a complete command to the radio.
|
||||
|
||||
It is neccessary to disable the radio interrupt when doing this
|
||||
as a command in progress must finish before a radio interrupt
|
||||
as a command in progress must finish before a radio interrupt
|
||||
can be handled.
|
||||
|
||||
\param pCmdBytes Pointer to a number of bytes to be transferred.
|
||||
|
|
@ -1531,7 +1531,7 @@ static RIE_Responses RadioSendCommandBytes(RIE_U8 *pCmdBytes,RIE_U8 NumBytes)
|
|||
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode )
|
||||
\brief Send a single byte command to the radio.
|
||||
|
|
@ -1543,7 +1543,7 @@ static RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode )
|
|||
RIE_U8 Command = (RIE_U8)CmdCode;
|
||||
return RadioSendCommandBytes(&Command,0x1);
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode )
|
||||
\brief Send a single byte command to the radio.
|
||||
|
|
@ -1561,7 +1561,7 @@ static RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode )
|
|||
Response = RadioSendCommandBytes(&Command,0x1);
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\fn RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
|
||||
\brief Read bytes from specified memory map address
|
||||
\param ulAdr Address to read at.
|
||||
|
|
@ -1575,7 +1575,7 @@ static RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
|
|||
|
||||
NVIC_DisableIRQ(UHFTRX_IRQn);
|
||||
RADIO_CSN_ASSERT;
|
||||
|
||||
|
||||
if(Response == RIE_Success) // Send first byte (SPI_MEMR_RD + Bytes)
|
||||
Response = RadioSPIXferByte(SPI_MEM_RD | ((ulAdr & 0x700) >> 8),NULL);
|
||||
if(Response == RIE_Success)// Send Second byte remainder of address
|
||||
|
|
@ -1589,7 +1589,7 @@ static RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
|
|||
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
\fn RIE_Responses RadioMMapWrite(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
|
||||
\brief Read bytes from specified memory map address
|
||||
\param ulAdr Address to read at.
|
||||
|
|
@ -1615,7 +1615,7 @@ static RIE_Responses RadioMMapWrite(RIE_U32 ulAdr,RIE_U32 ulLen,RIE_U8 * pDat
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
\internal Hide from Doxegen
|
||||
\fn void SetRadioConfiguration(void)
|
||||
\brief Create a default radio configuration that all base configurations
|
||||
|
|
@ -1654,7 +1654,7 @@ static RIE_Responses SetRadioConfiguration(RIE_BaseConfigs BaseConfig)
|
|||
}
|
||||
return Response;
|
||||
}
|
||||
/**
|
||||
/**
|
||||
@internal Hide from Doxegen
|
||||
@fn RIE_Responses RadioConfigure (void)
|
||||
@brief Configure the Radio as per the current configuration
|
||||
|
|
@ -1666,8 +1666,8 @@ RIE_Responses RadioConfigure (void)
|
|||
if(Response == RIE_Success)
|
||||
Response = RadioToOffMode();
|
||||
if(Response == RIE_Success) // Write the configuration to the radio memory
|
||||
Response = RadioMMapWrite(BBRAM_START,
|
||||
sizeof(TyRadioConfiguration),
|
||||
Response = RadioMMapWrite(BBRAM_START,
|
||||
sizeof(TyRadioConfiguration),
|
||||
(RIE_U8 *)&RadioConfiguration);
|
||||
if(Response == RIE_Success) // Apply that configuration to the radio
|
||||
Response = RadioSendCommandWait(CMD_CONFIG_DEV);
|
||||
|
|
@ -1677,12 +1677,12 @@ RIE_Responses RadioConfigure (void)
|
|||
}
|
||||
|
||||
|
||||
/**
|
||||
/**
|
||||
@fn RIE_Responses RadioRadioGetRSSI (RIE_S8 *pRSSIdBm)
|
||||
@brief Return a Received Signal Strength Indicator value
|
||||
@param pRSSIdBm :{} detected RSSI in dBm.
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
RIE_S8 RSSIdBm;
|
||||
if (RIE_Response == RIE_Success)
|
||||
RIE_Response = RadioRadioGetRSSI(&RSSIdBm);
|
||||
|
|
@ -1700,7 +1700,7 @@ RIE_Responses RadioRadioGetRSSI (RIE_S8 *pRSSIdBm)
|
|||
if (Response == RIE_Success)
|
||||
Response = RadioSendCommandWait(CMD_GET_RSSI);
|
||||
if (Response == RIE_Success)
|
||||
Response = RadioSyncComms(); //
|
||||
Response = RadioSyncComms(); //
|
||||
if (pRSSIdBm)
|
||||
{
|
||||
if (Response == RIE_Success)
|
||||
|
|
@ -1710,15 +1710,15 @@ RIE_Responses RadioRadioGetRSSI (RIE_S8 *pRSSIdBm)
|
|||
return Response;
|
||||
}
|
||||
|
||||
/**
|
||||
@fn RIE_Responses RadioTxSetPower(RIE_PAPowerLevel Power)
|
||||
@brief Set the Transmit Power Level for Radio Transmission.
|
||||
/**
|
||||
@fn RIE_Responses RadioTxSetPower(RIE_PAPowerLevel Power)
|
||||
@brief Set the Transmit Power Level for Radio Transmission.
|
||||
@param Power :{PowerLevel0 ,PowerLevel1 ,PowerLevel2 ,PowerLevel3,
|
||||
PowerLevel4 ,PowerLevel5 ,PowerLevel6 ,PowerLevel7,
|
||||
PowerLevel8 ,PowerLevel9 ,PowerLevel10,PowerLevel11,
|
||||
PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
|
||||
PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
|
||||
@pre RadioInit() must be called before this function is called.
|
||||
@code
|
||||
@code
|
||||
Response = RadioTxSetPower(PowerLevel8);
|
||||
@endcode
|
||||
@note Max TX Power is used by default.
|
||||
|
|
@ -1783,7 +1783,7 @@ RIE_Responses RadioTxSetPower (RIE_PAPowerLevel Power)
|
|||
// Write directly to the MCR in this case and avoid a reconfigure
|
||||
if (Response == RIE_Success)
|
||||
Response = RadioMMapWrite(MCR_pa_level_mcr_Adr, 0x1, (RIE_U8 *)&ucNewRegVal);
|
||||
RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
|
||||
RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
|
||||
}
|
||||
}
|
||||
return Response;
|
||||
|
|
|
|||
|
|
@ -89,10 +89,10 @@
|
|||
* processor.
|
||||
*/
|
||||
int elfloader_arch_relocate(int input_fd,
|
||||
struct elfloader_output *output,
|
||||
unsigned int sectionoffset,
|
||||
char *sectionaddr,
|
||||
struct elf32_rela *rela, char *addr);
|
||||
struct elfloader_output *output,
|
||||
unsigned int sectionoffset,
|
||||
char *sectionaddr,
|
||||
struct elf32_rela *rela, char *addr);
|
||||
|
||||
#endif /* ELFLOADER_ARCH_H_ */
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
* Header file for the Contiki ELF loader.
|
||||
* \author
|
||||
* Adam Dunkels <adam@sics.se>
|
||||
* Simon Berg <ksb@users.sourceforge.net>
|
||||
* Simon Berg <ksb@users.sourceforge.net>
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -132,7 +132,7 @@
|
|||
* Return value from elfloader_load() indicating that the offset for
|
||||
* a relative addressing mode was too big.
|
||||
*/
|
||||
#define ELFLOADER_OUTOF_RANGE 9
|
||||
#define ELFLOADER_OUTOF_RANGE 9
|
||||
|
||||
/**
|
||||
* Return value from elfloader_load() indicating that the relocations
|
||||
|
|
@ -144,13 +144,13 @@
|
|||
* Return value from elfloader_load() indicating that reading from the
|
||||
* ELF file failed in some way.
|
||||
*/
|
||||
#define ELFLOADER_INPUT_ERROR 11
|
||||
#define ELFLOADER_INPUT_ERROR 11
|
||||
|
||||
/**
|
||||
* Return value from elfloader_load() indicating that writing to a segment
|
||||
* failed.
|
||||
*/
|
||||
#define ELFLOADER_OUTPUT_ERROR 12
|
||||
#define ELFLOADER_OUTPUT_ERROR 12
|
||||
|
||||
|
||||
#define ELFLOADER_SEG_TEXT 1
|
||||
|
|
@ -164,10 +164,10 @@
|
|||
* This object defines methods (callbacks) for writing the segments to memory.
|
||||
* It can be extended by the user to include any necessary state.
|
||||
*/
|
||||
|
||||
struct elfloader_output {
|
||||
const struct elfloader_output_ops *ops;
|
||||
};
|
||||
|
||||
/**
|
||||
* \brief Allocate a new segment
|
||||
* \param input The output object
|
||||
|
|
@ -178,9 +178,8 @@ struct elfloader_output {
|
|||
* The returned address doesn't need to correspond to any real memory,
|
||||
* since it's only used for calculating the relocations.
|
||||
*/
|
||||
|
||||
void *elfloader_allocate_segment(struct elfloader_output *output,
|
||||
unsigned int type, int size);
|
||||
unsigned int type, int size);
|
||||
|
||||
/**
|
||||
* \brief Start writing to a new segment
|
||||
|
|
@ -191,15 +190,14 @@ void *elfloader_allocate_segment(struct elfloader_output *output,
|
|||
* \return Returns ELFLOADER_OK if successful, otherwise an error code
|
||||
*
|
||||
*/
|
||||
|
||||
int elfloader_start_segment(struct elfloader_output *output,
|
||||
unsigned int type, void *addr, int size);
|
||||
unsigned int type, void *addr, int size);
|
||||
|
||||
/**
|
||||
* \brief Mark end of segment
|
||||
* \param input The output object
|
||||
* \return Zero if successful
|
||||
*/
|
||||
|
||||
int elfloader_end_segment(struct elfloader_output *output);
|
||||
|
||||
/**
|
||||
|
|
@ -209,9 +207,8 @@ int elfloader_end_segment(struct elfloader_output *output);
|
|||
* \param len Length of data
|
||||
* \return The number of bytes actually written, or negative if failed.
|
||||
*/
|
||||
|
||||
int elfloader_write_segment(struct elfloader_output *output, const char *buf,
|
||||
unsigned int len);
|
||||
unsigned int len);
|
||||
|
||||
/**
|
||||
* \brief Get the current offset in the file where the next data will
|
||||
|
|
@ -219,7 +216,6 @@ int elfloader_write_segment(struct elfloader_output *output, const char *buf,
|
|||
* \param input The output object
|
||||
* \return The current offset.
|
||||
*/
|
||||
|
||||
unsigned int elfloader_segment_offset(struct elfloader_output *output);
|
||||
|
||||
#define elfloader_output_alloc_segment(output, type, size) \
|
||||
|
|
@ -240,12 +236,12 @@ unsigned int elfloader_segment_offset(struct elfloader_output *output);
|
|||
|
||||
struct elfloader_output_ops {
|
||||
void * (*allocate_segment)(struct elfloader_output *output,
|
||||
unsigned int type, int size);
|
||||
unsigned int type, int size);
|
||||
int (*start_segment)(struct elfloader_output *output,
|
||||
unsigned int type, void *addr, int size);
|
||||
unsigned int type, void *addr, int size);
|
||||
int (*end_segment)(struct elfloader_output *output);
|
||||
int (*write_segment)(struct elfloader_output *output, const char *buf,
|
||||
unsigned int len);
|
||||
unsigned int len);
|
||||
unsigned int (*segment_offset)(struct elfloader_output *output);
|
||||
};
|
||||
|
||||
|
|
@ -269,8 +265,7 @@ void elfloader_init(void);
|
|||
* elfloader_loaded_process variable.
|
||||
*
|
||||
*/
|
||||
int elfloader_load(int input_fd,
|
||||
struct elfloader_output *output);
|
||||
int elfloader_load(int input_fd, struct elfloader_output *output);
|
||||
|
||||
/**
|
||||
* A pointer to the processes loaded with elfloader_load().
|
||||
|
|
|
|||
|
|
@ -1001,11 +1001,11 @@ static NETBUF *NicGetPacket(void)
|
|||
* Hack alert: Rev A chips never set the odd frame indicator.
|
||||
*/
|
||||
fbc -= 3;
|
||||
/* nb = NutNetBufAlloc(0, NBAF_DATALINK, fbc);*/
|
||||
/* nb = NutNetBufAlloc(0, NBAF_DATALINK, fbc);*/
|
||||
|
||||
/* Perform the read. */
|
||||
/* if (nb)
|
||||
NicRead(nb->nb_dl.vp, fbc);*/
|
||||
/* if (nb)
|
||||
NicRead(nb->nb_dl.vp, fbc);*/
|
||||
}
|
||||
|
||||
/* Release the packet. */
|
||||
|
|
@ -1191,12 +1191,12 @@ PROCESS_THREAD(lanc111_process, ev, data)
|
|||
*/
|
||||
imsk = nic_inlb(NIC_MSK);
|
||||
nic_outlb(NIC_MSK, 0);
|
||||
/* while ((nb = NicGetPacket()) != 0) {
|
||||
if (nb != (NETBUF *) 0xFFFF) {
|
||||
ni->ni_rx_packets++;
|
||||
(*ifn->if_recv) (dev, nb);
|
||||
}
|
||||
}*/
|
||||
/* while ((nb = NicGetPacket()) != 0) {
|
||||
if (nb != (NETBUF *) 0xFFFF) {
|
||||
ni->ni_rx_packets++;
|
||||
(*ifn->if_recv) (dev, nb);
|
||||
}
|
||||
}*/
|
||||
nic_outlb(NIC_MSK, imsk | INT_RCV | INT_ERCV);
|
||||
}
|
||||
|
||||
|
|
@ -1351,7 +1351,7 @@ lanc111_init(void)
|
|||
|
||||
/* Register interrupt handler and enable interrupts. */
|
||||
/* if (NutRegisterIrqHandler(&LANC111_SIGNAL, NicInterrupt, dev))
|
||||
return -1;*/
|
||||
return -1;*/
|
||||
|
||||
/*
|
||||
* Start the receiver thread.
|
||||
|
|
|
|||
|
|
@ -1,31 +1,30 @@
|
|||
/*
|
||||
* Copyright (c) 2006, Swedish Institute of Computer Science
|
||||
* All rights reserved.
|
||||
* 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.
|
||||
* 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.
|
||||
*
|
||||
/**
|
||||
* \file
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
* SUCH DAMAGE.
|
||||
*
|
||||
* This file is part of libmc1322x: see http://mc1322x.devl.org
|
||||
* for details.
|
||||
* for details.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -80,15 +80,15 @@ ISR(TIMERA1, timera1)
|
|||
++count;
|
||||
|
||||
/* Make sure the CLOCK_CONF_SECOND is a power of two, to ensure
|
||||
that the modulo operation below becomes a logical and and not
|
||||
an expensive divide. Algorithm from Wikipedia:
|
||||
http://en.wikipedia.org/wiki/Power_of_two */
|
||||
that the modulo operation below becomes a logical and and not
|
||||
an expensive divide. Algorithm from Wikipedia:
|
||||
http://en.wikipedia.org/wiki/Power_of_two */
|
||||
#if (CLOCK_CONF_SECOND & (CLOCK_CONF_SECOND - 1)) != 0
|
||||
#error CLOCK_CONF_SECOND must be a power of two (i.e., 1, 2, 4, 8, 16, 32, 64, ...).
|
||||
#error Change CLOCK_CONF_SECOND in contiki-conf.h.
|
||||
#endif
|
||||
if(count % CLOCK_CONF_SECOND == 0) {
|
||||
++seconds;
|
||||
++seconds;
|
||||
energest_flush();
|
||||
}
|
||||
last_tar = read_tar();
|
||||
|
|
|
|||
|
|
@ -52,5 +52,3 @@ enum {
|
|||
|
||||
/**@} // End of addtogroup
|
||||
*/
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
* @brief Cortex-M3 Non-Volatile Memory data storage system.
|
||||
* See @ref nvm for documentation.
|
||||
*
|
||||
* The functions in this file return an ::StStatus value.
|
||||
* The functions in this file return an ::StStatus value.
|
||||
* See error-def.h for definitions of all ::StStatus return values.
|
||||
*
|
||||
* See hal/micro/cortexm3/nvm.h for source code.
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
* that is a multiple of physical flash pages. There are two pages: LEFT
|
||||
* and RIGHT. The term "flash page" is used to refer to a page of
|
||||
* physical flash.
|
||||
*
|
||||
*
|
||||
* NVM data storage works by alternating between two pages: LEFT and RIGHT.
|
||||
* The basic algorithm is driven by a call to halCommonSaveToNvm(). It will:
|
||||
* - erase the inactive page
|
||||
|
|
@ -58,35 +58,35 @@
|
|||
* is LEFT then the state machine will advance until state 7 and then exit.
|
||||
* If "Read from" is RIGHT, then the state machine will advance until
|
||||
* state 3 and then exit.
|
||||
*
|
||||
*
|
||||
* @code
|
||||
* Starting from erased or invalid mgmt, write to LEFT
|
||||
* State # 0 0 1 2 3
|
||||
* Reads from: x x e w L L L
|
||||
* State # 0 0 1 2 3
|
||||
* Reads from: x x e w L L L
|
||||
* Valid xx|xx FF|FF r r 00|FF 00|FF 00|00
|
||||
* Active xx|xx FF|FF a i 00|FF 00|FF 00|00
|
||||
* Dead xx|xx FF|FF s t FF|FF FF|00 FF|00
|
||||
* Spare xx|xx FF|FF e e FF|FF FF|FF FF|FF
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
* Starting from LEFT page, transition to RIGHT page:
|
||||
* State # 3 4 5 6 7
|
||||
* Reads from: L e L w R R R
|
||||
* State # 3 4 5 6 7
|
||||
* Reads from: L e L w R R R
|
||||
* Valid 00|00 r 00|FF r 00|00 00|00 00|00
|
||||
* Active 00|00 a 00|FF i 00|FF 00|FF 00|00
|
||||
* Dead FF|00 s FF|FF t FF|FF 00|FF 00|FF
|
||||
* Spare FF|FF e FF|FF e FF|FF FF|FF FF|FF
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
* Starting from RIGHT page, transition to LEFT page:
|
||||
* State # 7 8 9 10 3
|
||||
* Reads from: R e R w L L L
|
||||
* State # 7 8 9 10 3
|
||||
* Reads from: R e R w L L L
|
||||
* Valid 00|00 r FF|00 r 00|00 00|00 00|00
|
||||
* Active 00|00 a FF|00 i FF|00 FF|00 00|00
|
||||
* Dead 00|FF s FF|FF t FF|FF FF|00 FF|00
|
||||
* Spare FF|FF e FF|FF e FF|FF FF|FF FF|FF
|
||||
* @endcode
|
||||
*
|
||||
*
|
||||
* Based on the 10 possible states, there are 5 valid 32bit mgmt words:
|
||||
* - 0xFFFFFFFF
|
||||
* - 0xFFFFFF00
|
||||
|
|
@ -95,7 +95,7 @@
|
|||
* - 0xFF00FFFF
|
||||
* The algorithm determines the current state by using these 5 mgmt words
|
||||
* with the 10 possible combinations of LEFT mgmt and RIGHT mgmt.
|
||||
*
|
||||
*
|
||||
* Detailed State Description:
|
||||
* - State 0:
|
||||
* In this state the mgmt bytes do not conform to any of the other states
|
||||
|
|
@ -135,8 +135,8 @@
|
|||
* Once at these states, the current page is marked Valid and Active and
|
||||
* the old page is marked as Dead. The algorithm knows which page to
|
||||
* read from and which page needs to be erased on the next write to the NVM.
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
* Notes on algorithm behavior:
|
||||
* - Refer to nvm-def.h for a list of offset/length that define the data
|
||||
* stored in NVM storage space.
|
||||
|
|
@ -189,14 +189,14 @@
|
|||
/**
|
||||
* @brief Copy the NVM data from flash into the provided RAM location.
|
||||
* It is illegal for the offset to be greater than NVM_DATA_SIZE_B.
|
||||
*
|
||||
*
|
||||
* @param data A (RAM) pointer to where the data should be copied.
|
||||
*
|
||||
*
|
||||
* @param offset The location from which the data should be copied. Must be
|
||||
* 16bit aligned.
|
||||
*
|
||||
*
|
||||
* @param length The length of the data in bytes. Must be 16bit aligned.
|
||||
*
|
||||
*
|
||||
* @return An StStatus value indicating the success of the function.
|
||||
* - ST_SUCCESS if the read completed cleanly.
|
||||
* - ST_ERR_FATAL if the NVM storage management indicated an invalid
|
||||
|
|
@ -206,10 +206,10 @@ StStatus halCommonReadFromNvm(void *data, uint32_t offset, uint16_t length);
|
|||
|
||||
/**
|
||||
* @brief Return the address of the token in NVM
|
||||
*
|
||||
*
|
||||
* @param offset The location offset from which the address should be returned
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
* @return The address requested
|
||||
*/
|
||||
uint16_t *halCommonGetAddressFromNvm(uint32_t offset);
|
||||
|
|
@ -217,14 +217,14 @@ uint16_t *halCommonGetAddressFromNvm(uint32_t offset);
|
|||
/**
|
||||
* @brief Write the NVM data from the provided location RAM into flash.
|
||||
* It is illegal for the offset to be greater than NVM_DATA_SIZE_B.
|
||||
*
|
||||
*
|
||||
* @param data A (RAM) pointer from where the data should be taken.
|
||||
*
|
||||
*
|
||||
* @param offset The location to which the data should be written. Must be
|
||||
* 16bit aligned.
|
||||
*
|
||||
*
|
||||
* @param length The length of the data in bytes. Must be 16bit aligned.
|
||||
*
|
||||
*
|
||||
* @return An StStatus value indicating the success of the function.
|
||||
* - ST_SUCCESS if the write completed cleanly.
|
||||
* - Any other status value is an error code generated by the low level
|
||||
|
|
|
|||
|
|
@ -23,14 +23,14 @@ typedef enum
|
|||
|
||||
/**
|
||||
* @brief Initialize the UART
|
||||
*
|
||||
*
|
||||
* @param baudrate The baudrate which will be used for communication.
|
||||
* Ex: 115200
|
||||
*
|
||||
*
|
||||
* @param databits The number of data bits used for communication.
|
||||
* Valid values are 7 or 8
|
||||
*
|
||||
* @param parity The type of parity used for communication.
|
||||
*
|
||||
* @param parity The type of parity used for communication.
|
||||
* See the SerialParity enum for possible values
|
||||
*
|
||||
* @return stopbits The number of stop bits used for communication.
|
||||
|
|
@ -45,9 +45,9 @@ void uartInit(uint32_t baudrate, uint8_t databits, SerialParity parity, uint8_t
|
|||
* instead which does not define fflush(). Therefore, we manually define
|
||||
* fflush() in the low level UART driver. This function simply redirects
|
||||
* to the __write() function with a NULL buffer, triggering a flush.
|
||||
*
|
||||
*
|
||||
* @param handle The output stream. Should be set to 'stdout' like normal.
|
||||
*
|
||||
*
|
||||
* @return Zero, indicating success.
|
||||
*/
|
||||
size_t fflush(int handle);
|
||||
|
|
@ -61,7 +61,7 @@ size_t fflush(int handle);
|
|||
#define stdout _LLIO_STDOUT
|
||||
#endif
|
||||
/**
|
||||
* @brief Read the input byte if any.
|
||||
* @brief Read the input byte if any.
|
||||
*/
|
||||
boolean __io_getcharNonBlocking(uint8_t *data);
|
||||
void __io_putchar( char c );
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
/**
|
||||
* \brief Compiler and Platform specific definitions and typedefs common to
|
||||
* all platforms.
|
||||
* all platforms.
|
||||
*
|
||||
* platform-common.h provides PLATFORM_HEADER defaults and common definitions.
|
||||
* This head should never be included directly, it should only be included
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
* <!--(C) COPYRIGHT 2010 STMicroelectronics. All rights reserved. -->
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#ifndef PLATCOMMONOKTOINCLUDE
|
||||
// This header should only be included by a PLATFORM_HEADER
|
||||
#error platform-common.h should not be included directly
|
||||
|
|
@ -29,7 +29,7 @@
|
|||
#ifndef PLATFORMCOMMON_H_
|
||||
#define PLATFORMCOMMON_H_
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Many of the common definitions must be explicitly enabled by the
|
||||
// Many of the common definitions must be explicitly enabled by the
|
||||
// particular PLATFORM_HEADER being used
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
|
@ -69,16 +69,16 @@
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
#ifdef _HAL_USE_COMMON_DIVMOD_
|
||||
/** \name Divide and Modulus Operations
|
||||
* Some platforms can perform divide and modulus operations on 32 bit
|
||||
* Some platforms can perform divide and modulus operations on 32 bit
|
||||
* quantities more efficiently when the divisor is only a 16 bit quantity.
|
||||
* C compilers will always promote the divisor to 32 bits before performing the
|
||||
* operation, so the following utility functions are instead required to take
|
||||
* operation, so the following utility functions are instead required to take
|
||||
* advantage of this optimisation.
|
||||
*/
|
||||
//@{
|
||||
/**
|
||||
* \brief Provide a portable name for the uint32_t by uint16_t division
|
||||
* library function (which can perform the division with only a single
|
||||
* library function (which can perform the division with only a single
|
||||
* assembly instruction on some platforms)
|
||||
*/
|
||||
#define halCommonUDiv32By16(x, y) ((uint16_t) (((uint32_t) (x)) / ((uint16_t) (y))))
|
||||
|
|
@ -111,12 +111,12 @@
|
|||
#ifdef _HAL_USE_COMMON_MEMUTILS_
|
||||
/** \name C Standard Library Memory Utilities
|
||||
* These should be used in place of the standard library functions.
|
||||
*
|
||||
*
|
||||
* These functions have the same parameters and expected results as their C
|
||||
* Standard Library equivalents but may take advantage of certain implementation
|
||||
* optimizations.
|
||||
*
|
||||
* Unless otherwise noted, these functions are utilized by the StStack and are
|
||||
*
|
||||
* Unless otherwise noted, these functions are utilized by the StStack and are
|
||||
* therefore required to be implemented in the HAL. Additionally, unless otherwise
|
||||
* noted, applications that find these functions useful may utilze them.
|
||||
*/
|
||||
|
|
@ -212,22 +212,22 @@
|
|||
#define SETBIT(reg, bit) reg |= BIT(bit)
|
||||
|
||||
/**
|
||||
* \brief Sets the bits in the \c reg register or the byte
|
||||
* as specified in the bitmask \c bits.
|
||||
* \brief Sets the bits in the \c reg register or the byte
|
||||
* as specified in the bitmask \c bits.
|
||||
* @note This is never a single atomic operation.
|
||||
*/
|
||||
#define SETBITS(reg, bits) reg |= (bits)
|
||||
|
||||
/**
|
||||
* \brief Clears a bit in the \c reg register or byte.
|
||||
* @note Assuming \c reg is an IO register, some platforms (such as the AVR)
|
||||
* \brief Clears a bit in the \c reg register or byte.
|
||||
* @note Assuming \c reg is an IO register, some platforms (such as the AVR)
|
||||
* can implement this in a single atomic operation.
|
||||
*/
|
||||
#define CLEARBIT(reg, bit) reg &= ~(BIT(bit))
|
||||
|
||||
/**
|
||||
* \brief Clears the bits in the \c reg register or byte
|
||||
* as specified in the bitmask \c bits.
|
||||
* \brief Clears the bits in the \c reg register or byte
|
||||
* as specified in the bitmask \c bits.
|
||||
* @note This is never a single atomic operation.
|
||||
*/
|
||||
#define CLEARBITS(reg, bits) reg &= ~(bits)
|
||||
|
|
@ -238,7 +238,7 @@
|
|||
#define READBIT(reg, bit) (reg & (BIT(bit)))
|
||||
|
||||
/**
|
||||
* \brief Returns the value of the bitmask \c bits within
|
||||
* \brief Returns the value of the bitmask \c bits within
|
||||
* the register or byte \c reg.
|
||||
*/
|
||||
#define READBITS(reg, bits) (reg & (bits))
|
||||
|
|
@ -263,13 +263,13 @@
|
|||
#define HIGH_BYTE(n) ((uint8_t)(LOW_BYTE((n) >> 8)))
|
||||
|
||||
/**
|
||||
* \brief Returns the value built from the two \c uint8_t
|
||||
* \brief Returns the value built from the two \c uint8_t
|
||||
* values \c high and \c low.
|
||||
*/
|
||||
#define HIGH_LOW_TO_INT(high, low) ( \
|
||||
(( (uint16_t) (high) ) << 8) + \
|
||||
( (uint16_t) ( (low) & 0xFF)) \
|
||||
)
|
||||
)
|
||||
|
||||
/**
|
||||
* \brief Returns the low byte of the 32-bit value \c n as an \c uint8_t.
|
||||
|
|
@ -301,21 +301,21 @@
|
|||
//@{
|
||||
|
||||
/**
|
||||
* \brief Returns the elapsed time between two 8 bit values.
|
||||
* \brief Returns the elapsed time between two 8 bit values.
|
||||
* Result may not be valid if the time samples differ by more than 127
|
||||
*/
|
||||
#define elapsedTimeInt8u(oldTime, newTime) \
|
||||
((uint8_t) ((uint8_t)(newTime) - (uint8_t)(oldTime)))
|
||||
|
||||
/**
|
||||
* \brief Returns the elapsed time between two 16 bit values.
|
||||
* \brief Returns the elapsed time between two 16 bit values.
|
||||
* Result may not be valid if the time samples differ by more than 32767
|
||||
*/
|
||||
#define elapsedTimeInt16u(oldTime, newTime) \
|
||||
((uint16_t) ((uint16_t)(newTime) - (uint16_t)(oldTime)))
|
||||
|
||||
/**
|
||||
* \brief Returns the elapsed time between two 32 bit values.
|
||||
* \brief Returns the elapsed time between two 32 bit values.
|
||||
* Result may not be valid if the time samples differ by more than 2147483647
|
||||
*/
|
||||
#define elapsedTimeInt32u(oldTime, newTime) \
|
||||
|
|
|
|||
|
|
@ -149,4 +149,3 @@ StStatus halBootloaderStart(uint8_t mode, uint8_t channel, uint16_t panId);
|
|||
|
||||
/** @} END micro group */
|
||||
/** @} */
|
||||
|
||||
|
|
|
|||
|
|
@ -7,11 +7,11 @@
|
|||
* \defgroup sicslowpan 6LoWPAN implementation
|
||||
* @{
|
||||
|
||||
6lowpan is a Working Group in IETF which defines the use of IPv6 on
|
||||
6lowpan is a Working Group in IETF which defines the use of IPv6 on
|
||||
IEEE 802.15.4 links.
|
||||
|
||||
Our implementation is based on RFC4944 <em>Transmission of IPv6
|
||||
Packets over IEEE 802.15.4 Networks</em>, draft-hui-6lowpan-interop-00
|
||||
Packets over IEEE 802.15.4 Networks</em>, draft-hui-6lowpan-interop-00
|
||||
<em>Interoperability Test for 6LoWPAN</em>, and draft-hui-6lowpan-hc-01
|
||||
<em>Compression format for IPv6 datagrams in 6lowpan Networks</em>.
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ Packets over IEEE 802.15.4 Networks</em>, draft-hui-6lowpan-interop-00
|
|||
\subsection rfc4944 RFC 4944
|
||||
|
||||
RFC4944 defines address configuration mechanisms based on 802.15.4
|
||||
16-bit and 64-bit addresses, fragmentation of IPv6 packets below IP
|
||||
16-bit and 64-bit addresses, fragmentation of IPv6 packets below IP
|
||||
layer, IPv6 and UDP header compression, a mesh header to enable link-layer
|
||||
forwarding in a mesh under topology, and a broadcast header to enable
|
||||
broadcast in a mesh under topology.
|
||||
|
|
@ -32,7 +32,7 @@ broadcast in a mesh under topology.
|
|||
|
||||
We implement addressing, fragmentation, and header compression. We support
|
||||
the header compression scenarios defined in draft-hui-6lowpan-interop-00.
|
||||
This draft defines an interoperability scenario which was used between
|
||||
This draft defines an interoperability scenario which was used between
|
||||
ArchRock and Sensinode implementations.
|
||||
|
||||
We do not implement mesh under related features, as we target route over
|
||||
|
|
@ -40,8 +40,8 @@ techniques.
|
|||
|
||||
\subsection hc01 draft-hui-6lowpan-hc-01
|
||||
|
||||
draft-hui-6lowpan-hc-01 defines a stateful header compression mechanism
|
||||
which should soon deprecate the stateless header compression mechanism
|
||||
draft-hui-6lowpan-hc-01 defines a stateful header compression mechanism
|
||||
which should soon deprecate the stateless header compression mechanism
|
||||
defined in RFC4944. It is much more powerfull and flexible, in
|
||||
particular it allows compression of some multicast addresses and of all
|
||||
global unicast addresses.
|
||||
|
|
@ -59,7 +59,7 @@ It is initialized from the MAC %process, which calls sicslowpan_init
|
|||
|
||||
The main 6lowpan functions are implemented in the sicslowpan.h and
|
||||
sicslowpan.c files. They are used to format packets between the
|
||||
802.15.4 and the IPv6 layers.
|
||||
802.15.4 and the IPv6 layers.
|
||||
|
||||
6lowpan also creates a few IPv6 and link-layer dependencies which are
|
||||
detailed in the next section.
|
||||
|
|
@ -89,13 +89,13 @@ typedef struct uip_802154_longaddr uip_lladdr_t;
|
|||
\endcode
|
||||
|
||||
<b>Neighbor Discovery Link Layer Address options </b><br>
|
||||
The format of ND link-layer address options depends on the length of
|
||||
the link-layer addresses.
|
||||
The format of ND link-layer address options depends on the length of
|
||||
the link-layer addresses.
|
||||
802.15.4 specificities regarding link-layer address options are implemented in uip-nd6.h.
|
||||
\code
|
||||
#define UIP_ND6_OPT_SHORT_LLAO_LEN 8
|
||||
#define UIP_ND6_OPT_LONG_LLAO_LEN 16
|
||||
#define UIP_ND6_OPT_LLAO_LEN UIP_ND6_OPT_LONG_LLAO_LEN
|
||||
#define UIP_ND6_OPT_LLAO_LEN UIP_ND6_OPT_LONG_LLAO_LEN
|
||||
\endcode
|
||||
|
||||
<b>Address Autoconfiguration</b><br>
|
||||
|
|
@ -105,7 +105,7 @@ the link-layer address. The dependency is reflected in the
|
|||
\code
|
||||
#if (UIP_LLADDR_LEN == 8)
|
||||
memcpy(ipaddr->u8 + 8, lladdr, UIP_LLADDR_LEN);
|
||||
ipaddr->u8[8] ^= 0x02;
|
||||
ipaddr->u8[8] ^= 0x02;
|
||||
\endcode
|
||||
|
||||
\subsection io Packet Input/Output
|
||||
|
|
@ -119,24 +119,24 @@ destination link-layer addresses as two rime addresses.
|
|||
\code
|
||||
packetbuf_copyfrom(&rx_frame.payload, rx_frame.payload_length);
|
||||
packetbuf_set_datalen(rx_frame.payload_length);
|
||||
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, (const rimeaddr_t *)&rx_frame.dest_addr);
|
||||
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, (const rimeaddr_t *)&rx_frame.dest_addr);
|
||||
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, (const rimeaddr_t *)&rx_frame.src_addr);
|
||||
\endcode
|
||||
It then calls the sicslowpan #input function. Similarly, when the IPv6 layer
|
||||
It then calls the sicslowpan #input function. Similarly, when the IPv6 layer
|
||||
has a packet to send over the radio, it puts the packet in uip_buf,
|
||||
sets uip_len and calls the sicslowpan #output function.
|
||||
|
||||
\subsection frag Fragmentation
|
||||
|
||||
\li #output function: When an IP packet, after header compression, is
|
||||
too big to fit in a 802.15.4 frame, it is fragmented in several packets
|
||||
which are sent successively over the radio. The packets are formatted
|
||||
too big to fit in a 802.15.4 frame, it is fragmented in several packets
|
||||
which are sent successively over the radio. The packets are formatted
|
||||
as defined in RFC 4944. Only the first fragment contains the IP/UDP
|
||||
compressed or uncompressed header fields.
|
||||
|
||||
\li #input function: This function takes care of fragment
|
||||
reassembly. We do not assume that the fragments are received in order.
|
||||
When reassembly of a packet is ongoing, we discard any non fragmented
|
||||
reassembly. We do not assume that the fragments are received in order.
|
||||
When reassembly of a packet is ongoing, we discard any non fragmented
|
||||
packet or fragment from another packet. Reassembly times out after
|
||||
#SICSLOWPAN_REASS_MAXAGE = 20s.
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ compilation option.
|
|||
|
||||
\note As we do not support complex buffer allocation mechanism, for now
|
||||
we define a new 1280 bytes buffer (#sicslowpan_buf) to reassemble packets.
|
||||
At reception, once all the fragments are received, we copy the packet
|
||||
At reception, once all the fragments are received, we copy the packet
|
||||
to #uip_buf, set #uip_len, and call #tcpip_input.
|
||||
|
||||
\note #MAC_MAX_PAYLOAD defines the maximum payload
|
||||
|
|
@ -161,7 +161,7 @@ The #SICSLOWPAN_CONF_COMPRESSION compilation option defines the
|
|||
HC1 and IPv6 compression are defined in RFC4944, HC01 in
|
||||
draft-hui-6lowpan-hc. What we call IPv6 compression means sending packets
|
||||
with no compression, and adding the IPv6 dispatch before the IPv6 header.<br>
|
||||
If at compile time IPv6 "compression" is chosen, packets sent will never
|
||||
If at compile time IPv6 "compression" is chosen, packets sent will never
|
||||
be compressed, and compressed packets will not be processed at reception.<br>
|
||||
If at compile time either HC1 or HC01 are chosen, we will try to compress
|
||||
all fields at sending, and will accept packets compressed with the
|
||||
|
|
@ -170,7 +170,7 @@ Note that HC1 and HC01 supports are mutually exclusive. HC01 should soon
|
|||
deprecate HC1.
|
||||
|
||||
<b>Compression related functions</b><br>
|
||||
When a packet is received, the #input function is called. Fragmentation
|
||||
When a packet is received, the #input function is called. Fragmentation
|
||||
issues are handled, then we check the dispatch byte: if it is IPv6, we
|
||||
treat the packet inline. If it is HC1 or HC01, the corresponding
|
||||
decompression function (#uncompress_hdr_hc1 or #uncompress_hdr_hc01)
|
||||
|
|
@ -184,21 +184,21 @@ to compress the packet as much as possible.
|
|||
<b>HC1 comments</b><br>
|
||||
In HC1, if the IPv6 flow label is not compressed, we would need to copy
|
||||
the fields after the flow label starting in the middle of a byte (the
|
||||
flow label is 20 bits long). To avoid this, we compress the packets only
|
||||
flow label is 20 bits long). To avoid this, we compress the packets only
|
||||
if all fields can be compressed. If we cannot, we use the IPv6 dispatch
|
||||
and send all headers fields inline. This behavior is the one defined in
|
||||
draft-hui-6lowpan-interop-00.<br>
|
||||
In the same way, if the packet is an UDP packet, we compress the UDP
|
||||
In the same way, if the packet is an UDP packet, we compress the UDP
|
||||
header only if all fields can be compressed.<br>
|
||||
Note that HC1 can only compress unicast link local addresses. For this
|
||||
Note that HC1 can only compress unicast link local addresses. For this
|
||||
reason, we recommend using HC01.
|
||||
|
||||
<b>HC01 comments</b><br>
|
||||
HC01 uses address contexts to enable compression of global unicast
|
||||
HC01 uses address contexts to enable compression of global unicast
|
||||
addresses. All nodes must share context (namely the global prefixes in
|
||||
use) to compress and uncompress such addresses successfully. The context
|
||||
number is defined by 2 bits. Context 00 is reserved for the link local
|
||||
context. Other contexts have to be distributed within the LoWPAN
|
||||
number is defined by 2 bits. Context 00 is reserved for the link local
|
||||
context. Other contexts have to be distributed within the LoWPAN
|
||||
dynamically, by means of ND extensions yet to be defined.<br>
|
||||
Until then, if you want to test global address compression, you need
|
||||
to configure the global contexts manually.
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
/**
|
||||
* \defgroup uip6 uIP IPv6 specific features
|
||||
*
|
||||
The uIP IPv6 stack provides new Internet communication abilities to Contiki.
|
||||
The uIP IPv6 stack provides new Internet communication abilities to Contiki.
|
||||
This document describes Ipv6 specific features. For features that
|
||||
are common to the IPv4 and IPv6 code please refer to \ref uip "uIP".
|
||||
|
||||
|
|
@ -21,7 +21,7 @@ for extensions and options, and its new QoS and security capabilities.
|
|||
|
||||
The uip IPv6 stack implementation targets constrained devices such as
|
||||
sensors. The code size is around 11.5Kbyte and the RAM usage around
|
||||
1.7Kbyte (see \ref size "below" for more detailed information).
|
||||
1.7Kbyte (see \ref size "below" for more detailed information).
|
||||
Our implementation follows closely RFC 4294 <em>IPv6 Node Requirements</em>
|
||||
whose goal is to allow "IPv6 to function well and
|
||||
interoperate in a large number of situations and deployments".
|
||||
|
|
@ -38,12 +38,12 @@ http://www.ietf.org/rfc.html.
|
|||
|
||||
\note The #NETSTACK_CONF_WITH_IPV6 compilation flag is used to enable IPv6.
|
||||
It is also recommended to set #UIP_CONF_IPV6_CHECKS to 1
|
||||
if one cannot guarantee that the incoming packets are correctly formed.
|
||||
if one cannot guarantee that the incoming packets are correctly formed.
|
||||
|
||||
\subsection ipv6 IPv6 (RFC 2460)
|
||||
The IP packets are processed in the #uip_process function.
|
||||
After a few validity checks on the IPv6 header, the extension headers
|
||||
are processed until an upper layer (ICMPv6, UDP or TCP) header is found.
|
||||
are processed until an upper layer (ICMPv6, UDP or TCP) header is found.
|
||||
We support 4 extension headers:
|
||||
\li Hop-by-Hop Options: this header is used to carry optional
|
||||
information that need to be examined only by a packet's destination node.
|
||||
|
|
@ -81,18 +81,18 @@ typedef union uip_ip6addr_t {
|
|||
\endcode
|
||||
|
||||
We assume that each node has a <em>single interface</em> of type
|
||||
#uip_ds6_netif_t.
|
||||
#uip_ds6_netif_t.
|
||||
|
||||
Each interface can have a configurable number of unicast IPv6
|
||||
addresses including its link-local address. It also has a
|
||||
solicited-node multicast address. We assume that the unicast
|
||||
addresses are obtained via \ref autoconf "stateless address autoconfiguration"
|
||||
addresses are obtained via \ref autoconf "stateless address autoconfiguration"
|
||||
so that the solicited-node address is the same for all the
|
||||
unicast addresses. Indeed, the solicited-node multicast address
|
||||
is formed by combining the prefix FF02::1:FF00:0/104 and the
|
||||
last 24-bits of the corresponding IPv6 address. When using stateless address
|
||||
autoconfiguration these bits are always equal to the last 24-bits of
|
||||
the link-layer address.
|
||||
the link-layer address.
|
||||
|
||||
\subsection multicast Multicast support
|
||||
We do not support applications using multicast. Nevertheless, our node
|
||||
|
|
@ -108,7 +108,7 @@ safely skipped and we do so.
|
|||
other's presence, to determine each other's link-layer addresses, to
|
||||
find routers, and to maintain reachability information about the paths
|
||||
to active neighbors" (citation from the abstract of RFC
|
||||
4861).
|
||||
4861).
|
||||
|
||||
\note In IPv6 terminology, a \em link is a communication medium over
|
||||
which nodes can communicate at the link layer, i.e., the layer
|
||||
|
|
@ -157,7 +157,7 @@ different entry fields.
|
|||
<b>Neighbor discovery processes </b><br>
|
||||
\li Address resolution\n
|
||||
Determine the link-layer address of a %neighbor given its IPv6 address.\n
|
||||
-> send a NS (done in #tcpip_ipv6_output).
|
||||
-> send a NS (done in #tcpip_ipv6_output).
|
||||
\li Neighbor unreachability detection\n
|
||||
Verify that a neighbor is still reachable via a cached link-layer
|
||||
address.\n
|
||||
|
|
@ -183,7 +183,7 @@ Configure an address for an interface by combining a received prefix
|
|||
and the interface ID (see #uip_netif_addr_add). The interface ID is
|
||||
obtained from the link-layer address using #uip_netif_get_interface_id.\n
|
||||
-> Receive a RA with a prefix information option that has the
|
||||
autonomous flag set.
|
||||
autonomous flag set.
|
||||
|
||||
When an interface becomes active, its link-local address is created
|
||||
by combining the FE80::0/64 prefix and the interface ID. DAD is then
|
||||
|
|
@ -196,14 +196,14 @@ performed in #uip_netif_init.
|
|||
\subsection icmpv6 ICMPv6 (RFC 4443)
|
||||
We support ICMPv6 Error messages as well as Echo Reply and Echo Request
|
||||
messages. The application used for sending Echo Requests (see ping6.c)
|
||||
is not part of the IP stack.
|
||||
is not part of the IP stack.
|
||||
|
||||
\note RFC 4443 stipulates that 'Every ICMPv6 error message MUST
|
||||
include as much of the IPv6 offending (invoking) packet as
|
||||
possible'. In a constrained environment this is not very resource
|
||||
friendly.
|
||||
|
||||
The ICMPv6 message headers and constants are defined in uip-icmp6.h.
|
||||
The ICMPv6 message headers and constants are defined in uip-icmp6.h.
|
||||
|
||||
<HR>
|
||||
|
||||
|
|
@ -232,16 +232,16 @@ This could be avoided by using callback timers to handle ND and Netif structures
|
|||
<HR>
|
||||
|
||||
\section compileflags Compile time flags and variables
|
||||
This section just lists all IPv6 related compile time flags. Each flag
|
||||
This section just lists all IPv6 related compile time flags. Each flag
|
||||
function is documented in this page in the appropriate section.
|
||||
\code
|
||||
/*Boolean flags*/
|
||||
NETSTACK_CONF_WITH_IPV6
|
||||
NETSTACK_CONF_WITH_IPV6
|
||||
UIP_CONF_IPV6_CHECKS
|
||||
UIP_CONF_IPV6_QUEUE_PKT
|
||||
UIP_CONF_IPV6_REASSEMBLY
|
||||
UIP_CONF_IPV6_QUEUE_PKT
|
||||
UIP_CONF_IPV6_REASSEMBLY
|
||||
/*Integer flags*/
|
||||
UIP_CONF_NETIF_MAX_ADDRESSES
|
||||
UIP_CONF_NETIF_MAX_ADDRESSES
|
||||
NBR_TABLE_CONF_MAX_NEIGHBORS
|
||||
\endcode
|
||||
|
||||
|
|
@ -252,7 +252,7 @@ The IPv6 code uses the same \ref memory "single global buffer" as the
|
|||
IPv4 code. This buffer should be large enough to contain one
|
||||
packet of maximum size, i.e., #UIP_LINK_MTU = 1280 bytes. When \ref
|
||||
reass "fragment reassembly" is enabled an additional buffer of the
|
||||
same size is used.
|
||||
same size is used.
|
||||
|
||||
The only difference with the IPv4 code is the per %neighbor buffering
|
||||
that is available when #UIP_CONF_IPV6_QUEUE_PKT is set to 1. This
|
||||
|
|
@ -272,20 +272,20 @@ our code. These numbers are obtained using 'avr-gcc 4.2.2 (WinAVR
|
|||
|
||||
\note The following compilation flags were used:
|
||||
\code
|
||||
UIP_CONF_IPV6 1
|
||||
UIP_CONF_IPV6_CHECKS 1
|
||||
UIP_CONF_IPV6_QUEUE_PKT 0
|
||||
UIP_CONF_IPV6_REASSEMBLY 0
|
||||
UIP_CONF_IPV6 1
|
||||
UIP_CONF_IPV6_CHECKS 1
|
||||
UIP_CONF_IPV6_QUEUE_PKT 0
|
||||
UIP_CONF_IPV6_REASSEMBLY 0
|
||||
|
||||
UIP_NETIF_MAX_ADDRESSES 3
|
||||
UIP_ND6_MAX_PREFIXES 3
|
||||
UIP_ND6_MAX_NEIGHBORS 4
|
||||
UIP_ND6_MAX_DEFROUTER 2
|
||||
UIP_NETIF_MAX_ADDRESSES 3
|
||||
UIP_ND6_MAX_PREFIXES 3
|
||||
UIP_ND6_MAX_NEIGHBORS 4
|
||||
UIP_ND6_MAX_DEFROUTER 2
|
||||
\endcode
|
||||
|
||||
The total IPv6 code size is approximately 11.5Kbyte and the RAM usage around
|
||||
1.8Kbyte. For an additional NEIGHBOR count 35bytes, 25 for an additional
|
||||
PREFIX, 7 for an additional DEFROUTER, and 25 for an additional ADDRESS.
|
||||
PREFIX, 7 for an additional DEFROUTER, and 25 for an additional ADDRESS.
|
||||
|
||||
<HR>
|
||||
|
||||
|
|
@ -345,7 +345,7 @@ We will soon support RFC4944 transmission of IPv6 packets over 802.15.4\n
|
|||
\li ICMPv6 RFC 4443 (MUST): full support
|
||||
\li IPv6 addressing architecture RFC 3513 (MUST): full support
|
||||
\li Privacy extensions for address autoconfiguration RFC 3041 (SHOULD): no support.
|
||||
\li Default Address Selection RFC 3484 (MUST): full support.
|
||||
\li Default Address Selection RFC 3484 (MUST): full support.
|
||||
\li MLDv1 (RFC 2710) and MLDv2 (RFC 3810) (conditional MUST applying here): no support. As we run IPv6 over Multicast or broadcast capable links (Ethernet or 802.15.4), the conditional MUST applies. We should be able to send an MLD report when joining a solicited node multicast group at address configuration time. This will be available in a later release.
|
||||
|
||||
<b>DNS (RFC 1034, 1035, 3152, 3363, 3596) and DHCPv6 (RFC 3315) (conditional MUST)</b><br>
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ void menu_process(char c);
|
|||
extern char usb_busy;
|
||||
|
||||
//! Counter for USB Serial port
|
||||
extern U8 tx_counter;
|
||||
extern U8 tx_counter;
|
||||
|
||||
//! Timers for LEDs
|
||||
uint8_t led3_timer;
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ extract_random_bit_() {
|
|||
cli();
|
||||
|
||||
#ifdef PRR
|
||||
// Enable ADC module
|
||||
// Enable ADC module
|
||||
PRR &= ~(1 << PRADC);
|
||||
#endif
|
||||
|
||||
|
|
@ -100,7 +100,7 @@ extract_random_bit_() {
|
|||
// Toggling the reference voltage
|
||||
// seems to help introduce noise.
|
||||
ADMUX^=(1<<REFS1);
|
||||
|
||||
|
||||
// We only want to exit the loop if the first
|
||||
// and second sampled bits are different.
|
||||
// This is preliminary conditioning.
|
||||
|
|
@ -156,7 +156,7 @@ static uint8_t
|
|||
extract_random_bit_() {
|
||||
uint8_t ret;
|
||||
uint8_t trx_ctrl_0 = hal_register_read(TRX_CTRL_0);
|
||||
|
||||
|
||||
// Set radio clock output to 8MHz
|
||||
hal_register_write(TRX_CTRL_0,0x8|5);
|
||||
|
||||
|
|
@ -170,10 +170,10 @@ extract_random_bit_() {
|
|||
|
||||
// Toss out the other bit, we only care about one of them.
|
||||
ret &= 1;
|
||||
|
||||
|
||||
// Restore the clkm state
|
||||
hal_register_write(TRX_CTRL_0,trx_ctrl_0);
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -191,7 +191,7 @@ contiki_init(void)
|
|||
/* Initialize communication stack */
|
||||
netstack_init();
|
||||
printf("%s/%s/%s, channel check rate %lu Hz\n",
|
||||
NETSTACK_NETWORK.name, NETSTACK_MAC.name, NETSTACK_RDC.name,
|
||||
NETSTACK_NETWORK.name, NETSTACK_MAC.name, NETSTACK_RDC.name,
|
||||
CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1:
|
||||
NETSTACK_RDC.channel_check_interval()));
|
||||
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ contiki_init()
|
|||
set_rime_addr();
|
||||
{
|
||||
uint8_t longaddr[8];
|
||||
|
||||
|
||||
memset(longaddr, 0, sizeof(longaddr));
|
||||
linkaddr_copy((linkaddr_t *)&longaddr, &linkaddr_node_addr);
|
||||
printf("MAC %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
|
||||
|
|
@ -241,7 +241,7 @@ contiki_init()
|
|||
/* Initialize communication stack */
|
||||
netstack_init();
|
||||
printf("%s/%s/%s, channel check rate %lu Hz\n",
|
||||
NETSTACK_NETWORK.name, NETSTACK_MAC.name, NETSTACK_RDC.name,
|
||||
NETSTACK_NETWORK.name, NETSTACK_MAC.name, NETSTACK_RDC.name,
|
||||
CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1:
|
||||
NETSTACK_RDC.channel_check_interval()));
|
||||
|
||||
|
|
@ -294,11 +294,11 @@ contiki_init()
|
|||
int i;
|
||||
lladdr = uip_ds6_get_link_local(-1);
|
||||
for(i = 0; i < 7; ++i) {
|
||||
printf("%02x%02x:", lladdr->ipaddr.u8[i * 2],
|
||||
lladdr->ipaddr.u8[i * 2 + 1]);
|
||||
printf("%02x%02x:", lladdr->ipaddr.u8[i * 2],
|
||||
lladdr->ipaddr.u8[i * 2 + 1]);
|
||||
}
|
||||
printf("%02x%02x\n", lladdr->ipaddr.u8[14],
|
||||
lladdr->ipaddr.u8[15]);
|
||||
lladdr->ipaddr.u8[15]);
|
||||
}
|
||||
|
||||
if(1) {
|
||||
|
|
@ -320,7 +320,7 @@ contiki_init()
|
|||
|
||||
/* Initialize eeprom */
|
||||
eeprom_init();
|
||||
|
||||
|
||||
/* Start serial process */
|
||||
serial_line_init();
|
||||
|
||||
|
|
@ -417,10 +417,9 @@ JNIEXPORT void JNICALL
|
|||
Java_org_contikios_cooja_corecomm_CLASSNAME_setMemory(JNIEnv *env, jobject obj, jint rel_addr, jint length, jbyteArray mem_arr)
|
||||
{
|
||||
jbyte *mem = (*env)->GetByteArrayElements(env, mem_arr, 0);
|
||||
memcpy(
|
||||
(char*) (((long)rel_addr) + referenceVar),
|
||||
mem,
|
||||
length);
|
||||
memcpy((char*) (((long)rel_addr) + referenceVar),
|
||||
mem,
|
||||
length);
|
||||
(*env)->ReleaseByteArrayElements(env, mem_arr, mem, 0);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
|
@ -453,7 +452,7 @@ Java_org_contikios_cooja_corecomm_CLASSNAME_tick(JNIEnv *env, jobject obj)
|
|||
doActionsBeforeTick();
|
||||
|
||||
/* Poll etimer process */
|
||||
if (etimer_pending()) {
|
||||
if(etimer_pending()) {
|
||||
etimer_request_poll();
|
||||
}
|
||||
|
||||
|
|
@ -481,9 +480,9 @@ Java_org_contikios_cooja_corecomm_CLASSNAME_tick(JNIEnv *env, jobject obj)
|
|||
nextRtimer = rtimer_arch_next() - (rtimer_clock_t) simCurrentTime;
|
||||
if(etimer_pending() && rtimer_arch_pending()) {
|
||||
simNextExpirationTime = MIN(nextEtimer, nextRtimer);
|
||||
} else if (etimer_pending()) {
|
||||
} else if(etimer_pending()) {
|
||||
simNextExpirationTime = nextEtimer;
|
||||
} else if (rtimer_arch_pending()) {
|
||||
} else if(rtimer_arch_pending()) {
|
||||
simNextExpirationTime = nextRtimer;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -122,5 +122,4 @@ status(int type)
|
|||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
SENSORS_SENSOR(acc_sensor, ACC_SENSOR,
|
||||
value, configure, status);
|
||||
SENSORS_SENSOR(acc_sensor, ACC_SENSOR, value, configure, status);
|
||||
|
|
|
|||
|
|
@ -100,5 +100,4 @@ configure(int type, int c)
|
|||
}
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
SENSORS_SENSOR(ext_sensor, "Ext",
|
||||
value, configure, status);
|
||||
SENSORS_SENSOR(ext_sensor, "Ext", value, configure, status);
|
||||
|
|
|
|||
Loading…
Reference in New Issue