Faire son propre contrôleur MIDI USB: Présentation de l’environnement Arduino

Ca y’est c’est parti! On va aujourd’hui prendre en main l’environnement Arduino. Nous allons apprendre les bases et tenter de nous familiariser avec technologie afin de pouvoir comprendre ce que nous ferons dans les chapitres qui vont suivre. Il vous appartient de suivre ou non, puisque je livrerai tout de même les codes brut de fonderie pour celles et ceux qui ne souhaitent  pas comprendre mais juste fabriquer leur jouet.

Installation de l’IDE

« Ca y’est ça commence, il nous balance un trigramme à la tronche: IDE… ». L’IDE est l’environnement de développement qui va nous servir à créer nos programmes, les compiler et les uploader dans notre carte électronique. (Définition d’un IDE). Pour faire simple, c’est le logiciel dans lequel nous allons écrire un programme informatique, ce logiciel le transformera en un bout de code (compilation) qui saura être compris par notre carte Arduino, et se chargera ensuite d’envoyer ce code dans la carte elle même.

Pour installer l’environnement, rendez-vous sur la page d’Arduino dans la section download: Download

Je ne vais pas détailler l’installation, c’est très très simple à vous de jouer!

Découverte de l’interface de programmation

A l’ouverture du logiciel, vous tomberez sur la fenêtre suivante:

Comme vous pouvez le constater, la fenêtre est divisée en 3 parties:

– Outils

– Code

– Logs

Nous allons dans un premier temps détailler la barre d’outils qui nous sera très utile tout au long de nos manipulations:

La barre d’outils

Verify: Il nous permettra de contrôler si notre programme est bien écrit, et ne comporte pas de faute ni de logique, ni de synthaxe.

 

Upload: comme son nom l’indique, il nous permettra d’envoyer le programme dans la carte Arduino. Et comme son nom ne l’indique pas, si vous n’avez pas fait de Verify au préalable il se chargera de le faire aussi 😀

C’est la gestion des fichiers: New, Open (ouvrir) et Save (enregistrer), on détaille? Non je ne crois pas 🙂

 

Le dernier, mais de loin un des plus important à comprendre c’est le Serial Monitor. Il vous permettra d’ouvrir un moniteur de liason série….Arf ça y’est ça commence, des termes barbares et très techniques se pointent! Vous me laissez une chance de vous expliquer ce que c’est? Allez on y va. De tout temps l’homme… Pour faire simple: La carte Arduino sera connectée à votre ordinateur par un câble USB. Mais ce n’est pas vraiment une connexion USB qui opère entre votre ordinateur et votre carte. C’est ce que l’on appelle une liaison série. C’est un protocole qui leur permet de dialoguer ensemble (dans les deux sens). Pour faire une comparaison, pensez au MIDI qui lui aussi est un protocole qui permet à plusieurs instruments de dialoguer ensemble dans les deux sens (MIDI IN, MIDI OUT). La différence notable avec le midi (enfin la différence dont nous devrons tenir compte pour notre projet) c’est que nous pouvons régler la vitesse de dialogue sur un port série, alors qu’en midi c’est fixe, mais nous y reviendrons. Mais à quoi sert un moniteur série? Et bien tout simplement à matérialiser nos actions, à écrire sur l’écran ce que nous dira la carte Arduino quand on bougera un potentiomètre par exemple. Il nous permettra donc de calibrer, de vérifier de corriger notre programme pour arriver au résultat souhaité.

La fenêtre de programmation:

Eh bien c’est tout simplement comme un notepad ou n’importe quel autre éditeur de texte qui nous permettra de rentrer notre code avec nos petite mains! Le petit plus (mais qui n’est un pas un fort d’Arduino), c’est ce que l’on nomme la complétion. Certaines instructions et variables seront automatiquement reconnues par cet éditeur et changerons automatiquement de couleur pour nous indiquer que nous n’avons pas fait de faute de syntaxe.

La fenêtre des Logs:

Vous vous rappelez à l’école, quand il y avait un contrôle, vous étiez obligés de créer une marge pour que le prof puisse corriger vos exercices, et marquer en rouge ce qui n’allait pas (ou ce qui allait d’ailleurs). Eh bien là c’est pareil, quand vous lancerez des actions, soit ça passe et ça nous le dit, soit ça ne passe pas et ça nous le dit aussi. Par exemple, s’il y a une faute de syntaxe, quand on lancera la vérification, c’est là dedans qu’on nous dira qu’il y a en a une et où.

 

Pffffiouuuuu que de théorie, que de théorie…Mais malheureusement cela va continuer un peu 🙂 Mais promis nous arriverons vite à du pratique!

Bon puisqu’on est dans l’explication de l’environnement de dev, on va rester encore un peu sur la partie logicielle, on enchainera sur la partie hardware ensuite.

Qu’est-ce que c’est un programme?

Alors là, je ne suis pas développeur à la base (vous non plus d’ailleurs si vous êtes en train de lire ça), je vais donc vous donner ma vision, mais ce n’est pas forcément la bonne définition. En gros c’est un ensemble d’instructions qui vont dire à votre carte de réagir comme ça à tel événement. Exemple, si je tourne un potard vers la gauche, j’envoie un midi CC qui augmente sur ma sortie MIDI. La façon de programmer dans Arduino a été pensée à la base pour des designer industriels n’ayant aucune notion de programmation, c’est un C pour les newbies donc plutôt accessible. Ma vision des choses m’amène à distinguer trois sujets important: Les données, les fonctions/opérations, les librairies (dans un premier temps cela nous suffira largement.) Pour faire un parallèle avec Ableton Live par exemple:

– Les données: on pourra dire qu’un clip audio est une donnée

– Le bouton play: une fonction qui nous permettra de lancer une lecture sur la donnée (le clip)

– Un plug d’effet: une librairie qui nous permettra d’apporter un traitement facilité sur notre clip…

Un programme (dans sa version simple) Arduino est composé de trois parties principales:

La déclarations des données, une fonction Setup (dans laquelle on va mettre en place certaines configurations qui resteront vraies pendant toute l’exécution d’un programme), et une fonction Loop qui est une boucle infini qui exécutera un ensemble d’instructions en boucle.

Mais qu’est ce qu’une carte Arduino?

Bon on vient de se bouffer pas mal de théorie sur l’environnement de dev, et en plus sans exemple!!!! On aurait pu commencer un TP, mais bon il me semble qu’une dernière couche de théorie est nécessaire.Donc on va continuer dans l’abstrait mais en un peu moins chiant et peut être déjà un peu plus parlant pour vous. On enchaine sur la présentation hardware de la carte Arduino. En gros une carte Arduino est un mini ordinateur constitué d’un micro contrôleur (l’équivalent du micro processeur dans un ordinateur) et de différentes entrées sorties ( l’équivalent sur un ordinateur seront les prises USB, la sortie vidéo, l’entrée/sortie audio, etc). Une carte Arduino va donc nous servir à soit recueillir des informations venant de différents périphérique (pour le coup il s’agira la plupart du temps de capteurs: potards, boutons, encodeurs, …) et d’envoyer des informations en sortie (vers notre ordinateur en ce qui nous concerne) formatées. Voici un schémas détaillant les entrées sorties d’une carte Arduino:

Pour le projet qui nous intéresse, nous auront des potards et des boutons reliés à notre carte Arduino, cette dernière devra regarder dans quels états ils se trouvent, formater les résultats sous forme de message MIDI et les envoyer vers notre ordinateur ( On pourrait aussi tout à fait se passer d’ordinateur, en matérialisant physiquement des prises MIDI directement sur la carte Arduino, le web regorge de projets comme ça, moi ce qui m’intéresse pour le coup c’est de vous montrer comment réaliser un périphérique MIDI USB). Faisons donc un petit schémas expliquant ce à quoi nous voulons arriver. On avait dit dans l’article précédent:

6 boutons, 5 potentiomètres (dont un fader):

