Problema con il codice 3 LED ed il sensore Ultrasoninc Sensor HC-SR04

Salve, ho un problema con il codice Arduino, sono alle prime armi quindi mi scuso se magari sia un errore banale. Spiego in breve, sto utilizzando 3 LED ed il sensore di prossimità Ultrasoninc Sensor HC-SR04, quello che deve succedere è questo:

  • il LED1 deve accendersi in modo incrementale a distanza minore di 10 cm (funziona)
  • il LED2 deve lampeggiare con una velocità a distanza minore di 200cm ed un'altra a distanza minore di 100cm (funziona)
  • Il LED3 deve aumentare di +1 la sua intensità ogni volta che il LED1 si accende, se il LED1 non si accende per un tot di tempo deve diminuire la sua intensità di -1.
    Invio l'ultimo dei codici che ho provato a scrivere, in cui il LED1 e il LED2 funzionano correttamente invece il LED3 rimane sempre spento.

CODICE:


#define echoPin 2 // attach pin D2 Arduino to pin Echo of HC-SR04
#define trigPin 3 //attach pin D3 Arduino to pin Trig of HC-SR04

// defines variables
long duration; // variable for the duration of sound wave travel
int distance; // variable for the distance measurement

int acceso; // variabile che definisce il LED acceso

int lucentezza = 0; // definisce la variabile “lucentezza” con valore iniziale 0
int incremento = 5; // definisce la variabile “incremento” con valore 5

const int LED1 = 5; // definisce il LED1 sul pin 5
const int LED2 = 6; // definisce il LED2 sul pin 6
const int LED3 = 7; // definisce il LED3 sul pin 7

void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an OUTPUT
  pinMode(echoPin, INPUT); // Sets the echoPin as an INPUT
  Serial.begin(9600); // // Serial Communication is starting with 9600 of baudrate speed
  Serial.println("Ultrasonic Sensor HC-SR04 Test"); // print some text in Serial Monitor
  Serial.println("with Arduino UNO R3");

  pinMode(LED1 , OUTPUT);
  pinMode(LED2 , OUTPUT);
  pinMode(LED3 , OUTPUT);
}
void loop() {
  // Clears the trigPin condition
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin HIGH (ACTIVE) for 10 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2; // Speed of sound wave divided by 2 (go and back)
  // Displays the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  int acceso = 0; // dichiara il valore di "acceso"

  if ( distance < 10 ) // a distanza 10cm il LED1 si accende
  {
    analogWrite (LED1, lucentezza); // invia al LED1 una tensione pari a (5/255) * lucentezza
    lucentezza = lucentezza + incremento; // modifica il valore di lucentezza
    if (lucentezza == 0 || lucentezza == 255) // il simbolo || e’ un operatore booleano che
      // rappresenta la “or” mentre == e’ il simbolo convenzionalmente utilizzato per verificare la
      // condizione di uguaglianza. Non viene utilizzato il normale simbolo = poiche’ il programma lo
      // interpreterebbe come l’assegnazione di un valore es. lucentezza = 0 verrebbe interpretato
      // come “assegna 0 alla variabile lucentezza”
    {
      incremento = incremento * -1; // se la lucentezza ha raggiunto gli estremi ( 0 oppure 255)
      // cambia segno all'incremento (lo si moltiplica per -1 e quindi se
      // era 5 lo fa diventare -5 e viceversa)
    }
    delay (10); //attende 50 millisecondi prima di ricominciare il ciclo

    acceso = (acceso + 1 / 255); // variabile locale

  }
  else
  {
    digitalWrite(LED1, LOW);
  }


  if ( distance < 200 ) // se la distanza è 200cm il led lampeggia più lentamente

  {
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
  }
  {
    analogWrite (LED2, lucentezza); // invia al LED2 una tensione pari a (5/255) * lucentezza
    lucentezza = lucentezza + incremento; // modifica il valore di lucentezza
    if (lucentezza == 0 || lucentezza == 255) // il simbolo || e’ un operatore booleano che
      // rappresenta la “or” mentre == e’ il simbolo convenzionalmente utilizzato per verificare la
      // condizione di uguaglianza. Non viene utilizzato il normale simbolo = poiche’ il programma lo
      // interpreterebbe come l’assegnazione di un valore es. lucentezza = 0 verrebbe interpretato
      // come “assegna 0 alla variabile lucentezza”
    {
      incremento = incremento * -1; // se la lucentezza ha raggiunto gli estremi ( 0 oppure 255)
      // cambia segno all'incremento (lo si moltiplica per -1 e quindi se
      // era 5 lo fa diventare -5 e viceversa)
      {
        delay (50); //attende 50 millisecondi prima di ricominciare il ciclo
      }
    }
    else
    {
      digitalWrite(LED2, LOW);
    }
    if ( distance < 100 ) // se la distanza è 100cm il led lampeggia più velocemente

    {
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
    }
    {
      analogWrite (LED2, lucentezza); // invia al LED2 una tensione pari a (5/255) * lucentezza
      lucentezza = lucentezza + incremento; // modifica il valore di lucentezza
      if (lucentezza == 0 || lucentezza == 255) // il simbolo || e’ un operatore booleano che
        // rappresenta la “or” mentre == e’ il simbolo convenzionalmente utilizzato per verificare la
        // condizione di uguaglianza. Non viene utilizzato il normale simbolo = poiche’ il programma lo
        // interpreterebbe come l’assegnazione di un valore es. lucentezza = 0 verrebbe interpretato
        // come “assegna 0 alla variabile lucentezza”
      {
        incremento = incremento * -1; // se la lucentezza ha raggiunto gli estremi ( 0 oppure 255)
        // cambia segno all'incremento (lo si moltiplica per -1 e quindi se
        // era 5 lo fa diventare -5 e viceversa)
        {
          delay (50); //attende 50 millisecondi prima di ricominciare il ciclo
        }
      }
      else
      {
        digitalWrite(LED2, LOW);
      }
      {
        analogWrite (LED3, acceso); // ogni volta che si accende il LED1, il LED 3 aumenta di +1 la sua intensità
      }
      delay (50); //attende 50 millisecondi prima di ricominciare il ciclo
    }
  }
}

