Archivi tag: buzzer

Arduino: Sensore Piezoelettrico

Per effettuare una misura dinamica di pressione o allungamento o vibrazione di superfici è possibile utilizzare sensori che si basano su quello che viene comunemente chiamato “effetto piezoelettrico”, la parola “piezoelettrico” deriva dalla parola greca “piezein” che significa premere. La piezoelettricità è la proprietà di alcuni cristalli, che se sottoposti all’azione di una forza esterna esterna, provoca in essi una migrazione di cariche elettriche. Con l’utilizzo di un apposito circuito elettronico, la migrazione di cariche elettriche può essere tradotta una differenza di potenziale.

L’effetto piezoelettrico è un effetto reversibile, ciò vuol dire che una volta che abbiamo applicato una variazione meccanica sul cristallo si ottiene una variazione di cariche e in maniera analoga quando viene fornita una carica elettrica al sensore, questo si allungherà o si comprimerà.

Quando applichiamo al cristallo una forza meccanica le cariche elettriche si spostano accumulandosi sulle facce opposte del cristallo:

I materiali piezoelettrici utilizzati possono essere naturali o di sintesi dopo polarizzazione:

Materiali naturali

  • Quarzo cristallino (SiO2)
  • sale di Rochelle o sale di Seignette (tartrato di Sodio e Potassio)
  • Tormalina

Materiali di sintesi

  • Piezoceramici
    • Titanio Zirconato di Piombo (PZT)
    • Titanio di Bario (BaTiO3)

L’effetto piezoelettrico può essere sfruttato per:

  • generare energia elettrica
  • in campo medicale: ecografi
  • sensori di vibrazione per allarmi
  • sensori di impatto
  • sonar (in campo militare)
  • viene utilizzato negli accendini
  • per gli orologi
  • per rilevare variazioni meccaniche
  • produrre suoni, come nelle chitarre elettriche
  • messa a fuoco di strumenti ottici
  • sensori in capo ambientale per il radio tracking
  • ecc…

Esempio tipico è quello dei cicalini piezoelettrici, conosciuti anche come buzzer, che vengono utilizzate in molte delle sperimentazioni con Arduino, infatti sottoponendo a tensione elettrica e ad una determinata frequenza il materiale piezoelettrico all’interno del buzzer, viene posta in oscillazione e questo muovendo l’aria, dall’apposita apertura collocata sul buzzer, permette di percepire il suono.

Nelle sperimentazioni con Arduino è tipico usare sensori piezoelettrici economici che generalmente hanno forma circolare. Questi sensori non hanno gradi di precisioni elevati e sono utilizzati prevalentemente per rilevare vibrazioni. Per capire come sono realizzati questi sensori immaginate ad un sandwich in in cui l’elemento piezoelettrico, costituito da piombo-zirconato è inserito tra due piastre metalliche. Il loro utilizzo in circuito con microcontrollori è particolarmente semplice anche perché funzionano con le tensioni e le correnti che si hanno direttamente dai pin di uscita di questi circuiti elettronici.

Nel caso abbiate necessità di consultare i dati tecnici di diverse tipologie di dispositivi piezoelettrici vi rimando al questi due datasheet:

Realizziamo ora un circuito che ci permette, mediante il sensore piezoelettrico e Arduino, la rilevazione di vibrazioni e urti. Colleghiamo il sensore sulla breadboard e dalla breadboard ad Arduino, in questo modo eviteremo di far vibrare il sensore quando tocchiamo Arduino per effettuare i collegamenti.

Colleghiamo il filo rosso del sensore ad un ingresso analogico di Arduino, ad esempio A0 mentre il filo nero lo colleghiamo. In parallelo al sensore bisognerà inserire una resistore con resistenza da 1MOhm, ciò è necessario perché un piezo è un componente con caratteristiche capacitive e la resistenza in parallelo permette di assorbire le cariche che vengono accumulate sulla capacità.

Il circuito proposto è estremamente semplice ed è riportato di seguito:

Esempio 1

/*
 * Prof. Maffucci Michele
 * data: 22.01.2021
 * Lettura sensore piezoelettrico
 * 
 * Esempio 1: stampa dei valori sulla serial monitor
 * e visualizzazione del grafico sulla serial Plot
 * 
 * Si ricorda che la Serial Plotter e la Serial Monitor
 * non possono essere usati contemporaneamente
 * 
 */


void setup(){
   // Inizializzazione della serial monitor
  Serial.begin(9600);
}

void loop(){
  // val contiene il valore letto dal sensore  
  int val = analogRead(A0);
  Serial.println(val);
  delay(20);
}

Se si selezione Serial Plotter dal menù Tools:

si avrà la visualizzazione del grafico degli urti provocati sul sensore:

Come si può notare i valori sull’asse delle ordinate è compreso tra 0 e 1023.

Esempio 2

Arduino, come già spiegato nelle mie slide: Alfabeto di Arduino – Lezione 4, non è in grado di leggere direttamente valori di tensione, bisognerà utilizzare il convertitore analogico/digitale (ADC) integrato in esso per convertire una tensione elettrica in un valore numerico. L’ADC di Arduino è a 10 bit, quindi potrà mappare valori compresi tra 0V e 5V in valori numerici compresi tra 0 e 1023. (1024 valori), pertanto si avrà una risoluzione di 5/1024 = 4,88 mV.

Per ottenere la tensione elettrica partendo dai valori restituiti dall’ADC, sarà sufficiente prendere il valore restituito dall’analogRead() e moltiplicarlo per la tensione unitaria corrispondente ad una unità 5/1024 = 4,88 mV. Traduciamo questo in codice per visualizzare la tensione elettrica sulla Serial Plotter.

/*
 * Prof. Maffucci Michele
 * data: 22.01.2021
 * Lettura sensore piezoelettrico
 * 
 * Esempio 2: stampa dei valori della tensione elettrica
 * sulla Serial Monitor e Serial Plotter
 * resitituita dal sensore nell'intervallo 0V - 5V
 * 
 * Si ricorda che la Serial Plotter e la Serial Monitor
 * non possono essere usati contemporaneamente
 * 
 */

