Initial commit with FONA support.

Author: tdicola

Adafruit_IO_Arduino.cpp

@@ -0,0 +1,156 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Adafruit Industries
+// Author: Tony DiCola
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#include "Adafruit_IO_Arduino.h"
+
+FeedData::FeedData() {
+    // Feed data is invalid without a value so write all zeros.
+    memset(_value, 0, sizeof(_value));
+}
+
+FeedData::FeedData(const FeedData& copy) {
+    // Copy the value from the provided FeedData object.
+    memset(_value, 0, sizeof(_value));
+    strncpy(_value, copy._value, sizeof(_value)-1);
+}
+
+FeedData::FeedData(const char* value) {
+    // Copy the provided string value as the feed data value.  If the string
+    // can't fit into the feed data's memory then keep the value in an invalid
+    // state (all zeros).
+    memset(_value, 0, sizeof(_value));
+    if (strlen(value) <= FEEDDATA_LENGTH-1) {
+        strncpy(_value, value, sizeof(_value)-1);       
+    }
+}
+
+FeedData::FeedData(Stream& stream, uint16_t length, uint32_t timeoutMS) {
+    // Load the data value from the provided stream.  Will read a value up to
+    // length characters in size.  If the data can't be read for some reason,
+    // like the timeout exceeding, then the FeedData will be left in an invalid
+    // state.
+    memset(_value, 0, sizeof(_value));
+    if (length > FEEDDATA_LENGTH-1) {
+        // Not enough space to store the value.
+        return;
+    }
+    stream.setTimeout(timeoutMS);
+    if (stream.readBytes(_value, length) != length) {
+        // Didn't find enough data, set the value as invalid.
+        memset(_value, 0, sizeof(_value));
+    }
+}
+
+bool FeedData::intValue(int* value) {
+    // Attempt to convert the value to an integer.  Returns true if it succeeds,
+    // and false if it fails for some reason.
+    char* endptr;
+    *value = (int)strtol(_value, &endptr, 10);
+    return (*_value != 0 && *endptr == 0);
+}
+
+bool FeedData::uintValue(unsigned int* value) {
+    // Attempt to convert the value to an unsigned integer.  Returns true if it
+    // succeeds, and false if it fails for some reason.
+    char* endptr;
+    *value = (unsigned int)strtoul(_value, &endptr, 10);
+    return (*_value != 0 && *endptr == 0);
+}
+
+bool FeedData::longValue(long* value) {
+    // Attempt to convert the value to a long.  Returns true if it
+    // succeeds, and false if it fails for some reason.
+    char* endptr;
+    *value = strtol(_value, &endptr, 10);
+    return (*_value != 0 && *endptr == 0);
+}
+
+bool FeedData::ulongValue(unsigned long* value) {
+    // Attempt to convert the value to an unsigned long.  Returns true if it
+    // succeeds, and false if it fails for some reason.
+    char* endptr;
+    *value = strtoul(_value, &endptr, 10);
+    return (*_value != 0 && *endptr == 0);  
+}
+
+bool FeedData::floatValue(float* value) {
+    // Attempt to convert the value to a float.  Returns true if it succeeds,
+    // and false if it fails for some reason.
+    char* endptr;
+    *value = (float)strtod(_value, &endptr);
+    return (*_value != 0 && *endptr == 0);
+}
+
+bool FeedData::doubleValue(double* value) {
+    // Attempt to convert the value to a double.  Returns true if it succeeds,
+    // and false if it fails for some reason.
+    char* endptr;
+    *value = strtod(_value, &endptr);
+    return (*_value != 0 && *endptr == 0);
+}
+
+// Buffer to store values converted from numbers to strings before sending to IO.
+static char _converted[FEEDDATA_LENGTH];
+
+bool Adafruit_IO_Feed::send(int value) {
+    // Convert int to string, then send the value (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    itoa(value, _converted, 10);
+    return _adapter->send(_name, _converted, _key, false);
+}
+
+bool Adafruit_IO_Feed::send(unsigned int value) {
+    // Convert uint to string, then send the value (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    utoa(value, _converted, 10);
+    return _adapter->send(_name, _converted, _key, false);
+}
+
+bool Adafruit_IO_Feed::send(long value) {
+    // Convert long to string, then send the value (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    ltoa(value, _converted, 10);
+    return _adapter->send(_name, _converted, _key, false);
+}
+
+bool Adafruit_IO_Feed::send(unsigned long value) {
+    // Convert ulong to string, then send the value (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    ultoa(value, _converted, 10);
+    return _adapter->send(_name, _converted, _key, false);
+}
+
+bool Adafruit_IO_Feed::send(float value) {
+    // Convert float to string using scientific notation, then send the value 
+    // (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    dtostre(value, _converted, 10, 0);
+    return _adapter->send(_name, _converted, _key, false);
+}
+
+bool Adafruit_IO_Feed::send(double value) {
+    // Convert double to string using scientific notation, then send the value 
+    // (being careful not to quote it).
+    memset(_converted, 0, sizeof(_converted));
+    dtostre(value, _converted, 10, 0);
+    return _adapter->send(_name, _converted, _key, false);
+}

