chi ha la pazienza di controllare il mio 1° prog

Forum

Ciao a tutti ho cominciato a studiare. Non vi nascondo che ho notevoli difficoltà, ma insisto.
Ho pensato di creare un semplice (per VOI) programma da applicare ad un fuoristrada,
per il quale la visibilità post in parcheggio e nulla.

Il sens utilizzato e lo SHARP GP2D12 (è quello più indicato o avete qualche altro consiglio?)
Il circuito di prova l’ho testato ponendo al posto del buzz un led . (a proposito, che tipo di buzz devo acq e dove ?)
ho inserito un altro led solo con funzione di controllo.
Incredibile ma funziona ma?

Trovo le prime difficoltà che vi elenco qui sotto:

  1. Il buzz rimane leggermente alimentato non dovrebbe, in quanto quando non c’è nessun veicolo dietro deve rimanere muto e cominciare a suonare solo quando ci si avvicina all’ostacolo.

  2. Il buzz dovrebbe suonare sempre più frequentemente man mano che ci avvicina all’oggetto, non conosco il modo per invertire il segnale dato che la lettura del sensore è crescente da 30 (distanza infinita) a 5300 (circa 10 cm)

  3. Ci vogliono 2 sensori per coprire il posteriore dell’auto e quindi ho cercato di ripetere duplicando il programma sostituendo solo l’identificazione del sensore (sensorSX) e le letture (valSX) ma una volta fatto non funziona e mi da valori sballati in entrambe le letture (SX E DX). (però non ho 2 sensori per provare effettivamente)

Chissà se qualcuno ha la pazienza di aiutarmi, non ridete della mia programmazione elementare ma almeno ho fatto tutto da solo.

Grazie in anticipo

Per cortesia linguaggio molto semplice sono completamente a digiuno della materia.

riccardo

/*

  • parking sensor 0.1
  • by Paverik
  • sensor tipe sharp GP2D12 F 76 range 10cm/80cm

*/

int sensorDX = 2; // select the analogic input pin for the sensor rigt
int sensorSX = 5; // select the analogic input pin for the sensor left
int ledPin = 13; // select the pin for the LED
int buzz = 12; // select the pin for buzz
int valDX = 0; // variable to store the value coming from the sensor
int valSX = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);
}

void loop() {
valDX = analogRead(sensorDX); // read the value from the sensorDX

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX * 10); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX * 10); // serial print is only for view the program whereas run

if(valDX < 100); // check val < 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
if(ledPin == HIGH); // check
digitalWrite(buzz,LOW); // buzz quiet

delay(valDX); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
if(ledPin,LOW); // check
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valDX); // stop the program for some time

if(valDX > 100); // check valDX > 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
if(ledPin == HIGH); // check
digitalWrite(buzz,LOW); // buzz quiet

}

Ciao a tutti ho cominciato a studiare. Non vi nascondo che ho notevoli difficoltà, ma insisto.

Bravo paverick non desistere!! :slight_smile:

Ho pensato di creare un semplice (per VOI) programma da applicare ad un fuoristrada, per il quale la visibilità post in parcheggio è nulla.

Bella idea.
Mi piace :slight_smile:

Il sens utilizzato e lo SHARP GP2D12 (è quello più indicato o avete qualche altro consiglio?)
Il circuito di prova l’ho testato ponendo al posto del buzz un led . (a proposito, che tipo di buzz devo acq e dove ?)

Direi ceh come sensore vada benissimo.
Il buzz, in realtà non lo trovi con questa nomenclatura ma come “piezoelettrico”
Lo trovi in qualsiasi negozio di elettronica.
Occhio perchè necessità di una resistenza in parallelo per scaricarsi… ma trovi marea di info su web.

ho inserito un altro led solo con funzione di controllo.
Incredibile ma funziona ma?

Trovo le prime difficoltà che vi elenco qui sotto:

  1. Il buzz rimane leggermente alimentato non dovrebbe, in quanto quando non c’è nessun veicolo dietro deve rimanere muto e cominciare a suonare solo quando ci si avvicina all’ostacolo.

Per fare questo basta che utilizzi una variabile memoria.
In pseudocodice:

memoria = 0;
Se vicinanza < soglia, memoria =1, altrimenti memoria =0;
Se memoria = 1, suona canta e balla, altrimenti stai zitto;
  1. Il buzz dovrebbe suonare sempre più frequentemente man mano che ci avvicina all’oggetto, non conosco il modo per invertire il segnale dato che la lettura del sensore è crescente da 30 (distanza infinita) a 5300 (circa 10 cm)

Non so se il sharp funziona come il sensore di luce.
In tal caso prova ad invertire i pin e vedrai che sarà DECRESCENTE al decrescere della distanza.

  1. Ci vogliono 2 sensori per coprire il posteriore dell’auto e quindi ho cercato di ripetere duplicando il programma sostituendo solo l’identificazione del sensore (sensorSX) e le letture (valSX) ma una volta fatto non funziona e mi da valori sballati in entrambe le letture (SX E DX). (però non ho 2 sensori per provare effettivamente)

Sballati cosa vuol dire?

Chissà se qualcuno ha la pazienza di aiutarmi, non ridete della mia programmazione elementare ma almeno ho fatto tutto da solo.

Grazie in anticipo

Per cortesia linguaggio molto semplice sono completamente a digiuno della materia.

A chi lo dici :slight_smile:

int sensorDX = 2; // select the analogic input pin for the sensor rigt
int sensorSX = 5; // select the analogic input pin for the sensor left
int ledPin = 13; // select the pin for the LED
int buzz = 12; // select the pin for buzz
int valDX = 0; // variable to store the value coming from the sensor
int valSX = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);
}

void loop() {
valDX = analogRead(sensorDX); // read the value from the sensorDX

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX * 10); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX * 10); // serial print is only for view the program whereas run

Come mai moltiplichi per 10 i valori di ritorno?
Non comprendo…

if(valDX < 100); // check val < 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
if(ledPin == HIGH); // check
digitalWrite(buzz,LOW); // buzz quiet

Non userei un if led pin ma metterei tutto insieme del tipo:

if(valDX < 100);   
 digitalWrite(ledPin, HIGH);          // turn the ledPin on
 digitalWrite(buzz,LOW);            // buzz quiet

delay(valDX); // stop the program for some time

NON USARE DELAY bensì la funzione millis come spiegato qui verso il fondo POST DA CONTROLLARE

digitalWrite(ledPin, LOW); // turn the ledPin off
if(ledPin,LOW); // check
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valDX); // stop the program for some time

if(valDX > 100); // check valDX > 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
if(ledPin == HIGH); // check
digitalWrite(buzz,LOW); // buzz quiet

}

Prova con queste accortezze e dovrebbe già migliorare…

grazie per avermi dedicato il tuo tempo. grazie anche per l'incitamento.

1-presto acq il piezoelettrico per la resistenza vedremo se riesco a creare il circ.

2 - ho moltiplicato i valori solo per provare la funzione e non l'ho tolta.

3- adesso mi studio tutti i tuoi preziosi consigli e approfitterò di te per un ulteriore e sicuramente necessario ricontrollo.

  • 4 ordino anche l'altro sensore per avere il circuito completo da testare.

passeranno alcuni giorni perchè, purtroppo mi tocca lavorare, e devo trovare il momento tranquillo per agire.

ciao e grazie ancora

grazie per avermi dedicato il tuo tempo.
grazie anche per l’incitamento.

Figurati…
E’ che ricordo anche io l’inizio: ero persino un po’ scettico ma adesso ogni nuova cosa non è più uno scoglio da sormontare ma un nuovo gioco ;D

1-presto acq il piezoelettrico per la resistenza vedremo se riesco a creare il circ.

Il circuito è semplicissimo: guarda questo.

2 - ho moltiplicato i valori solo per provare la funzione e non l’ho tolta.

Capito. Anche a me capita ogni tanto…

4 ordino anche l’altro sensore per avere il circuito completo da testare.

ottimo!

passeranno alcuni giorni perchè, purtroppo mi tocca lavorare, e devo trovare il momento tranquillo per agire.