void setup(){
   // Inizializzazione della serial monitor
  Serial.begin(9600);
}

void loop(){
  // val contiene il valore letto dal sensore  
  int val = analogRead(A0);
  // tensione contiene il valore di tensione elettrica
  float tensione = val *(5.0/1024);
  Serial.println(tensione);
  delay(20);
}

Esercizio 1

Realizziamo un interruttore on/off, possiamo utilizzare gli esempi già disponibili all’interno dell’IDE di Arduino e che in altre occasioni ho utilizzato su questo sito.  L’idea è quella di realizzare un sistema antirimbalzo software (debounce) e attivare l’on o l’off su un LED se l’intensità della forza meccanica impressa è superiore ad un valore di soglia che impostiamo nel codice.

Esercizio 2

Collegare 10 LED ad Arduino ed utilizzare un sensore piezoelettrico per accendere una quantità di LED proporzionale alla forza impressa sul sensore.

Esercizio 3

Realizziamo un dimmer, un sistema in grado di regolare l’intensità luminosa di un LED. La regolazione dell’intensità luminosa sarà fatto toccando il sensore piezoelettrico. Il doppio tocco veloce (in un intervallo di tempo prestabilito da voi) inverte la modalità di variazione dell’intensità luminosa (aumentare/diminuire), nel caso non si riesca a realizzare lo sketch con il doppio tocco veloce, utilizzare un pulsante esterno per invertire la modalità intensità luminosa prodotta.

Esercizio 4

Utilizzando la stessa logica di funzionamento dell’esercizio 2, utilizzare ora una striscia LED per misurare l’intensità della forza meccanica con cui sollecitiamo il sensore piezoelettrico.

Buon Coding a tutti 🙂

Arduino: utilizzo di buzzer attivi e passivi – lezione 1

Nella progettazione di un sistema di automazione sono molto spesso previsti apparati di interazione e di allarme che potranno essere visivi o sonori. Per quanto riguarda gli apparati sonori spesso vengono utilizzati dei buzzer, chiamati anche cicalini. Con questo dispositivo potremo quindi segnalare lo stato di un sistema.

I buzzer possono essere di due tipi:

  • attivi
  • passivi

I buzzer possono essere di tipo magnetico o piezoelettrici la scelta del tipo dipende sostanzialmente da tre fattori:

  1. segnale di pilotaggio
  2. potenza di uscita richiesta
  3. spazio fisico disponibile

Buzzer attivo

Un buzzer attivo usa un oscillatore interno che permette di emettere un tono a frequenza fissa se viene alimentato con una tensione continua.

L’oscillatore interno è in grado di modificare il campo magnetico di una bobina a cui è connesso meccanicamente una membrana che oscillerà alla frequenza fissata dall’oscillatore.

Con Arduino si potrà realizzare un sistema di automazione in grado di comandare l’emissione del suono abilitando o disabilitando l’alimentazione del buzzer.

Caratteristiche tecniche di un buzzer attivo

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

Buzzer passivo

Un buzzer passivo non possiede un oscillatore interno e quindi è indispensabile un circuito esterno in grado di generare un’onda quadra che mettere in oscillazione la membrana interna del buzzer, questi attuatori potranno così emettere toni a diversa frequenza.

Con Arduino si potrà realizzare un sistema di automazione in grado di comandare l’emissione del suono per un certo tempo ad una determinata frequenza utilizzando il la modulazione digitale PWM.

Caratteristiche tecniche di un buzzer attivo

  • 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

Pilotare un buzzer con Arduino

Per produrre un suono con Arduino si utilizza la funzione tone, il link vi rimanda al references di Arduino in cui troverete tutti i dettagli di utilizzo della funzione.

L’istruzione che verrà utilizzata è:

tone(pin, frequenza)
tone(pin,frequenza,durata)
  • pin: sarà il pin (PWM) su cui sarà presente il segnale modulato a cui verrà connesso il buzzer.
  • frequenza: frequenza del suono emesso. (unsigned int)
  • durata: la durata del tono espressa in millisecondi. (unsigned long)

Come indicato nel references:

Genera un’onda quadra alla frequenza specificata ( e duty cycle al 50% ) su un pin. Una durata puà essere specificata, altrimenti l’onda continua fino alla chiamata di noTone(). Il pin può essere connesso ad un buzzer piezoelettrico o altro speaker per riprodurre toni.

Solo un tono alla volta può essere generato. Se un tono è gia in riproduzione su un pin differente, la chiamata a tone() non avrà alcun effetto. Se il tono è in riproduzione sullo stesso pin, la chiamata ne imposterà la frequenza.

L’uso della funzione tone() interferirà con l’output PWM sui pin 3 e 11 (sulle schede diverse dalla Mega ).

Non è possibile generare toni inferioni a 31Hz. Per i dettagli tecnici, vedi le note di Brett Hagman.

NOTA: Se vuoi riprodurre toni differenti su pin multipli, hai bisogno di chiamare noTone() su un pin prima di chiamare tone() sul pin successivo.

La funzione noTone() interrompe la generazione dell’onda quadra causata da tone(). L’uso di noTone() non ha alcun effetto se non si sta generando alcun tono.

Sintassi:

noTone(pin);

Con Arduino è possibile riprodurre un solo tono alla volta in quanto l’utilizzo della funzione tone è legato ad un timer specifico del microcontrollore, il timer2 e se questo è richiesto da altre funzioni, come ad esempio un analogRead su pin PWM la funzione tone non potrà essere utilizzata. Per aggirare questo limite è possibile utilizzare la libreria Tone.h che vedremo nella prossime lezioni.

Il suono che può essere riprodotto mediante un altoparlante o un buzzer passivo collegato ad Arduino sarà un suono “metallico”, non sarà simile a quello di uno strumento musicale, e questo verrà ottenuto utilizzando un’onda quadra alla frequenza specificata.

