Arduino, musique et manivelle

Bonjour à tous, :slight_smile:

Pour le besoin d'un projet que je vais présenter ici, je m'intéresse à Arduino et attends pour demain ma première carte Quimat Arduino Carte UNO R3 Starter Kit. J'espère avoir fait le bon choix.

Disons tout de suite que je débute vraiment en électronique mais potasse les tutoriels pour comprendre comment aborder mon sujet et dans quelles conditions Arduino va pouvoir piloter ce projet.

Je veux construire un appareil à musique qui pourrait ressembler à un orgue de barbarie sauf que la musique sera enregistrée sur une carte SD (ou clef USB) et le son restitué par haut parleur grâce à un système d'amplification qui fonctionnerait sur batterie pour garder sa mobilité à l'instrument.

Si en plus des leds clignotaient au rythme de la musique, cela serait parfait. :wink:

Je ne sais pas encore comment articuler mon projet qui n'en est qu'au stade de l'étude, et la première chose qui me préoccupe est celle de la manivelle qui devra faire en sorte que quand je la tourne ça chante et quand je ne la tourne pas, ça ne chante pas.

Une piste m'a été donnée par un forumeur dans un autre fil qui parle "d'un codeur incrémental pour capter la vitesse de rotation de la manivelle et ainsi modifier la vitesse de lecture" et m'a recommandé d'ouvrir une discussion à ce sujet. Donc, acte.

Je pense que vous pardonnerez mon "amateurisme" d'autant plus que je découvre tout ça d'un coup.

Musique, électronique et Arduino.

Si vous vouliez en discuter avec moi et m'aider à faire mes premiers pas...

Bonjour

Je ne sais pas encore comment articuler mon projet qui n’en est qu’au stade de l’étude, et la première chose qui me préoccupe est celle de la manivelle qui devra faire en sorte que quand je la tourne ça chante et quand je ne la tourne pas, ça ne chante pas.

dans ce cas il suffit d’une ‘dynamo’ pour produire l’énergie électrique alimentant le montage
on tourne ça chante, on ne tourne pas , ça chante pas ! (entre la dynamo et le montage : un pont de diodes, qq condensateurs et un régulateur de tension)

(Dans le cahier des charge ci-dessus il n’est pas demandé de modifier la hauteur du son en fonction de la vitesse de rotation de la manivelle) Autant faire simple !

Je suis justement en train de réparer une petite lampe à leds à manivelle venant d’un supermarché (accu rechargeable LIR 2032 HS) Dedans : une ‘dynamo’, un pont de diodes pour redresser, un accu LIR2032 , qq résistances et 3 leds blanches…
manivelle.jpg
C’est peut être même réalisable sans carte Arduino :
Manivelle, dynamo +redresseur + régulateur + DFPLAYER + carte µSD +ampli éventuel

(Dans le cahier des charge ci-dessus il n'est pas demandé de modifier la hauteur du son en fonction de la vitesse de rotation de la manivelle) Autant faire simple !

Bing, en plein dedans. Merci al1fch d'y avoir pensé et pour ta réponse. :slight_smile:

A vrais dire, bien que sachant que cela soit possible, je n'ai pas (encore) assez de compétances pour comprendre comment cela peut bien fonctionner.

J'y pense toutefois car, selon le lieu de la prestation, intérieur ou environnement plus bruyant, il est utile de pouvoir moduler le son et j'avais pensé à un bête potentiomère. Idée de newsbee bien évidemment.
Les vrais orgues disposent d'un système nommé "transpositeur" pour cela (et aussi à adapter la voix du tourneur (de manivelle) à la tonalité de l'instrument) et il est en effet utile d'y penser dans le cahiers des charges.
Pour la dynamo a manivelle, la piste est à suivre et je vais examiner...

Manivelle, dynamo +redresseur + régulateur + DFPLAYER + carte µSD +ampli éventuel

Le point faible de la dynamo pour alimenter le montage est qu'à l'arrêt de la manivelle la carte Arduino s'arrête et s'éteint; Elle repartira au début du morceau à chaque fois.

Avec un encodeur on peut reprendre la musique précisément là où on s'était arrêté.

Avec un encodeur on peut reprendre la musique précisément là où on s'était arrêté.

La dynamo est une piste comme une autre et merci Christian_R pour cette remarque qui a une sacrée importance.
Pour ceux qui s'intéressent à ce projet et à titre d'information, voici le travail d'un super (et génial) bricoleur Qui passe sa vie à bidouiller des orgues de barbarie tant pour les fabriquer que pour les automatiser avec des systèmes électronique.
Voici une page où il explique pas mal de choses nous concernant et en particulier comment il a bricolé un capteur de vitesse. Voir à ce chapitre vers le milieux de cette page. Il y a même des photos.

http://orgue-de-barbarie.pagesperso-orange.fr/carton_elec.htm