Anche su questo ti sono solidale.
Anche a me PURTROPPO tocca lavorare ;D
Io giochicchio la sera dalle 22 all’una ma poi sei stanco… i pezzi non sono ancora arrivati… non sei ancora riuscito a risolvere quel problema per cui non puoi andare avanti… Comprendo bene :stuck_out_tongue:
Facci sapere allora!

ciao a tutti e in particolare al mio mentore Nathanvi.
Ho dato una occhiata alle modifiche che mi hai consigliato.

  1. la tras in mills() è corretta? mi sembra che il lampeggio sia più regolare.

  2. Ho eliminato gli if di troppo come hai detto tu

  3. Ho aggiunto il codice anche per l’atro sensore (che deve ancora arrivare)

  4. Il sensore sharp ha 3 collegamenti come un servo per capirsi + - e impulso non credo si possa invertire e se si, cosa inverto? Se non è possibile rimane il problema dell’inversione della frequenza di intermittenza del suono (cioè lento quando l’oggetto è lontano e frequente quando è vicino)

Passiamo ora alla variabile in pseudo codice che tu mi hai consigliato per far si che il buzz stia zitto sotto una certa soglia. Queste variabili sono ancora una nebulosa nella mia mente.
Devo inserire all’inizio del codice un comando che indica una cella di memoria che chiamo “soglia”.
Per cui se scrivo “ int soglia = 0” con questo comando creo una memoria dei dati che si chiamano soglia e che partono da 0. Adesso dovrò indicare nel codice void loop che il valore letto
sensorDX = soglia.
Con questo comando gli dico di mem i valori del sensore nel banco di mem soglia.
Adesso se il valore soglia è di un tot “fai quello che di dico”
È corretto oppure non ho capito nulla?

Ti ringrazio in anticipo.

ciao riccardo

Ecco il prog modificato:

/*

  • parking sensor 0.2
  • by Paverik
  • sensor tipe sharp GP2D12 F 76 range 10cm/80cm
    */

int sensorDX = 2; // select the analogic input pin for the sensor rigt
int sensorSX = 5; // select the analogic input pin for the sensor left
int ledPin = 13; // select the pin for the LED
int buzz = 12; // select the pin for buzz
int valDX = 0; // variable to store the value coming from the sensor
int valSX = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);
valDX = millis();
valSX = millis();
}

void loop() {
valDX = analogRead(sensorDX); // read the value from the sensorDX

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX * 10); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX * 10); // serial print is only for view the program whereas run

// ----------------------------SENSOR DX--------------------------------------------------

if(valDX > 100); // check val > 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
digitalWrite(buzz,LOW); // buzz quiet
delay(valDX); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valDX); // stop the program for some time

if(valDX < 100); // check valDX < 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
digitalWrite(buzz,LOW); // buzz quiet

// ----------------------------SENSOR SX--------------------------------------------------

valSX = analogRead(sensorSX); // read the value from the sensorDX

if(valSX > 100); // check val > 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
digitalWrite(buzz,LOW); // buzz quiet
delay(valSX); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valSX); // stop the program for some time

if(valSX < 100); // check valDX < 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
digitalWrite(buzz,LOW); // buzz quiet

}

ciao a tutti e in particolare al mio mentore Nathanvi.
Ho dato una occhiata alle modifiche che mi hai consigliato.

Per carità paverik non parliamo di mentore perchè sono alle prime armi anche io :slight_smile:

(CUT…)

  1. Il sensore sharp ha 3 collegamenti come un servo per capirsi + - e impulso non credo si possa invertire e se si, cosa inverto? Se non è possibile rimane il problema dell’inversione della frequenza di intermittenza del suono (cioè lento quando l’oggetto è lontano e frequente quando è vicino)

Effettivamente detta così c’è poco da invertire…
Sinceramente non saprei.
Ma quindi a seconda di quanto dista l’oggetto non ti restituisce dei numeri interi bensì degli impulsi più o meno frequenti?
Mi sembra strano.
Mi aspetto, dato che leggi il sensore da un pin analogico che ti venga restituito un valore intero…