Per riprodurre suoni simili a quelli di uno strumento musicale bisognerà utilizzare una scheda elettronica esterna che verrà controllata da Arduino, ma vedremo questa possibilità in una lezione successiva.

Per questa lezione utilizzerò prima un buzzer attivo e successivamente un buzzer passivo.

Esempio 1 – utilizzo buzzer attivo

 

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 01
   Utilizzo di un buzzer attivo
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int buzzerRitardo = 1000;      

void setup() {
  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 02 – utilizzo buzzer attivo

Per richiamare l’uso di valori interi dalla Serial Monitor di seguito uno sketch che permette di inserire da computer il valore del delay che regola l’ON e l’OFF del buzzer attivo.

Lo schema di collegamento è il medesimo dell’esempio precedente.

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 02
   Utilizzo di un buzzer attivo
   Inserimento delay da Serial Monitor
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int  buzzerRitardo = 0;      

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

void setup() {
   
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio 
    delay(200);
    Serial.print("Inserisci il ritardo in millisecondi: ");
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available())
  {
    // in r viene memorizzato il valore inserito
    // attraverso la Serial Monitor
    int r = Serial.parseInt();
    if (r != 0) {
      buzzerRitardo = r;
      Serial.println(buzzerRitardo);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      abilitaMessaggio = 0;
    }
  }
  
  // funzione permette di fare suonare il Buzzer
  suona();
}

