Ciao a tutti, un amico ha da poco installato impianto FV con inverter e accumulo della Western, inizialmente sprovvisto di monitoraggio, che ha poi integrato per visualizzare produzione, consumi da batterie e da enel sia da browser che da app. Il sistema è molto ben fatto, ma abbastanza chiuso.
Da qualche settimana ho iniziato con arduino uno e eth shield un sistema che legga i valori di interesse per poter comandare alcuni carichi in casa, quando le batterie sono già cariche e la produzione FV è ancora a certi livelli ed in secondo momento creare un display remoto.

Ho studiato un po' il sistema e nel sito di monitoraggio ho scovato il server di appoggio che, se interrogato, restituisce un file in formato .JSON contenente alcuni parametri  questo il link
LINK

questo il file [code][
  {
    "_id": "5968bed20440a9ba00d1adb2",
    "eviceId": "2DC3D0FDD0129BF",
    "ateTime": "2017-08-01T10:31:08.581Z",
    "Production": 0.57768,
    "Consumption": 0.7038,
    "Grid": 0,
    "Storage": 0.12612,
    "StorageLevel": 56.35,
    "SystemState": 0,
    "GridCharge": 0,
    "FvState": 0,
    "ProductionPro": 0,
    "BatterySoc": 0
  }
]

Da qui ho percorso due strade:
- con libreria ArduinoJson, ho concluso poco e niente, riesco a recuperare solo stringhe inutili.
- con i comandi client.parseFloat(); ogni 10sec. riesco recuperare i dati, ma da seriale, sembra a caso, legge valori a 0, -0, insomma non affidabile per comandare ad esempio l'autoclave di irrigazione..

Non sono certo sia un problema di arduino o codice, perché alcune volte anche da pc questi valori sono a 0, ma non sempre!

Chiedo a Voi esperti se avete qualche consiglio o dritta.
grazie in anticipo!


Prova questo, invia alla seriale ogni 5 sec. i dati di Production e Consumption. ;)
Ricordati di installare la libreria 'ArduinoJson.h' da qui LINK


#include <ArduinoJson.h>
#include <Ethernet.h>
#include <SPI.h>

EthernetClient client;

const char* server = "ws2.noman.it";  // server's address
const char* resource = "/api/energy/realtime/D2DC3D0FDD0129BF";                    // http resource
const unsigned long BAUD_RATE = 9600;                 // serial connection speed
const unsigned long HTTP_TIMEOUT = 10000;  // max respone time from server
const size_t MAX_CONTENT_SIZE = 512;       // max size of the HTTP response

// The type of data that we want to extract from the page
struct UserData {
  char Production[32];
  char Consumption[32];
};

// ARDUINO entry point #1: runs once when you press reset or power the board
void setup() {
  initSerial();
  initEthernet();
}

// ARDUINO entry point #2: runs over and over again forever
void loop() {
  if (connect(server)) {
    if (sendRequest(server, resource) && skipResponseHeaders()) {
      UserData userData;
      if (readReponseContent(&userData)) {
        printUserData(&userData);
      }
    }
  }
  disconnect();
  wait();
}

// Initialize Serial port
void initSerial() {
  Serial.begin(BAUD_RATE);
  while (!Serial) {
    ;  // wait for serial port to initialize
  }
  Serial.println("Serial ready");
}

// Initialize Ethernet library
void initEthernet() {
  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
  if (!Ethernet.begin(mac)) {
    Serial.println("Failed to configure Ethernet");
    return;
  }
  Serial.println("Ethernet ready");
  delay(1000);
}

// Open connection to the HTTP server
bool connect(const char* hostName) {
  Serial.print("Connect to ");
  Serial.println(hostName);

  bool ok = client.connect(hostName, 1880);

  Serial.println(ok ? "Connected" : "Connection Failed!");
  return ok;
}

// Send the HTTP GET request to the server
bool sendRequest(const char* host, const char* resource) {
  Serial.print("GET ");
  Serial.println(resource);

  client.print("GET ");
  client.print(resource);
  client.println(" HTTP/1.0");
  client.print("Host: ");
  client.println(host);
  client.println("Connection: close");
  client.println();

  return true;
}

// Skip HTTP headers so that we are at the beginning of the response's body
bool skipResponseHeaders() {
  // HTTP headers end with an empty line
  char endOfHeaders[] = "\r\n\r\n";

  client.setTimeout(HTTP_TIMEOUT);
  bool ok = client.find(endOfHeaders);

  if (!ok) {
    Serial.println("No response or invalid response!");
  }

  return ok;
}

