rooty/Arduino
1
0
Fork 0
mirror of https://github.com/arduino/Arduino.git synced 2025-01-30 19:52:13 +01:00
Code Issues Releases Activity

Spacebrew update

Browse Source
This commit is contained in:
Federico Fissore 2014-04-01 09:35:56 +02:00
parent 2f7e712fb9
commit 88ed5d53a6
8 changed files with 679 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
libraries/Bridge/examples/SpacebrewYun/inputOutput/inputOutput.ino
View File

@ -35,98 +35,98 @@ int counter = 0;
void setup() { void setup() {
// start the serial port // start the serial port
Serial.begin(57600); Serial.begin(57600);
// for debugging, wait until a serial console is connected // for debugging, wait until a serial console is connected
delay(4000); delay(4000);
while (!Serial) { while (!Serial) { ; }
;
}
// start-up the bridge // start-up the bridge
Bridge.begin(); Bridge.begin();
// configure the spacebrew object to print status messages to serial // configure the spacebrew object to print status messages to serial
sb.verbose(true); sb.verbose(true);
// configure the spacebrew publisher and subscriber // configure the spacebrew publisher and subscriber
sb.addPublish("string test", "string"); sb.addPublish("string test", "string");
sb.addPublish("range test", "range"); sb.addPublish("range test", "range");
sb.addPublish("boolean test", "boolean"); sb.addPublish("boolean test", "boolean");
sb.addPublish("custom test", "crazy"); sb.addPublish("custom test", "crazy");
sb.addSubscribe("string test", "string"); sb.addSubscribe("string test", "string");
sb.addSubscribe("range test", "range"); sb.addSubscribe("range test", "range");
sb.addSubscribe("boolean test", "boolean"); sb.addSubscribe("boolean test", "boolean");
sb.addSubscribe("custom test", "crazy"); sb.addSubscribe("custom test", "crazy");
// register the string message handler method // register the string message handler method
sb.onRangeMessage(handleRange); sb.onRangeMessage(handleRange);
sb.onStringMessage(handleString); sb.onStringMessage(handleString);
sb.onBooleanMessage(handleBoolean); sb.onBooleanMessage(handleBoolean);
sb.onCustomMessage(handleCustom); sb.onCustomMessage(handleCustom);
// connect to cloud spacebrew server at "sandbox.spacebrew.cc"
sb.connect("sandbox.spacebrew.cc");
// connect to cloud spacebrew server at "sandbox.spacebrew.cc"
sb.connect("sandbox.spacebrew.cc");
// we give some time to arduino to connect to sandbox, otherwise the first sb.monitor(); call will give an error
delay(1000);
} }
void loop() { void loop() {
// monitor spacebrew connection for new data // monitor spacebrew connection for new data
sb.monitor(); sb.monitor();
// connected to spacebrew then send a string every 2 seconds // connected to spacebrew then send a string every 2 seconds
if ( sb.connected() ) { if ( sb.connected() ) {
// check if it is time to send a new message // check if it is time to send a new message
if ( (millis() - last) > interval ) { if ( (millis() - last) > interval ) {
String test_str_msg = "testing, testing, "; String test_str_msg = "testing, testing, ";
test_str_msg += counter; test_str_msg += counter;
counter ++; counter ++;
sb.send("string test", test_str_msg); sb.send("string test", test_str_msg);
sb.send("range test", 500); sb.send("range test", 500);
sb.send("boolean test", true); sb.send("boolean test", true);
sb.send("custom test", "youre loco"); sb.send("custom test", "youre loco");
last = millis(); last = millis();
} }
} }
delay(1000);
} }
// define handler methods, all standard data type handlers take two appropriate arguments // define handler methods, all standard data type handlers take two appropriate arguments
void handleRange (String route, int value) { void handleRange (String route, int value) {
Serial.print("Range msg "); Serial.print("Range msg ");
Serial.print(route); Serial.print(route);
Serial.print(", value "); Serial.print(", value ");
Serial.println(value); Serial.println(value);
} }
void handleString (String route, String value) { void handleString (String route, String value) {
Serial.print("String msg "); Serial.print("String msg ");
Serial.print(route); Serial.print(route);
Serial.print(", value "); Serial.print(", value ");
Serial.println(value); Serial.println(value);
} }
void handleBoolean (String route, boolean value) { void handleBoolean (String route, boolean value) {
Serial.print("Boolen msg "); Serial.print("Boolen msg ");
Serial.print(route); Serial.print(route);
Serial.print(", value "); Serial.print(", value ");
Serial.println(value ? "true" : "false"); Serial.println(value ? "true" : "false");
} }
// custom data type handlers takes three String arguments // custom data type handlers takes three String arguments
void handleCustom (String route, String value, String type) { void handleCustom (String route, String value, String type) {
Serial.print("Custom msg "); Serial.print("Custom msg ");
Serial.print(route); Serial.print(route);
Serial.print(" of type "); Serial.print(" of type ");
Serial.print(type); Serial.print(type);
Serial.print(", value "); Serial.print(", value ");
Serial.println(value); Serial.println(value);
} }

70
libraries/Bridge/examples/SpacebrewYun/spacebrewBoolean/spacebrewBoolean.ino
View File

