giomba/nes-proj
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #37 from simonduq/pr/rm-libs

Browse Source 
Removing old/unused libs
This commit is contained in:
Nicolas Tsiftes 2017-06-21 14:30:15 +02:00 committed by GitHub
commit a5a830beb1
19 changed files with 1 additions and 2133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/contiki-lib.h
View File

@ -37,7 +37,6 @@
#include "contiki.h"
#include "lib/list.h"
#include "lib/memb.h"
#include "lib/mmem.h"
#include "lib/random.h"
#endif /* CONTIKI_LIB_H_ */

162
core/lib/gcr.c
View File

@ -1,162 +0,0 @@
/*
* Copyright (c) 2006, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \file
* Implementation of GCR coding/decoding
* \author
* Joakim Eriksson <joakime@sics.se>
*
*/
/* GCR conversion table - used for converting ordinary byte to 10-bits */
/* (or 4 bits to 5) */
static const unsigned char GCR_encode[16] = {
0x0a, 0x0b, 0x12, 0x13,
0x0e, 0x0f, 0x16, 0x17,
0x09, 0x19, 0x1a, 0x1b,
0x0d, 0x1d, 0x1e, 0x15
};
/* 5 bits > 4 bits (0xff => invalid) */
static const unsigned char GCR_decode[32] = {
0xff, 0xff, 0xff, 0xff, // 0 - 3invalid...
0xff, 0xff, 0xff, 0xff, // 4 - 7 invalid...
0xff, 0x08, 0x00, 0x01, // 8 invalid... 9 = 8, a = 0, b = 1
0xff, 0x0c, 0x04, 0x05, // c invalid... d = c, e = 4, f = 5
0xff, 0xff, 0x02, 0x03, // 10-11 invalid...
0xff, 0x0f, 0x06, 0x07, // 14 invalid...
0xff, 0x09, 0x0a, 0x0b, // 18 invalid...
0xff, 0x0d, 0x0e, 0xff, // 1c, 1f invalid...
};
static unsigned char gcr_bits = 0;
static unsigned short gcr_val = 0;
/* Call before starting encoding or decoding */
void gcr_init(void) {
gcr_val = 0;
gcr_bits = 0;
}
/* Use this to check if encoding / decoding is complete for now */
unsigned char gcr_finished(void) {
return gcr_bits == 0;
}
/* Encode one character - and store in bits - get encoded with get_encoded */
void gcr_encode(unsigned char raw_data) {
gcr_val |=
((GCR_encode[raw_data >> 4u] << 5u ) |
GCR_encode[raw_data & 0xf]) << gcr_bits;
gcr_bits += 10;
}
/* Gets the current char of the encoded stream */
unsigned char gcr_get_encoded(unsigned char *raw_data) {
if (gcr_bits >= 8) {
*raw_data = (unsigned char) (gcr_val & 0xff);
gcr_val = gcr_val >> 8u;
gcr_bits = gcr_bits - 8;
return 1;
}
return 0;
}
/* Decode one char - result can be get from get_decoded */
void gcr_decode(unsigned char gcr_data) {
gcr_val |= gcr_data << gcr_bits;
gcr_bits += 8;
}
/* check if the current decoded stream is correct */
unsigned char gcr_valid(void) {
if (gcr_bits >= 10) {
unsigned short val = gcr_val & 0x3ff;
if ((GCR_decode[val >> 5u] << 4u) == 0xff ||
(GCR_decode[val & 0x1f]) == 0xff) {
return 0;
}
}
return 1;
}
/* gets the decoded stream - if any char is available */
unsigned char gcr_get_decoded(unsigned char *raw_data) {
if (gcr_bits >= 10) {
unsigned short val = gcr_val & 0x3ff;
*raw_data = (unsigned char) ((GCR_decode[val >> 5] << 4) |
(GCR_decode[val & 0x1f]));
gcr_val = gcr_val >> 10;
gcr_bits = gcr_bits - 10;
return 1;
}
return 0;
}
/*
static const char encoded[] = {
0x4a, 0x25, 0xa5, 0xfc, 0x96, 0xff, 0xff, 0xb5, 0xd4, 0x5a, 0xea, 0xff, 0xff, 0xaa, 0xd3, 0xff
};
int main(int argc, char **argv) {
// unsigned char c[] = "testing gcr 1 2 3 4 5 6...";
unsigned char c[] = { 0, 8, 0xe0, 0x2b, 0xac, 0x10, 0x01, 0x11, 0x50, 0xff, 0xf4, 0xa4, 0x00 };
unsigned char c2[200];
int pos = 0, pos2 = 0, i = 0;
printf("Testing GCR on: %s \n", c);
gcr_init();
for (i = 0; i < sizeof(c); i++) {
gcr_encode(c[i]);
while(gcr_get_encoded(&c2[pos])) {
printf("%02x=>%02x ", c[i], c2[pos]);
pos++;
}
}
printf("\n");
printf("Encoded result %d chars (from %d) \n", pos, i);
gcr_init();
for (i = 0; i < pos; i++) {
gcr_decode(c2[i]);
if(!gcr_valid()) {
printf("GCR: not valid\n");
}
while(gcr_get_decoded(&c[pos2])) {
pos2++;
}
}
printf("GCR: %s\n",c);
}
*/

51
core/lib/gcr.h
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2006, Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*
* -----------------------------------------------------------------
*
* Author : Adam Dunkels, Joakim Eriksson, Niclas Finne
* Created : 2006-10-02
* Updated : $Date: 2006/10/05 09:23:41 $
* $Revision: 1.1 $
*/
#ifndef GCR_H_
#define GCR_H_
void gcr_init();
unsigned char gcr_finished();
void gcr_encode(unsigned char raw_data);
void gcr_decode(unsigned char gcr_data);
unsigned char gcr_get_encoded(unsigned char *raw_data);
unsigned char gcr_get_decoded(unsigned char *raw_data);
unsigned char gcr_valid();
#endif /* GCR_H_ */

116
core/lib/me.c
View File