Passiamo ora alla variabile in pseudo codice che tu mi hai consigliato per far si che il buzz stia zitto sotto una certa soglia. Queste variabili sono ancora una nebulosa nella mia mente.
Devo inserire all’inizio del codice un comando che indica una cella di memoria che chiamo “soglia”.
Per cui se scrivo “ int soglia = 0” con questo comando creo una memoria dei dati che si chiamano soglia e che partono da 0. Adesso dovrò indicare nel codice void loop che il valore letto
sensorDX = soglia.
Con questo comando gli dico di mem i valori del sensore nel banco di mem soglia.
Adesso se il valore soglia è di un tot “fai quello che di dico”
È corretto oppure non ho capito nulla?

Più o meno ma effettivamente c’è un po’ di confusione.
Guardiamo il codice che hai scritto…

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);
valDX = millis();
valSX = millis();
}

Primo sbaglio.
millis deve essere data ad una variabile che “segna il tempo”.
Del tipo:
unsigned long time;
void setup(){
time = millis();
}
Non puoi e non devi dare il valore di millis a valDX e valSX perchè saranno le variabili che conterranno il valore del sensore e quindi non centrano nulla con il tempo.

void loop() {
valDX = analogRead(sensorDX); // read the value from the sensorDX

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX * 10); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX * 10); // serial print is only for view the program whereas run

// ----------------------------SENSOR DX--------------------------------------------------

if(valDX > 100); // check val > 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
digitalWrite(buzz,LOW); // buzz quiet
delay(valDX); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valDX); // stop the program for some time

Sbagliato.
Prima di tutto dovresti proprio eliminare la funzione delay
Tale funzione, ottima negli esempi per non complicare il codice, è brutta da usare in questi casi.
Quello che fai in tale codice è dirgli: Se la variabile valDX è maggiore di 100 bloccati per un numero di millisecondi pari al valore della variabile stessa
Ciò significa che se l’oggetto è distante 4000 lui si blocca per 4 secondi e se fa lo stesso con l’altro sensore avrai tempi morti moooolto lunghi rischiando di non accorgerti quando l’oggetto si avvicina.

if(valDX < 100); // check valDX < 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
digitalWrite(buzz,LOW); // buzz quiet

Beh, in tal caso lo accenderi il buz…
Se l’oggetto è pari a 100 o inferirore digitalWrite(buzz,HIGH);

// ----------------------------SENSOR SX--------------------------------------------------

valSX = analogRead(sensorSX); // read the value from the sensorDX

if(valSX > 100); // check val > 100 if is true blink the led like val DX
digitalWrite(ledPin, HIGH); // turn the ledPin on
digitalWrite(buzz,LOW); // buzz quiet
delay(valSX); // stop the program for some time
digitalWrite(ledPin, LOW); // turn the ledPin off
digitalWrite(buzz,HIGH); // buzz in allarm
delay(valSX); // stop the program for some time

if(valSX < 100); // check valDX < 100 if is true the led is HIGH
digitalWrite(ledPin,HIGH);
digitalWrite(buzz,LOW); // buzz quiet

}

Vale lo stesso discorso di prima.
Scritto così, comunque, penso che tu possa tranquillamente far a meno della funzione millis perchè il buzz si accende se l’oggetto è vicino e si spegne se lontano.
Se al contrario vuoi che il buzz vada ad intermittenza sempre più frequentemente all’avvicinarsi dell’oggetto devi scrivere qualcosa di questo tipo:

if(valSX > soglia){    // devi vedere il range del sensore
                               // supponendo che sia da 0 a 1023 direi che 
                               // soglia debba essere intorno a 800 o 900
                               // in tal caso l'oggetto è lontano e puoi
                               // spegnere tutto
 digitalWrite(ledPin, LOW);   
 digitalWrite(buzz,LOW); 
}
 
 if(valSX <= soglia){                         //se l'oggetto si avvicina
    if(time > millis() + (30*valSX)){    //se sono passati 30 millisecondi
                                                       //moltiplicati valSX (in altre 
                                                  //parole più si avvicina, più il valore
                                                  // valSX diminuisce, più ravvicinati
                                                 // sono i cambi di stato del buzz
             time=millis();                //riassegna millis a time
             digitalWrite(ledPin,mem);   // accendi o spegni il LED a
                                                     // seconda di quanto vale mem
                                                     //che sarà 0 o 1
             digitalWrite(buzz,mem);// accendi o spegni il BUZZ a
                                                     // seconda di quanto vale mem
                                                     //che sarà 0 o 1
             mem=!mem;         //dai a mem l'opposto: quindi se era 0
                                          //diventa 1 e viceversa
      }
 }

