Hairless Midi Error: got unexpected data byte

Hi! I’m building a midi controller and, I have a problem… when I start the hairless midi converter I got this error:
+0.006 - Error: got unexpected data byte 0x52
there is the code, thanks for help!

// |===============MESSAGE=================|============DONNEE1============|=========DONNEE2==========|
// | 1000 cccc = note off => 128(10) | 0xxx xxxx: hauteur note | 0xxx xxxx: vélocité |
// | 1001 cccc = note on => 129(10) | 0xxx xxxx: hauteur note | 0xxx xxxx: vélocité |
// | 1110 cccc = pitch bend => 224(10) | 0000 0000: code | 0xxx xxxx: vitesse |
// | 1011 cccc = control change => 176(10) | 0xxx xxxx: numero | 0xxx xxxx: valeur |
// --------------------------------------------------------------------------------------------------
//========================
//Analog pin ZERO
int valuePinZero = 0;
int valuePinZero2 = 0;

//Analog pin ONE
int valuePinOne = 0;
int valuePinOne2 = 0;

//Analog pin TWO
int valuePinTwo = 0;
int valuePinTwo2 = 0;

//Analog pin THREE
int valuePinTHREE = 0;
int valuePinTHREE2 = 0;

//Analog pin FOUR
int valuePinFOUR = 0;
int valuePinFOUR2 = 0;

//Analog pin FIVE
int valuePinFIVE = 0;
int valuePinFIVE2 = 0;

//Analog pin SIX
int valuePinSIX = 0;
int valuePinSIX2 = 0;

//Analog pin SEVEN
int valuePinSEVEN = 0;
int valuePinSEVEN2 = 0;

//Analog pin EIGHT
int valuePinEIGHT = 0;
int valuePinEIGHT2 = 0;

//Analog pin NINE
int valuePinNINE = 0;
int valuePinNINE2 = 0;
void setup()
{
  Serial.begin(9600); // vitesse de communication
}

void loop()
{
  //controleur ZERO
  //----------------
  valuePinZero = (analogRead(0) / 8); //lecture de la valeur du potentiomètre
  if (valuePinZero - valuePinZero2 >= 2 || valuePinZero2 - valuePinZero >= 2) { //si cette valeur varie de plus de 2 entre deux lectures...


    valuePinZero2 = valuePinZero; //...on actualise

    MIDI_TX(176, 75, valuePinZero); //et on envoi un message du type (CONTROLLEUR CANAL 0, NUMERO 75, VALEUR = valeur lue) ==> voir tableau
    //delay(100); //pour le debuggage
  }

  //controleur ONE
  //----------------
  valuePinOne = (analogRead(1) / 8);
  if (valuePinOne - valuePinOne2 >= 2 || valuePinOne2 - valuePinOne >= 2)
  {

    valuePinOne2 = valuePinOne;

    MIDI_TX(176, 76, valuePinOne);
    //delay(100);
  }

  //controleur TWO
  //----------------
  valuePinTwo = (analogRead(2) / 8);
  if (valuePinTwo - valuePinTwo2 >= 2 || valuePinTwo2 - valuePinTwo >= 2)
  {

    valuePinTwo2 = valuePinTwo;

    MIDI_TX(176, 77, valuePinTwo);
    //delay(100);
  }

  
    //controleur THREE
    //----------------
    valuePinTHREE = (analogRead(3) / 8); //lecture de la valeur du potentiomètre
    if (valuePinTHREE - valuePinTHREE2 >= 2 || valuePinTHREE2 - valuePinTHREE >= 2) { //si cette valeur varie de plus de 2 entre deux lectures...

      valuePinTHREE2 = valuePinTHREE; //...on actualise

      MIDI_TX(176, 77, valuePinTHREE); //et on envoi un message du type (CONTROLLEUR CANAL 0, NUMERO 75, VALEUR = valeur lue) ==> voir tableau
      //delay(100); //pour le debuggage
    }

    //controleur FOUR
    //----------------
    valuePinFOUR = (analogRead(4) / 8);
    if (valuePinFOUR - valuePinFOUR2 >= 2 || valuePinFOUR2 - valuePinFOUR >= 2)
    {

      valuePinFOUR2 = valuePinFOUR;

      MIDI_TX(176, 78, valuePinFOUR);
      //delay(100);
    }

    //controleur FIVE
    //----------------
    valuePinFIVE = (analogRead(5) / 8);
    if (valuePinFIVE - valuePinFIVE2 >= 2 || valuePinFIVE2 - valuePinFIVE >= 2)
    {

      valuePinFIVE2 = valuePinFIVE;

      MIDI_TX(176, 79, valuePinFIVE);
      //delay(100);
    }


      //controleur SIX
      //----------------
      valuePinSIX = (analogRead(6) / 8); //lecture de la valeur du potentiomètre
      if (valuePinSIX - valuePinSIX2 >= 2 || valuePinSIX2 - valuePinSIX >= 2) { //si cette valeur varie de plus de 2 entre deux lectures...


        valuePinSIX2 = valuePinSIX; //...on actualise

        MIDI_TX(176, 80, valuePinSIX); //et on envoi un message du type (CONTROLLEUR CANAL 0, NUMERO 75, VALEUR = valeur lue) ==> voir tableau
        //delay(100); //pour le debuggage
      }

      //controleur SEVEN
      //----------------
      valuePinSEVEN = (analogRead(7) / 8);
      if (valuePinSEVEN - valuePinSEVEN2 >= 2 || valuePinSEVEN2 - valuePinSEVEN >= 2)
      {

        valuePinSEVEN2 = valuePinSEVEN;

        MIDI_TX(176, 81, valuePinOne);
        //delay(100);
      }

      //controleur EIGHT
      //----------------
      valuePinEIGHT = (analogRead(8) / 8);
      if (valuePinEIGHT - valuePinEIGHT2 >= 2 || valuePinEIGHT2 - valuePinEIGHT >= 2)
      {

        valuePinEIGHT2 = valuePinEIGHT;

        MIDI_TX(176, 82, valuePinEIGHT);
        //delay(100);
      }

      
        //controleur NINE
        //----------------
        valuePinNINE = (analogRead(9) / 8); //lecture de la valeur du potentiomètre
        if (valuePinNINE - valuePinNINE2 >= 2 || valuePinNINE2 - valuePinNINE >= 2) { //si cette valeur varie de plus de 2 entre deux lectures...


          valuePinNINE = valuePinNINE; //...on actualise

          MIDI_TX(176, 83, valuePinNINE); //et on envoi un message du type (CONTROLLEUR CANAL 0, NUMERO 75, VALEUR = valeur lue) ==> voir tableau
          //delay(100);//pour le debuggage
          }
          }
          


         

          void MIDI_TX(unsigned char MESSAGE, unsigned char DONNEE1, unsigned char DONNEE2) //fonction d'envoi du message MIDI ==> voir tableau
          {
            Serial.write(MESSAGE); //envoi de l'octet de message sur le port série
            Serial.write(DONNEE1); //envoi de l'octet de donnée 1 sur le port série
            Serial.write(DONNEE2); //envoi de l'octet de donnée 2 sur le port série
          }

final_analogin.ino (5.4 KB)

Have you ever heard of arrays?

  if (valuePinZero - valuePinZero2 >= 2 || valuePinZero2 - valuePinZero >= 2) { //si cette valeur varie de plus de 2 entre deux lectures...

Never heard of the abs() function, either, I see.

Why are you calling MIDI_TX with a bunch of ints, when the function declaration CLEARLY says that it takes an unsigned char? Why are you using ints to store byte-sized values, anyway?