[RISOLTO] Conflitto tra cicli "for" e sketch di zero_crossig

[capitankevin]

Salve a tutti altro sketch ed altro problema:

Qualche giorno fa ho creato un circuitino per dimmerare le resistenze degli accumulatori di acqua calda che lavorano con il fotovoltaico.
Il programma in pratica prende la potenza prodotta dai pannelli la confronta con quella utilizzata (frigorifero lavatrice ecc) e se la differenza è sopra un dato valore attacca le resistenze elettriche e fa acqua calda per il sanitario o per il riscaldamento.
Ora siccome sono resistenze elettriche ho pensato bene di tirare via i rele' e metterci dei dimmer con zero_crossing
Lo sketch da solo funziona (a parte la resistenza da mettere e per questo ringrazio Uwe) ma quando lo aggiungo allo sketch che mi gestisce le potenze nella seriale non leggo più niente e probabilmente arduino si impalla.
C'e qualche accorgimento in particolare da seguire visto che il programma è praticamente tutto sul void setup?
Sembra come se arduino cercasse di inizializzare la seriale senza riuscirci

[capitankevin]

Ci ho lavoricchiato un po' (ed infatti ho cambiato il titolo) ed ho capito che ad impallare lo sketch sono i cicli "for" che utilizzo per leggere i sensori di tensione corrente etemperatura e che poi Arduino calcola le relative medie.
Portroppo se elimino i cicli for lo sketch mi funziona ma i valori di corrente e tensione (e quindi di potenza) mi oscillano troppo.

Qualcuno ha qualche idea?
la parte che crea problemi è questa

 for (i=0; i<500;i++) // leggo 500 valori del sensore
  {
  Tensioneingresso = analogRead (A3); //rilevo la tensione della rete elettrica
  Tensione_rete = Tensioneingresso*500/1024; //Determino la variabile della tensione
  sommatensioni=sommatensioni+Tensione_rete;
  delay(2);
  }  
  Tensione=(sommatensioni/500); // determino la media dei valori
  sommatensioni=0; //azzero la variabile
  
  for (i=0; i<500;i++) // leggo 500 valori del sensore 
  {
  Correnteingresso1 = analogRead (A1);// rilevo la tensione raddrizzata al potenziometro fotovoltaico
  Correntefotovoltaico=Correnteingresso1*25/1023; // Determino la variabile delle corrente prodotta
  sommacorrenti1=sommacorrenti1+Correntefotovoltaico;
  delay(2);
  }
  Corrente1=sommacorrenti1/500;
  sommacorrenti1=0;
  
  for (i=0; i<500;i++) // leggo 500 valori del sensore 
  {
  Correnteingresso2 = analogRead (A2); // rilevo la tensione raddrizzata al potenziometro fotovoltaico
  Correnteutenza = Correnteingresso2*25/1023;
  sommacorrenti2=sommacorrenti2+Correnteutenza;
  delay(2);
  }
  Corrente2=sommacorrenti2/500;
  sommacorrenti2=0;
  
  Potenza1=(Tensione*Corrente1*0.9); // calcolo la potenza prodotta con cosfi=0,9
  delay(50);
  Potenza2=(Tensione*Corrente2*0.9); // calcolo la potenza utilizzata con cosfi=0,9
  delay(50);

mentre lo sketch che funziona lo mando in allegato

dimmer_per_boiler_3.ino (4.44 KB)

[Maurotec]

Ho modificato il codice dentro al loop per far si che stampi su seriale una volta al secondo.

  }                                 
}             

unsigned long printTimer = 0;  // aggiunta variabile per il timer di stampa
                        
void loop() { 
  
  // programma per il bilancio delle potenze elettriche

       dim=128-(Potenza_dimmer_boiler/10.16);
  
  if (printTimer == 0)
	printTimer = millis();
  if ( (millis() - printTimer) < 1000 ) 
	return;
  printTimer = 0; 
  
  Serial.print ("Tensione di rete  ");
  Serial.println(Tensione);// invio il valore di tensione

 Serial.print (" LIVELLO DIMMER  ");
  Serial.println (dim);
  // rimosso il delay 5000
}

