[RESOLU]Problème code contrôleur midi ATmega2560 et hairless

Bonjour,

Tout d’abord,je suis un noob presque total dans le code et l'électronique mais j’ai envie de me faire plaisir en faisant un contrôleur midi usb. et je suis bloqué avec hairless qui ne reconnaît pas mon arduino. Ce projet m'amène à découvrir un langage que je ne connais pas et m'intéresse de jour en jour. De plus, il se combine avec mon activité.Mais je dois avouer que c’est abrupt! mais je vais y arriver. et quelquefois un peu d’aide n’est pas négligeable. pour voir l’ébauche du projet en action vous pouvez voir une vidéo que j’ai faite sur insta pour vous donner une idée (Login • Instagram)

Le projet est de faire faire un contrôleur midi usb avec:

potentiomètres (B10Kx12)

boutons poussoirs(x16)

capteur ultrason(x1 type hc-sr04) (c’est mon ambition)

potentiomètre sensitif(type softpot linéaire) (c’est mon ambition aussi)

Je possède un arduino ATMega2560 32U4 avec la puce 16u2.

1-J’ai pris ce code pour l’arduino : je ne mets pas le code maintenant car c'est long, j'attendrais votre réponse.

2-J’ai fait le montage avec un bouton poussoir et un potentiomètre et ensuite compiler et téléverser en mode debug. Tout est ok, tout est reconnu.

3-Ensuite j’ai remplacé à la ligne 27 “ # define DEBUG 1 “ par “# define ARTMEGA32U4 1”

4- j’ai commenté toutes les lignes avec sérial en entête( j’ai vu ça sur internet, mais je ne sais pas si c’est bien de faire ça)

5 - Ici j’obtiens un message d’erreur qui me fais pousser les cheveux à l’envers

C:\Users\guita\Documents\ARDUINO CODES\DIY-Midi-Controller-master\DIY-Midi-Controller-master\Code - código\en-DIY_midi_controller\en-DIY_midi_controller.ino: In function 'void buttons()':

en-DIY_midi_controller:149:1: error: 'MidiUSB' was not declared in this scope

en-DIY_midi_controller:171:1: error: 'MidiUSB' was not declared in this scope

C:\Users\guita\Documents\ARDUINO CODES\DIY-Midi-Controller-master\DIY-Midi-Controller-master\Code - código\en-DIY_midi_controller\en-DIY_midi_controller.ino: In function 'void potentiometers()':

en-DIY_midi_controller:226:1: error: 'MidiUSB' was not declared in this scope

C:\Users\guita\Documents\ARDUINO CODES\DIY-Midi-Controller-master\DIY-Midi-Controller-master\Code - código\en-DIY_midi_controller\en-DIY_midi_controller.ino: In function 'void noteOn(byte, byte, byte)':

en-DIY_midi_controller:253:3: error: 'midiEventPacket_t' was not declared in this scope

en-DIY_midi_controller:254:3: error: 'MidiUSB' was not declared in this scope

C:\Users\guita\Documents\ARDUINO CODES\DIY-Midi-Controller-master\DIY-Midi-Controller-master\Code - código\en-DIY_midi_controller\en-DIY_midi_controller.ino: In function 'void noteOff(byte, byte, byte)':

en-DIY_midi_controller:258:3: error: 'midiEventPacket_t' was not declared in this scope

en-DIY_midi_controller:259:3: error: 'MidiUSB' was not declared in this scope

C:\Users\guita\Documents\ARDUINO CODES\DIY-Midi-Controller-master\DIY-Midi-Controller-master\Code - código\en-DIY_midi_controller\en-DIY_midi_controller.ino: In function 'void controlChange(byte, byte, byte)':

en-DIY_midi_controller:263:3: error: 'midiEventPacket_t' was not declared in this scope

en-DIY_midi_controller:264:3: error: 'MidiUSB' was not declared in this scope

en-DIY_midi_controller:264:20: error: 'event' was not declared in this scope

