arduino bloccato da teleruttore!!

Buona domenica a tutti scusate per l'assenza ma sono stato impegnato con la scuola e lo studio :0 :0 :0 !! co il mio progetto sono fermo ho fatto tutte le prove possibili ma niente arduino si riavvia sempre doto un tot di on/off del teleruttore, però questa volta la differenza è che ho collegato una piccola pompa per acquari e l'ho fatta girare, indovinate un pò!! Sempre uguale! Sono disperato non so più cosa provare!! :0 :0 :0 :0

poi si blocca tutto pagina web ed arduino e quindi devo resettare tutto!!

secondo me si blocca tutto perchè non hai postato lo sketch :D e non penso che senza questo otterrai altri aiuti, quello che ti si poteva dire ti è stato detto.

uwefed:

poi si blocca tutto pagina web ed arduino e quindi devo resettare tutto!! al teleruttore non c'è collegato nessun carico!!

Sei sicuro che non é un problema di RAM esaurita? Ciao Uwe

Ripeto la mia risposta. Dacci lo sketch e dicci quale Arduino usi. Ciao Uwe

Bene questo è lo sketch me il problema non è lo sketch perché facendo delle prove succedeva lo stesso con la seriale. :expressionless: :expressionless:
Uso arduino uno rev3 e relativa ethernet shield.

#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>
// size of buffer used to capture HTTP requests
#define REQ_BUF_SZ   60

// MAC address from Ethernet shield sticker under board
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 20); // IP address, may need to change depending on network
EthernetServer server(80);  // create a server at port 80
File webFile;               // the web page file on the SD card
char HTTP_req[REQ_BUF_SZ] = {0}; // buffered HTTP request stored as null terminated string
char req_index = 0;              // index into HTTP_req buffer
boolean LED_state[4] = {0}; // stores the states of the LEDs

void setup()
{
    // disable Ethernet chip
    pinMode(10, OUTPUT);
    digitalWrite(10, HIGH);
   
    if (!SD.begin(4)) {;
        return;    // init failed
    }
    
    // check for index.htm file
    if (!SD.exists("index.htm")) {
        
        return;  // can't find index file
    }
    
    // switches on pins 2, 3 and 5
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    pinMode(5, INPUT);
    // LEDs
    pinMode(6, OUTPUT);
    pinMode(7, OUTPUT);
    pinMode(8, OUTPUT);
    pinMode(9, OUTPUT);
    
    Ethernet.begin(mac, ip);  // initialize Ethernet device
    server.begin();           // start to listen for clients
}

void loop()
{
    EthernetClient client = server.available();  // try to get client

    if (client) {  // got client?
        boolean currentLineIsBlank = true;
        while (client.connected()) {
            if (client.available()) {   // client data available to read
                char c = client.read(); // read 1 byte (character) from client
                // limit the size of the stored received HTTP request
                // buffer first part of HTTP request in HTTP_req array (string)
                // leave last element in array as 0 to null terminate string (REQ_BUF_SZ - 1)
                if (req_index < (REQ_BUF_SZ - 1)) {
                    HTTP_req[req_index] = c;          // save HTTP request character
                    req_index++;
                }
                // last line of client request is blank and ends with \n
                // respond to client only after last line received
                if (c == '\n' && currentLineIsBlank) {
                    // send a standard http response header
                    client.println("HTTP/1.1 200 OK");
                    // remainder of header follows below, depending on if
                    // web page or XML page is requested
                    // Ajax request - send XML file
                    if (StrContains(HTTP_req, "ajax_inputs")) {
                        // send rest of HTTP header
                        client.println("Content-Type: text/xml");
                        client.println("Connection: keep-alive");
                        client.println();
                        SetLEDs();
                        // send XML file containing input states
                        XML_response(client);
                    }
                    else {  // web page request
                        // send rest of HTTP header
                        client.println("Content-Type: text/html");
                        client.println("Connection: keep-alive");
                        client.println();
                        // send web page
                        webFile = SD.open("index.htm");        // open web page file
                        if (webFile) {
                            while(webFile.available()) {
                                client.write(webFile.read()); // send web page to client
                            }
                            webFile.close();
                        }
                    }
                    req_index = 0;
                    StrClear(HTTP_req, REQ_BUF_SZ);
                    break;
                }
                // every line of text received from the client ends with \r\n
                if (c == '\n') {
                    // last character on line of received text
                    // starting new line with next character read
                    currentLineIsBlank = true;
                } 
                else if (c != '\r') {
                    // a text character was received from client
                    currentLineIsBlank = false;
                }
            } // end if (client.available())
        } // end while (client.connected())
        delay(1);      // give the web browser time to receive the data
        client.stop(); // close the connection
    } // end if (client)
}