Nel for la cpu sta li 1 secondo e poi ancora ecc, è proprio necessario?
Ti può bastare di fare la media di 10 valori ognuno preso ogni 100ms?

Ciao.

[capitankevin]

Diciamo che non ho bisogno di uno sketch veloce (infatti ho messo un delay 5000) perche mi aggiorni il programma con una certa lentezza perche quello che mi interessa è avere valori stabili.
Il fatto è che non capisco perchè si impalla in teoria dovrebbe fare i suoi cicli "for" metterci anche 5 secondi e poi eseguire il resto.
Lo sketch senza il dimmer funziona bene è lento nella parte del fotovoltaico ma funziona.
Purtroppo lo sketch completo abbastanza grosso con un altro "for" per la rilevazione di una temperatura data ed ora soglie comandi relè.
La cosa che più mi interessa è capire il motivo perchè se mi ricapita almeno so cosa fare.

Ti ringrazio molto per l'aiuto domani ci riprovo per ora

[leo72]

@capitankevin:
per favore, le prox volte includi il codice usando gli appositi tag

[capitankevin]

Lo so scusami Leo ma l'ho fatto per distinguere i due codici altrimenti si poteva creare confusione
Scusa

[leo72]

Li dividi in più blocchi distinti come ha fatto Mauro.
Edita il tuo post se vuoi ridividere il codice, io l'ho riunito in un unico blocco.

[capitankevin]

Ok terro a mente e scusami ancora.

Ho provato a modificare il codice con i consigli di Mauro ma niente,non va, si impalla e non dimmera.
Mi sa che i "for" proprio non li digerisce.

C'e qualche altro sistema per fare la media dei valori ?
Purtroppo senza una media di valori la tensione mi oscilla anche di 20 volt considerando che la prendo tramite un tasfo 220/6 volt raddrizzata con ponte di graetz co diodi a bassa impedenza , condensatore per il ripple e partitore di tensione regolabile ( mi arriva bella raddrizzata ed ad onda quasi piatta a 2,30 volt e cioè con rapporto 1/100)
Per la corrente vale lo stesso, uso due TA, trimmer per lo shunt, ponte di graetz e condensatore per il ripple.

Quindi (penso) dei bei segnali. 8)

[leo72]

capitankevin:
Ho provato a modificare il codice con i consigli di Mauro ma niente,non va, si impalla e non dimmera.

Pubblica il codice che non ti funziona.

[Maurotec]

Ho modificato il codice. Versione: 4
Modificato il nome "i" in zeroCrossCounter
Modificato il nome "dim" in dimmerValue
Aggiunta funzione serialDump()
Temporizzata la chiamata a serialDump()
Commentato i delay, rimuovili tu, significa ripulisci il codice e poi allegalo al post, nel nome fai comparire il numero
di revisione superiore a 4.

Mi accorgo ora che: zero_cross e fuori coerenza, quindi zeroCross.
Decidi le regole per chiamare le variabili e mantieni coerenza in tutto il codice.
Tutte le variabili coinvolte nella routine di interrupt devono essere dichiarate "volatile"

Queste modifiche risolvono il problema? no non lo so, ma di sicuro aiutano la comprensione del codice,
e questo semplifica la risoluzione dei problemi.

#include <TimerOne.h>           
#include <Wire.h>

//volatile int i=0;               	// Variabile volatile per i conteggi
volatile byte zeroCrossCounter = 0; 	// Variabile volatile per i conteggi
volatile boolean zero_cross=0;  	// Variabile per dire al controllore quando la sinusoide passa per zero
int AC_pin = 9;                 // Variabile di uscita per l'opto-triac del puffer
int POT_pin = A0;               // Pot for testing the dimming
//int dim = 0;                    // Livello dimmer (0-128)  0 = on, 128 = 0ff   
volatile byte dimmerValue = 0;                    // Livello dimmer (0-128)  0 = on, 128 = 0ff   
int freqStep = 75;              // Ritardo all'accensione dell'opto-triac in microsecondi

      // Variabili della sezione fotovoltaico