Ciao. Mi sembra che tu abbia dichiarato erroneamente e utilizzato la variabile 'acceso'. Ci sono 2 volte - come globale e locale. Immagino che se rimuovi la dichiarazione locale il programma funzionerà.

Ciao, grazie per la risposta, ho provato ad eliminare la variabile locale, ma il LED3 continua a non accendersi, comunque avevo aggiunto la variabile locale sotto il LED1 perché da come ho capito (probabilmente sbagliato) la variabile locale "acceso=acceso+1/255" doveva far aumentare di 1 l'intensità del LED3 ogni volta che l'intensità del LED1 arrivava a 255 e nel momento in cui ponevo un successivo codice come analogWrite (LED3, acceso).

@ale_00 : Buongiorno, prima di tutto ti segnalo che, nella sezione in lingua Spagnola, si può scrivere SOLO in Spagnolo ... quindi, per favore, la prossima volta presta più attenzione in quale sezione metti i tuoi post; questa volta esso è stato spostato, da un moderatore della sezione di lingua Spagnola, nella sezione di lingua Italiana ... la prossima volta potrebbe venire direttamente eliminato, dopo di che ...

... essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con molta attenzione tutto il succitato REGOLAMENTO ... Grazie. :slight_smile:

Guglielmo
P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione nell’apposito thread, nel rispetto del suddetto regolamento nessuno altro ti risponderà (eventuali risposte verrebbero cancellate), quindi ti consiglio di farla al più presto. :wink:


@flashko : Ti prego, prima di rispondere, di verificare sempre se l'utente abbia effettuato la presentazione, (basta verificare nel profilo utente) e di attendere a rispondere sino a quando l'utente non abbia admpiuto al nostro REGOLAMENTO. Grazie anticipatamente per la
collaborazione.

ciao. secondo me ci sono alcune cose da sistemare:

  • tieni solo la variabile globale come dice @flashko
  • ci sono diverse parentesi graffe aperte / chiuse inutilmente che probabimente fanno fare allo sketch cose diverse da quelle che pensi
  • quetsa riga acceso = (acceso + 1 / 255); non credo faccia quello che vorresti facesse... occhio alla precedenza degli operatori aritmetici

