Problema tra Arduino Nano RP2040 connect e Buzzer Passivo

[Massimo Goldaniga]

Ciao a tutti,

dopo aver realizzato, testato e rilasciato alcuni progetti 

(fatti con le schede Arduino UNO e con Futura Nano R4)

ora stò cercando di fare il "porting" dei miei sketch su scheda

Arduino Nano RP2040 connect

CI SONO "N" PROBLEMI !

Ve ne espongo uno solo (semplice semplice).

1) Ho attaccato un buzzer passivo (su GND e su PIN D3)

2) Uso lo sketch che vedete più avanti

3) Il buzzer emette dei "tic-tic" buffi e debolissimi

4) Ho attaccato il buzzer passivo su altri PIN Digitali
(che sul RP2040 dovrebbero essere con PWM)

5) Ho sistemato il PIN nello sketch

6) Il buzzer emette dei "tic-tic" buffi e debolissimi

Il buzzer passivo è quello che ho sempre usato nei miei progetti precedenti

(e dovrebbe funzionare da 3V a 12V).

Qualcuno può aiutarmi ?

Ciao e grazie

Max

Sketch:

/*

-------------------------------------------------------------------------

Esempio Buzzer 1 (Su Arduino Nano RP2040 connect)

Emette dei suoni di test

-------------------------------------------------------------------------

*/

// --- Define Buzzer Pin

  int BuzzerPin = 3;

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

// setup()

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

void setup() {

// --- Initialize Serial port

  Serial.begin(9600);

  while(!Serial);

// --- Set Buzzer

  pinMode(BuzzerPin,OUTPUT);

  digitalWrite(BuzzerPin,LOW);                      

// --- User FeedBack on Buzzer

  tone(BuzzerPin,440);

  delay(500);

  tone(BuzzerPin,880);

  delay(500);

 

  tone(BuzzerPin,1720);

  delay(500);

  noTone(BuzzerPin);

  delay(500);

}

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

// loop()

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

void loop() {

  tone(BuzzerPin,880);

  delay(500);

  noTone(BuzzerPin);

  delay(500);

}

[Michele Ricciardi]

Ciao, azzardo

Problema di duty cycle? Le la durata del segnale on è troppo breve l’energia trasmessa e’ bassa e quindi il volume….

Potrebbe essere? Parlavi di PWM…

Ciaooooo

Michele

--
Hai ricevuto questo messaggio perché sei iscritto al gruppo "Arduino User Group & Wearables Milano" di Google Gruppi.
Per annullare l'iscrizione a questo gruppo e non ricevere più le sue email, invia un'email a milano-aug+...@googlegroups.com.
Per visualizzare questa discussione, visita https://groups.google.com/d/msgid/milano-aug/CAEoAVnnch2kgEb-ZqaVrRXB2NZXgaaGJOanBqxM6HvcAtgqMeg%40mail.gmail.com.

[Roberto Portesani]

Ciao Massimo ,al posto di in buzzer prova a collegare un piccolo altoparlante attraverso un semplice transistor. 

Inviato da Outlook per Android

---

From: milan...@googlegroups.com <milan...@googlegroups.com> on behalf of Michele Ricciardi <michele.r...@gmail.com>
Sent: Thursday, June 5, 2025 6:13:54 PM
To: milan...@googlegroups.com <milan...@googlegroups.com>
Subject: Re: [AUG Milano & Wearables] Problema tra Arduino Nano RP2040 connect e Buzzer Passivo

 

Per visualizzare questa discussione, visita https://groups.google.com/d/msgid/milano-aug/CACQdXsPjnohonddih8N-uiGhfam3oXFGz%2BLcDRCsT0jAwgi2Vw%40mail.gmail.com.

[Massimo Goldaniga]

Ciao carissimi,

grazie dei vostri suggerimenti.

Probabilmente mi sono spiegato male:

1) Con Arduino Uno R4 (Minima o WiFi) --> funziona tutto perfettamente

2) Con Arduino Nano RP2040 Connect --> il buzzer 

invece che emettere le frequenze pilotate dallo sketch con la tone()
emette solo dei "tick-tick" 

Quello che so io:

• I Pin della R4 escono a 5V
• I Pin della Nano RP escono a 3.3V
• Però quel buzzer può venire alimentato da 3V a 12V

Io ho l'impressione che 

la funzione tone() NON faccia il suo dovere con la Nano RP2040

(ma, googleando, non trovo nulla in merito)

Invece, sul sito ufficiale di Arduino, nella reference della tone() trovo:

"...

Use of the 

tone()

 function will interfere with PWM output on pins 3 and 11 

(on boards other than the Mega).

..."

Dato che TUTTI i pin digitali della nano RP2040 supportano il PWM