// checks if received HTTP request is switching on/off LEDs
// also saves the state of the LEDs
void SetLEDs(void)
{
    // LED 1 (pin 6)
    if (StrContains(HTTP_req, "LED1=1")) {
        LED_state[0] = 1;  // save LED state
        digitalWrite(6, HIGH);
    }
    else if (StrContains(HTTP_req, "LED1=0")) {
        LED_state[0] = 0;  // save LED state
        digitalWrite(6, LOW);
    }
    // LED 2 (pin 7)
    if (StrContains(HTTP_req, "LED2=1")) {
        LED_state[1] = 1;  // save LED state
        digitalWrite(7, HIGH);
    }
    else if (StrContains(HTTP_req, "LED2=0")) {
        LED_state[1] = 0;  // save LED state
        digitalWrite(7, LOW);
    }
    // LED 3 (pin 8)
    if (StrContains(HTTP_req, "LED3=1")) {
        LED_state[2] = 1;  // save LED state
        digitalWrite(8, HIGH);
    }
    else if (StrContains(HTTP_req, "LED3=0")) {
        LED_state[2] = 0;  // save LED state
        digitalWrite(8, LOW);
    }
    // LED 4 (pin 9)
    if (StrContains(HTTP_req, "LED4=1")) {
        LED_state[3] = 1;  // save LED state
        digitalWrite(9, HIGH);
    }
    else if (StrContains(HTTP_req, "LED4=0")) {
        LED_state[3] = 0;  // save LED state
        digitalWrite(9, LOW);
    }
}

// send the XML file with analog values, switch status
//  and LED status
void XML_response(EthernetClient cl)
{
    int analog_val;            // stores value read from analog inputs
    int count;                 // used by 'for' loops
    int sw_arr[] = {2, 3, 5};  // pins interfaced to switches
    
    cl.print("<?xml version = \"1.0\" ?>");
    cl.print("<inputs>");
    // read analog inputs
    for (count = 2; count <= 5; count++) { // A2 to A5
        analog_val = analogRead(count);
        cl.print("<analog>");
        cl.print(analog_val);
        cl.println("</analog>");
    }
    // read switches
    for (count = 0; count < 3; count++) {
        cl.print("<switch>");
        if (digitalRead(sw_arr[count])) {
            cl.print("ON");
        }
        else {
            cl.print("OFF");
        }
        cl.println("</switch>");
    }
   
    
    cl.print("</inputs>");
}

// sets every element of str to 0 (clears array)
void StrClear(char *str, char length)
{
    for (int i = 0; i < length; i++) {
        str[i] = 0;
    }
}

// searches for the string sfind in the string str
// returns 1 if string found
// returns 0 if string not found
char StrContains(char *str, char *sfind)
{
    char found = 0;
    char index = 0;
    char len;

    len = strlen(str);
    
    if (strlen(sfind) > len) {
        return 0;
    }
    while (index < len) {
        if (str[index] == sfind[found]) {
            found++;
            if (strlen(sfind) == found) {
                return 1;
            }
        }
        else {
            found = 0;
        }
        index++;
    }

    return 0;
}
...
client.println("Content-Type: text/html");
client.println("Connection: keep-alive");
client.println();
...
cl.print("<?xml version = \"1.0\" ?>");
cl.print("<inputs>");
...