Adafruit_IO_Arduino.h

@@ -0,0 +1,117 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Adafruit Industries
+// Author: Tony DiCola
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#ifndef ADAFRUIT_IO_ARDUINO_H
+#define ADAFRUIT_IO_ARDUINO_H
+
+#include "Arduino.h"
+
+// Control how big the buffer is for storing a data instance's value.
+// Keep at least a value of ~33 to store large numeric and float values.
+#define FEEDDATA_LENGTH 33
+
+// Uncomment/comment to enable & disable debug output.
+//#define ADAFRUIT_IO_DEBUG
+
+// Macros for debug output (only enabled when debug mode is enabled.)
+#ifdef ADAFRUIT_IO_DEBUG
+    #define DEBUG_PRINT(t) { Serial.print(t); }
+    #define DEBUG_PRINTLN(t) { Serial.println(t); }
+#else
+    #define DEBUG_PRINT(t) {}
+    #define DEBUG_PRINTLN(t) {}
+#endif
+
+
+// Adafruit IO feed data instance.  Exposes functions to read the value of the
+// feed as different types.
+class FeedData {
+public:
+    FeedData();
+    FeedData(const FeedData& copy);
+    FeedData(const char* value);
+    FeedData(Stream& stream, uint16_t length, uint32_t timeoutMS = 5000);
+
+    // Functions to support checking if this data instance was able to be read
+    // from the AIO service.
+    bool isValid() { return _value != NULL; }
+
+    // Allow implicit conversion to a C string.
+    operator char*() { return _value; }
+
+    // Explicit conversion functions that convert to the specified value.  Each
+    // will return true if the conversion succeeded and false if it could not
+    // be converted.
+    bool intValue(int* value);
+    bool uintValue(unsigned int* value);
+    bool longValue(long* value);
+    bool ulongValue(unsigned long* value);
+    bool floatValue(float* value);
+    bool doubleValue(double* value);
+
+private:
+    char _value[FEEDDATA_LENGTH];
+};
+
+
+// Interface for an AIO service that defines functions to send and receive data
+// to the AIO REST API.  Concrete implementations for FONA, CC3000, and ESP8266
+// are what users will actually use.
+class AIOService {
+public:
+    virtual ~AIOService() {}
+    virtual bool send(const char* feed, const char* value, const char* key,
+                      bool quoted) = 0;
+    virtual FeedData receive(const char* feed, const char* key) = 0;
+};
+
+
+// Main IO feed class that uses an AIO serviec reference to send and receive
+// data with IO.
+class Adafruit_IO_Feed {
+public:
+    Adafruit_IO_Feed(const char* name, const char* key, AIOService* adapter):
+        _name(name), _key(key), _adapter(adapter)
+    {}
+    
+    bool send(const char* value) { 
+        return _adapter->send(_name, value, _key, true);
+    }
+    bool send(int value);
+    bool send(unsigned int value);
+    bool send(long value);
+    bool send(unsigned long value);
+    bool send(float value);
+    bool send(double value);
+
+    FeedData receive() {
+        return _adapter->receive(_name, _key);
+    }
+
+private:
+    const char* _name;
+    const char* _key;
+    AIOService* _adapter;
+};
+
+
+#endif