Come inviare più datastream su COSM

Salve a tutti,
ho installato una piccola stazione meteo, utilizzando il DHT11 come sensore, Arduino con scheda WiFi e due led per indicare se la temperatura è troppo passa o troppo alta. Ora riesco a leggere correttamente la temperatura. Tuttavia, vorrei anche inviare la percentuale della temperatura. Come posso fare ? Ho già provato il codice presente in playground ma non funziona. Riporto il codice che sto attualmente utilizzando:

/*
  Wifi Pachube sensor client

 This sketch connects an analog sensor to Pachube (http://www.pachube.com)
 using an Arduino Wifi shield.

 This example is written for a network using WPA encryption. For 
 WEP or WPA, change the Wifi.begin() call accordingly.

 This example has been updated to use version 2.0 of the Pachube.com API. 
 To make it work, create a feed with a datastream, and give it the ID
 sensor1. Or change the code below to match your feed.

 Circuit:
 * Analog sensor attached to analog in 0
 * Wifi shield attached to pins 10, 11, 12, 13

 created 13 Mar 2012
 modified 23 Apr 2012
 by Tom Igoe

 This code is in the public domain.

 */
#include <SPI.h>
#include <WiFi.h>

#define APIKEY         " :)" // replace your pachube api key here
#define FEEDID          :)                   // replace your feed ID
#define USERAGENT      "Weather's arduino"     // user agent is the project name
#define DHT11_PIN 0      // define anlog  port 0

char ssid[] = " XD;      //  your network SSID (name) 
char pass[] = " XD";   // your network password

byte read_dht11_dat()
{
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    while(!(PINC & _BV(DHT11_PIN)))
    {};  // wait  forever until anlog input port 0 is '1'   (NOTICE: PINC reads all the analog input ports 
    //and  _BV(X) is the macro operation which pull up positon 'X'to '1' and the rest positions to '0'. it is equivalent to 1<<X.) 
    delayMicroseconds(30);
    if(PINC & _BV(DHT11_PIN))  //if analog input port 0 is still '1' after 30 us
      result |=(1<<(7-i));     //this position is 1
    while((PINC & _BV(DHT11_PIN)));  // wait '1' finish
    }
    return result;
}





int status = WL_IDLE_STATUS;

// initialize the library instance:
WiFiClient client;
// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
IPAddress server(216,52,233,122);      // numeric IP for api.pachube.com
//char server[] = "api.pachube.com";   // name address for pachube API

unsigned long lastConnectionTime = 0;          // last time you connected to the server, in milliseconds
boolean lastConnected = false;                 // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000; //delay between updates to Pachube.com

void setup() {
  DDRC |= _BV(DHT11_PIN);   //let analog port 0 be output port 
  PORTC |= _BV(DHT11_PIN);  //let the initial value of this port be '1'
  // start serial port:
  Serial.begin(9600);
  delay(300);//Let system settle
  delay(700);//Wait rest of 1000ms recommended delay before
  //accessing sensor

  // attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) { 
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    status = WiFi.begin(ssid, pass);
    // wait 10 seconds for connection:
    delay(10000);
  } 
  // you're connected now, so print out the status:
  printWifiStatus();
}


void loop() {
  
  byte dht11_dat[5];    
  byte dht11_in;
  byte i;// start condition
      
  PORTC &= ~_BV(DHT11_PIN);    // 1. pull-down i/o pin for 18ms
  delay(18);
  PORTC |= _BV(DHT11_PIN);     // 2. pull-up i/o pin for 40us
  delayMicroseconds(1);
  DDRC &= ~_BV(DHT11_PIN);     //let analog port 0 be input port 
  delayMicroseconds(40);      
   
  dht11_in = PINC & _BV(DHT11_PIN);  // read only the input port 0
  if(dht11_in)
  {
    Serial.println("dht11 start condition 1 not met"); // wait for DHT response signal: LOW
    delay(1000);
    return;
  }
  delayMicroseconds(80);
  dht11_in = PINC & _BV(DHT11_PIN); //  
  if(!dht11_in)
  {
    Serial.println("dht11 start condition 2 not met");  //wair for second response signal:HIGH
    return;
  }
   
  delayMicroseconds(80);// now ready for data reception
  for (i=0; i<5; i++)
  {  dht11_dat[i] = read_dht11_dat();}  //recieved 40 bits data. Details are described in datasheet
   
  DDRC |= _BV(DHT11_PIN);      //let analog port 0 be output port after all the data have been received
  PORTC |= _BV(DHT11_PIN);     //let the  value of this port be '1' after all the data have been received
  byte dht11_check_sum = dht11_dat[0]+dht11_dat[1]+dht11_dat[2]+dht11_dat[3];// check check_sum
  if(dht11_dat[4]!= dht11_check_sum)
  {
    Serial.println("DHT11 checksum error");
  }
  Serial.print("Current humdity = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("temperature = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("C  ");
  delay(2000);  //fresh time
  
  //This is the "heart" of the program.
  
  
  // read the analog sensor:
  int sensorReading =dht11_dat[2];   

  // if there's incoming data from the net connection.
  // send it out the serial port.  This is for debugging
  // purposes only:
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // if there's no net connection, but there was one last time
  // through the loop, then stop the client:
  if (!client.connected() && lastConnected) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }

  // if you're not connected, and ten seconds have passed since
  // your last connection, then connect again and send data:
  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
    sendData(sensorReading);
  }
  // store the state of the connection for next time through
  // the loop:
  lastConnected = client.connected();
}