Così facendo dovrebbe funzionare.
Da testare ma la via penso sia questa…

Ritorno dai bagordi pasquali.
Ho cercato di studiare le tue istruzioni, ma il mio livello è talmente basso che non sono riuscito a risolvere molto.
Andiamo per gradi.
Ho scoperto una cosa, con i passi di programmazione e con un microcontrollore come l’arduino si può fare veramente di tutto, quello che è il bello anche in modo abbastanza facile e intuitivo. Per me l’ostacolo principale è capire ad ogni linea di comando cosa veramente succede e con quale priorità.
Mi spiego meglio: mi immagino una pallina che per gravità scorre un percorso tortuoso con continue deviazioni. Ogni ostacolo o deviazione fa fare alla pallina un percorso diverso.
Se ho ben chiaro come agiscono le deviazioni posso fare fare alla pallina quello che voglio.

Vediamo se mi fai un po’ di scuola:
analizzo al alta voce il percorso della pallina, descrivendo i passaggi CON DELLE AFFERMAZIONI DIMMI SE SONO VERE O FALSE)

/*

  • parking sensor 0.4
  • by Paverik
  • sensor tipe sharp GP2D12 F 76 range 10cm/80cm
    */

int sensorDX = 2; // select the analogic input pin for the sensor rigt
int sensorSX = 5; // select the analogic input pin for the sensor left
int ledPin = 13; // select the pin for the LED
int buzz = 12; // select the pin for buzz
int valDX = 0; // variable to store the value coming from the sensor
int valSX = 0; // variable to store the value coming from the sensor
QUESTI 2 PASSAGGI INDICANO DA CHE PUNTO BISOGNA COMINCIARE A CONTARE (IN QUESTO CASO DA ZERO) SE IL SENSORE RITORNASSE PER IPOTESI VALORI NEGATIVI SI POTREBBE SCRIVERE CONTA DA -100

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);

}

void loop() {

valDX = analogRead(sensorDX); // read the value from the sensorDX
valDX = analogRead(sensorSX); // read the value from the sensorSX

LEGGE 16 MILIONI DI VOLTE AL SECONDO I DUE SENSORI PRIMA IL DX POI IL SX

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX); // serial print is only for view the program whereas run

// ----------------------------SENSOR DX--------------------------------------------------

if (valDX < 20);
{
digitalWrite(ledPin,LOW);
}
LEGGE IL VALORE DEL SENSORE (CHE RITORNA VALORI CHE VANNO DA 3 (INFINITO) A 500 (10 CM) SE E’ PIU’ PICCOLO DI 20 SPEGNE IL LED E TERMINA IL VOID LOOP. ALTRIMENTI ESEGUE I PASSAGGI SUCCESSIVI.(QUESTO IN REALTA’ FACENDO GIRARE IL PROG NON SUCCEDE CIOE’ IL LED LAMPEGGI SEMPRE PIU FREQUENTEMENTE. ANCHE CON VALORI SOTTO IL 20 NON SI SPEGNE QUINDI CI DEVE ESSERE UN ERRORE SINTATTICO IN QUANTO NON ESEGUE L’ISTRUZIONE INIZIALE)

digitalWrite(ledPin,HIGH);
delay(valDX);
digitalWrite(ledPin,LOW);
delay(valDX);

// ----------------------------SENSOR SX--------------------------------------------------

if (valDX < 20);
{
digitalWrite(ledPin,LOW);
}

digitalWrite(ledPin,HIGH);
delay(valSX);
digitalWrite(ledPin,LOW);
delay(valSX);

}

SE SEI D’ACCORDO RISOLVIAMO PRIMA QUESTO IMPORTANTE PASSAGGIO POI PASSIAMO AL RESTO.