bool readReponseContent(struct UserData* userData) {
  // Compute optimal size of the JSON buffer according to what we need to parse.
  // See https://bblanchon.github.io/ArduinoJson/assistant/
const size_t bufferSize = JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(13) + 260;
DynamicJsonBuffer jsonBuffer(bufferSize);

JsonArray& root = jsonBuffer.parseArray(client);

JsonObject& root_0 = root[0];

  if (!root.success()) {
    Serial.println("JSON parsing failed!");
    //  Serial.println(client);
    return false;
  }

  // Here were copy the strings we're interested in
  strcpy(userData->Production, root_0["Production"]);
  strcpy(userData->Consumption, root_0["Consumption"]);
  // It's not mandatory to make a copy, you could just use the pointers
  // Since, they are pointing inside the "content" buffer, so you need to make
  // sure it's still in memory when you read the string

  return true;
}

// Print the data extracted from the JSON
void printUserData(const struct UserData* userData) {
  Serial.print("Production = ");
  Serial.println(userData->Production);
  Serial.print("Consumption = ");
  Serial.println(userData->Consumption);
}

// Close the connection with the HTTP server
void disconnect() {
  Serial.println("isconnect");
  client.stop();
}

// Pause for a 5 seconds
void wait() {
  Serial.println("Wait 5 seconds");
  delay(5000);
}


Grazie mille per l'aiuto, leggendo il tuo codice ho già notato alcune cose che avevo sbagliato!
stasera provo 
grazie mille

Ieri sera ho testato e funziona, ho aggiunto altre due letture Grid e Storage, perfetto.
Ora ho solo un dubbio, recupera i valori come char, sarebbe possibile come float, in modo da poter eseguire operazioni matematiche dai dati ricevuti?
complimenti ancora per le conoscenze!!



Taglio :
Ieri sera ho testato e funziona, ho aggiunto altre due letture Grid e Storage, perfetto.
Ora ho solo un dubbio, recupera i valori come char, sarebbe possibile come float, in modo da poter eseguire operazioni matematiche dai dati ricevuti?
complimenti ancora per le conoscenze!!



Esiste una bella funzione
float valore=Stringadaconvertire.toFloat()
Prova...  ;)

nel frattempo ho riletto la documentazione della libreria, ho risolto con float produzione = root_0["Production"];

poi una prova banale di somma e funziona!

sto procedendo con lo studio dei dati e come li interpreta il sito

per esempio Storage assume valore solo in scarica, quando invece le batterie sono in carica da JSON Storage = 0, il sito visualizza Produzione-Consumo

Ho recuperato anche SystemState, assume 0 quando il carico è alimentato da FV e/o batterie, valore 1 quando è connesso ad Enel





Grande! Dai che il risultato finale sarà eccellente!  ;)

Ciao a tutti, finalmente è arrivato l'ultimo pezzo per il progetto, Nextion 3,2" (dimensioni perfette per Vimar Idea 503), ci devo ancora lavorare per la visualizzazione grafica, ma la soddisfazione è tanta!


altra visualizzazione con touch


questa è una prova


Bravo! Con il nextion è bellissimo

Complimenti Taglio 

La grafica è ancora da migliorare, ci vuole tempo e capacità con trasparenze ed effetti (che non ho!).. tutto merito di Danye, per la dritta con la libreria Json!


Ciao Taglio e complimenti,
son nuovo e incuriosito, appunto ma non so che Regolatore MPPT della Western usi.
Puoi erudirmi?


Ciao, scusami ma è un po' che non passo dal forum. Il regolatore è di un amico, non ricordo di preciso il modello, a memoria Leonardo da 5kw.
Il progetto si è un po' arenato, un fulmine ha avuto la meglio sulla logica dell'inverter e sul monitoraggio proprietario!

Oltre a comandare semplici relè, lo sviluppo è arrivato ad accendere un cdz Mitsubishi via IrDa (sia come raffreddamento che PdC) per non buttare la corrente in esubero.

Una grossa pecca che ci ha bloccato, il server che genera il JSON con i dati (della western/noman), che legge arduino, si attiva solo se, o l'app android o il pc, effettua l'accesso con user e pwd del monitoraggio e rimane attivo per circa 5/10min variabili, poi smette l'aggiornamento.
Quindi, ai fini pratici, non è affidabile per comandare carichi..
Le poche conoscenze di programmazione lato server/siti/https...mi hanno arenato!