exit status 1

'MidiUSB' was not declared in this scope

Avant je n’avais pas changer à la ligne 27 “DEBUG 1” et avait fait ceci

6-flasher l’arduino avec atmel flip en choisissant un fichier permettant à l’arduino d'être reconnu comme contrôleur usb.

6-Déplugger l’arduino, replugger l’arduino et vérifier si l’arduino est reconnu comme contrôleur midi dans le gestionnaire de périphérique : Et là, ok.

7- ici je rencontrais un problème, mais qui est sans doute dû à une ou plusieurs erreurs en amont évidemment.

J’ouvre Loop midi et hairless qui permettent de créer un pont virtuel entre l’arduino et mon logiciel de DAW ou autre.

8-Hairless ne reconnait mon arduino qui doit être je pense sur un port COM.

Bon… Il est vrai que peut être la solution est simple pour les aguerris, mais pour moi c’est l’impasse. Merci d’avance.Si vous avez besoin d’infos pas de problèmes

Et si la mise en forme doit être différente faites le moi savoir.

Bonjour
utiliser un mega2560 pour faire du midi over usb n'est pas et de loin la meilleure solution
Hairless à un gros defaut , il ne supporte pas sauf à recompiler le 31250 (norme MIDI en input.)

Pour ton projet le plus simple (mais çà ne sera pas pret ce soir pour la fête de la musique ! :crazy_face: ) est d'utiliser un board qui fasse du MIDI over USB en natif.

Perso j'utilise soit des boards équipés avec du 32U4 (arduino leonardo ou clones et dérivés)

et j'avance aussi depuis qq temps avec du pico2040

cela fonctionne trés bien et AMHA investi sur un leonardo (exemple ) tu gagneras en facilité de developpement

Il est vrai que je n’ai pas choisi le plus facile, mais je pense que le mega à plus d’entrée et que cela pourrait être plus facile à gérer. (erreur peut-être puisque j’ai vu que l’on pouvait rajouter des entrées avec d’autres modèles) Mais je souhaitais ne pas avoir à rajouter du matériel en plus.