SONO COSCIENTE DELL’ELEMENTARITA DEL MIO DISCORSO E NON TI BIASIMO SE VORRAI DEDICARTI A QUALCOSA DI PIU’ STIMOLANTE , GRAZIE COMUNQUE.

RICCARDO

Ritorno dai bagordi pasquali.

Lasciamo perdere… Tra braciole di maiale e colombe…

Per me l’ostacolo principale è capire ad ogni linea di comando cosa veramente succede e con quale priorità.
Mi spiego meglio: mi immagino una pallina che per gravità scorre un percorso tortuoso con continue deviazioni. Ogni ostacolo o deviazione fa fare alla pallina un percorso diverso.
Se ho ben chiaro come agiscono le deviazioni posso fare fare alla pallina quello che voglio.

Allora il principio è senza dubbio questo ma nel caso di Arduino aggiungo un’altra cosa.
Immagina pure una pallina spinta verso il basso e che durante la caduta si muova lungo dei percorsi con continue deviazioni ma immagina che quando arriva in fondo ci sia una molla che la rimandi all’inizio del percorso stesso e da li ricominci a cadere…
E’ un concetto quasi banale ma importantissimo per comprendere le dinamiche e… ti fa anche cambiare l’ottica di programmazione…

int valDX = 0; // variable to store the value coming from the sensor
int valSX = 0; // variable to store the value coming from the sensor
QUESTI 2 PASSAGGI INDICANO DA CHE PUNTO BISOGNA COMINCIARE A CONTARE (IN QUESTO CASO DA ZERO) SE IL SENSORE RITORNASSE PER IPOTESI VALORI NEGATIVI SI POTREBBE SCRIVERE CONTA DA -100

Falso. Nel commento vi è scritto: “variable to store the value from the sensor” ovvero variabile che memorizza il valore del sensore. Quindi il termine “contare” è proprio errato.
Partiamo anche da un’altra ipotesi fondamentale: io NON so i valori minimi e massimi del sensore; questo dovresti saperlo tu dal datasheet. Io ipotizzo che vadano da 0 (molto vicino) a 1023 (molto lontano)… Se così non è me lo devi dire tu.
Ti consiglio a tal proposito uno schetck iniziale molto semplice del tipo:

int sensore =2;

void setup(){
    Serial.begin(9600);
    pinMode(sensore, INPUT);
}

void loop(){
    int valore;
    valore = analogRead(sensore);
    Serial.print("Il valore del sensore: ");
    Serial.println(valore,DEC);
    delay(500);
}

Spero di non essermi dimenticato nulla perchè in ufficio, come sai, non riesco a testarlo…
A questo punto carica lo sketch, avvia il Serial monitor (l’ultima icona a destra dell’IDE di programmazione) e visualizza i numeri che dovrebbero cambiare a seconda della posizione della tua mano rispetto il sensore di destra…
A questo punto prendi nota del valore minimo e massimo così ci chiariamo le idee su questo punto.

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(buzz, OUTPUT); // declare the buzz as an OUTPUT
Serial.begin(9600);

}

La funzione setup serve per “inizializzare” le funzioni di base.
Da adesso in avanti inizia il loop ovvero la pallina che cade e risale 16milioni di volte al secondo.

