From: rtrimana Date: Thu, 12 Apr 2018 23:09:16 +0000 (-0700) Subject: Adding .ino files for IoTCloud library tests (periodic write and sleep); adding DHT... X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=baee185a6308fb8e31ed2422163784491925954d;p=iotcloud.git Adding .ino files for IoTCloud library tests (periodic write and sleep); adding DHT library for humidity/temperature sensor. --- diff --git a/version2/src/C/DHT.cpp b/version2/src/C/DHT.cpp new file mode 100644 index 0000000..2ef244c --- /dev/null +++ b/version2/src/C/DHT.cpp @@ -0,0 +1,179 @@ +/* DHT library + +MIT license +written by Adafruit Industries +*/ + +#include "DHT.h" + +DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) { + _pin = pin; + _type = type; + _count = count; + firstreading = true; +} + +void DHT::begin(void) { + // set up the pins! + pinMode(_pin, INPUT); + digitalWrite(_pin, HIGH); + _lastreadtime = 0; +} + +//boolean S == Scale. True == Farenheit; False == Celcius +float DHT::readTemperature(bool S) { + float f; + + if (read()) { + switch (_type) { + case DHT11: + f = data[2]; + if(S) + f = convertCtoF(f); + + return f; + case DHT22: + case DHT21: + f = data[2] & 0x7F; + f *= 256; + f += data[3]; + f /= 10; + if (data[2] & 0x80) + f *= -1; + if(S) + f = convertCtoF(f); + + return f; + } + } + return NAN; +} + +float DHT::convertCtoF(float c) { + return c * 9 / 5 + 32; +} + +float DHT::convertFtoC(float f) { + return (f - 32) * 5 / 9; +} + +float DHT::readHumidity(void) { + float f; + if (read()) { + switch (_type) { + case DHT11: + f = data[0]; + return f; + case DHT22: + case DHT21: + f = data[0]; + f *= 256; + f += data[1]; + f /= 10; + return f; + } + } + return NAN; +} + +float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) { + // Adapted from equation at: https://github.com/adafruit/DHT-sensor-library/issues/9 and + // Wikipedia: http://en.wikipedia.org/wiki/Heat_index + return -42.379 + + 2.04901523 * tempFahrenheit + + 10.14333127 * percentHumidity + + -0.22475541 * tempFahrenheit*percentHumidity + + -0.00683783 * pow(tempFahrenheit, 2) + + -0.05481717 * pow(percentHumidity, 2) + + 0.00122874 * pow(tempFahrenheit, 2) * percentHumidity + + 0.00085282 * tempFahrenheit*pow(percentHumidity, 2) + + -0.00000199 * pow(tempFahrenheit, 2) * pow(percentHumidity, 2); +} + + +boolean DHT::read(void) { + uint8_t laststate = HIGH; + uint8_t counter = 0; + uint8_t j = 0, i; + unsigned long currenttime; + + // Check if sensor was read less than two seconds ago and return early + // to use last reading. + currenttime = millis(); + if (currenttime < _lastreadtime) { + // ie there was a rollover + _lastreadtime = 0; + } + if (!firstreading && ((currenttime - _lastreadtime) < 2000)) { + return true; // return last correct measurement + //delay(2000 - (currenttime - _lastreadtime)); + } + firstreading = false; + /* + Serial.print("Currtime: "); Serial.print(currenttime); + Serial.print(" Lasttime: "); Serial.print(_lastreadtime); + */ + _lastreadtime = millis(); + + data[0] = data[1] = data[2] = data[3] = data[4] = 0; + + // pull the pin high and wait 250 milliseconds + digitalWrite(_pin, HIGH); + delay(250); + + // now pull it low for ~20 milliseconds + pinMode(_pin, OUTPUT); + digitalWrite(_pin, LOW); + delay(20); + noInterrupts(); + digitalWrite(_pin, HIGH); + delayMicroseconds(40); + pinMode(_pin, INPUT); + + // read in timings + for ( i=0; i< MAXTIMINGS; i++) { + counter = 0; + while (digitalRead(_pin) == laststate) { + counter++; + delayMicroseconds(1); + if (counter == 255) { + break; + } + } + laststate = digitalRead(_pin); + + if (counter == 255) break; + + // ignore first 3 transitions + if ((i >= 4) && (i%2 == 0)) { + // shove each bit into the storage bytes + data[j/8] <<= 1; + if (counter > _count) + data[j/8] |= 1; + j++; + } + + } + + interrupts(); + + /* + Serial.println(j, DEC); + Serial.print(data[0], HEX); Serial.print(", "); + Serial.print(data[1], HEX); Serial.print(", "); + Serial.print(data[2], HEX); Serial.print(", "); + Serial.print(data[3], HEX); Serial.print(", "); + Serial.print(data[4], HEX); Serial.print(" =? "); + Serial.println(data[0] + data[1] + data[2] + data[3], HEX); + */ + + // check we read 40 bits and that the checksum matches + if ((j >= 40) && + (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) ) { + return true; + } + + + return false; + +} diff --git a/version2/src/C/DHT.h b/version2/src/C/DHT.h new file mode 100644 index 0000000..5280f9c --- /dev/null +++ b/version2/src/C/DHT.h @@ -0,0 +1,41 @@ +#ifndef DHT_H +#define DHT_H +#if ARDUINO >= 100 + #include "Arduino.h" +#else + #include "WProgram.h" +#endif + +/* DHT library + +MIT license +written by Adafruit Industries +*/ + +// how many timing transitions we need to keep track of. 2 * number bits + extra +#define MAXTIMINGS 85 + +#define DHT11 11 +#define DHT22 22 +#define DHT21 21 +#define AM2301 21 + +class DHT { + private: + uint8_t data[6]; + uint8_t _pin, _type, _count; + unsigned long _lastreadtime; + boolean firstreading; + + public: + DHT(uint8_t pin, uint8_t type, uint8_t count=6); + void begin(void); + float readTemperature(bool S=false); + float convertCtoF(float); + float convertFtoC(float); + float computeHeatIndex(float tempFahrenheit, float percentHumidity); + float readHumidity(void); + boolean read(void); + +}; +#endif diff --git a/version2/src/C/SlotBuffer.h b/version2/src/C/SlotBuffer.h index 0f6d625..6bb369d 100755 --- a/version2/src/C/SlotBuffer.h +++ b/version2/src/C/SlotBuffer.h @@ -9,7 +9,7 @@ * @version 1.0 */ -#define SlotBuffer_DEFAULT_SIZE 32 +#define SlotBuffer_DEFAULT_SIZE 4 class SlotBuffer { private: diff --git a/version2/src/C/Test.ino b/version2/src/C/Test.ino deleted file mode 100644 index 6267214..0000000 --- a/version2/src/C/Test.ino +++ /dev/null @@ -1,130 +0,0 @@ -#include "Table.h" -#include "IoTString.h" -#include "TimingSingleton.h" -#include "TransactionStatus.h" - -#define NUMBER_OF_TESTS 2 - -TimingSingleton *timer; -bool foundError; -MyVector * transStatusList; -Table *t1; - -void setup() { - // TODO: This test uses the Serial library - // Please install "screen" on your machine and run - // it on the serial port right after flashing the - // firmware onto the Particle board. - // e.g. sudo screen /dev/ttyACM0 - Serial.begin(); - timer = TimingSingleton_getInstance(); - foundError = false; - transStatusList = new MyVector(); - IoTString *baseurl = new IoTString("http://dc-6.calit2.uci.edu/test.iotcloud/"); - IoTString * password = new IoTString("reallysecret"); - t1 = new Table(baseurl, password, 321, -1); - t1->initTable(); - Serial.println("Finished table init..."); - baseurl->releaseRef(); - password->releaseRef(); - - // Make the Keys - for (int i = 0; i < NUMBER_OF_TESTS; i++) { - char buffer[80]; - sprintf(buffer, "a%d", i); - IoTString *ia = new IoTString(buffer); - sprintf(buffer, "b%d", i); - IoTString *ib = new IoTString(buffer); - t1->createNewKey(ia, 321); - t1->createNewKey(ib, 321); - ia->releaseRef(); - ib->releaseRef(); - } - Serial.println("Finished key generation..."); -} - - -void loop() { - // Do Updates for the keys - for (int i = 0; i < NUMBER_OF_TESTS; i++) { - char buffer[80]; - sprintf(buffer, "a%d", i); - IoTString * iKeyA = new IoTString(buffer); - IoTString * iValueA = new IoTString(buffer); - - sprintf(buffer, "b%d", i); - IoTString * iKeyB = new IoTString(buffer); - IoTString * iValueB = new IoTString(buffer); - - t1->startTransaction(); - t1->put(iKeyA, iValueA); - transStatusList->add(t1->commitTransaction()); - iKeyA->releaseRef(); - iValueA->releaseRef(); - - t1->startTransaction(); - t1->put(iKeyB, iValueB); - transStatusList->add(t1->commitTransaction()); - iKeyB->releaseRef(); - iValueB->releaseRef(); - - Serial.println("Added new transaction: "); - Serial.print("a"); - Serial.println(i); - Serial.print("b"); - Serial.println(i); - } - - t1->update(); - Serial.println("Updated table..."); - - for (int i = 0; i < NUMBER_OF_TESTS; i++) { - char buffer[80]; - sprintf(buffer, "a%d", i); - IoTString * iKeyA = new IoTString(buffer); - IoTString * iValueA = new IoTString(buffer); - - sprintf(buffer, "b%d", i); - IoTString * iKeyB = new IoTString(buffer); - IoTString * iValueB = new IoTString(buffer); - - IoTString *testValA1 = t1->getCommitted(iKeyA); - IoTString *testValB1 = t1->getCommitted(iKeyB); - - if ((testValA1 == NULL) || (testValA1->equals(iValueA) == false)) { - Serial.println("Key-Value t1 incorrect: keyA"); - foundError = true; - } - - if ((testValB1 == NULL) || (testValB1->equals(iValueB) == false)) { - Serial.println("Key-Value t1 incorrect: keyB"); - foundError = true; - } - - iKeyA->releaseRef(); - iValueA->releaseRef(); - iKeyB->releaseRef(); - iValueB->releaseRef(); - testValA1->releaseRef(); - testValB1->releaseRef(); - } - - for (uint i = 0; i < transStatusList->size(); i++) { - TransactionStatus * status = transStatusList->get(i); - if (status->getStatus() != TransactionStatus_StatusCommitted) { - foundError = true; - Serial.println("Status error"); - } - delete status; - } - - if (foundError) { - Serial.println("Found Errors..."); - } - - delete transStatusList; - delete t1; - - Serial.println("Process done... now waiting..."); - while(true) { } -} diff --git a/version2/src/others/DHT/DHT.cpp b/version2/src/others/DHT/DHT.cpp new file mode 100644 index 0000000..2ef244c --- /dev/null +++ b/version2/src/others/DHT/DHT.cpp @@ -0,0 +1,179 @@ +/* DHT library + +MIT license +written by Adafruit Industries +*/ + +#include "DHT.h" + +DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) { + _pin = pin; + _type = type; + _count = count; + firstreading = true; +} + +void DHT::begin(void) { + // set up the pins! + pinMode(_pin, INPUT); + digitalWrite(_pin, HIGH); + _lastreadtime = 0; +} + +//boolean S == Scale. True == Farenheit; False == Celcius +float DHT::readTemperature(bool S) { + float f; + + if (read()) { + switch (_type) { + case DHT11: + f = data[2]; + if(S) + f = convertCtoF(f); + + return f; + case DHT22: + case DHT21: + f = data[2] & 0x7F; + f *= 256; + f += data[3]; + f /= 10; + if (data[2] & 0x80) + f *= -1; + if(S) + f = convertCtoF(f); + + return f; + } + } + return NAN; +} + +float DHT::convertCtoF(float c) { + return c * 9 / 5 + 32; +} + +float DHT::convertFtoC(float f) { + return (f - 32) * 5 / 9; +} + +float DHT::readHumidity(void) { + float f; + if (read()) { + switch (_type) { + case DHT11: + f = data[0]; + return f; + case DHT22: + case DHT21: + f = data[0]; + f *= 256; + f += data[1]; + f /= 10; + return f; + } + } + return NAN; +} + +float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) { + // Adapted from equation at: https://github.com/adafruit/DHT-sensor-library/issues/9 and + // Wikipedia: http://en.wikipedia.org/wiki/Heat_index + return -42.379 + + 2.04901523 * tempFahrenheit + + 10.14333127 * percentHumidity + + -0.22475541 * tempFahrenheit*percentHumidity + + -0.00683783 * pow(tempFahrenheit, 2) + + -0.05481717 * pow(percentHumidity, 2) + + 0.00122874 * pow(tempFahrenheit, 2) * percentHumidity + + 0.00085282 * tempFahrenheit*pow(percentHumidity, 2) + + -0.00000199 * pow(tempFahrenheit, 2) * pow(percentHumidity, 2); +} + + +boolean DHT::read(void) { + uint8_t laststate = HIGH; + uint8_t counter = 0; + uint8_t j = 0, i; + unsigned long currenttime; + + // Check if sensor was read less than two seconds ago and return early + // to use last reading. + currenttime = millis(); + if (currenttime < _lastreadtime) { + // ie there was a rollover + _lastreadtime = 0; + } + if (!firstreading && ((currenttime - _lastreadtime) < 2000)) { + return true; // return last correct measurement + //delay(2000 - (currenttime - _lastreadtime)); + } + firstreading = false; + /* + Serial.print("Currtime: "); Serial.print(currenttime); + Serial.print(" Lasttime: "); Serial.print(_lastreadtime); + */ + _lastreadtime = millis(); + + data[0] = data[1] = data[2] = data[3] = data[4] = 0; + + // pull the pin high and wait 250 milliseconds + digitalWrite(_pin, HIGH); + delay(250); + + // now pull it low for ~20 milliseconds + pinMode(_pin, OUTPUT); + digitalWrite(_pin, LOW); + delay(20); + noInterrupts(); + digitalWrite(_pin, HIGH); + delayMicroseconds(40); + pinMode(_pin, INPUT); + + // read in timings + for ( i=0; i< MAXTIMINGS; i++) { + counter = 0; + while (digitalRead(_pin) == laststate) { + counter++; + delayMicroseconds(1); + if (counter == 255) { + break; + } + } + laststate = digitalRead(_pin); + + if (counter == 255) break; + + // ignore first 3 transitions + if ((i >= 4) && (i%2 == 0)) { + // shove each bit into the storage bytes + data[j/8] <<= 1; + if (counter > _count) + data[j/8] |= 1; + j++; + } + + } + + interrupts(); + + /* + Serial.println(j, DEC); + Serial.print(data[0], HEX); Serial.print(", "); + Serial.print(data[1], HEX); Serial.print(", "); + Serial.print(data[2], HEX); Serial.print(", "); + Serial.print(data[3], HEX); Serial.print(", "); + Serial.print(data[4], HEX); Serial.print(" =? "); + Serial.println(data[0] + data[1] + data[2] + data[3], HEX); + */ + + // check we read 40 bits and that the checksum matches + if ((j >= 40) && + (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) ) { + return true; + } + + + return false; + +} diff --git a/version2/src/others/DHT/DHT.h b/version2/src/others/DHT/DHT.h new file mode 100644 index 0000000..5280f9c --- /dev/null +++ b/version2/src/others/DHT/DHT.h @@ -0,0 +1,41 @@ +#ifndef DHT_H +#define DHT_H +#if ARDUINO >= 100 + #include "Arduino.h" +#else + #include "WProgram.h" +#endif + +/* DHT library + +MIT license +written by Adafruit Industries +*/ + +// how many timing transitions we need to keep track of. 2 * number bits + extra +#define MAXTIMINGS 85 + +#define DHT11 11 +#define DHT22 22 +#define DHT21 21 +#define AM2301 21 + +class DHT { + private: + uint8_t data[6]; + uint8_t _pin, _type, _count; + unsigned long _lastreadtime; + boolean firstreading; + + public: + DHT(uint8_t pin, uint8_t type, uint8_t count=6); + void begin(void); + float readTemperature(bool S=false); + float convertCtoF(float); + float convertFtoC(float); + float computeHeatIndex(float tempFahrenheit, float percentHumidity); + float readHumidity(void); + boolean read(void); + +}; +#endif diff --git a/version2/src/others/DHT/README.txt b/version2/src/others/DHT/README.txt new file mode 100644 index 0000000..4dfcbab --- /dev/null +++ b/version2/src/others/DHT/README.txt @@ -0,0 +1,3 @@ +This is an Arduino library for the DHT series of low cost temperature/humidity sensors. + +To download. click the DOWNLOADS button in the top right corner, rename the uncompressed folder DHT. Check that the DHT folder contains DHT.cpp and DHT.h. Place the DHT library folder your /libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE. \ No newline at end of file diff --git a/version2/src/others/DHT/examples/DHTtester/DHTtester.ino b/version2/src/others/DHT/examples/DHTtester/DHTtester.ino new file mode 100644 index 0000000..021107f --- /dev/null +++ b/version2/src/others/DHT/examples/DHTtester/DHTtester.ino @@ -0,0 +1,71 @@ +// Example testing sketch for various DHT humidity/temperature sensors +// Written by ladyada, public domain + +#include "DHT.h" + +#define DHTPIN 2 // what pin we're connected to + +// Uncomment whatever type you're using! +//#define DHTTYPE DHT11 // DHT 11 +#define DHTTYPE DHT22 // DHT 22 (AM2302) +//#define DHTTYPE DHT21 // DHT 21 (AM2301) + +// Connect pin 1 (on the left) of the sensor to +5V +// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1 +// to 3.3V instead of 5V! +// Connect pin 2 of the sensor to whatever your DHTPIN is +// Connect pin 4 (on the right) of the sensor to GROUND +// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor + +// Initialize DHT sensor for normal 16mhz Arduino +DHT dht(DHTPIN, DHTTYPE); +// NOTE: For working with a faster chip, like an Arduino Due or Teensy, you +// might need to increase the threshold for cycle counts considered a 1 or 0. +// You can do this by passing a 3rd parameter for this threshold. It's a bit +// of fiddling to find the right value, but in general the faster the CPU the +// higher the value. The default for a 16mhz AVR is a value of 6. For an +// Arduino Due that runs at 84mhz a value of 30 works. +// Example to initialize DHT sensor for Arduino Due: +//DHT dht(DHTPIN, DHTTYPE, 30); + +void setup() { + Serial.begin(9600); + Serial.println("DHTxx test!"); + + dht.begin(); +} + +void loop() { + // Wait a few seconds between measurements. + delay(2000); + + // Reading temperature or humidity takes about 250 milliseconds! + // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) + float h = dht.readHumidity(); + // Read temperature as Celsius + float t = dht.readTemperature(); + // Read temperature as Fahrenheit + float f = dht.readTemperature(true); + + // Check if any reads failed and exit early (to try again). + if (isnan(h) || isnan(t) || isnan(f)) { + Serial.println("Failed to read from DHT sensor!"); + return; + } + + // Compute heat index + // Must send in temp in Fahrenheit! + float hi = dht.computeHeatIndex(f, h); + + Serial.print("Humidity: "); + Serial.print(h); + Serial.print(" %\t"); + Serial.print("Temperature: "); + Serial.print(t); + Serial.print(" *C "); + Serial.print(f); + Serial.print(" *F\t"); + Serial.print("Heat index: "); + Serial.print(hi); + Serial.println(" *F"); +} diff --git a/version2/src/others/ino/Periodic.ino b/version2/src/others/ino/Periodic.ino new file mode 100644 index 0000000..e6531fd --- /dev/null +++ b/version2/src/others/ino/Periodic.ino @@ -0,0 +1,61 @@ +/** + * Periodic write and sleep to cloud. + * @author Rahmadi Trimananda + * @version 1.0 + */ + +#include "Table.h" +#include "IoTString.h" +#include "TimingSingleton.h" +#include "TransactionStatus.h" + +#define SLEEP_TIME 300 // in seconds + +TimingSingleton *timer; +bool foundError; +MyVector * transStatusList; +char keyBuffer[80]; +char dataBuffer[80]; + +Table *t1; +IoTString *iKeyA; +IoTString *iValueA; + +void setup() { + // TODO: This test uses the Serial library + // Please install "screen" on your machine and run + // it on the serial port right after flashing the + // firmware onto the Particle board. + // e.g. sudo screen /dev/ttyACM0 + Serial.begin(); + timer = TimingSingleton_getInstance(); + foundError = false; + transStatusList = new MyVector(); + IoTString *baseurl = new IoTString("http://dc-6.calit2.uci.edu/test.iotcloud/"); + IoTString *password = new IoTString("reallysecret"); + t1 = new Table(baseurl, password, 321, -1); + t1->rebuild(); + + baseurl->releaseRef(); + password->releaseRef(); +} + + +void loop() { + // Key + sprintf(keyBuffer, "sensor0"); + iKeyA = new IoTString(keyBuffer); + + // Do Updates for the keys + sprintf(dataBuffer, "data92617"); + iValueA = new IoTString(dataBuffer); + + t1->startTransaction(); + t1->put(iKeyA, iValueA); + transStatusList->add(t1->commitTransaction()); + t1->update(); + + iKeyA->releaseRef(); + iValueA->releaseRef(); + System.sleep(SLEEP_MODE_DEEP, SLEEP_TIME); +} diff --git a/version2/src/others/ino/Test.ino b/version2/src/others/ino/Test.ino new file mode 100644 index 0000000..32caccb --- /dev/null +++ b/version2/src/others/ino/Test.ino @@ -0,0 +1,136 @@ +/** + * Basic tests for IoTCloud library. + * @author Brian Demsky + * @version 1.0 + */ + +#include "Table.h" +#include "IoTString.h" +#include "TimingSingleton.h" +#include "TransactionStatus.h" + +#define NUMBER_OF_TESTS 2 + +TimingSingleton *timer; +bool foundError; +MyVector * transStatusList; +Table *t1; + +void setup() { + // TODO: This test uses the Serial library + // Please install "screen" on your machine and run + // it on the serial port right after flashing the + // firmware onto the Particle board. + // e.g. sudo screen /dev/ttyACM0 + Serial.begin(); + timer = TimingSingleton_getInstance(); + foundError = false; + transStatusList = new MyVector(); + IoTString *baseurl = new IoTString("http://dc-6.calit2.uci.edu/test.iotcloud/"); + IoTString * password = new IoTString("reallysecret"); + t1 = new Table(baseurl, password, 321, -1); + t1->initTable(); + Serial.println("Finished table init..."); + baseurl->releaseRef(); + password->releaseRef(); + + // Make the Keys + for (int i = 0; i < NUMBER_OF_TESTS; i++) { + char buffer[80]; + sprintf(buffer, "a%d", i); + IoTString *ia = new IoTString(buffer); + sprintf(buffer, "b%d", i); + IoTString *ib = new IoTString(buffer); + t1->createNewKey(ia, 321); + t1->createNewKey(ib, 321); + ia->releaseRef(); + ib->releaseRef(); + } + Serial.println("Finished key generation..."); +} + + +void loop() { + // Do Updates for the keys + for (int i = 0; i < NUMBER_OF_TESTS; i++) { + char buffer[80]; + sprintf(buffer, "a%d", i); + IoTString * iKeyA = new IoTString(buffer); + IoTString * iValueA = new IoTString(buffer); + + sprintf(buffer, "b%d", i); + IoTString * iKeyB = new IoTString(buffer); + IoTString * iValueB = new IoTString(buffer); + + t1->startTransaction(); + t1->put(iKeyA, iValueA); + transStatusList->add(t1->commitTransaction()); + iKeyA->releaseRef(); + iValueA->releaseRef(); + + t1->startTransaction(); + t1->put(iKeyB, iValueB); + transStatusList->add(t1->commitTransaction()); + iKeyB->releaseRef(); + iValueB->releaseRef(); + + Serial.println("Added new transaction: "); + Serial.print("a"); + Serial.println(i); + Serial.print("b"); + Serial.println(i); + } + + t1->update(); + Serial.println("Updated table..."); + + for (int i = 0; i < NUMBER_OF_TESTS; i++) { + char buffer[80]; + sprintf(buffer, "a%d", i); + IoTString * iKeyA = new IoTString(buffer); + IoTString * iValueA = new IoTString(buffer); + + sprintf(buffer, "b%d", i); + IoTString * iKeyB = new IoTString(buffer); + IoTString * iValueB = new IoTString(buffer); + + IoTString *testValA1 = t1->getCommitted(iKeyA); + IoTString *testValB1 = t1->getCommitted(iKeyB); + + if ((testValA1 == NULL) || (testValA1->equals(iValueA) == false)) { + Serial.println("Key-Value t1 incorrect: keyA"); + foundError = true; + } + + if ((testValB1 == NULL) || (testValB1->equals(iValueB) == false)) { + Serial.println("Key-Value t1 incorrect: keyB"); + foundError = true; + } + + iKeyA->releaseRef(); + iValueA->releaseRef(); + iKeyB->releaseRef(); + iValueB->releaseRef(); + testValA1->releaseRef(); + testValB1->releaseRef(); + } + + for (uint i = 0; i < transStatusList->size(); i++) { + TransactionStatus * status = transStatusList->get(i); + if (status->getStatus() != TransactionStatus_StatusCommitted) { + foundError = true; + Serial.println("Status error"); + } + delete status; + } + + if (foundError) { + Serial.println("Found Errors..."); + } + + delete transStatusList; + delete t1; + + Serial.println("Process done... now waiting..."); + while(true) { } +}