int analogPin1 = A1; // Variabile dell'ingresso in tensione potenziometro di SHUNT del fotovoltaico
int analogPin2 = A2; // Variabile dell'ingresso in tensione potenziometro di SHUNT dell'utenza
int analogPin3 = A3; // Ingresso sensore della tensione di rete
float Correnteingresso1 = 0;// Variabile del dato in ingresso in corrente dal fotovoltaico
float Correntefotovoltaico = 0; 
float sommacorrenti1 = 0;
float Corrente1 = 0;//corrente prodotta
float Correnteingresso2 = 0;// Variabile del dato in ingresso in corrente dall'utenza
float Correnteutenza = 0;
float sommacorrenti2 = 0;
float Corrente2 = 0; //corrente consumata
float Tensioneingresso = 0;  //Variabile del dato in ingresso in tensione
float Tensione_rete = 0; // Tensione di rete elettrica
float sommatensioni = 0;
int Tensione = 0;
int Potenza1;  // Potenza prodotta dal fotovoltaico (arrotondata per difetto nei decimali)
int Potenza2;  // Potenza utilizzata (arrotondata per difetto nei decimali)
int Potenza_dimmer_boiler =0; // Differenza tra potenze prodotta e consumata

/* Comment: Potenza? cosa è una classe una struct, no un intero e allora perché
   attribuirgli questa importanza? Le variabili iniziano sempre in minuscolo.
   
   La comprensione del codice diminuisce ulteriormente perché ci sono moltissime
   altre variabili semplici che iniziano con il maiuscolo.

   Ci sono variabili dichiarate come "int" ma il loro valore va da 0 255, allora
   leggendo il codice si va in cerca dell'uso negativo di questa variabile, ma si scopre
   poi che non assumerà mai valori negativi, questo accade per tutto il codice
   ed è un inferno capirci qualcosa. 
*/ 
 
void setup() {
  Serial.begin(9600);  // Begin setup
  pinMode(AC_pin, OUTPUT);                              // Definisco il pin di uscita PWM per il triac
  attachInterrupt(0, zero_cross_detect, RISING);        // Metto Interupt sul Pin 2 (interupt 0) per la funzione Zero Cross Detection
  Timer1.initialize(freqStep);                          // Initializzo la libreria TimerOne per la frequenza che mi serve
  Timer1.attachInterrupt(dim_check, freqStep);     
  // Uso la libreria per interrompere la funzione che uso
  // per vedere quando è l'istante corretto per accendere 
  // l'opto-triac.
  // La funzione riprederà ogni "freqStep" in microsecondi                                      
}

void zero_cross_detect() {   
  zero_cross = true;             // setto la variabile booleana quando è passato l'impulso di zero_crossing
  zeroCrossCounter = 0;		 // reset time step counter                         
  digitalWrite(AC_pin, LOW);
}                                 

// Accendo il TRIAC al ritardo corretto
void dim_check() {                   
  if(zero_cross == true) { 
            
    if(i>=dimmerValue) {                     
      digitalWrite(AC_pin, HIGH);  	// accendo il led dell'opto_triac 
      
      zeroCrossCounter = 0;  		// reset time step counter                         
      zero_cross=false;    		// reset zero cross detection

    } else {

      zeroCrossCounter++;  		// increment time step counter                     

    }                               
  }                                 
}

unsigned long printTimer = 0;  // aggiunta variabile per il timer di stampa           
                          