@ -35,57 +35,55 @@ int last_value = 0;
// create variables to manage interval between each time we send a string // create variables to manage interval between each time we send a string
void setup() { void setup() {
// start the serial port // start the serial port
Serial.begin(57600); Serial.begin(57600);
// for debugging, wait until a serial console is connected // for debugging, wait until a serial console is connected
delay(4000); delay(4000);
while (!Serial) { while (!Serial) { ; }
;
}
// start-up the bridge // start-up the bridge
Bridge.begin(); Bridge.begin();
// configure the spacebrew object to print status messages to serial // configure the spacebrew object to print status messages to serial
sb.verbose(true); sb.verbose(true);
// configure the spacebrew publisher and subscriber // configure the spacebrew publisher and subscriber
sb.addPublish("physical button", "boolean"); sb.addPublish("physical button", "boolean");
sb.addSubscribe("virtual button", "boolean"); sb.addSubscribe("virtual button", "boolean");
// register the string message handler method // register the string message handler method
sb.onBooleanMessage(handleBoolean); sb.onBooleanMessage(handleBoolean);
// connect to cloud spacebrew server at "sandbox.spacebrew.cc" // connect to cloud spacebrew server at "sandbox.spacebrew.cc"
sb.connect("sandbox.spacebrew.cc"); sb.connect("sandbox.spacebrew.cc");
pinMode(3, INPUT); pinMode(3, INPUT);
digitalWrite(3, HIGH); digitalWrite(3, HIGH);
} }
void loop() { void loop() {
// monitor spacebrew connection for new data // monitor spacebrew connection for new data
sb.monitor(); sb.monitor();
// connected to spacebrew then send a new value whenever the pot value changes // connected to spacebrew then send a new value whenever the pot value changes
if ( sb.connected() ) { if ( sb.connected() ) {
int cur_value = digitalRead(3); int cur_value = digitalRead(3);
if ( last_value != cur_value ) { if ( last_value != cur_value ) {
if (cur_value == HIGH) sb.send("physical button", false); if (cur_value == HIGH) sb.send("physical button", false);
else sb.send("physical button", true); else sb.send("physical button", true);
last_value = cur_value; last_value = cur_value;
} }
} }
} }
// handler method that is called whenever a new string message is received // handler method that is called whenever a new string message is received
void handleBoolean (String route, boolean value) { void handleBoolean (String route, boolean value) {
// print the message that was received // print the message that was received
Serial.print("From "); Serial.print("From ");
Serial.print(route); Serial.print(route);
Serial.print(", received msg: "); Serial.print(", received msg: ");
Serial.println(value ? "true" : "false"); Serial.println(value ? "true" : "false");
} }

64
libraries/Bridge/examples/SpacebrewYun/spacebrewRange/spacebrewRange.ino
View File

@ -36,53 +36,51 @@ int last_value = 0;
// create variables to manage interval between each time we send a string // create variables to manage interval between each time we send a string
void setup() { void setup() {
// start the serial port // start the serial port
Serial.begin(57600); Serial.begin(57600);
// for debugging, wait until a serial console is connected // for debugging, wait until a serial console is connected
delay(4000); delay(4000);
while (!Serial) { while (!Serial) { ; }
;
}
// start-up the bridge // start-up the bridge
Bridge.begin(); Bridge.begin();
// configure the spacebrew object to print status messages to serial // configure the spacebrew object to print status messages to serial
sb.verbose(true); sb.verbose(true);
// configure the spacebrew publisher and subscriber // configure the spacebrew publisher and subscriber
sb.addPublish("physical pot", "range"); sb.addPublish("physical pot", "range");
sb.addSubscribe("virtual pot", "range"); sb.addSubscribe("virtual pot", "range");
// register the string message handler method // register the string message handler method
sb.onRangeMessage(handleRange); sb.onRangeMessage(handleRange);
// connect to cloud spacebrew server at "sandbox.spacebrew.cc" // connect to cloud spacebrew server at "sandbox.spacebrew.cc"
sb.connect("sandbox.spacebrew.cc"); sb.connect("sandbox.spacebrew.cc");
} }
void loop() { void loop() {
// monitor spacebrew connection for new data // monitor spacebrew connection for new data
sb.monitor(); sb.monitor();
// connected to spacebrew then send a new value whenever the pot value changes // connected to spacebrew then send a new value whenever the pot value changes
if ( sb.connected() ) { if ( sb.connected() ) {
int cur_value = analogRead(A0); int cur_value = analogRead(A0);
if ( last_value != cur_value ) { if ( last_value != cur_value ) {
sb.send("physical pot", cur_value); sb.send("physical pot", cur_value);
last_value = cur_value; last_value = cur_value;
} }
} }
} }
// handler method that is called whenever a new string message is received // handler method that is called whenever a new string message is received
void handleRange (String route, int value) { void handleRange (String route, int value) {
// print the message that was received // print the message that was received
Serial.print("From "); Serial.print("From ");
Serial.print(route); Serial.print(route);
Serial.print(", received msg: "); Serial.print(", received msg: ");
Serial.println(value); Serial.println(value);
} }

64
libraries/Bridge/examples/SpacebrewYun/spacebrewString/spacebrewString.ino
View File