void loop() {

valDX = analogRead(sensorDX); // read the value from the sensorDX
valDX = analogRead(sensorSX); // read the value from the sensorSX

LEGGE 16 MILIONI DI VOLTE AL SECONDO I DUE SENSORI PRIMA IL DX POI IL SX

No e si… 16 milioni di volte è TUTTO quello che c’è nel loop…
Quindi il sensore viene letto e con esso tutto quello che c’è di seguito per tutte le volte al secondo che abbiam detto.

Serial.print("valore DX "); // serial print is only for view the program whereas run
Serial.println(valDX); // serial print is only for view the program whereas run
Serial.print("valore SX "); // serial print is only for view the program whereas run
Serial.println(valSX); // serial print is only for view the program whereas run

// ----------------------------SENSOR DX--------------------------------------------------

if (valDX < 20);
{
digitalWrite(ledPin,LOW);
}
LEGGE IL VALORE DEL SENSORE (CHE RITORNA VALORI CHE VANNO DA 3 (INFINITO) A 500 (10 CM) SE E’ PIU’ PICCOLO DI 20 SPEGNE IL LED E TERMINA IL VOID LOOP. ALTRIMENTI ESEGUE I PASSAGGI SUCCESSIVI.(QUESTO IN REALTA’ FACENDO GIRARE IL PROG NON SUCCEDE CIOE’ IL LED LAMPEGGI SEMPRE PIU FREQUENTEMENTE. ANCHE CON VALORI SOTTO IL 20 NON SI SPEGNE QUINDI CI DEVE ESSERE UN ERRORE SINTATTICO IN QUANTO NON ESEGUE L’ISTRUZIONE INIZIALE)

Con la premessa di prima non so quali siano i valori… Mi son basato su quello che hai detto tu che all’allontanarsi dell’oggetto i numeri decrescono. In tal caso all’arrivo di 20… spegne il led ma NON termina il loop!!! Il loop non termina mai…
Il fatto che il led lampeggi sempre dipende dai valori del sensore e… torniamo al punto prima. Devi capire BENE da che valore a che valore il sensore si sposti…

digitalWrite(ledPin,HIGH);
delay(valDX);
digitalWrite(ledPin,LOW);
delay(valDX);

Hai aggiunto tu queste istruzioni?
In ogni caso sono sbagliate…
Che senso hanno? Voglion dire: accendi il LED, aspetta il valore letto dal sensore e poi spegnilo…
Non hanno proprio senso…

// ----------------------------SENSOR SX--------------------------------------------------

if (valDX < 20);
{
digitalWrite(ledPin,LOW);
}

digitalWrite(ledPin,HIGH);
delay(valSX);
digitalWrite(ledPin,LOW);
delay(valSX);

}

SE SEI D’ACCORDO RISOLVIAMO PRIMA QUESTO IMPORTANTE PASSAGGIO POI PASSIAMO AL RESTO.

SONO COSCIENTE DELL’ELEMENTARITA DEL MIO DISCORSO E NON TI BIASIMO SE VORRAI DEDICARTI A QUALCOSA DI PIU’ STIMOLANTE , GRAZIE COMUNQUE.

Più che altro ti consiglio di partire, come ho fatto io, da sketch moooolto più semplici.
Da un sensore di luminosità come quello dato nello starter kit e di provarli uno ad uno, testare, compredere l’uso della seriale, capire bene il funzionamento del loop, studiare il concetto di IF, FOR, WHILE che stanno alla base della programmazione e via dicendo.
In questo modo stai già mettendo molta carne al fuoco e rischi di abbandonare perchè non capisci quello che fai…
Ovviamente il mio è un consiglio: parti a piccoli passi; le falcate vengono dopo :stuck_out_tongue:

OK, seguo il tuo consiglio al 100%.

Mi metto a studiare sketch più elementari.

Per dovere di cronaca ti do dei chiarimenti che potranno essermi utili in futuro.

Allora il principio è senza dubbio questo ma nel caso di Arduino aggiungo un'altra cosa. Immagina pure una pallina spinta verso il basso e che durante la caduta si muova lungo dei percorsi con continue deviazioni ma immagina che quando arriva in fondo ci sia una molla che la rimandi all'inizio del percorso stesso e da li ricominci a cadere... E' un concetto quasi banale ma importantissimo per comprendere le dinamiche e... ti fa anche cambiare l'ottica di programmazione...

Perfetto l'avevo intuito e ho capito, quello che non capisco è se un programma si deve fermare per aspettare un nuovo evento per poi continuare? Oppure se deve saltare dei passi di programmazione per eseguire altre cose (tipo goto ? del basic)? Ma, ci penseremo più avanti.

Falso. Nel commento vi è scritto: "variable to store the value from the sensor" ovvero variabile che memorizza il valore del sensore. Quindi il termine "contare" è proprio errato.[/color]

OK è una scatola che immagazzina un numero di ritorno del sensore ma lo zero che cosa indica?

Partiamo anche da un'altra ipotesi fondamentale: io NON so i valori minimi e massimi del sensore; questo dovresti saperlo tu dal datasheet. Io ipotizzo che vadano da 0 (molto vicino) a 1023 (molto lontano).... Se così non è me lo devi dire tu. Ti consiglio a tal proposito uno schetck iniziale molto semplice del tipo:

il sensore ritorna valori che vanno da 2 (oltre 80 cm) a 515 (molto vicino) in realtà il datasheet parla di volt di ritorno addirittura da dei grafici dove indica il valore in volt per una data distanza. Esattamente 0.4 V. a 80cm 2,4 V. a 10cm. Il tuo schetck l'ho testato e da gli stessi valori del mio.

Hai aggiunto tu queste istruzioni? In ogni caso sono sbagliate... Che senso hanno? Voglion dire: accendi il LED, aspetta il valore letto dal sensore e poi spegnilo... Non hanno proprio senso...

Il mio intento era: in funzione della lettura del sensore l'intermittenza del led varia (nel tempo di accensione e spegnimento) così posso capire quando mi avvicino all'oggetto. Devo dire che funziona perfettamente come ho descritto, pur rimanendo il problema di invertire la frequenza (ma questo lo vedremo in seguito).

Detto questo chiudo la parentesi e ti riconfermo che mi metterò a provare schetck puramente per capire le funzioni principali, come mi hai consigliato.

Ciao e grazie ancora. ;)