FORSE 

intendono dire che la tone() ed il PWM interferiscono su tutti i pin digitali della nano

BOH !

Quindi, FORSE, la tone() sulla nano RP2040 NON si può usare ?

Ed allora come faccio a dare allo user dei feedback sonori (modulabili a programma) con la nano ?

Ciao e grazie

Max

Per visualizzare questa discussione, visita https://groups.google.com/d/msgid/milano-aug/DBAP195MB10020308EE273DF42D94E83BA76FA%40DBAP195MB1002.EURP195.PROD.OUTLOOK.COM.

[Gmail R.Porte]

Per visualizzare questa discussione, visita https://groups.google.com/d/msgid/milano-aug/CAEoAVnnPJW9g7FWxKTyGn0gztFcmDksPGM7gYnMNwERzxWhv5Q%40mail.gmail.com.

Ciao Massimo ,

ho provato questo  semplicissimo sketch preso dagli esempi per generare toni sia su un RP2040 Connect e funziona perfettamente.

Sulla tua board Rp2040 riesci a far girare un'altro sketch tipo il blink ?

Te lo chiedo perche' io ho una seconda board RP2040 Connect su cui credo di aver installatro micropython in passato e per qualche motivo usando l'ide arduino per caricare uno sketch in C  apparentemente lo carica ma non funziona.

Credo sia da ricaricare il bootloader per usarla in C.

Sperando ti sia utile ...

Buona giornata . 

Roberto  

*

  Multiple tone player

  Plays multiple tones on multiple pins in sequence

  circuit:

  - three 8 ohm speakers on digital pins 6, 7, and 8

  created 8 Mar 2010

  by Tom Igoe

  based on a snippet from Greg Borenstein

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/toneMultiple

*/

void setup() {

}

void loop() {

  // turn off tone function for pin 8:

  noTone(8);

  // play a note on pin 6 for 200 ms:

  tone(8, 440, 200);

  delay(200);

  // turn off tone function for pin 6:

  noTone(8);

  // play a note on pin 7 for 500 ms:

  tone(8, 494, 500);

  delay(500);

  // turn off tone function for pin 7:

  noTone(8);

  // play a note on pin 8 for 300 ms:

  tone(8, 523, 300);

  delay(300);

}

 

[Massimo Goldaniga]

Ciao Roberto,

Grazie dell'aiuto !

1) sulla mia rp2040 gli sketch di esempio (tipo blink) funzionano

2) ogni tentativo di usare la tone() e' vano

3) domani proverò ad usare la libreria toneac2 (ma non sono "speranzoso")

4) Tullio mi ha proposto di scrivere una function alternativa alla tone() che metta velocemente ad HIGH e poi a LOW un pin digitale per generare una onda SENZA usare i Timer.

Questa cosa mi "intriga" un sacco e la approfondirò di sicuro.

Grazie a tutti e.....

Vi terrò Informati

Max

[Massimo Goldaniga]

Ciao a tutti,

eccomi a voi con la 

funzione tone() riscritta ex novo (come da ottime indicazioni di Tullio).

In coda a questa eMail troverete uno sketch che ho fatto per l'Arduino RP2040

che esegue la nuova tone() in vari modi (come dimostrazione).

Il punto saliente è il ciclo di for:

// --- LOOP di emissione dei cicli di HIGH-LOW *** per simulare la tone() ***

  for (long Cycle=0 ; Cycle<CycleMaxNumber ; Cycle++) {

    digitalWrite(InpPin, HIGH);

    delayMicroseconds(HighDelayMicroseconds);

    digitalWrite(InpPin, LOW);

    delayMicroseconds(LowDelayMicroseconds);

  }

che evita l'uso dalla tone()

e "... tutto il resto è noia ..."

Se ne avete voglia e tempo, fatemi sapere cosa ve ne pare.

Grazie Tullio !

(ma grazie anche a tutti gli altri !)

A presto

Max

/*

-----------------------------------------------------------------------------

Esempio_Buzzer_2_TullioAndMax

Obbiettivo:

 NON usare più

 la fuzione standard tone() *** che su Arduino Nano RP2040 non funziona ***

 ed utilizzare una nuova funzione di generazione dei tone (appositamente scritta)

ATTENZIONE:

 la tone() ufficiale non tiene bloccato lo sketch perchè usa un Timer (e necessita di un delay in coda)

 la nuova fuzione TIENE BLOCCATO LO SKETCH (fino al termine del BEEP emesso) e NON necessita di delay in coda

 quindi NON è più necessaria neppure la notone()

-----------------------------------------------------------------------------

*/

  int   BuzzerPin = 6;              // Scegli un pin digitale qualsiasi (anche se non è PWM)

  float NoteArrayFrequency[9*12];   // Array delle frequense delle note di 9 ottave                  

  int   LoopCount = 0;              // Contatore delle escuzioni della funzione loop()