@ -33,54 +33,52 @@ int interval = 2000;
void setup() { void setup() {
// start the serial port // start the serial port
Serial.begin(57600); Serial.begin(57600);
// for debugging, wait until a serial console is connected // for debugging, wait until a serial console is connected
delay(4000); delay(4000);
while (!Serial) { while (!Serial) { ; }
;
}
// start-up the bridge // start-up the bridge
Bridge.begin(); Bridge.begin();
// configure the spacebrew object to print status messages to serial // configure the spacebrew object to print status messages to serial
sb.verbose(true); sb.verbose(true);
// configure the spacebrew publisher and subscriber // configure the spacebrew publisher and subscriber
sb.addPublish("speak", "string"); sb.addPublish("speak", "string");
sb.addSubscribe("listen", "string"); sb.addSubscribe("listen", "string");
// register the string message handler method // register the string message handler method
sb.onStringMessage(handleString); sb.onStringMessage(handleString);
// connect to cloud spacebrew server at "sandbox.spacebrew.cc" // connect to cloud spacebrew server at "sandbox.spacebrew.cc"
sb.connect("sandbox.spacebrew.cc"); sb.connect("sandbox.spacebrew.cc");
} }
void loop() { void loop() {
// monitor spacebrew connection for new data // monitor spacebrew connection for new data
sb.monitor(); sb.monitor();
// connected to spacebrew then send a string every 2 seconds // connected to spacebrew then send a string every 2 seconds
if ( sb.connected() ) { if ( sb.connected() ) {
// check if it is time to send a new message // check if it is time to send a new message
if ( (millis() - last_time) > interval ) { if ( (millis() - last_time) > interval ) {
sb.send("speak", "is anybody out there?"); sb.send("speak", "is anybody out there?");
last_time = millis(); last_time = millis();
} }
} }
} }
// handler method that is called whenever a new string message is received // handler method that is called whenever a new string message is received
void handleString (String route, String value) { void handleString (String route, String value) {
// print the message that was received // print the message that was received
Serial.print("From "); Serial.print("From ");
Serial.print(route); Serial.print(route);
Serial.print(", received msg: "); Serial.print(", received msg: ");
Serial.println(value); Serial.println(value);
} }

2
libraries/SpacebrewYun/keywords.txt
View File

@ -1,4 +1,4 @@
SpacebrewYun KEYWORD3 SpacebrewYun KEYWORD1
addPublish KEYWORD2 addPublish KEYWORD2
addSubscribe KEYWORD2 addSubscribe KEYWORD2
connect KEYWORD2 connect KEYWORD2

8
libraries/SpacebrewYun/library.properties
View File

@ -1,8 +1,10 @@
name=SpacebrewYun name=SpacebrewYun
version=1.0
author=Julio Terra author=Julio Terra
maintainer=Julio Terra <julioterra@gmail.com> email=julioterra@gmail.com
sentence=Easily connect the Arduino Yun to Spacebrew sentence=Easily connect the Arduino Yun to Spacebrew
paragraph=This library was developed to enable you to easily connect the Arduino Yun to Spacebrew. To learn more about Spacebrew visit Spacebrew.cc paragraph=This library was developed to enable you to easily connect the Arduino Yun to Spacebrew. To learn more about Spacebrew visit Spacebrew.cc
url=https://github.com/julioterra/yunSpacebrew url=https://github.com/julioterra/yunSpacebrew
architectures=* architectures=avr
version=1.0
dependencies=Bridge
core-dependencies=arduino (>=1.5.0)

704
libraries/SpacebrewYun/src/SpacebrewYun.cpp
View File

