Arduino YUN sketch si blocca apparentemente senza motivo....

Buongiorno a tutti…il mio progetto è:

  • creare un sensore di temperatura (mediante l’utilizzo del sensore digitale waterproof Dallas DS18B20) che, al raggiungimento di una certa soglia,attivi (mediante l’utilizzo di una piccola board con due relè 250v) una elettrovalvola motorizzata;
  • durante il suo funzionamento, lo sketch deve inviare, periodicamente, un comando di tipo URL es. “http://192.168.1.2:8083/command=set_active....ecc ecc” per inviare la temperatura letta e in caso di attivazione della valvola, lo stato della stessa ON e poi OFF.

Scopiazzando in qua e la e usando come base lo sketch di esempio della libreria Dallas, ho buttato giuù il listato che posto al termine di queste righe…
INFO UTILI:la scheda è aggiornata all’ultima release OPENWRT e la trasmissione dei comandi avviene per mezzo di rete WIRELESS avente potenza segnale 100%.
PROBLEMA: lo sketch sembra girare perfettamente ma dopo un tot di ore MAI LE STESSE e difficilmente quantificabili NON funziona più…
Ad esempio ieri sera l’ho attivato alle 21.00 e stamattina alle 6:00 il led di segnalazione di lettura temperatura non lampeggiava e la temperatura leggibile da altro apparecchio (quello a cui trasmetto con il comando CURL che si vede nel listato) era ZERO…la scheda era correttamente raggiungibile in wireless.

CONSIDERAZIONI PERSONALI:non rilevo anomalie nel codice ed ho effettuato vari test con DEBUG utilizzando la comunicazione seriale, comando che ho volutamente ELIMINATO dal listato qui presente per permettervi una migliore lettura…spero che nell’attività di puliza non abbia eliminato anche parentesi graffe :confused:

Potrebbe essere scheda fallata???
Grazie a tutti coloro che vorranno rispondermi

P.S.- prima di scrivere ho letto tutti i post di regolamento e raccomandazioni ed ho effettuato varie ricerche su internet…abbiate pazienza se ho sbagliato qualcosa

#include <Process.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// INIZIO DEVICE TIPO ONEWIRE SU PIN DIGITALE //
OneWire ds0(2);  // PIN DS18B20

// INIZIO LED //
const int RLed = 12; // valvola ON
const int GLed = 11; // ON-OFF
#define COMANDO_VALVOLA 3 //digital PIN che comanda rele
#define TEMP_MAX 85  // temperatura di soglia oltre la quale si attiva valvola

bool intervallo=FALSE;  //variabile che verra settata a TRUE quando si attivera la valvola e lo rimarra fintanto che non passera un tempo prestabilito 
float temporizzatore=0; //la variabile che terra il tempo che deve passare prima che intervallo possa tornare a FALSE
float tempoinviaTemp=0; //temporizzatore che fa inviare ogni 15 secondi la lettura della temperatura a domotica (altrimenti avveniva ogni 6)

bool prima_lettura=TRUE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata

void setup() {
pinMode(RLed, OUTPUT);  // set the digital pin as output:
pinMode(GLed, OUTPUT);  // set the digital pin as output:
pinMode(COMANDO_VALVOLA, OUTPUT);  // set the digital pin as output:
digitalWrite(COMANDO_VALVOLA, HIGH);  // set il COMANDO_VALVOLA a HIGH inizialmente in quanto il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa

digitalWrite(GLed, HIGH); // Initial state (verifica funzionamento LED)
digitalWrite(RLed, HIGH); // Initial state (per verifica funzionamento LED
delay (2000);
digitalWrite(GLed, LOW); // Initial state (verifica funzionamento LED)
digitalWrite(RLed, LOW); // Initial state (per verifica funzionamento LED

 // AVOID FREEZE ON REBOOT // 
 
  delay(15000);
  Bridge.begin();
  // STOP REBOOT NO-FREEZE //  

}
void loop() 
{

    // ONEWIRE DS18B20 DIGITAL TEMP SENSOR //

  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  int celsius;    // float to have xx.yy
  if ( !ds0.search(addr)) {
    ds0.reset_search();

    delay(6000);     ///////////// MASTER DELAY \\\\\\\\\\\\
    return;
  }
  
  for( i = 0; i < 8; i++) {
    digitalWrite(GLed, HIGH); //serve per far accendere brevemente il led verde e verificare il funzionamento
  }

  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      return;
  } 

  ds0.reset();
  ds0.select(addr);
  ds0.write(0x44, 1);        // start conversion, with parasite power on at the end
  