// -------------------------------------------------------------------------- setup()

void setup() {

// --- Imposto il Pin del buzzer

  pinMode(BuzzerPin, OUTPUT);

// --- Imposto la seriale per gli User FeedBack

  Serial.begin(9600);

  while (!Serial);

// --- Inizializzo array delle frequenze delle note musicali

  SetNoteArrayFrequency();

  for (int i=48;i<=48+12;i++) {

    Serial.print("NoteArrayIndex[" + String(i)+"]"+"\t");

    Serial.print("=NoteArrayFrequency=" + String(NoteArrayFrequency[i])+"\t");

    Serial.print("\r\n");  

  }

// --- End setup()

}

// -------------------------------------------------------------------------- loop()

void loop() {

  int Frequency = 0;        // Frequenza in Hertz della nota da emettere

  int DurationMillis = 0;   // Durata della nota da emettere (in millisecondi)

// --- Conteggio Loop eseguiti

  LoopCount = LoopCount + 1;

// --- Determino tempo impiegato da un ciclo di 1000000 for

  if ( LoopCount == 1 ) {

    long ForMicroseconds = GetForMicroseconds(1000000);

    Serial.print("ForMicroseconds="+String(ForMicroseconds));

    delay(5000);

  }

// --- Loop per 1 ottava da 440 Hertz in su (mezzo tono per volta)

  if ( LoopCount == 1 ) {

    for (int i=48;i<=48+12;i++) {

      Frequency = NoteArrayFrequency[i];

      DurationMillis = 200;

      TullioAndMaxBeep(BuzzerPin,Frequency,DurationMillis);

      delay(200);  

    }

  }

// --- Loop per 9 ottave

  if ( LoopCount == 1 ) {

    for (int i=0;i<108;i=i+12) {

      Frequency = NoteArrayFrequency[i];

      DurationMillis = 200;

      TullioAndMaxBeep(BuzzerPin,Frequency,DurationMillis);

      delay(200);  

    }

  }

// --- Loop mezzo tono per volta per 9 ottave

  if ( LoopCount == 1 ) {

    for (int i=0;i<108;i++) {

      Frequency = NoteArrayFrequency[i];

      DurationMillis = 100;

      TullioAndMaxBeep(BuzzerPin,Frequency,DurationMillis);

  //    delay(200);  

    }

  }

// --- Giro di DO per 4 volte

  if ( LoopCount <= 4 ) {

    DurationMillis = 200;

    int ModoMaggiore = 0;

    int ModoMinore = 1;

// --- Arpeggio di DO maggiore

    Arpeggio(BuzzerPin,51,DurationMillis,ModoMaggiore);

// --- Arpeggio di LA minore

    Arpeggio(BuzzerPin,48,DurationMillis,ModoMinore);

// --- Arpeggio di FA maggiore

    Arpeggio(BuzzerPin,44,DurationMillis,ModoMaggiore);

// --- Arpeggio di SOL maggiore

    Arpeggio(BuzzerPin,46,DurationMillis,ModoMaggiore);

  }

// --- End loop()

}

// -------------------------------------------------------------------------- TullioAndMaxBeep()

// Input:

// int InpPin  = Numero del Pin digitale su cui emettere il beep

// int InpFreq = Frequenza in Hertz da emettere (tra 55 e 15000 circa)

// int InpDurationMillis = Durata del beep (in millisecondi)