void suona() {
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 03 – utilizzo buzzer attivo

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.

 

/* Prof. Michele Maffucci
   data: 01.01.2021

   Esempio 03
   Utilizzo di un buzzer attivo
   Inserimento delay da Trimmer per impostare
   un ritardo tra 100 e 1000 millisecondi
*/

// pin a cui è collegato il buzzer
byte buzzerPin = 2;
int  buzzerRitardo = 0;      

// per stampare una sola volta il messaggio sulla Serial Monitor  
bool abilitaMessaggio = 0;

// variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

void setup() {
   
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  // valore analogico letto su A0 inserito con il trimmer
  val = analogRead(A0);

// Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 100, 1000
  
  buzzerRitardo = map(val, 285, 719, 100, 1000);

  // funzione permette di fare suonare il Buzzer
  suona();
}

void suona() {
  // buzzer ON
  digitalWrite(buzzerPin,HIGH);
  delay(buzzerRitardo);

  // buzzer OFF
  digitalWrite(buzzerPin,LOW);
  delay(buzzerRitardo);
}

Esempio 4 – utilizzo buzzer passivo

Utilizziamo ora un buzzer passivo per riprodurre un tono in base alla frequenza impostata da un trimmer collegato al pin A0. Si faccia attenzione che ora il buzzer è collegato al pin 5 di tipo PWM

/* Prof. Michele Maffucci
   data: 04.01.2021

   Esempio 04
   Utilizzo di un buzzer passivo per riprodurre
   un tono in base alla frequenza impostata
   da un trimmer collegato al pin A0
*/

// pin (PWM) a cui è collegato il buzzer
byte buzzerPin = 5;

// variabile in cui memorizzare la frequenza del tono
int  intonazionePin = 0;

 // variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

// frequenza del tono
unsigned int frequenza;

// durata del tono
unsigned long durata = 10;

void setup()
{
  // inizializzazione pin a cui è collegto il buzzer
  pinMode(buzzerPin, OUTPUT);
}

void loop()
{
   // valore analogico letto su A0 inserito con il trimmer
   val = analogRead(A0);

 // Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 1000, 5000

  // frequenza assunerà un valore tra 1000 Hz e 5000 Hz
  frequenza = map(val, 285, 719, 1000, 5000);

  // emissione del tono
  tone(buzzerPin, frequenza, durata);

  // pausa di 1 millisecondo
  delay(1);
}

Nella prossime lezioni, utilizzando un buzzer passivo, realizzeremo dei brevi brani musicali e successivamente sostituiremo il buzzer con un altoparlante da 8 Ohm.

Buon Making a tutti 🙂

Kit di sensori per sperimentazione con Arduino

Tutti i sensori in commercio necessitano di un circuito elettronico di contorno che ne permette l’interfacciamento al microcontrollore è quindi indispensabile per chi desidera effettuare sperimentazioni avere competenze elettroniche adeguate che certamente non si hanno per i molti (studenti, maker, ecc…) che incominciano ad utilizzare Arduino. Le difficoltà che si hanno nelle prime fasi di sperimentazione potrebbero essere superato considerando il sensore una black box di cui sappiamo qual’è la grandezza fisica che rilevano e quali sono le funzioni dei piedini da collegare alla scheda Arduino, questo metodo è praticamente identico a quanto già si fa a scuola utilizzando ad esempio i Lego Mindstorms, la concentrazione va sulla programmazione e non sul singolo componente, la tecnologia la si studia in una fase successiva, quando il percorso didattico lo permette. Il vantaggio principale nell’operare in questo modo è che si riesce ad implementare artefatti sufficientemente complessi che hanno come obiettivo quello di far percepire il proprio apprendimento e di accettare in una fase successiva la difficoltà nella comprensione dettagliata (interna) di ogni singolo circuito elettronico.
I motivi di questo mio operare inoltre si rifà ad una breve sperimentazione sulla dispersione scolastica in cui ho necessità di rimotivare alcuni allievi e quindi ho bisogno di offrire degli strumenti che possano dare immediatamente “soddisfazione” e voglia di costruire.
La “cavia” 🙂 per la mia progettazione, prima che i miei allievi, è stato il giovane liceale (mio figlio) che entra per la seconda volta come protagonista su queste pagine, infatti ho deciso di regalargli un kit di sensori estremamente interessante costituito da ben 37 sensori acquistato su Bangood ad un prezzo conveniente che in questo periodo inoltre risulta in offerta. Ho avuto modo di utilizzare tutti i sensori e ritengo che con questo kit potrete sviluppare una quantità elevata di esperimenti. Perché ho scelto questo kit? Ho analizzato diverse soluzioni su diversi store on-line, ma il rapporto qualità/prezzo risultava il migliore.
Per facilitarne l’utilizzo sto creando un breve manuale con gli sketch di base per utilizzare i vari sensori in modo che si possa in autonomia effettuare i primi esperimenti, li aggiungerò volta per volta anche perché li utilizzerò nei prossimi giorni anche a scuola.
Spero di rispondere, con questa mia proposta, a quanti in queste vacanze mi hanno chiesto consigli sulla dotazione di base per incominciare con Arduino pur avendo conoscenze scarse o nulle in elettronica.
Non entrerò nel dettaglio del funzionamento fisico, l’atteggiamento ora e nei successivi post, che parleranno di questo kit, sarà quello di descrizione dei mattoncini con gli sketch di esempio che potrete poi voi migliorare ed ampliare. All’interno degli sketch trovate la spiegazione sul funzionamento delle varie parti di codice.

scatola-sensori

sensori

Questa la lista dei sensori del kit (tratto dal sito Bangood)

1 x Active buzzer module
1 x Passive buzzer module
1 x Common cathode RED&GREEN LED module
1 x Two color common cathode LED module
1 x Knock sensor module
1 x Shock switch sensor module
1 x Photo resistor sensor module
1 x Push button module
1 x Tilt switch module
1 x RGB LED module
1 x Infrared transmit module
1 x RGB colorful LED module
1 x Hydrargyrum switch sensor module
1 x Colorful auto flash module
1 x Magnet-ring sensor module
1 x Hall sensor module
1 x Infrared receive sensor module
1 x Analogy hall sensor module
1 x Magic ring module
1 x Rotate encode module
1 x Light break sensor module
1 x Finger pulse sensor module
1 x Magnetic spring module
1 x Obstacle avoidance sensor module
1 x Tracking sensor module
1 x Microphone sensor module
1 x Laser transmit module
1 x Relay module
1 x Analog temperature sensor module
1 x 18b20 temperature sensor module
1 x Digital temperature sensor module
1 x Linear hall Sensor module
1 x Flame sensor module
1 x High sensitive voice sensor module
1 x Humidity sensor module
1 x Joystick PS2 module
1 x Touch sensor module

Una premessa necessaria prima di incominciare con la descrizione e l’utilizzo dei sensori del kit acquistato su Bangood e di dare qualche nozione su cosa sono i sensori e gli attuatori, in modo che sia più semplice procedere con la sperimentazione.

Riprendo quanto già pubblicato nelle mie slide

I sistemi elettronici per interagire con il mondo fisico, utilizzano:

  • sensori che hanno il compito di percepire quantità fisiche dell’ambiente
  • attuatori, dispositivi che compiono un’azione in funzione di ciò che è stato rilevato dal sensore ed elaborato da un circuito elettronico.

Sensori e attuatori vengono anche detti trasduttori.

Un trasduttore è quindi un dispositivo in grado di convertire una grandezza fisica in un’altra.

In generale i trasduttori che convertono grandezze fisiche in segnali elettrici saranno collocati in ingresso ad un circuito elettronico, come Arduino e vengono denominati sensori.

Trasduttori che a partire da segnali elettrici in ingresso permettono di controllare o modificare una grandezza fisica esterna sono detti attuatori.

Esempi di sensori

Il termometro a mercurio converte la variazione della temperatura nella variazione di lunghezza di una colonnina di mercurio.

termometro

Il microfono che converte il suono in segnale elettrico.

microfono

Sensori di luce: Fototransitor, fotodiodo, fotoresistenza, pannello solare. La variazione di luce viene convertita in una variazione di una grandezza elettrica: resistenza, corrente elettrica, ecc…

sensori-luce

Esempi di attuatori

L’altoparlante è un attuatore che converte un segnale elettrico in onde sonore per questo motivo viene anche definito come un trasduttore elettroacustico.

altoparlante

La molla converte una forza in uno spostamento lineare

molla

Potenziometro, converte uno spostamento lineare in una variazione di resistenza

potenziometro

Termistore, trasforma una temperatura in una variazione di impedenza.

termistore

Sensori del kit

BUZZER

I buzzer possono essere di due tipi: attivi e passivi
I buzzer attivi hanno al loro interno un’oscillatore che emetterà suono se vengono alimentati, mentre quelli passivi non posseggono un oscillatore interno e quindi per emettere suono è indispensabile fornire al buzzer un segnale ad onda quadra tra i 2Khz e i 5 Khz.

Sperimentazione Buzzer attivo

buzzer-passivo

schema-buzzer-passivo

  • Pin S del sensore collegato al pin 4 di Arduino
  • Pin sensore a GND di Arduino
  • Pin alimentazione sensore (centrale) collegato a +5V di Arduino

buzzer-passivo-foto

// Prof. Michele Maffucci
// 08.01.15
// Utilizzo del buzzer passivo

const int pinBuzzer = 4;
// pin a cui è collegato il buzzer

int frequenzaquenza;
// variabile in cui memorizzare il valore della frequenza

void setup()
{
  pinMode(pinBuzzer,OUTPUT); // inizializzazione del pin a cui è collegato il buzzer
}

void loop()
{
  for(int i = 200; i <= 1000; i++) // loop di frequenze da 200 a 1000 hz { tone(pinBuzzer,i); // viene emesso dal buzzer un suono a frequenza i delay(5); // attesa di 5 millisecondi (in modo da percepire il suono emesso) } delay(3000); // attesa di 3 secondi. La frequenza più alta sarà emessa per 4 secondi for(int i = 1000; i >= 200; i--)  // loop di frequenze da 100 a 200 hz
  {
    tone(pinBuzzer,i);   // viene emesso dal buzzer un suono a frequenza i
    delay(5);            // attesa di 5 millisecondi (in modo da percepire il suono emesso)   
  }
}

Sperimentazione Buzzer attivo

buzzer-attivo

schema-buzzer-attivo

  • Pin S del sensore collegato al pin 11 di Arduino
  • Pin sensore a GND di Arduino
  • Pin alimentazione sensore (centrale) collegato a +5V di Arduino

buzzer-attivo-foto

// Prof. Michele Maffucci
// 08.01.15
// Utilizzo del pinBuzzer attivo

const int pinBuzzer = 11;
// pin a cui è collegato il buzzer

void setup()
{
  pinMode(pinBuzzer,OUTPUT);  // inizializzazione del pin a cui è collegato il buzzer
}

void loop()
{
  int a,b;

  // la condizione del while è sempre vera "1" quini il ciclo sarà infinito
  // all'interno di ogni ciclo sul pin a cui è collegato il buzzer viene inviata
  // un segnale alto per x ms ed un segnale basso per y ms il periodo totale dell'onda
  // sarà T = x + y e quindi la frequenza sarà f = 1/T

  while(1)
  {
    // emissione di una segnale a frequenza di 500 hz
    for(a=0;a<80;a++)
    {
      digitalWrite(pinBuzzer,HIGH);
      delay(1);                      // attesa di 1 ms
      digitalWrite(pinBuzzer,LOW);
      delay(1);                      // attesa di 1 ms
    }
    // emissione di una segnale a frequenza di 250 hz
    for(b=0;b<100;b++)
    {
      digitalWrite(pinBuzzer,HIGH);
      delay(2);                  // attesa di 2 ms
      digitalWrite(pinBuzzer,LOW);
      delay(2);                  // attesa di 2 ms
    }
  }
} 

Sensore di battito

Il sensore di battiti vi permetterà di rilevare vibrazioni anche molto lievi, infatti è costituito da una piccolissima molla che posta in vibrazione chiude un contatto.

battito

schema-sensore-battito

  • Pin S del sensore collegato al pin 7 di Arduino
  • Pin sensore a GND di Arduino
  • Pin alimentazione sensore (centrale) collegato a +5V di Arduino

battitto-foto

// Prof. Michele Maffucci
// 08.01.15
// Sensore di battito

const int pinBattito = 7;    // pin a cui è collegato il il sensore
const int pinLed =  13;      // pin a cui è collegato il LED che rileva il battito
                             // viene usato il led L collegato al pin 13


int statoBattito = 0;        // variabile in cui memorizzare lo stato del sensore

void setup() {
  // inizializzazione del pin a cui è collegato il LED ad output
  pinMode(pinLed, OUTPUT);
  
  // inizializzazione del pin a cui è collegato il sensore ad input
  pinMode(pinBattito, INPUT);     
}

void loop(){
  // lettura dello stato del sensore
  statoBattito = digitalRead(pinBattito);

  // verifica se il sensore rileva un battito
  // il sensore è attivo basso
  
  // se rileva un battito il sensore è ad HIGH:
  if (statoBattito == LOW) {     
    // accendel il LED 
    digitalWrite(pinLed, HIGH);
    delay(1000);
  } 
  else {
    // spegne il LED:
    digitalWrite(pinLed, LOW); 
  }
}

Nelle prossime puntate la descrizione degli altri sensori.

Due chiacchere su Arduino Esplora

arduino-esplora
Mettendo ordine tra la mia library di sketch ho ritrovato alcune bozze di tutorial per Arduino Esplora che avevo incominciato a scrive nel mese di novembre durante il viaggio di rientro in treno da Verona (JobOrienta). Condivido con voi quanto da me velocemente elaborato, sperando che possa essere utile anche ad altri.
L’attivit di creazione dei tutorial incomincia ovviamente dagli esempi resi disponibili da Arduino e quello che vi allego e lo sketch per il rilievo della temperatura e la scrittura sul TFT.
Ho aggiunto alla soluzione dell’esempio standard modifiche alla modalit di visualizzazione su TFT, allarme nel caso di superamento di una temperatura di soglia, variazione di colore del led rgb e avvisi sonori.
Poich lo sketch destinato agli studenti, all’interno di esso, in modalit di commento trovate le spiegazioni delle funzioni di libreria in cui metto in evidenza (anche in maniera ripetuta) funzionalit, parametri e valori restituiti.
Vi allego inoltre una versione dello stesso sketch con meno commenti in modo che per i pi esperti sia possibile vedere la struttura generale del codice.
Lo sketch non stato ottimizzato e nasce come primo esempio su cui gli studenti dovranno poi effettuare modifiche e miglioramenti.

/*

 Rilevatore di temperatura con Esplora TFT - V03
 
 Questo esempio  per il TFT collegato ad Arduino Esplora.
 
 Questo sketch e tratto dal tutorial disponibile su sito Arduino
 
 la cui prima versione  stata creata il 15 aprile 2013 da Scott Fitzgerald
 la potete trovare al seguente indirizzo
 
 http://arduino.cc/en/Tutorial/EsploraTFTTemp
 
 modified 23 November 2013
 by Michele Maffucci
 https://www.maffucci.it
 
 La variante proposta permette di segnalare un allarme
 se viene superata una temperatura di soglia fissata dall'utente,
 inoltre a titolo didattico sono stati aggiunti commenti di spiegazione
 alle funzioni utilizzate.
 
 */

// inclusione delle librerie necessarie per
// il funzionamento di Esplora, del TFT

#include #include <Esplora.h>  
#include <TFT.h>
#include <SPI.h>

char tempPrintout[3];  // array in cui memorizzare i valori di temperatura in gradi C
char tempPrintoutF[3]; // array in cui memorizzare i valori di temperatura in gradi F

// temperatura di allarme
const int maxTemp = 22;

void setup() {

  // begin()
  // Inizializzazione dell'LCD
  // istanza della classe TFT quando si usa la scheda Esplora.
  // Se si usa il display deve essere presente.

  // parametri
  // nessuno

  // restituisce
  // nulla

  // EsploraTFT.background(0,0,0);
  // Cancella lo schermo con uno sfondo nero

  EsploraTFT.begin();

  //--

  // Cancella tutto quello che attualmente visualizzata sullo schermo LCD
  // con il colore indicato. Pu essere utilizzato nel loop() per cancellare lo schermo.
  // La funzione background() accetta valori a 8 bit per ognuno dei canali rosso, verde e blu
  // per lo schermo non visualizza con questa fedelt.
  // I valori di rosso e blu sono scalati a 5 bit e il verde a 6 bit.

  // sintassi
  // screen.background(red, green, blue);

  // parametri
  // red: int da 0 a 255
  // green: int da 0 a 255
  // blu: int da 0 a 255

  // restituisce
  // nulla

  EsploraTFT.background(0,0,0);

  //---

  // stroke()
  // La funzione stroke() accetta valori a 8 bit per ognuno dei canali rosso, verde e blu
  // per lo schermo non visualizza con questa fedelt.
  // I valori di rosso e blu sono scalati a 5 bit e il verde a 6 bit.

  // sintassi
  // screen.stroke(red, green, blue);

  // parametri
  // red: int da 0 a 255
  // green: int da 0 a 255
  // blu: int da 0 a 255

  // restituisce
  // nulla

  // EsploraTFT.stroke(255,0,0);
  // imposta il colore delle line e delle forme a rosso

  EsploraTFT.stroke(255,0,0);

  //---

  // setTextSize();
  // Imposta la dimensione del testo che segue
  // La dimensione di default  1.
  // Ogni aumento di dimensione di una unit corrisponde ad un aumento di 10 pixel.
  // Quindi dimensione 1 = 10 pixel, dimensione 2 = 20 pixel e cos via.

  // sintassi
  // screen.setTextSize(size);

  // parametri
  // size: intero da 1 a 5

  // restituisce
  // nulla

  // EsploraTFT.setTextSize(2);
  // imposta la dimensione del testo a 2 (20 px)

  EsploraTFT.setTextSize(2);

  // il testo viene posizionato in alto a sinistra dello schermo
  // il testo rimane permanente sullo schermo
  // la prima riga alle coordinate (0,0)
  // la seconda riga alle coordinate (0,20)

  //---

  // .text();

  // sintassi
  // screen.text(text, xPos, yPos);

  // parametri
  // text : array di tipo char in cui viene memorizzato il testo da visualizzare sul display
  // xPos : variabile int, coordinata x del testo da scrivere
  // yPos : variabile int, coordinata y del testo da scrivere

  // restituisce
  // nulla

  // scrive il testo tra virgolette alle coordinate (0, 0)
  // scrive il testo tra virgolette alle coordinate (0, 20)

  EsploraTFT.text("Gradi\n ",0,0);
  EsploraTFT.text("centigradi:\n ",0,20);

  // il testo che segue, all'interno del loop, vine impostato a 5 (50 px)
  EsploraTFT.setTextSize(5);
}

void loop() {

  // viene letta la temperatura in Celcius e memorizzata come stringa
  // il metodo readTemperature permette di restituire la temperatura in gradi Celsius
  // oppure in gradi Faherenheit, dipende dal parametro che viene passato, nell'esempio
  // DEGREES_C gradi centigradi. L'intervallo in gradi oscilla da -40 C a 150 C

  // readTemperature()
  // Legge la temperatura ambiente rilevata dal sensore su Esplora
  // e in funzione del parametro passato restituisce il valore
  // in gradi Celsius che Fahrenheit

  // parametri
  // scale: la scala scelta per l'output.
  // pu asumere i valori: DEGREES_C e DEGREES_F

  // restituisce
  // un valore intero che rappresenta la temperatura in gradi Celsius o Fahrenheit.
  // L'intervallo di temperatura in gradi Celsius  da -40C a 150C
  // L'intervallo di temperatura in gradi Fahrenheit  da -40F a 302F.

  String temperature = String(Esplora.readTemperature(DEGREES_C));
  String temperatureF = String(Esplora.readTemperature(DEGREES_F));

  //--

  // toCharArray();
  // Copia la stringa di caratteri nel buffer

  // sintassi
  // string.toCharArray(buf, len)

  // parametri
  // string: variabile di tipo string
  // buf: il buffer dove copiare la stringa di caratteri (char [])
  // len: la dimensione del buffer (unsigned int)

  // converte la stringa in array di caratteri

  temperature.toCharArray(tempPrintout, 3);
  temperatureF.toCharArray(tempPrintoutF, 3);

  controlTemp();

}

void controlTemp(){

  // controlliamo se la temperatura  maggiore del valore fissato maxTemp
  if (Esplora.readTemperature(DEGREES_C)>maxTemp){

    // imposta il colore del testo a bianco
    EsploraTFT.stroke(255,0,0);


    // scrive la temperatura in gradi Celsius nelle linee sottostante alle coordinate indicate
    EsploraTFT.setTextSize(5);
    EsploraTFT.text(tempPrintout, 0, 50);

    // scrive i caratteri "." e "C" alle coordinate indicate
    EsploraTFT.text(".", 55, 25);
    EsploraTFT.text("C", 80, 50);

    // scrive la temperatura in gradi Fahrenheit nelle linee sottostante alle coordinate indicate
    EsploraTFT.setTextSize(1);
    EsploraTFT.text(tempPrintoutF, 110, 78);

    // scrive i caratteri "." e "F" alle coordinate indicate
    EsploraTFT.text(".", 121, 73);
    EsploraTFT.text("F", 126, 78);

    // imposta il testo a 2
    EsploraTFT.setTextSize(2);
    // imposta il colore del testo
    EsploraTFT.stroke(255,255,0);

    // scrive il testo sottostante alle coordinate indicate
    EsploraTFT.text("Attenzione:\n ",0,90);
    EsploraTFT.text("troppo caldo!:\n ",0,110);

    // funzione che consente di effettuare il blink del led sulla scheda Esplora 
    blinkLedOn();

    // tone()
    // La funzione genera un'onda quadra di frequenza e durata stabilita dal buzzer di Esplora
    // La durata  espressa in milliseconds, se non  specificata nessuna durata l'emissione
    // del tono prosegue fino a quando non viene incontrata una finzione Esplora.noTone().
    // Attenzione che l'uso di tone() interferisce con il fading del red rosso.

    // sintassi
    // Esplora.tone(frequency, duration) 

    // parametri
    // frequency: un unsigned int che rappresenta la frequenza espressa in hertz 
    // duration: un unsigned long che rappresenta la durata in millisecondi (ozionale) del tono

    // emissione di un tono di allarme. Nota LA per 1 secondo
    Esplora.tone(440, 1000);

    // ripristina il testo a 5 per il prossimo ciclo di controllo
    // EsploraTFT.setTextSize(5);

    // persistenza del messaggio per 1 secondo
    // prima che venga effettuato il successivo controllo

    delay(1000);

    // cancella il testo prima di avviare il successivo loop
    EsploraTFT.stroke(0,0,0);

    // imposta il testo ad una dimensione di 2 cio 20 px
    EsploraTFT.setTextSize(2);

    // scrive il testo alle coordinate indicate
    EsploraTFT.text("Attenzione:\n ",0,90);
    EsploraTFT.text("troppo caldo!:\n ",0,110);

    // imposta il testo ad una dimensione di 5 cio 50 px
    EsploraTFT.setTextSize(5);

    // stampa il valore della temperatura in gradi Celsius alle coordinate indicate
    EsploraTFT.text(tempPrintout, 0, 50);

    // imposta il testo ad una dimensione di 1 cio 10 px
    EsploraTFT.setTextSize(1);

    // stampa il valore della temperatura in gradi Fahrenheit alle coordinate indicate
    EsploraTFT.text(tempPrintoutF, 110, 78);

  }
  else{
    // nel caso in cui la temperatura  al di sotto dei 22 gradi Celsius
    // viene impostato il colore di linee e forme a bianco

    // spegne LED esterno
    blinkLedOff();

    // imposta il colore del testo a bianco
    EsploraTFT.stroke(255,255,255);

    // scrive la temperatura in gradi Celsius nelle linee sottostante alle coordinate indicate

    // imposta il testo ad una dimensione di 5 cio 50 px
    EsploraTFT.setTextSize(5);

    // stampa il valore della temperatura in gradi Celsius alle coordinate indicate
    EsploraTFT.text(tempPrintout, 0, 50);

    // scrive i caratteri "." e "C" alle coordinate indicate
    EsploraTFT.text(".", 55, 25);
    EsploraTFT.text("C", 80, 50);

    // imposta il testo ad una dimensione di 1 cio 10 px
    EsploraTFT.setTextSize(1);

    // stampa il valore della temperatura in gradi Fahrenheit alle coordinate indicate
    EsploraTFT.text(tempPrintoutF, 110, 78);

    // scrive i caratteri "." e "F" alle coordinate indicate
    EsploraTFT.text(".", 121, 73);
    EsploraTFT.text("F", 126, 78);

    delay(1000);

    // cancella il testo prima di avviare il successivo loop
    EsploraTFT.stroke(0,0,0);

    // imposta il testo ad una dimensione di 2 cio 20 px
    EsploraTFT.setTextSize(2);

    // scrive i caratteri "Attenzione:" (con ritorno a capo) e "troppo caldo!:" (con ritorno a capo) alle coordinate indicate
    EsploraTFT.text("Attenzione:\n ",0,90);
    EsploraTFT.text("troppo caldo!:\n ",0,110);

    // imposta il testo ad una dimensione di 5 cio 50 px
    EsploraTFT.setTextSize(5);

    // stampa il valore della temperatura in gradi Celsius alle coordinate indicate
    EsploraTFT.text(tempPrintout, 0, 50);

    // imposta il testo ad una dimensione di 1 cio 10 px
    EsploraTFT.setTextSize(1);

    // stampa il valore della temperatura in gradi Fahrenheit alle coordinate indicate
    EsploraTFT.text(tempPrintoutF, 110, 78);
  }
}

// funzione che permette di far lampeggiare in diversi colori il led di Esplora
void blinkLedOn(){

  // writeRGB()
  // Consente di controllare la luminosit di un determinato colore del led rgb di Esplora.

  // sintassi
  // Esplora.writeRGB(red, green, blue)

  // parametri
  // red, variabile int imposta la luminosit del rosso. Intervallo da 0 a 255.
  // green, variabile int imposta la luminosit del verde. Intervallo da 0 a 255.
  // blue, variabile int imposta la luminosit del blu. Intervallo da 0 a 255.

  // restituisce
  // nulla

  Esplora.writeRGB(255,0,0);    // LED rosso
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(0,255,0);    // LED verde
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(0,0,255);    // LED blu
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(255,255,0);  // LED giallo
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(0,255,255);  // LED ciano
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(255,0,255);  // LED magenta
  delay(1000);                  // attesa di 1 sec
  Esplora.writeRGB(255,255,255);// LED bianco
  delay(1000);                  // attesa di 1 sec
}

void blinkLedOff(){
  Esplora.writeRGB(0,0,0);    // spegne il LED
}

Questa la versione con meno commenti:
Continua a leggere

Arduino LilyPad – lezione 04: suono

Per questa lezione ho utilizzato LilyPad Buzzer che ho acquistato su Sparkfun. Si tratta di un piccolo buzzer induttivo con due pin I/O in grado di riprodurre suoni di un livello sufficientemente alto da poter essere sentiti ad esempio se avete il buzzer in tasca, ma non aspettatevi livelli sonori elevatissimi.
Le dimensioni sono di 20 mm di diametro e 0,8 mm di spessore.

Passo 01

Come consigliato nella lezione n. 3 procedete anche per questa piccola scheda alla realizzazione del supporto protettivo in cartocino al fine di evitare scivolamenti dei morsetti a coccodrillo.

Passo 02

Collegate il “+” del buzzer al piedino 9 di LilyPad e il “-” del buzzer al “-” di LiLyPad come rappresentato nell’immagine:

Passo 03

Avviate l’IDE di Arduino e copiate ed incollate il codice che trovate di seguito:

/* Arduino LilyPad: lezione 04: suono
 * Uso del modulo buzzer
 * Michele Maffucci LilyPad Buzzer per realizzare semplici note musicali
 * https://www.maffucci.it/2011/06/30/arduino-lilypa-zione-04-suono/
 * Progetto originale:
 * http://web.media.mit.edu/~leah/LilyPad/07_sound.html
 * per un grafico sulle differenti frequenze delle note:
 * http://www.phy.mtu.edu/~suits/notefreqs.html
 */
 
int ledPin = 13;	// il LED  connesso al pin digitale 13
int speakerPin = 9;	// il buzzer  connesso al pin digitale 9 (uscita di tipo PWM)
 	 
void setup()	 
{	 
         pinMode(ledPin, OUTPUT);		// si imposta ledPin come pin di output
         pinMode(speakerPin, OUTPUT);	// si imposta speakerPin come pin di output
}	 
 	 
void loop()	// inizio del loop
{	 
          scale();		// chiamata della funzione scale()
          delay(1000);	// attesa di 1 secondo
}	 
 	 
void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds)		// funzione che produce il suono
{	 
          int x;
          
          // converte il periodo della nota in un intero lungo
          long delayAmount = (long)(1000000/frequencyInHertz);
          
          long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));
          
			for (x=0;x<loopTime;x++)
				{
					digitalWrite(speakerPin,HIGH);
					delayMicroseconds(delayAmount);
					digitalWrite(speakerPin,LOW);
					delayMicroseconds(delayAmount);
				}
}	 
 	 