//  delay(50);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
  
  present = ds0.reset();
  ds0.select(addr);    
  ds0.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds0.read();
  }
  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (int)raw / 16.0; // float to have xx.yy

  digitalWrite(GLed, LOW);
  if (millis()-tempoinviaTemp>30000) //praticamente un invio temperatura a Letocrono ogni 5 letture
  {
    inviaTemp(celsius);
    tempoinviaTemp=millis();
  }
  if (celsius>TEMP_MAX && intervallo==FALSE && prima_lettura==FALSE)
  {
    inviaTemp(celsius);
//    Serial.print ("VALVOLA APERTA PER 15 sec.");
    digitalWrite(RLed,HIGH);
    digitalWrite (COMANDO_VALVOLA,LOW); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    runCurlON();
    delay(40000); //tempo occorrente alla valvola per effettuare una apertura completa
    digitalWrite (COMANDO_VALVOLA,HIGH); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    digitalWrite(RLed,LOW);
    runCurlOFF();
    intervallo=TRUE;
    temporizzatore=millis();
  }
  if (intervallo==TRUE && millis()-temporizzatore>300000) //quando intervallo viene attivato, parte il conteggio del tempo prima che la verifica della temperatura possa riattivare la valvola altrimenti la lentezza con la quale il sensore PERDE calore la farebbe attivare continuamente  
  {
    intervallo=FALSE;
//    Serial.print ("PASSATI 5 MINUTI RIATTIVO CONTROLLO");
  } 
prima_lettura=FALSE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata
}


void runCurlON() {
   // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  Process p;		// Create a process and call it "p"
  p.begin("curl");	// Process that launch the "curl" command
  p.addParameter("http://192.168.1.2:8083/command=set_active?766"); // Add the URL parameter to "curl"
  p.run();		// Run the process and wait for its termination
}

void runCurlOFF() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  Process p;		// Create a process and call it "p"
  p.begin("curl");	// Process that launch the "curl" command
  p.addParameter("http://192.168.1.2:8083/command=set_active?768"); // Add the URL parameter to "curl"
  p.run();		// Run the process and wait for its termination
}

void inviaTemp(int gradiC)
{
  Process p;		// Create a process and call it "p"
  p.begin("curl");	// Process that launch the "curl" command
  String myUrl="http://192.168.1.2:8083/command=set_value?773=";
  myUrl+=gradiC;
  p.addParameter(myUrl); // Add the URL parameter to "curl"
  p.run();		// Run the process and wait for its termination
}

In qualità di possessore di una Yun mi schiero sul campo, ma: giusto per evitare di perdere il senno dietro a problemi di codice che magari non ci sono ! Con cosa alimenti Yun ? (mi sono da poco scottato con problemi di alimentazione di alcuni Arduino Mini che ho che ogni tanto si freezano!)

La scheda ti risulta raggiungibile quindi in teoria la parte Linux rimane attiva e funzionante (processore dedicato e sezione d'alimentazione separata se non ricordo male...) mentre magari si blocca il loop del atmega che quindi non gli restituisce più il valore della lettura del sensore ?!

E' la prima volta che in un codice vedo salvare il valore di millis() dentro una float !! Di solito si usa il tipo unsigned long per evitare problemi di overflow... (che sia questo che causa il problema?) prova:

unsigned long temporizzatore=0; //la variabile che terra il tempo che deve passare prima che intervallo possa tornare a FALSE
unsigned long tempoinviaTemp=0; //temporizzatore che fa inviare ogni 15 secondi la lettura della temperatura a domotica (altrimenti avveniva ogni 6)

e vedi se si blocca ancora ;)

