Faire sortir du SON – part 2 le DAC (Convertisseur MIDI → CV/Gate Arduino)

Après les mauvais résultats du filtre RC, je me suis penché sur le DAC, qui a donné des résultats bien plus probants. Avec une liaison SPI, quelque calculs sur la valeurs à envoyer au DAC et un simple SPI.transfer(), on arrive à faire sortir une tension. Par exemple, ce code passe en revue toutes les valeurs possibles que le DAC peut accepter :

Plus d’infos sur le DAC et le SPI ici : http://tronixstuff.wordpress.com/2011/06/15/tutorial-arduino-and-the-spi-bus-part-ii/ (en anglais)

#include "SPI.h"

word outputValue = 0; // word = 16 bits

byte data = 0;

int a;

void setup()

{

//set pin(s) to input and output

pinMode(10, OUTPUT); //verrou du DAC

SPI.begin(); //démarrage de la liaison SPI

SPI.setBitOrder(MSBFIRST);

}

void dac(int a)

{

outputValue = a;

digitalWrite(10, LOW);

data = highByte(outputValue); //on enverra les données en 2 octets : selection du premier octet

data = 0b00001111 & data;

data = 0b00010000 | data; //on ajoute les paramètres du DAC à envoyer

SPI.transfer(data);

data = lowByte(outputValue);

SPI.transfer(data); //deuxième octet

digitalWrite(10, HIGH);

delay(100);

}

void loop()

{

for(int a=0; a<=3800; a++)

{

dac(a);

}

}

 

Pour accorder le DAC, j’ai fais le choix d’utiliser un tableau de valeurs, afin 1) d’éviter des calculs à l’Arduino et 2) une gestion plus facile de l’accordage (à mon sens). Pour cela, j’ai utilisé un bouton poussoir, un accordeur, et un peu de code. Chaque pression sur le bouton incrémentait ma variable a, et avec l’accordeur, je notais les valeurs où la note était juste. J’ai fait ça pour une dizaine de note, et en ai déduit les autres.

La partie MIDI est simple : un callback pour simplement le NoteOn et NoteOff, et une variable qui évite de couper la note en cours si on reçoit un message NoteOff d’une note différente. Plus d’info sur la librairie MIDI que j’ai utilisé ici : http://playground.arduino.cc/Main/MIDILibrary (en anglais)

Pour le montage de l’Arduino sur la breadboard, cette page http://arduino.cc/en/Main/Standalone (en anglais) vous ravira, et pour l’envoi des programmes sur l’ATMega dans le circuit, j’ai utilisé https://www.sparkfun.com/tutorials/200 (en anglais)

Le code « final » est là. Ce code permet, à l’heure actuelle :

  • L’accord note par note

  • la conversion de signaux MIDI de type NoteOn et NoteOff en signaux CV/Gate

 

#include <MIDI.h>

#include <SPI.h>

byte
Lire la suite

Faire sortir du SON – part 1 le filtre

J’avais deux solutions pour transformer l’impulsion en PWM sortant de l’ATMega en signal continu 0-5V pour contrôler le monotron :

N’ayant pour l’instant pas sous la main de DAC (qui va arriver dans la deuxième commande de matériel), j’ai déjà testé avec un filtre RC. Après avoir enlevé la résistance R11 (Beatnic explique tout ça ici), j’ai d’abord fait un petit montage à l’arrache sur ma breadboard histoire de voir ce que ça donnait :

Image

Le rendu était mauvais : j’avais une étendue de deux tons, environs. J’ai du adapter quelques résistances. J’ai également fImageait des soudures un peu plus propre derrières le monotron,celles que j’avais utilisés jusque là restaient des test que j’avais fais il y quelques mois. A gauche sur la breadboard, l’optocoupleur et la diode pour le MIDI (j’avais fais le montage mais ne m’en suis pas servi pour l’instant)

J’ai donc ajouté des résistances en sorties (2*10M, de mémoire), et ai programmé l’Arduino pour que sa sortie PWM prenne toutes les valeurs possibles. J’ai également programmé un genre de voltmètre, qui me renvoyait pour chaque valeur la tension de sortie du filtre. Le résultat en vidéo :