La carte Arduino devra savoir dans quels états se trouvent ces différents capteurs. Je n’ai pas placé les deux groupes (boutons et potentiomètres) au hasard géographiquement sur l’image. Si vous remarquez bien, les potentiomètres sont du coté des entrées analogiques et les boutons du côté des entrées/sorties digitales. Mais pourquoi donc???? C’est quoi la différence entre une entrée digitale, et une entrée analogique??? Commençons par la plus facile: une entrée digitale ne sait lire que deux état différents: 0 ou 1 (Électroniquement parlant ce sera 0 volt ou 5 volts), et une entrée analogique sur une Arduino saura elle reconnaitre 1024 états différents, de 0 à 1023. Vous commencez à comprendre? Je brancherai donc mes boutons sur les entrées digitales, pour savoir s’ils sont enfoncés ou pas, et les potards sur les entrée analogiques, pour savoir où ils en sont dans leur course (complétement à gauche 0, au milieu 512, complétement à droite: 1023). Vous avez donc maintenant une vision globale de ce à quoi nous souhaitons arriver à la fin de notre projet.

Entrons dans le vif du sujet, c’est parti!!!!!!

Bon ca y’est un peu de pratique now!!! Pour nos premiers pas : Nos premières ligne de code et nos premiers câblages, je vous propose de voir comment connecter un simple potentiomètre et d’aller lire sa valeur mais où doc??? Eh bien dans le serial monitor!!!! Go go go:

  • Mise en place matérielle:

Matériel nécessaire:

– Un potentiomètre 10k linéaire

– 3 petits bouts de câble

– une carte Arduino

– un ordinateur lol

Première étape: souder 3 fils d’une longueur d’au moins 15cm sur chacune des 3 pattes d’un de vos potentiomètres. Ensuite brancher les 3 fils comme sur le schémas suivant:

Le fil du milieu dans l’entrée analogique A0, un fil d’une extrémité dans l’entrée GND (Ground/ 0V), et la dernière dans la sortie 5V. Ce qui va se passer électroniquement: Quand vous allez tourner votre potard, dans le fil du milieu,  vous aller envoyer un signal compris entre 0 et 5v selon la position du potard. Complétement à gauche 0V, vers le milieu 2,5v et à fond 5V (Si c’est le contraire qui se passe inversez les fils des extrémités.) Le microcontroleur se chargera de traduire ces valeurs entre 0 et 1023. Quoi je vous embrouille? Bon eh bien pour aller vérifier tout ça, on va commencer à coder.

  • Mon premier code

D’habitude sur la plupart des tuto le premier truc qu’on vous apprends à faire c’est de faire clignoter une LED, mais bon déjà ici on n’aura pas de LED à allumer, et puis si vous êtes ici c’est que vous voulez bouger du potard pour faire du son alors go, on va direct apprendre à jouer avec.

Précédemment, je vous ai expliqué qu’un code typique Arduino se construit principalement en trois partie (je répète pour ceux qui ont déjà oublié):

– La déclaration des variables

– La fonction setup

– La fonction loop (boucle infini)

Dans notre premier code, nous aurons besoin de 2 variables:

  • La valeur que nous retournera notre potard en fonction de sa position
  • Le numéro de l’entrée sur laquelle nous allons brancher notre potard.

En ce qui concerne notre partie setup/initialisation

  • nous aurons juste besoin de dire que nous allons utiliser le port série pour communiquer entre notre ordinateur et notre carte Arduino, afin de pouvoir lire à l’écran la valeur que nous indiquera le potard, et ce dans le serial monitor (<- ça peut faire barbar, mais ne vous inquiétez pas en pratique vous verrez c’est très simple et super logique!)

En ce qui concerne la boucle infini:

  • notre programme principal en gros, nous devrons faire en sorte que celui-ci lise en continu la position du potard et renvoie régulièrement sa valeur dans le serial monitor pour nous l’afficher.

Ce que je vous propose c’est de vous donner le code que je vous expliquerai ensuite (par contre je le mets en format image, pour vous forcer à le taper par vous même, il n’y a pas meilleur entrainement pour se faire la main (nan Jee, pas de remarque désobligeante steuplé)):

Déclaration des variables:

Déja vous voyez la première ligne qui commence par 2 « // Déclaration…. » Les 2 slash signifient que la ligne qui suit est un commentaire, qu’elle ne sera pas prise en compte dans notre programme. Ca aide à s’y retrouver quand on revient dans un code que nous n’avons pas parcouru depuis longtemps. Dans notre cas le code va être très simple mais cela peut vite devenir crucial.

int valeurPotard;

Ceci est une déclaration de variable. Le premier mot: int nous indique le type de variable que nous sommes en train de déclarer. Dans ce cas, int est l’abréviation de integer (nombre entier), et sa valeur peut être comprise entre -32768 et 32767. valeurPotard est le nom de la variable, c’est nous qui la choisissons. Il faut choisir un nom parlant, car encore une fois ici le code est simple, mais rapidement le nombre de variable va augmenter et pour nous y retrouver il faudra des noms explicites qui nous simplifieront la vie. La ligne se finit par un « ; » vous verrez que chaque instruction en C doit se finir par un point virgule.

int potard1 = A0;

Comme précédemment nous déclarons une nouvelle variable du type int. Celle ci correspond à l’entrée que nous allons utiliser pour brancher notre premier potard. La différence avec la déclaration précédente réside dans le fait que nous attribuons dès le départ une valeur à notre variable, ici A0. Vous apprendrez rapidement, que l’Arduino UNO possède 6 entrées analogiques: A0, A1, A2, A3, A4 et A5.

 

void setup()

{

}

Bon là je ne vais pas entrer dans les détails, mais sachez que pour un code écrit en Arduino il vous faudra toujours une fonction setup. Pour la déclarer c’est void setup() et comme dans toute fonctions, pour « l’encadrer » vous devrez toujours au début insérer l’accolade { au début et } à la fin. Tout le contenu de la fonction devra se trouver entre les deux. Ce qui est le cas avec notre première instruction:

Serial.begin(9600);

Cette instruction veut littéralement dire: Début de la communication série à une vitesse de 9600 bauds. On démarre une communication série entre l’Arduino et l’ordinateur. C’est cette instruction qui nous permettra d’aller afficher ensuite la valeur de notre potard dans la fenêtre du moniteur série. Si vous voulez en savoir plus sur les communications série allez lire cet article directement sur le site Arduino.

void loop()

{

}

Comme pour la fonction setup, la fonction loop() est obligatoire dans un programme destinée à une carte Arduino. C’est en quelque sorte le programme principale, c’est dans cette boucle que tout va se passer (ou presque). Un fois le setup passé (initialisation), le programme tournera à l’infini dans cette boucle. C’est comme si dans LIVE, vous établissiez une loop entre les locator 16 à 18. Vous commencez la lecture depuis le locator 0, il va lire jusque 16 et ensuite tournera en boucle entre 16 et 18.

valeurPotard = analogRead (potard1)/8;

Ca y’est on code pour de vrai!!!! Alors, ici on donne une valeur à valeurPotard en faisant suivre un = après le nom de la variable. analogRead(potard1) est une fonction qui prend en paramètre potard1. analogRead est la fonction qui va aller mesurer le courant qui passe dans une entrée analogique; Là on lui demande d’aller lire le courant qui passe dans l’entrée potard1, donc A0!!! On aurait pu écrire directement: analogRead(A0); mais il vaut mieux prendre l’habitude de travailler avec des variables vous comprendrez vite pourquoi, faites moi confiance. Et le /8 qu’est-ce qu’il vient faire à la fin??? Eh bien rappelez vous, je vous ai dit que les entrées analogiques de l’arduino nous retournaient des valeurs comprises entre 0 et 1023, mais les valeurs midi elles sont comprises entre 0 et 127!!!! donc 1023/8=127 :))) Ah oui un seul slash c’est le signe de la division.

Serial.print(« Valeur de mon potard: »);

Serial.println(valeurPotard);