P.s. Ricorda di presentarti nell'opportuna sezione!

Credo che il problema sia nell'uso dell'oggetto String usato nella routine inviaTemp.

Quando si effettua la somma di stringhe, crei una nuova stringa di lunghezza maggiore e questa occupa una certa memoria.

Terminata la routine, in teoria, la memoria occupata ritorna disponibile, ma non sempre è così.

Il processo di recupero dello spazio allocato in precedenza prevede che, se lo spazio richiesto è uguale non ci sono problemi, ma se è maggiore viene allocata altra memoria in altra posizione.

A lungo andare questo provoca la saturazione della memoria.

Per risolvere il problema, o si usa un vettore char evitando l'oggetto String, oppure si prealloca una quantità di byte pari alla massima necessaria con l'istruzione string.reserve(size).

beltin:
Buongiorno a tutti…

Ti invitiamo a presentarti (dicci quali conoscenze hai di elettronica e di programmazione) qui: Presentazioni
e a leggere il regolamento: Regolamento

Grazie per le risposte….ho postato la presentazione come consigliato da nid69ita. Per quanto riguarda la parte di programmazione ho seguito il consiglio di 5a2v0 cambiando il tipo alla variabile dei temporizzatori mentre per quanto riguarda la "string", devo capire il consiglio di cyberhs (essendo un neofita,devo studiare come scrivere il codice) e poi proverò ad inserirlo.

Grazie

String è una classe di oggetti, abbastanza comoda ma pesantina per la poca SRAM di queste MCU
stringhe per il C/C++ sono vettori o array di caratteri di dimensioni fissate a priori e terminate con il carattere speciale null ‘\0’

Ovvero una stringa è un vettore di, esempio, 10 char:

char str[10];
str[0]='C';
str[1]='i';
str[2]=97;             // decimale 97 -> ascii='a'
str[3]='o';            
str[4]='\0';

se stampi str otterrai “Ciao”
la funzione strlen(str) ti risponderà 4 caratteri validi
la funzione sizeof(str) ti risponderà 10 byte ovvero lo spazio totale occupato da str

Allora…tornato a casa da poco vado a mettere in pratica quanto consigliatomi.

Opto per l'uso della istruzione .reserve(size) (più da niubbo…perfetta per me) che vado a mettere nel mio setup dopo aver dichiarato la variabile fuori da esso.

Per rispondere alla domanda sull'alimentazione, io uso un alimentatore da pc portatili 5v. 2A, collegato direttamente alla Vin e al GND.

Cmq per ora stava girando perfettamente…..speriamo che con con la precauzione del .reserve possa anticipare eventuali anomalie di funzionamento.

Grazie ancora per gli ottimi consigli!

Ultimissima NEWS....stanotte lo sketch si è bloccato MA stavolta ho capito il perché.....nella lista dei processi ho visto che risultava in perenne esecuzione un CURL ecc ecc...ho provato a fare il kill del processo e magicamente tutto ha ripreso a funzionare quindi ergo il problema è il p.run che non finisce mai!!! Consigli ???

  1. Che versione dell IDE utilizzi? Ho letto qualche post dove bisognava aggiornare la libreria bridge altrimenti causava questo tipo di blocchi…

  2. Perchè non provi ad assegnare al processo che chiami da arduino su linux un nome diverso ? In tutti e 3 i casi chiami il processo semlicemente p, ma cosa succede se l’operazione precedente non ha ancora terminato e provi a creare un processo con lo stesso nome ?

  3. Potresti provare a impostare il timeout di connessione E il tempo massimo di esecuzione per il cURL (non come soluzione definitiva) ma per capire se il problema può dipendere da uno dei cURL che usi che magari non riesce a connettersi e rimane all’infinito il processo aperto e arduino si blocca ovviamente in attesa della conclusione…