E tu pensi che non sia un problema di RAM??

  1. usa la macro F()
    al posto di xxx.println(“testo”);
    scrivi xxx.println(F(“testo”));
  2. prova il tutto con una Arduino MEGA 2560 che ha piú memoria

Ciao Uwe

se non sbaglio occupa il 79% di memoria quindi non dovrebbe essere un problema comunque proverò non costa nulla e si impara XD

beh l'ho modificato lo spazio occupato è del 73% ma sempre uguale :~ :~

michele1996:
se non sbaglio occupa il 79% di memoria quindi non dovrebbe essere un problema comunque proverò non costa nulla e si impara XD

Allora non stai usando lo sketch che ci hai dato. Quello postato, compilato ora su 1.5.7, mi dice che occupa il 66% delle risorse, pari a 1358 byte su 2048. Ottimizzando con la F() scendo al 57% (1184 byte).

A prescindere che un arduino UNO è troppo limitato per farci girare un web server, quindi chiudiamo un occhio :) In base a quello che dici

Ho un piccolo problema con un teleruttore con bobina a 220v, il rele da solo funziona perfettamente riesco ad accendere tranquillamente lampadine, e altre cavolate varie, per non appena collego il il relè per far eccitare la bobina del teleruttore le prime "accensioni " vanno bene, poi si blocca tutto pagina web ed arduino e quindi devo resettare tutto!!

vorrei capire che prove hai fatto per escludere che sia il software, ti ho detto che potrebbe essere il software perchè apparentemente la compilazione e la ram usata dallo sketch può andare a buon fine, ma il problema di un webserver non fatto con i fiocchi sono le variabili di grandezza indefinita, le stringhe e i buffer troppo grandi. Quando un client si collega ad arduino e avviene la negoziazione si dicono molte cose con migliaia di char e spesso le variabili string su arduino vengono caricate di questi char, non tutti ovviamente ma una buona fetta necessaria per poterne fare il parse ed estrarre i dati GET, POST ecc ... se io invio uno stringone enorme GET o POST il server è obbligato a caricarselo tutto ... quindi qui escono fuori i limiti di RAM quella che lo sketch riempe e svuota continuamente durante l'esecuzione del programma. Non è escluso che in un determinato momento questa si riempie e causi il crash.

UNO SRAM 2 KB MEGA SRAM 8 KB DUE SRAM 96 KB

1) Dopo quanto ti va in crash? dopo ore, minuti, dopo giorni? 2) Dici che succede solo quando metti il relè piccolo e il teleruttore senza carico 220v, hai provato solo il relè piccolo? 3) con un led va tutto bene? con diverse ore di test non 2 accensioni e basta (io lo trovavo inchiodato anche dopo 10-12 ore) 4) come alimenti arduino? non potrebbe essere che quel relè non sia indicato e che crei problemi sull'alimentazione?

devi fare molte prove tu e per logica escludere tutto ....

Ad esempio: se è davvero il relè che da questo problema e fosse il mio arduino, per prima cosa farei una contro prova, lascio l'hardware così come è, e ci carico l'webserver elementare che si trova sugli esempi dell'IDE che sono proprio pochi byte, attivo il relè da remoto un po' di volte e se non lo fa più ... lascio a te la conclusione, altrimenti è indiscutibile che l'hardware ha dei problemi

questo pezzo lo puoi fare con 4-5 righe di codice