@ -2,34 +2,38 @@
SpacebrewYun::SpacebrewYun(const String& _name, const String& _description) { SpacebrewYun::SpacebrewYun(const String& _name, const String& _description) {
name = _name; name = _name;
description = _description; description = _description;
subscribers = NULL; subscribers = NULL;
publishers = NULL; publishers = NULL;
server = "sandbox.spacebrew.cc"; server = "sandbox.spacebrew.cc";
port = 9000; port = 9000;
_connected = false; _started = false;
_verbose = false; _connected = false;
_error_msg = false; _verbose = false;
_error_msg = false;
sub_name = ""; sub_name = "";
sub_msg = ""; sub_msg = "";
sub_type = ""; sub_type = "";
read_name = false; read_name = false;
read_msg = false; read_msg = false;
for ( int i = 0; i < pidLength; i++ ) { connect_attempt = 0;
pid [i] = '\0'; connect_attempt_inter = 10000;
}
for ( int i = 0; i < sbPidsLen; i++ ) { for ( int i = 0; i < pidLength; i++ ) {
sbPids [i] = '\0'; pid [i] = '\0';
} }
Console.buffer(64); for ( int i = 0; i < sbPidsLen; i++ ) {
sbPids [i] = '\0';
}
Console.buffer(64);
} }
@ -45,348 +49,356 @@ SpacebrewYun::OnSBOpen SpacebrewYun::_onOpen = NULL;
SpacebrewYun::OnSBClose SpacebrewYun::_onClose = NULL; SpacebrewYun::OnSBClose SpacebrewYun::_onClose = NULL;
SpacebrewYun::OnSBError SpacebrewYun::_onError = NULL; SpacebrewYun::OnSBError SpacebrewYun::_onError = NULL;
void SpacebrewYun::onOpen(OnSBOpen function) { void SpacebrewYun::onOpen(OnSBOpen function){
_onOpen = function; _onOpen = function;
} }
void SpacebrewYun::onClose(OnSBClose function) { void SpacebrewYun::onClose(OnSBClose function){
_onClose = function; _onClose = function;
} }
void SpacebrewYun::onRangeMessage(OnRangeMessage function) { void SpacebrewYun::onRangeMessage(OnRangeMessage function){
_onRangeMessage = function; _onRangeMessage = function;
} }
void SpacebrewYun::onStringMessage(OnStringMessage function) { void SpacebrewYun::onStringMessage(OnStringMessage function){
_onStringMessage = function; _onStringMessage = function;
} }
void SpacebrewYun::onBooleanMessage(OnBooleanMessage function) { void SpacebrewYun::onBooleanMessage(OnBooleanMessage function){
_onBooleanMessage = function; _onBooleanMessage = function;
} }
void SpacebrewYun::onCustomMessage(OnCustomMessage function) { void SpacebrewYun::onCustomMessage(OnCustomMessage function){
_onCustomMessage = function; _onCustomMessage = function;
} }
void SpacebrewYun::onError(OnSBError function) { void SpacebrewYun::onError(OnSBError function){
_onError = function; _onError = function;
} }
void SpacebrewYun::addPublish(const String& name, const String& type) { void SpacebrewYun::addPublish(const String& name, const String& type) {
struct Publisher *p = new Publisher(); struct Publisher *p = new Publisher();
p->name = createString(name.length() + 1); p->name = createString(name.length() + 1);
p->type = createString(type.length() + 1); p->type = createString(type.length() + 1);
p->confirmed = false; p->confirmed = false;
p->time = 0; p->time = 0;
if (type == "range") { if (type == "range") {
p->lastMsg = createString(sub_msg_int_max); p->lastMsg = createString(sub_msg_int_max);
emptyString(p->lastMsg, sub_msg_int_max); emptyString(p->lastMsg, sub_msg_int_max);
} }
else if (type == "boolean") { else if (type == "boolean") {
p->lastMsg = createString(sub_msg_bool_max); p->lastMsg = createString(sub_msg_bool_max);
emptyString(p->lastMsg, sub_msg_bool_max); emptyString(p->lastMsg, sub_msg_bool_max);
} }
else { else {
p->lastMsg = createString(sub_msg_str_max); p->lastMsg = createString(sub_msg_str_max);
emptyString(p->lastMsg, sub_msg_str_max); emptyString(p->lastMsg, sub_msg_str_max);
} }
name.toCharArray(p->name, name.length() + 1); name.toCharArray(p->name, name.length() + 1);
type.toCharArray(p->type, type.length() + 1); type.toCharArray(p->type, type.length() + 1);
if (publishers == NULL) { if (publishers == NULL){
publishers = p; publishers = p;
} }
else { else {
struct Publisher *curr = publishers; struct Publisher *curr = publishers;
int counter = 1; int counter = 1;
while (curr->next != NULL) { while(curr->next != NULL){
curr = curr->next; curr = curr->next;
counter++; counter++;
} }
curr->next = p; curr->next = p;
} }
p->next = NULL; p->next = NULL;
} }
void SpacebrewYun::addSubscribe(const String& name, const String& type) { void SpacebrewYun::addSubscribe(const String& name, const String& type) {
Subscriber *s = new Subscriber(); Subscriber *s = new Subscriber();
s->name = createString(name.length() + 1); s->name = createString(name.length() + 1);
s->type = createString(type.length() + 1); s->type = createString(type.length() + 1);
name.toCharArray(s->name, name.length() + 1); name.toCharArray(s->name, name.length() + 1);
type.toCharArray(s->type, type.length() + 1); type.toCharArray(s->type, type.length() + 1);
if (subscribers == NULL) { if (subscribers == NULL){
subscribers = s; subscribers = s;
} }
else { else {
struct Subscriber *curr = subscribers; struct Subscriber *curr = subscribers;
while (curr->next != NULL) { while(curr->next != NULL){
curr = curr->next; curr = curr->next;
} }
curr->next = s; curr->next = s;
} }
} }
void SpacebrewYun::connect(String _server, int _port) { void SpacebrewYun::connect(String _server, int _port) {
server = _server; Serial.print(F("NEW LIB"));
port = _port; _started = true;
server = _server;
port = _port;
connect_attempt = millis();
killPids(); killPids();
brew.begin("run-spacebrew"); // Process should launch the "curl" command brew.begin("run-spacebrew"); // Process should launch the "curl" command
// brew.begin("python"); // Process should launch the "curl" command // brew.begin("python"); // Process should launch the "curl" command
// brew.addParameter("/usr/lib/python2.7/spacebrew/spacebrew.py"); // Process should launch the "curl" command // brew.addParameter("/usr/lib/python2.7/spacebrew/spacebrew.py"); // Process should launch the "curl" command
brew.addParameter("--server"); brew.addParameter("--server");
brew.addParameter(server); brew.addParameter(server);
brew.addParameter("--port"); brew.addParameter("--port");
brew.addParameter(String(port)); brew.addParameter(String(port));
brew.addParameter("-n"); brew.addParameter("-n");
brew.addParameter(name); brew.addParameter(name);
brew.addParameter("-d"); brew.addParameter("-d");
brew.addParameter(description); brew.addParameter(description);
if (subscribers != NULL) { if (subscribers != NULL) {
struct Subscriber *curr = subscribers; struct Subscriber *curr = subscribers;
while (curr != NULL) { while(curr != NULL){
if (_verbose) { if (_verbose) {
Serial.print(F("Creating subscribers: ")); Serial.print(F("Creating subscribers: "));
Serial.print(curr->name); Serial.print(curr->name);
Serial.print(F(" of type: ")); Serial.print(F(" of type: "));
Serial.println(curr->type); Serial.println(curr->type);
} }
brew.addParameter("-s"); // Add the URL parameter to "curl" brew.addParameter("-s"); // Add the URL parameter to "curl"
brew.addParameter(curr->name); // Add the URL parameter to "curl" brew.addParameter(curr->name); // Add the URL parameter to "curl"
brew.addParameter(","); // Add the URL parameter to "curl" brew.addParameter(","); // Add the URL parameter to "curl"
brew.addParameter(curr->type); // Add the URL parameter to "curl" brew.addParameter(curr->type); // Add the URL parameter to "curl"
// if (curr->next == NULL) curr = NULL; // if (curr->next == NULL) curr = NULL;
// else curr = curr->next; // else curr = curr->next;
curr = curr->next; curr = curr->next;
} }
} }
if (publishers != NULL) { if (publishers != NULL) {
struct Publisher *curr = publishers; struct Publisher *curr = publishers;
while (curr != NULL) { while(curr != NULL){
if (_verbose) { if (_verbose) {
Serial.print(F("Creating publishers: ")); Serial.print(F("Creating publishers: "));
Serial.print(curr->name); Serial.print(curr->name);
Serial.print(F(" of type: ")); Serial.print(F(" of type: "));
Serial.println(curr->type); Serial.println(curr->type);
} }
brew.addParameter("-p"); // Add the URL parameter to "curl" brew.addParameter("-p"); // Add the URL parameter to "curl"
brew.addParameter(curr->name); // Add the URL parameter to "curl" brew.addParameter(curr->name); // Add the URL parameter to "curl"
brew.addParameter(","); // Add the URL parameter to "curl" brew.addParameter(","); // Add the URL parameter to "curl"
brew.addParameter(curr->type); // Add the URL parameter to "curl" brew.addParameter(curr->type); // Add the URL parameter to "curl"
curr = curr->next; curr = curr->next;
} }
} }
Console.begin(); Console.begin();
if (_verbose) { if (_verbose) {
Serial.println(F("Console started ")); Serial.println(F("Console started "));
} }
brew.runAsynchronously(); brew.runAsynchronously();
if (_verbose) { if (_verbose) {
Serial.println(F("Brew started ")); Serial.println(F("Brew started "));
} }
while (!Console) { while (!Console) { ; }
;
}
} }
void SpacebrewYun::monitor() { void SpacebrewYun::monitor() {
while (Console.available() > 0) {
char c = Console.read();
if (c == char(CONNECTION_START) && !_connected) { // if not connected try to reconnect after appropriate interval
if (_verbose) { if (_started && !_connected) {
Serial.print(F("Connected to spacebrew server at: ")); if ((millis() - connect_attempt) > connect_attempt_inter) {
Serial.println(server); connect(server, port);
Serial.print(F("Application name set to: ")); }
Serial.println(name); }
}
if (_onOpen != NULL) {
_onOpen();
}
_connected = true;
}
else if (c == char(CONNECTION_END) && _connected) {
_connected = false;
if (_verbose) {
Serial.print(F("Disconnected from spacebrew server at: "));
Serial.println(server);
}
if (_onClose != NULL) {
_onClose();
}
}
if (_verbose) { // if message received from console, then process it
if (c == char(CONNECTION_ERROR)) { while (Console.available() > 0) {
_error_msg = true; char c = Console.read();
Serial.println(F("ERROR :: with Spacebrew.py Connection ::"));
}
else if (_error_msg && c == char(MSG_END)) {
_error_msg = false;
Serial.println();
}
if (_error_msg) {
Serial.print(c);
}
}
if (_connected) { if (c == char(CONNECTION_START) && _started && !_connected) {
if (c == char(MSG_START)) { if (_verbose) {
read_name = true; Serial.print(F("Connected to spacebrew server at: "));
} else if (c == char(MSG_DIV) || sub_name.length() > sub_name_max) { Serial.println(server);
read_name = false; Serial.print(F("Application name set to: "));
read_msg = true; Serial.println(name);
} else if (c == char(MSG_END) || sub_msg.length() > sub_msg_str_max) { }
if (read_msg == true) { if (_onOpen != NULL){
read_msg = false; _onOpen();
onMessage(); }
// delay(2); _connected = true;
} }
if (read_confirm == true) {
read_confirm = false;
onConfirm();
delay(2);
}
} else if (c == char(MSG_CONFIRM)) {
read_confirm = true;
} else {
if (read_name == true) {
sub_name += c;
} else if (read_confirm == true) {
sub_name += c;
} else if (read_msg == true) {
sub_msg += c;
}
else if (_verbose) {
Serial.print(c);
}
}
}
}
if (publishers != NULL) { else if (c == char(CONNECTION_END) && _connected) {
struct Publisher *curr = publishers; _connected = false;
while ((curr != NULL)) { if (_verbose) {
Serial.print(F("Disconnected from spacebrew server at: "));
Serial.println(server);
}
if (_onClose != NULL){
_onClose();
}
}
if ( (curr->confirmed == 0) && ((millis() - curr->time) > 50) ) { if (_verbose) {
if (_verbose) { if (c == char(CONNECTION_ERROR)) {
Serial.print(F("resending msg: ")); _error_msg = true;
Serial.println(curr->name); Serial.println(F("ERROR :: with Spacebrew.py Connection ::"));
} }
send(curr->name, curr->lastMsg); else if (_error_msg && c == char(MSG_END)) {
} _error_msg = false;
curr = curr->next; Serial.println();
} }
} if (_error_msg) {
Serial.print(c);
}
}
if (_connected) {
if (c == char(MSG_START)) {
read_name = true;
} else if (c == char(MSG_DIV) || sub_name.length() > sub_name_max) {
read_name = false;
read_msg = true;
} else if (c == char(MSG_END) || sub_msg.length() > sub_msg_str_max) {
if (read_msg == true) {
read_msg = false;
onMessage();
// delay(2);
}
if (read_confirm == true) {
read_confirm = false;
onConfirm();
delay(2);
}
} else if (c == char(MSG_CONFIRM)) {
read_confirm = true;
} else {
if (read_name == true) {
sub_name += c;
} else if (read_confirm == true) {
sub_name += c;
} else if (read_msg == true) {
sub_msg += c;
}
else if (_verbose) {
Serial.print(c);
}
}
}
}
// check if received confirmation that linino received messages
if (publishers != NULL && _connected) {
struct Publisher *curr = publishers;
while((curr != NULL)){
if ( (curr->confirmed == 0) && ((millis() - curr->time) > 50) ) {
if (_verbose) {
Serial.print(F("resending msg: "));
Serial.println(curr->name);
}
send(curr->name, curr->lastMsg);
}
curr = curr->next;
}
}
} }
void SpacebrewYun::onConfirm() { void SpacebrewYun::onConfirm() {
if (publishers != NULL) { if (publishers != NULL) {
struct Publisher *curr = publishers; struct Publisher *curr = publishers;
while ((curr != NULL)) { while((curr != NULL)){
if (sub_name.equals(curr->name) == true) { if (sub_name.equals(curr->name) == true) {
curr->confirmed = true; curr->confirmed = true;
// if (_verbose) { break;
// Serial.print(F("confirmed ")); }
// Serial.println(curr->name); curr = curr->next;
// } }
break; }
}
curr = curr->next;
}
}
sub_name = ""; sub_name = "";
sub_msg = ""; sub_msg = "";
sub_type = ""; sub_type = "";
} }
boolean SpacebrewYun::connected() { boolean SpacebrewYun::connected() {
return SpacebrewYun::_connected; return SpacebrewYun::_connected;
} }
void SpacebrewYun::verbose(boolean verbose = true) { void SpacebrewYun::verbose(boolean verbose = true) {
_verbose = verbose; _verbose = verbose;
} }
void SpacebrewYun::onMessage() { void SpacebrewYun::onMessage() {
if (subscribers != NULL) { if (subscribers != NULL) {
struct Subscriber *curr = subscribers; struct Subscriber *curr = subscribers;
while ((curr != NULL) && (sub_type == "")) { while((curr != NULL) && (sub_type == "")){
if (sub_name.equals(curr->name) == true) { if (sub_name.equals(curr->name) == true) {
sub_type = curr->type; sub_type = curr->type;
} }
curr = curr->next; curr = curr->next;
} }
} }
if ( sub_type.equals("range") ) { if ( sub_type.equals("range") ) {
if (_onRangeMessage != NULL) { if (_onRangeMessage != NULL) {
_onRangeMessage( sub_name, int(sub_msg.toInt()) ); _onRangeMessage( sub_name, int(sub_msg.toInt()) );
} else { } else {
Serial.println(F("ERROR :: Range message received, no callback method is registered")); Serial.println(F("ERROR :: Range message received, no callback method is registered"));
} }
} else if ( sub_type.equals("boolean") ) { } else if ( sub_type.equals("boolean") ) {
if (_onBooleanMessage != NULL) { if (_onBooleanMessage != NULL) {
_onBooleanMessage( sub_name, ( sub_msg.equals("false") ? false : true ) ); _onBooleanMessage( sub_name, ( sub_msg.equals("false") ? false : true ) );
} else { } else {
Serial.println(F("ERROR :: Boolean message received, no callback method is registered")); Serial.println(F("ERROR :: Boolean message received, no callback method is registered"));
} }
} else if ( sub_type.equals("string") ) { } else if ( sub_type.equals("string") ) {
if (_onStringMessage != NULL) { if (_onStringMessage != NULL) {
_onStringMessage( sub_name, sub_msg ); _onStringMessage( sub_name, sub_msg );
} else { } else {
Serial.println(F("ERROR :: String message received, no callback method is registered")); Serial.println(F("ERROR :: String message received, no callback method is registered"));
} }
} else { } else {
if (_onCustomMessage != NULL) { if (_onCustomMessage != NULL) {
_onCustomMessage( sub_name, sub_msg, sub_type ); _onCustomMessage( sub_name, sub_msg, sub_type );
} else { } else {
Serial.println(F("ERROR :: Custom message received, no callback method is registered")); Serial.println(F("ERROR :: Custom message received, no callback method is registered"));
} }
} }
sub_name = ""; sub_name = "";
sub_msg = ""; sub_msg = "";
sub_type = ""; sub_type = "";
} }
void SpacebrewYun::send(const String& name, const String& value) { void SpacebrewYun::send(const String& name, const String& value){
if (publishers != NULL) { if (publishers != NULL) {
Console.print(char(29)); Console.print(char(29));
Console.print(name); Console.print(name);
Console.print(char(30)); Console.print(char(30));
Console.print(value); Console.print(value);
Console.print(char(31)); Console.print(char(31));
Console.flush(); Console.flush();
struct Publisher *curr = publishers; struct Publisher *curr = publishers;
while (curr != NULL) { while(curr != NULL){
if (name.equals(curr->name) == true) { if (name.equals(curr->name) == true) {
int msg_len = 0; int msg_len = 0;
if (curr->type == "range") msg_len = sub_msg_int_max; if (curr->type == "range") msg_len = sub_msg_int_max;
else if (curr->type == "boolean") msg_len = sub_msg_bool_max; else if (curr->type == "boolean") msg_len = sub_msg_bool_max;
else msg_len = sub_msg_str_max; else msg_len = sub_msg_str_max;
if (value.length() < msg_len) msg_len = value.length() + 1; if (value.length() < msg_len) msg_len = value.length() + 1;
value.toCharArray(curr->lastMsg, msg_len); value.toCharArray(curr->lastMsg, msg_len);
curr->confirmed = false; curr->confirmed = false;
curr->time = millis(); curr->time = millis();
} }
curr = curr->next; curr = curr->next;
} }
} }
} }
@ -395,39 +407,39 @@ void SpacebrewYun::send(const String& name, const String& value) {
*/ */
void SpacebrewYun::getPids() { void SpacebrewYun::getPids() {
// request the pid of all python processes // request the pid of all python processes
// brew.begin("run-getsbpids"); // Process should launch the "curl" command // brew.begin("run-getsbpids"); // Process should launch the "curl" command
pids.begin("python"); pids.begin("python");
pids.addParameter("/usr/lib/python2.7/spacebrew/getprocpid.py"); // Process should launch the "curl" command pids.addParameter("/usr/lib/python2.7/spacebrew/getprocpid.py"); // Process should launch the "curl" command
pids.run(); pids.run();
if (_verbose) { if (_verbose) {
Serial.println(F("Checking if spacebrew process already running")); Serial.println(F("Checking if spacebrew process already running"));
} }
int sbPidsIndex = 0; int sbPidsIndex = 0;
int pidCharIndex = 0; int pidCharIndex = 0;
char c = '\0'; char c = '\0';
while ( pids.available() > 0 ) { while ( pids.available() > 0 ) {
c = pids.read(); c = pids.read();
if ( c >= '0' && c <= '9' ) { if ( c >= '0' && c <= '9' ) {
pid[pidCharIndex] = c; pid[pidCharIndex] = c;
pidCharIndex = (pidCharIndex + 1) % pidLength; pidCharIndex = (pidCharIndex + 1) % pidLength;
} }
else if ( (c == ' ' || c == '\n') && pidCharIndex > 0) { else if ( (c == ' ' || c == '\n') && pidCharIndex > 0) {
sbPids[sbPidsIndex] = atoi(pid); sbPids[sbPidsIndex] = atoi(pid);
if ( sbPidsIndex < (sbPidsLen - 1) ) sbPidsIndex = (sbPidsIndex + 1); if ( sbPidsIndex < (sbPidsLen - 1) ) sbPidsIndex = (sbPidsIndex + 1);
for ( int i = 0; i < pidLength; i++ ) { for( int i = 0; i < pidLength; i++ ){
pid[i] = '\0'; pid[i] = '\0';
pidCharIndex = 0; pidCharIndex = 0;
} }
} }
} }
} }
/** /**
@ -435,27 +447,27 @@ void SpacebrewYun::getPids() {
* on the linino. * on the linino.
*/ */
void SpacebrewYun::killPids() { void SpacebrewYun::killPids() {
getPids(); getPids();
delay(400); delay(400);
for (int i = 0; i < sbPidsLen; i ++) { for (int i = 0; i < sbPidsLen; i ++) {
if (sbPids[i] > 0) { if (sbPids[i] > 0) {
char * newPID = itoa(sbPids[i], pid, 10); char * newPID = itoa(sbPids[i], pid, 10);
if (_verbose) { if (_verbose) {
Serial.print(F("Stopping existing spacebrew processes with pids: ")); Serial.print(F("Stopping existing spacebrew processes with pids: "));
Serial.println(newPID); Serial.println(newPID);
} }
Process p; Process p;
p.begin("kill"); p.begin("kill");
p.addParameter("-9"); p.addParameter("-9");
p.addParameter(newPID); // Process should launch the "curl" command p.addParameter(newPID); // Process should launch the "curl" command
p.run(); // Run the process and wait for its termination p.run(); // Run the process and wait for its termination
delay(400); delay(400);
} }
} }
} }

204
libraries/SpacebrewYun/src/SpacebrewYun.h
View File

@ -8,28 +8,28 @@
#include <Process.h> #include <Process.h>
enum SBmsg { enum SBmsg {
CONNECTION_START = char(28), CONNECTION_START = char(28),
CONNECTION_END = char(27), CONNECTION_END = char(27),
CONNECTION_ERROR = char(26), CONNECTION_ERROR = char(26),
MSG_CONFIRM = char(7), MSG_CONFIRM = char(7),
MSG_START = char(29), MSG_START = char(29),
MSG_DIV = char(30), MSG_DIV = char(30),
MSG_END = char(31) MSG_END = char(31)
}; };
struct Publisher { struct Publisher {
char *name; char *name;
char *type; char *type;
char *lastMsg; char *lastMsg;
Publisher *next; Publisher *next;
int confirmed; int confirmed;
long time; long time;
}; };
struct Subscriber { struct Subscriber{
char *name; char *name;
char *type; char *type;
Subscriber *next; Subscriber *next;
}; };
int const pidLength = 6; int const pidLength = 6;
@ -37,114 +37,102 @@ int const sbPidsLen = 4;
class SpacebrewYun { class SpacebrewYun {
public: public:
SpacebrewYun(const String&, const String&); SpacebrewYun(const String&, const String&);
void addPublish(const String&, const String&); void addPublish(const String&, const String&);
void addSubscribe(const String&, const String&); void addSubscribe(const String&, const String&);
void connect(String, int); void connect(String, int);
void connect() { void connect() { connect(server, port); };
connect(server, port); void connect(String _server) { connect(String(_server), port); };
};
void connect(String _server) {
connect(String(_server), port);
};
void monitor(); void monitor();
void onMessage(); void onMessage();
void onConfirm(); void onConfirm();
boolean connected(); boolean connected();
void send(const String&, const String&); void send(const String&, const String&);
void send(const String& name, char * value) { void send(const String& name, char * value) { send(name, String(value)); }
send(name, String(value)); void send(const String& name, bool value){ send(name, (value ? String("true") : String("false"))); };
} void send(const String& name, int value) { send(name, String(value)); };
void send(const String& name, bool value) { void send(const String& name, long value) { send(name, String(value)); };
send(name, (value ? String("true") : String("false"))); void send(const String& name, float value) { send(name, String(value)); };
};
void send(const String& name, int value) {
send(name, String(value));
};
void send(const String& name, long value) {
send(name, String(value));
};
void send(const String& name, float value) {
send(name, String(value));
};
void verbose(boolean); void verbose(boolean);
typedef void (*OnBooleanMessage)(String name, boolean value); typedef void (*OnBooleanMessage)(String name, boolean value);
typedef void (*OnRangeMessage)(String name, int value); typedef void (*OnRangeMessage)(String name, int value);
typedef void (*OnStringMessage)(String name, String value); typedef void (*OnStringMessage)(String name, String value);
typedef void (*OnCustomMessage)(String name, String value, String type); typedef void (*OnCustomMessage)(String name, String value, String type);
typedef void (*OnSBOpen)(); typedef void (*OnSBOpen)();
typedef void (*OnSBClose)(); typedef void (*OnSBClose)();
typedef void (*OnSBError)(int code, String message); typedef void (*OnSBError)(int code, String message);
void onOpen(OnSBOpen function); void onOpen(OnSBOpen function);
void onClose(OnSBClose function); void onClose(OnSBClose function);
void onRangeMessage(OnRangeMessage function); void onRangeMessage(OnRangeMessage function);
void onStringMessage(OnStringMessage function); void onStringMessage(OnStringMessage function);
void onBooleanMessage(OnBooleanMessage function); void onBooleanMessage(OnBooleanMessage function);
void onCustomMessage(OnCustomMessage function); void onCustomMessage(OnCustomMessage function);
void onError(OnSBError function); void onError(OnSBError function);
private: private:
Process brew; Process brew;
String name; String name;
String server; String server;
String description; String description;
boolean _connected; boolean _started;
boolean _error_msg; boolean _connected;
boolean _verbose; boolean _error_msg;
int port; boolean _verbose;
int port;
/**Output should be at least 5 cells**/ /**Output should be at least 5 cells**/
static OnBooleanMessage _onBooleanMessage; static OnBooleanMessage _onBooleanMessage;
static OnRangeMessage _onRangeMessage; static OnRangeMessage _onRangeMessage;
static OnStringMessage _onStringMessage; static OnStringMessage _onStringMessage;
static OnCustomMessage _onCustomMessage; static OnCustomMessage _onCustomMessage;
static OnSBOpen _onOpen; static OnSBOpen _onOpen;
static OnSBClose _onClose; static OnSBClose _onClose;
static OnSBError _onError; static OnSBError _onError;
Subscriber * subscribers; Subscriber * subscribers;
Publisher * publishers; Publisher * publishers;
String sub_name; String sub_name;
String sub_msg; String sub_msg;
String sub_type; String sub_type;
boolean read_name; boolean read_name;
boolean read_msg; boolean read_msg;
boolean read_confirm; boolean read_confirm;
static int sub_name_max; static int sub_name_max;
static int sub_msg_str_max; static int sub_msg_str_max;
static int sub_msg_int_max; static int sub_msg_int_max;
static int sub_msg_bool_max; static int sub_msg_bool_max;
// int sub_name_max;
// int sub_msg_str_max;
Process pids; long connect_attempt;
char pid [6]; int connect_attempt_inter;
int sbPids [4];
void killPids(); Process pids;
void getPids(); char pid [6];
int sbPids [4];
static char * createString(int len) { void killPids();
char * out = ( char * ) malloc ( len + 1 ); void getPids();
return out;
}
static void emptyString(char * str, int len) { static char * createString(int len){
for (int i = 0; i < len; i++) { char * out = ( char * ) malloc ( len + 1 );
str[i] = '\0'; return out;
} }
}
static void emptyString(char * str, int len){
for (int i = 0; i < len; i++) {
str[i] = '\0';
}
}
}; };