// this method makes a HTTP connection to the server:
void sendData(int thisData) {
  // if there's a successful connection:
  if (client.connect(server, 80)) {
    Serial.println("connecting...");
    // send the HTTP PUT request:
    client.print("PUT /v2/feeds/");
    client.print(FEEDID);
    client.println(".csv HTTP/1.1");
    client.println("Host: api.pachube.com");
    client.print("X-PachubeApiKey: ");
    client.println(APIKEY);
    client.print("User-Agent: ");
    client.println(USERAGENT);
    client.print("Content-Length: ");

    // calculate the length of the sensor reading in bytes:
    // 8 bytes for "sensor1," + number of digits of the data:
    int thisLength = 8 + getLength(thisData);
    client.println(thisLength);

    // last pieces of the HTTP PUT request:
    client.println("Content-Type: text/csv");
    client.println("Connection: close");
    client.println();

    // here's the actual content of the PUT request:
    client.print("sensor1,");
    client.println(thisData);
     

  } 
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }
   // note the time that the connection was made or attempted:
  lastConnectionTime = millis();
}


// This method calculates the number of digits in the
// sensor reading.  Since each digit of the ASCII decimal
// representation is a byte, the number of digits equals
// the number of bytes:

int getLength(int someValue) {
  // there's at least one byte:
  int digits = 1;
  // continually divide the value by ten, 
  // adding one to the digit count for each
  // time you divide, until you're at 0:
  int dividend = someValue /10;
  while (dividend > 0) {
    dividend = dividend /10;
    digits++;
  }
  // return the number of digits:
  return digits;
}

void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

Inoltre, anche se dichiaro come float la variabile da inviare, viene riportato un int, come mai ? secondo voi è possibile inserire facilmente i dati su un sito Wordpress ? Grazie come sempre per il supporto.

Penso che con "percentuale della temperatura" intendessi l'umidità.

Non mi è chiaro il "non funziona". Nel codice c'è la stampa sulla seriale e quindi l'invio del dato a cosm. Credo che la stampa sulla seriale funzioni, no? Cioè questa parte dovrebbe funzionare

  Serial.print("Current humdity = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("temperature = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("C  ");

Leggendo il resto trovo queste istruzioni

  // read the analog sensor:
  int sensorReading =dht11_dat[2];

Qui in realtà non legge nulla, copia la parte intera della temperatura.

Dopodiché più avanti c'è questa

sendData(sensorReading);

e nella funzione void sendData(int thisData)

c'è questo

    // here's the actual content of the PUT request:
    client.print("sensor1,");
    client.println(thisData);

Cioè viene mandato il dato di un solo sensore che poi su cosm risulta sensor1. Inoltre sembra che venga mandata la sola parte intera della temperatura, senza il decimale.

Sempre che non abbia capito male.

Ho ricorretto un po’ il codice e sono riuscito ad inviare più data stream alla volta. Però, non riesco a mandare il dato il float, perchè ci sono dei problemi di conversione con la variabile datastring. Ecco il codice ricorretto:

/* Questo programma permette di inviare dati al sito COSM, che permette di realizzare grafici e salvare le informazioni inviate. 
Per la connnessione ad Internet, viene sfruttata la libreria WiFi.h, che contiene le funzioni che permettono di connettere Arduino alla rete WiFi, una volta inseriti i dati relativi nei vettori ssid e pass. 
Per leggere la temperatura e l'umidità, viene utilizzata la libreria DHT11, che converte i valori di tensioni, nei valori corretti. 
 */

#include <SPI.h>
#include <WiFi.h>

#define APIKEY         "" // Inserire la chiave api di COSM qui
#define FEEDID                           // Inserire il Feed ID
#define USERAGENT      "Weather's arduino"      // Inserire il nome del progetto
#define DHT11_PIN 0      // Viene defnita la porta A0, che serve per leggere i valori
int ledblue = 2; // Dichiaro il led blu
int ledred = 3; // Dichiaro il led rosso
int temp_max = 30; // La temperatura minima per cui si accende il LED rosso
int temp_min = 0; // La temperatura massima per cui si accende il LED blu

char ssid[] = "";      // Il nome della rete WiFi a cui si connette Arduino
char pass[] = "";   // La password della rete WiFi

int status = WL_IDLE_STATUS;

byte read_dht11_dat()
{
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    while(!(PINC & _BV(DHT11_PIN)))
    {};  
    delayMicroseconds(30);
    if(PINC & _BV(DHT11_PIN))  
      result |=(1<<(7-i));     
    while((PINC & _BV(DHT11_PIN))); 
    }
      return result;
}