#include <Process.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// INIZIO DEVICE TIPO ONEWIRE SU PIN DIGITALE //
OneWire ds0(2);  // PIN DS18B20

// INIZIO LED //
const int RLed = 12; // valvola ON
const int GLed = 11; // ON-OFF
#define COMANDO_VALVOLA 3 //digital PIN che comanda rele
#define TEMP_MAX 85  // temperatura di soglia oltre la quale si attiva valvola

bool intervallo = FALSE; //variabile che verra settata a TRUE quando si attivera la valvola e lo rimarra fintanto che non passera un tempo prestabilito
float temporizzatore = 0; //la variabile che terra il tempo che deve passare prima che intervallo possa tornare a FALSE
float tempoinviaTemp = 0; //temporizzatore che fa inviare ogni 15 secondi la lettura della temperatura a domotica (altrimenti avveniva ogni 6)

bool prima_lettura = TRUE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata

void setup() {
  pinMode(RLed, OUTPUT);  // set the digital pin as output:
  pinMode(GLed, OUTPUT);  // set the digital pin as output:
  pinMode(COMANDO_VALVOLA, OUTPUT);  // set the digital pin as output:
  digitalWrite(COMANDO_VALVOLA, HIGH);  // set il COMANDO_VALVOLA a HIGH inizialmente in quanto il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa

  digitalWrite(GLed, HIGH); // Initial state (verifica funzionamento LED)
  digitalWrite(RLed, HIGH); // Initial state (per verifica funzionamento LED
  delay (2000);
  digitalWrite(GLed, LOW); // Initial state (verifica funzionamento LED)
  digitalWrite(RLed, LOW); // Initial state (per verifica funzionamento LED

  // AVOID FREEZE ON REBOOT //

  delay(15000);
  Bridge.begin();
  // STOP REBOOT NO-FREEZE //

}
void loop()
{

  // ONEWIRE DS18B20 DIGITAL TEMP SENSOR //

  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  int celsius;    // float to have xx.yy
  if ( !ds0.search(addr)) {
    ds0.reset_search();

    delay(6000);     ///////////// MASTER DELAY \\\\\\\\\\\\
    return;
  }

  for ( i = 0; i < 8; i++) {
    digitalWrite(GLed, HIGH); //serve per far accendere brevemente il led verde e verificare il funzionamento
  }

  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      return;
  }

  ds0.reset();
  ds0.select(addr);
  ds0.write(0x44, 1);        // start conversion, with parasite power on at the end

  //  delay(50);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.

  present = ds0.reset();
  ds0.select(addr);
  ds0.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds0.read();
  }
  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (int)raw / 16.0; // float to have xx.yy

  digitalWrite(GLed, LOW);
  if (millis() - tempoinviaTemp > 30000) //praticamente un invio temperatura a Letocrono ogni 5 letture
  {
    inviaTemp(celsius);
    tempoinviaTemp = millis();
  }
  if (celsius > TEMP_MAX && intervallo == FALSE && prima_lettura == FALSE)
  {
    inviaTemp(celsius);
    //    Serial.print ("VALVOLA APERTA PER 15 sec.");
    digitalWrite(RLed, HIGH);
    digitalWrite (COMANDO_VALVOLA, LOW); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    runCurlON();
    delay(40000); //tempo occorrente alla valvola per effettuare una apertura completa
    digitalWrite (COMANDO_VALVOLA, HIGH); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    digitalWrite(RLed, LOW);
    runCurlOFF();
    intervallo = TRUE;
    temporizzatore = millis();
  }
  if (intervallo == TRUE && millis() - temporizzatore > 300000) //quando intervallo viene attivato, parte il conteggio del tempo prima che la verifica della temperatura possa riattivare la valvola altrimenti la lentezza con la quale il sensore PERDE calore la farebbe attivare continuamente
  {
    intervallo = FALSE;
    //    Serial.print ("PASSATI 5 MINUTI RIATTIVO CONTROLLO");
  }
  prima_lettura = FALSE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata
}


