Archivi tag: coding

Corso di Processing – lezione 07

Blocchi di Codice e Flusso di Esecuzione in Processing: setup() e draw()

Quando si scrive un programma in Processing, è fondamentale comprendere il flusso di esecuzione del codice. Un programma può essere composto da un insieme di istruzioni sequenziali, ma spesso abbiamo bisogno di strutturarlo in modo più organizzato, definendo ciò che deve accadere una sola volta e ciò che deve essere ripetuto continuamente.

Per questo motivo, Processing utilizza due funzioni principali:

  • setup(): eseguita una sola volta all’inizio del programma.
  • draw(): eseguita continuamente in un ciclo, permettendo di aggiornare la grafica in tempo reale.

1. Il Blocco setup()

La funzione setup() viene eseguita una sola volta all’avvio del programma. Qui possiamo definire le impostazioni iniziali, come la dimensione della finestra, il colore di sfondo e altre configurazioni che non devono cambiare nel tempo.

Esempio: Inizializzare una finestra con sfondo fisso

1void setup() {
2  size(400, 400); // Imposta la dimensione della finestra
3  background(200, 200, 255); // Sfondo celeste
4}

In questo caso, background(200, 200, 255); viene eseguito una sola volta all’inizio, quindi lo sfondo non cambia più.

Esercizio: Modificate il codice per impostare uno sfondo giallo e una finestra di dimensione 500×500.

2. Il Blocco draw()

La funzione draw() viene eseguita continuamente, creando un effetto di animazione o interattività.

Esempio: Disegnare un cerchio che segue il mouse

1void setup() {
2  size(400, 400);
3  background(255); // Sfondo bianco
4}
5 
6void draw() {
7  fill(255, 0, 0, 150); // Rosso con trasparenza
8  noStroke();
9  ellipse(mouseX, mouseY, 50, 50); // Disegna un cerchio che segue il mouse
10}

Esercizio: Modificare il codice per cambiare il colore del cerchio ogni volta che il mouse si muove (suggerimento: ricordate come usare la funzione random() vista nella lezione precedente).
Continua a leggere

Lezione 6 – Corso di Elettronica Creativa con Arduino Sensor Kit

Sensore di luminosità

Inizio questa lezione con un’informazione che va a correggere quanto scritto sul sito Arduino in riferimento al Grove Light Sensor in cui erroneamente viene indicato il dispositivo come fotoresistenza, in realtà si tratta di un fototransistor e ciò, soprattutto per i neofiti può creare qualche problema di comprensione, soprattutto perché lo sketch presentato non fornisce esattamente quanto indicato.

Fotoresistenza o fototransistor?

  • Versione 1.0 del Grove-Light Sensor – usava una classica CdS LDR GL5528, cioè una vera fotoresistenza.
  • Versione 1.1 / 1.2 (quella montata sullo Shield dell’Arduino Sensor Kit) – per ragioni RoHS (il cadmio delle CdS è vietato) Seeed ha sostituito l’LDR con un LS06-S: si tratta di un sensore a fototransistor lineare (tecnicamente una fotodiodo-transistor) che “mima” la vecchia fotoresistenza ma è più rapido e lineare.

Il sito di Arduino non ha aggiornato la terminologia e continua a chiamarlo “photo-resistor”.

Ora come possiamo fare per non creare problemi a chi inizia?

Innanzi tutto se volete utilizzare una fotoresistenza vi rimando alle mie slide: Alfabeto di Arduino – Lezione 3, ma attenzione in questo caso dovrete usare una breadboard e realizzare un circuito con un resistore da 10Kohm e una fotoresistenza, in questo modo usando lo sketch presente sul sito Arduino o quelli indicati nelle mie slide tutto funzionerà ed avrete valori che variano tra 0 e circa 900, coll’esempio sul sito Arduino avrete un valore massimo più basso.

Dal punto di vista teorico cosa succede (usando una fotoresistenza):