// Viene inizializzata la funzione contenuta in WiFi.h
WiFiClient client;

// L'indirizzo a cui si connette Arduino per inviare i dati
char server[] = "api.pachube.com";  

unsigned long lastConnectionTime = 0;          // Tempo di ultima connessione
boolean lastConnected = false;                 // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000;  // ritardo tra l'invio dei dati

void setup() {
  // Iniziliazzo le due porte per i LED
  pinMode(ledblue, OUTPUT); 
  pinMode(ledred, OUTPUT);
  // start serial port:
  DDRC |= _BV(DHT11_PIN);    
  PORTC |= _BV(DHT11_PIN);  
  // Inzializzo la seriale, in modo da poter leggere i dati:
  Serial.begin(9600);
  delay(300);
  delay(700);// Ritardo prima di accedere ancora al sensore

  // Attendo che Arduino si connetti alla rete
  while ( status != WL_CONNECTED) { 
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    status = WiFi.begin(ssid, pass);
    
    delay(10000);
  } 
  // Ora la connessione WiFi funziona
  printWifiStatus();
}

void loop() {
  // Vengono letti i dati e inseriti nel vettore
  byte dht11_dat[5];    
  byte dht11_in;
  byte i;
      
  PORTC &= ~_BV(DHT11_PIN);    
  delay(18);
  PORTC |= _BV(DHT11_PIN);     
  delayMicroseconds(1);
  DDRC &= ~_BV(DHT11_PIN);     
  delayMicroseconds(40);      
   
  dht11_in = PINC & _BV(DHT11_PIN);  
  if(dht11_in)
  {
    Serial.println("dht11 start condition 1 not met"); //Aspetta la risposta DHT segnale: LOW
    delay(1000);
    return;
  }
  delayMicroseconds(80);
  dht11_in = PINC & _BV(DHT11_PIN);  
  if(!dht11_in)
  {
    Serial.println("dht11 start condition 2 not met");  //Aspetta la risposta DHT segnale:HIGH
    return;
  }
   
  delayMicroseconds(80);// ora è pronto per leggere i dati
  for (i=0; i<5; i++)
  {  dht11_dat[i] = read_dht11_dat();} 
   
  DDRC |= _BV(DHT11_PIN);      
  PORTC |= _BV(DHT11_PIN);     
  byte dht11_check_sum = dht11_dat[0]+dht11_dat[1]+dht11_dat[2]+dht11_dat[3];
  if(dht11_dat[4]!= dht11_check_sum)
  {
    Serial.println("DHT11 checksum error");
  }
  // Vengono stampi sul seriale i dati raccolti, quali temperatura e umidità
  Serial.print("Current humdity = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("temperature = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("C  ");
  delay(2000);  
  
   // Inizializzo la funzione che permette di far accedere il LED se la temperatura è troppo alto, oppure troppo bassa
  
  if(dht11_dat[2]>temp_max) {
    digitalWrite(ledred, HIGH);   // Accendo il LED Rosso
    delay(500); //Tempo di accensione              
    digitalWrite(ledred, LOW); // Spengo il LED Rosso
  }
   // Imposto la variabile, che esprime il valore della temperatura
   if(dht11_dat[2]<temp_min) {
    digitalWrite(ledblue, HIGH);   // Accendo il LED blu
    delay(500); //Tempo di accensione              
    digitalWrite(ledblue, LOW); // Spengo il LED blu
  }
 // Imposto la variabile, che esprime il valore della percentuale dell'umidità
  int sensorReading =dht11_dat[2];   
  

  String dataString = "sensor1,";
  dataString += sensorReading;

 
  int otherSensorReading = dht11_dat[0];
  dataString += "\nsensor2,";
  dataString += otherSensorReading;

 
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  
  if (!client.connected() && lastConnected) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }

  
  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
    sendData(dataString);
  }
  
  lastConnected = client.connected();
}

