Web Json + Xively

Buenas, estamos desarrollando un prototipo de estación meteorológica y estamos en un dilema: Queremos enviar datos a dos páginas totalmente diferentes. La primera sería una web generada por Arduino y que seria de formato Json, que luego utilizariamos para generar una aplicación para Android. La segunda sería enviar los datos recogidos por nuestros sensores a la página xively.com, una web para almacenar datos recogidos por los sensores, perfecta para la meteorología. El problema es que conseguimos programarlo perfectamente, pero a la hora de enviar los datos el programa se satura y no logramos postear los datos en ningún lado.

Os adjunto el programa para que le echeis un vistazo:

#include <SPI.h>
#include <WiFi.h>
#include <Adafruit_BMP085.h> // Incluir las librerias que necesitemos
#include <Wire.h>
#include <DHT.h>
#include <HttpClient.h>
#include <Xively.h>
#define DHTPIN 5 // Pin del sensor
#define DHTTYPE DHT22 // Modelo de sensor DHT
DHT dht(DHTPIN, DHTTYPE); // configuracion del DHT
Adafruit_BMP085 bmp;

int sensormq;
int sensorlluvia;
int anemo = 2;
int i = 0;
int valor=0; //Definicion de los sensores con sus variables
int vueltas = 0;
int velocidad = 0;
int luz = 3;
int lluvia = 2;
int aire = 1;
int status = WL_IDLE_STATUS;
char ssid = “"; // Nombre de la red Wifi
char pass[] = "
"; // Contraseña de la red Wifi, solo para WPA
char xivelyKey[] = "
************”;
char LLUVIAId = “LLUVIA”;
char AIREId = “AIRE”;
char DHThumedadId = “HUMEDAD”;
char DHTtemperaturaId = “TEMPERATURA”;
char PRESIONId = “PRESION”;
char ANEMOMETROId = “VIENTO”;
char LUZId = “LUMINOSIDAD”;
const int bufferSize = 14;
char bufferValue[bufferSize]; // enough space to store the string we’re going to send

XivelyDatastream datastreams = {
XivelyDatastream(LLUVIAId, strlen(LLUVIAId), DATASTREAM_BUFFER, bufferValue, bufferSize),
XivelyDatastream(AIREId, strlen(AIREId), DATASTREAM_FLOAT),
XivelyDatastream(DHThumedadId, strlen(DHThumedadId), DATASTREAM_FLOAT),
XivelyDatastream(DHTtemperaturaId, strlen(DHTtemperaturaId), DATASTREAM_FLOAT),
XivelyDatastream(PRESIONId, strlen(PRESIONId), DATASTREAM_FLOAT),
XivelyDatastream(ANEMOMETROId, strlen(ANEMOMETROId), DATASTREAM_FLOAT),
XivelyDatastream(LUZId, strlen(LUZId), DATASTREAM_FLOAT)
};

XivelyFeed feed(**************, datastreams, 7 / number of datastreams */);
WiFiClient client;
XivelyClient xivelyclient(client);
WiFiServer server(80); // Puerto protocolo de transferencia HTTP servidor web (por defecto 80)

void setup() {
Serial.begin(9600); //Inicializar la terminal
if (!bmp.begin()) { //Inicializar sensor BMP 085
Serial.println(“Could not find a valid BMP085 sensor, check wiring!”);
while (1) {}
}
dht.begin(); //Inicializar sensor DHT22
if (WiFi.status() == WL_NO_SHIELD) { //Chequeo de la conexion del modulo wifi al Arduino
Serial.println(“WiFi shield not present”);
while(true);
}

while ( status != WL_CONNECTED) { //Conexion del modulo wifi al SSID
Serial.print("Intentando conectarse a la SSID especificada: ");
Serial.println(ssid);
status = WiFi.begin(ssid, pass); //Ingresa en la red wifi con el usuario y contraseña indicada
delay(10000);

}
server.begin(); //Inicializar el servidor web
pinMode(anemo, INPUT);
pinMode(lluvia, INPUT);
pinMode(aire, INPUT);
pinMode(luz, INPUT);
attachInterrupt(0, parpadeo, RISING); //Funcion para la lectura de impulsos del anemometro
printWifiStatus(); //Funcion que muestra en la terminal los datos de la conexion; IP, alcance señal, etc…
}

void printWifiStatus() { //Bloque para mostrar los datos de la conexion Wifi
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

// Muestra la IP
IPAddress ip = WiFi.localIP();
Serial.print("IP: ");
Serial.println(ip);

// Muestra la potencia de la señal
long rssi = WiFi.RSSI();
Serial.print(“Fuerza de la senal (RSSI):”);
Serial.print(rssi);
Serial.println(" dBm");
}

void parpadeo() //Funcion auxiliar para el anemometro
{
i++;
}

