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

Bonjour Artouste,
Mon moniteur est ouvert à 115200 baud.
Je n'avais pas utilisé hairless, et après ton message et un plat de pâte :slight_smile: j'ai ouvert hailess pour voir et la j'ai du signal. mais quand j'ouvre mon soft rien ne se passe.
Dans hairless il met ce message :

+12.266 - Serial In: Ch 1: Program change 120
+13.243 - Serial In: Ch 1: Program change 0
+13.243 - Serial In: System Message #8
+13.243 - Serial In: Ch 1: Program change 56
+13.887 - Warning: got a status byte when we were expecting 2 more data bytes, sending possibly incomplete MIDI message 0x80

Mais normalement, je n'ai pas besoin d'hairless avec mon interface. Non?

J'ai cablé le DIN5 au TX1, puis le DIN4 au 5v puis le DIN2 Sur A0.

oui c'est pour ne pas utiliser hairless
une interface hard MIDI DIN simple c'est çà

tout est bien branché. Si je considère 2 du Midi in (avec le triangle) va vers l'Analog A0 de l'Arduino. J'ai retesté sans hairless et rien ne se passe .

Je ne veux pas utiliser un Midi IN sur l'arduino ( pas pour l'instant) j'ai déjà du mal avec mon midi out :sweat_smile:

Beuh! Midi broche 2 vers la terre. ça m'apprendra à répondre dans la précipitation.

Bon! J'ai tester mon interface midi, et elle fonctionne parfaitement .
Je remarque que mon interface midi de reçoit pas d'information de l'Arduino. C'est peut-être ici que le problème se trouve maintenant.
Je regarde ce matin...
Si tu as une idée Artouste, je suis preneur.
J'ai l'impression d'être pas loin de la solution. Argh!!!
Pour le câblage j'ai vérifier et revérifier, toutes les connections sont bonnes.
Je dois mal m'y prendre dans une étape .Pô grave, je recommence. Je veux y arriver!!!!

Bonjour
si dans un premier temps tu ne cherche qu'à injecter du MIDI de l'arduino vers ton adaptateur USB/MIDI

Tu n'a besoin que de çà , une R 220
image

Merci pour cette réponse ultra rapide!
Bon, J'ai essayé, ça marche pô.
C'est peut-être dans le code (que je ne comprends pas enfin dans les détails)
DONC, je me prends une journée et demi pour "apprendre à décrypter les codes" en apprenant à coder je commence après un bon plat de pâtes. a

Attention avec les DIN5 mâle de l'adaptateur usb/MIDI trés souvent MIDI IN et MIDI OUT sont inversées