void loop() { 
  
  // programma per il bilancio delle potenze elettriche
  
  Tensioneingresso = analogRead (A3); //rilevo la tensione della rete elettrica
  Tensione = Tensioneingresso*500/1024; //Determino la variabile della tensione
   
  Correnteingresso1 = analogRead (A1);// rilevo la tensione raddrizzata al potenziometro fotovoltaico
  Corrente1=Correnteingresso1*25/1023; // Determino la variabile delle corrente prodotta
  
  Correnteingresso2 = analogRead (A2); // rilevo la tensione raddrizzata al potenziometro fotovoltaico
  Corrente2 = Correnteingresso2*25/1023;
  
  Potenza1=(Tensione*Corrente1*0.9); // calcolo la potenza prodotta con cosfi=0,9
  // delay(50); a che serve qui??
  Potenza2=(Tensione*Corrente2*0.9); // calcolo la potenza utilizzata con cosfi=0,9
  // delay(50); a che serve qui??	
  
  Potenza_dimmer_boiler = ( Potenza1-Potenza2 );
  
  dimmerValue = 128 - ( Potenza_dimmer_boiler/10.16 ); 
  
  if (printTimer == 0)
	printTimer = millis();			// load timer value

  if ( (millis() - printTimer) > 1000 ) { 	// check timeout

	serialDump();				
  	printTimer = 0; 			// reset timer

  }
   
}

/** 
   static void serialDump() 
   Print data to serial out
*/
static void serialDump()
{
  Serial.print ("Tensione di rete  ");
  Serial.println(Tensione);// invio il valore di tensione
  Serial.println (" ");
  Serial.print ("Potenza prodotta  ");
  Serial.println (Potenza1);// invio il valore della potenza prodotta dal fotovoltaico
  Serial.print ("Potenza utilizzata  ");
  Serial.println (Potenza2);// invio il valore della potenza assorbita dall'utenza
  Serial.println (" "); 
  Serial.print ("Potenza disponibile  ");
  Serial.println (Potenza_dimmer_boiler); 
  Serial.print (" LIVELLO DIMMER  ");
  Serial.println (dimmerValue);
}

[capitankevin]

Ok questo è il codice completo (anche con la modifica suggerita da Mauro tec).
Il pin di uscita del boiler ( pin3 =8) è anche reindirizzato all' ingresso(pin5=4) ho buttato un uscita ma una volta applicato il secondo dimmer ritornerà libera.
I dimmer pertanto saranno 2 (appena realizzo il secondo triac).
Alla seriale leggo fino alla data e ora poi si blocca (quindi già al primo ciclo "for")
Come vedi la uno è FULL infatti poi passo tutto su MEGA sperando che non cambi molto lo sketch

Il problema è che mi serve una certa velocità nell'aggiornamento altrimenti il dimmer non segue il fotovoltaico ma la stampa nella seriale la posso mandare anche ogni 5 o 10 secondi perchè poi va fatto un grafico con visual basic (se non mi mandano prima alla neuro)