La fotoresistenza (o LDR, Light Dependent Resistor) per rilevare l’intensità della luce:

  • la resistenza della fotoresistenza diminuisce quando l’intensità luminosa aumenta;
  • la resistenza della fotoresistenza aumenta quando l’intensità luminosa diminuisce.

L’ADC dell’Arduino la converte in un numero intero da 0 (buio) a 1023 (molta luce) quindi la lettura avviene tramite l’istruzione analogRead() per questo kit collegheremo direttamente il modulo al pin A3 e quindi nel codice scriveremo: analogRead(A3).

1// Prof. Maffucci Michele
2// Uso del sensore di luminosità
3// 27.05.2025
4 
5int sensore_luce = A3;   // pin del sensore di luminosità
6 
7void setup() {
8  analogReference(INTERNAL);   // 1,1 V; attivare PRIMA di qualsiasi analogRead
9  delay(3);                    // attesa minima per la stabilizzazione della reference
10  Serial.begin(9600);          // avvia la comunicazione seriale
11}
12 
13void loop() {
14  int luce_grezza = analogRead(sensore_luce);      // legge il valore grezzo dal pin A3
15  int luce = map(luce_grezza, 0, 1023, 0, 100);    // converte 0–1023 in 0–100 (percentuale)
16 
17Serial.print("Livello di luce: ");
18  Serial.println(luce);  // stampa il valore di luce sul Monitor Seriale
19 
20delay(1000);           // attende 1 secondo prima della prossima lettura
21}

Le cose sono simili con il Grove-Light Sensor sull’Arduino Sensor Kit, ma avrete, come dicevo, valori massimi più bassi, che raggiungo circa i 750 con la torcia dello smartphone direttamente puntata sul fototransistor. Dal punto di vista funzionale nulla cambia ma è importante aver ben presente che siamo lavorando con componenti elettronici diversi che hanno comportamenti simili.

Con lo sketch precedente otterremo sulla serial monitor questi valori:

Il fatto che il valore massimo si fermi attorno a 750 è in realtà perfettamente coerente con l’elettronica del modulo.

Quindi per ora, per chi inizia potete far finta che il componente sull’Arduino Sensor Kit è una fotoresistenza e se desiderate potete fermarvi a questo punto.

Continua a leggere

Corso di Processing – lezione 06

Gestione del colore in Processing ed utilizzo dei commenti

Il colore è un elemento essenziale nella grafica digitale. In Processing, la gestione dei colori avviene tramite il modello RGB (Red, Green, Blue), in cui ogni colore è definito dalla combinazione di tre valori compresi tra 0 e 255. Esploriamo ora come applicare il colore agli oggetti grafici nei nostri sketch.

1. Il Modello RGB

I colori sugli schermi dei computer vengono generati combinando le tre componenti principali:

  • Rosso (Red)
  • Verde (Green)
  • Blu (Blue)

Ciascuna componente può assumere valori da 0 (assenza di colore) a 255 (massima intensità). Per esempio:

1size(400, 400); // Imposta la finestra
2background(0, 0, 255); // Sfondo blu

Alcuni esempi di colori nel modello RGB:

  • Nerofill(0, 0, 0);
  • Biancofill(255, 255, 255);
  • Rossofill(255, 0, 0);
  • Verdefill(0, 255, 0);
  • Blufill(0, 0, 255);
  • Giallofill(255, 255, 0);
  • Cianofill(0, 255, 255);
  • Magentafill(255, 0, 255);

Selezione del Colore in Processing

Quando si lavora con i colori in Processing, può sorgere una domanda fondamentale: come faccio a conoscere i valori RGB di un colore specifico?

Per facilitare questa operazione, Processing mette a disposizione un Color Selector, uno strumento intuitivo che permette di scegliere facilmente un colore e ottenere i relativi valori numerici.

Come accedere al Color Selector