j'avais bricolé un petit code avec un piezo, une résistance et un Keyes KY-040 Rotary Encoder qui jouait "bon anniversaire" (codé en dur) une note après l'autre (dans un sens ou dans l'autre en fonction du sens dans lequel on tournait)

ça doit représenter une cinquantaine de ligne en gérant à la main l'encodeur rotatif - mois encore en utilisant une librairie

si ça vous intéresse je dois pouvoir retrouver ce bout de code

@ J-M-L

Oui, ça m'intéresse au plus haut point et cela me fera des exercises pour chercher à comprendre comment fonctionne tout ça.

Merci. :slight_smile:

Je l’ai retrouvé :slight_smile:

Voici le fichier principal

#include "simpleBouton.h" // Credit to @bricoleau cf http://forum.arduino.cc/index.php?topic=375232.0
#include "notes.h" // pris ici https://www.arduino.cc/en/Tutorial/toneMelody

// ------------------------------------------------------------
// Keyes KY-040 Rotary Encoder Module Pour Arduino
// ENCODER <---> ARDUINO
// CLK     <---> A0     --> CLK (Data Output 1)
//  DT     <---> A1     --> DT (Data Output 2)
//  SW     <---> A2     --> SW(itch) = le bouton 
//   +     <---> 5v
// GND     <---> GND

const uint8_t CLKpin = A0;
const uint8_t DTpin = A1;
const uint8_t SWpin = A2;

#define rotaryPORT PINC // pour l'efficacité on utilise les PORT --> il faut déclarer celui utilisé pour DTPin CLKPin (connectées dans cet ordre et côte à côte)
#define rotaryBitMask 0b11 // les 2 bits du masque pour extraire DTPin CLKPin (connectées dans cet ordre descendant). ici on est en A1 et A0 donc le masque est constitué des 2 bit de poids faible

simpleBouton rotarySW(SWpin); // thanks @bricoleau :)

const uint8_t pinBuzzer = 12; // D12 --- R:220Ω --- PIEZO --- GND

struct uneNote_t {
  int frequence;
  int8_t duree;
};

uneNote_t melodie[] = {
  {NOTE_C4, 8},
  {NOTE_C4, 8},
  {NOTE_D4, 4},
  {NOTE_C4, 4},
  {NOTE_F4, 4},
  {NOTE_E4, 2},
  {NOTE_C4, 8},
  {NOTE_C4, 8},
  {NOTE_D4, 4},
  {NOTE_C4, 4},
  {NOTE_G4, 4},
  {NOTE_F4, 2},
  {NOTE_C4, 8},
  {NOTE_C4, 8},
  {NOTE_C5, 4},
  {NOTE_A4, 4},
  {NOTE_F4, 4},
  {NOTE_E4, 4},
  {NOTE_D4, 4},
  {NOTE_AS4, 8},
  {NOTE_AS4, 8},
  {NOTE_A4, 4},
  {NOTE_F4, 4},
  {NOTE_G4, 4},
  {NOTE_F4, 2}
};


const uint8_t nbNotes = sizeof(melodie) / sizeof(melodie[0]); // le nombre total de notes
uint8_t noteCourante;

// ------------------------------------------------------------
// GESTION DU Keyes KY-040 Rotary Encoder Module Pour Arduino
// ------------------------------------------------------------

enum rotaryAction : uint8_t {NO_ROTARY_ACTION, ROTARY_CW, ROTARY_CCW};
const byte rotaryShiftRight = __builtin_ctz(rotaryBitMask); // count trailing zero to see how many position to shift results

rotaryAction rotaryStep()
{
  static uint32_t rotaryChrono = millis();
  const uint8_t rotaryDebounce = 1u;

  static uint8_t oldMask = (rotaryPORT & rotaryBitMask) >> rotaryShiftRight;
  uint8_t newMask = (rotaryPORT & rotaryBitMask) >> rotaryShiftRight; // read the right pins  and shift result in LSB

  rotaryAction action =  NO_ROTARY_ACTION;
  if (millis() - rotaryChrono >= rotaryDebounce) {
    if ((newMask & 0b1) != (oldMask & 0b1)) {
      if (((newMask & 0b10) >> 1) != (newMask & 0b1))
        action =  ROTARY_CW; // Means pin A Changed first = Clockwise
      else action = ROTARY_CCW;
      oldMask = newMask ;
    }
    rotaryChrono += rotaryDebounce;
  }
  return action;
}


// ------------------------------------------------------------


void setup()
{
  Serial.begin(115200);
  pinMode(CLKpin, INPUT);
  pinMode(DTpin, INPUT);
  pinMode(pinBuzzer, OUTPUT);
  noteCourante = 0;
}

void loop()
{
  switch (rotaryStep()) {
    case ROTARY_CW:
      tone(pinBuzzer, melodie[noteCourante].frequence, 1000 / melodie[noteCourante].duree);
      noteCourante++;
      if (noteCourante >= nbNotes) noteCourante = 0;
      break;
    case ROTARY_CCW:
      tone(pinBuzzer, melodie[noteCourante].frequence, 1000 / melodie[noteCourante].duree);
      if (noteCourante == 0) noteCourante = nbNotes - 1;
      else noteCourante--;
      break;
    case NO_ROTARY_ACTION:
      break;
  }
  if (rotarySW) noteCourante = 0; // remet au début
}

il faut créer aussi un fichier notes.h et le mettre dans le même dossier que le .ino (pris ici)

#ifndef NOTES_H
#define NOTES_H
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978
#endif

qui définit les fréquences (notations anglo-saxonne)

Donc le Piezo en pin 12 avec une résistance de 200Ω par exemple vers GND
l’encodeur sur A0, A1, A2 tel que défini dans le code (et bien sûr 5V et GND)

il faut récupérer la librairie de @bricoleau pour gérer le bouton (en appuyant dessus ça remet la chanson au début)

à vous de jouer :slight_smile:

Merci pour cela J-M-L.

Et hop ! C'est dans ma bibliothèque de tests à opérer sans faute. :wink:

Bonjour à tous,

J'ai finalement réussi à construire mon appareil qui fonctionne avec des cartes RFID pour lancer la musique et pour la manivelle, j'ai utilisé un codeur rotatif.

Merci à ceux qui ont suivi ce fil. :slight_smile:

bravo - on veut des photos :slight_smile:

Oups, le système ne veut pas de mes photos (pas optimisées).

Trouvez les premières ici.

Demain, j'en ferai d'autres plus une vidéo si il ne fait pas trop chaux.