Stò già lavorando anche per far funzionare il tutto via rete in modo da poter controllare l'on/off e cambiare le impostazioni via rete.
Proprio adesso stò facendo dei test con un arduino uno appena è stabile il codice lo posto.

Puoi postare il tuo sketch modificato così lo posso testare per verificarne il problema?

Scusami per stasera non ce la faccio a postare il codice. Domani in serata lo posto.
Grazie di tutto, buon test!

CITAZIONE (jackie2_it, 11/03/2014 22:00:02 )

#include <SoftwareSerial.h>
SoftwareSerial mySerial(3, 4); // RX, TX

mySerial.write(0x01); // Lunghezza dei dati sostituito da: mySerial.write(0x01)

#include 
SoftwareSerial mySerial(3, 4); // RX, TX


#define SER_SIZE 256 //dimensione massima del buffer 
static uint8_t bufferRegolatore[SER_SIZE + 1] = ""; //buffer che conterrà i byte letti dalla seriale. 
int serind; //indice per il buffer. 

//variabili d'appoggio per i valori letti dal regolatore. 
int tensioneBatteria = 0; 
int tensionePannello = 0; 
int correnteCarico = 0; 
int tensioneBatteriaScarica = 0; 
int tensioneBatteriaCarica = 0; 
int caricoOnOff = 0; 
int sovraccarico = 0; 
int cortoCircuitoCarico = 0; 
int soc = 0; 
int batteriaSovraccarica = 0; 
int indicatoreSottoScarica = 0; 
int indicatoreBatteriaCarica = 0; 
int indicatoreCarica = 0; 
int temperaturaBatteria = 0; 
int correnteCarica = 0; 

int contasecondi = 0; 

void setup() { 
// initialize serial communication at 9600 bits per second: 
Serial.begin(9600); 
mySerial.begin(9600); //comunica con il regolatore a 9600. 
} 

void parser() { 
//elabora il buffer ed estrae i valori. 
tensioneBatteria = (bufferRegolatore[10] << 8) | bufferRegolatore[9]; 
tensionePannello = (bufferRegolatore[12] << 8) | bufferRegolatore[11]; 
correnteCarico = (bufferRegolatore[16] << 8) | bufferRegolatore[15]; 
tensioneBatteriaScarica = (bufferRegolatore[18] << 8) | bufferRegolatore[17]; 
tensioneBatteriaCarica = (bufferRegolatore[20] << 8) | bufferRegolatore[19]; 
caricoOnOff = bufferRegolatore[21]; 
sovraccarico = bufferRegolatore[22]; 
cortoCircuitoCarico = bufferRegolatore[23]; 
soc = bufferRegolatore[24]; 
batteriaSovraccarica = bufferRegolatore[25]; 
indicatoreSottoScarica = bufferRegolatore[26]; 
indicatoreBatteriaCarica = bufferRegolatore[27]; 
indicatoreCarica = bufferRegolatore[28]; 
temperaturaBatteria = bufferRegolatore[29] - 30; // come indicato nella documentazione bisogna sottrarre 30 al valore rilevato. 
correnteCarica = (bufferRegolatore[31] << 8) | bufferRegolatore[30]; 

//invio sull'usb i dati rilevati in modo da poterli leggere dal pc. 
Serial.print("Tensione Batteria: "); 
Serial.println(tensioneBatteria); 

Serial.print("Tensione Pannello: "); 
Serial.println(tensionePannello); 

Serial.print("Corrente Carico: "); 
Serial.println(correnteCarico); 

Serial.print("Tensione Batteria Scarica: "); 
Serial.println(tensioneBatteriaScarica); 

Serial.print("Tensione Batteria Carica: "); 
Serial.println(tensioneBatteriaCarica); 

Serial.print("Carico Acceso/Spento: "); 
Serial.println(caricoOnOff); 

Serial.print("C'è stato un sovraccarico: "); 
Serial.println(sovraccarico); 

Serial.print("Cortocircuito del carico: "); 
Serial.println(cortoCircuitoCarico); 

Serial.print("SOC: "); 
Serial.println(soc); 

Serial.print("Batteria sovraccarica: "); 
Serial.println(batteriaSovraccarica); 

Serial.print("Batteria scarica: "); 
Serial.println(indicatoreSottoScarica); 

Serial.print("Batteria completamente carica: "); 
Serial.println(indicatoreBatteriaCarica); 

Serial.print("Batteria in carica: "); 
Serial.println(indicatoreCarica); 

Serial.print("Temperatura della batteria: "); 
Serial.println(temperaturaBatteria); 

Serial.print("Corrente di carica: "); 
Serial.println(correnteCarica); 
Serial.println("--------------------------------"); 
} 