void scale ()
{	 
			// speakerPin: piedino LilyPad; numero da: 2093 a 4186: frequenza della nota; 500: durata della nota

			digitalWrite(ledPin,HIGH);	//accende il LED
			beep(speakerPin,2093,500);	//C: suona le note C (C7 come da tabella linkata sopra) per 500ms
			beep(speakerPin,2349,500);	//D
			beep(speakerPin,2637,500);	//E
			beep(speakerPin,2793,500);	//F
			beep(speakerPin,3136,500);	//G
			beep(speakerPin,3520,500);	//A
			beep(speakerPin,3951,500);	//B
			beep(speakerPin,4186,500);	//C
			digitalWrite(ledPin,LOW);	//spegne il LED
}

Un long un tipo intero lungo che pu contenere un numero intero positivo o negativo (quindi senza punto decimale) di 32 bit con valori compresi tra 2.147.483.647 a – 2.147.483.648

Analizziamo con molta attenzione la funzione beep.

long delayAmount = (long)(1000000/frequencyInHertz); ?

Domanda: cosa vuol dire 1000000/frequencyInHertz:

Vi ricordo che il periodo di una forma d’onda :

T =1/f

dove f la frequenza espressa in Hertz. L’unit di misura del periodo T il secondo.

quindi la formula:

1000000/frequencyInHertz

pu essere scritta come:

1000000 * (1/frequencyInHertz)

ovvero:

1000000 * T

Domanda: perch moltiplichiamo per 1000000?

Perch la variabile delayAmount verr passata a delayMicroseconds() che una funzione che mette in pausa il programma per un tempo, espresso in microsecondi, specificato dal parametro.

Domanda: ma in un secondo quanti microsecondi ci sono?

1 milione di microsecondi

Ecco spiegato l’arcano, poich delayMicroseconds() accetta un parametro in microsecondi bisogna moltiplicare 1/frequencyInHertz per 1000000.

Domanda: cosa vuol dire (long) nell’istruzione:

long delayAmount = (long)(1000000/frequencyInHertz);

Per spiegare questa linea di codice devo parlarvi di Type-casting.
In C possibile forzare il tipo di una variabile (int, long, float, …) in un altro tipo, utilizzando l’operatore “()

Ad esempio:

int a;
int b=67;
float c=3.14;
float d;
char lettera='M';

/* assegna il valore 3 (solo la parte intera) ad a */
a=(int)c 

/* assegna il valore 77 (codice ASCII) ad a */
a=(int)lettera

/* assegna alla variabile d il valore di b, 67.0 (valore float) */
d=(float)b

In alcuni casi il Type-casting viene fatto automaticamente dal compilatore in altri casi bisogna specificarlo. Il Type-casting una richiesta al compilatore di trasformazione di tipo.