@ -1,116 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/** \addtogroup me
* @{ */
/**
* \file
* Implementation of the table-driven Manchester encoding and decoding.
* \author
* Adam Dunkels <adam@sics.se>
*/
#include "me_tabs.h"
/*---------------------------------------------------------------------------*/
/**
* Manchester encode an 8-bit byte.
*
* This function Manchester encodes an 8-bit byte into a 16-bit
* word. The function me_decode() does the inverse operation.
*
* \param c The byte to be encoded
*
* \retval The encoded word.
*/
/*---------------------------------------------------------------------------*/
unsigned short
me_encode(unsigned char c)
{
return me_encode_tab[c];
}
/*---------------------------------------------------------------------------*/
/**
* Decode a Manchester encoded 16-bit word.
*
* This function decodes a Manchester encoded 16-bit word into a 8-bit
* byte. The function does not check for parity errors in the encoded
* byte.
*
* \param m The 16-bit Manchester encoded word
* \return The decoded 8-bit byte
*/
/*---------------------------------------------------------------------------*/
unsigned char
me_decode16(unsigned short m)
{
unsigned char m1, m2, c;
m1 = m >> 8;
m2 = m & 0xff;
c = (me_decode_tab[m1] << 4) |
me_decode_tab[m2];
return c;
}
/*---------------------------------------------------------------------------*/
/**
* Decode a Manchester encoded 8-bit byte.
*
* This function decodes a Manchester encoded 8-bit byte into 4
* decoded bits.. The function does not check for parity errors in the
* encoded byte.
*
* \param m The 8-bit Manchester encoded byte
* \return The decoded 4 bits
*/
/*---------------------------------------------------------------------------*/
unsigned char
me_decode8(unsigned char m)
{
return me_decode_tab[m];
}
/*---------------------------------------------------------------------------*/
/**
* Check if an encoded byte is valid.
*/
/*---------------------------------------------------------------------------*/
unsigned char
me_valid(unsigned char m)
{
return me_valid_tab[m];
}
/*---------------------------------------------------------------------------*/
/** @} */

75
core/lib/me.h
View File

@ -1,75 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/** \addtogroup lib
@{ */
/**
* \defgroup me Table-driven Manchester encoding and decoding
*
* Manchester encoding is a bit encoding scheme which translates each
* bit into two bits: the original bit and the inverted bit.
*
* Manchester encoding is used for transmitting ones and zeroes
* between two computers. The Manchester encoding reduces the receive
* oscillator drift by making sure that no consecutive ones or zeroes
* are ever transmitted.
*
* The table driven method of Manchester encoding and decoding uses
* two tables with 256 entries. One table is a direct mapping of an
* 8-bit byte into a 16-bit Manchester encoding of the byte. The
* second table is a mapping of a Manchester encoded 8-bit byte to 4
* decoded bits.
*
* @{
*/
/**
* \file
* Header file for the table-driven Manchester encoding and decoding
* \author
* Adam Dunkels <adam@sics.se>
*
*/
#ifndef ME_H_
#define ME_H_
unsigned char me_valid(unsigned char m);
unsigned short me_encode(unsigned char c);
unsigned char me_decode16(unsigned short m);
unsigned char me_decode8(unsigned char m);
#endif /* ME_H_ */
/** @} */
/** @} */

121
core/lib/me_tabs.c
View File

@ -1,121 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
const unsigned short me_encode_tab[256] = {
0x5555, 0x5556, 0x5559, 0x555a, 0x5565, 0x5566, 0x5569, 0x556a, 0x5595,
0x5596, 0x5599, 0x559a, 0x55a5, 0x55a6, 0x55a9, 0x55aa, 0x5655, 0x5656,
0x5659, 0x565a, 0x5665, 0x5666, 0x5669, 0x566a, 0x5695, 0x5696, 0x5699,
0x569a, 0x56a5, 0x56a6, 0x56a9, 0x56aa, 0x5955, 0x5956, 0x5959, 0x595a,
0x5965, 0x5966, 0x5969, 0x596a, 0x5995, 0x5996, 0x5999, 0x599a, 0x59a5,
0x59a6, 0x59a9, 0x59aa, 0x5a55, 0x5a56, 0x5a59, 0x5a5a, 0x5a65, 0x5a66,
0x5a69, 0x5a6a, 0x5a95, 0x5a96, 0x5a99, 0x5a9a, 0x5aa5, 0x5aa6, 0x5aa9,
0x5aaa, 0x6555, 0x6556, 0x6559, 0x655a, 0x6565, 0x6566, 0x6569, 0x656a,
0x6595, 0x6596, 0x6599, 0x659a, 0x65a5, 0x65a6, 0x65a9, 0x65aa, 0x6655,
0x6656, 0x6659, 0x665a, 0x6665, 0x6666, 0x6669, 0x666a, 0x6695, 0x6696,
0x6699, 0x669a, 0x66a5, 0x66a6, 0x66a9, 0x66aa, 0x6955, 0x6956, 0x6959,
0x695a, 0x6965, 0x6966, 0x6969, 0x696a, 0x6995, 0x6996, 0x6999, 0x699a,
0x69a5, 0x69a6, 0x69a9, 0x69aa, 0x6a55, 0x6a56, 0x6a59, 0x6a5a, 0x6a65,
0x6a66, 0x6a69, 0x6a6a, 0x6a95, 0x6a96, 0x6a99, 0x6a9a, 0x6aa5, 0x6aa6,
0x6aa9, 0x6aaa, 0x9555, 0x9556, 0x9559, 0x955a, 0x9565, 0x9566, 0x9569,
0x956a, 0x9595, 0x9596, 0x9599, 0x959a, 0x95a5, 0x95a6, 0x95a9, 0x95aa,
0x9655, 0x9656, 0x9659, 0x965a, 0x9665, 0x9666, 0x9669, 0x966a, 0x9695,
0x9696, 0x9699, 0x969a, 0x96a5, 0x96a6, 0x96a9, 0x96aa, 0x9955, 0x9956,
0x9959, 0x995a, 0x9965, 0x9966, 0x9969, 0x996a, 0x9995, 0x9996, 0x9999,
0x999a, 0x99a5, 0x99a6, 0x99a9, 0x99aa, 0x9a55, 0x9a56, 0x9a59, 0x9a5a,
0x9a65, 0x9a66, 0x9a69, 0x9a6a, 0x9a95, 0x9a96, 0x9a99, 0x9a9a, 0x9aa5,
0x9aa6, 0x9aa9, 0x9aaa, 0xa555, 0xa556, 0xa559, 0xa55a, 0xa565, 0xa566,
0xa569, 0xa56a, 0xa595, 0xa596, 0xa599, 0xa59a, 0xa5a5, 0xa5a6, 0xa5a9,
0xa5aa, 0xa655, 0xa656, 0xa659, 0xa65a, 0xa665, 0xa666, 0xa669, 0xa66a,
0xa695, 0xa696, 0xa699, 0xa69a, 0xa6a5, 0xa6a6, 0xa6a9, 0xa6aa, 0xa955,
0xa956, 0xa959, 0xa95a, 0xa965, 0xa966, 0xa969, 0xa96a, 0xa995, 0xa996,
0xa999, 0xa99a, 0xa9a5, 0xa9a6, 0xa9a9, 0xa9aa, 0xaa55, 0xaa56, 0xaa59,
0xaa5a, 0xaa65, 0xaa66, 0xaa69, 0xaa6a, 0xaa95, 0xaa96, 0xaa99, 0xaa9a,
0xaaa5, 0xaaa6, 0xaaa9, 0xaaaa, };
const unsigned char me_decode_tab[256] = {
0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x2,
0x2, 0x3, 0x3, 0x2, 0x2, 0x3, 0x3, 0x0, 0x0,
0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3,
0x3, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5,
0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7, 0x6,
0x6, 0x7, 0x7, 0x4, 0x4, 0x5, 0x5, 0x4, 0x4,
0x5, 0x5, 0x6, 0x6, 0x7, 0x7, 0x6, 0x6, 0x7,
0x7, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1,
0x2, 0x2, 0x3, 0x3, 0x2, 0x2, 0x3, 0x3, 0x0,
0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2,
0x3, 0x3, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5,
0x5, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7,
0x6, 0x6, 0x7, 0x7, 0x4, 0x4, 0x5, 0x5, 0x4,
0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7, 0x6, 0x6,
0x7, 0x7, 0x8, 0x8, 0x9, 0x9, 0x8, 0x8, 0x9,
0x9, 0xa, 0xa, 0xb, 0xb, 0xa, 0xa, 0xb, 0xb,
0x8, 0x8, 0x9, 0x9, 0x8, 0x8, 0x9, 0x9, 0xa,
0xa, 0xb, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xc,
0xd, 0xd, 0xc, 0xc, 0xd, 0xd, 0xe, 0xe, 0xf,
0xf, 0xe, 0xe, 0xf, 0xf, 0xc, 0xc, 0xd, 0xd,
0xc, 0xc, 0xd, 0xd, 0xe, 0xe, 0xf, 0xf, 0xe,
0xe, 0xf, 0xf, 0x8, 0x8, 0x9, 0x9, 0x8, 0x8,
0x9, 0x9, 0xa, 0xa, 0xb, 0xb, 0xa, 0xa, 0xb,
0xb, 0x8, 0x8, 0x9, 0x9, 0x8, 0x8, 0x9, 0x9,
0xa, 0xa, 0xb, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc,
0xc, 0xd, 0xd, 0xc, 0xc, 0xd, 0xd, 0xe, 0xe,
0xf, 0xf, 0xe, 0xe, 0xf, 0xf, 0xc, 0xc, 0xd,
0xd, 0xc, 0xc, 0xd, 0xd, 0xe, 0xe, 0xf, 0xf,
0xe, 0xe, 0xf, 0xf, };
const unsigned char me_valid_tab[256] = {
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1,
0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0,
0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, };