Ps. Come si fa a selezionare in grigetto come fai tu dei blocchi di risposta (quote)in modo così ordinato e i passi di programma con una cornice a parte (code)?

OK, seguo il tuo consiglio al 100%.

Benissimo: mi fa piacere.
Più che altro perchè andando per gradi pur avendo un obiettivo in mente è più facile camminare.

Perfetto l’avevo intuito e ho capito, quello che non capisco è se un programma si deve fermare per aspettare un nuovo evento per poi continuare? Oppure se deve saltare dei passi di programmazione per eseguire altre cose (tipo goto ? del basic)? Ma, ci penseremo più avanti.

No, il programma luppa (neologismo italiano schifoso ma che significa che compie tutte le azioni nel loop).
Non si ferma: semplicemente va avanti e ritorna…
Ovvio che se trova dei GOTO o dei FOR prima di arrivare alla fine del loop e tornare indietro si ferma e fa qualcosa.
Mi spiego meglio: se nel loop c’è una funzione del tipo:

void loop(){
  // varie parti di codice..... 
  if(val==1){
    for(int i=0; i<100; i++){
      //fai qualcosa nel for
    }
  }
  // altre parti di codice...
}

Il programma fa qualcosa. Se val è uno entra nel for e a quel punto, prima di andare avanti, fa l’operazione dentro il for per 100 volte.
A quel punto ritorna a fare il loop.

OK è una scatola che immagazzina un numero di ritorno del sensore ma lo zero che cosa indica?

Dipende dai valori che ritornano i sensori.
Cmq si, l’idea della scatola mi piace più del contatore :slight_smile:

il sensore ritorna valori che vanno da 2 (oltre 80 cm) a 515 (molto vicino) in realtà il datasheet parla di volt di ritorno addirittura da dei grafici dove indica il valore in volt per una data distanza. Esattamente 0.4 V. a 80cm 2,4 V. a 10cm.
Il tuo schetck l’ho testato e da gli stessi valori del mio.

Perfetto. Allora tieni a mente questi valori quando proverai…

Detto questo chiudo la parentesi e ti riconfermo che mi metterò a provare schetck puramente per capire le funzioni principali, come mi hai consigliato.

Ottimo.
E’ fondamentale partire a fare piccoli passi.

Ps. Come si fa a selezionare in grigetto come fai tu dei blocchi di risposta (quote)in modo così ordinato e i passi di programma con una cornice a parte (code)?

Per quotare le parole degli altri metti le parole tra i due tag “quote”
Del tipo:

Per il codice idem come sopra ma con le parole “code”:
[ code.] codice [/code]

PS: ho messo il puntino per evitare che il programma interpretasse quindi non “quote.” ma “quote”

E altro consiglio: fai sempre un Preview del messaggio prima di Postarlo…

questi post sono veramente utili anche per me che sono alle prime armi. grazie