void runCurlON() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  Process on;		// Create a process and call it "p"
  on.begin("curl");	// Process that launch the "curl" command
  on.addParameter("--connect-timeout 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  on.addParameter("--max-time 30"); //--max-time SECONDS  Maximum time allowed for the transfer
  on.addParameter("http://192.168.1.2:8083/command=set_active?766"); // Add the URL parameter to "curl"
  on.run();		// Run the process and wait for its termination
}

void runCurlOFF() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  Process off;		// Create a process and call it "p"
  off.begin("curl");	// Process that launch the "curl" command
  off.addParameter("--connect-timeout 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  off.addParameter("--max-time 30"); //--max-time SECONDS  Maximum time allowed for the transfer
  off.addParameter("http://192.168.1.2:8083/command=set_active?768"); // Add the URL parameter to "curl"
  off.run();		// Run the process and wait for its termination
}

void inviaTemp(int gradiC) {
  Process invia;	// Create a process and call it "p"
  invia.begin("curl");	// Process that launch the "curl" command
  String myUrl = "http://192.168.1.2:8083/command=set_value?773=";
  myUrl += gradiC;
  invia.addParameter("--connect-timeout 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  invia.addParameter("--max-time 30"); //--max-time SECONDS  Maximum time allowed for the transfer
  invia.addParameter(myUrl); // Add the URL parameter to "curl"
  invia.run();		// Run the process and wait for its termination
}

Prima di tutto un infinito grazie per la risposta.....completa ed esaustiva! Per rispondere punto per punto: -versione IDE : al momento non so risponderti MA mi hai fatto venire il dubbio che non sia aggiornatissima perché ho usato un portatile che non utilizzavo da tempo...verificherò appena torno a casa; - chiamare i processi con nomi diversi mi spaventa un po' perché se cominciano a rimanere appesi più processi....si satura velocemente la memoria....; - il punto 3 mi attrae particolarmente ! Perché non come soluzione definitiva? Sembra una ottima alternativa,semplice e spero efficace! Ma se il processo rimane appeso non si "killa" automaticamente?

Non definitiva perché se il curl non riesce a collegarsi si tronca dopo tot secondi e le operazioni che il tuo programma doveva svolgere con quel curl verranno saltate... Ho pensato di aggiungerlo per debug... Cioe per vedere solo se cosi si blocca pure o no....

Poi si potrebbe anche lasciare il timeout come "valvola di sicurezza"...

5a2v0: Non definitiva perché se il curl non riesce a collegarsi si tronca dopo tot secondi e le operazioni che il tuo programma doveva svolgere con quel curl verranno saltate... CUT Ho

Per completezza del post, l'operazione che quel CURL deve svolgere altro non è che aggiornare la temperatura su di un pannello remoto e quindi, anche se mi salta una o qualche lettura CHISSENE :) !! L'importante è che lo sketch poi prosegua il suo andamento per evitare che nel frattempo si verifichino le condizioni di avviamento della valvola ma questa non si attivi >:(

Ci sarebbe anche la possibilità di far partire il processo con

runAsynchronously()

al posto del normale

run()

Cito il reference:

Description

Starts a Linux process identified in Process.begin().

Unlike run(), runAsynchronously() is not-blocking. Your sketch will continue to run while the Linux process runs in the background.

Così lo sketch non si ferma proprio ad aspettare l'esito dell'operazione... i timeout di connessione e di tempo max di esecuzione li potresti tenere sempre e comunque per evitare come ti è già capitato che rimanesse un curl aperto a vita ;)

Guarda…non mi lancio in dichiarazioni “audaci” nei tuoi confronti per non turbare la serietà di questo forum…adesso provo a inserire queste due ulteriori chicche nello sketch ……grazie :slight_smile:

Allora come promesso ho subito inserito il nuovo codice nello sketch,caricato ma....non funzionava più l'invio ! Dopo svariati tentativi ed un po di serial per fare debug,mi sono ricordato che un problema poteva essere la eccessiva lunghezza del comando (comprensivo di parametri)...pertanto ho utilizzato gli argomenti ridotti ovvero -K anziché --connect-timeout e -m anziché --max-time e comunque non andava.....ho poi "scoperto" che il runAsynchronously non funziona . Pertanto ho usato il run() ma con le precazioni di impostare il time out a 5 secondi ed il Max time a 10 non dovrebbero esserci più problemi (spero...)

Non funziona? Ma ma ma... Mmm io ricordo di averlo usato tempo fa con la mia yun... Non ci hai detto piu la versione di IDE che usi e se hai aggiornato o meno!

OPS...sono un cagnaccio....Versione 1.6.3. Ora aggiorno alla 1.6.5 e riprovo

Ok fatto....aggiornato e ricaricato sketch con il run.Asynchronously ma aimè il risultato non cambia....non invia.....ho provato sia con gli argomenti lunghi che abbreviato ma funziona solo con il run()

Forse trovato una spiegazione: tu dichiari Process p all’interno della funzione chiamata dentro il loop…

Utilizzando run.Asynchronously Arduino non aspetta la sua parte linux e va avanti con il loop! Probabilmente così tanto veloce da non permettere l’esecuzione del suddetto codice…

Prova a dichiararlo a livello globale:

#include <Process.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// INIZIO DEVICE TIPO ONEWIRE SU PIN DIGITALE //
OneWire ds0(2);  // PIN DS18B20

// INIZIO LED //
const int RLed = 12; // valvola ON
const int GLed = 11; // ON-OFF
#define COMANDO_VALVOLA 3 //digital PIN che comanda rele
#define TEMP_MAX 85  // temperatura di soglia oltre la quale si attiva valvola

bool intervallo = FALSE; //variabile che verra settata a TRUE quando si attivera la valvola e lo rimarra fintanto che non passera un tempo prestabilito
float temporizzatore = 0; //la variabile che terra il tempo che deve passare prima che intervallo possa tornare a FALSE
float tempoinviaTemp = 0; //temporizzatore che fa inviare ogni 15 secondi la lettura della temperatura a domotica (altrimenti avveniva ogni 6)

bool prima_lettura = TRUE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata
Process on;    // Create a process and call it "on"
Process off;    // Create a process and call it "off"
Process invia;    // Create a process and call it "invia"


void setup() {
  pinMode(RLed, OUTPUT);  // set the digital pin as output:
  pinMode(GLed, OUTPUT);  // set the digital pin as output:
  pinMode(COMANDO_VALVOLA, OUTPUT);  // set the digital pin as output:
  digitalWrite(COMANDO_VALVOLA, HIGH);  // set il COMANDO_VALVOLA a HIGH inizialmente in quanto il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa

  digitalWrite(GLed, HIGH); // Initial state (verifica funzionamento LED)
  digitalWrite(RLed, HIGH); // Initial state (per verifica funzionamento LED
  delay (2000);
  digitalWrite(GLed, LOW); // Initial state (verifica funzionamento LED)
  digitalWrite(RLed, LOW); // Initial state (per verifica funzionamento LED

  // AVOID FREEZE ON REBOOT //

  delay(15000);
  Bridge.begin();
  // STOP REBOOT NO-FREEZE //

}
void loop()
{

  // ONEWIRE DS18B20 DIGITAL TEMP SENSOR //

  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  int celsius;    // float to have xx.yy
  if ( !ds0.search(addr)) {
    ds0.reset_search();

    delay(6000);     ///////////// MASTER DELAY \\\\\\\\\\\\
    return;
  }

  for ( i = 0; i < 8; i++) {
    digitalWrite(GLed, HIGH); //serve per far accendere brevemente il led verde e verificare il funzionamento
  }

  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      return;
  }

  ds0.reset();
  ds0.select(addr);
  ds0.write(0x44, 1);        // start conversion, with parasite power on at the end

  //  delay(50);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.

  present = ds0.reset();
  ds0.select(addr);
  ds0.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds0.read();
  }
  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (int)raw / 16.0; // float to have xx.yy

  digitalWrite(GLed, LOW);
  if (millis() - tempoinviaTemp > 30000) //praticamente un invio temperatura a Letocrono ogni 5 letture
  {
    inviaTemp(celsius);
    tempoinviaTemp = millis();
  }
  if (celsius > TEMP_MAX && intervallo == FALSE && prima_lettura == FALSE)
  {
    inviaTemp(celsius);
    //    Serial.print ("VALVOLA APERTA PER 15 sec.");
    digitalWrite(RLed, HIGH);
    digitalWrite (COMANDO_VALVOLA, LOW); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    runCurlON();
    delay(40000); //tempo occorrente alla valvola per effettuare una apertura completa
    digitalWrite (COMANDO_VALVOLA, HIGH); //il led on board al rele funziona al contrario..si spegne con stato logico alto e viceversa
    digitalWrite(RLed, LOW);
    runCurlOFF();
    intervallo = TRUE;
    temporizzatore = millis();
  }
  if (intervallo == TRUE && millis() - temporizzatore > 300000) //quando intervallo viene attivato, parte il conteggio del tempo prima che la verifica della temperatura possa riattivare la valvola altrimenti la lentezza con la quale il sensore PERDE calore la farebbe attivare continuamente
  {
    intervallo = FALSE;
    //    Serial.print ("PASSATI 5 MINUTI RIATTIVO CONTROLLO");
  }
  prima_lettura = FALSE; //ho notato che la prima lettura dopo un ritorno di corrente era sempre di 85C che avrebbe causato l'apertura della valvola...cosi facendo la prima lettura viene saltata
}