void TullioAndMaxBeep(int InpPin, int InpFrequency, int InpDurationMillis) {

// --- Definizioni  

  long CycleMicroseconds = 0;

  int  CycleMaxNumber = 0;

  long HalfCycleMicroseconds = 0;

  long HighDelayMicroseconds = 0;

  long LowDelayMicroseconds = 0;

// --- Determino numero di "Cicli" da eseguire

  CycleMaxNumber = long(InpFrequency) * long(InpDurationMillis) / 1000.0;

// --- Determino lunghezza di ogni "Ciclo" HIGH-LOW (espressa in in Microsecondi)

  CycleMicroseconds = 1000000.0 / InpFrequency;

// --- Determino lunghezza del "Semi-Ciclo"

  HalfCycleMicroseconds = CycleMicroseconds / 2.0;

// --- Determino il Delay da applicare al semiciclo HIGH

//      è SEMPRE uguale al Semi-Ciclo standard

  HighDelayMicroseconds = HalfCycleMicroseconds;

// --- Determino il Delay da applicare al semiciclo LOW

//      è SEMPRE uguale al Semi-Ciclo standard - qualche microsoecondo

//      (per consentire l'esecuzione della FOR)

//      Per fare le cose fatte per bene:

//      bisognerebbe determinare la durata reale della istruzione for

//      e non togliere arbitrariamente 1 microsecondo... :-)

  LowDelayMicroseconds = HalfCycleMicroseconds - 1;

  Serial.println("");

  Serial.print("InpFrequency="+String(InpFrequency));

  Serial.println("\tInpDurationMillis="+String(InpDurationMillis));

  Serial.print("CycleNumber="+String(CycleMaxNumber));

  Serial.println("\tCycleMicroseconds="+String(CycleMicroseconds));

  Serial.print("HalfCycleMicroseconds="+String(HalfCycleMicroseconds));

  Serial.print("\tHigh="+String(HighDelayMicroseconds));

  Serial.print("\tLow="+String(LowDelayMicroseconds));

  Serial.println("");

// --- LOOP di emissione dei cicli di HIGH-LOW *** per simulare la tone() ***

  for (long Cycle=0 ; Cycle<CycleMaxNumber ; Cycle++) {

    digitalWrite(InpPin, HIGH);

    delayMicroseconds(HighDelayMicroseconds);

    digitalWrite(InpPin, LOW);

    delayMicroseconds(LowDelayMicroseconds);

  }

// --- End TullioAndMaxBeep()

}

// -------------------------------------------------------------------------- Arpeggio()

// Input:

// int InpPin             = Numero del Pin digitale su cui emettere il beep

// int InpNote            = Numero della nota fondamentale

// int InpDutationMillis  = Durata della singola nota (in millisecondi)

// int InpModo            = Modo dell'accordo (0=Maggiore, 1=Minore)

void Arpeggio(int InpPin, int InpNote, int InpDurationMillis, int InpModo) {

// --- Definisco nota da suonare

  int N = InpNote;                          // Nota da emettere

  int DurationMillis = InpDurationMillis;   // Durata della nota da emettere (in millisecondi)

  int T = N;                                // Nota tonica

  int M = N + 4;                            // Nota modale (la terza giusta)

  if ( InpModo == 1 ) { M = M - 1; }        // ma se l'accordo è minore è diminuita di mezzo tono

  int D = N + 7;                            // Nota dominante (la quinta giusta)

  int O = N + 12;                           // Nota tonica (ottava superiore)

 

// --- Emetto tonica

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[T],DurationMillis);

// --- Emetto modale

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[M],DurationMillis);

// --- Emetto dominante

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[D],DurationMillis);

// --- Emetto tonica (ottava superiore)

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[O],DurationMillis);

// --- ri-Emetto dominante

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[D],DurationMillis);

// --- ri-Emetto modale

  TullioAndMaxBeep(BuzzerPin,NoteArrayFrequency[M],DurationMillis);

// -- End Arpeggio()

}

// -------------------------------------------------------------------------- GetForMicroseconds()

// Input:

// int InpMax  = Numero di cicli for da eseguire

// Output:

// long Microsecondi impiegati

long GetForMicroseconds(long InpMax) {

// --- Definizioni  

  unsigned long StartMicroseconds;

  unsigned long StopMicroseconds;

  unsigned long DeltaMicroseconds;

 

// --- Memorizzo Microsecondi di Start

  StartMicroseconds = micros();

// --- Eseguo il ciclo di for

  for (long i=0 ; i<InpMax; i++) {

//    i = i;

  }

// --- Memorizzo Microsecondi di Stop

  StopMicroseconds = micros();

// --- Calcolo Microsecondi impiegati

  DeltaMicroseconds = StopMicroseconds - StartMicroseconds;

// --- Rendo al chiamante

  return DeltaMicroseconds;

// --- End GetForMicroseconds()

}

// -------------------------------------------------------------------------- SetNoteArrayFrequency()

// Caricamenteo Array delle frequenze delle Note Musicali (scala cromatica)

// Input:

// nulla

void SetNoteArrayFrequency() {

// --- Si parte dalla nota 0 = 1° LA basso del pianoforte

  int NoteArrayIndex = 0;

// --- Scansione delle 9 ottave

  for (int Ottava=0;Ottava<9;Ottava++) {

// --- Scansione dei 12 semitoni di ogni ottava

    for (int SemiTono=0;SemiTono<12;SemiTono++)  {

// --- Imposto la frequenze della singola nota

      NoteArrayFrequency[NoteArrayIndex] = 27.500 * pow(2,float(NoteArrayIndex)/12);

// --- Prossima nota

      NoteArrayIndex = NoteArrayIndex + 1;

// --- End loop delle note della ottava

    }

// --- End loop delle ottave

  }

// --- End SetNoteArrayFrequency()

}