void json()
{
WiFiClient cliente = server.available();
if (cliente) {
Serial.println(“Nuevo cliente encontrado”);
boolean currentLineIsBlank = true;
while (cliente.connected()) {
if (cliente.available()) {
char c = cliente.read();
Serial.write(c);
if (c == ‘\n’ && currentLineIsBlank) { //Formato de la web a la hora de enviar los datos
cliente.println(“HTTP/1.1 200 OK”);
cliente.println(“Content-Type: text/json”);
cliente.println(“Connnection: close”);
cliente.println();

float h = dht.readHumidity(); //Declarar variable de humedad del DHT22
float t = dht.readTemperature(); //Declarar variable de temperatura del DHT22

cliente.println("{");
cliente.print("“Humedad”:");
cliente.print(h);
cliente.println(",");
cliente.print("“Temperatura”:");
cliente.print(t);
cliente.println(",");
cliente.print("“Presion”:");
cliente.print(bmp.readPressure());
cliente.println(",");
cliente.print("“Aire”:");
sensormq = analogRead(1);
cliente.print(sensormq);
cliente.println(",");
vueltas=i/2;
velocidad=((vueltas*0.09106)*3.6);
cliente.print("“Viento”:");
cliente.print(velocidad);
cliente.println(",");
i=0;
vueltas=0;
velocidad=0;
cliente.print("“Lluvia”:");
sensorlluvia = analogRead(2);
cliente.println(sensorlluvia);
cliente.println("}");
break;
}
if (c == ‘\n’) {
currentLineIsBlank = true;
}
else if (c != ‘\r’) {
currentLineIsBlank = false;
}
}
}
delay(1); //Tiempo para que el navegador web reciba los datos
cliente.stop(); //Cerrar conexión
Serial.println(“Cliente desconectado”);
Serial.println("");
}
}

void loop()
{
for (int z=0;z<15000; z++)
{
json();
}
int valorlluvia = analogRead(lluvia);
if(valorlluvia>=950)
{
datastreams[0].setBuffer(“NO”);
Serial.print("LLUVIA ");
Serial.println(datastreams[0].getBuffer());
}

if(valorlluvia<950)
{
datastreams[0].setBuffer(“SI”);
Serial.print("LLUVIA ");
Serial.println(datastreams[0].getBuffer());
}

int valoraire = analogRead(aire);
datastreams[1].setFloat(valoraire);
Serial.print("AIRE ");
Serial.println(datastreams[1].getFloat());

int valorhumedad = dht.readHumidity();
datastreams[2].setFloat(valorhumedad);
Serial.print("DHT humedad ");
Serial.println(datastreams[2].getFloat());

int valortemperatura = dht.readTemperature();
datastreams[3].setFloat(valortemperatura);
Serial.print("DHT temperatura ");
Serial.println(datastreams[3].getFloat());

int valorpresion = (bmp.readPressure()/100);
datastreams[4].setFloat(valorpresion);
Serial.print("PRESION ");
Serial.println(datastreams[4].getFloat());

vueltas=i/2;
velocidad=((vueltas*0.09106)*3.6);
datastreams[5].setFloat(velocidad);
Serial.print("ANEMOMETRO ");
Serial.println(datastreams[5].getFloat());
i=0;
vueltas=0;
velocidad=0;

int valorluz = analogRead(luz);
datastreams[6].setFloat(valorluz);
Serial.print("LUMINOSIDAD ");
Serial.println(datastreams[6].getFloat());

Serial.println(“Subiendo los datos a Xyvely”);
int ret = xivelyclient.put(feed, xivelyKey);
Serial.print("HTTP: ");
Serial.println(ret);
Serial.println();
}

Os dejamos también la URL de nuestra página de xively: https://xively.com/feeds/1292605205

Un saludo. g2e

Hola muy bueno el proyecto, también estoy haciendo algo parecido usando xively y arduino. Te pregunto si no te queda medio grande el programa como rozando los 32k, poqrque en mi caso ando como en los 29k.

Ahora respecto de tu tema y soy medio atrevido porque estoy aprendiendo pero me parece que el tema viene por usar el mismo puerto http el 80 para 2 direcciones web, capaz que deberías definir otro puerto por ejemplo el 81. Entonces una pagina la sacas por el 80 y la otra por el 81. Te queda algo asi: https://xively.com/feeds/1292605205, esta es la que sale por el puerto 80 y la que sale por el puerto 81 sería http://miproyecto.dyndns.info:81. Ahora te queda otro trabajo en el router que es abrir los puertos en Forwarding abris el 80 y 81 para la ip que tenes asignada por el router para tu placa y por las dudas yo habilito también DMZ en el router. Esto que te cuento lo practico con los Dvr cuando utilizan la misma conexion de internet. Espero que te sirva de ayuda.