From 99a203cbdbef4774ceae57a26bc054fcaf92ae93 Mon Sep 17 00:00:00 2001 From: scipio Date: Mon, 5 Mar 2007 19:07:57 +0000 Subject: [PATCH] Noise simulation. --- tos/lib/tossim/sim_noise.c | 282 +++++++++++++++++++++++++++++++++++++ tos/lib/tossim/sim_noise.h | 62 ++++++++ 2 files changed, 344 insertions(+) create mode 100644 tos/lib/tossim/sim_noise.c create mode 100644 tos/lib/tossim/sim_noise.h diff --git a/tos/lib/tossim/sim_noise.c b/tos/lib/tossim/sim_noise.c new file mode 100644 index 00000000..115a209b --- /dev/null +++ b/tos/lib/tossim/sim_noise.c @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2006 Stanford University. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - Neither the name of the Stanford University 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 COPYRIGHT HOLDERS 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 STANFORD + * UNIVERSITY OR ITS 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. + */ + +/** + * The C functions for accessing TOSSIM's noise simulation data + * structures. + * + * @author Philip Levis + * @date Mar 2 2007 + */ + + +// $Id$ + + +#include + +#include +#include + +#ifdef TESTING +#include +#include +#include +#define TOSSIM_MAX_NODE 20 +sim_time_t sim_mote_start_time(int mote) { + return 37; +} +sim_time_t sim_ticks_per_sec() { + return 10000000; +} +#endif + +typedef struct noise_model { + uint32_t historyLength; // The history "k" of the model + uint32_t sampleRateHz; // The rate at which samples change + hashtable_t* table; // A pointer to the distribution hashtable + double* firstReadings; // An array of the first k values of the trace + double* lastReadings; // An array of the last k values observed + uint32_t lastReading; // When was the last value observed + uint8_t discretization; // The discretization unit for readings + sim_time_t increment; // The sim_time between samples (derived from sample rate) + uint16_t bins; // The number of noise value bins (range / discretization) + double minNoise; // The minimum noise value + bool dirty; // Has data been added to the model so it needs to be recomputed? +} noise_model_t; + +noise_model_t models[TOSSIM_MAX_NODE]; + +void clear_data(uint32_t mote); +void add_data(uint32_t mote, double value); +void generate_model(int mote); +static unsigned int sim_noise_hash(void* key); +static int sim_noise_equal(void* key1, void* key2); + +void create_model(uint32_t mote, uint32_t sampleRate, uint32_t historyLength, uint8_t discretization, uint16_t bins, double minNoise) { + int i; + if (mote < TOSSIM_MAX_NODES) { + models[mote].historyLength = historyLength; + models[mote].sampleRateHz = sampleRate; + models[mote].table = create_hashtable(10240, sim_noise_hash, sim_noise_equal); + models[mote].lastReadings = (double*)(malloc(sizeof(double) * historyLength)); + models[mote].discretization = discretization; + models[mote].lastReading = historyLength - 1; + for (i = 0; i < historyLength; i++) { + models[mote].lastReadings[i] = 0.0; + } + models[mote].dirty = FALSE; + models[mote].bins = bins; + models[mote].minNoise = minNoise; + models[mote].increment = sim_ticks_per_sec() / models[mote].sampleRateHz; + } +} + +void clear_model(uint32_t mote) { + clear_data(mote); + if (models[mote].table != NULL) { + hashtable_destroy(models[mote].table, 1); + models[mote].table = NULL; + } + if (models[mote].lastReadings != NULL) { + free(models[mote].lastReadings); + models[mote].lastReadings = NULL; + } +} + +void add_reading(int mote, double value) { + add_data(mote, value); + models[mote].dirty = 1; +} + +char* hashString = NULL; +int hashStringLength = 0; + +#define SAMPLE_STR_LEN 10 +char* generateHashString(double* readings, int len, int discretization) { + char* ptr; + int i; + if (hashStringLength < len * SAMPLE_STR_LEN) { + int newLen = (len * SAMPLE_STR_LEN); + free(hashString); + hashString = (char*)malloc(sizeof(char) * newLen + 1); + hashStringLength = newLen; + } + ptr = hashString; + for (i = 0; i < len; i++) { + int val = (int)readings[i]; + val /= discretization; + val *= discretization; + ptr += snprintf(ptr, SAMPLE_STR_LEN, "%i ", val); + } +} + +typedef struct noise_distribution { + int dist; +} noise_distribution_t; + + +double sampleDistribution(noise_distribution_t* dist) { + return 0; +} + +void appendReading(int mote, double reading) { + memcpy(models[mote].lastReadings, models[mote].lastReadings + 1, models[mote].historyLength - 1 * sizeof(double)); + models[mote].lastReadings[models[mote].historyLength - 1] = reading; + models[mote].lastReading++; +} + +void generateReading(int mote) { + char* str = generateHashString(NULL, 0, 0); + noise_distribution_t* noise = (noise_distribution_t*)hashtable_search(models[mote].table, hashString); + double reading = sampleDistribution(noise); + appendReading(mote, reading); +} + +void generateReadings(int mote, uint64_t count) { + uint64_t i; + for (i = 0; i < count; i++) { + generateReading(mote); + } +} + +double getSample(int mote, sim_time_t time) { + int64_t readingNo; + int64_t readingCount; + sim_time_t timePassed = time - sim_mote_start_time(mote); + if (timePassed < 0) { + return models[mote].lastReadings[0]; + } + if (models[mote].dirty) { + generate_model(mote); + } + readingNo = timePassed / (uint64_t)models[mote].increment; + + if (readingNo < models[mote].historyLength) { + return models[mote].lastReadings[readingNo]; + } + + readingCount = readingNo - models[mote].lastReading; + generateReadings(mote, readingCount); + return models[mote].lastReadings[0]; +} + + + +typedef struct noise_data { + uint32_t size; + uint32_t maxSize; + double* readings; +} noise_data_t; + +noise_data_t data[TOSSIM_MAX_NODE]; + +void init_data(uint32_t mote) { + if (mote < TOSSIM_MAX_NODE) { + data[mote].size = 0; + data[mote].maxSize = 1024; + data[mote].readings = (double*)(malloc(sizeof(double) * 1024)); + } +} + +void clear_data(uint32_t mote) { + if (mote < TOSSIM_MAX_NODE) { + data[mote].size = 0; + data[mote].maxSize = 0; + if (data[mote].readings != NULL) { + free(data[mote].readings); + data[mote].readings = NULL; + } + } +} + +void add_data(uint32_t mote, double value) { + if (mote < TOSSIM_MAX_NODE) { + if (data[mote].size == data[mote].maxSize) { + double* ndata = (double*)malloc(sizeof(double) * 2 * data[mote].maxSize); + memcpy(ndata, data[mote].readings, data[mote].size * sizeof(double)); + free(data[mote].readings); + data[mote].readings = ndata; + data[mote].maxSize *= 2; + } + data[mote].readings[data[mote].size] = value; + data[mote].size++; + } +} + + + +static unsigned int sim_noise_hash(void* key) { + char* str = (char*)key; + unsigned int hashVal = 0; + int c; + + while ((c = *str++)) + hashVal = c + (hashVal << 6) + (hashVal << 16) - hashVal; + + return hashVal; +} + +static int sim_noise_equal(void* key1, void* key2) { + return (strcmp((char*)key1, (char*)key2) == 0); +} + +void generate_model(int mote) { + uint64_t i; + + // Not enough data to generate a model + if (data[mote].size <= models[mote].historyLength) { + return; + } + + for (i = 0; i < models[mote].historyLength; i++) { + models[mote].firstReadings[i] = data[mote].readings[i]; + } + + for (;i < data[mote].size; i++) { + double* dataStart = data[mote].readings + (i - models[mote].historyLength); + int dataLen = models[mote].historyLength; + int discretize = models[mote].discretization; + char* hashStr = generateHashString(dataStart, dataLen, discretize); + printf ("%s\n", hashStr); + } +} + +int main() { + int i; + char* hashStr; + create_model(0, 1024, 20, 4, 200, -120); + for (i = 0; i < 200; i++) { + models[0].lastReadings[i] = (drand48() * -60.0) - 40.0; + } + hashStr = generateHashString(models[0].lastReadings, 20, 3); + printf ("%s\n", hashStr); +} diff --git a/tos/lib/tossim/sim_noise.h b/tos/lib/tossim/sim_noise.h new file mode 100644 index 00000000..cac5c0ec --- /dev/null +++ b/tos/lib/tossim/sim_noise.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2006 Stanford University. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - Neither the name of the Stanford University 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 COPYRIGHT HOLDERS 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 STANFORD + * UNIVERSITY OR ITS 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. + */ + +/** + * The C functions for accessing TOSSIM's noise simulation data + * structures. + * + * @author Philip Levis + * @date Mar 2 2007 + */ + + +// $Id$ + + + +#ifndef SIM_GAIN_H_INCLUDED +#define SIM_GAIN_H_INCLUDED + + +#ifdef __cplusplus +extern "C" { +#endif + +void create_model(uint32_t mote, uint32_t sampleRate, uint32_t historyLength); +void clear_model(uint32_t mote); +void add_reading(uint32_t mote, double value); +double getSample(uint32_t mote, sim_time_t time); + +#ifdef __cplusplus +} +#endif + +#endif // SIM_GAIN_H_INCLUDED -- 2.39.2