In questo tutorial esploreremo come rilevare la luce usando un Arduino. Il rilevamento della luce è un aspetto fondamentale di molti progetti, che vanno dagli interruttori automatici alle luci regolate. Comprendendo i principi alla base del rilevamento della luce, potrai creare applicazioni innovative che rispondono alle variazioni dei livelli di luce.
Usando una scheda Arduino, possiamo facilmente interfacciarci con vari sensori e componenti per rilevare la luce. Uno dei sensori più comunemente usati per questo scopo è la fotoresistenza, nota anche come LDR (light-dependent resistor). Misurando la resistenza della fotoresistenza, possiamo determinare l’intensità della luce che la colpisce.
In questo post ti guideremo nel processo di costruzione di un rilevatore di luce usando un Arduino e una fotoresistenza. Esploreremo anche come espandere questa configurazione base per creare progetti più avanzati, come un interruttore automatico, luci regolate e persino un servo controllato dalla luce.
Che tu sia un principiante o un appassionato esperto di Arduino, questo tutorial ti fornirà le conoscenze necessarie per iniziare a lavorare con il rilevamento della luce. Allora, iniziamo!
Componenti necessari
Di seguito trovi i componenti necessari per costruire questo progetto. Se hai già resistori, LED e trimmer, ovviamente non ti serviranno i kit elencati. Altrimenti, vale la pena acquistarli, poiché sarà più economico rispetto all’acquisto di singoli componenti.
Arduino Uno
Set di fili Dupont
Breadboard
Cavo USB per Arduino UNO
Kit di resistori e LED
Set di resistori variabili
Set di fotoresistenze
Servo posizionale
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Cos’è una fotoresistenza o LDR
Una fotoresistenza, nota anche come LDR (light-dependent resistor), è un tipo di resistore la cui resistenza varia in base alla quantità di luce a cui è esposto. È un componente passivo ampiamente usato in varie applicazioni di rilevamento e controllo della luce. L’immagine sotto mostra una tipica fotoresistenza.
Nota che non c’è polarità per i due fili. Essendo semplicemente un resistore, può essere usata in qualsiasi orientamento. Per Arduino puoi anche trovare moduli con circuiti integrati aggiuntivi che permettono di regolare la sensibilità del sensore, ma noi lo costruiremo da soli.
Come funziona una fotoresistenza?
Una fotoresistenza è fatta di un materiale semiconduttore fotoconduttivo. Quando la luce colpisce la superficie della fotoresistenza, i fotoni dell’energia luminosa eccitano gli elettroni nel materiale semiconduttore, facendoli muovere più liberamente. Questo movimento riduce la resistenza della fotoresistenza.
Al contrario, quando non c’è luce o l’intensità è bassa, il materiale semiconduttore presenta una resistenza più alta. Questa caratteristica rende le fotoresistenze ideali per rilevare i livelli di luce.
Partitore di tensione
Per misurare la resistenza di una fotoresistenza e convertirla in una tensione misurabile, si usa comunemente un voltage divider circuito. Consiste in due resistori collegati in serie, uno dei quali è la fotoresistenza. L’altro è spesso un potenziometro o trimmer per regolare la sensibilità o la soglia del circuito. Tuttavia, si trovano anche circuiti più semplici che usano un resistore a valore fisso al posto del trimmer.
L’immagine sotto mostra lo schema del partitore di tensione che useremo nelle sezioni successive.
Puoi vedere che la fotoresistenza (R1) e il trimmer (R2) sono collegati in serie tra l’alimentazione (5V) e massa (GND). Il punto di giunzione tra la fotoresistenza (R1) e il trimmer è collegato a un pin di ingresso analogico (A0) dell’Arduino. Man mano che la resistenza della fotoresistenza cambia con l’intensità luminosa, varia anche la tensione in quel punto.
La formula per calcolare la tensione di uscita di un partitore di tensione è:
V_A0 = Vin * (R1 / (R1 + R2))
Dove:
- V_A0 è la tensione di uscita
- Vin (+5V) è la tensione di ingresso
- R1 è la resistenza della fotoresistenza
- R2 è la resistenza del trimmer
Nella prossima sezione imparerai come costruire un rilevatore di luce usando questo circuito e un Arduino.
Costruire un rilevatore di luce
In questa sezione mostro come collegare un LDR a un Arduino e visualizzare le intensità luminose misurate sul Monitor Seriale.
Costruire il partitore di tensione
Il diagramma seguente mostra come collegare i componenti per costruire il partitore di tensione di cui abbiamo parlato. Prima colleghiamo 5V alla linea di alimentazione positiva della breadboard con un filo rosso. Poi colleghiamo la massa (GND) alla linea negativa con un filo blu.
Ora il partitore di tensione. Collega un pin della fotoresistenza (LDR) alla linea di alimentazione positiva (filo rosso). L’altro pin va collegato al pin centrale del trimmer. Assicurati di collegarlo correttamente, altrimenti la regolazione non funzionerà.
Per il trimmer scegliamo un valore di resistenza approssimativamente uguale a quello della LDR in condizioni di luce normale. Nel mio caso circa 20K Ohm. Il valore esatto non è critico.
Poi colleghiamo il punto di giunzione tra trimmer e fotoresistenza con un filo giallo all’ingresso analogico A0 dell’Arduino.
L’ultimo collegamento è tra uno degli altri pin del trimmer e la linea di alimentazione negativa (filo blu). Non importa quale pin usi per questo. Infine, ruota il trimmer nella posizione centrale e iniziamo a scrivere il software.
Codice per il rilevatore di luce
Il software per il rilevatore di luce è molto semplice. Definiamo una costante ldrPin per il pin a cui è collegato l’LDR e una variabile ldrValue per memorizzare la luminosità rilevata.
const int ldrPin = A0;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
Serial.print("LDR:");
Serial.println(ldrValue);
delay(100);
}
Nella setup() funzione, inizializziamo la comunicazione Serial e impostiamo la modalità del ldrPin su INPUT, dato che leggeremo da esso.
Nella funzione l oop() leggiamo il valore dell’LDR tramite analogRead() e lo stampiamo sul Monitor Seriale. Ora apri il Serial Plotter e muovi la mano davanti all’LDR per variare la quantità di luce che riceve. Dovresti vedere una curva variabile simile a quella sotto.
Se non ottieni alcun segnale (linea piatta), controlla il circuito e assicurati che il trimmer sia nella posizione centrale.
L’ingresso analogico restituisce valori nell’intervallo da 0 a 1023 su un Arduino UNO. Tuttavia, di solito non vedremo l’intera gamma, a meno che il sensore non sia esposto a completa oscurità o luminosità estrema.
Per ottenere una buona sensibilità del sensore, prova diversi livelli di luminosità/oscurità e regola il trimmer in modo da non raggiungere il valore minimo (0) o massimo (1023). Nota che questi valori non sono calibrati in alcun modo. Per esempio, se vuoi misurare l’intensità luminosa in Lux, avresti bisogno di una sorgente luminosa con intensità nota per calibrare le letture.
Costruire un interruttore automatico
Ora che possiamo rilevare la luce, possiamo costruire un interruttore automatico. Quando fa buio, accendiamo la luce. Per questo esempio, aggiungiamo un LED con un resistore al circuito.
Manteniamo il partitore di tensione così com’è. Aggiungiamo solo il LED e un resistore da 220 Ohm sulla breadboard come mostrato sopra. Poi colleghiamo il pin lungo del LED con un filo arancione al Pin 9 dell’Arduino. Infine, colleghiamo il pin del resistore con un filo blu alla linea di alimentazione negativa della breadboard. Fatto!
Estendere il codice è molto semplice. Basta aggiungere una costante ledPin per il pin di uscita a cui è collegato il LED e impostare il pinMode su OUTPUT nella funzione setup().
const int ldrPin = A0;
const int ledPin = 9;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
digitalWrite(ledPin, ldrValue > 500 ? HIGH: LOW);
delay(1000);
}
Nella funzione loop() leggiamo il ldrValue come prima. Ma poi, a seconda del valore, accendiamo o spegniamo il LED usando digitalWrite. Se il ldrValue è maggiore di 500, è abbastanza luminoso e spegniamo il LED (LOW). Se il valore è minore, è buio e accendiamo il LED (HIGH).
Ecco fatto! Ora hai una luce automatica che si accende quando fa buio. Puoi regolare la soglia cambiando il valore 500 con uno più alto o più basso (nell’intervallo da 0 a 1023). Se vuoi controllare luci più potenti, puoi sostituire il LED con un relè e accendere le luci della stanza, per esempio.
Costruire una luce regolata o dimmer
Nella sezione precedente abbiamo costruito un interruttore automatico che accende o spegne completamente il LED. In questa sezione ti mostro come regolare la luminosità del LED in modo fluido, a seconda di quanto è luminosa la luce. Quindi, invece di accendere o spegnere il LED, lo dimmeriamo.
Ecco il codice. Iniziamo aggiungendo una variabile brightness ma lasciamo la funzione setup() invariata.
const int ldrPin = A0;
const int ledPin = 9;
int ldrValue = 0;
int brightness = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
brightness = map(ldrValue, 50, 300, 255, 0);
brightness = constrain(brightness, 0, 255);
analogWrite(ledPin, brightness);
delay(10);
}
Nella funzione loop() leggiamo il ldrValue come prima, ma poi map il suo valore nell’intervallo da 255 a 0. Nota che l’intervallo è invertito (255 a 0 invece di 0 a 255), perché vogliamo che il LED diventi più luminoso quanto più è buio intorno.
Il ldrValue ha un intervallo possibile da 0 a 1023. Ma nel codice sopra usiamo solo l’intervallo da 50 a 300. In questo modo il LED reagisce a cambiamenti relativamente piccoli nelle condizioni di luce. Altrimenti, dovrebbe essere molto luminoso o molto buio per vedere una variazione nella luminosità del LED.
Tuttavia, questo crea un piccolo problema. La funzione map non garantisce che il valore di uscita sia effettivamente nell’intervallo 255 a 0. Se la luce diventa più intensa o più debole rispetto ai valori 50 o 300 dell’intervallo di ingresso, il valore di uscita sarà minore o maggiore di 0 o 255. Ma la funzione analogWrite() supporta solo l’intervallo da 0 a 255. Perciò usiamo constrain() per assicurarci che il valore rientri in questo intervallo.
La funzione analogWrite() usa la PWM (Pulse Width Modulation) per regolare la luminosità del LED. Se vuoi saperne di più, dai un’occhiata al nostro tutorial su How use Arduino to control an LED with a Potentiometer.
Ecco fatto! Ora hai una luce regolata che diventa più luminosa quanto più è buio intorno. Se vuoi meno o più sensibilità, gioca con i valori dell’intervallo di ingresso (50, 300).
Costruire un rilevatore di direzione della luce
Possiamo facilmente modificare il nostro circuito di rilevamento della luce per farlo diventare un rilevatore di direzione della luce. Per farlo, sostituiamo semplicemente il trimmer con una seconda LDR. Come vedi sotto, il nuovo circuito è ancora un partitore di tensione ma con due LDR.
A seconda di quale LDR riceve più luce, la tensione su A0 aumenterà o diminuirà. Nota che non importa quanta luce ricevono le LDR. Che sia chiaro o buio, la tensione su A0 sarà circa la stessa. Ciò che conta è il rapporto. Più grande è la differenza di luce ricevuta dalle LDR, più A0 si discosterà dal valore medio di circa 2,5 V.
Costruiamo questo circuito sulla breadboard. Essendo essenzialmente lo stesso circuito di prima, rimuoviamo il trimmer e lo sostituiamo con una LDR.
La corrente scorre dalla linea di alimentazione positiva attraverso la serie delle due LDR fino alla linea negativa. Come prima, prendiamo il segnale (filo giallo) dal punto di giunzione e lo colleghiamo al Pin A0 dell’Arduino.
Qui sotto trovi il codice che useremo.
const int ldrPin = A0;
const int midValue = 500;
const int midRange = 10;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
Serial.print("LDR:");
Serial.println(ldrValue);
if (ldrValue > midValue + midRange) {
Serial.println("Left");
} else if (ldrValue < midValue - midRange) {
Serial.println("Right");
} else {
Serial.println("Middle");
}
delay(100);
}
Estendiamo il semplice codice del rilevatore di luce aggiungendo due variabili. midValue è il valore che ci aspettiamo di leggere da A0 quando entrambe le LDR sono esposte alla stessa quantità di luce. In teoria questo valore dovrebbe essere 1023/2 = 512 (metà dell’intervallo di ingresso). In pratica, la resistenza delle due LDR non è mai perfettamente identica e il valore reale sarà leggermente diverso.
const int midValue = 500; const int midRange = 10;
Per trovare questo punto medio, avvicina entrambe le LDR a una fonte luminosa con lo stesso angolo e distanza e leggi il ldrValue dal Monitor Seriale. Questo sarà il tuo valore per midValue. Nel mio caso ho letto circa 500, che è abbastanza vicino al valore teorico.
La costante midRange definisce la quantità di deviazione che ci aspettiamo da midValue prima di definire una direzione. Definisce una tolleranza. Per qualsiasi valore in quell’intervallo stamperemo che la luce è in posizione centrale – né a sinistra né a destra.
La funzione setup() rimane invariata. Inizializziamo solo il Monitor Seriale e impostiamo la modalità del pin.
Nella funzione loop() leggiamo ldrValue come prima e poi lo confrontiamo con midValue.
if (ldrValue > midValue + midRange) {
Serial.println("Left");
} else if (ldrValue < midValue - midRange) {
Serial.println("Right");
} else {
Serial.println("Middle");
}
Se il valore del sensore è maggiore del valore medio più la tolleranza, sappiamo che la LDR di sinistra ha ricevuto più luce e stampiamo “Left”. Se il valore è minore del valore medio meno la tolleranza, stampiamo “Right”. Nel caso rimanente, entrambe le LDR ricevono più o meno la stessa luce e stampiamo “Middle”. Nota che “left” e “right” dipendono da come è orientato il tuo circuito.
Un’ultima nota: puoi migliorare notevolmente la sensibilità direzionale posizionando le LDR in tubi in modo che ricevano solo luce direzionale. Qui sotto c’è una foto del mio semplice espediente per testare questo:
Aggiungendo i tubi posso rilevare con precisione la direzione da cui proviene la luce e nella prossima sezione ti mostrerò come controllare un servo con questo sistema.
Costruire un servo controllato dalla luce
I servomotori posizionali sono progettati per ruotare a un angolo specifico. Questo li rende una scelta naturale per provare il nostro rilevatore di direzione della luce. Potremo controllare l’angolo del servo e farlo puntare verso la direzione da cui proviene la luce.
Per prima cosa aggiungi il servo collegando la sua alimentazione alle linee di alimentazione (marrone è negativo e rosso è positivo). Poi collega l’ingresso del segnale del servo (giallo) con un filo arancione al Pin 9 dell’Arduino. Fatto!
Qui sotto trovi il codice per controllare il servo. È una piccola estensione del codice precedente. Se hai difficoltà a capire il codice e la sua spiegazione, dai un’occhiata al nostro tutorial su How to Control Servo Motors with Arduino, che fornisce più dettagli sui servomotori.
#include "Servo.h"
#define IR_RECEIVE_PIN 8
const int ldrPin = A0;
const int servoPin = 9;
const int range = 780;
const int mid = 1600;
const int midValue = 500;
const int midRange = 10;
int ldrValue = 0;
int angle = 0;
Servo servo;
void rotate(int angle) {
angle = map(angle, 0, 180, mid - range, mid + range);
servo.writeMicroseconds(angle);
}
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
servo.attach(servoPin);
}
void loop() {
ldrValue = analogRead(ldrPin);
int angle = (ldrValue - midValue) * 0.8;
angle = constrain(angle, -90, +90);
if (angle > midRange) {
rotate(90 + angle);
} else if (angle < -midRange) {
rotate(90 + angle);
} else {
rotate(90);
}
delay(100);
}
Il codice ha alcune costanti aggiuntive come range e mid che sono usate nella funzione rotate(), che ruota il servo a un angolo dato. A parte le costanti e le funzioni relative al servo, il resto del codice è molto simile a quello visto sopra.
Le parti interessanti avvengono tutte nella funzione loop(). Lì convertiamo il ldrValue in un angolo sottraendo il midValue da ldrValue e moltiplicando per un fattore di 0,8.
int angle = (ldrValue - midValue) * 0.8;
Il fattore 0,8 va regolato in base alle dimensioni/fisica del tuo sistema; in particolare alla distanza tra le LDR. Come prima, non c’è garanzia che il valore dell’angolo sia nell’intervallo da -90 a +90 gradi. Perciò lo limitiamo:
angle = constrain(angle, -90, +90);
Infine, decidiamo se ruotare il servo a sinistra o a destra in base all’angolo rilevato. Se la variazione dell’angolo è piccola (-midRange… +midRange), manteniamo il servo a 90 gradi.
if (angle > midRange) {
rotate(90 + angle);
} else if (angle < -midRange) {
rotate(90 + angle);
} else {
rotate(90);
}
Con questo circuito e codice puoi ora controllare l’angolo del servo in base alla direzione della luce. Potresti usarlo per costruire un’auto che si dirige verso la luce. Con due di questi rilevatori di direzione della luce orientati perpendicolarmente potresti costruire un pannello solare che segue il movimento del sole per massimizzare le prestazioni.
Tuttavia, per applicazioni di inseguimento della luce è preferibile usare un servo continuo invece del servo posizionale usato qui. Questo ti permetterebbe di ruotare il servo in senso negativo o positivo fino a raggiungere il punto medio. Per maggiori dettagli leggi il nostro tutorial sulle differenze tra Positional versus Continuous Servos.
Alcune altre applicazioni dei rilevatori di luce sono descritte di seguito.
Applicazioni
Domotica
Usando un rilevatore di luce, puoi automatizzare varie attività in casa. Per esempio, puoi programmare il tuo Arduino per accendere le luci quando rileva buio e spegnerle quando rileva luce. Questo aiuta a risparmiare energia e offre comodità.
Sistemi di sicurezza
I rilevatori di luce possono essere usati nei sistemi di sicurezza per attivare allarmi o telecamere quando c’è un improvviso cambiamento nell’intensità luminosa. Questo aiuta a rilevare intrusi o attività insolite in un’area specifica.
Monitoraggio delle piante
La luce è fondamentale per la crescita delle piante. Usando un rilevatore di luce, puoi monitorare la quantità di luce ricevuta dalle tue piante e assicurarti che abbiano le condizioni ottimali per crescere. Questo è particolarmente utile per il giardinaggio indoor o le serre.
Stazioni meteorologiche
I rilevatori di luce possono essere usati anche nelle stazioni meteorologiche per misurare l’intensità della luce solare. Queste informazioni possono essere usate per analizzare i modelli meteorologici, calcolare la radiazione solare o persino prevedere le condizioni meteo.
Installazioni artistiche
I rilevatori di luce possono essere incorporati in installazioni artistiche interattive per creare effetti di luce dinamici e reattivi. Rilevando i cambiamenti nella luce ambientale, l’Arduino può controllare la luminosità, il colore o il pattern delle luci, creando un’esperienza immersiva per gli spettatori.
Questi sono solo alcuni esempi delle molte applicazioni del rilevamento della luce con Arduino. La versatilità di Arduino e la sua compatibilità con vari sensori lo rendono una scelta eccellente per realizzare progetti basati sulla luce.
Riepilogo
In questo tutorial abbiamo imparato come rilevare la luce usando un Arduino ed esplorato varie applicazioni dei sensori di luce nei progetti maker. Usando una fotoresistenza, possiamo facilmente misurare l’intensità luminosa nell’ambiente.
Abbiamo iniziato comprendendo il concetto base di una fotoresistenza e come funziona. Una fotoresistenza è un tipo di resistore che cambia la sua resistenza in base alla quantità di luce che la colpisce. Questa proprietà la rende un componente ideale per il rilevamento della luce.
Poi abbiamo costruito un semplice rilevatore di luce usando un Arduino e una fotoresistenza. Collegando la fotoresistenza a un pin analogico dell’Arduino, siamo riusciti a leggere il valore di resistenza e convertirlo in un valore corrispondente di intensità luminosa. Questo ci ha permesso di creare un sistema base di rilevamento della luce.
Successivamente abbiamo esplorato applicazioni più avanzate dei sensori di luce. Abbiamo costruito un interruttore automatico che accende o spegne una sorgente luminosa in base alle condizioni di luce ambientale. Questo può essere utile per risparmiare energia controllando automaticamente l’illuminazione di una stanza.
Abbiamo anche costruito un sistema di luce regolata, dove l’intensità di una sorgente luminosa viene adattata in base alle condizioni di luce circostanti. Questo aiuta a mantenere un livello costante di illuminazione in un’area specifica.
Infine, abbiamo costruito un sistema con servo controllato dalla luce. Usando i valori di intensità luminosa della fotoresistenza, siamo riusciti a controllare il movimento di un servomotore. Questo apre possibilità per creare progetti interattivi che rispondono ai cambiamenti di luce.
Speriamo che questo tutorial ti abbia fornito una solida base per lavorare con i sensori di luce e Arduino. Sentiti libero di esplorare le varie applicazioni menzionate e lascia che la tua creatività brilli!
Domande frequenti
Ecco alcune domande frequenti sul rilevamento della luce con Arduino:
Posso usare una scheda microcontrollore diversa da Arduino?
Sì, puoi usare altre schede microcontrollore come ESP32, Raspberry Pi o STM32 per rilevare la luce. I principi e le tecniche discussi in questo post si applicano a qualsiasi scheda che supporti ingressi analogici.
Come determino la polarità di una fotoresistenza?
Le fotoresistenze, o LDR, sono componenti non polarizzati. Ciò significa che non hanno un terminale positivo o negativo specifico. Puoi collegarle in qualsiasi orientamento senza preoccuparti della polarità.
Qual è l’intervallo di resistenza di una fotoresistenza?
La resistenza di una fotoresistenza varia con l’intensità della luce che la colpisce. In luce intensa la resistenza diminuisce, al buio aumenta. L’intervallo tipico va da alcune centinaia di ohm in luce intensa a diversi megaohm al buio. È importante scegliere valori di resistori appropriati nel circuito per garantire un rilevamento accurato.
Come posso calibrare il circuito di rilevamento della luce?
Per calibrare il circuito, puoi regolare i valori dei resistori nel partitore di tensione collegato alla fotoresistenza. Misurando la tensione di uscita a diversi livelli di luce, puoi determinare i valori soglia per il rilevamento. Questa calibrazione assicura che il circuito risponda accuratamente ai livelli di luce desiderati.
Posso usare più fotoresistenze in un singolo progetto?
Sì, puoi usare più fotoresistenze in un progetto. Collegandole a diversi ingressi analogici di Arduino o altri microcontrollori, puoi monitorare i livelli di luce da varie posizioni o direzioni. Questo è utile in applicazioni come sistemi di sicurezza, illuminazione automatica o monitoraggio ambientale.
Posso usare un modulo sensore di luce invece di una fotoresistenza?
Sì, puoi usare moduli sensore di luce che includono fotoresistenze o altri sensori di luce integrati. Questi moduli spesso offrono funzionalità aggiuntive come sensibilità regolabile o uscite digitali. Quando usi un modulo, consulta il datasheet o la documentazione per capire il pinout e le caratteristiche operative.
In cosa differiscono le fotoresistenze dai sensori di movimento PIR?
Fotoresistenze e sensori di movimento a infrarossi passivi (PIR) sono entrambi usati per rilevare cambiamenti ambientali, ma funzionano con principi diversi. Le prime rilevano variazioni di intensità luminosa, i secondi rilevano variazioni di radiazione infrarossa causate da oggetti in movimento. Le fotoresistenze sono adatte per monitorare i livelli di luce, mentre i sensori PIR sono ideali per rilevare movimenti di persone o animali.
Se hai altre domande o hai bisogno di assistenza, sentiti libero di chiedere nella sezione commenti qui sotto.
Link
Di seguito alcuni link utili per approfondire
- Light Sensor (Photoresistor) With Arduino in Tinkercad
- How to Use Photoresistors to Detect Light on an Arduino
- Arduino Photo Resistor Tutorial (Step by Step) – YouTube
- Understanding this photoresistor circuit – General Electronics
- How to Use a Photoresistor (or Photocell) – Arduino Tutorial
- photoresistor how to use it – General Electronics
- Photoresistor: Basics and Arduino Tutorial