È possibile aprire il selettore di colori direttamente dall’ambiente di sviluppo di Processing andando su:
MenuStrumentiSelezionatore dei colori…

Una volta aperta la finestra del selettore, si può esplorare la gamma di colori disponibili e ottenere i relativi valori RGB(Rosso, Verde, Blu). Inoltre, lo strumento fornisce informazioni anche sui valori:

  • HSB (Hue, Saturation, Brightness)
  • Esadecimale (Hex), utile per il web design e altre applicazioni grafiche.

2. Applicare il colore agli oggetti

Per impostare il colore di riempimento di una figura, utilizziamo la funzione fill(), mentre stroke() permette di cambiare il colore del contorno.

Esempio: disegnare un cerchio colorato

1size(400, 400);
2background(200); // Sfondo grigio
3fill(255, 0, 0); // Colore rosso
4stroke(0, 0, 0); // Contorno nero
5ellipse(200, 200, 150, 150);

Esercizio: Prova a cambiare il colore del cerchio variando i valori RGB nella funzione fill().
Continua a leggere

Nuova sezione dedicata a Processing!

Ho appena pubblicato una pagina che raccoglie tutte le mie lezioni, esercizi e materiali su Processing in un unico posto comodo da consultare.

Trovate il link diretto nel banner “Processing”, ben visibile nella colonna destra del sito: cliccate e accedete alla raccolta completa, in continuo aggiornamento.

Se state seguendo il corso o cercate ispirazione per le vostre attività in classe, date uno sguardo e fatemi sapere cosa ne pensate ed ovviamente se avete suggerimenti nella realizzazione di lezioni non esitate a segnalarmeli.

Grazie

Lezione 5 – Corso di Elettronica Creativa con Arduino Sensor Kit

Il Buzzer

Quando progettiamo un impianto di automazione abbiamo quasi sempre bisogno di avvisare l’utente di uno stato o di un’anomalia. Oltre alle classiche spie luminose, un modo immediato per “farsi sentire” è impiegare un buzzer, noto colloquialmente come cicalino. Questo piccolo attuatore trasforma un segnale elettrico in un impulso sonoro che può variare da un semplice beep continuo a brevi toni di diversa frequenza.

Tipologie principali di buzzer

Attivo
Contiene un oscillatore interno che genera automaticamente la frequenza fissa non appena viene alimentato.
Con Arduino basta portare il pin di alimentazione a livello HIGH/LOW per abilitare o silenziare il suono.

Passivo
Non possiede oscillatore: necessita di un’onda quadra esterna per farlo vibrare.
Arduino può pilotarlo con PWM (analogWrite) o con la funzione tone() per scegliere la frequenza desiderata.

Tecnologie costruttive

I buzzer – siano essi attivi o passivi – possono realizzarsi con due differenti principi fisici:

  • Magnetici
    una bobina varia il campo magnetico e fa oscillare una sottile membrana metallica.
  • Piezoelettrici
    un disco di materiale piezo si deforma quando riceve tensione, generando la vibrazione acustica.

La scelta fra le due tecnologie dipende principalmente da:

  1. Segnale di pilotaggio disponibile (continua, PWM, ampiezza)
  2. Pressione sonora richiesta (volume)
  3. Spazio e forma concessi dal progetto

Come funziona un buzzer attivo

All’interno è presente un piccolo circuito oscillatore che, alimentato in continua, fa variare il campo magnetico di una bobina. La bobina è rigidamente accoppiata a una membrana, la quale vibra alla frequenza impostata dal circuito e produce un suono costante. In pratica: lo accendiamo – suona; lo spegniamo – tace.

Dati tecnici

  • Tensione nominale: 6V DC
  • Tensione di esercizio: 4-8V DC
  • Corrente nominale: < 30mA
  • Tipo di suono: segnale acustico continuo
  • Frequenza di risonanza: ~2300 Hz

Come funziona un buzzer passivo