essaie de tester/inverser les 2 DIN en utilisant juste 4 et 5 des MIDI avec la sortie TX arduino et la R 220 à 5V arduino (c'est optocouplé dans l’adaptateur)

Oh Pinaise!!! Une petite étape encore de franchie :grinning:
Mais du coup j'ai fait une grosse erreur de Noob :sweat_smile
J'ai inversé la broche 4 et 5 de la DIN.
C'est en testant tranquillement et en me posant cette question,

Mais didonc! si tu ne testes que la connectivité tu n'es peut-être pas sûr de la qualité branchement d'origine.
BINGO! me suis planté.
En regardant de face la fiche DIN je l'ai câblée identiquement à l'arrière en me précipitant j'ai erroné mon parallaxe :grin: (ou peut-être cela n'a rien à voir mais en revérifiant tout c'est le seul point qui changeait.

...............................................................
Bon maintenant mon interface reçoit bien du midi, mon soft le reconnait et je peux assigner mes deux potentiomètres :+1:. Mais...

En testant mes potentiomètres et mes boutons dans MIDI_OX je vois qu'ils balayent tout les messages/evenements midi. Beuh...
Donc quand je les assignent dans mon soft c'est la foire.

Est(ce dans le code? dans le câblage? J'en sais rien mais je vais encore regarder sur le net et vérifier si je n'ai pas encore fait une panade quelque part. Si y'a une piste? :grinning:

C'est super quand même, ca avance! C'est pas encore fini, mais du coup ca me motive pour rentrer dans le dur par la suite.

erreurs classiques avec du MIDI connectique DIN :boom: , vu de l’arrière ou vue de l'avant ? MIDI IN ou MIDI OUT ?
A partir de là je pense qque le reste de tes probléme viennent d'un mauvais assignement/interpretation

S tu es sous windows un petit soft incontournable pour jouer avec du midi et arduino
MIDIoX

Assignement dans mon soft? Interprétation du soft?
Pour MIDIoX, je l'ai deja. Comme cité au dessus

Du coup, tu me dis que si c'est la foire dans mon soft, et que cela se vérifie dans MIDIoX c'est un problème d'assignement de ma part que je doit corriger dans mon soft.
L'intégration ? je ne sais pas ce que c'est. C'est dans le code ou ailleurs?

c'est qu'il faut revoir ton soft pour être certain qu'il crache des bonnes trames trames MIDI en fonction de tes souhaits

ok ça marche! Merci ! je continue et je mets à jour le post.
:grin: Le tunnel est bientôt fini je l'espère.

Ah oui! mais mon problème a changé, donc je dois sans doute faire un nouveau post si je n'arrive pas à résoudre mon nouveau problème Non? Et donc marquer ce post comme résolu.

A moins que le code peut être la cause du problème. Mais bon je vais déjà faire ce qui est cité plus haut. Merci encore :+1:

C'est dans la continuité du topic
donc :
post ton code ... correctement
explique ce qui coince

Ca marche! :+1:

YESSS!!!! CA MARCHE :star_struck: :star_struck: :star_struck:

Un grand merci Artouste pour toutes ces infos qui mon permis d'avancer et de conclure une partie de mon projet. Il me reste plus à ajouter un capteur à ultrason et mon capteur de force pour agir sur la vélocité ou autre je verrai. Mais ce sera sans doute dans un autre Topic.

Je fais un résumer demain sur ce que j'ai fais pour que cela fonctionne.
C'était cette fois-ci dans le code.
tout mes softs reconnaissent mon interface et peut assigner tout mes potars et boutons.
YESSS!!! A demain pour le resumer.

Encore Merci Artouste!!!!

Bonjour Artouste et aux autres qui verront ce post.

Résumer du post et nouveau "probleme" :

1_probleme de depart : Pas de reconnaissance Hairless avec mon atmega2560
2_Erreur de ma part puisque l'atmega2560 ne possede pas de 32U4
3_solution Utiliser soit :
-Un Board possedant 32U4
-Un systeme modulaire c'est à dire rajouter unce carte possedant
le 32U4 comme un micro pro sur l'atmega2560
-Utiliser une interface midi du type M-audio
(ou autre moins cher, mais j'en possedait deja une)
4-J'ai choisi la derniere option (par facilité je l'avoue mais c'est cool!)
5-Brancher/connecter tout ce petit monde et faire bien attention aux
connections de la fiche DIN (Noob que je suis je suis tomber dedans)
6-Dans le code, verifier que la ligne "MIDI_CREATE_DEFAULT_INSTANCE();"
est decommenté (si vous avez téléchargé un code deja fait).Pour
moi cela à regeler le probleme d'assignation dans les softs
7-verifier que la vitesse est celle que vous voulez si vous
n'utiliser pas hairless (ici hairless n'a pas lieu d'être avec
une interface midi). ICI j'utilise une vitesse de 31250 et non de 115200
D'ailleurs une note dans le code me previens
// Baud Rate
// use if using with ATmega2560 (uno, mega, nano...)
// 31250 for MIDI class compliant | 115200 for Hairless MIDI
Serial.begin(31250); //*
8_probleme que je ne comprends pas trop :

  • Je ne dois pas alimenter ma
    board en usb et connecter mon interface midi en même temps. Je dois
    Alimenter ma board en secteur ou batterie (pile par ex) et là ca marche
    DOnc ce n'est plus un probleme et cela m'arrange.

ENcore un drand merci à toi Artouste qui m'a mis sur la voie avec des
Phrase courte et simple. Etant novice cela m'a grandement aidé.
Si j'ai fait des conclusions nébuleuse n'hésites pas !

Je ne ferme pas ce post parce que j'ai un nouveau problème :sweat_smile:
Je veux que mes boutons soit reconnu en CC et en Toggle mais je ne sais pas comment intégrer ça dans le code . Je suis en train de regarder ça . Mais si t'a une piste Artouste :grinning:

pas de code, pas de pistes ! :desktop_computer:

Je souhaiterai que le CC et toggle soit afilier aux boutons.

Voici le code qui m'interresse :grin:

MIDI_CREATE_DEFAULT_INSTANCE();

//************************************************************
//***SET THE NUMBER OF CONTROLS USED**************************
//************************************************************
//---How many buttons are connected directly to pins?---------
byte NUMBER_BUTTONS = 0;
//---How many potentiometers are connected directly to pins?--
byte NUMBER_POTS = 0;

//***DEFINE DIRECTLY CONNECTED POTENTIOMETERS************************
//Pot (Pin Number, Command, CC Control, Channel Number)
//**Command parameter is for future use**

//Pot PO1(A0, 0, 1, 1);
//Pot PO2(A1, 0, 10, 1);
//Pot PO3(A2, 0, 22, 1);
//Pot PO4(A3, 0, 118, 1);
//Pot PO5(A4, 0, 30, 1);
//Pot PO6(A5, 0, 31, 1);
//*******************************************************************
//Add pots used to array below like this->  Pot *POTS[] {&PO1, &PO2, &PO3, &PO4, &PO5, &PO6};
Pot *POTS[] {};
//*******************************************************************


//***DEFINE DIRECTLY CONNECTED BUTTONS*******************************
//Button (Pin Number, Command, Note Number, Channel, Debounce Time)
//** Command parameter 0=NOTE  1=CC  2=Toggle CC **

//Button BU1(2, 0, 60, 1, 5 );
//Button BU2(3, 0, 61, 1, 5 );
//Button BU3(4, 0, 62, 1, 5 );
//Button BU4(5, 0, 63, 1, 5 );
//Button BU5(6, 0, 64, 1, 5 );
//Button BU6(7, 0, 65, 1, 5 );
//Button BU7(8, 1, 64, 1, 5 );
//Button BU8(9, 2, 64, 1, 5 );
//*******************************************************************
//Add buttons used to array below like this->  Button *BUTTONS[] {&BU1, &BU2, &BU3, &BU4, &BU5, &BU6, &BU7, &BU8};
Button *BUTTONS[] {};
//*******************************************************************

void setup() {
  MIDI.begin(MIDI_CHANNEL_OFF);
}

void loop() {
  if (NUMBER_BUTTONS != 0) updateButtons();
  if (NUMBER_POTS != 0) updatePots();
  
//*****************************************************************
void updateButtons() {

  // Cycle through Button array
  for (int i = 0; i < NUMBER_BUTTONS; i = i + 1) {
    byte message = BUTTONS[i]->getValue();

    //  Button is pressed
    if (message == 0) {
      switch (BUTTONS[i]->Bcommand) {
        case 0: //Note
          MIDI.sendNoteOn(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
          break;
        case 1: //CC
          MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
          break;
        case 2: //Toggle
          if (BUTTONS[i]->Btoggle == 0) {
            MIDI.sendControlChange(BUTTONS[i]->Bvalue, 127, BUTTONS[i]->Bchannel);
            BUTTONS[i]->Btoggle = 1;
          }
          else if (BUTTONS[i]->Btoggle == 1) {
            MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
            BUTTONS[i]->Btoggle = 0;
          }
          break;
      }
    }

    //  Button is not pressed
    if (message == 1) {
      switch (BUTTONS[i]->Bcommand) {
        case 0:
          MIDI.sendNoteOff(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
          break;
        case 1:
          MIDI.sendControlChange(BUTTONS[i]->Bvalue, 0, BUTTONS[i]->Bchannel);
          break;
      }
    }
  }
}
//***********************************************************************
void updatePots() {
  for (int i = 0; i < NUMBER_POTS; i = i + 1) {
    byte potmessage = POTS[i]->getValue();
    if (potmessage != 255) MIDI.sendControlChange(POTS[i]->Pcontrol, potmessage, POTS[i]->Pchannel);
  }
}

Et voici le code d'origine

// LIBRARIES
// -- Defines the MIDI library -- //

// if using with ATmega328 - Uno, Mega, Nano...
#ifdef ATMEGA2560
#include <MIDI.h> // by Francois Best
MIDI_CREATE_DEFAULT_INSTANCE();

#endif
// ---- //

/////////////////////////////////////////////
// BUTTONS
const int N_BUTTONS = 2; //*  total numbers of buttons
const int BUTTON_ARDUINO_PIN[N_BUTTONS] = { 2, 3, }; //* 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 = 2; //* total numbers of pots (slide & rotary)
const int POT_ARDUINO_PIN[N_POTS] = { A1, 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 ATmega2560 (uno, mega, nano...)
  // 31250 for MIDI class compliant | 115200 for Hairless MIDI
  Serial.begin(31250); //*

#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 
#ifdef ATMEGA2560
// use if using with ATmega328 (uno, mega, nano...)
MIDI.sendNoteOn(note + i, 127, midiCh); // note, velocity, channel

#elif DEBUG
//Serial.print(i);
//Serial.println(": button on");
#endif

        }
        else {

          // Sends the MIDI note OFF 
#ifdef ATMEGA2560
// use if using with ATmega328 (uno, mega, nano...)
MIDI.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 ATMEGA2560
// use if using with ATmega328 (uno, mega, nano...)
MIDI.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];
      }
    }
  }
}

Voilà Merci d'avance. Je pense que je vais apprendre beaucoup sur un nouveau langage aujourd'hui. C'est cool!

Bonjour
Ta question n'est pas claire, expose tranquillement ton probleme

en tout état de cause déjà il manque un include de la lib MIDI sur le 1er code