(sur l’écran de l’ordinateur, la valeur de gauche est la valeur du rapport PWM, et celui de droite la tension de sortie du filtre (en unité, entre 0 et 1023) (infos)

Néanmoins, ça ne me convenait pas. L’étendue du clavier n’est pas suffisante, à peine quelques octaves. La solution sera donc le DAC, qui sera plus souple et plus précis.

Le code de test, au cas où (attention, c’est brouillon) :

byte tensout=0;
int analogIn = 5;
int tensin=0;
int analogOut=5;
int c=1;
float valin=0;
int i=0;
const int gatePin=7;

/* Permet de faire un tableau, via SERIAL, de la correspondance entre le rapport du PWM et la tension en sortie. tension exprimée en unité, à multiplier par 0.0049 */

void setup() 
{
 Serial.begin(9600);
 Serial.println("Pret");
 int c=1;
 analogReference(DEFAULT);
 pinMode(gatePin, OUTPUT);
}

void tens() 
{
 analogWrite(analogOut,0);
 delay(500);
 Serial.print(i, DEC);
 Serial.print(" ");
 valin = analogRead(analogIn);
 Serial.println(valin,0);
 int i=1;
 while(i<=255)
 {
 analogWrite(analogOut, i);
 digitalWrite(gatePin, HIGH);
 Serial.print(i, DEC);
 Serial.print(" ");
 delay(500);
 digitalWrite(gatePin, LOW); //stop sending gate signal
 delay(500);
 valin = analogRead(analogIn);
 Serial.println(valin,0); 
 i++;

}

}

void loop(){
if (c==1){
 tens();
 c++;
 Serial.print("END");
}
}

IMG_20130501_155156 (Copier)Deutsches Qualität

Présentation du projet et gestion du clavier (part 1)

L’idée est d’ajouter un clavier, un moyen de communiquer avec l’extérieur (du MIDI, donc), d’améliorer les contrôles, et de rajouter deux-trois fonctionnalités, comme la distortion, le mute du VCO, la mod de l’attaque, le tout dans le budget le plus réduit possible. Pour ça, donc, on recycle ce qu’on peut .. Le clavier vient d’un jouet Hello Kitty :

Image

Image

Image

des touches en bloc …(avec une clé USB pour l’échelle)

IMG_20130401_003404 (Copier)

… et une matrice codée bizarrement (37 touches pour 13 i/o ?!)

Au début, je pensais gérer le clavier avec un réseau de résistances, comme ici (http://generaledefoutre.wordpress.com/2012/05/29/korg-monotron-mods-et-travaux-part-1/), mais souhaitant pouvoir transposer, etc, j’avais besoin de quelque chose de plus souple. La gestion sera numérique ! On va passer par des puces programmables ATmega 328, et, ô surprise, la même puce qu’on retrouve dans l’Arduino Uno .. Il me sera bien utile pour le développement. J’aurai en fait besoin de deux puces ATmega : la première se chargera de décoder le clavier et d’envoyer des signaux midi, la deuxième décodera ces signaux midi (ou ceux provenant de l’entrée MIDI pour contrôleur externe) et les convertiras en signaux CV/gate, pour attaquer le monotron, en prenant en compte la transposition demandée, en gérant l’affichage, etc ..

Image

Le clavier est codé comme ça :Image

Je pensais pouvoir m’en sortir juste en envoyer tour à tour 5V sur les entrées BP00 à BP04, en lisant à chaque fois l’état de BP20 à BP27. Mais de gros problèmes de parasites sont apparus, j’avais des 0 et des 1 en pagaille, rien de bien concluant. Et je suis tombé sur http://www.codetinkerhack.com/2012/11/how-to-turn-piano-toy-into-midi.html et sur http://electroniqueamateur.blogspot.fr/2012/05/decodage-dun-clavier-dorgue-par-un.html (que je n’avais pas trouvé lors de mes nombreuses recherches sur internet 😦 ), qui utilisent tous les deux un registre à décalage .. Je vais donc me pencher là dessus.

Présentation du projet

L’idée est d’ajouter un clavier, un moyen de communiquer avec l’extérieur (du MIDI, donc), d’améliorer les contrôles, et de rajouter deux-trois fonctionnalités, comme la distortion, le mute du VCO, la mod de l’attaque, .. à un monotron, le tout dans le budget le plus réduit possible, histoire d’exploiter un peu le potentiel énorme de cette jolie bébête, et de garder une évolutivité possible. Après des mois à griffonner sur du papier, j’ai construit une maquette en 3D sous Sketchup (que vous pouvez trouver ici – skp – 8.2mb). Voici un aperçu de ce à quoi mon Monotron II ressemblera (note pour moi-même : retravailler le nom)

face

32av

34

On retrouvera, entre autres :

  • deux potentiomètres à la place d’un seul pour l’accord du taux du LFO
  • une distorsion avec un passe-haut commutable
  • le mute du VCO
  • contrôle de l’attaque du LFO
  • le choix entre le contrôle via source MIDI externe ou clavier interne
  • contrôle du glide
  • contrôle de la valeur du pitch bend par encodeur et affichage sur écran 7 segments
  • contrôle de la valeur de transposition par encodeur et affichage sur écran 7 segments
  • fonction hold (laisse une note jouée)
  • entrée du filtre conservée
  • MIDI out du clavier
  • Suppression de l’étage d’amplification (moins de souffle, pas de filtre)

La façade sera en verre synthétique, surement peint de l’intérieur, et la bestiole aura des flancs en bois. Le montage des puces et composants électroniques se fera sur un PCB maison.

J’ai laissé tomber l’idée d’ajouter un simple kit MIDI, comme celui proposé par beatnic, pour des raisons d’évolutivité : je veux pouvoir tout contrôler, et pouvoir rajouter une fonction l’an prochain si ça me chante. Il est plus simple et moins cher (mais plus long ..) de tout traiter par des ATmega programmables.

Le budget attendu est de l’ordre de 150-180€, tout compris (monotron, arduino, ..). N’ayant que 18 ans, j’ai du acheter un peu d’équipement pour la réaliser (3ème main, fer à souder pour électronique, ..)

— SOURCES —

Voici quelques liens qui m’ont bien aidé sur ce projet :