void SetLEDs(void)
{
    // LED 1 (pin 6)
    if (StrContains(HTTP_req, "LED1=1")) {
        LED_state[0] = 1;  // save LED state
        digitalWrite(6, HIGH);
    }
    else if (StrContains(HTTP_req, "LED1=0")) {
        LED_state[0] = 0;  // save LED state
        digitalWrite(6, LOW);
    }
    // LED 2 (pin 7)
    if (StrContains(HTTP_req, "LED2=1")) {
        LED_state[1] = 1;  // save LED state
        digitalWrite(7, HIGH);
    }
    else if (StrContains(HTTP_req, "LED2=0")) {
        LED_state[1] = 0;  // save LED state
        digitalWrite(7, LOW);
    }
    // LED 3 (pin 8)
    if (StrContains(HTTP_req, "LED3=1")) {
        LED_state[2] = 1;  // save LED state
        digitalWrite(8, HIGH);
    }
    else if (StrContains(HTTP_req, "LED3=0")) {
        LED_state[2] = 0;  // save LED state
        digitalWrite(8, LOW);
    }
    // LED 4 (pin 9)
    if (StrContains(HTTP_req, "LED4=1")) {
        LED_state[3] = 1;  // save LED state
        digitalWrite(9, HIGH);
    }
    else if (StrContains(HTTP_req, "LED4=0")) {
        LED_state[3] = 0;  // save LED state
        digitalWrite(9, LOW);
    }
}

LED è una parola costante quindi IF trvato "LED" dopo l'uguale hai 0 oppure 1 quindi HIGH o LOW che puoi sostituire direttamente al digitlwrite prima dell' "=" ci metti il numero del pin che puoi sostituire al digitalwrite

digitalWrite(numero pin prima dell "=" , 0/1 che è dopo l' '"=");

oppure LED31 per accendere il 3 LED30 per spegnere il 3

leggi il char dopo la parola LED ... char xxx[y+1] leggi il char dopo la parola LED ... char xxx[y+2] ciao

Grazie della spiegazione sei stato molto preciso, e ieri sera ho fatto molti test in fatti credo di aver trovato il problema. Sono andato all'officina elettrica di mio padre e ho preso un voltometro digitale e ho collegato un puntale al comune del piccolo relè e uno al contatto, giusto per vedere cosa succedeva, infatti come sospettavo il tutto funziona correttamente fino a quando ll teleruttore a un cesto punto quando apre il contatto la tensione che ritorna è elevatissima a volte anche 500v, qundi il piccolo relè è impotente difronte a quella tensione poiché ne supporta la metà.

Se non sono stato chiaro ditelo e rispiegherò meglio la cosa! :) :)

buon pomeriggio a tutti! Facendo qualche ricerca per controllare le sovratensioni mi sono imbattuto nel varistore componente passivo che limita la corrente voi che ne dite? io ho trovato questo che limita la corrente massimo a 275v però forse ne devo trovare uno che massimo ne supporta 250v coi che ne dite? quale mi conviene prendere? il piccolo relè massimo supporta 250v ac

Stai confondendo il concetto di corrente con quello di tensione.

Il varistore è un componente che varia la sia resistenza in funzione della corrente che lo attraversa: all'aumentare della corrente aumenta anche la sua resistenza.

Di solito è usato come fusibile autoripristinante.

Nel tuo caso non è di nessun aiuto poiché devi limitare la tensione dovuta all'apertura del circuito a 230V che genera extra tensioni che, come hai già provato, raggungono picchi di 500V.

Ecco perché devi usare lo snubber che ti ho consigliato in parallelo ai contatti del servo relè.

EDIT: o meglio, si può usare anche un varistore ma occorre conoscere altri parametri che solo l'oscilloscopio può fornire.

Ma è normale che ci siano dei picchi, come regola si può dire che le sovratensioni provocate dalla commutazione di carichi induttivi sono tanto più grandi quanto più elevato è il valore dell'induttanza e quanto più piccolo è il tempo di disinserzione. Ciò significa che il massimo valore di sovratensione si avrà con alti valori di induttanza e corti tempi di disinserzione. I valori di sovratensione possono effettivamente raggiungere in alcuni casi anche i 10 kV. Il fatto che tu sia riuscito a leggerlo con un voltmetro digitale mi lascia perplesso.