Quando siamo in dubbio buona norma eseguire il Type-casting.

Il Type-casting risulta utile ad esempio in una divisione:

int x, y;
float w;

w=(float)x/(float)y;

questa operazione assicura che la divisione sia in floating-point.

Tornando alla nostra istruzione:

long delayAmount = (long)(1000000/frequencyInHertz);

quando effettuiamo un passaggio di valore ad una funzione bisogna convertire long in (long , infatti delayAmount viene passata a delayMicroseconds.

Domanda: ma cos’ delayAmount?

il periodo T della frequenza della nota.

Domanda: a cosa serve loopTime?

loopTime definisce il numero di volte in cui la nota deve essere suonata.

Infatti nel corpo del for:

digitalWrite(speakerPin,HIGH);
delayMicroseconds(delayAmount);
digitalWrite(speakerPin,LOW);
delayMicroseconds(delayAmount);

si ha:

digitalWrite(speakerPin,HIGH);

viene messo ad alto l’uscita speakerPin (pin 9)

delayMicroseconds(delayAmount);

la nota viene suonata per un tempo delayAmount, periodo della della nota

l’uscita speakerPin (pin 9) viene portata a massa (spento)

digitalWrite(speakerPin,LOW);

per una quantit di tempo pari al periodo:

delayMicroseconds(delayAmount);

La variazione del timbro della nota avviene se utilizzate la modulazione di larghezza di impulso in inglese Pulse Width Modulation, in questo modo se il treno di impulsi sufficientemente elevato l’orecchio umano non percepir una sequenza di impulsi ma un suono costante.