// Questa funzione permette di inviare i dati a COSM
void sendData(String thisData) {
  // Se c'è una connessione invia
  if (client.connect(server, 80)) {
    Serial.println("connecting...");
    
    client.print("PUT /v2/feeds/");
    client.print(FEEDID);
    client.println(".csv HTTP/1.1");
    client.println("Host: api.pachube.com");
    client.print("X-PachubeApiKey: ");
    client.println(APIKEY);
    client.print("User-Agent: ");
    client.println(USERAGENT);
    client.print("Content-Length: ");
    client.println(thisData.length());

    
    client.println("Content-Type: text/csv");
    client.println("Connection: close");
    client.println();

    
    client.println(thisData);
  } 
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }
  // note the time that the connection was made or attempted:
  lastConnectionTime = millis();
}


void printWifiStatus() {
 // Viene stampata a video il nome della rete a cui si è connessi
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // Stampa a video l'indirizzo IP
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

// Stampa a video la potenza del segnale WiFi
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

Come posso inviare i dati in float (solo la temperatura ?)

Ciao,
io lo ho implementato su shield Ethernet:

#include <SPI.h>
#include <Ethernet.h>
#include <HttpClient.h>
#include <Cosm.h>
#include <DHT.h>

// MAC address for your Ethernet shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Your Cosm key to let you upload data
char cosmKey[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

// Analog pin which we're monitoring (0 and 1 are used by the Ethernet shield)
int sensorPin = 2;

// Define the strings for our datastream IDs
char sensorId[] = "TempC";
char sensorId2[] = "Humid";
//char bufferId[] = "info_message";
//String stringId("random_string");
const int bufferSize = 140;
float TempC, Humid;
char bufferValue[bufferSize]; // enough space to store the string we're going to send
CosmDatastream datastreams[] = {
  CosmDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT),
  CosmDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT),
//  CosmDatastream(stringId, DATASTREAM_STRING)
};
// Finally, wrap the datastreams into a feed
CosmFeed feed(!!!FEEDNUMBER!!!, datastreams, 2 /* number of datastreams */);

EthernetClient client;
CosmClient cosmclient(client);


//*******************************************************************************************************
//DHT22
//*******************************************************************************************************
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11   // DHT 11 
#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

#define DHTPIN 3     // what pin we're connected to

DHT dht(DHTPIN, DHTTYPE);



void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  
  Serial.println("Starting multiple datastream upload to Cosm...");
  Serial.println();

  while (Ethernet.begin(mac) != 1)
  {
    Serial.println("Error getting IP address via DHCP, trying again...");
    delay(15000);
  }
}

void loop() {
  
  float TempC = dht.readTemperature();
//  int sensorValue = t;
  datastreams[0].setFloat(TempC);
  Serial.print("Read sensor T value ");
  Serial.println(datastreams[0].getFloat());

  float Humid = dht.readHumidity();
//  sensorValue = h;
//  Serial.print("printing H alone: ");
//  Serial.print(h);
  datastreams[1].setFloat(Humid);
  Serial.print("Read sensor H value ");
  Serial.println(datastreams[1].getFloat());

  // Pick a random number to send up in a string
//  String stringValue(random(100));
//  stringValue += " is a random number";
//  datastreams[2].setString(stringValue);
//  Serial.print("Setting string value to:\n    ");
//  Serial.println(datastreams[2].getString());

  Serial.println("Uploading it to Cosm");
  int ret = cosmclient.put(feed, cosmKey);
  Serial.print("cosmclient.put returned ");
  Serial.println(ret);

  Serial.println();
  delay(15000);
}

non è tutta farina del mio sacco,
non trovo il post del blog a cui mi sono ispirato, appena lo trovo lo posto…
mapperchè non mi segno le cose?

trovati: http://arduino.cc/forum/index.php?topic=126796.0 http://www.danilolarizza.com/arduino-cosm-internet-delle-cose/