Il buzzer passivo è sprovvisto di oscillatore e si comporta come un piccolo altoparlante: emette il tono dell’esatta frequenza del segnale che riceve. Con Arduino possiamo quindi:

  • generare una frequenza fissa con tone(pin, freq);
  • modulare il duty-cycle tramite analogWrite() per variare il volume;
  • creare melodie cambiando velocemente frequenza e durata.

Dati tecnici

  • Tensione nominale: 5V DC
  • Tensione di esercizio: 4-8V DC
  • Corrente nominale massima: ≤ 32 mA
  • Min. Uscita audio a 10 cm: 85 dB
  • Temperatura di esercizio: da 20°C a 45°C

Poiché vogliamo utilizzare il buzzer dell’Arduino Sensor Kit a questo punto possiamo chiederci:

“ma di che tipo è il buzzer di questo kit?”

E’ un buzzer di tipo passivo.

Nelle spiegazioni abbiamo parlato di PWM, di seguito alcuni dettagli, ma se volete approfondire consultate le mie slide: Alfabeto Arduino – Lezione 2 e l’approfondimento su questo sito: Arduino – Approfondimenti sulla modulazione di larghezza di impulso (PWM).

Per uno studio ancora più approfondito: Secrets of Arduino PWM.

Che cos’è il PWM

La modulazione di larghezza d’impulso, o PWM (Pulse Width Modulation), è una tecnica che permette di ottenere effetti analogici usando mezzi digitali. Il controllo digitale genera un’onda quadra, un segnale che passa continuamente da acceso (ON) a spento (OFF). Variando la frazione di tempo in cui il segnale rimane acceso (alto) rispetto a quella in cui rimane spento (basso), è possibile simulare tensioni intermedie tra lo 0 V (spento) e i 5 V (acceso al 100 %). Il periodo in cui il segnale resta acceso si chiama larghezza dell’impulso. Modificando (ovvero modulando) questa larghezza si ottengono valori analogici diversi. Se la commutazione ON/OFF avviene abbastanza velocemente, il segnale risulta percepito come una tensione “media” continua compresa tra 0 V e 5 V.
Questo segnale PWM può dunque essere usato per controllare con facilità un buzzer passivo.
Per generare segnali PWM con Arduino si utilizza la funzione analogWrite(), mentre digitalWrite() produce solo segnali in corrente continua (DC).
Sulla tua scheda ci sono sei pin digitali contrassegnati dal simbolo “~” (tilde), che indica la capacità di gestire un segnale PWM: 3, 5, 6, 9, 10, 11. Questi sono chiamati pin PWM.

Collegamenti

Come abbiamo detto precedentemente Il buzzer del kit è passivo: non produce autonomamente il tono, ma vibra quando riceve un’onda quadra. Con analogWrite() inviate un’onda PWM; variando il duty-cycle (0-255) variate il volume.

Esempio 1:  emissione di un beep

1/* Prof. Maffucci Michele
2   beep con il buzzer
3   14.05.25
4*/
5 
6const int BuzzerPin = 5;       // D5 ha anche il simbolo ~ = PWM
7 
8void setup() {
9  pinMode(BuzzerPin, OUTPUT);  // imposta il pin come uscita
10}
11 
12void loop() {
13  analogWrite(BuzzerPin, 128); // 50 % di duty-cycle ≈ volume medio
14  delay(1000);                 // suona per 1 s
15  analogWrite(BuzzerPin, 0);   // silenzio
16  delay(1000);                 // pausa di 1 s
17}

Funzionamento del codice

  • pinMode()
    imposta il pin in uscita, così può fornire tensione
  • analogWrite(pin, val)
    genera un’onda quadra a ~490 Hz sul pin; val è il duty-cycle (0 = 0 %, 255 = 100 %)
  • delay(ms)
    pausa del programma – qui determina per quanto tempo il buzzer resta attivo/inattivo

Continua a leggere