40
core/lib/me_tabs.h
View File

@ -1,40 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
#ifndef ME_TABS_H_
#define ME_TABS_H_
extern const unsigned short me_encode_tab[256];
extern const unsigned char me_decode_tab[256];
extern const unsigned char me_valid_tab[256];
#endif /* ME_TABS_H_ */

164
core/lib/mmem.c
View File

@ -1,164 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \addtogroup mmem
* @{
*/
/**
* \file
* Implementation of the managed memory allocator
* \author
* Adam Dunkels <adam@sics.se>
*
*/
#include "mmem.h"
#include "list.h"
#include "contiki-conf.h"
#include <string.h>
#ifdef MMEM_CONF_SIZE
#define MMEM_SIZE MMEM_CONF_SIZE
#else
#define MMEM_SIZE 4096
#endif
LIST(mmemlist);
unsigned int avail_memory;
static char memory[MMEM_SIZE];
/*---------------------------------------------------------------------------*/
/**
* \brief Allocate a managed memory block
* \param m A pointer to a struct mmem.
* \param size The size of the requested memory block
* \return Non-zero if the memory could be allocated, zero if memory
* was not available.
* \author Adam Dunkels
*
* This function allocates a chunk of managed memory. The
* memory allocated with this function must be deallocated
* using the mmem_free() function.
*
* \note This function does NOT return a pointer to the
* allocated memory, but a pointer to a structure that
* contains information about the managed memory. The
* macro MMEM_PTR() is used to get a pointer to the
* allocated memory.
*
*/
int
mmem_alloc(struct mmem *m, unsigned int size)
{
/* Check if we have enough memory left for this allocation. */
if(avail_memory < size) {
return 0;
}
/* We had enough memory so we add this memory block to the end of
the list of allocated memory blocks. */
list_add(mmemlist, m);
/* Set up the pointer so that it points to the first available byte
in the memory block. */
m->ptr = &memory[MMEM_SIZE - avail_memory];
/* Remember the size of this memory block. */
m->size = size;
/* Decrease the amount of available memory. */
avail_memory -= size;
/* Return non-zero to indicate that we were able to allocate
memory. */
return 1;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Deallocate a managed memory block
* \param m A pointer to the managed memory block
* \author Adam Dunkels
*
* This function deallocates a managed memory block that
* previously has been allocated with mmem_alloc().
*
*/
void
mmem_free(struct mmem *m)
{
struct mmem *n;
if(m->next != NULL) {
/* Compact the memory after the allocation that is to be removed
by moving it downwards. */
memmove(m->ptr, m->next->ptr,
&memory[MMEM_SIZE - avail_memory] - (char *)m->next->ptr);
/* Update all the memory pointers that points to memory that is
after the allocation that is to be removed. */
for(n = m->next; n != NULL; n = n->next) {
n->ptr = (void *)((char *)n->ptr - m->size);
}
}
avail_memory += m->size;
/* Remove the memory block from the list. */
list_remove(mmemlist, m);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Initialize the managed memory module
* \author Adam Dunkels
*
* This function initializes the managed memory module and
* should be called before any other function from the
* module.
*
*/
void
mmem_init(void)
{
static int inited = 0;
if(inited) {
return;
}
list_init(mmemlist);
avail_memory = MMEM_SIZE;
inited = 1;
}
/*---------------------------------------------------------------------------*/
/** @} */

93
core/lib/mmem.h
View File

@ -1,93 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \addtogroup mem
* @{
*/
/**
* \defgroup mmem Managed memory allocator
*
* The managed memory allocator is a fragmentation-free memory
* manager. It keeps the allocated memory free from fragmentation by
* compacting the memory when blocks are freed. A program that uses
* the managed memory module cannot be sure that allocated memory
* stays in place. Therefore, a level of indirection is used: access
* to allocated memory must always be done using a special macro.
*
* \note This module has not been heavily tested.
* @{
*/
/**
* \file
* Header file for the managed memory allocator
* \author
* Adam Dunkels <adam@sics.se>
*
*/
#ifndef MMEM_H_
#define MMEM_H_
/*---------------------------------------------------------------------------*/
/**
* \brief Get a pointer to the managed memory
* \param m A pointer to the struct mmem
* \return A pointer to the memory block, or NULL if memory could
* not be allocated.
* \author Adam Dunkels
*
* This macro is used to get a pointer to a memory block
* allocated with mmem_alloc().
*
* \hideinitializer
*/
#define MMEM_PTR(m) (struct mmem *)(m)->ptr
struct mmem {
struct mmem *next;
unsigned int size;
void *ptr;
};
/* XXX: tagga minne med "interrupt usage", vilke gör att man är
speciellt varsam under free(). */
int mmem_alloc(struct mmem *m, unsigned int size);
void mmem_free(struct mmem *);
void mmem_init(void);
#endif /* MMEM_H_ */
/** @} */
/** @} */

119
core/lib/petsciiconv.c
View File

@ -1,119 +0,0 @@
/*
* Copyright (c) 2002, Adam Dunkels.
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki desktop environment for the C64.
*
*
*/
/*
static unsigned char petscii2ascii[128] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x14,0x09,0x0d,0x11,0x93,0x0a,0x0e,0x0f,
0x10,0x0b,0x12,0x13,0x08,0x15,0x16,0x17,
0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
0x78,0x79,0x7a,0x5b,0x5c,0x5d,0x7e,0x5f,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,
0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,
0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0x7e,0xdf
};
*/
static unsigned char ascii2petscii[128] = {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x14,0x09,0x0d,0x11,0x93,0x0a,0x0e,0x0f,
0x10,0x0b,0x12,0x13,0x08,0x15,0x16,0x17,
0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
0x40,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,
0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,
0xd8,0xd9,0xda,0x5b,0x5c,0x5d,0x5e,0x5f,
0xc0,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
0x58,0x59,0x5a,0xdb,0xdd,0xdd,0x5e,0xdf,
};
/*-----------------------------------------------------------------------------------*/
void
petsciiconv_toascii(char *buf, unsigned int len)
{
unsigned int i;
char *ptr;
char c;
ptr = buf;
for(i = len; i > 0; --i) {
c = *ptr;
if(c == 0x0a) {
c = 0x0d;
} else if(c == 0x0d) {
c = 0x0a;
}
if(c != 0x40) {
switch (c & 0xe0) {
case 0x40:
case 0x60:
c ^= 0x20;
break;
case 0xc0:
c ^= 0x80;
break;
}
}
*ptr = c & 0x7f;
++ptr;
}
}
/*-----------------------------------------------------------------------------------*/
void
petsciiconv_topetscii(char *buf, unsigned int len)
{
unsigned int i;
char *ptr;
ptr = buf;
for(i = len; i > 0; --i) {
*ptr = ascii2petscii[*ptr & 0x7f];
++ptr;
}
}
/*-----------------------------------------------------------------------------------*/

79
core/lib/petsciiconv.h
View File

@ -1,79 +0,0 @@
/*
* Copyright (c) 2002, Adam Dunkels.
* 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. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki desktop environment for the C64.
*
*
*/
/**
* \file
* PETSCII/ASCII conversion functions.
* \author Adam Dunkels <adam@dunkels.com>
*
* The Commodore based Contiki targets all have a special character
* encoding called PETSCII which differs from the ASCII encoding that
* normally is used for representing characters.
*
* \note For targets that do not use PETSCII encoding the C compiler
* define WITH_ASCII should be used to avoid the PETSCII converting
* functions.
*
*/
#ifndef PETSCIICONV_H_
#define PETSCIICONV_H_
#ifdef WITH_PETSCII
#include "contiki-conf.h"
/**
* Convert a text buffer from PETSCII to ASCII.
*
* \param buf A pointer to the buffer which is to be converted.
* \param len The length of the buffer to be converted.
*/
void petsciiconv_toascii(char *buf, unsigned int len);
/**
* Convert a text buffer from ASCII to PETSCII.
*
* \param buf A pointer to the buffer which is to be converted.
* \param len The length of the buffer to be converted.
*/
void petsciiconv_topetscii(char *buf, unsigned int len);
#else /* WITH_PETSCII */
#define petsciiconv_toascii(buf, len)
#define petsciiconv_topetscii(buf, len)
#endif /* WITH_PETSCII */
#endif /* PETSCIICONV_H_ */

82
core/lib/print-stats.c
View File

@ -1,82 +0,0 @@
/*
* Copyright (c) 2007, Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \file
* Convenience function for printing system statistics
* \author
* Adam Dunkels <adam@sics.se>
*/
#include "lib/print-stats.h"
#include "net/linkaddr.h"
#include "sys/energest.h"
#include "sys/clock.h"
#include <stdio.h>
#define PRINTA(...) printf(__VA_ARGS__)
/*---------------------------------------------------------------------------*/
void
print_stats(void)
{
#if RIMESTATS_CONF_ENABLED
PRINTA("S %d.%d clock %lu tx %lu rx %lu rtx %lu rrx %lu rexmit %lu acktx %lu noacktx %lu ackrx %lu timedout %lu badackrx %lu toolong %lu tooshort %lu badsynch %lu badcrc %lu contentiondrop %lu sendingdrop %lu lltx %lu llrx %lu\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
clock_seconds(),
RIMESTATS_GET(tx), RIMESTATS_GET(rx),
RIMESTATS_GET(reliabletx), RIMESTATS_GET(reliablerx),
RIMESTATS_GET(rexmit), RIMESTATS_GET(acktx), RIMESTATS_GET(noacktx),
RIMESTATS_GET(ackrx), RIMESTATS_GET(timedout), RIMESTATS_GET(badackrx),
RIMESTATS_GET(toolong), RIMESTATS_GET(tooshort),
RIMESTATS_GET(badsynch), RIMESTATS_GET(badcrc),
RIMESTATS_GET(contentiondrop), RIMESTATS_GET(sendingdrop),
RIMESTATS_GET(lltx), RIMESTATS_GET(llrx));
#endif /* RIMESTATS_CONF_ENABLED */
#if ENERGEST_CONF_ON
PRINTA("E %d.%d clock %lu cpu %lu lpm %lu irq %lu gled %lu yled %lu rled %lu tx %lu listen %lu sensors %lu serial %lu\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
clock_seconds(),
energest_total_time[ENERGEST_TYPE_CPU].current,
energest_total_time[ENERGEST_TYPE_LPM].current,
energest_total_time[ENERGEST_TYPE_IRQ].current,
energest_total_time[ENERGEST_TYPE_LED_GREEN].current,
energest_total_time[ENERGEST_TYPE_LED_YELLOW].current,
energest_total_time[ENERGEST_TYPE_LED_RED].current,
energest_total_time[ENERGEST_TYPE_TRANSMIT].current,
energest_total_time[ENERGEST_TYPE_LISTEN].current,
energest_total_time[ENERGEST_TYPE_SENSORS].current,
energest_total_time[ENERGEST_TYPE_SERIAL].current);
#endif /* ENERGEST_CONF_ON */
}
/*---------------------------------------------------------------------------*/

45
core/lib/print-stats.h
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2007, Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \file
* Convenience function for printing system statistics
* \author
* Adam Dunkels <adam@sics.se>
*/
#ifndef PRINT_STATS_H_
#define PRINT_STATS_H_
void print_stats(void);
#endif /* PRINT_STATS_H_ */

475
core/lib/settings.c
View File

@ -1,475 +0,0 @@
/*
* Copyright (c) 2013, Robert Quattlebaum.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
#ifdef SETTINGS_CONF_SKIP_CONVENIENCE_FUNCS
#undef SETTINGS_CONF_SKIP_CONVENIENCE_FUNCS
#endif
#define SETTINGS_CONF_SKIP_CONVENIENCE_FUNCS 1
#include "contiki.h"
#include "settings.h"
#include "dev/eeprom.h"
#if CONTIKI_CONF_SETTINGS_MANAGER
#if !EEPROM_CONF_SIZE
#error CONTIKI_CONF_SETTINGS_MANAGER has been set, but EEPROM_CONF_SIZE hasnt!
#endif
#ifndef EEPROM_END_ADDR
#define EEPROM_END_ADDR (EEPROM_CONF_SIZE - 1)
#endif
#ifndef SETTINGS_MAX_SIZE
/** The maximum amount EEPROM dedicated to settings. */
#define SETTINGS_MAX_SIZE (127) /**< Defaults to 127 bytes */
#endif
#ifndef SETTINGS_TOP_ADDR
/** The top address in EEPROM that settings should use. Inclusive. */
#define SETTINGS_TOP_ADDR (settings_iter_t)(EEPROM_END_ADDR)
#endif
#ifndef SETTINGS_BOTTOM_ADDR
/** The lowest address in EEPROM that settings should use. Inclusive. */
#define SETTINGS_BOTTOM_ADDR (SETTINGS_TOP_ADDR + 1 - SETTINGS_MAX_SIZE)
#endif
typedef struct {
#if SETTINGS_CONF_SUPPORT_LARGE_VALUES
uint8_t size_extra;
#endif
uint8_t size_low;
uint8_t size_check;
settings_key_t key;
} item_header_t;
/*****************************************************************************/
// MARK: - Public Travesal Functions
/*****************************************************************************/
/*---------------------------------------------------------------------------*/
settings_iter_t
settings_iter_begin()
{
return settings_iter_is_valid(SETTINGS_TOP_ADDR) ? SETTINGS_TOP_ADDR : 0;
}
/*---------------------------------------------------------------------------*/
settings_iter_t
settings_iter_next(settings_iter_t ret)
{
if(ret) {
/* A settings iterator always points to the first byte
* after the actual key-value pair in memory. This means that
* the address of our value in EEPROM just happens
* to be the address of our next iterator.
*/
ret = settings_iter_get_value_addr(ret);
return settings_iter_is_valid(ret) ? ret : 0;
}
return SETTINGS_INVALID_ITER;
}
/*---------------------------------------------------------------------------*/
uint8_t
settings_iter_is_valid(settings_iter_t iter)
{
item_header_t header = { 0 };
if(iter == EEPROM_NULL) {
return 0;
}
if(iter < SETTINGS_BOTTOM_ADDR + sizeof(header)) {
return 0;
}
eeprom_read(iter - sizeof(header), (uint8_t *)&header, sizeof(header));
if((uint8_t) header.size_check != (uint8_t) ~ header.size_low) {
return 0;
}
if(iter < SETTINGS_BOTTOM_ADDR + sizeof(header) + settings_iter_get_value_length(iter)) {
return 0;
}
return 1;
}
/*---------------------------------------------------------------------------*/
settings_key_t
settings_iter_get_key(settings_iter_t iter)
{
item_header_t header;
eeprom_read(iter - sizeof(header), (uint8_t *)&header, sizeof(header));
if((uint8_t) header.size_check != (uint8_t)~header.size_low) {
return SETTINGS_INVALID_KEY;
}
return header.key;
}
/*---------------------------------------------------------------------------*/
settings_length_t
settings_iter_get_value_length(settings_iter_t iter)
{
item_header_t header;
settings_length_t ret = 0;
eeprom_read(iter - sizeof(header), (uint8_t *)&header, sizeof(header) );
if((uint8_t)header.size_check == (uint8_t)~header.size_low) {
ret = header.size_low;
#if SETTINGS_CONF_SUPPORT_LARGE_VALUES
if(ret & (1 << 7)) {
ret = ((ret & ~(1 << 7)) << 7) | header.size_extra;
}
#endif
}
return ret;
}
/*---------------------------------------------------------------------------*/
eeprom_addr_t
settings_iter_get_value_addr(settings_iter_t iter)
{
settings_length_t len = settings_iter_get_value_length(iter);
#if SETTINGS_CONF_SUPPORT_LARGE_VALUES
len += (len >= 128);
#endif
return iter - sizeof(item_header_t) - len;
}
/*---------------------------------------------------------------------------*/
settings_length_t
settings_iter_get_value_bytes(settings_iter_t iter, void *bytes,
settings_length_t max_length)
{
max_length = MIN(max_length, settings_iter_get_value_length(iter));
eeprom_read(settings_iter_get_value_addr(iter), bytes, max_length);
return max_length;
}
/*---------------------------------------------------------------------------*/
settings_status_t
settings_iter_delete(settings_iter_t iter)
{
settings_status_t ret = SETTINGS_STATUS_FAILURE;
settings_iter_t next = settings_iter_next(iter);
if(!next) {
/* Special case: we are the last item. we can get away with
* just wiping out our own header.
*/
item_header_t header;
memset(&header, 0xFF, sizeof(header));
eeprom_write(iter - sizeof(header), (uint8_t *)&header, sizeof(header));
ret = SETTINGS_STATUS_OK;
}
/* This case requires the settings store to be shifted.
* Currently unimplemented. TODO: Writeme!
*/
ret = SETTINGS_STATUS_UNIMPLEMENTED;
return ret;
}
/*****************************************************************************/
// MARK: - Public Functions
/*****************************************************************************/
/*---------------------------------------------------------------------------*/
uint8_t
settings_check(settings_key_t key, uint8_t index)
{
uint8_t ret = 0;
settings_iter_t iter;
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
if(settings_iter_get_key(iter) == key) {
if(!index) {
ret = 1;
break;
} else {
index--;
}
}
}
return ret;
}
/*---------------------------------------------------------------------------*/
settings_status_t
settings_get(settings_key_t key, uint8_t index, uint8_t *value,
settings_length_t * value_size)
{
settings_status_t ret = SETTINGS_STATUS_NOT_FOUND;
settings_iter_t iter;
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
if(settings_iter_get_key(iter) == key) {
if(!index) {
/* We found it! */
*value_size = settings_iter_get_value_bytes(iter,
(void *)value,
*value_size);
ret = SETTINGS_STATUS_OK;
break;
} else {
/* Nope, keep looking */
index--;
}
}
}
return ret;
}
/*---------------------------------------------------------------------------*/
settings_status_t
settings_add(settings_key_t key, const uint8_t *value,
settings_length_t value_size)
{
settings_status_t ret = SETTINGS_STATUS_FAILURE;
settings_iter_t iter;
item_header_t header;
/* Find the last item. */
for(iter = settings_iter_begin(); settings_iter_next(iter);
iter = settings_iter_next(iter)) {
/* This block intentionally left blank. */
}
if(iter) {
/* Value address of item is the same as the iterator for next item. */
iter = settings_iter_get_value_addr(iter);
} else {
/* This will be the first setting! */
iter = SETTINGS_TOP_ADDR;
}
if(iter < SETTINGS_BOTTOM_ADDR + value_size + sizeof(header)) {
/* This value is too big to store. */
ret = SETTINGS_STATUS_OUT_OF_SPACE;
goto bail;
}
header.key = key;
if(value_size < 0x80) {
/* If the value size is less than 128, then
* we can get away with only using one byte
* to store the size.
*/
header.size_low = value_size;
}
#if SETTINGS_CONF_SUPPORT_LARGE_VALUES
else if(value_size <= SETTINGS_MAX_VALUE_SIZE) {
/* If the value size is larger than or equal to 128,
* then we need to use two bytes. Store
* the most significant 7 bits in the first
* size byte (with MSB set) and store the
* least significant bits in the second
* byte (with LSB clear)
*/
header.size_low = (value_size >> 7) | 0x80;
header.size_extra = value_size & ~0x80;
}
#endif
else {
/* Value size way too big! */
ret = SETTINGS_STATUS_VALUE_TOO_BIG;
goto bail;
}
header.size_check = ~header.size_low;
/* Write the header first */
eeprom_write(iter - sizeof(header), (uint8_t *)&header, sizeof(header));
/* Sanity check, remove once confident */
if(settings_iter_get_value_length(iter) != value_size) {
goto bail;
}
/* Now write the data */
eeprom_write(settings_iter_get_value_addr(iter), (uint8_t *)value, value_size);
/* This should be the last item. If this is not the case,
* then we need to clear out the phantom setting.
*/
if((iter = settings_iter_next(iter))) {
memset(&header, 0xFF, sizeof(header));
eeprom_write(iter - sizeof(header),(uint8_t *)&header, sizeof(header));
}
ret = SETTINGS_STATUS_OK;
bail:
return ret;
}
/*---------------------------------------------------------------------------*/
settings_status_t
settings_set(settings_key_t key, const uint8_t *value,
settings_length_t value_size)
{
settings_status_t ret = SETTINGS_STATUS_FAILURE;
settings_iter_t iter;
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
if(settings_iter_get_key(iter) == key) {
break;
}
}
if((iter == EEPROM_NULL) || !settings_iter_is_valid(iter)) {
ret = settings_add(key, value, value_size);
goto bail;
}
if(value_size != settings_iter_get_value_length(iter)) {
/* Requires the settings store to be shifted. Currently unimplemented. */
ret = SETTINGS_STATUS_UNIMPLEMENTED;
goto bail;
}
/* Now write the data */
eeprom_write(settings_iter_get_value_addr(iter),
(uint8_t *)value, value_size);
ret = SETTINGS_STATUS_OK;
bail:
return ret;
}
/*---------------------------------------------------------------------------*/
settings_status_t
settings_delete(settings_key_t key, uint8_t index)
{
settings_status_t ret = SETTINGS_STATUS_NOT_FOUND;
settings_iter_t iter;
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
if(settings_iter_get_key(iter) == key) {
if(!index) {
/* We found it! */
ret = settings_iter_delete(iter);
break;
} else {
/* Nope, keep looking */
index--;
}
}
}
return ret;
}
/*---------------------------------------------------------------------------*/
void
settings_wipe(void)
{
/* Simply making the first item invalid will effectively
* clear the key-value store.
*/
const uint32_t x = 0xFFFFFF;
eeprom_write(SETTINGS_TOP_ADDR - sizeof(x), (uint8_t *)&x, sizeof(x));
}
/*****************************************************************************/
// MARK: - Other Functions
/*****************************************************************************/
#if DEBUG
#include <stdio.h>
/*---------------------------------------------------------------------------*/
void
settings_debug_dump(void)
{
settings_iter_t iter;
printf("{\n");
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
settings_length_t len = settings_iter_get_value_length(iter);
eeprom_addr_t addr = settings_iter_get_value_addr(iter);
uint8_t byte;
union {
settings_key_t key;
char bytes[0];
} u;
u.key = settings_iter_get_key(iter);
printf("\t\"%c%c\" = <", u.bytes[0], u.bytes[1]);
for(; len; len--, addr++) {
eeprom_read(addr, &byte, 1);
printf("%02X", byte);
if(len != 1) {
printf(" ");
}
}
printf(">;\n");
}
printf("}\n");
}
#endif /* DEBUG */
#endif /* CONTIKI_CONF_SETTINGS_MANAGER */