Ti serve un sopressore per abbattere questi picchi, un condensatore e/o un circuito RC. Fondamentalmente non c'è differenza se il sopressore viene applicato all'utilizzatore oppure all'interruttore, ma il metodo più efficace è quello di applicare un modulo di soppressione dei disturbi direttamente in parallelo al carico induttivo da commutare in questo caso sulla bobina del teleruttore.

Molti teleruttori hanno già a bordo i sopressori integrati tipo Siemens, ABB ...

definizione di sopressore http://it.wikipedia.org/wiki/Soppressore#Snubber_RC

Snubber Calculator http://www.daycounter.com/Calculators/Snubbers/Snubber-Design-Calculator.phtml

Le resistenze dipendenti dalla tensione, dette anche varistori, sono poco conosciute ed usate dai dilettanti di elettronica ... è scritto qui non lo dico io :) http://www.circuitielettronici.it/varistori.htm

cyberhs: Un valore valido per i 230V potrebbe essere R = 120 ohm e C = 0.1 uF = 100 nF con una tensione di lavoro di almeno 400V (meglio 600V).

Scusa cyberhs come hai calcolato questo valore? dissipazione della R in W?

ciao

michele1996: io ho trovato questo che limita la corrente massimo a 275v quale mi conviene prendere? il piccolo relè massimo supporta 250v ac

Penso tu abbia trovato un MOV a 275VAC tipo S14K275 o equivalente, va benissimo, mettilo in parallelo alla bobina del teleruttore e vedrai che risolvi il problema, sei stato bravo ad arrivare alla soluzione

E costano poco, un sopressore RC costa parecchio da 20 a 50 euro, ne ho visti diversi varistori addirittura saldati sul primario del trafo, ma a quanto leggo in giro non sono largamente usati. Bho!!

State dicendo tante cose ma non ho ancora capito se devo usare uno snubber o il varistore, da quanto ho capito con il varistore spendo molto meno che con lo snubber. Quindi ho fatto qualche ricerca e ho trovato questo potrebbe andare bene?

http://www.ebay.it/itm/5-Varistori-S10K275-275V-MOV-varistore-soppressore-/161100558953?pt=Altro_Elettronica_e_Elettricit%C3%A0&hash=item2582577269

Quindi il varistore lo inserirò in parallelo alla bobina del teleruttore e dovrebbe andare bene(almeno spero).

Scusa pablos ma cosa intendi quando dici:

Le resistenze dipendenti dalla tensione, dette anche varistori, sono poco conosciute ed usate dai dilettanti di elettronica ... è scritto qui non lo dico io .

C'é anche scritto: perché, grazie alle loro peculiari caratteristiche, sono ottimamente adatti per proteggere i circuiti elettronici ed i semiconduttori contro le tensioni eccessive.

Pablos e Michele devo correggermi in quanto sono io che ho fatto confusione tra varistore e PTC.

il varistore varia la sua resistenza in funzione della tensione: quindi prendendo un varistore da 400V (superiore alla tensione di picco di rete che è 324V) si dovrebbe risolvere il problema, anche se il sistema migliore è lo snubber.

Quanto al dimensionamento dello snubber, dobbiamo ricordare che siamo in regime alternato e che quindi la reattanza del condensatore non deve essere troppo bassa (capacità più alta).

Con 100nF, ad esempio, la corrente che circola nel circuito è di 7 mA con Xc = 1 / (2 * PI * f *C).

In funzione di questo si calcola la resistenza in serie e la sua potenza.

non sono un esperto come quelli sopra, quindi prendila con le pinze.
anche io avevo problemi con le bobine in generale perchè arduino e abbastanza sensibile, allora per liberarmi delle correnti parassite ho adottato un phototransistor come fanno negli ups per pc per proteggere l’USB.
in poche parole consiste in un led che attiva un fotodiodo lasciando passare corrente, cosi puoi tenere i due circuiti “quasi” separati

http://www.cosmo-ic.com/object/products/k1010.pdf