C’est vrai qu’il n’est pas natif, mais grâce à la puce 16U2 que l’on peut flashez je me dit que cela doit être possible.d’ailleurs en le flashant avec atmel flip je l’ai bien fait reconnaître dans mon gestionnaire de fichier en tant que contrôleur midi(mais j’avais auparavant laisser à la ligne 27 “#define DEBUG 1” dans le code.

Tu utilises des board 32U4 Mais le mien est aussi équipé d’un 32U4, il me semble que l’important c’est que le carte possède la puce 16U2 pour faire passer la carte en contrôleur midi. Mais tu as raison, une carte native aurait été plus judicieux. Mais je dois faire avec maintenant.

Mais au fait, que quoi donc recompiler le 31250 (c'est des bauds?)
Quoi qu’il en soit, mon premier problème n’est pas encore résolu(beuh)

Merci pour ta réponse. Pour mon prochain achat je me pencherais sur une de tes recommandation. J’ai vu aussi qu’il y a les teensy qui sont pas mal

Je vais mettre le code que j’ai pris sur internet.

> /*
>   Made by Gustavo Silveira, 2019.
>   - This Sketch reads the Arduino's digital and analog ports and send midi notes and midi control change
> 
>   
>   If you are using for anything that's not for personal use don't forget to give credit.
> 
>   PS: Just change the value that has a comment like " //* "
> 
> */
> 
> /////////////////////////////////////////////
> // Choosing your board
> // Define your board, choose:
> // "ATMEGA328" if using ATmega328 - Uno, Mega, Nano...
> // "ATMEGA32U4" if using with ATmega32U4 - Micro, Pro Micro, Leonardo...
> // "TEENSY" if using a Teensy board
> // "DEBUG" if you just want to debug the code in the serial monitor
> // you don't need to comment or uncomment any MIDI library below after you define your board
> 
> #define ATMEGA32U4 1 //* put here the uC you are using, like in the lines above followed by "1", like "ATMEGA328 1", "DEBUG 1", etc.
> 
> /////////////////////////////////////////////
> // LIBRARIES
> // -- Defines the MIDI library -- //
> 
> // if using with ATmega328 - Uno, Mega, Nano...
> #ifdef ATMEGA328
> #include <MIDI.h> // by Francois Best
> //MIDI_CREATE_DEFAULT_INSTANCE();
> 
> // if using with ATmega32U4 - Micro, Pro Micro, Leonardo...
> #elif ATMEGA32U4
> #include <Control_Surface.h>
> 
> #endif
> // ---- //
> 
> /////////////////////////////////////////////
> // BUTTONS
> const int N_BUTTONS = 1; //*  total numbers of buttons
> const int BUTTON_ARDUINO_PIN[N_BUTTONS] = {2}; //* pins of each button connected straight to the Arduino
> 
> int buttonCState[N_BUTTONS] = {};        // stores the button current value
> int buttonPState[N_BUTTONS] = {};        // stores the button previous value
> 
> //#define pin13 1 //* uncomment if you are using pin 13 (pin with led), or comment the line if not using
> byte pin13index = 12; //* put the index of the pin 13 of the buttonPin[] array if you are using, if not, comment
> 
> // debounce
> unsigned long lastDebounceTime[N_BUTTONS] = {0};  // the last time the output pin was toggled
> unsigned long debounceDelay = 50;    //* the debounce time; increase if the output flickers
> 
> /////////////////////////////////////////////
> // POTENTIOMETERS
> const int N_POTS = 1; //* total numbers of pots (slide & rotary)
> const int POT_ARDUINO_PIN[N_POTS] = {A0}; //* pins of each pot connected straight to the Arduino
> 
> int potCState[N_POTS] = {0}; // Current state of the pot
> int potPState[N_POTS] = {0}; // Previous state of the pot
> int potVar = 0; // Difference between the current and previous state of the pot
> 
> int midiCState[N_POTS] = {0}; // Current state of the midi value
> int midiPState[N_POTS] = {0}; // Previous state of the midi value
> 
> const int TIMEOUT = 300; //* Amount of time the potentiometer will be read after it exceeds the varThreshold
> const int varThreshold = 10; //* Threshold for the potentiometer signal variation
> boolean potMoving = true; // If the potentiometer is moving
> unsigned long PTime[N_POTS] = {0}; // Previously stored time
> unsigned long timer[N_POTS] = {0}; // Stores the time that has elapsed since the timer was reset
> 
> /////////////////////////////////////////////
> // MIDI
> byte midiCh = 1; //* MIDI channel to be used
> byte note = 1; //* Lowest note to be used
> byte cc = 1; //* Lowest MIDI CC to be used
> 
> /////////////////////////////////////////////
> // SETUP
> void setup() {
> 
>   // Baud Rate
>   // use if using with ATmega328 (uno, mega, nano...)
>   // 31250 for MIDI class compliant | 115200 for Hairless MIDI
>   Serial.begin(115200); //*
> 
> #ifdef DEBUG
> Serial.println("Debug mode");
> Serial.println();
> #endif
> 
>   // Buttons
>   // Initialize buttons with pull up resistors
>   for (int i = 0; i < N_BUTTONS; i++) {
>     pinMode(BUTTON_ARDUINO_PIN[i], INPUT_PULLUP);
>   }
> 
> #ifdef pin13 // inicializa o pino 13 como uma entrada
> pinMode(BUTTON_ARDUINO_PIN[pin13index], INPUT);
> #endif
> 
> }
> 
> /////////////////////////////////////////////
> // LOOP
> void loop() {
> 
>   buttons();
>   potentiometers();
> 
> }
> 
> /////////////////////////////////////////////
> // BUTTONS
> void buttons() {
> 
>   for (int i = 0; i < N_BUTTONS; i++) {
> 
>     buttonCState[i] = digitalRead(BUTTON_ARDUINO_PIN[i]);  // read pins from arduino
> 
> #ifdef pin13
> if (i == pin13index) {
> buttonCState[i] = !buttonCState[i]; // inverts the pin 13 because it has a pull down resistor instead of a pull up
> }
> #endif
> 
>     if ((millis() - lastDebounceTime[i]) > debounceDelay) {
> 
>       if (buttonPState[i] != buttonCState[i]) {
>         lastDebounceTime[i] = millis();
> 
>         if (buttonCState[i] == LOW) {
> 
>           // Sends the MIDI note ON accordingly to the chosen board
> #ifdef ATMEGA328
> // use if using with ATmega328 (uno, mega, nano...)
> MIDI.sendNoteOn(note + i, 127, midiCh); // note, velocity, channel
> 
> #elif ATMEGA32U4
> // use if using with ATmega32U4 (micro, pro micro, leonardo...)
> noteOn(midiCh, note + i, 127);  // channel, note, velocity
> MidiUSB.flush();
> 
> #elif TEENSY
> //do usbMIDI.sendNoteOn if using with Teensy
> usbMIDI.sendNoteOn(note + i, 127, midiCh); // note, velocity, channel
> 
> #elif DEBUG
> Serial.print(i);
> Serial.println(": button on");
> #endif
> 
>         }
>         else {
> 
>           // Sends the MIDI note OFF accordingly to the chosen board
> #ifdef ATMEGA328
> // use if using with ATmega328 (uno, mega, nano...)
> MIDI.sendNoteOn(note + i, 0, midiCh); // note, velocity, channel
> 
> #elif ATMEGA32U4
> // use if using with ATmega32U4 (micro, pro micro, leonardo...)
> noteOn(midiCh, note + i, 0);  // channel, note, velocity
> MidiUSB.flush();
> 
> #elif TEENSY
> //do usbMIDI.sendNoteOn if using with Teensy
> usbMIDI.sendNoteOn(note + i, 0, midiCh); // note, velocity, channel
> 
> #elif DEBUG
> Serial.print(i);
> Serial.println(": button off");
> #endif
> 
>         }
>         buttonPState[i] = buttonCState[i];
>       }
>     }
>   }
> }
> 
> /////////////////////////////////////////////
> // POTENTIOMETERS
> void potentiometers() {
> 
> 
>   for (int i = 0; i < N_POTS; i++) { // Loops through all the potentiometers
> 
>     potCState[i] = analogRead(POT_ARDUINO_PIN[i]); // reads the pins from arduino
> 
>     midiCState[i] = map(potCState[i], 0, 1023, 0, 127); // Maps the reading of the potCState to a value usable in midi
> 
>     potVar = abs(potCState[i] - potPState[i]); // Calculates the absolute value between the difference between the current and previous state of the pot
> 
>     if (potVar > varThreshold) { // Opens the gate if the potentiometer variation is greater than the threshold
>       PTime[i] = millis(); // Stores the previous time
>     }
> 
>     timer[i] = millis() - PTime[i]; // Resets the timer 11000 - 11000 = 0ms
> 
>     if (timer[i] < TIMEOUT) { // If the timer is less than the maximum allowed time it means that the potentiometer is still moving
>       potMoving = true;
>     }
>     else {
>       potMoving = false;
>     }
> 
>     if (potMoving == true) { // If the potentiometer is still moving, send the change control
>       if (midiPState[i] != midiCState[i]) {
> 
>         // Sends the MIDI CC accordingly to the chosen board
> #ifdef ATMEGA328
> // use if using with ATmega328 (uno, mega, nano...)
> MIDI.sendControlChange(cc + i, midiCState[i], midiCh); // cc number, cc value, midi channel
> 
> #elif ATMEGA32U4
> //use if using with ATmega32U4 (micro, pro micro, leonardo...)
> controlChange(midiCh, cc + i, midiCState[i]); //  (channel, CC number,  CC value)
> MidiUSB.flush();
> 
> #elif TEENSY
> //do usbMIDI.sendControlChange if using with Teensy
> usbMIDI.sendControlChange(cc + i, midiCState[i], midiCh); // cc number, cc value, midi channel
> 
> #elif DEBUG
> Serial.print("Pot: ");
> Serial.print(i);
> Serial.print(" ");
> Serial.println(midiCState[i]);
> //Serial.print("  ");
> #endif
> 
>         potPState[i] = potCState[i]; // Stores the current reading of the potentiometer to compare with the next
>         midiPState[i] = midiCState[i];
>       }
>     }
>   }
> }
> 
> /////////////////////////////////////////////
> // if using with ATmega32U4 (micro, pro micro, leonardo...)
> #ifdef ATMEGA32U4
> 
> // Arduino (pro)micro midi functions MIDIUSB Library
> void noteOn(byte channel, byte pitch, byte velocity) {
>   midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
>   MidiUSB.sendMIDI(noteOn);
> }
> 
> void noteOff(byte channel, byte pitch, byte velocity) {
>   midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
>   MidiUSB.sendMIDI(noteOff);
> }
> 
> void controlChange(byte channel, byte control, byte value) {
>   midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};
>   MidiUSB.sendMIDI(event);
> }
> #endif

Oui (gestionnaire de périphériques plutôt , non ?) , mais le 16U2 une fois énuméré en MIDI par chargement hex flip (jamais testé) , tu n' y a pas/plus accès ensuite pour lire/écouter des trames MIDI et tu n'a plus de bootloader, tu te retrouve avec 2 atmega (16 et 32U) qui ne savent pas/plus discuter ensemble .

Oh le noob! J'ai fais une boulette je dis

Je possède un arduino ATMega2560 32U4 avec la puce 16u2.

Non! Je possède un ATmega2560 rev3 avec 16U2 et pas d' Atmega 32U4(beuh, désolé)
je n'ai qu'une seule carte.
Oui t'as raison, gestionnaire de périphérique
Effectivement j'ai chargé le 16U2 avec hex flip ,et si je comprend bien, après cette étape le hairless ne le détecte pas parce que je n'ai plus de bootloader?

Et une chose que je ne comprends pas c'est pourquoi j'ai ce message d'erreur quand je téléverse avant toute tentative de flashez quoi que ce soit.

J'aurais du prendre un arduino uno :sweat_smile:

Désolé, je n'avais regardé les conditions pour bien poster. Le code ci dessus doit être gênant. Je veillerais à ne pas reproduire cette incartade :sweat_smile:

J'aurais du relever moi même.

un arduino mega2560 "legacy" c'est un atmega2560 le mcu principal et un atmega16u pour à l'origine servir de lien usb serial.
Tu ne peux pas intervenir sur la programmation du 16U2 par l'IDE arduino et utiliser du MIDI over USB.

Dans un projet comme le tien il est plus simple de partir sur du systeme modulaire
J'avais fait çà avec un mega2560 en "Master" et comme il n'y avais pas assez d'IO des nanos en tranches supplémentaires, c’était une une base serial MIDI DIN et çà n'avait pas été trop compliqué de passer au MIDI over USB en insérant un micro pro (32U4) .

Oui
pense à lire le topic consacré aux bonnes pratique du forum francophone

(Les bonnes pratiques du Forum Francophone)
:+1:

Je commence un peu à comprendre
Tu me conseille donc de prendre un micro pro qui lui est natif usb grace au 32U4 et de l'insérer au mega?
Ce qui me faciliterai la tache pour la reconnaissance USB/MIDI étant donné que le micro aurait un port COM virtuel en plus du port serie.
Si j'ai bien compris :grin:

en gros
un mega2560 dispose de 4 port serial hard
tu discute en MIDI over USB avec le 32U4 (et donc l'equipement audio I.e traktor et autres soft )
tu discute entre le mega et le 32U4 en serial Hard
tu peux connecter sans probleme du MIDI "DIN" en utilisant un des serial du Mega , çà fait une pseudo passerelle

:+1:

Suis-obligé de mettre du MIDI "DIN"? Je peux directement connecter le mega et le micro pro avec les port serials tx et rx.
ou alors je ne comprends pas la fonction passerelle MIDI"DIN" :sweat_smile:

absolument pas obligé
c'est simplement d'avoir sous la main un dispositif permettant2 types de connexion MIDI

Ah yes!! Bon si je résume, mon problème avec le code ci-dessus et le problème hairless est normal. Puisque mon arduino n'a pas de Microcontroleur 32U4 et pour palier à ce problème je dois utiliser un Arduino avec ce microcontroleur ( qui peut être aussi un leonardo et bien sur le micro).
Le plus c'est qu'en mettant le Mega et le micro je dispose de pas mal D'IO :grinning: enfin c'est relatif.

D'ou ta reponse

Ici j'utiliserai un système modulaire ATmega2560 et Micro 32U4. Comme le nombre des IO me conviennent je n'ajouterai pas de nano :laughing:

il me restera qu' passer à l'assemblage et au code.

je vois juste?

si le mapping de pinout te conviens avec le mega2560 (et éventuellement le pinout du 32U4)
c'est ok
Perso pour du midi over usb au debut j'utilisais un emu 1X1

c'est totalement transparent

Avant je veux te remercier pour tes réponses qui me font grandement avancer dans la compréhension de mon projet MERCI :+1:

tu veux dire que si je branche une interface midi tu type M-audio USB uno (que je possède) sur le mega2560 avec un MIDI DIN ca fonctionnera comme contrôleur midi? C'est peut-être ça la solution!

Il faudra sans doute l'introduire dans le code non? en même temps toutes les infos doivent-être mise dans le micro contrôleur.

Tu l'utilisais au début, pourquoi as tu changé de mode opératoire?

Du coup
Je discute en MIDI over USB avec l'interface midi (du type M audio)
Je discute entre le Mega et l'interface midi avec le port MIDI DIN que j'aurai attaché au mega2560
C'est ça? si c'est le cas ça va me faciliter la tache non?

çà fonctionnera sans aucun problème , il faut juste penser à utiliser un serial hard autre que le serial/USB de base pour conserver la possibilité de debug sur le mega2560
utiliser serial1 2 ou 3 pour recuperer les signaux TTL sur prise DIN5

Je suis passé au 32U4 ou pico2040 parce que c'est plus pratique pour tester avec des PC

Bon, ca avance. Je vais passer la caisse pour des DIN et résistances (je pense je vais regarder).
Je ne clôture pas, j'attends la commande je fais les tests et je met a jour le post.
Merci Artouste pour ces précieux conseils :grinning: :+1:

Bon, me revoilà. Merci encore pour tes réponses Artouste!!!

J'ai reçu mes DIN et fait le montage, plugger mon interface midi M-AUDIO uno. J'ai bien utilisé le serial TX1 pour les TTL sur la DIN5.
J'ai téléverser un code qui semble fonctionner (il y a aucune erreur pendant la compilation, mais bon j'en sais trop rien).
Par contre dans le moniteur les valeurs sont avec des points d'interrogation inversé et des 8.
Bon..
Je fais le test juste avec un potentiomètre 10K Et j'ai bien relié une résistance de 220Ohm sur la DIN5 et une sur la DIN4.
Je plugge mon interface midi (j'ai aussi brancher en usb l'arduino), et dans mon moniteur midi (Pocket midi) rien ne se passe, pourtant il est bien reconnu. Beuh!!
Bonne journée à toi!

ton moniteur serie est ouvert à quelle vitesse ?
attention la lib midi ouvre le port serie à 31250 (vitesse standard MIDI)
et hairless n'accepte pas le 31250

mais normalement tu n'a pas besoin de hairless

comment a tu connecté tes DIN5 ?