352
core/lib/settings.h
View File

@ -1,352 +0,0 @@
/*
* Copyright (c) 2013, Robert Quattlebaum
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
#ifndef CONTIKI_SETTINGS_H_
#define CONTIKI_SETTINGS_H_
/** @file settings.h
* @brief Settings Manager
* @author Robert Quattlebaum <darco@deepdarc.com>
*/
/** @addtogroup lib
* @{ */
/** @defgroup settings_lib Settings Manager
*
* The settings manager is an EEPROM-based key-value store. Keys
* are 16-bit integers and values may be up to 16,383 bytes long.
* It is intended to be used to store configuration-related information,
* like network settings, radio channels, etc.
*
* ## Features ##
*
* * Robust data format which requires no initialization.
* * Supports multiple values with the same key.
* * Data can be appended without erasing EEPROM.
* * Max size of settings data can be easily increased in the future,
* as long as it doesn't overlap with application data.
*
* ## Data Format ##
*
* The format was inspired by OLPC manufacturing data, as described here:
* <http://wiki.laptop.org/go/Manufacturing_data>
*
* Since the beginning of EEPROM often contains application-specific
* information, the best place to store settings is at the end of
* EEPROM. Because we are starting at the end of EEPROM, it makes sense
* to grow the list of key-value pairs downward, toward the start of
* EEPROM.
*
* Each key-value pair is stored in memory in the following format:
*
* | Order | Size | Name | Description |
* | -------- | -------- | ---------- | ------------------------------- |
* | 0 | 2 | key | |
* | -2 | 1 | size_check | One's-complement of next byte |
* | -3 | 1 or 2 | size | The size of the value, in bytes |
* | -4 or -5 | variable | value | |
*
* The end of the key-value pairs is denoted by the first invalid entry.
* An invalid entry has any of the following attributes:
*
* * The size_check byte doesn't match the one's compliment
* of the size byte (or size_low byte).
* * The key has a value of 0x0000.
*
* @{ */
#include <stdint.h>
#include <string.h>
#include "dev/eeprom.h"
#include "sys/cc.h"
/*****************************************************************************/
// MARK: - Types
typedef enum {
SETTINGS_STATUS_OK = 0,
SETTINGS_STATUS_FAILURE,
SETTINGS_STATUS_INVALID_ARGUMENT,
SETTINGS_STATUS_NOT_FOUND,
SETTINGS_STATUS_OUT_OF_SPACE,
SETTINGS_STATUS_VALUE_TOO_BIG,
SETTINGS_STATUS_UNIMPLEMENTED,
} settings_status_t;
typedef uint16_t settings_key_t;
typedef uint16_t settings_length_t;
/*****************************************************************************/
// MARK: - Settings Keys
/** Two-character constant macro */
#define TCC(a,b) ((a)+(b)*256)
/* All-capital-letter constants are always contiki-defined. */
#define SETTINGS_KEY_EUI64 TCC('E','8') /**< EUI64 Address, 8 bytes */
#define SETTINGS_KEY_EUI48 TCC('E','6') /*!< MAC Address, 6 bytes */
#define SETTINGS_KEY_CHANNEL TCC('C','H') /*!< Channel number, uint8_t */
#define SETTINGS_KEY_TXPOWER TCC('T','P') /*!< Transmit power, uint8_t */
#define SETTINGS_KEY_PAN_ID TCC('P','N') /*!< PAN ID, uint16_t */
#define SETTINGS_KEY_PAN_ADDR TCC('P','A') /*!< PAN address, uint16_t */
#define SETTINGS_KEY_AES128KEY TCC('S','K') /*!< AES128 key, 16 bytes */
#define SETTINGS_KEY_AES128ENABLED TCC('S','E') /*!< AES128 enabled, bool */
#define SETTINGS_KEY_HOSTNAME TCC('H','N') /*!< Hostname, C-String */
#define SETTINGS_KEY_DOMAINNAME TCC('D','N') /*!< Domainname, C-String */
/*****************************************************************************/
// MARK: - Experimental Settings Keys
#define SETTINGS_KEY_RDC_INDEX TCC('R','D') /*!< RDC index, uint8_t */
#define SETTINGS_KEY_CHANNEL_MASK TCC('C','M') /*!< Channel mask, uint16_t */
/*****************************************************************************/
// MARK: - Constants
/** Use this when you want to retrieve the last item */
#define SETTINGS_LAST_INDEX 0xFF
/** Returned when key is invalid. */
#define SETTINGS_INVALID_KEY 0xFFFF
/** Returned if no (further) element was found. */
#define SETTINGS_INVALID_ITER EEPROM_NULL
#ifndef SETTINGS_CONF_SUPPORT_LARGE_VALUES
#define SETTINGS_CONF_SUPPORT_LARGE_VALUES 0
#endif
#if SETTINGS_CONF_SUPPORT_LARGE_VALUES
#define SETTINGS_MAX_VALUE_SIZE 0x3FFF /* 16383 bytes */
#else
#define SETTINGS_MAX_VALUE_SIZE 0x7F /* 127 bytes */
#endif
/*****************************************************************************/
// MARK: - Settings accessors
/** Fetches the value associated with the given key. */
extern settings_status_t settings_get(settings_key_t key, uint8_t index,
uint8_t *value,
settings_length_t * value_size);
/** Adds the given key-value pair to the end of the settings store. */
extern settings_status_t settings_add(settings_key_t key,
const uint8_t *value,
settings_length_t value_size);
/** Checks to see if the given key exists. */
extern uint8_t settings_check(settings_key_t key, uint8_t index);
/** Reinitializes all of the EEPROM used by settings. */
extern void settings_wipe(void);
/** Sets the value for the given key. If the key already exists in
* the settings store, then its value will be replaced.
*/
extern settings_status_t settings_set(settings_key_t key,
const uint8_t *value,
settings_length_t value_size);
/** Removes the given key (at the given index) from the settings store. */
extern settings_status_t settings_delete(settings_key_t key, uint8_t index);
/*****************************************************************************/
// MARK: - Settings traversal functions
typedef eeprom_addr_t settings_iter_t;
/** Will return \ref SETTINGS_INVALID_ITER if the settings store is empty. */
extern settings_iter_t settings_iter_begin(void);
/** Will return \ref SETTINGS_INVALID_ITER if at the end of settings list. */
extern settings_iter_t settings_iter_next(settings_iter_t iter);
extern uint8_t settings_iter_is_valid(settings_iter_t iter);
extern settings_key_t settings_iter_get_key(settings_iter_t iter);
extern settings_length_t settings_iter_get_value_length(settings_iter_t iter);
extern eeprom_addr_t settings_iter_get_value_addr(settings_iter_t iter);
extern settings_length_t settings_iter_get_value_bytes(settings_iter_t item,
void *bytes,
settings_length_t
max_length);
extern settings_status_t settings_iter_delete(settings_iter_t item);
/*****************************************************************************/
// MARK: - inline convenience functions
/* Unfortunately, some platforms don't properly drop unreferenced functions,
* so on these broken platforms we can save a significant amount
* of space by skipping the definition of the convenience functions.
*/
#if !SETTINGS_CONF_SKIP_CONVENIENCE_FUNCS
static CC_INLINE const char *
settings_get_cstr(settings_key_t key, uint8_t index, char *c_str,
settings_length_t c_str_size)
{
/* Save room for the zero termination. */
c_str_size--;
if(settings_get(key, index, (uint8_t *)c_str, &c_str_size) == SETTINGS_STATUS_OK) {
/* Zero terminate. */
c_str[c_str_size] = 0;
} else {
c_str = NULL;
}
return c_str;
}
static CC_INLINE settings_status_t
settings_set_cstr(settings_key_t key, const char* c_str)
{
return settings_set(key, (const uint8_t *)c_str, strlen(c_str));
}
static CC_INLINE settings_status_t
settings_add_cstr(settings_key_t key, const char* c_str)
{
return settings_add(key, (const uint8_t *)c_str, strlen(c_str));
}
static CC_INLINE uint8_t
settings_get_bool_with_default(settings_key_t key, uint8_t index,
uint8_t default_value)
{
uint8_t ret = default_value;
settings_length_t sizeof_uint8 = sizeof(uint8_t);
settings_get(key, index, (uint8_t *)&ret, &sizeof_uint8);
return !!ret;
}
static CC_INLINE uint8_t
settings_get_uint8(settings_key_t key, uint8_t index)
{
uint8_t ret = 0;
settings_length_t sizeof_uint8 = sizeof(uint8_t);
settings_get(key, index, (uint8_t *)&ret, &sizeof_uint8);
return ret;
}
static CC_INLINE settings_status_t
settings_add_uint8(settings_key_t key, uint8_t value)
{
return settings_add(key, (const uint8_t *)&value, sizeof(uint8_t));
}
static CC_INLINE settings_status_t
settings_set_uint8(settings_key_t key, uint8_t value)
{
return settings_set(key, (const uint8_t *)&value, sizeof(uint8_t));
}
static CC_INLINE uint16_t
settings_get_uint16(settings_key_t key, uint8_t index)
{
uint16_t ret = 0;
settings_length_t sizeof_uint16 = sizeof(uint16_t);
settings_get(key, index, (uint8_t *)&ret, &sizeof_uint16);
return ret;
}
static CC_INLINE settings_status_t
settings_add_uint16(settings_key_t key, uint16_t value)
{
return settings_add(key, (const uint8_t *)&value, sizeof(uint16_t));
}
static CC_INLINE settings_status_t
settings_set_uint16(settings_key_t key, uint16_t value)
{
return settings_set(key, (const uint8_t *)&value, sizeof(uint16_t));
}
static CC_INLINE uint32_t
settings_get_uint32(settings_key_t key, uint8_t index)
{
uint32_t ret = 0;
settings_length_t sizeof_uint32 = sizeof(uint32_t);
settings_get(key, index, (uint8_t *)&ret, &sizeof_uint32);
return ret;
}
static CC_INLINE settings_status_t
settings_add_uint32(settings_key_t key, uint32_t value)
{
return settings_add(key, (const uint8_t *)&value, sizeof(uint32_t));
}
static CC_INLINE settings_status_t
settings_set_uint32(settings_key_t key, uint32_t value)
{
return settings_set(key, (const uint8_t *)&value, sizeof(uint32_t));
}
#if __int64_t_defined
static CC_INLINE uint64_t
settings_get_uint64(settings_key_t key, uint8_t index)
{
uint64_t ret = 0;
settings_length_t sizeof_uint64 = sizeof(uint64_t);
settings_get(key, index, (uint8_t *)&ret, &sizeof_uint64);
return ret;
}
static CC_INLINE settings_status_t
settings_add_uint64(settings_key_t key, uint64_t value)
{
return settings_add(key, (const uint8_t *)&value, sizeof(uint64_t));
}
static CC_INLINE settings_status_t
settings_set_uint64(settings_key_t key, uint64_t value)
{
return settings_set(key, (const uint8_t *)&value, sizeof(uint64_t));
}
#endif /* __int64_t_defined */
#endif /* !SETTINGS_CONF_SKIP_CONVENIENCE_FUNCS */
#endif /* !defined(CONTIKI_SETTINGS_H_) */
/** @} */
/** @} */