sistemate queste cose vedi come si comporta lo sketch.

ciao, grazie a tutti per aver risposto, ho risolto alcuni problemi ma ne sono nati altri, il codice che sto inoltrando funziona per quanto riguarda l'incremento del LED3 di + 1, però ha problemi con i delay (ci sono troppi delay e quindi il fade del LED1 va troppo lentamente.) e non funziona il decremento di -1 in funzione del tempo.

#define echoPin 2 // attach pin D2 Arduino to pin Echo of HC-SR04
#define trigPin 3 //attach pin D3 Arduino to pin Trig of HC-SR04
// defines variables
long duration; // variable for the duration of sound wave travel
int distance; // variable for the distance measurement
int acceso; // variabile che definisce il LED acceso
int lucentezza = 0; // definisce la variabile “lucentezza” con valore iniziale 0
int incremento = 15; // definisce la variabile “incremento” con valore 5
int lucentezzaLED3 = 0; // definisce la variabile “lucentezza” con valore iniziale 0
int incrementoLED3 = 5; // definisce la variabile “incremento” con valore 5
const int LED1 = 5; // definisce il LED1 sul pin 5
const int LED2 = 6; // definisce il LED2 sul pin 6
const int LED3 = 10; // definisce il LED3 sul pin 10
void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an OUTPUT
  pinMode(echoPin, INPUT); // Sets the echoPin as an INPUT
  Serial.begin(9600); // // Serial Communication is starting with 9600 of baudrate speed
  Serial.println("Ultrasonic Sensor HC-SR04 Test"); // print some text in Serial Monitor
  Serial.println("with Arduino UNO R3");
  pinMode(LED1 , OUTPUT);
  pinMode(LED2 , OUTPUT);
  pinMode(LED3 , OUTPUT);
}
void loop() {
  // Clears the trigPin condition
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin HIGH (ACTIVE) for 10 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2; // Speed of sound wave divided by 2 (go and back)
  // Displays the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
  int acceso = LED1, lucentezza; // dichiara il valore di "acceso"
  if ( distance < 10 ) // a distanza 10cm il LED1 si accende
  {
analogWrite (LED1, lucentezza);
lucentezza = lucentezza + incremento;
if (lucentezza == 0 || lucentezza == 255)
 {
 incremento = incremento *-1;
 }
delay (1); //attende 50 millisecondi prima di ricominciare il ciclo
}

  else
  {
    digitalWrite(LED1, LOW);
  }
  {
    acceso = lucentezza + incremento;
    analogWrite (LED3, acceso); // ogni volta che si accende il LED1, il LED 3 aumenta di +1 la sua intensità
    if (lucentezzaLED3 == 0 || lucentezzaLED3 == 255)
    {
      incrementoLED3 = incrementoLED3 * -1;
    }
    delay (1000);
  }
  if ( distance < 200 ) // se la distanza è 200cm il led lampeggia più lentamente
  {
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
    digitalWrite(LED2, HIGH);
    delay(150);
    digitalWrite(LED2, LOW);
    delay(80);
  }
  {
    analogWrite (LED2, lucentezza);
    lucentezza = lucentezza + incremento;
    if (lucentezza == 0 || lucentezza == 255)
    {
      incremento = incremento * -1;
      {
        delay (50);
      }
    }
    else
    {
      digitalWrite(LED2, LOW);
    }
    if ( distance < 100 ) // se la distanza è 100cm il led lampeggia più velocemente
    {
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
      digitalWrite(LED2, HIGH);
      delay(50);
      digitalWrite(LED2, LOW);
      delay(30);
    }
    {
      analogWrite (LED2, lucentezza);
      lucentezza = lucentezza + incremento;
      if (lucentezza == 0 || lucentezza == 255)
      {
        incremento = incremento * -1;
        {
          delay (50);
        }
      }
      else
      {
        digitalWrite(LED2, LOW);
      }
    }
  }
}