void runCurlON() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  on.begin("curl"); // Process that launch the "curl" command
  on.addParameter("-K 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  on.addParameter("-m 10"); //--max-time SECONDS  Maximum time allowed for the transfer
  on.addParameter("http://192.168.1.2:8083/command=set_active?766"); // Add the URL parameter to "curl"
  on.runAsynchronously();   // Run the process and wait for its termination
}

void runCurlOFF() {
  // Launch "curl" command and get Arduino ascii art logo from the network
  // curl is command line program for transferring data using different internet protocols
  off.begin("curl");  // Process that launch the "curl" command
  off.addParameter("-K 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  off.addParameter("-m 10"); //--max-time SECONDS  Maximum time allowed for the transfer
  off.addParameter("http://192.168.1.2:8083/command=set_active?768"); // Add the URL parameter to "curl"
  off.runAsynchronously();    // Run the process and wait for its termination
}

void inviaTemp(int gradiC) {
  invia.begin("curl");  // Process that launch the "curl" command
  String myUrl = "http://192.168.1.2:8083/command=set_value?773=";
  myUrl += gradiC;
  invia.addParameter("-K 5"); //--connect-timeout SECONDS  Maximum time allowed for connection
  invia.addParameter("-m 10"); //--max-time SECONDS  Maximum time allowed for the transfer
  invia.addParameter(myUrl); // Add the URL parameter to "curl"
  invia.runAsynchronously();    // Run the process and wait for its termination
}

p.s. io ho modificato lo sketch che ti avevo editato prima con 3 process indipendenti… vedi tu se vuoi dichiararne solo 1, ma vista l’esecuzione senza attesa io preferirei lasciarne 3 (se qualcuno più preparato di me vuol dire la sua sulla scelta migliore ben venga, sono curioso anche io !!)

Per l'ennesima volta ho utilizzato i tuoi consigli ed effettivamente ora funziona anche con il .runAsynchronously….che dire! Aspettiamo almeno due giorni per cantare vittoria?? :) :)