void loop() { 

if (contasecondi == 0) { 
//inizio inviando il synchronous head (preso paro paro dalla documentazione) 
mySerial.write(0xEB); 
mySerial.write(0x90); 
mySerial.write(0xEB); 
mySerial.write(0x90); 
mySerial.write(0xEB); 
mySerial.write(0x90); 

mySerial.write(0x01); // versione indico 1 
mySerial.write(0xA0); // Richiedo al regolatore i dati in tempo reale. 
mySerial.write(0x01); // Lunghezza dei dati sostituito da: mySerial.write(0x01) altrimenti non compila
mySerial.write(0x6F); // Check sum 
mySerial.write(0x52); // Check sum 
mySerial.write(0x7F); 

contasecondi=30; 
serind=0; 
//Serial.println("Inviato comando"); 
} 

// leggo la risposta del regolatore. 
while (mySerial.available() > 0) { 
/*Serial.print("ricezione"); 
Serial.print(serind);*/ 
char *ptr; //puntatore al buffer in memoria. 
ptr = (char *) &bufferRegolatore; 
ptr = ptr + serind; 
if (mySerial.readBytes(ptr, 1) == 1) { 
serind++; 
} 
if ((serind == 36) && (bufferRegolatore[35] == 0x7F)) parser(); 
} 

delay(1000); 
contasecondi -=1; 

//Serial.println(contasecondi); 

}

Stà venendo su un bel lavoro di collaborazione .
Volevo sottolineare che se postate i codici ,essi non vengono visualizzati correttamente.
In particolare l'include delle librerie e tutti i comandi html
es:

quindi consiglio per ora di allegare anche il codice zippato o in file testo.

Ciao grandi
ElettroshockNow

Purtroppo la libreria SoftwareSerial ha dei problemi quando deve attendere dei dati con l'istruzione available. Se hai a disposizione uno ethernet shield posso provare a mettere su uno sketch che utilizzi la seriale di Arduino (non potrai più utilizzarla per vedere i dati sul PC) ma li potrai vedere su un browser web fammi sapere.

@elettro grazie per l'indicazione per il prossimo sketch seguo le indicazioni di allevarlo. Se vedi qualche strafalcione fammi sapere ok?

Ciao jackie2_it ho risolto nel mio caso con Arduino uno in questo modo:

  Serial.write(0xAA); 
  Serial.write(0x55); 
  Serial.write(0xAA); 
  Serial.write(0x55); 
  Serial.write(0xAA); 
  Serial.write(0x55);
  Serial.write(0xEB); 
  Serial.write(0x90); 
  Serial.write(0xEB); 
  Serial.write(0x90); 
  Serial.write(0xEB); 
  Serial.write(0x90); 
  Serial.write(0x16); // versione indico 1 
  Serial.write(0xA0); // Richiedo al regolatore i dati in tempo reale. 
  Serial.write(0x00); // Lunghezza dei dati 
  Serial.write(0xB1); // Check sum 
  Serial.write(0xA7); // Check sum 
  Serial.write(0x7F);
 delay(500); 
  if (Serial.available() > 40) {
    digitalWrite(5, HIGH);// accende il led se ricevo i dati dal regolatore
    data_long = Serial.available();
    for (int n=0; n < data_long; n++){       
      data[n] = Serial.read();
    } 
  }

  tensione_pannello = (data[12]<<8)|data[11];
  corrente_pannello = 0;
  tensione_batteria = (data[10]<<8)|data[9];
  corrente_batteria = (data[31]<<8)|data[30];
  tensione_carico = tensione_batteria;
  corrente_carico = (data[16]<<8)|data[15];

Prova a fare questo test togli quella sequenza aggiuntiva in testa e lascia solo quella che avevo messo io cosi per capire che cosa cambia?

Ma per inviare i dati verso il sito usi un interfaccia di rete su arduino o usi il pc?

CITAZIONE (jackie2_it, 12/03/2014 19:58:40 )

Mi sa che non risponde perché dipende dal fatto che hai quel available a 40?

Ma che modello è il tuo epsolar?

CITAZIONE (jackie2_it, 12/03/2014 20:10:55 )

Uguale al mio. Non capisco come mi fa a funzionare.
In effetti dalla documentazione i byte sono 12 per il syncronous header provo a modificarlo anche io e riprovò.
Il passaggio successivo se hai la ethernet shield potrebbe essere quello di controllare le funzioni del sensore via rete e se non sai come fare posso mostrare come aggiungere la possibilità di misurare la corrente del pannello solare?

CITAZIONE (jackie2_it, 12/03/2014 20:14:13 )

Quel software che avevo messo nel link del cavo non invia i primi 6 byte che hai indicato e funziona lo stesso molto strano. Ma come fai a leggere i valori se la seriale è già occupata a comunicare con il regolatore?