1
core/net/ipv6/websocket.c
View File

@ -34,7 +34,6 @@
#include <string.h>
#include "contiki-net.h"
#include "lib/petsciiconv.h"
#include "websocket.h"

2
drivers/cpu/msp430/Makefile.msp430
View File

@ -36,7 +36,7 @@ CONTIKI_CPU_DIRS = $(CONTIKI_CPU_FAM_DIR) . dev
MSP430 = msp430.c flash.c clock.c leds.c leds-arch.c \
watchdog.c lpm.c rtimer-arch.c
UIPDRIVERS = me.c me_tabs.c slip.c crc16.c
UIPDRIVERS = slip.c crc16.c
ifndef CPU_HAS_MSP430X
# include mtarch.c only in the non-large memory model case, because

5
examples/settings-example/Makefile
View File

@ -1,5 +0,0 @@
CONTIKI_PROJECT = settings-example
all: $(CONTIKI_PROJECT)
CFLAGS += -DCONTIKI_CONF_SETTINGS_MANAGER=1
CONTIKI = ../..
include $(CONTIKI)/Makefile.include

151
examples/settings-example/settings-example.c
View File

@ -1,151 +0,0 @@
/*
* Copyright (c) 2013, Robert Quattlebaum.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* @file settings-example.c
* @brief Contiki example showing how to use the settings manager.
* @author Robert Quattlebaum <darco@deepdarc.com>
*/
#include "contiki.h"
#include "lib/settings.h"
#include <stdio.h> /* For printf() */
/*---------------------------------------------------------------------------*/
PROCESS(settings_example_process, "Settings Example Process");
AUTOSTART_PROCESSES(&settings_example_process);
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(settings_example_process, ev, data)
{
int i;
settings_status_t status;
settings_iter_t iter;
char hostname[30];
uint16_t panid;
uint16_t channel;
PROCESS_BEGIN();
/*************************************************************************/
/* Basic setting of parameters */
status = settings_set_uint16(SETTINGS_KEY_PAN_ID, 0xABCD);
if(SETTINGS_STATUS_OK != status) {
printf("settings-example: `set` failed: %d\n", status);
}
status = settings_set_uint8(SETTINGS_KEY_CHANNEL, 26);
if(SETTINGS_STATUS_OK != status) {
printf("settings-example: `set` failed: %d\n", status);
}
status = settings_set_cstr(SETTINGS_KEY_HOSTNAME, "contiki.local");
if(SETTINGS_STATUS_OK != status) {
printf("settings-example: `set` failed: %d\n", status);
}
/*************************************************************************/
/* Basic getting of parameters */
panid = settings_get_uint16(SETTINGS_KEY_PAN_ID, 0);
if(0xABCD != panid) {
printf("settings-example: `get` failed: value mismatch.\n");
}
channel = settings_get_uint16(SETTINGS_KEY_CHANNEL, 0);
if(26 != channel) {
printf("settings-example: `get` failed: value mismatch.\n");
}
if(!settings_get_cstr(SETTINGS_KEY_HOSTNAME, 0, hostname, sizeof(hostname))) {
printf("settings-example: `get` failed: settings_get_cstr returned NULL\n");
} else if(strcmp(hostname, "contiki.local") != 0) {
printf("settings-example: `get` failed: value mismatch.\n");
}
/*************************************************************************/
/* Adding multiple values with the same key */
for(i = 0; i < 10; i++) {
settings_add_uint8(TCC('e','x'), i + 20);
}
/*************************************************************************/
/* Reading multiple values with the same key */
for(i = 0; i < 10; i++) {
if(settings_get_uint8(TCC('e', 'x'), i) != i + 20) {
printf("settings-example: `get` failed: value mismatch.\n");
}
}
/*************************************************************************/
/* Iterating thru all settings */
for(iter = settings_iter_begin(); iter; iter = settings_iter_next(iter)) {
settings_length_t len = settings_iter_get_value_length(iter);
eeprom_addr_t addr = settings_iter_get_value_addr(iter);
uint8_t byte;
union {
settings_key_t key;
char bytes[0];
} u;
u.key = settings_iter_get_key(iter);
if(u.bytes[0] >= 32 && u.bytes[0] < 127
&& u.bytes[1] >= 32 && u.bytes[1] < 127
) {
printf("settings-example: [%c%c] = <",u.bytes[0],u.bytes[1]);
} else {
printf("settings-example: <0x%04X> = <",u.key);
}
for(; len; len--, addr++) {
eeprom_read(addr, &byte, 1);
printf("%02X", byte);
if(len != 1) {
printf(" ");
}
}
printf(">\n");
}
printf("settings-example: Done.\n");
PROCESS_END();
}
/*---------------------------------------------------------------------------*/