e per la precisione...vorresti che facesse SOLO quella cosa li, i setcolor specifici, oppure deve fare anche altro contemporaneamente?...comunque il codice che sti usando è lontano dal fare quello che vuoi e ci sarà da rivedere diverse cose.
ci sto litigando da giorni e infatti capisco le mie lacune ma anche il fatto che non va bene questo, continuo la ricerca
grazie a tutti
Sono di fretta per analizzare il tuo codice, provo a fare una ipotesi concettuale.
Diciamo che hai 13 funzioni possibili.
Da seriale dici quale attivare/disattivare.
Puoi averne attive anche più di una contemporaneamente.
Ti crei 13 variabili o un array a 13 posizioni, dove memorizzare lo stato delle funzioni 1 = acceso, 0 = spento.
Inizializzi la struttura con tutti i valori a 0.
Nel loop chiami queste funzioni in sequenza
verificaComandi
eseguiComandi
la verificaComandi controlla se c'è qualcosa sulla seriale, se non c'è nulla esce subito, se c'è legge cosa c'è e aggiorna di conseguenza le 13 variabili di stato ed esce.
eseguiComandi verifica le 13 variabili di stato e per quelle a 1 richiama il relativo codice che attiva la funzione.
Nel caso dei led, pin 13, finchè non dai il primo comando la sua variabile è a zero, appena la attivi passa a 1 e l'eseguiComandi esegue una singola sequenza, poi finisce il loop e ricomincia.
Finchè non dai lo stop lo stato 13 resta a 1 e quindi ad ogni iterazione del loop viene eseguito nella eseguiComandi un ciclo dei led.
Ti ho fatto più confusione?
Il fatto è che con tutti quei delay non può tenere d'occhio quello che succede!
delay, se li conosci li eviti, se li conosci non ti uccidono 
maubarzi:
delay, se li conosci li eviti, se li conosci non ti uccidono
Ma no :D, a volte sono comodi, dipende sempre da quello che devi fare ...
... se devi solo aspettare e non servire altri eventi, il delay() va più che bene ed e comodo, se invece devi ritardare un qualche cosa, ma contemporaneamnete svolgere altro ... ovviamnete non li puoi usare
Guglielmo
Per una cosa del genere bisogna prendere il tempo appena viene rilevato un input (io solitamente uso variabili unsigned long t0, t1, t2...), poi svolgere le varie operazioni se millis()-t0 è <1000, else <2000, else <3000 ecc.
Comunque, quegli effetti li farei parecchio più lenti e ripetuti di come si vede su YouTube.
Anche il cianuro ha campi di applicazione utili ;D ma se lo conosci lo eviti, se lo conosci non ti uccide
comunque si, hai ragione, ci sono casi molto semplici dove "va più che bene ed e comodo" :-[
maubarzi:
comunque si, hai ragione, ci sono casi molto semplici dove "va più che bene ed e comodo" :-[
... e non pensare solo a delay(), ma anche a delayMicroseconds() ... entrambe estremamente utile specie se stai scrivendo un qualche driver e la sequenza di comandi da inviare deve rispettare dei precisi tempi di attesa tra un comando ed il successivo. Apri il driver del LCD e guarda il metodo begin() ... t'accorgerai di quante ce ne stanno 
Guglielmo
Apposta ogni volta che deve scrivere qualcosa perde un sacco di tempo! (sono le temporizzazioni richieste dal display, lo so :D)
care vecchie interrupt, dove siete finite? troppo poche e troppo care...
maubarzi:
care vecchie interrupt, dove siete finite? troppo poche e troppo care...
... ci fai poco con una sequenza di inizializzazione ... tanto fermo li devi stare quando inizializzi l'hardware e fino a quando non è pronto ... :
Guglielmo
Dipende, stiamo entrando sul filosofico però, da come progetti ad ogni livello e dall'ambito specifico.
Potresti strutturare le cose per inizializzare in background e ovviamente rendere il dispositivo disponibilie solo a inizializzazione terminata.
Approccio più complicato sicuramente ma eviti certe attese iniziali che in alcuni ambiti possono essere fastidiose o addirittura dannose.
I delay sono un giusto compormesso per semplificare le cose che altrimenti sarebbero troppo complicate.
Qui siamo su Arduino, quindi 
Signori Buongiorno.
Come da vostri suggerimenti, mi sono andato a cercare qualche esempio in giro ed ho trovato questa lezione con questo esempio di Michele Maffucci che mi sembra adeguata al mio caso.
/*
Autore: Michele Maffucci
data: 10.01.13
Uso delle funzioni esterne
*/
const int INDICE_PIN = 4; // definisce una costante per il numero di pin
int pinPulsanti[INDICE_PIN] = {2,3,4}; // create un array of pin per gli input
// costituiti dai pulsanti
int pinLed[INDICE_PIN] = {9,10,11}; // crea un array di pin di output per il LED
void setup()
{
for(int indice = 0; indice < INDICE_PIN; indice++)
{
pinMode(pinLed[indice], OUTPUT); // dichiara il LED come output
pinMode(pinPulsanti[indice], INPUT); // dichiara il pulsante come input
// digitalWrite(pinPulsanti[indice],HIGH); // abilita la resistenza di pull-up
// l'abilitazione della resistenza di pull-up mi permette di non utilizzare
// una resistenza esterna in serie al pulsante
}
}
void loop(){
for(int indice = 0; indice < INDICE_PIN; indice++)
{
int val = digitalRead(pinPulsanti[indice]); // legge il valore di input
if (val == HIGH) // controlla se il pulsante è premuto
{
if (indice == 0)
{
blink1(pinLed[indice],100);
}
if (indice == 1)
{
blink2(pinLed[indice],100);
}
if (indice == 2)
{
blink3(pinLed[indice],100);
}
}
else
{
digitalWrite(pinLed[indice], LOW); // spegne il LED
}
}
}
void blink1(int pin, int tempo)
{
for (int contatore=tempo; contatore>10 && contatore <= tempo; contatore=contatore-10)
{
digitalWrite(pin, HIGH); // accende il LED
delay(contatore); // attende 50 millisecondi
digitalWrite(pin, LOW); // spegne il LED
delay(contatore); // attende 50 millisecondi
}}
void blink2(int pin, int tempo)
{
for (int contatore=tempo; contatore>10 && contatore <= tempo; contatore=contatore-10)
{
digitalWrite(pin, HIGH); // accende il LED
delay(contatore); // attende 100 millisecondi
digitalWrite(pin, LOW); // spegne il LED
delay(contatore); // attende 100 millisecondi
}}
void blink3(int pin, int tempo)
{
for (int contatore=tempo; contatore>10 && contatore <= tempo; contatore=contatore-10)
{ digitalWrite(pin, HIGH); // accende il LED
delay(contatore); // attende 150 millisecondi
digitalWrite(pin, LOW); // spegne il LED
delay(contatore); // attende 150 millisecondi
}}
per prima cosa vorrei sapere se ho preso un esempio giusto, per secondo se si, vorrei capire come poter are in modo che ogni funzione cicli finchè non ri premo il pulsante che l'ha chiamata.....in parole povere :
prima pressione parte una funzione che continua finchè non ripremo lo stesso pulsante.
Come sempre Grazie
Array di N variabili booleane
Ogni volta che sento un pulsante nego la variabile posta nella posizione corrispondente.
Controlli boolean per boolean e se é alta esegui la funzione.
Pseudo codice
bool agisco [NUMFUNZIONI];
//setup
//in loop
{
byte numcomando=OttieniInput();
agisco [numcomando]=!agisco[numcomando];
if (agisco [0])
{FunzioneZero();}
if (agisco[1])
{FunzioneUno();}
//continua
Se poi fai un array di puntatore a funzione trasformi la serie di if in quattro righe circa.
Buongiorno a tutti e Buon Natale.
Sempre seguendo i vostri aiuti sto cercando di capire le istruzioni " bool "
Ho trovato un esempio che mi sembrerebbe adeguato per capire come risolvere il problema iniziale,
mi sono fermato su queste righe:
if (ledEnable) ledEnable = 0;
else ledEnable = 1; // Flip ledEnable
break;
non capisco come funziona il bool " ledEnable" , nel senso che non capisco chi le faccia cambiare stato.....
e di conseguenza non capisco come funzionano queste righe..
Grazie
if (ledEnable) ledEnable = 0;
(significa se ledEnable e' "true", ovvero vale 1, mettilo a zero)
else ledEnable = 1;
(significa altrimenti, cioe' se la condizione precedente NON e' vera, quindi ledEnable e' false ovvero a zero, mettilo ad uno)
... anche se forse bastava "ledEnable = !ledEnable" (che significa semplicemente "inverti lo stato di ledEnable" in questo caso)... pero' dipende da tutto il resto ...
Bool dovrebbe essere solo il tipo di variabile, "boleana", cioe' che puo essere solo 1 o 0, true o false ...
traducile in italiano e diventano:
se ledEnable (che è come scrivere se ledEnabled è vero)
allora ledEnabled = 0 (funziona anche se concettualmente è sbagliato, bisognerebbe scrivere = false)
altrimenti (cioè se ledEnable è =0)
ledEnable = 1 ((funziona anche se concettualmente è sbagliato, bisognerebbe scrivere = true)
fine se
quindi supponendo che all'inizio la dichiarazione della variabile sia:
bool ledEnable = 0 (che corrisponde a false)
la prima volta che viene eseguito quel pazzo di programma essendo ledEnable=0 non estrerà nell'if ma entrerà nell'else (tradotto altrimenti) e quindi lledEnable diventerà = 1
al giro successivo essendo =1 entrerà nell'if e ledEnable diventerà =0
e così all'infinito
quindi un giro sarà = 0
e un giro sarà = 1
kemosabesay:
come poter are in modo che ogni funzione cicli finchè non ri premo il pulsante che l'ha chiamata.....in parole povere :
prima pressione parte una funzione che continua finchè non ripremo lo stesso pulsante.
Direttamente preso dal mondo ladder... non so se esiste qualcosa di più semplice:
pressed = (digitalRead(...) == PRESS_LEVEL);
if (pressed && !prec_pressed) { enable = !enable; }
prec_pressed = pressed;
if (enable) { func(); }
Tutte variabili bool, o byte, o uint8_t.
'enable' e 'prec_pressed' devono essere persistenti, quindi o globali oppure locali static.
NOTA: si da per scontata la presenza di un debounce hardware.
Dopo di che, scrivere tante righe con molti nomi diversi per le variabili, o scrivere poche righe usando gli array (come suggerisce Silente), non cambia nulla nel funzionamento, è una scelta soggettiva.
Ok grazie mi avete sboccato un pezzo grazie