diff options
Diffstat (limited to 'libraries/Bridge')
38 files changed, 4043 insertions, 0 deletions
diff --git a/libraries/Bridge/Bridge.cpp b/libraries/Bridge/Bridge.cpp new file mode 100644 index 0000000..c929ed8 --- /dev/null +++ b/libraries/Bridge/Bridge.cpp @@ -0,0 +1,204 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include "Bridge.h" + +BridgeClass::BridgeClass(Stream &_stream) : index(0), stream(_stream), started(false) { + // Empty +} + +void BridgeClass::begin() { + if (started) + return; + started = true; + + // Wait for Atheros bootloader to finish startup + do { + dropAll(); + delay(1100); + } while (stream.available()>0); + + // Bridge startup: + // - If the bridge is not running starts it safely + stream.print(CTRL_C); + delay(250); + stream.print(F("\n")); + delay(500); + stream.print(F("\n")); + delay(750); + // Wait for OpenWRT message + // "Press enter to activate console" + stream.print(F("run-bridge\n")); + delay(500); + dropAll(); + + // - If the bridge was already running previous commands + // are ignored as "invalid packets". + + // Reset the brigde + uint8_t cmd[] = {'X','X', '1','0','0'}; + uint8_t res[1]; + transfer(cmd, 5, res, 1); + if (res[0] != 0) + while (true); +} + +void BridgeClass::put(const char *key, const char *value) { + // TODO: do it in a more efficient way + String cmd = "D"; + cmd += key; + cmd += "\xFE"; + cmd += value; + transfer((uint8_t*)cmd.c_str(), cmd.length()); +} + +unsigned int BridgeClass::get(const char *key, uint8_t *value, unsigned int maxlen) { + uint8_t cmd[] = {'d'}; + unsigned int l = transfer(cmd, 1, (uint8_t *)key, strlen(key), value, maxlen); + if (l < maxlen) + value[l] = 0; // Zero-terminate string + return l; +} + +void BridgeClass::crcUpdate(uint8_t c) { + CRC = CRC ^ c; + CRC = (CRC >> 8) + (CRC << 8); +} + +void BridgeClass::crcReset() { + CRC = 0xAAAA; +} + +void BridgeClass::crcWrite() { + stream.write((char)(CRC >> 8)); + stream.write((char)(CRC & 0xFF)); +} + +bool BridgeClass::crcCheck(uint16_t _CRC) { + return CRC == _CRC; +} + +uint16_t BridgeClass::transfer(const uint8_t *buff1, uint16_t len1, + const uint8_t *buff2, uint16_t len2, + const uint8_t *buff3, uint16_t len3, + uint8_t *rxbuff, uint16_t rxlen) +{ + uint16_t len = len1 + len2 + len3; + for ( ; ; delay(100), dropAll() /* Delay for retransmission */) { + // Send packet + crcReset(); + stream.write((char)0xFF); // Start of packet (0xFF) + crcUpdate(0xFF); + stream.write((char)index); // Message index + crcUpdate(index); + stream.write((char)((len >> 8) & 0xFF)); // Message length (hi) + crcUpdate((len >> 8) & 0xFF); + stream.write((char)(len & 0xFF)); // Message length (lo) + crcUpdate(len & 0xFF); + for (uint16_t i=0; i<len1; i++) { // Payload + stream.write((char)buff1[i]); + crcUpdate(buff1[i]); + } + for (uint16_t i=0; i<len2; i++) { // Payload + stream.write((char)buff2[i]); + crcUpdate(buff2[i]); + } + for (uint16_t i=0; i<len3; i++) { // Payload + stream.write((char)buff3[i]); + crcUpdate(buff3[i]); + } + crcWrite(); // CRC + + // Wait for ACK in 100ms + if (timedRead(100) != 0xFF) + continue; + crcReset(); + crcUpdate(0xFF); + + // Check packet index + if (timedRead(5) != index) + continue; + crcUpdate(index); + + // Recv len + int lh = timedRead(5); + if (lh < 0) + continue; + crcUpdate(lh); + int ll = timedRead(5); + if (ll < 0) + continue; + crcUpdate(ll); + uint16_t l = lh; + l <<= 8; + l += ll; + + // Recv data + for (uint16_t i=0; i<l; i++) { + int c = timedRead(5); + if (c < 0) + continue; + // Cut received data if rxbuffer is too small + if (i < rxlen) + rxbuff[i] = c; + crcUpdate(c); + } + + // Check CRC + int crc_hi = timedRead(5); + if (crc_hi < 0) + continue; + int crc_lo = timedRead(5); + if (crc_lo < 0) + continue; + if (!crcCheck((crc_hi<<8)+crc_lo)) + continue; + + // Increase index + index++; + + // Return bytes received + if (l > rxlen) + return rxlen; + return l; + } +} + +int BridgeClass::timedRead(unsigned int timeout) { + int c; + unsigned long _startMillis = millis(); + do { + c = stream.read(); + if (c >= 0) return c; + } while(millis() - _startMillis < timeout); + return -1; // -1 indicates timeout +} + +void BridgeClass::dropAll() { + while (stream.available() > 0) { + stream.read(); + } +} + +// Bridge instance +#ifdef __AVR_ATmega32U4__ + // Leonardo variants (where HardwareSerial is Serial1) + SerialBridgeClass Bridge(Serial1); +#else + SerialBridgeClass Bridge(Serial); +#endif diff --git a/libraries/Bridge/Bridge.h b/libraries/Bridge/Bridge.h new file mode 100644 index 0000000..3bc1be8 --- /dev/null +++ b/libraries/Bridge/Bridge.h @@ -0,0 +1,91 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef BRIDGE_H_ +#define BRIDGE_H_ + +#include <Arduino.h> +#include <Stream.h> + +class BridgeClass { +public: + BridgeClass(Stream &_stream); + void begin(); + + // Methods to handle key/value datastore + void put(const char *key, const char *value); + unsigned int get(const char *key, uint8_t *buff, unsigned int size); + unsigned int get(const char *key, char *value, unsigned int maxlen) + { get(key, reinterpret_cast<uint8_t *>(value), maxlen); } + + // Trasnfer a frame (with error correction and response) + uint16_t transfer(const uint8_t *buff1, uint16_t len1, + const uint8_t *buff2, uint16_t len2, + const uint8_t *buff3, uint16_t len3, + uint8_t *rxbuff, uint16_t rxlen); + // multiple inline versions of the same function to allow efficient frame concatenation + uint16_t transfer(const uint8_t *buff1, uint16_t len1) + { return transfer(buff1, len1, NULL, 0); } + uint16_t transfer(const uint8_t *buff1, uint16_t len1, + uint8_t *rxbuff, uint16_t rxlen) + { return transfer(buff1, len1, NULL, 0, rxbuff, rxlen); } + uint16_t transfer(const uint8_t *buff1, uint16_t len1, + const uint8_t *buff2, uint16_t len2, + uint8_t *rxbuff, uint16_t rxlen) + { return transfer(buff1, len1, buff2, len2, NULL, 0, rxbuff, rxlen); } +private: + uint8_t index; + int timedRead(unsigned int timeout); + void dropAll(); + +private: + void crcUpdate(uint8_t c); + void crcReset(); + void crcWrite(); + bool crcCheck(uint16_t _CRC); + uint16_t CRC; + +private: + static const char CTRL_C = 3; + Stream &stream; + bool started; +}; + +// This subclass uses a serial port Stream +class SerialBridgeClass : public BridgeClass { +public: + SerialBridgeClass(HardwareSerial &_serial) + : BridgeClass(_serial), serial(_serial) { + // Empty + } + + void begin() { + serial.begin(250000); + BridgeClass::begin(); + } + +private: + HardwareSerial &serial; +}; + +extern SerialBridgeClass Bridge; + +#endif /* BRIDGE_H_ */ + +#include <Console.h> +#include <Process.h> diff --git a/libraries/Bridge/Console.cpp b/libraries/Bridge/Console.cpp new file mode 100644 index 0000000..8607421 --- /dev/null +++ b/libraries/Bridge/Console.cpp @@ -0,0 +1,153 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include <Console.h> + +// Default constructor uses global Bridge instance +ConsoleClass::ConsoleClass() : + bridge(Bridge), inBuffered(0), inReadPos(0), inBuffer(NULL), + autoFlush(true) +{ + // Empty +} + +// Constructor with a user provided BridgeClass instance +ConsoleClass::ConsoleClass(BridgeClass &_b) : + bridge(_b), inBuffered(0), inReadPos(0), inBuffer(NULL), + autoFlush(true) +{ + // Empty +} + +ConsoleClass::~ConsoleClass() { + end(); +} + +size_t ConsoleClass::write(uint8_t c) { + if (autoFlush) { + uint8_t tmp[] = { 'P', c }; + bridge.transfer(tmp, 2); + return 1; + } else { + outBuffer[outBuffered++] = c; + if (outBuffered == outBufferSize) + flush(); + } +} + +size_t ConsoleClass::write(const uint8_t *buff, size_t size) { + if (autoFlush) { + // TODO: do it in a more efficient way + uint8_t *tmp = new uint8_t[size+1]; + tmp[0] = 'P'; + memcpy(tmp+1, buff, size); + bridge.transfer(tmp, size+1); + delete[] tmp; + return size; + } else { + while (size > 0) { + outBuffer[outBuffered++] = *buff++; + size--; + if (outBuffered == outBufferSize) + flush(); + } + } +} + +void ConsoleClass::flush() { + if (autoFlush) + return; + + bridge.transfer(outBuffer, outBuffered); + outBuffered = 1; +} + +void ConsoleClass::noBuffer() { + if (autoFlush) + return; + delete[] outBuffer; + autoFlush = true; +} + +void ConsoleClass::buffer(uint8_t size) { + noBuffer(); + if (size==0) + return; + outBuffer = new uint8_t[size+1]; + outBuffer[0] = 'P'; // WRITE tag + outBufferSize = size+1; + outBuffered = 1; + autoFlush = false; +} + +bool ConsoleClass::connected() { + uint8_t tmp = 'a'; + bridge.transfer(&tmp, 1, &tmp, 1); + return tmp==1; +} + +int ConsoleClass::available() { + // Look if there is new data available + doBuffer(); + return inBuffered; +} + +int ConsoleClass::read() { + doBuffer(); + if (inBuffered == 0) + return -1; // no chars available + else { + inBuffered--; + return inBuffer[inReadPos++]; + } +} + +int ConsoleClass::peek() { + doBuffer(); + if (inBuffered == 0) + return -1; // no chars available + else + return inBuffer[inReadPos]; +} + +void ConsoleClass::doBuffer() { + // If there are already char in buffer exit + if (inBuffered > 0) + return; + + // Try to buffer up to 32 characters + inReadPos = 0; + uint8_t tmp[] = { 'p', BUFFER_SIZE }; + inBuffered = bridge.transfer(tmp, 2, inBuffer, BUFFER_SIZE); +} + +void ConsoleClass::begin() { + bridge.begin(); + end(); + inBuffer = new uint8_t[BUFFER_SIZE]; +} + +void ConsoleClass::end() { + noBuffer(); + if (inBuffer) { + delete[] inBuffer; + inBuffer = NULL; + } +} + +ConsoleClass Console; diff --git a/libraries/Bridge/Console.h b/libraries/Bridge/Console.h new file mode 100644 index 0000000..73a9739 --- /dev/null +++ b/libraries/Bridge/Console.h @@ -0,0 +1,69 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef CONSOLE_H_ +#define CONSOLE_H_ + +#include <Bridge.h> + +class ConsoleClass : public Stream { +public: + // Default constructor uses global Bridge instance + ConsoleClass(); + // Constructor with a user provided BridgeClass instance + ConsoleClass(BridgeClass &_b); + ~ConsoleClass(); + + void begin(); + void end(); + + void buffer(uint8_t size); + void noBuffer(); + + bool connected(); + + // Stream methods + // (read from console socket) + int available(); + int read(); + int peek(); + // (write to console socket) + size_t write(uint8_t); + size_t write(const uint8_t *buffer, size_t size); + void flush(); + + operator bool () { return connected(); } + +private: + BridgeClass &bridge; + + void doBuffer(); + uint8_t inBuffered; + uint8_t inReadPos; + static const int BUFFER_SIZE = 32; + uint8_t *inBuffer; + + bool autoFlush; + uint8_t outBuffered; + uint8_t outBufferSize; + uint8_t *outBuffer; +}; + +extern ConsoleClass Console; + +#endif diff --git a/libraries/Bridge/FileIO.cpp b/libraries/Bridge/FileIO.cpp new file mode 100644 index 0000000..0fab55f --- /dev/null +++ b/libraries/Bridge/FileIO.cpp @@ -0,0 +1,203 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include <FileIO.h> + +File::File(BridgeClass &b) : mode(255), bridge(b) { + // Empty +} + +File::File(const char *_filename, uint8_t _mode, BridgeClass &b) : mode(_mode), bridge(b) { + filename = _filename; + char modes[] = {'r','w','a'}; + uint8_t cmd[] = {'F', modes[mode]}; + uint8_t res[2]; + bridge.transfer(cmd, 2, (uint8_t*)filename.c_str(), filename.length(), res, 2); + if (res[0] != 0) { // res[0] contains error code + mode = 255; // In case of error keep the file closed + return; + } + handle = res[1]; + buffered = 0; +} + +File::operator bool() { + return (mode != 255); +} + +File::~File() { + close(); +} + +size_t File::write(uint8_t c) { + return write(&c, 1); +} + +size_t File::write(const uint8_t *buf, size_t size) { + if (mode == 255) + return -1; + uint8_t cmd[] = {'g', handle}; + uint8_t res[1]; + bridge.transfer(cmd, 2, buf, size, res, 1); + if (res[0] != 0) // res[0] contains error code + return -res[0]; + return size; +} + +int File::read() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else { + buffered--; + return buffer[readPos++]; + } +} + +int File::peek() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else + return buffer[readPos]; +} + +boolean File::seek(uint32_t position) { + uint8_t cmd[] = { + 's', + handle, + (position >> 24) & 0xFF, + (position >> 16) & 0xFF, + (position >> 8) & 0xFF, + position & 0xFF + }; + uint8_t res[1]; + bridge.transfer(cmd, 6, res, 1); + if (res[0]==0) { + // If seek succeed then flush buffers + buffered = 0; + return true; + } + return false; +} + +uint32_t File::position() { + uint8_t cmd[] = {'S', handle}; + uint8_t res[5]; + bridge.transfer(cmd, 2, res, 5); + //err = res[0]; // res[0] contains error code + uint32_t pos = res[1] << 24; + pos += res[2] << 16; + pos += res[3] << 8; + pos += res[4]; + return pos - buffered; +} + +void File::doBuffer() { + // If there are already char in buffer exit + if (buffered > 0) + return; + + // Try to buffer up to 32 characters + readPos = 0; + uint8_t cmd[] = {'G', handle, sizeof(buffer)}; + buffered = bridge.transfer(cmd, 3, buffer, sizeof(buffer)) - 1; + //err = buff[0]; // First byte is error code + if (buffered>0) { + // Shift the reminder of buffer + for (uint8_t i=0; i<buffered; i++) + buffer[i] = buffer[i+1]; + } +} + +int File::available() { + // Look if there is new data available + doBuffer(); + return buffered; +} + +void File::flush() { +} + +//int read(void *buf, uint16_t nbyte) + +//uint32_t size() + +void File::close() { + if (mode == 255) + return; + uint8_t cmd[] = {'f', handle}; + bridge.transfer(cmd, 2); + mode = 255; +} + +const char *File::name() { + return filename.c_str(); +} + +//boolean isDirectory(void) +//File openNextFile(uint8_t mode = O_RDONLY); +//void rewindDirectory(void) + + + + + + +boolean FileSystemClass::begin() { + return true; +} + +File FileSystemClass::open(const char *filename, uint8_t mode) { + return File(filename, mode); +} + +boolean FileSystemClass::exists(const char *filepath) { + Process ls; + ls.begin("ls"); + ls.addParameter(filepath); + int res = ls.run(); + return (res == 0); +} + +boolean FileSystemClass::mkdir(const char *filepath) { + Process mk; + mk.begin("mkdir"); + mk.addParameter("-p"); + mk.addParameter(filepath); + int res = mk.run(); + return (res == 0); +} + +boolean FileSystemClass::remove(const char *filepath) { + Process rm; + rm.begin("rm"); + rm.addParameter(filepath); + int res = rm.run(); + return (res == 0); +} + +boolean FileSystemClass::rmdir(const char *filepath) { + Process rm; + rm.begin("rmdir"); + rm.addParameter(filepath); + int res = rm.run(); + return (res == 0); +} + +FileSystemClass FileSystem; diff --git a/libraries/Bridge/FileIO.h b/libraries/Bridge/FileIO.h new file mode 100644 index 0000000..629e5f2 --- /dev/null +++ b/libraries/Bridge/FileIO.h @@ -0,0 +1,101 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef __FILEIO_H__ +#define __FILEIO_H__ + +#include <Process.h> + +#define FILE_READ 0 +#define FILE_WRITE 1 +#define FILE_APPEND 2 + +class File : public Stream { + +public: + File(BridgeClass &b = Bridge); + File(const char *_filename, uint8_t _mode, BridgeClass &b = Bridge); + ~File(); + + virtual size_t write(uint8_t); + virtual size_t write(const uint8_t *buf, size_t size); + virtual int read(); + virtual int peek(); + virtual int available(); + virtual void flush(); + int read(void *buf, uint16_t nbyte); + boolean seek(uint32_t pos); + uint32_t position(); + uint32_t size(); + void close(); + operator bool(); + const char * name(); + + boolean iFileSystemirectory(void); + File openNextFile(uint8_t mode = FILE_READ); + void rewindDirectory(void); + + //using Print::write; + +private: + void doBuffer(); + uint8_t buffered; + uint8_t readPos; + static const int BUFFER_SIZE = 64; + uint8_t buffer[BUFFER_SIZE]; + +private: + BridgeClass &bridge; + String filename; + uint8_t mode; + uint8_t handle; +}; + +class FileSystemClass { +public: + FileSystemClass() : bridge(Bridge) { } + FileSystemClass(BridgeClass &_b) : bridge(_b) { } + + boolean begin(); + + // Open the specified file/directory with the supplied mode (e.g. read or + // write, etc). Returns a File object for interacting with the file. + // Note that currently only one file can be open at a time. + File open(const char *filename, uint8_t mode = FILE_READ); + + // Methods to determine if the requested file path exists. + boolean exists(const char *filepath); + + // Create the requested directory heirarchy--if intermediate directories + // do not exist they will be created. + boolean mkdir(const char *filepath); + + // Delete the file. + boolean remove(const char *filepath); + + boolean rmdir(const char *filepath); + +private: + friend class File; + + BridgeClass &bridge; +}; + +extern FileSystemClass FileSystem; + +#endif diff --git a/libraries/Bridge/HttpClient.cpp b/libraries/Bridge/HttpClient.cpp new file mode 100644 index 0000000..510af38 --- /dev/null +++ b/libraries/Bridge/HttpClient.cpp @@ -0,0 +1,53 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include "HttpClient.h" + +unsigned int HttpClient::get(String &url) { + begin("curl"); + addParameter(url); + return run(); +} + +unsigned int HttpClient::get(const char *url) { + begin("curl"); + addParameter(url); + return run(); +} + +void HttpClient::getAsynchronously(String &url) { + begin("curl"); + addParameter(url); + runAsynchronously(); +} + +void HttpClient::getAsynchronously(const char *url) { + begin("curl"); + addParameter(url); + runAsynchronously(); +} + +boolean HttpClient::ready() { + return running(); +} + +unsigned int HttpClient::getResult() { + return exitValue(); +} + + diff --git a/libraries/Bridge/HttpClient.h b/libraries/Bridge/HttpClient.h new file mode 100644 index 0000000..940a66d --- /dev/null +++ b/libraries/Bridge/HttpClient.h @@ -0,0 +1,36 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef HTTPCLIENT_H_ +#define HTTPCLIENT_H_ + +#include <Process.h> + +class HttpClient : public Process { +public: + + unsigned int get(String &url); + unsigned int get(const char * url); + void getAsynchronously(String &url); + void getAsynchronously(const char * url); + boolean ready(); + unsigned int getResult(); + +}; + +#endif /* HTTPCLIENT_H_ */ diff --git a/libraries/Bridge/Mailbox.cpp b/libraries/Bridge/Mailbox.cpp new file mode 100644 index 0000000..cf2b9e5 --- /dev/null +++ b/libraries/Bridge/Mailbox.cpp @@ -0,0 +1,56 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include <Mailbox.h> + +unsigned int MailboxClass::readMessage(uint8_t *buff, unsigned int size) { + uint8_t tmp[] = { 'm' }; + return bridge.transfer(tmp, 1, buff, size); +} + +void MailboxClass::readMessage(String &str, unsigned int maxLength) { + uint8_t tmp[] = { 'm' }; + // XXX: Is there a better way to create the string? + uint8_t buff[maxLength+1]; + int l = bridge.transfer(tmp, 1, buff, maxLength); + buff[l] = 0; + str = (const char *)buff; +} + +void MailboxClass::writeMessage(const uint8_t *buff, unsigned int size) { + uint8_t cmd[] = {'M'}; + bridge.transfer(cmd, 1, buff, size, NULL, 0); +} + +void MailboxClass::writeMessage(const String& str) { + writeMessage((uint8_t*) str.c_str(), str.length()); +} + +void MailboxClass::writeJSON(const String& str) { + uint8_t cmd[] = {'J'}; + bridge.transfer(cmd, 1, (uint8_t*) str.c_str(), str.length(), NULL, 0); +} + +unsigned int MailboxClass::messageAvailable() { + uint8_t tmp[] = {'n'}; + uint8_t res[2]; + bridge.transfer(tmp, 1, res, 2); + return (res[0] << 8) + res[1]; +} + +MailboxClass Mailbox(Bridge); diff --git a/libraries/Bridge/Mailbox.h b/libraries/Bridge/Mailbox.h new file mode 100644 index 0000000..35bd1d6 --- /dev/null +++ b/libraries/Bridge/Mailbox.h @@ -0,0 +1,53 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef _MAILBOX_CLASS_H_INCLUDED_ +#define _MAILBOX_CLASS_H_INCLUDED_ + +#include <Bridge.h> + +class MailboxClass { +public: + MailboxClass(BridgeClass &b = Bridge) : bridge(b) { } + + void begin() { } + void end() { } + + // Receive a message and store it inside a buffer + unsigned int readMessage(uint8_t *buffer, unsigned int size); + // Receive a message and store it inside a String + void readMessage(String &str, unsigned int maxLength=128); + + // Send a message + void writeMessage(const uint8_t *buffer, unsigned int size); + // Send a message + void writeMessage(const String& str); + // Send a JSON message + void writeJSON(const String& str); + + // Return the size of the next available message, 0 if there are + // no messages in queue. + unsigned int messageAvailable(); + +private: + BridgeClass &bridge; +}; + +extern MailboxClass Mailbox; + +#endif // _MAILBOX_CLASS_H_INCLUDED_ diff --git a/libraries/Bridge/Process.cpp b/libraries/Bridge/Process.cpp new file mode 100644 index 0000000..219922a --- /dev/null +++ b/libraries/Bridge/Process.cpp @@ -0,0 +1,142 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include <Process.h> + +Process::~Process() { + close(); +} + +size_t Process::write(uint8_t c) { + uint8_t cmd[] = {'I', handle, c}; + bridge.transfer(cmd, 3); + return 1; +} + +void Process::flush() { +} + +int Process::available() { + // Look if there is new data available + doBuffer(); + return buffered; +} + +int Process::read() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else { + buffered--; + return buffer[readPos++]; + } +} + +int Process::peek() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else + return buffer[readPos]; +} + +void Process::doBuffer() { + // If there are already char in buffer exit + if (buffered > 0) + return; + + // Try to buffer up to 32 characters + readPos = 0; + uint8_t cmd[] = {'O', handle, sizeof(buffer)}; + buffered = bridge.transfer(cmd, 3, buffer, sizeof(buffer)); +} + +void Process::begin(const String &command) { + close(); + cmdline = new String(command); +} + +void Process::addParameter(const String ¶m) { + *cmdline += "\xFE"; + *cmdline += param; +} + +void Process::runAsynchronously() { + uint8_t cmd[] = {'R'}; + uint8_t res[2]; + bridge.transfer(cmd, 1, (uint8_t*)cmdline->c_str(), cmdline->length(), res, 2); + handle = res[1]; + + delete cmdline; + cmdline = NULL; + + if (res[0]==0) // res[0] contains error code + started = true; +} + +boolean Process::running() { + uint8_t cmd[] = {'r', handle}; + uint8_t res[1]; + bridge.transfer(cmd, 2, res, 1); + return (res[0] == 1); +} + +unsigned int Process::exitValue() { + uint8_t cmd[] = {'W', handle}; + uint8_t res[2]; + bridge.transfer(cmd, 2, res, 2); + return (res[0] << 8) + res[1]; +} + +unsigned int Process::run() { + runAsynchronously(); + while (running()) + delay(100); + return exitValue(); +} + +void Process::close() { + if (started) { + uint8_t cmd[] = {'w', handle}; + bridge.transfer(cmd, 2); + } + started = false; +} + +unsigned int Process::runShellCommand(const String &command) { + runShellCommandAsynchronously(command); + while (running()) + delay(100); + return exitValue(); +} + +void Process::runShellCommandAsynchronously(const String &command) { + begin("/bin/ash"); + addParameter("-c"); + addParameter(command); + runAsynchronously(); +} + +// This method is currently unused +//static unsigned int __commandOutputAvailable(uint8_t handle) { +// uint8_t cmd[] = {'o', handle}; +// uint8_t res[1]; +// Bridge.transfer(cmd, 2, res, 1); +// return res[0]; +//} + diff --git a/libraries/Bridge/Process.h b/libraries/Bridge/Process.h new file mode 100644 index 0000000..cacf516 --- /dev/null +++ b/libraries/Bridge/Process.h @@ -0,0 +1,69 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef PROCESS_H_ +#define PROCESS_H_ + +#include <Bridge.h> + +class Process : public Stream { +public: + // Constructor with a user provided BridgeClass instance + Process(BridgeClass &_b = Bridge) : + bridge(_b), started(false), buffered(0), readPos(0) { } + ~Process(); + + void begin(const String &command); + void addParameter(const String ¶m); + unsigned int run(); + void runAsynchronously(); + boolean running(); + unsigned int exitValue(); + void close(); + + unsigned int runShellCommand(const String &command); + void runShellCommandAsynchronously(const String &command); + + operator bool () { return started; } + + // Stream methods + // (read from process stdout) + int available(); + int read(); + int peek(); + // (write to process stdin) + size_t write(uint8_t); + void flush(); + // TODO: add optimized function for block write + +private: + BridgeClass &bridge; + unsigned int handle; + String *cmdline; + boolean started; + +private: + void doBuffer(); + uint8_t buffered; + uint8_t readPos; + static const int BUFFER_SIZE = 64; + uint8_t buffer[BUFFER_SIZE]; + +}; + +#endif diff --git a/libraries/Bridge/YunServer.cpp b/libraries/Bridge/YunServer.cpp new file mode 100644 index 0000000..c6d54e4 --- /dev/null +++ b/libraries/Bridge/YunServer.cpp @@ -0,0 +1,145 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include <YunServer.h> + +YunServer::YunServer(uint16_t _p, BridgeClass &_b) : + bridge(_b), port(_p), listening(false) { +} + +void YunServer::begin() { + uint8_t tmp[] = { + 'N', + (port >> 8) & 0xFF, + port & 0xFF + }; + uint8_t res[1]; + bridge.transfer(tmp, 3, (const uint8_t *)"0.0.0.0", 7, res, 1); + listening = (res[0] == 1); +} + +YunClient YunServer::accept() { + uint8_t cmd[] = {'k'}; + uint8_t res[1]; + unsigned int l = bridge.transfer(cmd, 1, res, 1); + if (l==0) + return YunClient(); + return YunClient(res[0]); +} + +YunClient::YunClient(int _h, BridgeClass &_b) : + bridge(_b), handle(_h), opened(true), buffered(0) { +} + +YunClient::YunClient(BridgeClass &_b) : + bridge(_b), handle(0), opened(false), buffered(0) { +} + +YunClient::~YunClient() { +} + +YunClient& YunClient::operator=(const YunClient &_x) { + opened = _x.opened; + handle = _x.handle; + return *this; +} + +void YunClient::stop() { + if (opened) { + uint8_t cmd[] = {'j', handle}; + bridge.transfer(cmd, 2); + } + opened = false; +} + +void YunClient::doBuffer() { + // If there are already char in buffer exit + if (buffered > 0) + return; + + // Try to buffer up to 32 characters + readPos = 0; + uint8_t cmd[] = {'K', handle, sizeof(buffer)}; + buffered = bridge.transfer(cmd, 3, buffer, sizeof(buffer)); +} + +int YunClient::available() { + // Look if there is new data available + doBuffer(); + return buffered; +} + +int YunClient::read() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else { + buffered--; + return buffer[readPos++]; + } +} + +int YunClient::read(uint8_t *buff, size_t size) { + int readed = 0; + do { + if (buffered == 0) { + doBuffer(); + if (buffered == 0) + return readed; + } + buff[readed++] = buffer[readPos++]; + buffered--; + } while (readed < size); + return readed; +} + +int YunClient::peek() { + doBuffer(); + if (buffered == 0) + return -1; // no chars available + else + return buffer[readPos]; +} + +size_t YunClient::write(uint8_t c) { + if (!opened) + return 0; + uint8_t cmd[] = {'l', handle, c}; + bridge.transfer(cmd, 3); + return 1; +} + +size_t YunClient::write(const uint8_t *buf, size_t size) { + if (!opened) + return 0; + uint8_t cmd[] = {'l', handle}; + bridge.transfer(cmd, 2, buf, size, NULL, 0); + return size; +} + +void YunClient::flush() { +} + +uint8_t YunClient::connected() { + if (!opened) + return false; + uint8_t cmd[] = {'L', handle}; + uint8_t res[1]; + bridge.transfer(cmd, 2, res, 1); + return (res[0] == 1); +} diff --git a/libraries/Bridge/YunServer.h b/libraries/Bridge/YunServer.h new file mode 100644 index 0000000..e1be55a --- /dev/null +++ b/libraries/Bridge/YunServer.h @@ -0,0 +1,87 @@ +/* + Copyright (c) 2013 Arduino LLC. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef CONNECTOR_H_ +#define CONNECTOR_H_ + +#include <Bridge.h> +#include <Server.h> +#include <Client.h> + +class YunClient; + +class YunServer : public Server { +public: + // Constructor with a user provided BridgeClass instance + YunServer(uint16_t port, BridgeClass &_b = Bridge); + + void begin(); + YunClient accept(); + + virtual size_t write(uint8_t c) { /* TODO */ } + +private: + uint16_t port; + bool listening; + BridgeClass &bridge; +}; + +class YunClient : public Client { +public: + // Constructor with a user provided BridgeClass instance + YunClient(int _h, BridgeClass &_b = Bridge); + YunClient(BridgeClass &_b = Bridge); + ~YunClient(); + + // Stream methods + // (read message) + virtual int available(); + virtual int read(); + virtual int read(uint8_t *buf, size_t size); + virtual int peek(); + // (write response) + virtual size_t write(uint8_t); + virtual size_t write(const uint8_t *buf, size_t size); + virtual void flush(); + // TODO: add optimized function for block write + + virtual operator bool () { return opened; } + + YunClient& operator=(const YunClient &_x); + + virtual void stop(); + virtual uint8_t connected(); + + virtual int connect(IPAddress ip, uint16_t port) { /* TODO */ }; + virtual int connect(const char *host, uint16_t port) { /* TODO */ }; + +private: + BridgeClass &bridge; + unsigned int handle; + boolean opened; + +private: + void doBuffer(); + uint8_t buffered; + uint8_t readPos; + static const int BUFFER_SIZE = 64; + uint8_t buffer[BUFFER_SIZE]; + +}; + +#endif // CONNECTOR_H_ diff --git a/libraries/Bridge/examples/BootWatcher001/BootWatcher001.ino b/libraries/Bridge/examples/BootWatcher001/BootWatcher001.ino new file mode 100644 index 0000000..7833d54 --- /dev/null +++ b/libraries/Bridge/examples/BootWatcher001/BootWatcher001.ino @@ -0,0 +1,90 @@ + +/* + Arduino Yun Boot watcher + + Allows you to use the Yun's 32U4 processor as a + serial terminal for the linino processor + + Upload this to an Arduino Yun via serial (not WiFi) + then open the serial monitor at 115200 to see the boot process + of the linino processor. You can also use the serial monitor + as a basic command line interface for the linino processor using + this sketch. + + The circuit: + * Arduino Yun + + created March 2013 + by Massimo Banzi + modified 26 May 2013 + by Tom Igoe + + This example code is in the public domain. + */ + +long baud = 115200; + +// Pin 13 has an LED connected on most Arduino boards. +// give it a name: +int led = 13; +int ledState = HIGH; // whether the LED is high or low + +String bootString = ""; +int bootLineCount = 0; +boolean booting = true; + +void setup() { + Serial.begin(baud); // open serial connection to Linino + Serial1.begin(baud); // open serial connection via USB-Serial + + // initialize the digital pin as an output. + pinMode(led, OUTPUT); + digitalWrite(led, ledState); // turn the LED on (HIGH is the voltage level) + while(booting) { + listenForBoot(); + } + delay(500); +} + + +void loop() { + // After booting, become a serial terminal: + if (Serial.available()) { // got anything from USB-Serial? + char c = (char)Serial.read(); // read from USB-serial + Serial1.write(c); // write to Linino + ledState=!ledState; // invert LED state + digitalWrite(led, ledState); // toggle the LED + } + if (Serial1.available()) { // got anything from Linino? + char c = (char)Serial1.read(); // read from Linino + Serial.write(c); // write to USB-serial + } + +} + +void listenForBoot() { + char c; + if (Serial1.available()) { // got anything from Linino? + c = (char)Serial1.read(); // read from Linino + + if (c == '\n') { // clear the bootString every newline + bootLineCount++; // increment the boot line counter + Serial.println(bootLineCount); // print the count + bootString = ""; // clear the boot string + } + else { // anything other than newline, add to string + bootString += c; + } + } + + // look for the final boot string message: + if (bootString.endsWith("entered forwarding state")) { + Serial1.println(); + } + + // look for the command prompt: + if (bootString.endsWith(":/#")) { + Serial.println("Ready for action."); + booting = false; + } +} diff --git a/libraries/Bridge/examples/Bridge/Bridge.ino b/libraries/Bridge/examples/Bridge/Bridge.ino new file mode 100644 index 0000000..c7627b2 --- /dev/null +++ b/libraries/Bridge/examples/Bridge/Bridge.ino @@ -0,0 +1,150 @@ + +//#include <Bridge.h> +#include <Mailbox.h> + +void setup() { + pinMode(13,OUTPUT); + digitalWrite(13, LOW); + Bridge.begin(); + digitalWrite(13, HIGH); + Serial.begin(9600); +} + +void loop() { + while (Mailbox.messageAvailable()) { + String msg; + Mailbox.readMessage(msg); + process(msg); + } + delay(100); // Poll every 0.100s +} + +void process(String command) { + Serial.println(command); + // "digital/13" -> digitalRead(13) + // "digital/13/1" -> digitalWrite(13, HIGH) + // "analog/2/123" -> analogWrite(2, 123) + // "analog/2" -> analogRead(2) + // "mode/13/input" -> pinMode(13, INPUT) + // "mode/13/output" -> pinMode(13, OUTPUT) + + // is digital command? + if (command.startsWith("digital/")) { + // extract subcommand (after the "/") + command = command.substring(8); + digitalCommand(command); + + } + // is analog command? + else if (command.startsWith("analog/")) { + // extract subcommand (after the "/") + command = command.substring(7); + analogCommand(command); + + } + // is mode command? + else if (command.startsWith("mode/")) { + // extract subcommand (after the "/") + command = command.substring(5); + modeCommand(command); + } +} + +void digitalCommand(String command) { + int pin, value; + + // Find the position of the "/" inside the command + int slashIndex = command.indexOf("/"); + + // If there are no slashes + if (slashIndex == -1) { + // then we are in the following case: + // "digital/13" -> digitalRead(13) + + // so we can extract the pin number from the remainder of the command string + pin = command.toInt(); + } + else { + // else, we found a slash, so we are in the following case: + // "digital/13/1" -> digitalWrite(13, HIGH) + + // we must estract pin number before the "/" + pin = command.substring(0, slashIndex).toInt(); + // and value after the "/" + value = command.substring(slashIndex+1).toInt(); + digitalWrite(pin, value); + } + reportDigitalRead(pin, true); +} + +void analogCommand(String command) { + int pin, value; + if (command.indexOf("/") != -1) { + pin = command.substring(0, command.indexOf("/")).toInt(); + value = command.substring(command.indexOf("/") + 1, command.length()).toInt(); + analogWrite(pin, value); + } + else { + pin = command.toInt(); + } + reportAnalogRead(pin, true); +} + +void modeCommand(String command) { + int pin; + String strValue; + pin = command.substring(0, command.indexOf("/")).toInt(); + strValue = command.substring(command.indexOf("/") + 1, command.length()); + if (strValue == "output") { + pinMode(pin, OUTPUT); + reportPinMode(pin, strValue); + } + else if (strValue == "input") { + pinMode(pin, INPUT); + reportPinMode(pin, strValue); + } +} + +void reportPinMode(int pin, String mode) { + String json = "{\"pin\":"; + json += pin; + json += ", \"mode\": \""; + json += mode; + json += "\"}"; + Mailbox.writeJSON(json); +} + +void reportDigitalRead(int pin, boolean dataset) { + int value = digitalRead(pin); + + String json = "{\"pin\":"; + json += pin; + json += ", \"value\": "; + json += value; + json += "}"; + Mailbox.writeJSON(json); + + if (dataset) { + String key = "D"; + key += pin; + Bridge.put(key.c_str(), String(value).c_str()); + } +} + +void reportAnalogRead(int pin, boolean dataset) { + int value = analogRead(pin); + + String json = "{\"pin\":"; + json += pin; + json += ", \"value\": "; + json += value; + json += "}"; + Mailbox.writeJSON(json); + + if (dataset) { + String key = "A"; + key += pin; + Bridge.put(key.c_str(), String(value).c_str()); + } +} + diff --git a/libraries/Bridge/examples/ConsoleAsciiTable/ConsoleAsciiTable.ino b/libraries/Bridge/examples/ConsoleAsciiTable/ConsoleAsciiTable.ino new file mode 100644 index 0000000..4cdf4c1 --- /dev/null +++ b/libraries/Bridge/examples/ConsoleAsciiTable/ConsoleAsciiTable.ino @@ -0,0 +1,94 @@ +/* + ASCII table + + Prints out byte values in all possible formats: + * as raw binary values + * as ASCII-encoded decimal, hex, octal, and binary values + + For more on ASCII, see http://www.asciitable.com and http://en.wikipedia.org/wiki/ASCII + + The circuit: No external hardware needed. + + created 2006 + by Nicholas Zambetti + modified 9 Apr 2012 + by Tom Igoe + modified 22 May 2013 + by Cristian Maglie + + This example code is in the public domain. + + <http://www.zambetti.com> + + */ + +#include <Console.h> + +void setup() { + //Initialize Console and wait for port to open: + Bridge.begin(); + Console.begin(); + + // Uncomment the following line to enable buffering: + // - better transmission speed and efficiency + // - needs to call Console.flush() to ensure that all + // transmitted data is sent + + //Console.buffer(64); + + while (!Console) { + ; // wait for Console port to connect. + } + + // prints title with ending line break + Console.println("ASCII Table ~ Character Map"); +} + +// first visible ASCIIcharacter '!' is number 33: +int thisByte = 33; +// you can also write ASCII characters in single quotes. +// for example. '!' is the same as 33, so you could also use this: +//int thisByte = '!'; + +void loop() { + // prints value unaltered, i.e. the raw binary version of the + // byte. The Console monitor interprets all bytes as + // ASCII, so 33, the first number, will show up as '!' + Console.write(thisByte); + + Console.print(", dec: "); + // prints value as string as an ASCII-encoded decimal (base 10). + // Decimal is the default format for Console.print() and Console.println(), + // so no modifier is needed: + Console.print(thisByte); + // But you can declare the modifier for decimal if you want to. + //this also works if you uncomment it: + + // Console.print(thisByte, DEC); + + Console.print(", hex: "); + // prints value as string in hexadecimal (base 16): + Console.print(thisByte, HEX); + + Console.print(", oct: "); + // prints value as string in octal (base 8); + Console.print(thisByte, OCT); + + Console.print(", bin: "); + // prints value as string in binary (base 2) + // also prints ending line break: + Console.println(thisByte, BIN); + + // if printed last visible character '~' or 126, stop: + if(thisByte == 126) { // you could also use if (thisByte == '~') { + // ensure the latest bit of data is sent + Console.flush(); + + // This loop loops forever and does nothing + while(true) { + continue; + } + } + // go on to the next character + thisByte++; +} diff --git a/libraries/Bridge/examples/ConsolePixel/ConsolePixel.ino b/libraries/Bridge/examples/ConsolePixel/ConsolePixel.ino new file mode 100644 index 0000000..4201465 --- /dev/null +++ b/libraries/Bridge/examples/ConsolePixel/ConsolePixel.ino @@ -0,0 +1,58 @@ +/* + Console Pixel + + An example of using the Arduino board to receive data from the + Console on the Arduino Yun. In this case, the Arduino boards turns on an LED when + it receives the character 'H', and turns off the LED when it + receives the character 'L'. + + To see the Console, pick your Yun's name and IP address in the Port menu + then open the Port Monitor. You can also see it by opening a terminal window + and typing + ssh root@ yourYunsName.local 'telnet localhost 6571' + then pressing enter. When prompted for the password, enter it. + + + The circuit: + * LED connected from digital pin 13 to ground + + created 2006 + by David A. Mellis + modified 25 Jun 2013 + by Tom Igoe + + This example code is in the public domain. + + */ +#include <Console.h> + +const int ledPin = 13; // the pin that the LED is attached to +char incomingByte; // a variable to read incoming Console data into + +void setup() { + // initialize Console communication: + Bridge.begin(); + Console.begin(); + while(!Console); // wait for the Console to open from the remote side + Console.println("type H or L to turn pin 13 on or off"); + // initialize the LED pin as an output: + pinMode(ledPin, OUTPUT); +} + +void loop() { + // see if there's incoming Console data: + if (Console.available() > 0) { + // read the oldest byte in the Console buffer: + incomingByte = Console.read(); + Console.println(incomingByte); + // if it's a capital H (ASCII 72), turn on the LED: + if (incomingByte == 'H') { + digitalWrite(ledPin, HIGH); + } + // if it's an L (ASCII 76) turn off the LED: + if (incomingByte == 'L') { + digitalWrite(ledPin, LOW); + } + } +} + diff --git a/libraries/Bridge/examples/ConsoleRead/ConsoleRead.ino b/libraries/Bridge/examples/ConsoleRead/ConsoleRead.ino new file mode 100644 index 0000000..7b38f03 --- /dev/null +++ b/libraries/Bridge/examples/ConsoleRead/ConsoleRead.ino @@ -0,0 +1,55 @@ +/* + Console.read() example: + read data coming from bridge using the Console.read() function + and store it in a string. + + To see the Console, pick your Yun's name and IP address in the Port menu + then open the Port Monitor. You can also see it by opening a terminal window + and typing + ssh root@ yourYunsName.local 'telnet localhost 6571' + then pressing enter. When prompted for the password, enter it. + + created 13 Jun 2013 + by Angelo Scialabba + modified 16 June 2013 + by Tom Igoe + + This example code is in the public domain. + */ + +#include <Console.h> + +String name; + +void setup() { + //Initialize Console and wait for port to open: + Bridge.begin(); + Console.begin(); + + while (!Console){ + ; // wait for Console port to connect. + } + Console.println("Hi, what's your name?"); +} + +void loop() { + if (Console.available() > 0) { + char thisChar = Console.read(); //read the next char received + //look for the newline character, this is the last character in the string + if (thisChar == '\n') { + //print text with the name received + Console.print("Hi "); + Console.print(name); + Console.println("! Nice to meet you!"); + Console.println(); + //Ask again for name and clear the old name + Console.println("Hi, what's your name?"); + name = ""; + } + else { //if the buffer is empty Cosole.read returns -1 + name += thisChar; //thisChar is int, treat him as char and add it to the name string + } + } +} + + diff --git a/libraries/Bridge/examples/Datalogger/Datalogger.ino b/libraries/Bridge/examples/Datalogger/Datalogger.ino new file mode 100644 index 0000000..5878e05 --- /dev/null +++ b/libraries/Bridge/examples/Datalogger/Datalogger.ino @@ -0,0 +1,90 @@ +/* + SD card datalogger + + This example shows how to log data from three analog sensors + to an SD card mounted on the Arduino Yun using the Bridge library. + + The circuit: + * analog sensors on analog ins 0, 1, and 2 + * SD card attached to SD card slot of the Arduino Yun + + You can remove the SD card while the Linux and the + sketch are running but be careful not to remove it while + the system is writing to it. + + created 24 Nov 2010 + modified 9 Apr 2012 + by Tom Igoe + adapted to the Yun Bridge library 20 Jun 2013 + by Federico Vanzati + modified 21 Jun 2013 + by Tom Igoe + + This example code is in the public domain. + + */ + +#include <FileIO.h> +#include <Serial.h> + +void setup() { + // Initialize the Bridge and the Serial + Bridge.begin(); + Serial.begin(9600); + FileSystem.begin(); + + while(!Serial); // wait for Serial port to connect. + Serial.println("Filesystem datalogger"); +} + + +void loop () { + // make a string that start with a timestamp for assembling the data to log: + String dataString = ""; + dataString += addTimeStamp(); + dataString += " = "; + + // read three sensors and append to the string: + for (int analogPin = 0; analogPin < 3; analogPin++) { + int sensor = analogRead(analogPin); + dataString += String(sensor); + if (analogPin < 2) { + dataString += ","; + } + } + + // open the file. note that only one file can be open at a time, + // so you have to close this one before opening another. + // The FileSystem card is mounted at the following "/mnt/FileSystema1" + File dataFile = FileSystem.open("/mnt/sda1/datalog.txt", FILE_APPEND); + + // if the file is available, write to it: + if (dataFile) { + dataFile.println(dataString); + dataFile.close(); + // print to the serial port too: + Serial.println(dataString); + } + // if the file isn't open, pop up an error: + else { + Serial.println("error opening datalog.txt"); + } + + delay(15000); + +} + +// This function append a time stamp to the string passed as argument +String addTimeStamp() { + String result; + Process time; + time.begin("date"); + time.addParameter("+%D-%T"); + time.run(); + + while(time.available()>0) { + char c = time.read(); + if(c != '\n') + result += c; + } +} diff --git a/libraries/Bridge/examples/FileWriteScript/FileWriteScript.ino b/libraries/Bridge/examples/FileWriteScript/FileWriteScript.ino new file mode 100644 index 0000000..d5bbb26 --- /dev/null +++ b/libraries/Bridge/examples/FileWriteScript/FileWriteScript.ino @@ -0,0 +1,65 @@ +/* + Write to file using FileIO classes. + + This sketch demonstrate how to write file into the Yún filesystem. + A shell script file is created in /tmp, and it is executed afterwards. + + */ + +#include <FileIO.h> + +void setup() { + // Setup Bridge (needed every time we communicate with the Arduino Yún) + Bridge.begin(); + + // Setup Console + Console.begin(); + // Buffering improves Console performance, but we must remember to + // finish sending using the Console.flush() command. + Console.buffer(64); + + // Setup File IO + SD.begin(); + + // Upload script used to gain network statistics + uploadScript(); +} + +void loop() { + // Run stats script every 5 secs. + runScript(); + delay(5000); +} + +void uploadScript() { + // Write our shell script in /tmp + // Using /tmp stores the script in RAM this way we can preserve + // the limited amount of FLASH erase/write cycles + File script = SD.open("/tmp/wlan-stats.sh", FILE_WRITE); + script.print("#!/bin/sh\n"); + script.print("ifconfig wlan0 | grep \"RX bytes\" | tr ':' ' ' | awk \"{ print \\$3 \\\" \\\" \\$8 }\"\n"); + script.close(); + + // Make the script executable + Process chmod; + chmod.begin("chmod"); + chmod.addParameter("+x"); + chmod.addParameter("/tmp/wlan-stats.sh"); + chmod.run(); +} + +void runScript() { + // Launch script and show results on the console + Process myscript; + myscript.begin("/tmp/wlan-stats.sh"); + myscript.run(); + + Console.print("WiFi RX/TX bytes: "); + while (myscript.available()) { + char c = myscript.read(); + Console.print(c); + } + Console.println(); + Console.flush(); +} + diff --git a/libraries/Bridge/examples/HttpClient/HttpClient.ino b/libraries/Bridge/examples/HttpClient/HttpClient.ino new file mode 100644 index 0000000..bf5e8ff --- /dev/null +++ b/libraries/Bridge/examples/HttpClient/HttpClient.ino @@ -0,0 +1,23 @@ + +#include <HttpClient.h> + +void setup() { + pinMode(13, OUTPUT); + digitalWrite(13, LOW); + Bridge.begin(); +} + +void loop() { + HttpClient client; + client.get("http://my.server.address/file.php"); + + char c = client.read(); + if (c=='1') + digitalWrite(13, HIGH); + if (c=='0') + digitalWrite(13, LOW); + + delay(5000); +} + + diff --git a/libraries/Bridge/examples/OLDYahooWeather/OLDYahooWeather.ino b/libraries/Bridge/examples/OLDYahooWeather/OLDYahooWeather.ino new file mode 100644 index 0000000..b751e1d --- /dev/null +++ b/libraries/Bridge/examples/OLDYahooWeather/OLDYahooWeather.ino @@ -0,0 +1,94 @@ +/* + Yahoo Weather Forecast parser + + http://developer.yahoo.com/weather/ + This sketch demonstrate how to use the Linux command line tools + to parse a simple XML file on the Arduino Yún. + + First thing download the XML file from the Yahoo Weather service + than use "grep" and "cut" to extract the data you want. + + To find the location ID of your location, browse or search for your + city from the Weather home page. The location ID is in the URL for + the forecast page for that city. + + created 21 Jun 2013 + by Federico Vanzati + + */ + +#include <Bridge.h> + +String locationID = "725003"; // Turin, Italy + +// table with keywords to search in the XML file +// the third column is the tag to the field +String forecast[10][3] = { + "location", "2", "city", + "condition", "6", "temperature", + "condition", "2", "condition", + "astronomy", "2", "sunrise", + "astronomy", "4", "sunset", + "atmosphere", "2", "humidity", + "atmosphere", "6", "pressure", + "wind", "6", "wind speed", + "wind", "4", "wind direction", + "wind", "2", "chill temperature" +}; + + +void setup() { + Bridge.begin(); + Serial.begin(9600); + while(!Serial); + + Serial.println("Weather Forecast for your location: \n"); +} + +void loop() { + + for(int i=0; i<10; i++) { + + // Compose the request + + // curl is a program that connect to an URL an download the content + // is used to get the weather forecast from yahoo in XML format + String command = "curl -s "; // -s is the silent option + command += "http://weather.yahooapis.com/forecastrss"; // yahoo weather RSS service + command += "?w="; // query for the location + command += locationID; + //command += "\\&u=c"; // ask for celsius degrees + + // add a new process + // grep is used to extract a single line of content containig a search keyword form the XML + command += " | "; // pipe a new process + command += "grep "; + command += forecast[i][0]; // word to search in the XML file + + // add a new process + // cut is a program that split a text in different fields + // when encouter the passed character delimiter + command += " | "; // pipe a new process + command += "cut "; + command += "-d \\\" "; // -d parameter split the string every " char + command += "-f "; // -f parameter is to return the 6th splitted element + command += forecast[i][1]; // the field are already manually calculated and inserted in the forecast table + + + Serial.print(forecast[i][2]); + Serial.print("= "); + + // run the command + Process wf; + wf.runShellCommand(command); + + while(wf.available()>0) + { + Serial.print( (char)wf.read() ); + } + } + + //do nothing forevermore + while(1); +} + diff --git a/libraries/Bridge/examples/Process/Process.ino b/libraries/Bridge/examples/Process/Process.ino new file mode 100644 index 0000000..919cea7 --- /dev/null +++ b/libraries/Bridge/examples/Process/Process.ino @@ -0,0 +1,70 @@ +/* + Running process using Process class. + + This sketch demonstrate how to run linux processes + using an Arduino Yún. + + created 5 Jun 2013 + by Cristian Maglie + + */ + +#include <Process.h> + +void setup() { + // Setup Bridge (needed every time we communicate with the Arduino Yún) + Bridge.begin(); + + // Setup Console + Console.begin(); + // Buffering improves Console performance, but we must remember to + // finish sending using the Console.flush() command. + Console.buffer(64); + + // Wait until a Network Monitor is connected. + while (!Console); + + // run various example processes + runCurl(); + runCpuInfo(); +} + +void loop() { + // Do nothing here. +} + +void runCurl() { + // Launch "curl" command and get Arduino asciilogo from the network + + Process p; // Create a process and call it "p" + p.begin("curl"); // Process should launch the "curl" command + p.addParameter("http://arduino.cc/asciilogo.txt"); // Add the URL parameter to "curl" + p.run(); // Run the process and wait for its termination + + // Print arduino logo over the console. + // A process output can be read with the stream methods + while (p.available()>0) { + char c = p.read(); + Console.print(c); + } + // Ensure the latest bit of data is sent. + Console.flush(); +} + +void runCpuInfo() { + // Launch "cat /proc/cpuinfo" command (shows info on Atheros CPU) + Process p; + p.begin("cat"); + p.addParameter("/proc/cpuinfo"); + p.run(); + + // Print command output on the Console. + // A process output can be read with the stream methods + while (p.available()>0) { + char c = p.read(); + Console.print(c); + } + // Ensure the latest bit of data is sent. + Console.flush(); +} + diff --git a/libraries/Bridge/examples/ShellCommands/ShellCommands.ino b/libraries/Bridge/examples/ShellCommands/ShellCommands.ino new file mode 100644 index 0000000..d2f9b7a --- /dev/null +++ b/libraries/Bridge/examples/ShellCommands/ShellCommands.ino @@ -0,0 +1,52 @@ + +/* + Running shell coommands using Process class. + + This sketch demonstrate how to run linux shell commands + using an Arduino Yún. It runs the wifiCheck script on the linino side + of the Yun, then uses grep to get just the signal strength line. + Then it uses parseInt() to read the wifi signal strength as an integer, + and finally uses that number to fade an LED using analogWrite(). + + The circuit: + * Arduino Yun with LED connected to pin 9 + + created 12 Jun 2013 + by Cristian Maglie + modified 25 June 2013 + by Tom Igoe + + This example code is in the public domain. + + */ + +#include <Process.h> + +void setup() { + // initialize the Bridge and Serial connections: + Bridge.begin(); + Serial.begin(9600); +} + +void loop() { + Process p; + // This command line runs the wifiCheck script, (lua /arduino/pretty...), then + // sends the result to the grep command to look for a line containing the word + // "Signal:" the result is passed to this sketch: + p.runShellCommand("lua /arduino/pretty_wifi_info.lua | grep Signal"); + + // do nothing until the process finishes, so you get the whole output: + while(p.running()); + + // Read command output. runShellCommand() should have passed "Signal: xx&": + while (p.available()) { + int result = p.parseInt(); // look for an integer + int signal = map(result, 0, 100, 0, 255); // map result from 0-100 range to 0-255 + analogWrite(9, signal); // set the brightness of LED on pin 9 + Serial.println(result); // print the number as well + } + delay(5000); // wait 5 seconds before you do it again +} + + + diff --git a/libraries/Bridge/examples/Temboo/GetYahooWeatherReport/GetYahooWeatherReport.ino b/libraries/Bridge/examples/Temboo/GetYahooWeatherReport/GetYahooWeatherReport.ino new file mode 100644 index 0000000..4a4e818 --- /dev/null +++ b/libraries/Bridge/examples/Temboo/GetYahooWeatherReport/GetYahooWeatherReport.ino @@ -0,0 +1,109 @@ +/* + GetYahooWeatherReport + + Demonstrates making a request to the Yahoo! Weather API using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + +int numRuns = 0; // execution count, so that this doesn't run forever +int maxRuns = 10; // max number of times the Yahoo WeatherByAddress Choreo should be run + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + while(!Serial); + Bridge.begin(); +} + +void loop() +{ + // while we haven't reached the max number of runs... + if (numRuns < maxRuns) { + + // print status + Serial.println("Running GetWeatherByAddress - Run #" + String(numRuns++) + "..."); + + // we need a Process object to send a Choreo request to Temboo + Process GetWeatherByAddressChoreo; + + // invoke the Temboo client + GetWeatherByAddressChoreo.begin("temboo"); + + // set Temboo account credentials + GetWeatherByAddressChoreo.addParameter("-a"); + GetWeatherByAddressChoreo.addParameter(TEMBOO_ACCOUNT); + GetWeatherByAddressChoreo.addParameter("-u"); + GetWeatherByAddressChoreo.addParameter(TEMBOO_APP_KEY_NAME); + GetWeatherByAddressChoreo.addParameter("-p"); + GetWeatherByAddressChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Yahoo > Weather > GetWeatherByAddress) + GetWeatherByAddressChoreo.addParameter("-c"); + GetWeatherByAddressChoreo.addParameter("/Library/Yahoo/Weather/GetWeatherByAddress"); + + // set choreo inputs; in this case, the address for which to retrieve weather data + // the Temboo client provides standardized calls to 100+ cloud APIs + GetWeatherByAddressChoreo.addParameter("-i"); + GetWeatherByAddressChoreo.addParameter("Address:104 Franklin St., New York NY 10013"); + + // run the choreo + GetWeatherByAddressChoreo.run(); + + // when the choreo results are available, print them to the serial monitor + while(GetWeatherByAddressChoreo.available()) { + + // note that in this example, we just print the raw XML response from Yahoo + // see the examples on using Temboo SDK output filters at http://www.temboo.com/arduino + // for information on how to filter this data + + Serial.print((char)GetWeatherByAddressChoreo.read()); + } + GetWeatherByAddressChoreo.close(); + + } + + Serial.println("Sleeping..."); + Serial.println(""); + delay(30000); // sleep 30 seconds between GetWeatherByAddress calls +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ diff --git a/libraries/Bridge/examples/Temboo/ReadATweet/ReadATweet.ino b/libraries/Bridge/examples/Temboo/ReadATweet/ReadATweet.ino new file mode 100644 index 0000000..5acdbab --- /dev/null +++ b/libraries/Bridge/examples/Temboo/ReadATweet/ReadATweet.ino @@ -0,0 +1,185 @@ +/* + ReadATweet + + Demonstrates retrieving the most recent Tweet from a user's home timeline + using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + In order to run this sketch, you'll need to register an application using + the Twitter dev console at https://dev.twitter.com. After creating the + app, you'll find OAuth credentials for that application under the "OAuth Tool" tab. + Substitute these values for the placeholders below. + + This example assumes basic familiarity with Arduino sketches, and that your Yun + is connected to the Internet. + + Looking for social APIs? We've got Facebook, Google+, Instagram, Tumblr and more. + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +const String TWITTER_ACCESS_TOKEN = "your-twitter-access-token"; +const String TWITTER_ACCESS_TOKEN_SECRET = "your-twitter-access-token-secret"; +const String TWITTER_CONSUMER_KEY = "your-twitter-consumer-key"; +const String TWITTER_CONSUMER_SECRET = "your-twitter-consumer-secret"; + +int numRuns = 0; // execution count, so this sketch doesn't run forever +int maxRuns = 10; // the max number of times the Twitter HomeTimeline Choreo should run + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + delay(4000); + while(!Serial); + Bridge.begin(); +} + +void loop() +{ + // while we haven't reached the max number of runs... + if (numRuns < maxRuns) { + + // print status + Serial.println("Running ReadATweet - Run #" + String(numRuns++) + "..."); + + // define the Process that will be used to call the "temboo" client + Process HomeTimelineChoreo; + + // invoke the Temboo client + HomeTimelineChoreo.begin("temboo"); + + // set Temboo account credentials + HomeTimelineChoreo.addParameter("-a"); + HomeTimelineChoreo.addParameter(TEMBOO_ACCOUNT); + HomeTimelineChoreo.addParameter("-u"); + HomeTimelineChoreo.addParameter(TEMBOO_APP_KEY_NAME); + HomeTimelineChoreo.addParameter("-p"); + HomeTimelineChoreo.addParameter(TEMBOO_APP_KEY); + + // tell the Temboo client which Choreo to run (Twitter > Timelines > HomeTimeline) + HomeTimelineChoreo.addParameter("-c"); + HomeTimelineChoreo.addParameter("/Library/Twitter/Timelines/HomeTimeline"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Twitter/Timelines/HomeTimeline/ + // for complete details about the inputs for this Choreo + + HomeTimelineChoreo.addParameter("-i"); + HomeTimelineChoreo.addParameter("Count:1"); // the max number of Tweets to return from each request + + // add the Twitter account information + HomeTimelineChoreo.addParameter("-i"); + HomeTimelineChoreo.addParameter("AccessToken:" + TWITTER_ACCESS_TOKEN); + HomeTimelineChoreo.addParameter("-i"); + HomeTimelineChoreo.addParameter("AccessTokenSecret:" + TWITTER_ACCESS_TOKEN_SECRET); + HomeTimelineChoreo.addParameter("-i"); + HomeTimelineChoreo.addParameter("ConsumerSecret:" + TWITTER_CONSUMER_SECRET); + HomeTimelineChoreo.addParameter("-i"); + HomeTimelineChoreo.addParameter("ConsumerKey:" + TWITTER_CONSUMER_KEY); + + // next, we'll define two output filters that let us specify the + // elements of the response from Twitter that we want to receive. + // see the examples at http://www.temboo.com/arduino + // for more on using output filters + + // we want the text of the tweet + HomeTimelineChoreo.addParameter("-o"); + HomeTimelineChoreo.addParameter("tweet:/[1]/text:Response"); + + // and the name of the author + HomeTimelineChoreo.addParameter("-o"); + HomeTimelineChoreo.addParameter("author:/[1]/user/screen_name:Response"); + + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = HomeTimelineChoreo.run(); + + // a response code of 0 means success; print the API response + if(rc == 0) { + + String author; // a String to hold the tweet author's name + String tweet; // a String to hold the text of the tweet + + + // choreo outputs are returned as key/value pairs, delimited with + // newlines and record/field terminator characters, for example: + // Name1\n\x1F + // Value1\n\x1E + // Name2\n\x1F + // Value2\n\x1E + + // see the examples at http://www.temboo.com/arduino for more details + // we can read this format into separate variables, as follows: + + while(HomeTimelineChoreo.available()) { + // read the name of the output item + String name = HomeTimelineChoreo.readStringUntil('\x1F'); + name.trim(); + + // read the value of the output item + String data = HomeTimelineChoreo.readStringUntil('\x1E'); + data.trim(); + + // assign the value to the appropriate String + if (name == "tweet") { + tweet = data; + } else if (name == "author") { + author = data; + } + } + + Serial.println("@" + author + " - " + tweet); + + } else { + // there was an error + // print the raw output from the choreo + while(HomeTimelineChoreo.available()) { + Serial.print((char)HomeTimelineChoreo.read()); + } + } + + HomeTimelineChoreo.close(); + } + + Serial.println("Sleeping..."); + Serial.println(""); + delay(90000); // sleep 90 seconds between HomeTimeline calls +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ diff --git a/libraries/Bridge/examples/Temboo/SendATweet/SendATweet.ino b/libraries/Bridge/examples/Temboo/SendATweet/SendATweet.ino new file mode 100644 index 0000000..70befef --- /dev/null +++ b/libraries/Bridge/examples/Temboo/SendATweet/SendATweet.ino @@ -0,0 +1,142 @@ +/* + SendATweet + + Demonstrates sending a tweet via a Twitter account using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + In order to run this sketch, you'll need to register an application using + the Twitter dev console at https://dev.twitter.com. After creating the + app, you'll find OAuth credentials for that application under the "OAuth Tool" tab. + Substitute these values for the placeholders below. + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for social APIs? We've got Facebook, Google+, Instagram, Tumblr and more. + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +const String TWITTER_ACCESS_TOKEN = "your-twitter-access-token"; +const String TWITTER_ACCESS_TOKEN_SECRET = "your-twitter-access-token-secret"; +const String TWITTER_CONSUMER_KEY = "your-twitter-consumer-key"; +const String TWITTER_CONSUMER_SECRET = "your-twitter-consumer-secret"; + +int numRuns = 1; // execution count, so this sketch doesn't run forever +int maxRuns = 10; // the max number of times the Twitter HomeTimeline Choreo should run + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + delay(4000); + while(!Serial); + + Bridge.begin(); +} + +void loop() +{ + // only try to send the tweet if we haven't already sent it successfully + if (numRuns <= maxRuns) { + + Serial.println("Running SendATweet - Run #" + String(numRuns++) + "..."); + + // we need a Process object to send a Choreo request to Temboo + Process StatusesUpdateChoreo; + + // invoke the Temboo client + StatusesUpdateChoreo.begin("temboo"); + + // set Temboo account credentials + StatusesUpdateChoreo.addParameter("-a"); + StatusesUpdateChoreo.addParameter(TEMBOO_ACCOUNT); + StatusesUpdateChoreo.addParameter("-u"); + StatusesUpdateChoreo.addParameter(TEMBOO_APP_KEY_NAME); + StatusesUpdateChoreo.addParameter("-p"); + StatusesUpdateChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Twitter > Tweets > StatusesUpdate) + StatusesUpdateChoreo.addParameter("-c"); + StatusesUpdateChoreo.addParameter("/Library/Twitter/Tweets/StatusesUpdate"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Twitter/Tweets/StatusesUpdate/ + // for complete details about the inputs for this Choreo + + // add the Twitter account information + StatusesUpdateChoreo.addParameter("-i"); + StatusesUpdateChoreo.addParameter("AccessToken:" + TWITTER_ACCESS_TOKEN); + StatusesUpdateChoreo.addParameter("-i"); + StatusesUpdateChoreo.addParameter("AccessTokenSecret:" + TWITTER_ACCESS_TOKEN_SECRET); + StatusesUpdateChoreo.addParameter("-i"); + StatusesUpdateChoreo.addParameter("ConsumerSecret:" + TWITTER_CONSUMER_SECRET); + StatusesUpdateChoreo.addParameter("-i"); + StatusesUpdateChoreo.addParameter("ConsumerKey:" + TWITTER_CONSUMER_KEY); + + String tweet("My Arduino Yun has been running for " + String(millis()) + " milliseconds."); + + StatusesUpdateChoreo.addParameter("-i"); + StatusesUpdateChoreo.addParameter("StatusUpdate:" + tweet); + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = StatusesUpdateChoreo.run(); + + // a return code of zero (0) means everything worked + if (rc == 0) { + Serial.println("Success! Tweet sent!"); + } else { + // a non-zero return code means there was an error + // read and print the error message + while (StatusesUpdateChoreo.available()) { + Serial.print((char)StatusesUpdateChoreo.read()); + } + } + StatusesUpdateChoreo.close(); + + // do nothing for the next 90 seconds + Serial.println("Sleeping..."); + delay(90000); + } +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ + + + diff --git a/libraries/Bridge/examples/Temboo/SendAnEmail/SendAnEmail.ino b/libraries/Bridge/examples/Temboo/SendAnEmail/SendAnEmail.ino new file mode 100644 index 0000000..76fdc1d --- /dev/null +++ b/libraries/Bridge/examples/Temboo/SendAnEmail/SendAnEmail.ino @@ -0,0 +1,147 @@ +/* + SendAnEmail + + Demonstrates sending an email via a Google Gmail account using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + Since this sketch uses Gmail to send the email, you'll also need a valid + Google Gmail account. The sketch needs the username and password you use + to log into your Gmail account: substitute the placeholders below for these values. + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +// your Gmail address, eg "bob.smith@gmail.com" +const String GMAIL_USER_NAME = "xxxxxxxxxx"; + +// your Gmail password +const String GMAIL_PASSWORD = "xxxxxxxxxx"; + +// the email address you want to send the email to, eg "jane.doe@temboo.com" +const String TO_EMAIL_ADDRESS = "xxxxxxxxxx"; + + +boolean success = false; // a flag to indicate whether we've sent the email yet or not + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + delay(4000); + while(!Serial); + + Bridge.begin(); +} + +void loop() +{ + // only try to send the email if we haven't already sent it successfully + if (!success) { + + Serial.println("Running SendAnEmail..."); + + // we need a Process object to send a Choreo request to Temboo + Process SendEmailChoreo; + + // invoke the Temboo client + SendEmailChoreo.begin("temboo"); + + // set Temboo account credentials + SendEmailChoreo.addParameter("-a"); + SendEmailChoreo.addParameter(TEMBOO_ACCOUNT); + SendEmailChoreo.addParameter("-u"); + SendEmailChoreo.addParameter(TEMBOO_APP_KEY_NAME); + SendEmailChoreo.addParameter("-p"); + SendEmailChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Google > Gmail > SendEmail) + SendEmailChoreo.addParameter("-c"); + SendEmailChoreo.addParameter("/Library/Google/Gmail/SendEmail"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Google/Gmail/SendEmail/ + // for complete details about the inputs for this Choreo + + // the first input is a your Gmail user name. + SendEmailChoreo.addParameter("-i"); + SendEmailChoreo.addParameter("Username:" + GMAIL_USER_NAME); + + // next is your Gmail password. + SendEmailChoreo.addParameter("-i"); + SendEmailChoreo.addParameter("Password:" + GMAIL_PASSWORD); + + // who to send the email to + SendEmailChoreo.addParameter("-i"); + SendEmailChoreo.addParameter("ToAddress:" + TO_EMAIL_ADDRESS); + + // then a subject line + SendEmailChoreo.addParameter("-i"); + SendEmailChoreo.addParameter("Subject:ALERT: Greenhouse Temperature"); + + // next comes the message body, the main content of the email + SendEmailChoreo.addParameter("-i"); + SendEmailChoreo.addParameter("MessageBody:Hey! The greenhouse is too cold!"); + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = SendEmailChoreo.run(); + + // a return code of zero (0) means everything worked + if (rc == 0) { + Serial.println("Success! Email sent!"); + success = true; + } else { + // a non-zero return code means there was an error + // read and print the error message + while (SendEmailChoreo.available()) { + Serial.print((char)SendEmailChoreo.read()); + } + } + SendEmailChoreo.close(); + + // do nothing for the next 60 seconds + delay(60000); + } +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ + diff --git a/libraries/Bridge/examples/Temboo/SendAnSMS/SendAnSMS.ino b/libraries/Bridge/examples/Temboo/SendAnSMS/SendAnSMS.ino new file mode 100644 index 0000000..67a0b25 --- /dev/null +++ b/libraries/Bridge/examples/Temboo/SendAnSMS/SendAnSMS.ino @@ -0,0 +1,160 @@ +/* + SendAnSMS + + Demonstrates sending an SMS via a Twilio account using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + Since this sketch uses Twilio to send the SMS, you'll also need a valid + Twilio account. You can create one for free at https://www.twilio.com. + + The sketch needs your Twilio phone number, along with + the Account SID and Auth Token you get when you register with Twilio. + Make sure to use the Account SID and Auth Token from your Twilio Dashboard + (not your test credentials from the Dev Tools panel). + + Also note that if you're using a free Twilio account, you'll need to verify + the phone number to which messages are being sent by going to twilio.com and following + the instructions under the "Numbers > Verified Caller IDs" tab (this restriction + doesn't apply if you have a paid Twilio account). + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + + + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +// the Account SID from your Twilio account +const String TWILIO_ACCOUNT_SID = "xxxxxxxxxx"; + +// the Auth Token from your Twilio account +const String TWILIO_AUTH_TOKEN = "xxxxxxxxxx"; + +// your Twilio phone number, e.g., "+1 555-222-1212" +const String TWILIO_NUMBER = "xxxxxxxxxx"; + +// the number to which the SMS should be sent, e.g., "+1 555-222-1212" +const String RECIPIENT_NUMBER = "xxxxxxxxxx"; + +boolean success = false; // a flag to indicate whether we've sent the SMS yet or not + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + delay(4000); + while(!Serial); + + Bridge.begin(); +} + +void loop() +{ + // only try to send the SMS if we haven't already sent it successfully + if (!success) { + + Serial.println("Running SendAnSMS..."); + + // we need a Process object to send a Choreo request to Temboo + Process SendSMSChoreo; + + // invoke the Temboo client + SendSMSChoreo.begin("temboo"); + + // set Temboo account credentials + SendSMSChoreo.addParameter("-a"); + SendSMSChoreo.addParameter(TEMBOO_ACCOUNT); + SendSMSChoreo.addParameter("-u"); + SendSMSChoreo.addParameter(TEMBOO_APP_KEY_NAME); + SendSMSChoreo.addParameter("-p"); + SendSMSChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Twilio > SMSMessages > SendSMS) + SendSMSChoreo.addParameter("-c"); + SendSMSChoreo.addParameter("/Library/Twilio/SMSMessages/SendSMS"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Twilio/SMSMessages/SendSMS/ + // for complete details about the inputs for this Choreo + + // the first input is a your AccountSID + SendSMSChoreo.addParameter("-i"); + SendSMSChoreo.addParameter("AccountSID:" + TWILIO_ACCOUNT_SID); + + // next is your Auth Token + SendSMSChoreo.addParameter("-i"); + SendSMSChoreo.addParameter("AuthToken:" + TWILIO_AUTH_TOKEN); + + // next is your Twilio phone number + SendSMSChoreo.addParameter("-i"); + SendSMSChoreo.addParameter("From:" + TWILIO_NUMBER); + + // next, what number to send the SMS to + SendSMSChoreo.addParameter("-i"); + SendSMSChoreo.addParameter("To:" + RECIPIENT_NUMBER); + + // finally, the text of the message to send + SendSMSChoreo.addParameter("-i"); + SendSMSChoreo.addParameter("Body:Hey, there! This is a message from your Arduino Yun!"); + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = SendSMSChoreo.run(); + + // a return code of zero (0) means everything worked + if (rc == 0) { + Serial.println("Success! SMS sent!"); + success = true; + } else { + // a non-zero return code means there was an error + // read and print the error message + while (SendSMSChoreo.available()) { + Serial.print((char)SendSMSChoreo.read()); + } + } + SendSMSChoreo.close(); + + // do nothing for the next 60 seconds + Serial.println("Sleeping..."); + delay(60000); + } +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/
\ No newline at end of file diff --git a/libraries/Bridge/examples/Temboo/SendDataToGoogleSpreadsheet/SendDataToGoogleSpreadsheet.ino b/libraries/Bridge/examples/Temboo/SendDataToGoogleSpreadsheet/SendDataToGoogleSpreadsheet.ino new file mode 100644 index 0000000..9698d81 --- /dev/null +++ b/libraries/Bridge/examples/Temboo/SendDataToGoogleSpreadsheet/SendDataToGoogleSpreadsheet.ino @@ -0,0 +1,184 @@ +/* + SendDataToGoogleSpreadsheet + + Demonstrates appending a row of data to a Google spreadsheet from the Arduino Yun + using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + Since this sketch uses a Google spreadsheet, you'll also need a + Google account: substitute the placeholders below for your Google account values. + + This example assumes basic familiarity with Arduino sketches, and that your + Yun is connected to the Internet. + + The columns in your spreadsheet must have labels for the Choreo to + work properly. It doesn't matter what the column labels actually are, + but there must be text in the first row of each column. This example + assumes there are two columns. The first column is the time (in milliseconds) + that the row was appended, and the second column is a sensor value + (simulated in this example via a random number). In other words, your spreadsheet + should look like: + + Time | Sensor Value | + ------+----------------- + | | + + NOTE that the first time you run this sketch, you may receive a warning from + Google, prompting you to authorize access from a 3rd party system. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. + +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information, + // as described in the footer comment below + + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +const String GOOGLE_USERNAME = "your-google-username"; +const String GOOGLE_PASSWORD = "your-google-password"; + +// the title of the spreadsheet you want to send data to +const String SPREADSHEET_TITLE = "your-spreadsheet-title"; + + +const unsigned long RUN_INTERVAL_MILLIS = 60000; // how often to run the Choreo (in milliseconds) + +// the last time we ran the Choreo +// (initialized to 60 seconds ago so the +// Choreo is run immediately when we start up) +unsigned long lastRun = (unsigned long)-60000; + +void setup() { + + // for debugging, wait until a serial console is connected + Serial.begin(9600); + delay(4000); + while(!Serial); + + Serial.print("Initializing the bridge..."); + Bridge.begin(); + Serial.println("Done"); +} + +void loop() +{ + // get the number of milliseconds this sketch has been running + unsigned long now = millis(); + + // run again if it's been 60 seconds since we last ran + if (now - lastRun >= RUN_INTERVAL_MILLIS) { + + // remember 'now' as the last time we ran the choreo + lastRun = now; + + Serial.println("Getting sensor value..."); + + // get the value we want to append to our spreadsheet + unsigned long sensorValue = getSensorValue(); + + Serial.println("Appending value to spreadsheet..."); + + // we need a Process object to send a Choreo request to Temboo + Process AppendRowChoreo; + + // invoke the Temboo client + AppendRowChoreo.begin("temboo"); + + // set Temboo account credentials + AppendRowChoreo.addParameter("-a"); + AppendRowChoreo.addParameter(TEMBOO_ACCOUNT); + AppendRowChoreo.addParameter("-u"); + AppendRowChoreo.addParameter(TEMBOO_APP_KEY_NAME); + AppendRowChoreo.addParameter("-p"); + AppendRowChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Google > Spreadsheets > AppendRow) + AppendRowChoreo.addParameter("-c"); + AppendRowChoreo.addParameter("/Library/Google/Spreadsheets/AppendRow"); + + // set the required Choreo inputs + // see https://www.temboo.com/library/Library/Google/Spreadsheets/AppendRow/ + // for complete details about the inputs for this Choreo + + // your Google username (usually your email address) + AppendRowChoreo.addParameter("-i"); + AppendRowChoreo.addParameter("Username:" + GOOGLE_USERNAME); + + // your Google account password + AppendRowChoreo.addParameter("-i"); + AppendRowChoreo.addParameter("Password:" + GOOGLE_PASSWORD); + + // the title of the spreadsheet you want to append to + // NOTE: substitute your own value, retaining the "SpreadsheetTitle:" prefix. + AppendRowChoreo.addParameter("-i"); + AppendRowChoreo.addParameter("SpreadsheetTitle:" + SPREADSHEET_TITLE); + + // convert the time and sensor values to a comma separated string + String rowData(now); + rowData += ","; + rowData += sensorValue; + + // add the RowData input item + AppendRowChoreo.addParameter("-i"); + AppendRowChoreo.addParameter("RowData:" + rowData); + + // run the Choreo and wait for the results + // The return code (rc) will indicate success or failure + unsigned int rc = AppendRowChoreo.run(); + + // return code of zero (0) means success + if (rc == 0) { + Serial.println("Success! Appended " + rowData); + Serial.println(""); + } else { + // return code of anything other than zero means failure + // read and display any error messages + while (AppendRowChoreo.available()) { + Serial.print((char)AppendRowChoreo.read()); + } + } + + AppendRowChoreo.close(); + } +} + +// this function simulates reading the value of a sensor +// in this example, we're generating a random number +unsigned long getSensorValue() { + return (unsigned long)random(0, 256); +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ + diff --git a/libraries/Bridge/examples/Temboo/ToxicFacilitiesSearch/ToxicFacilitiesSearch.ino b/libraries/Bridge/examples/Temboo/ToxicFacilitiesSearch/ToxicFacilitiesSearch.ino new file mode 100644 index 0000000..eea009e --- /dev/null +++ b/libraries/Bridge/examples/Temboo/ToxicFacilitiesSearch/ToxicFacilitiesSearch.ino @@ -0,0 +1,174 @@ +/* + ToxicFacilitiesSearch + + Demonstrates making a request to the Envirofacts API using the Temboo Arduino Yun SDK. + This example retrieves the names and addresses of EPA-regulated facilities in the + Toxins Release Inventory (TRI) database within a given zip code. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + +// the zip code to search +const String US_ZIP_CODE = "11215"; + +int numRuns = 1; // execution count, so that this doesn't run forever +int maxRuns = 10; // max number of times the Envirofacts FacilitiesSearch Choreo should be run + +void setup() { + Serial.begin(9600); + + // for debugging, wait until a serial console is connected + delay(4000); + while(!Serial); + Bridge.begin(); +} + +void loop() +{ + // while we haven't reached the max number of runs... + if (numRuns <= maxRuns) { + + // print status + Serial.println("Running ToxicFacilitiesSearch - Run #" + String(numRuns++) + "..."); + + // we need a Process object to send a Choreo request to Temboo + Process FacilitiesSearchByZipChoreo; + + // invoke the Temboo client + FacilitiesSearchByZipChoreo.begin("temboo"); + + // set Temboo account credentials + FacilitiesSearchByZipChoreo.addParameter("-a"); + FacilitiesSearchByZipChoreo.addParameter(TEMBOO_ACCOUNT); + FacilitiesSearchByZipChoreo.addParameter("-u"); + FacilitiesSearchByZipChoreo.addParameter(TEMBOO_APP_KEY_NAME); + FacilitiesSearchByZipChoreo.addParameter("-p"); + FacilitiesSearchByZipChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (EnviroFacts > Toxins > FacilitiesSearchByZip) + FacilitiesSearchByZipChoreo.addParameter("-c"); + FacilitiesSearchByZipChoreo.addParameter("/Library/EnviroFacts/Toxins/FacilitiesSearchByZip"); + + // set choreo inputs; in this case, the US zip code for which to retrieve toxin release data + // the Temboo client provides standardized calls to 100+ cloud APIs + FacilitiesSearchByZipChoreo.addParameter("-i"); + FacilitiesSearchByZipChoreo.addParameter("Zip:" + US_ZIP_CODE); + + // specify two output filters, to help simplify the Envirofacts API results. + // see the tutorials on using Temboo SDK output filters at http://www.temboo.com/arduino + FacilitiesSearchByZipChoreo.addParameter("-o"); + FacilitiesSearchByZipChoreo.addParameter("fac:FACILITY_NAME:Response"); + + FacilitiesSearchByZipChoreo.addParameter("-o"); + FacilitiesSearchByZipChoreo.addParameter("addr:STREET_ADDRESS:Response"); + + // run the choreo + FacilitiesSearchByZipChoreo.run(); + + String facs; + String addrs; + + // when the choreo results are available, process them. + // the output filters we specified will return comma delimited + // lists containing the name and street address of the facilities + // located in the specified zip code. + while(FacilitiesSearchByZipChoreo.available()) { + String name = FacilitiesSearchByZipChoreo.readStringUntil('\x1F'); + name.trim(); + + String data = FacilitiesSearchByZipChoreo.readStringUntil('\x1E'); + data.trim(); + + if (name == "fac") { + facs = data; + } else if (name == "addr") { + addrs = data; + } + } + FacilitiesSearchByZipChoreo.close(); + + // parse the comma delimited lists of facilities to join the + // name with the address and print it to the serial monitor + if (facs.length() > 0) { + int i = -1; + int fstart = 0; + int astart = 0; + String f; + String a; + do { + i = facs.indexOf(',', fstart); + if (i >= 0) { + f = facs.substring(fstart, i); + fstart = i + 1; + } + + i = addrs.indexOf(',', astart); + if (i >= 0) { + a = addrs.substring(astart, i); + astart = i + 1; + } + + if (i >= 0) { + printResult(f, a); + } + + }while (i >= 0); + f = facs.substring(fstart); + a = addrs.substring(astart); + printResult(f, a); + } else { + Serial.println("No facilities found in zip code " + US_ZIP_CODE); + } + } + + Serial.println("Sleeping..."); + Serial.println(""); + delay(30000); // sleep 30 seconds between calls +} + +// a simple utility function, to output the facility name and address in the serial monitor. +void printResult(String fac, String addr) { + Serial.print(fac); + Serial.print(" - "); + Serial.println(addr); +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ + diff --git a/libraries/Bridge/examples/Temboo/UpdateFacebookStatus/UpdateFacebookStatus.ino b/libraries/Bridge/examples/Temboo/UpdateFacebookStatus/UpdateFacebookStatus.ino new file mode 100644 index 0000000..1352762 --- /dev/null +++ b/libraries/Bridge/examples/Temboo/UpdateFacebookStatus/UpdateFacebookStatus.ino @@ -0,0 +1,133 @@ +/* + UpdateFacebookStatus + + Demonstrates sending a Facebook status update using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + In order to run this sketch, you'll need to register an application using + the Facebook dev console at https://developers.facebook.com/apps. After creating + the app, log in to Temboo and visit https://www.temboo.com/library/Library/Facebook/Publishing/SetStatus/ + to use our OAuth Wizard (or OAuth Choreos) to obtain a Facebook access token. + Substitute your access token for the placeholder value of FACEBOOK_ACCESS_TOKEN below. + + This example assumes basic familiarity with Arduino sketches, and that your Yun + is connected to the Internet. + + Looking for social APIs? We've got Twitter, Google+, Instagram, Tumblr and more. + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information, + // as described in the footer comment below + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +// the Facebook Access Token, which can be obtained using the Temboo OAuth Wizard or Choreos +const String FACEBOOK_ACCESS_TOKEN = "xxxxxxxxxx"; + + +int numRuns = 0; // execution count, so this sketch doesn't run forever +int maxRuns = 10; // the max number of times the Facebook SetStatus Choreo should run + +void setup() { + Serial.begin(9600); + + // For debugging, wait until a serial console is connected. + delay(4000); + while(!Serial); + Bridge.begin(); +} + +void loop() { + // while we haven't reached the max number of runs... + if (numRuns < maxRuns) { + + // print status + Serial.println("Running UpdateFacebookStatus - Run #" + String(numRuns++) + "..."); + + // Define the status message we want to post on Facebook; since Facebook + // doesn't allow duplicate status messages, we'll include a changing value. + String statusMsg = "My Arduino Yun has been running for " + String(millis()) + " milliseconds!"; + + // define the Process that will be used to call the "temboo" client + Process SetStatusChoreo; + + // invoke the Temboo client + SetStatusChoreo.begin("temboo"); + + // set Temboo account credentials + SetStatusChoreo.addParameter("-a"); + SetStatusChoreo.addParameter(TEMBOO_ACCOUNT); + SetStatusChoreo.addParameter("-u"); + SetStatusChoreo.addParameter(TEMBOO_APP_KEY_NAME); + SetStatusChoreo.addParameter("-p"); + SetStatusChoreo.addParameter(TEMBOO_APP_KEY); + + // tell the Temboo client which Choreo to run (Facebook > Publishing > SetStatus) + SetStatusChoreo.addParameter("-c"); + SetStatusChoreo.addParameter("/Library/Facebook/Publishing/SetStatus"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Facebook/Publishing/SetStatus/ + // for complete details about the inputs for this Choreo + + SetStatusChoreo.addParameter("-i"); + SetStatusChoreo.addParameter("AccessToken:" + FACEBOOK_ACCESS_TOKEN); + SetStatusChoreo.addParameter("-i"); + SetStatusChoreo.addParameter("Message:" + statusMsg); + + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = SetStatusChoreo.run(); + + // print the response code and API response. + Serial.println("Resonse code: " + String(rc)); + + // note that in this case, we're just printing the raw response from Facebook. + // see the examples on using Temboo SDK output filters at http://www.temboo.com/arduino + // for information on how to filter this data + while(SetStatusChoreo.available()) { + Serial.print((char)SetStatusChoreo.read()); + } + + SetStatusChoreo.close(); + } + + Serial.println("Sleeping..."); + Serial.println(""); + + delay(30000); // sleep 30 seconds between SetStatus calls +} + +/* + IMPORTANT NOTE: TembooAccount.h: + + TembooAccount.h is a file referenced by this sketch that contains your Temboo account information. + You need to create this file. To do so, make a new tab in Arduino, call it TembooAccount.h, and + include the following variables and constants: + + #define TEMBOO_ACCOUNT "myTembooAccountName" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "myFirstApp" // your Temboo app key name + #define TEMBOO_APP_KEY "xxx-xxx-xxx-xx-xxx" // your Temboo app key + + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/
\ No newline at end of file diff --git a/libraries/Bridge/examples/Temboo/UploadToDropbox/UploadToDropbox.ino b/libraries/Bridge/examples/Temboo/UploadToDropbox/UploadToDropbox.ino new file mode 100644 index 0000000..cb56582 --- /dev/null +++ b/libraries/Bridge/examples/Temboo/UploadToDropbox/UploadToDropbox.ino @@ -0,0 +1,212 @@ +/* + UploadToDropbox + + Demonstrates uploading a file to Dropbox using the Temboo Arduino Yun SDK. + + Check out the latest Arduino & Temboo examples and support docs at http://www.temboo.com/arduino + + A Temboo account and application key are necessary to run all Temboo examples. + If you don't already have one, you can register for a free Temboo account at + http://www.temboo.com + + You'll also need a valid Dropbox account, and OAuth credentials for Dropbox. To + obtain OAuth credentials for Dropbox, you'll need to register a Dropbox app at + https://www.dropbox.com/developers/apps and then follow the instructions at + https://www.temboo.com/library/Library/Dropbox/OAuth/ to run the Initialize and Finalize + OAuth Choreos to complete the OAuth handshake and retrieve your Access Token information. + + This example assumes basic familiarity with Arduino sketches, and that your Yun is connected + to the Internet. + + Looking for another API? We've got over 100 in our Library! + + This example code is in the public domain. +*/ + +#include <Bridge.h> +#include <Console.h> +#include <FileIO.h> +#include <HttpClient.h> +#include <Process.h> +#include "TembooAccount.h" // contains Temboo account information + // as described in the footer comment below + + +/*** SUBSTITUTE YOUR VALUES BELOW: ***/ + +// your Dropbox app key, available on the Dropbox developer console after registering an app +const String DROPBOX_APP_KEY = "xxxxxxxxxx"; + +// your Dropbox app secret, available on the Dropbox developer console after registering an app +const String DROPBOX_APP_SECRET = "xxxxxxxxxx"; + +// your Dropbox access token, which is returned by the FinalizeOAuth Choreo +const String DROPBOX_ACCESS_TOKEN = "xxxxxxxxxx"; + +// your Dropbox access token secret, which is returned by the FinalizeOAuth Choreo +const String DROPBOX_ACCESS_TOKEN_SECRET = "xxxxxxxxxx"; + + +boolean success = false; // a flag to indicate whether we've uploaded the file yet + +void setup() { + Serial.begin(9600); + + // For debugging, wait until a serial console is connected. + delay(4000); + while(!Serial); + Bridge.begin(); +} + +void loop() +{ + // only try to upload the file if we haven't already done so + if (!success) { + + Serial.println("Base64 encoding data to upload..."); + + // base64 encode the data to upload + String base64EncodedData = base64Encode("Hello, Arduino!"); + + + Serial.println("Uploading data to Dropbox..."); + + // we need a Process object to send a Choreo request to Temboo + Process UploadFileChoreo; + + // invoke the Temboo client + UploadFileChoreo.begin("temboo"); + + // set Temboo account credentials + UploadFileChoreo.addParameter("-a"); + UploadFileChoreo.addParameter(TEMBOO_ACCOUNT); + UploadFileChoreo.addParameter("-u"); + UploadFileChoreo.addParameter(TEMBOO_APP_KEY_NAME); + UploadFileChoreo.addParameter("-p"); + UploadFileChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Dropbox > FilesAndMetadata > UploadFile) + UploadFileChoreo.addParameter("-c"); + UploadFileChoreo.addParameter("/Library/Dropbox/FilesAndMetadata/UploadFile"); + + // set the required choreo inputs + // see https://www.temboo.com/library/Library/Dropbox/FilesAndMetadata/UploadFile/ + // for complete details about the inputs for this Choreo + + // first specify the name of the file to create/update on Dropbox + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("FileName:ArduinoTest.txt"); + + // next, the root folder on Dropbox relative to which the file path is specified. + // unless you're using an in-production Dropbox app, this should be left as "sandbox" + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("Root:sandbox"); + + // next, the Base64 encoded file data to upload + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("FileContents:" + base64EncodedData); + + // finally, the Dropbox OAuth credentials defined above + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("AppSecret:" + DROPBOX_APP_SECRET); + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("AccessToken:" + DROPBOX_ACCESS_TOKEN); + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("AccessTokenSecret:" + DROPBOX_ACCESS_TOKEN_SECRET); + UploadFileChoreo.addParameter("-i"); + UploadFileChoreo.addParameter("AppKey:" + DROPBOX_APP_KEY); + + // tell the Process to run and wait for the results. The + // return code (rc) will tell us whether the Temboo client + // was able to send our request to the Temboo servers + unsigned int rc = UploadFileChoreo.run(); + + // a return code of zero (0) means everything worked + if (rc == 0) { + Serial.println("Success! File uploaded!"); + success = true; + } else { + // a non-zero return code means there was an error + Serial.println("Uh-oh! Something went wrong!"); + } + + // print out the full response to the serial monitor in all + // cases, just for debugging + while (UploadFileChoreo.available()) { + Serial.print((char)UploadFileChoreo.read()); + } + UploadFileChoreo.close(); + + Serial.println("Sleeping..."); + } + + delay(30000); // sleep 30 seconds between upload attempts +} + + +/* + A utility function to Base64 encode the specified string + by calling a Temboo Utilities Choreo. +*/ +String base64Encode(String toEncode) { + + // we need a Process object to send a Choreo request to Temboo + Process Base64EncodeChoreo; + + // invoke the Temboo client + Base64EncodeChoreo.begin("temboo"); + + // set Temboo account credentials + Base64EncodeChoreo.addParameter("-a"); + Base64EncodeChoreo.addParameter(TEMBOO_ACCOUNT); + Base64EncodeChoreo.addParameter("-u"); + Base64EncodeChoreo.addParameter(TEMBOO_APP_KEY_NAME); + Base64EncodeChoreo.addParameter("-p"); + Base64EncodeChoreo.addParameter(TEMBOO_APP_KEY); + + // identify the Temboo Library choreo to run (Utilities > Encoding > Base64Encode) + Base64EncodeChoreo.addParameter("-c"); + Base64EncodeChoreo.addParameter("/Library/Utilities/Encoding/Base64Encode"); + + // set choreo inputs + Base64EncodeChoreo.addParameter("-i"); + Base64EncodeChoreo.addParameter("Text:" + toEncode); + + // run the choreo + Base64EncodeChoreo.run(); + + // read in the choreo results, and return the "Base64EncodedText" output value. + // see http://www.temboo.com/arduino for more details on using choreo outputs. + while(Base64EncodeChoreo.available()) { + // read the name of the output item + String name = Base64EncodeChoreo.readStringUntil('\x1F'); + name.trim(); + + // read the value of the output item + String data = Base64EncodeChoreo.readStringUntil('\x1E'); + data.trim(); + + if(name == "Base64EncodedText") { + return data; + } + } +} + +/* + IMPORTANT NOTE About TembooAccount.h: + + TembooAccount.h is not included with this example because it contains your account information. + You need to create it for your own version of this application. To do so, make + a new tab in Arduino, call it TembooAccount.h, and include the following variables and constants: + + #define TEMBOO_ACCOUNT "matthew-yun" // your Temboo account name + #define TEMBOO_APP_KEY_NAME "someKey" // your Temboo app key name + #define TEMBOO_APP_KEY "fveIrkjAVIkuNUUPE6df" // your Temboo app key + The same TembooAccount.h file settings can be used for all Temboo SDK sketches. + + You can find your Temboo App Key information on the Temboo website, + under My Account > Application Keys + + Keeping your account information in a separate file means you can save it once, + then just distribute the main .ino file without worrying that you forgot to delete your credentials. +*/ diff --git a/libraries/Bridge/examples/TimeCheck/TimeCheck.ino b/libraries/Bridge/examples/TimeCheck/TimeCheck.ino new file mode 100644 index 0000000..2673dea --- /dev/null +++ b/libraries/Bridge/examples/TimeCheck/TimeCheck.ino @@ -0,0 +1,79 @@ + +/* + Time Check + + Gets the time from the linino processor via Bridge + then parses out hours, minutes and seconds for the Arduino + using an Arduino Yun. + + created 27 May 2013 + modified 21 June 2013 + By Tom Igoe + */ + + +#include <Process.h> + +Process date; // process used to get the date +int hours, minutes, seconds; // for the results +int lastSecond = -1; // need an impossible value for comparison + +void setup() { + Serial.begin(9600); // initialize serial + Bridge.begin(); // initialize Bridge + + while(!Serial); // wait for Serial Monitor to open + Serial.println("Time Check"); // Title of sketch + + // run an initial date process. Should return: + // hh:mm:ss : + if (!date.running()) { + date.begin("date"); + date.addParameter("+%T"); + date.run(); + } +} + +void loop() { + + if(lastSecond != seconds) { // if a second has passed + // print the time: + if (hours <= 9) Serial.print("0"); // adjust for 0-9 + Serial.print(hours); + Serial.print(":"); + if (minutes <= 9) Serial.print("0"); // adjust for 0-9 + Serial.print(minutes); + Serial.print(":"); + if (seconds <= 9) Serial.print("0"); // adjust for 0-9 + Serial.println(seconds); + + // restart the date process: + if (!date.running()) { + date.begin("date"); + date.addParameter("+%T"); + date.run(); + } + } + + //if there's a result from the date process, parse it: + while (date.available()>0) { + // get the result of the date process (should be hh:mm:ss): + String timeString = date.readString(); + + // find the colons: + int firstColon = timeString.indexOf(":"); + int secondColon= timeString.lastIndexOf(":"); + + // get the substrings for hour, minute second: + String hourString = timeString.substring(0, firstColon); + String minString = timeString.substring(firstColon+1, secondColon); + String secString = timeString.substring(secondColon+1); + + // convert to ints,saving the previous second: + hours = hourString.toInt(); + minutes = minString.toInt(); + lastSecond = seconds; // save to do a time comparison + seconds = secString.toInt(); + } + +} diff --git a/libraries/Bridge/examples/WiFiStatus/WiFiStatus.ino b/libraries/Bridge/examples/WiFiStatus/WiFiStatus.ino new file mode 100644 index 0000000..4df9bf0 --- /dev/null +++ b/libraries/Bridge/examples/WiFiStatus/WiFiStatus.ino @@ -0,0 +1,32 @@ +#include <Process.h> + +void setup() { + Serial.begin(9600); // initialize serial communication + while(!Serial); // do nothing until the serial monitor is opened + + Serial.println("Starting bridge...\n"); + pinMode(13,OUTPUT); + digitalWrite(13, LOW); + Bridge.begin(); // make contact with the linux processor + digitalWrite(13, HIGH); + + delay(2000); // wait 2 seconds +} + +void loop() { + Process wifiCheck; // initialize a new process + + wifiCheck.runShellCommand("lua /arduino/pretty_wifi_info.lua"); // command you want to run + + // while there's any characters coming back from the + // process, print them to the serial monitor: + while (wifiCheck.available() > 0) { + char thisChar = wifiCheck.read(); + Serial.print(thisChar); + } + + Serial.println(); + + delay(5000); +} + diff --git a/libraries/Bridge/examples/XivelyClient/XivelyClient.ino b/libraries/Bridge/examples/XivelyClient/XivelyClient.ino new file mode 100644 index 0000000..69f979c --- /dev/null +++ b/libraries/Bridge/examples/XivelyClient/XivelyClient.ino @@ -0,0 +1,110 @@ +/* + Xively sensor client with Strings + + This sketch connects an analog sensor to Xively, + using an Arduino Yún. + + created 15 March 2010 + updated 27 May 2013 + by Tom Igoe + + */ + +// include all Libraries needed: +#include <Process.h> +#include "passwords.h" // contains my passwords, see below + +/* + NOTE: passwords.h is not included with this repo because it contains my passwords. + You need to create it for your own version of this application. To do so, make + a new tab in Arduino, call it passwords.h, and include the following variables and constants: + + #define APIKEY "foo" // replace your pachube api key here + #define FEEDID 0000 // replace your feed ID + #define USERAGENT "my-project" // user agent is the project name + */ + + +// set up net client info: +const unsigned long postingInterval = 60000; //delay between updates to xively.com +unsigned long lastRequest = 0; // when you last made a request +String dataString = ""; + +void setup() { + // start serial port: + Bridge.begin(); + Serial.begin(9600); + + while(!Serial); // wait for Network Serial to open + Serial.println("Xively client"); + + // Do a first update immediately + updateData(); + sendData(); + lastRequest = millis(); +} + +void loop() { + // get a timestamp so you can calculate reading and sending intervals: + long now = millis(); + + // if the sending interval has passed since your + // last connection, then connect again and send data: + if (now - lastRequest >= postingInterval) { + updateData(); + sendData(); + lastRequest = now; + } +} + +void updateData() { + // convert the readings to a String to send it: + dataString = "Temperature,"; + dataString += random(10) + 20; + // add pressure: + dataString += "\nPressure,"; + dataString += random(5) + 100; +} + +// this method makes a HTTP connection to the server: +void sendData() { + // form the string for the API header parameter: + String apiString = "X-ApiKey: "; + apiString += APIKEY; + + // form the string for the URL parameter: + String url = "https://api.xively.com/v2/feeds/"; + url += FEEDID; + url += ".csv"; + + // Send the HTTP PUT request + + // Is better to declare the Process here, so when the + // sendData function finishes the resources are immediately + // released. Declaring it global works too, BTW. + Process xively; + Serial.print("\n\nSending data... "); + xively.begin("curl"); + xively.addParameter("-k"); + xively.addParameter("--request"); + xively.addParameter("PUT"); + xively.addParameter("--data"); + xively.addParameter(dataString); + xively.addParameter("--header"); + xively.addParameter(apiString); + xively.addParameter(url); + xively.run(); + Serial.println("done!"); + + // If there's incoming data from the net connection, + // send it out the Serial: + while (xively.available()>0) { + char c = xively.read(); + Serial.write(c); + } + +} + + + + diff --git a/libraries/Bridge/examples/YunSerialTerminal/YunSerialTerminal.ino b/libraries/Bridge/examples/YunSerialTerminal/YunSerialTerminal.ino new file mode 100644 index 0000000..0ae3c2e --- /dev/null +++ b/libraries/Bridge/examples/YunSerialTerminal/YunSerialTerminal.ino @@ -0,0 +1,73 @@ +/* + Arduino Yun USB-to-Serial + + Allows you to use the Yun's 32U4 processor as a + serial terminal for the linino processor. + + Upload this to an Arduino Yun via serial (not WiFi) + then open the serial monitor at 115200 to see the boot process + of the linino processor. You can also use the serial monitor + as a basic command line interface for the linino processor using + this sketch. + + From the serial monitor the following commands can be issued: + + '~' followed by '0' -> Set the UART speed to 57600 baud + '~' followed by '1' -> Set the UART speed to 115200 baud + '~' followed by '2' -> Set the UART speed to 250000 baud + '~' followed by '3' -> Set the UART speed to 500000 baud + + The circuit: + * Arduino Yun + + created March 2013 + by Massimo Banzi + modified by Cristian Maglie + + This example code is in the public domain. + */ + +long lininoBaud = 250000; + +void setup() { + Serial.begin(115200); // open serial connection via USB-Serial + Serial1.begin(lininoBaud); // open serial connection to Linino +} + +boolean commandMode = false; + +void loop() { + // copy from virtual serial line to uart and vice versa + if (Serial.available()) { // got anything from USB-Serial? + char c = (char)Serial.read(); // read from USB-serial + if (commandMode == false) { // if we aren't in command mode... + if (c == '~') { // Tilde '~' key pressed? + commandMode = true; // enter in command mode + } else { + Serial1.write(c); // otherwise write char to Linino + } + } else { // if we are in command mode... + if (c == '0') { // '0' key pressed? + Serial1.begin(57600); // set speed to 57600 + Serial.println("Speed set to 57600"); + } else if (c == '1') { // '1' key pressed? + Serial1.begin(115200); // set speed to 115200 + Serial.println("Speed set to 115200"); + } else if (c == '2') { // '2' key pressed? + Serial1.begin(250000); // set speed to 250000 + Serial.println("Speed set to 250000"); + } else if (c == '3') { // '3' key pressed? + Serial1.begin(500000); // set speed to 500000 + Serial.println("Speed set to 500000"); + } else { // any other key pressed? + Serial1.write('~'); // write '~' to Linino + Serial1.write(c); // write char to Linino + } + commandMode = false; // in all cases exit from command mode + } + } + if (Serial1.available()) { // got anything from Linino? + char c = (char)Serial1.read(); // read from Linino + Serial.write(c); // write to USB-serial + } +} |