Per poter ovviare al problema del delay ho poi provato a sostituire delay con millis (), però non sono riuscita a far funzionare in nessun modo il LED3.
Inserisco qui sotto anche il codice con millis che però non contiene il LED3 perchè non sono riuscita a trovare un modo di scrivere il codice per la quale l'effetto si avvicini a quello voluto.

#define led1 5
#define LED2 6
#define LED3 10
#define echoPin 2 // attach pin D2 Arduino to pin Echo of HC-SR04
#define trigPin 3 //attach pin D3 Arduino to pin Trig of HC-SR04
// defines variables
long duration; // variable for the duration of sound wave travel
int distance; // variable for the distance measurement
int lucentezza = 0; // definisce la variabile “lucentezza” con valore iniziale 0
int incremento = 5; // definisce la variabile “incremento” con valore 5
unsigned long tempo;
int pausa = 1; //intervallo di 300 millisecondi
int valore = 5;
unsigned long tempo3;
void setup() {
  pinMode(led1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  analogWrite(5, 0);
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an OUTPUT
  pinMode(echoPin, INPUT); // Sets the echoPin as an INPUT
  Serial.begin(9600); // // Serial Communication is starting with 9600 of baudrate speed
  Serial.println("Ultrasonic Sensor HC-SR04 Test"); // print some text in Serial Monitor
  Serial.println("with Arduino UNO R3");
  tempo = 100;
  pausa = 0;
}
void loop() {
  // Clears the trigPin condition
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin HIGH (ACTIVE) for 10 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2; // Speed of sound wave divided by 2 (go and back)
  // Displays the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
  int acceso = 0;
  digitalWrite (led1, LOW);
  if ( distance < 10 ) // a distanza 10cm il LED1 si accende
  {
    analogWrite (led1, ++valore);
    if ( valore <= 255)
    {
      tempo = millis();
      while (led1 == ++valore);
      analogWrite (led1, ++valore);
      {
        pausa = millis() - tempo;
        if (pausa > 50)
          analogWrite (led1, LOW);
      }
    }
  }
  digitalWrite (LED2, LOW);
  if ( distance < 200) // a distanza 10cm il LED1 si accende
  {
    {
      tempo = millis ();
      if ( tempo > pausa + 500)
      {
        digitalWrite (LED2, HIGH);
      }
      if (tempo > pausa + 500)
      {
        digitalWrite (LED2, LOW);
        pausa = millis ();
      }
    }
  }
  digitalWrite (LED2, LOW);
  if ( distance < 100) // a distanza 10cm il LED1 si accende
  {
    {
      tempo = millis ();
      if ( tempo > pausa + 100)
      {
        digitalWrite (LED2, HIGH);
      }
      if (tempo > pausa + 200)
      {
        digitalWrite (LED2, LOW);
        pausa = millis ();
      }
    }
  }
}

Spero possiate darmi una mano,
Grazie mille per l'aiuto. :relaxed:

Non ho la soluzione al problema specifico ma ho dei suggerimenti e li espongo qui di seguito:

  1. Serve distinguere a colpo di occhio il codice bloccante da quello non bloccante per potere giudicare se il codice bloccante è compatibile con il comportamente che si desira ottenere. Quando si stabilisce che il codice è bloccante ed è incompatibile con il comportamento desiderato si capisce subito che quella strada non porta alla soluzione.

  2. In uno dei tuoi post hai scritto,
    <<però ha problemi con i delay (ci sono troppi delay e quindi il fade del LED1 va troppo lentamente.)>>
    Infatti il delay() è considerato bloccante come pure un while() potrebbe esserlo.

  3. Fai periodicamente un poco di ordine nel codice, quando si affolla crea delle funzioni tue e chiamale quando serve. Ad esempio la lettura della distanza rilevata dal sensore potrebbe essere spostata in una funzione di nome readHC-SR04() ma anche altro nome a tua scelta, per comprendere la modifica che ti suggerisco allego parte del codice sotto.

void readHC-SR04() {
// Clears the trigPin condition
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin HIGH (ACTIVE) for 10 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2; // Speed of sound wave divided by 2 (go and back)
}

void loop() {
  readHC-SR04();  // chiamata a funzione per aggiornare la variabile 'distance"
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

Ciao.

Se la distanza supera 10 cm deve spegnersi o rimanere nello stato in cui è?

Puoi rispiegare il funzionamento di LED3?

  • aumenta nello stesso modo di LED1?
  • quando arriva al massimo che fa?
  • si spegne dopo tot tempo che si è spento LED1?

Si entra nel corpo di questa if anche quando distance = 1 poiché 1 < 200 risulta vera, stessa cosa per < 100 e < 10, è voluto oppure ti risulta si debba corregere?

Ciao..

Nel LED1 se la distanza è maggiore di 10cm il Led si spegne completamente.

Il LED3 deve funzionare in funzione del LED1, ogni volta che il LED1 si accende, il LED3 aumenta di uno la sua intensità che rimane fissa fin quando non si da un nuovo input al LED1 (quindi fin quando non viene ri acceso il LED1), dopo un tot di tempo che il LED1 non riceve input il LED3 inizia a decrementare la sua intensità. quindi se ad esempio ho acceso 2 volte il LED1, il LED3 avrà intensità = 2 (ovvero 102, visto che l'intensità si controlla da 0 a 255), se passa ad esempio 1 minuto ed il LED1 non viene mai accesso in quel lasso di tempo il LED3 inizierà a decrescere quindi intensità -1 (ovvero 51). Spero di essermi riuscita a spiegare meglio. Grazie

Sisi è voluto

Ok, adesso è più chiaro.

Ho guardato il tuo ultimo codice... a parte che non hai provato nulla di quello che avevo scritto... che poi non è che sia obbligatorio seguire quello che dico io, per carità... ma una prova per vedere cosa succede... giusto per darmi soddisfazione... vabbè, sono fisse mie, lasciamo stare.

In ogni caso, senza offesa, io ripartirei da zero. Se ti ostini a mettere pezze su quel codice ho paura che non ne esci.
Prepara uno sketch solo per il led1, che funzioni bene. Poi postalo che vediamo come va.
Da lì si può andare avanti.

Ok se è voluto ciò mi aiuta un poco a capire come vuoi che si comporti il codice e infatti continuando a leggere ho trovato una porzione di codice che non ha senso per me:

tempo = millis();
      while (led1 == ++valore);    // questo ; forse ti è scappato
      analogWrite (led1, ++valore);
      { // questa blocco di codice forse lo volevi legare al while
        pausa = millis() - tempo;
        if (pausa > 50)
          analogWrite (led1, LOW);
      }

Inoltre led1 vale 5 ed il while ciclerà quando ++valore assume il valore 5 ma già al prossimo while
la condizione sarà 5 == 6 che è false.

PS: Le domande di @fratt sono anche le mie.

Ciao.

Ciao, avevo provato a fare ciò che mi hai scritto, ho fatto tantissime prove diverse, per semplicità ho poi riportato solo i codici che si avvicinavano di più all'effetto voluto.

Per quanto riguarda la variabile se la dichiaravo solo globale (nel codice postato) il LED3 rimaneva spento,

per quanto riguarda le parentesi, ogni volta che ne eliminavo una coppia il codice mi dava errore e quindi non le ho più eliminate.

La variabile acceso non sapevo come sostituirla.

Alla fine ho fatto così, sono ripartita da zero ed ho scritto un codice completamente diverso.

Ciao, in realtà avevo provato ad aggiungere while perché appunto utilizzando millis() e non più Delay, il loop non si ripeteva più ma l'operazione veniva eseguita solo una volta. Quando dici

intendi dire che vale 5 perché l'ho posto come analogwrite? e che ++valore somma +1 quindi al prossimo ciclo non funzionerà perché calcolerà 5+1?

#define led1 5
#define LED2 6
#define LED3 10

Ni, cioè led1 lo ha definito come costante e while cicla fintanto che la condizione è verà.
Ne riparliamo poi, se hai nuovo codice postalo pure.

Ciao.

Il codice sopra ha un comportamento già affrontato, mentre quello che segue è simile solo alla apparenza, tutto ciò determinato da un punto e virgola nel posto "sbagliato".

while (led1 == ++valore)  {  // non c'è il ; del codice precedente ed al suo posto c'è {
      analogWrite (led1, ++valore);
      pausa = millis() - tempo;
      if (pausa > 50)
          analogWrite (led1, LOW);
      }

Allora capita anche agli esperti fare l'errore del punto e virgola, proprio per questo gli esperti
si sono imposti di aprire la graffa subito dopo la condizione. Altri errori subdoli si possono evitare imponendosi di usare sempre le graffe con if, while, for ecc anche quando c'è una sola istruzione come di seguito:

 if (pausa > 50) { // graffa di inizio blocco di codice 
          analogWrite (led1, LOW);
 } // chiusura blocco di codice.

Fine corso rapido. :crazy_face:

Ciao.

1 Like

Premessa: quando scrivo qualcosa cerco di farlo solo per dare un contributo, per quelle che sono le mie capacità. Spero nessuno prenda a male quello che scrivo.

Tornando al problema...

Diciamo è "concettualmente sbagliato" dichiarare la stessa variabile sia globale che locale. Anche se ti sembra che funzioni meglio è solo una pezza che in realtà non aiuta.

Qui ho dato per scontato che tu avessi presente come "funzionano" le graffe in C. Ho inserito alcuni commenti dentro questo spezzone di codice, spero chiariscano le idee.

	if ( distance < 10 ) 
	{  // qui inizia il blocco di istruzioni dentro l'if
		analogWrite (LED1, lucentezza);
		lucentezza = lucentezza + incremento;
		if (lucentezza == 0 || lucentezza == 255)
		{
			incremento = incremento *-1;
		}
		delay (1); 
	} // qui finisce l'if
	else
	{ // qui inizia il blocco di istruzioni dentro l'else
		digitalWrite(LED1, LOW);
	} // qui finisce l'else
	{ // A - questa graffa è inutile, insieme alla graffa di chiusura
	  // questo blocco di istruzioni è fuori dall'else
		acceso = lucentezza + incremento;
		analogWrite (LED3, acceso); 
		if (lucentezzaLED3 == 0 || lucentezzaLED3 == 255)
		{
			incrementoLED3 = incrementoLED3 * -1;
		}
		delay (1000);
	} // qui chiudi la graffa A
	if ( distance < 200 ) 
	{ // inizio if
		digitalWrite(LED2, HIGH);
		ecc....
	} // fine if
	{ // B - anche questa graffa con la relativa chiusura è inutile
	  // questo blocco di istruzioni è fuori dall'if
		analogWrite (LED2, lucentezza);
		lucentezza = lucentezza + incremento;
		if (lucentezza == 0 || lucentezza == 255)
		{
			incremento = incremento * -1;
			{ // C - sempre inutile
			delay (50);
			} // chiusura C
		}
		else
		{
		digitalWrite(LED2, LOW);
		}
		if ( distance < 100 ) 
		{
			digitalWrite(LED2, HIGH);
			ecc.....
		}
		{ // D - sempre inutile
		  // blocco istruzioni fuori dall'if
			analogWrite (LED2, lucentezza);
			lucentezza = lucentezza + incremento;
			if (lucentezza == 0 || lucentezza == 255)
			{
				incremento = incremento * -1;
				{
				delay (50);
				}
			}
			else
			{
				digitalWrite(LED2, LOW);
			}
		} // chiusura D
	} // chiusura B

Il problema non era la variabile (anche se non ho ben capito cosa volevi fare), ma la precedenza degli operatori. Per come l'hai scritta equivale a acceso = (acceso + (1 / 255)) e mi pareva avesse poco senso.

Come dice @Maurotec posta il nuovo codice.

Alla fine è venuto un poema... portate pazienza.

:wink:
Ok, il "Diciamo" lo tolgo io e quindi: è concettualmente sbagliato. Nei libri viene mostrato come la variabile locale oscura (nasconde) la variabile globale quando entrambe hanno lo stesso nome.
Ma il vero rompicapo è poi scovarla tra le centinaia di righe di codice.

Ciao.