Lezione 5 – Corso di Elettronica Creativa con Arduino Sensor Kit

Lascia una risposta

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

vedi sorgente
stampa?
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

Esempio 2: utilizziamo ora un trimmer per modificare il delay che varia tra 100 e 1000 millisecondi, per fare questa operazione utilizzeremo la funzione map che rimapperà i valori presenti su A0 nell’intervallo 100, 1000.

vedi sorgente
stampa?
1/* Prof. Michele Maffucci
2 
3Utilizzo di un buzzer passivo per riprodurre
4   un tono in base alla frequenza impostata
5   da un trimmer collegato al pin A0
6 
714.05.25
8*/
9 
10// pin (PWM) a cui è collegato il buzzer
11byte buzzerPin = 5;
12 
13// variabile in cui memorizzare la frequenza del tono
14int  intonazionePin = 0;
15 
16// variabile in cui memorizzare il valore restituito dall'analogRead
17int val = 0;
18 
19// frequenza del tono
20unsigned int frequenza;
21 
22// durata del tono
23unsigned long durata = 10;
24 
25void setup()
26{
27  // inizializzazione pin a cui è collegto il buzzer
28  pinMode(buzzerPin, OUTPUT);
29}
30 
31void loop()
32{
33   // valore analogico letto su A0 inserito con il trimmer
34   val = analogRead(A0);
35 
36// Togliere il commento per valutare
37// valore massimo/minimo del valore restituito
38// dall'analogRead in questo modo si potranno
39// inserire nella map i valori massimi e minimi
40// dell'intervallo di partenza
41 
42// Serial.println(val);
43// delay(1000);
44 
45// ValMax = 285, ValMin = 719
46// riconvertiti nell'intervallo 1000, 5000
47 
48// frequenza assunerà un valore tra 1000 Hz e 5000 Hz
49   frequenza = map(val, 285, 719, 1000, 5000);
50 
51// emissione del tono
52   tone(buzzerPin, frequenza, durata);
53 
54// pausa di 1 millisecondo
55   delay(1);
56}

Esempio 3: scala di note

In questo esempio viene utilizzata la struttura dati array[] per approfondirne l’utilizzo seguire i due link:

vedi sorgente
stampa?
1/* Prof. Maffucci Michele
2 
3scala di note
4   14.05.25
5*/
6 
7const int BuzzerPin = 5;
8const int scala[] = {262, 294, 330, 349, 392, 440, 494, 523}; // frequenza note
9void setup() {}
10void loop() {
11  for (int i = 0; i < 8; i++) {
12    tone(BuzzerPin, scala[i], 250); // 250 ms ciascun tono
13    delay(300);
14  }
15  delay(1000);
16}

Esercizio 4: allarme intermittente controllato dal pulsante

vedi sorgente
stampa?
1/* Prof. Maffucci Michele
2 
3allarme intermittente controllato dal pulsante
4   14.05.25
5*/
6 
7#define BUZZER 5
8#define PULSANTE 4
9 
10void setup() {
11  pinMode(BUZZER, OUTPUT);
12  pinMode(PULSANTE, INPUT);
13}
14 
15void loop() {
16  if (digitalRead(PULSANTE)) {        // premuto?
17    tone(BUZZER, 3000);               // allarme continuo
18  } else {
19    noTone(BUZZER);                   // silenzio
20  }
21}

Esercizio 5: sirena con frequenza variabile

vedi sorgente
stampa?
1/* Prof. Maffucci Michele
2 
3sirena con frequenza variabile
4   14.05.25
5*/
6 
7const int BuzzerPin = 5;
8void setup() {}
9void loop() {
10  for (int f = 1000; f <= 4000; f += 20) {
11    tone(BuzzerPin, f, 10);
12    delay(10);
13  }
14}

L’istruzione for è usata per ripetere, per un determinato numero di volte, una serie di istruzioni, la ripetizione avviene se risulta vera una certa condizione logica, nel caso risulti falsa si esce dal ciclo. Per approfondirne l’uso seguire il link.

Buon Coding a tutti 🙂

Articoli correlati:

  1. Lezione 4 – Corso di Elettronica Creativa con Arduino Sensor Kit
  2. Lezione 1 – Corso di Elettronica Creativa con Arduino Sensor Kit
  3. Lezione 2 – Corso di Elettronica Creativa con Arduino Sensor Kit
  4. Lezione 3 – Corso di Elettronica Creativa con Arduino Sensor Kit
  5. Controlliamo DotBot con Arduino

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.