diff options
Diffstat (limited to 'libraries/Bridge/examples')
16 files changed, 1206 insertions, 0 deletions
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..df1e069 --- /dev/null +++ b/libraries/Bridge/examples/Bridge/Bridge.ino @@ -0,0 +1,133 @@ + +#include <Bridge.h> + +void setup() { + pinMode(13,OUTPUT); + digitalWrite(13, LOW); + Bridge.begin(); + digitalWrite(13, HIGH); +} + +void loop() { + while (Bridge.messageAvailable()) { + uint8_t buff[64]; + int l = Bridge.readMessage(buff, 64); + process(buff, l); + } + delay(100); // Poll every 0.100s +} + +void process(uint8_t buff[], int length) { + // "digital/13/1" -> digitalWrite(13, HIGH) + // "digital/13" -> digitalRead(13) + // "analog/2/123" -> analogWrite(2, 123) + // "analog/2" -> analogRead(2) + // "mode/13/input" -> pinMode(13, INPUT) + // "mode/13/output" -> pinMode(13, OUTPUT) + + // Sanity check + if (length < 9 || length > 14) + return; + + // string terminator + buff[length] = '\0'; + + String command = String((char*)buff); + + // digital command + if (command.indexOf("digital/") == 0) { + command = command.substring(8); + digitalCommand(command); + + // analog command + } else if (command.indexOf("analog/") == 0) { + command = command.substring(7); + analogCommand(command); + + // mode command + } else if (command.indexOf("mode/") == 0) { + command = command.substring(5); + modeCommand(command); + } +} + +void digitalCommand(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(); + digitalWrite(pin, value); + } else { + pin = command.toInt(); + } + 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 += "\"}"; + Bridge.writeJSON(json); +} + +void reportDigitalRead(int pin, boolean dataset) { + int value = digitalRead(pin); + + String json = "{\"pin\":"; + json += pin; + json += ", \"value\": "; + json += value; + json += "}"; + Bridge.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 += "}"; + Bridge.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/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..dfd269f --- /dev/null +++ b/libraries/Bridge/examples/Datalogger/Datalogger.ino @@ -0,0 +1,88 @@ +/* + SD card datalogger + + This example shows how to log data from three analog sensors + to an SD card mounted on the Linux 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 becareful to don't remove it while + the system is writing on it. + + created 24 Nov 2010 + modified 9 Apr 2012 + by Tom Igoe + adapted to the Yun Bridge library 20 Jun 2013 + by Federico Vanzati + + This example code is in the public domain. + + */ + +#include <FileIO.h> +#include <Console.h> + +void setup() { + // Initialize the Bridge and the Console + Bridge.begin(); + Console.begin(); + FileSystem.begin(); + + while(!Console){ + ; // wait for Console port to connect. + } +} + + +void loop () { + // make a string that start with a timestamp for assembling the data to log: + String dataString = ""; + addTimeStamp(dataString); + 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: + Console.println(dataString); + } + // if the file isn't open, pop up an error: + else { + Console.println("error opening datalog.txt"); + } + + delay(15000); + +} + +// This function append a time stamp to the string passed as argument +void addTimeStamp(String &string) { + Process time; + time.begin("date"); + time.addParameter("+%D-%T"); + time.run(); + + while(time.available()>0) { + char c = time.read(); + if(c != '\n') + string += 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/OLDWiFiCheck/OLDWiFiCheck.ino b/libraries/Bridge/examples/OLDWiFiCheck/OLDWiFiCheck.ino new file mode 100644 index 0000000..1cb9f03 --- /dev/null +++ b/libraries/Bridge/examples/OLDWiFiCheck/OLDWiFiCheck.ino @@ -0,0 +1,53 @@ +/* + Arduino Yun Wireless Config Check + + Checks the wireless state of Arduino Yun by calling + the linux command iwconfig. + + Upload this to an Arduino Yun via serial (not WiFi) + then open the serial monitor to see the status of + your Yun's WiFi connection. If it's connected to + a wireless network, the ESSID (name) of that network + and the signal strength will appear. + + The circuit: + * Arduino Yun + + created 22 May 2013 + by Tom Igoe + + This example code is in the public domain. + */ + +#include <Process.h> + +void setup() { + Serial.begin(9600); // initialize serial communication + while(!Serial); // do nothing until the serial monitor is opened + + pinMode(13,OUTPUT); + digitalWrite(13, LOW); + Bridge.begin(); // make contact with the linux processor + digitalWrite(13, HIGH); + + delay(2000); // wait 2 seconds + + Process wifiCheck; // initialize a new process + + + wifiCheck.begin("iwconfig"); // command you want to run + wifiCheck.addParameter("wlan0"); // parameter of the command + wifiCheck.run(); // run the command + + // 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); + } +} + +void loop() { + // nothing to do here. +} + diff --git a/libraries/Bridge/examples/OLDWifiSignalStrengthIndicator/OLDWifiSignalStrengthIndicator.ino b/libraries/Bridge/examples/OLDWifiSignalStrengthIndicator/OLDWifiSignalStrengthIndicator.ino new file mode 100644 index 0000000..e0b2d1f --- /dev/null +++ b/libraries/Bridge/examples/OLDWifiSignalStrengthIndicator/OLDWifiSignalStrengthIndicator.ino @@ -0,0 +1,112 @@ +/* + Wifi Signal Strength Indicator + + This example demonstrates the use of the bridge and process libraries + to communicate between the Arduino side and the linux side of the Arduino Yun. + + The Linux script returns the strength of the wifi signal. + + The Arduino sketch uses LEDs to indicate whether the current value of + the signal strength is above, below, or the same as the last value + + The circuit: + * LEDs on pins 8, 9, and 10 + * Built-in LED on pin 13 + + The script: + The following one line script must exist in the /root directory of the + linux file system, in a file named "wifiStrength.sh", and it must be executable: + + tail -1 /proc/net/wireless | cut -c22-23 + + created 06 June 2013 + by Michael Shiloh + modified 08 June 2013 + by Tom Igoe + + This example code is in the public domain + + */ + + +#include <Process.h> + +// global variable to store the last value of the signal strength +int lastValue; + +void setup() { + // set up LED pins as outputs: + pinMode(8, OUTPUT); + pinMode(9, OUTPUT); + pinMode(10, OUTPUT); + pinMode(13,OUTPUT); + + // Indicate that you're ready by flashing pin 13 LED twice + for (int flash = 0; flash < 3; flash++) { + digitalWrite(13,HIGH); + delay(200); + digitalWrite(13,LOW); + delay(800); + } + // initialize Serial and Bridge: + Serial.begin(9600); + Bridge.begin(); + + // Indicate that setup is finished + digitalWrite(13,HIGH); +} + +void loop() { + int value = 0; // the signal strength as an integer + String result; // the result of the process as a String + Process wifiCheck; // the process itself + + + // Run the script on the linux side. Note that any word + //or text separated by a tab or space is considered + //an additional parameter: + wifiCheck.begin("ash"); + wifiCheck.addParameter("/root/wifiStrength.sh"); + wifiCheck.run(); + + // If the process has sent any characters: + while (wifiCheck.available()>0) { + result = wifiCheck.readString(); // read the result into a string + value = result.toInt(); // parse the string as an int + } + + // for debugging + Serial.print("previous strength:"); + Serial.print(lastValue); + Serial.print("\tcurrent strength:"); + Serial.println(value); + + // indicate the relative string by lighting the appropriate LED + allOff(); // turn off all the LEDS + + if (value > lastValue) { // if the signal's getting stronger + digitalWrite(10, HIGH); + } + else if (value < lastValue){ // if the signal's getting weaker + digitalWrite(8, HIGH); + } + else { // if the signal's stayed steady + digitalWrite(9, HIGH); + } + + lastValue = value; // record this value for next time + delay(10); // small delay before next time through the loop +} + + +void allOff() { + digitalWrite(8, LOW); + digitalWrite(9, LOW); + digitalWrite(10, LOW); +} + + + + + + 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..4fd7384 --- /dev/null +++ b/libraries/Bridge/examples/ShellCommands/ShellCommands.ino @@ -0,0 +1,26 @@ + +/* Demonstrate shell commands */ + +#include <Process.h> + +void setup() { + Bridge.begin(); + Console.begin(); + Console.buffer(64); +} + +void loop() { + Process p; + // This command line prints the name of the wireless that the board is connected to or that the board has created + p.runShellCommand(F("lua /usr/lib/lua/pretty_wifi_info.lua | grep SSID")); + + // Read command output + while (p.available()) { + char c = p.read(); + Console.print(c); + } + Console.flush(); + + delay(5000); +} + diff --git a/libraries/Bridge/examples/TimeCheck/TimeCheck.ino b/libraries/Bridge/examples/TimeCheck/TimeCheck.ino new file mode 100644 index 0000000..54fd131 --- /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 + 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 + delay(2000); // wait 2 seconds + + 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..48b1403 --- /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(); + Console.begin(); + + while(!Console); // wait for Network Console to open + Console.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; + Console.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(); + Console.println("done!"); + + // If there's incoming data from the net connection, + // send it out the Console: + while (xively.available()>0) { + char c = xively.read(); + Console.write(c); + } + +} + + + + diff --git a/libraries/Bridge/examples/YahooWeather/YahooWeather.ino b/libraries/Bridge/examples/YahooWeather/YahooWeather.ino new file mode 100644 index 0000000..b751e1d --- /dev/null +++ b/libraries/Bridge/examples/YahooWeather/YahooWeather.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/YunSerialTerminal/YunSerialTerminal.ino b/libraries/Bridge/examples/YunSerialTerminal/YunSerialTerminal.ino new file mode 100644 index 0000000..11be9a3 --- /dev/null +++ b/libraries/Bridge/examples/YunSerialTerminal/YunSerialTerminal.ino @@ -0,0 +1,82 @@ +/* + 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 + + The circuit: + * Arduino Yun + + created March 2013 + by Massimo Banzi + modified by Cristian Maglie + + This example code is in the public domain. + */ + +long lininoBaud = 115200; + +// Pin 13 has an LED connected on most Arduino boards. +int led = 13; +int ledState = HIGH; // whether the LED is high or low + + +void setup() { + Serial.begin(115200); // open serial connection via USB-Serial + Serial1.begin(lininoBaud); // open serial connection to Linino + + // initialize the digital pin as an output. + pinMode(led, OUTPUT); + digitalWrite(led, ledState); // turn the LED on (HIGH is the voltage level) +} + + +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 { // 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 + } + 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 + } +} + + + + + |