Ultima cosa: finito questo lavoro mi piacerebbe condividerlo mettendo tutti gli schemi elettrici ( anche dell'altra scheda) che gestisce il circuito idraulico ed i touch-screen.
Naturalmente tutti fatti in autocad e spiegati (quindi una bella cosina fatta bene).
Mi piacerebbe sapere solo dove pubblicarlo e se può interessare.

Grazie ancora

Gestione_circuito_idraulico_di_alta_con_RTC_e_controllo_T_A_e_1.ino (12 KB)

[Maurotec]

Hai introdotto le mie modifiche nel modo sbagliato, quello nuovo che ho postato evita fraintendimenti.
PS: vedi che devi leggere e capire cosa fa il codice che ti propongono di aggiungere, diversamente si incasina tutto
tu sei quello che decide se è quando e dove inserire il codice suggerito, ma per farlo devi capire nel dettaglio.

Sistema il codice prelevando porzioni dal codice che ho postato. Fai il refactor di ogni variabile secondo consiglio, in questo punto non transigo ( se devo leggerlo e capirlo ho bisogno di coerenza e qualità del codice ).

Ciao.

[capitankevin]

Il problema è che con voi Arduino è una Ferrari..... mentre con me e ancora una Balilla =(
Però non demordo 8)
Quindi: 1 analizzo il codice. 2 vi faccio un po di domande sceme. 3 spero comprendiate la mia ignoranza.

Intanto grazie di cuore

[capitankevin]

Ho dat un occhiata ai commenti e vorrei chiedere una cosa:
La variabile semplice va dichiarata con le minuscole questo è da tenere a mente.
Il concetto di variabile int che va da 0 a 255 non ho ben capito, a cosa si riferisce?
Nel codice non ci sono valori negativi.

Se mi puoi fare un esempio ti ringrazio molto

[Maurotec]

La variabile semplice va dichiarata con le minuscole questo è da tenere a mente.

Ogni parola usata nel nome della variabile inizia con la maiuscola tranne la prima parola.
Il primo carattere minuscolo, es.
nParameter : // si capisce che conterrà il numero di parametri.
numberParameter: // ancora più esplicito di nParameter

dummyVar : // Variabili da buttare, cioè la dichiari e la usi dentro una funzione.
int dummyVar;

dummyVar = 5 + 8 / ecc.

Dalla dichiarazione all'ultimo uso della variabile non ci devono essere troppe righe di codice, 5-10 righe non oltre.

1. nonTrovoNomeGiustoPerLaMiaVariabile, lungo da scrivere, ma molto esplicativo.
   oppure
2. non_trovo_nome_giusto_per_la_mia_variabile, chilometrico

Devi scegliere ed essere coerente lungo tutto il codice. Comunque la scelta con
arduino è quasi obbligata o meglio per rimanere coerenti con gli esempi di codice
forniti con l'ide e con il linguaggio C++ si deve usare la forma (1)

Tipi base di Arduino:
Tipo Dimensione/descrizione Range
byte: 8 bit senza segno 0 a 255
int : 16 bit con segno -32.768 a 32.767
unsigned int 16 bit senza segno 0 a 65.535
long 32 bit con segno -2.147.483.648 a 2.147.483.647
unsigned long 32 bit senza segno 0 a 4.294.967.295

Ho moltiplicato a per e e diviso per o. Ma se la leggo io domani non la capisco.
Ho moltiplicato alfa per epsilon e diviso per omega, ora è più chiaro, alfa epsilon e omega sono gli operandi.

Stessa cosa vale nel codice sorgente:
i, e, a, t, x, z, p, k, j ecc sono nomi corti e corta deve essere la loro vita. Possono essere usati
come indici locali, come contatori nel for, while ecc. Appena il codice supera le 5-10 righe
modificare il codice per spezzarlo in più funzioni oppure cambiare nome agli indici allungando e
dandogli un nome più esplicativo.

Il codice lo scrivi tu, ma lo devono capire anche gli altri e dobbiamo fare anche in fretta, e ci riusciamo se il
codice è scritto senza trabocchetti.

Se lungo il codice vedo la variabile "c" cerco subito il parametro della funzione che sarà sicuramente (char c),
ma non lo trovo, allora cerco a salire dove è stata dichiarata c e scopro che è una variabile globale.
Questo può essere fatto per una variabile ma quando sono tante non si finisce più di cercare le variabili
e quando ne hai memorizzato due tre, ti scordi le altre e devi risalire il codice fino alla dichiarazione.
Non c'è tempo per fare questo, inoltre è facilissimo andare in confusione e non capirci più niente e
alla fine si abbandona e si lasci l'utente ai suoi guai.

Leggendo la parte iniziale del codice si cerca di memorizzare il nome delle variabili e il tipo, principalmente se
è con segno o meno. Quindi se mi usi il tipo "int" per "dim" io penso che c'è un motivo e che quindi la variabile può
assumere valori negativi. Poi scopro che il range per la variabile dim è da 0 a 128, allora il tipo byte è quello più
appropriato, anche perché ci fa risparmiare un byte 8 bit rispetto a "int" che ne occupa 16 di bit.

Poniti il problema:
Il codice che hai scritto oggi deve esserti comprensibile anche fra due anni, il codice scritto bene lo è, quello scritto
male fai fatica a comprenderlo da subito, figuriamoci fra un mese. Purtroppo è noioso, impiegare tempo
per trovare il nome ad una variabile, ma si la chiamo a, a? dopo due mesi riprendi in mano il codice per apportare
una modifica e tra 500 nomi di variabili tu ti ricordi di aver chiamato una variabile a, mai non accadrà mai e quindi
appena non sai come chiamare un variabile, ma si la chiamo a che già esiste, e ti va bene che c'è il compilatore che
te lo fa notare, ma alle volte si ingarbugliano tanto le cose che per il compilatore tutto è in regola ma il programma
non funzione. Te ne freghi tanto fra due anni non leggerai più il vecchio codice, si ma lo devono anche leggere
gli altri e non possono dedicarci 3 ore. Es quel codice scritto bene si capisce cosa fa in meno di 10 minuti (assai sono).

Spero ti sia utile quanto scritto, ma considera che è niente confronto a quello che puoi imparare leggendo
un libro, cosa che ti consiglio di fare.

Ciao.

[leo72]

capitankevin:
La variabile semplice va dichiarata con le minuscole questo è da tenere a mente.

Non è comunque una regola stringente, ossia che il compilatore non emette errore se usi una var con una iniziale Maiuscolta oppure se metti tutto MAIUSCOLO.
Convenzionalmente si tendono ad usare nomi tutto in minuscolo, esempio: contatore, oppure in camelCase, ossia più parole concatenate dove l'iniziale si mette maiuscolo per favorire la lettura, esempio: contatoreImpulsiSensore.
Un esempio di costante: LED_PIN.

Il concetto di variabile int che va da 0 a 255 non ho ben capito, a cosa si riferisce?
Nel codice non ci sono valori negativi.

Lavorando su una MCU con poca memoria, la scelta del tipo va fatta in base a una regola molto semplice: usare sempre il tipo di dato che occupa meno spazio in memoria ma che nel contempo sia capace di contenere tutto il range di valori che il tuo dato potrà assumere. Se leggi un pin analogico, hai un dato che va da 0 a 1023 per cui un byte, che può contenere solo 0..255, non ti basta. Ma se devi ad esempio dichiarare una variabile per un pin, che hanno numeri che non passano le 2 cifre, puoi usare il byte. Considera anche signed e unsigned: l'occupazione è identica ma il primo ha un range diverso dal secondo perché può contenere anche valori negativi.

[capitankevin]

Ok ora e un po più chiaro di prima e molte cose pensavo fossero diverse
Int per me era un valore intero e basta mentre byte non l'ho mai usato semplicemente perche non sapevo cosa servisse.
Cercherò di modificare il codice secondo i vostri consigli sperando di non incasinarlo invece di semplificarlo comunque la buona volontà ce la metto

[capitankevin]

Sto mettendo mano al codice per vedere se riesco a farlo partire.
Come vi ho gia scritto senza i cicli "for" funziona pertanto basterebbe solo mettere a posto la sintassi.
Ora una domanda:
Le variabili int, byte, char, ecc. le dichiaro sempre all'inizio ( sotto alle righe delle librerie) o le posso dichiarare anche nella parte "loop" del codice?
Questo eviterebbe di dover scorrere il codice fino in cima per vedere cosa gestisce questa o quella variabile.
Finora in tutto quello che ho trovato su arduino le variabili si dichiarano all'inizio ma bisogna considerare che sono tutti sketch piccoli che fanno fare ad Arduino una cosa od un'altra (quindi sotto le 10 - 15 righe e sempre inerenti allo stesso compito).
Quando si mettono insieme più compiti e quindi più funzioni non sarebbe più semplice fare:

// Descrivo il compito della parte di sketch ( es comando di accensione della macchina tizio)

int questo=0;
unsigned int quello=0;
char pin3=0;

  if (questo <quello)

  digitalWrite(pin3,HIGH);

// Comando della macchina caio

int gino=0;
int franco=0;
eccetera come sopra

Non so se si può fare ma il codice sarebbe molto più chiaro.

[Maurotec]

Al momento non ti preoccupare del fatto che le variabili sono tutte li in alto, affronta il problema variabili dal lato corretto. Le variabili globali sono visibili ed esistono per tutta la durata del programma, cioè fintanto che arduino è acceso. Le variabili locali che sono quelle interne ad un blocco di codice delimitato da {} vengono create all'entrata del blocco nel punto in cui le dichiari e terminano di esistere sempre alla fine del blocco, insomma sono visibili solo nel blocco di codice in cui le dichiari.

L'accesso alle variabili globali è più lento che quelle locali.

In C/C++ le variabili globali dai programmatori vengono digerite come la peperonata, anzi peggio.
Arduino invece basa la sua semplicità proprio sulle variabili globali, tuttavia con arduino (e in C++) le classi sono tipi utente molto usati e si dovrebbero usare molto più spesso di quello che si vede nelle applicazioni.
Con le classi raggruppi dentro un oggetto dati e funzioni e ciò e comodo e semplifica la manutenzione, purtroppo richiedono di un bel po di cose.

Dovresti affrontare sempre un problema per volta, quindi al momento lascia le variabili globali all'inizio, dagli un nome secondo consigli e posta il codice completo.

Miscelando codice che funziona con quello che non funziona tutto il programma finisce per non funzionare. C'è un modo per evitare che Arduino compili delle porzioni di codice e si basa sull'uso delle direttive del preprocessore C/C++. Tutto quello che inizia con "#" è di pertinenza del preprocessore.

Se scrivi nel codice:

#if (0)
     if (questo <quello)
         digitalWrite(pin3,HIGH);

#endif

Il preprocessore valuta #if (0) come condizione falsa e non compila il codice tra #if e #endif.
Esiste anche #else che funziona nel modo simile al costrutto if (cond) action0; else action1 che conosci e sai usare.
La differenza è che #if viene risolto prima della vera compilazione e permette di includere o meno porzioni di codice.

Ancora più comodo è usare il seguente codice:

#define ENABLE_DISABLE_BUILD_TEST_CODE      0

#if (ENABLE_DISABLE_BUILD_TEST_CODE == 1)
    // il codice qui dentro viene compilato solo se 
   // modifichiamo la direttiva #define così: #define ENABLE_DISABLE_BUILD_TEST_CODE      1
#endif

// altro codice ...
#if (ENABLE_DISABLE_BUILD_TEST_CODE == 1)
     // ogni volta che voglio includere o meno del codice in base alla costante ENABLE_DISABLE_BUILD_TEST_CODE
     // uso #if (ENABLE_DISABLE_BUILD_CODE == ) ecc.
     // come ho fatto qui e sopra
#endif

Ricorda non affrontare tutti i problemi insieme, sempre un problema alla volta, del resto potresti scoprire che
scomponendo un problema in 100 problemi e risolvendone 10 un per volta ti è sufficiente e sei soddisfatto del risultato e ti sei evitato i rimanenti 90 problemi e ce sempre tempo in futuro per occuparti di uno dei 90 problemi rimanenti se ti danno noia.

Le variabili globali le puoi anche dichiarare prima di una funzione creata da te, come ho fatto io per serialDump,
in questo modo e li vicino, non è il modo migliore ma quello migliore ancora non sei pronto per gestirlo, quindi non hai alternative al momento, cioè accontentati e riproponiti in futuro di studiare al fine di migliorare, semplificare, mantenere lo sviluppo del tuo progetto.

Tu hai chiesto un posto dove pubblicare il tuo progetto e ti rispondo che hai l'imbarazzo della scelta. Ci sono repostitor di google, gitorius, github ecc o semplicemente un tuo blog con google o altro di tua preferenza.

Ciao.

[capitankevin]

Ok direi che questo sketch è la base di partenza ed almeno questo funziona dimmera e sta dietro al fotovoltaico.
Secondo voi è corretto come sintassi? E abbastanza coerente?

Problema:
la tensione oscilla troppo (circa 20 volt) come posso stabilizzarla?

Dimmer1.ino (4.22 KB)