Dans la famille Serial je vous donne le print: Le Serial.print avec en paramètre une chaine de caractère entourée de guillemets (un phrase quoi), va aller écrire cette meme phrase dans le serial monitor. La différence en Serial.print et Serial.println le petit ln de la fin veut dire qu’à chaque fois que l’écriture est faite dans le serial monitor on ajoute un retour chariot pour passer à la ligne suivante. Donc ici, avec le premier Serial.print, on va écrire la phrase à la suite de celle-ci on va afficher valeurPotard puis on fait un retour chariot.

delay(100);

on va créer une latence, c’est juste pour l’esthétique de l’affichage que cela reste lisible à l’oeil 😀 Donc dans notre cas, on demande au programme de faire une pause de 100ms, le paramètre est en ms. Pour bien faire, on aurait pu dans l’initialisation de variables au début du programme faire un:

int delayAffichage ou int vitesseAffichage (<- c’est vous qui décidez du nom de votre variable) donc je disais int delayAffichage = 100;

et donc la dans la boucle on met: delay(delayAffichage);

Une fois cette pause de 100ms effectuée, on retourne au début de la fonction loop, on lit à nouveau la valeur du potard…et ainsi de suite :))))))

 

Il ne vous reste plus qu’à compiler puis uploader le programme sur votre carte, ouvrir la fenêtre du moniteur série

Voici une petite vidéo de ce que cela doit vous donner:

 

Bon eh bien mangez vous ça déjà, n’hésitez pas à poser vos questions, ici, pas sur le forum SVP! La suite pour bientôt 🙂

Amicalement,

EATY1

 

 

 

 

 

 

 

14 réflexions au sujet de « Faire son propre contrôleur MIDI USB: Présentation de l’environnement Arduino »

  1. Super! Je redoutais le plus la partie programmation de part la complexité mais en même temps de peur de suivre bêtement sans comprendre. L’explication des fonctions est top! Par contre j’ai eu du mal a comprendre les fonctions print et print « à la ligne » car certaines images sont manquantes je n’ai pa pu lire le code en entier.

    Merci en tout cas! J’ai pas besoin d’un controlleur en plus mais ça me donne méchamment envie de faire un caprice là XD

  2. Merci pour l’update les images s’affiche 😉

    Par contre question d’anticipation: comment on va faire pour connecter les autres potards alors qu’il n’y a qu’un 5v et qu’un ground du coté analogique?

  3. Imagine l’électricité comme de l’eau. Pour que l’eau coule il faut qu’il y a une différence d’altitude une pente. En électricité on parle de différence de potentiel, on mesure un potentiel en volts. Pour continuer sur l’analogie avec l’eau, les cable c’est comparable à du plat ou presque et donc le potentiel est le même à tous les points du cable (quand il commence à il y avoir une certaine section et une certaine longueur il commence à il y avoir une résistance donc une différence de potentiel).
    Pour en revenir à l’excellent tuto d’Eaty, Tu peux relier plusieurs chose au 5v et au GND tant que tu reste dans le raisonnable en section et longueur de cable ^^

    • Je viens de découvrir ce tuto et j’attends impatiemment la suite avant de me lancer complètement. C’est exactement ce que je recherchais, c’est génial merci beaucoup pour cette science qui finalement n’est pas si éloigné de nous ( intellectuellement parlant)

  4. La suite pour bientot… Je ne serais pas aussi précis que je le souhaitais initialement, manque de temps ou fainéantise je ne sais pas trop, mais ce que vous saurez faire à la fin c’est un controleur MIDI à votre image, USB pour pas trop cher 😀

    • Bonsoir, avant de faire de la pub, il aurait pu être sympa d’en demander l’autorisation, mais bon passons. Votre système modulaire a l’air effectivement bien sympathique. Cependant, il a pour moi un gros manque, il ne fonctionne pas en USB, mais seulement en MIDI DIN, ou en serial, et du coup en mode USB il vous faut utiliser un soft tiers… Là où je dirige ce tutoriel, la carte Arduino sera directement reconnue comme device MIDI. Votre concept est néanmoins intéressant, il ne parait pas difficile d’ailleurs de le mener un cran plus loin avec une petite optim du code, et l’utilisation d’HIDUINO pour le rendre full midi USB 😉

Laisser un commentaire