Multiplexer 43 fourches optiques

[Janosch]

Bonjour !

Je suis en train de plancher sur un projet: je voudrais "lire" 43 fourches optiques (avec un arduino nano).
C'est pour convertir un mélodica en MIDI.
Je pensais multiplexer en 8x6.
Pour la partie programmation, pas de soucis je me débrouillerais, c'est au niveau du câblage que j'ai plus de lacunes.

Voila où j'en suis pour l'instant:
(j'ai mis que 3 colonnes, mais il y'en aura 8...)

C'est fait avec le peu de connaissances que j'ai, et je suis sûr qu'il y'a des choses qui vont pas.
Les doutes que j'ai:
-Est-ce une abérration totale?
-Un BC547B peut-il gérer 6 Leds en série (Les fourches sont des LTH-301-07 Et ça fait donc du 12V, 20mA à gérer, si je dis pas de bêtises) ?
et comment calculer la valeur de la résistance à la base?
-Y'a t'il besoin d'autres chose? (des condensateurs pour filtrer par exemple?... )
-Les fourches doivent faire 1,2V/20mA, donc (12V-(6x1,2V))/0.02A=240Ω, j'ai bon?
-Tous mes phototransistors seraient alimentés par l'arduino en même temps, on est d'accores que ceux-cis consomment uniquement quand la diode est allumée?

Ah mince, ça fait beaucoup de questions en fait...

Merci pour toute aide!

Les datasheets au cas où:
https://www.mouser.fr/datasheet/2/23...07-1141226.pdf
https://www.farnell.com/datasheets/410427.pdf
https://www.arduino.cc/en/uploads/Ma...noManual23.pdf
-----

[carcan]

Hello !

l'idée est bonne, il faut voir à quelle vitesse tu veux "scanner" tes fourches.
Sinon pour les résistances de pull-up de 10k, il t'en faut 6 (pas 6*8).

A+
Laurent

[Janosch]

Ah, bonne nouvelle ça, merci beaucoup!




Pour ce qui est de la vitesse de Scan, je vois pas du tout comment calculer ça,
ni de quoi ça va dépendre (les Arduinos sont à 16Mhz, mais est-ce que ce sont-eux qui vont limiter la vitesse?).

Sinon, pour le BC547B c'est bon?

[jiherve]

bonjour
non pas comme çà, if faut un pull up par rangée de transistors occupant la même place dans des colonnes différentes.
8 colonnes et 6 rangées => 6 résistances.
En l’état il faut 14 I/0 mais en rajoutant un décodeur 1 parmi 8 (HC238) on peut tomber à 9 voire à 6 en utilisant un encodeur de priorité (LS148) mais cela dépend de l'usage.
La vitesse de scanning sera limité par la constante de temps présentée par le pull up et les capa parasites ainsi que le temps de réponse des fourches, à la louche 100µS par colonne, donc 1ms environ pour le tout, le µC sera toujours assez rapide (programmé en ASM) pour çà en charabiarduino je ne sais pas.
JR

[A voir en vidéo sur Futura]

[Janosch]

Comme je l'ai dis, j'ai des lacunes...
C'est mieux comme ça?



Pour ce qui est du nombre d'entrées, avec le nano c'est bon (22 entrées), au final j'en aurais besoin de 18.

[jiherve]

bonsoir,
oui donc yapuka!
JR

[Janosch]

Super! Merci encore!

J'ai commandé les pièces aujourd'hui, donc je monte mon prototype, et j'espère que tout marche.
Sinon vous risquez fort probablement de me recroiser...

Bonne soirée

[carcan]

Bon travail et à bientôt

[Janosch]

Hellooo!

Bon, j'ai fini mon protoype, et comme promis, je suis de retour

Je me heurte à un problème dont vous avez parlés : le timing!
En gros, vu que je dois scanner colonne par colonne, (celles attaquées par un transistor, schéma en #5), et donc allumer/éteindre rapidement,
je me retrouve avec 2.8V par colonne au lieu des 7.8V prévus.
Ca fait du 0.6V par diode, et ça m'arrange pas!
Je sens qu'en me creusant la tête je pourrais éventuellement contourner le problème en adaptant le code, mais j'aimerais bien avoir vos avis avant,
si vous le voulez bien.

Merci bien

[Qristoff]

Je pense que le transistor n'est pas suffisamment saturé. As-tu la référence des opto ? et combien il y a t-il d'optos par colonne ?

[Qristoff]

Désolé, j'avais pas vu que la référence était dans le 1er post.
Donc, c'est bien ce que je pensais. Le BC547 n'est pas suffisamment saturé. Si la tension de commande est 5V, il faut baisser la résistance de base à 2,2K pour avoir un courant de base de Ic/10 pour une bonne saturation. Sinon tu peux utiliser un petit mosfet style 2N7000, ça réduit le courant que doit sortir les sorties logiques.

[Janosch]

J'ai changé la résistance, mais le résultat est le même!


Au niveau du code, j'alumme une colonne, je scan ligne par ligne, j'éteins la colonne pour passer à la suivante.
En tout il y'aura 8 colonnes (et non pas 3 comme sur le schéma).
Avec une vitesse de scan de 1ms par exemple, le transistor est théoriquement alimenté à la base pendant 6ms (puisqu'il y'a 6 lignes),
mais apparemment ça ne lui suffit pas, j'ai toujours 2.8V entre U1 et U6...

[jiherve]

bonjour,
1 :comment tout ceci est il mesuré ?
2: lorsqu'une colonne est active il suffit de "lire" l'ensemble des lignes en un coup.
Donc on peut lire l'ensemble d'une colonne en 1ms et chaque transistor sera actif pendant ce temps, donc scan complet de la matrice en 8ms.
JR

[Qristoff]

Avant de se mettre à scanner, il faut déjà être sûr que les colonnes sont correctement alimentées !
Donc, tu alimentes une seule colonne et tu mesures les tensions en position statique et si tout est bon, on commence à scanner...

il suffit de "lire" l'ensemble des lignes en un coup

un coup d'horloge dans le registre 8 bits !

[jiherve]

re
ben oui si les lignes sont connectées à un port d'I/O unique alors il suffit d'une instruction (pas forcement un coup d'horloge) pour lire le tout, exemple ASM avec un AVR:
In r16,PINB.
C'est tout de même basique.
Si par contre les lignes sont reparties sur plusieurs ports (ce qui est inefficace) alors il faudra autant d'instructions que de ports concernés + du code pour concaténer tout çà.
JR

[Janosch]

1 :comment tout ceci est il mesuré ?

De quoi veux tu parler?
le timing est géré (et pas mesuré) par l'arduino, courant/tension par un multimètre de base (c'est peut-être ça le problème d'ailleurs?).

2: lorsqu'une colonne est active il suffit de "lire" l'ensemble des lignes en un coup.

Oui, évidemment, c'est beaucoup mieux.
Je vous poste mon code, c'est sûrement écrit un peu maladroitement, je fais ce que je peux ^^

#define NB_Colonnes    3
#define NB_Lignes      6
#define Latency        2 // temps d'allumage (en ms) entre chaque colonne

const int Colonne[NB_Colonnes] = {3, 4, 2}; //Pins utilisés
const int Ligne[NB_Lignes] = {5, 6, 7, 8, 9, 10}; //Pins utilisés
int keyState[NB_Colonnes][NB_Lignes] = {{}}; //Pour mémoriser l'état de chaque fourche 
int i = 0;
int j = 0;
unsigned long dly; 

void setup() 
{
  for(i=0; i<NB_Colonnes; i++) 
  {
    pinMode(Colonne[i], OUTPUT); // Les colonnes sont des sorties
    digitalWrite(Colonne[i], LOW); 
  }
  for(j=0; j<NB_Lignes; j++)
  {
    pinMode(Ligne[j], INPUT); // Les lignes sont des entrées
  }
  Serial.begin(9600);
}

void loop() 
{ 
  for(i=0; i<NB_Colonnes; i++) 
  {
    digitalWrite(Colonne[i], HIGH); // On allume une colonne de diodes

    dly = millis(); // (millis renvoie le nombre de ms écoulées depuis l'allumage de l'arduino)
    while(millis() - dly <= Latency)
    {
      for(j=0; j<NB_Lignes; j++) // On scanne ligne par ligne
      {
        if(digitalRead(Ligne[j]) ==  HIGH)
        {
          if(keyState[i][j] == 0) // Si fourche activée, et la fourche était éteint avant
          {
            // Ici on enverra le noteOn
            Serial.print(i);
            Serial.println(j);
            keyState[i][j] = 1; // Mémorise la fourche allumée
          }
        }
        else
        {
          if(keyState[i][j] == 1) // Si fouche désactivée, et la fourche était allumée avant
          {
            // Ici on enverra le noteOff
            Serial.print(i);
            Serial.println(j);
            keyState[i][j] = 0; // Mémorise la fourche éteinte
          }
        }    
      }
    }
  digitalWrite(Colonne[i], LOW); // On éteint la colonne
  }
}

Je me retrouve tout de même avec 0.6V par diode (selon mon multimètre toujours).
Et puis ce code à un défaut, je pense que c'est les rebonds, mais j'ai des noteOn/noteOff en boucle lorsque j'active (mécaniquement) les fourches, mais j'ai pas assez dormi pour y réfléchir maintenant.

[jiherve]

re
tu ne peux pas mesurer la tension au bornes des diodes car elle est, par construction, non continue au moyen d'un voltmètre lambda, il faut soit maintenir la commande ad vitam æternam soit utiliser un oscilloscope.
Pour le code c'est peut être ce qui peut se faire en charabiarduino , en ASM cela serait plus court mais passons!
JR

[Janosch]

J'adorerais maîtriser l'assembleur, mais bon, j'en suis pas là malheureusement.
Donc tu penses que le problème vient du code plutôt que du hard?

[jiherve]

Ajout,
la boucle While est inutile voir nefaste car suivant que Latency sera superieur ou inferieur au temps d'execution de la boucle for alors cela sera scanné plusieurs fois ou partiellement suivant la façon dont le compilo aura codé ce truc.
pour avoir un bon timing:
on active la colonne
on attends un peu( qqs centaines de µS)
on lit les lignes
on désactive la colonne
et on passe à la suivante
Pour verifier tes colonnes : débranche les resistances de base de l'arduino et connecte en une au 5V et là mesure
JR

[Janosch]

Je vois.
Mais il faut tout de même que je "time" tout ça, non?
C'est quoi la marche à suivre,
Allumer une colonne, scanner Ligne 1, delay, scanner Ligne 2, delay, Ligne 3... éteindre colonne, colonne suivante?
(delay non bloquant évidemment)

[Janosch]

Ah , merci pour l'edit

En position statique, pas de soucis, les fourches sont à 1.25V
C'est bizarre, des messages viennent d'apparaître (#14 et #15), ils m'ont échappés tout à l'heure.
Bon, je vais faire mes devoirs, je reviens

[jiherve]

Re
pour le timing ce qui compte c'est celui de la gestion des colonnes car les lignes seront activées ou non (suivant l’état des opto) toutes en même temps et il faudra que le temps de scanning complet soit << au temps d'appui moyen entre touche pour ne pas en rater, je ne connais pas la vitesse de frappe mais à la louche il faudra viser vers 10ms pour la totalité.
JR

[Janosch]

Yes, ça marche! à priori en tout cas.

J'ai un delay de 400µs entre chaque colonne, et ça marche!
ça fait donc un temps maximal de 0.4 x 8 = 3.2ms entre 2 touches, on est d'accords?
Et puis ce temps dépend de quelles touches consécutives sont activées aussi, on est d'accords pour ça aussi?

[jiherve]

Re
oui ce temps sera variable mais avec un balayage à 300Hz cela devrait aller.
JR

[Janosch]

Trop bien, merci beaucoup à vous 3!

J'ai une dernière question (enfin j'espère):
Que pensez-vous de ce projet, ça sent vraiment l'amateur à plein-nez, ou ça vous semble relativement fiable quand même, voire ça pourrait être commercialisé?
(j'ai un ami qui fabrique des mélodicas en bois et il m'avait déjà proposé une collaboration, on ne sait jamais...).
Ou est-ce que pour ça il faut que je travail directement en asm sur des puces, revoie mon circuit, etc...?

[antek]

ça peut faire un SHIELD pour Arduino
Pour vendre le produit prêt à l'emploi faudra réaliser une carte avec le µC.
Pour le langage il en faut un qui permette d'exploiter directement les ressources du µC.

[Janosch]

Tu pourrais développer le raisonnement?
En fait j'aimerais comprendre la raison, est pour des raisons de fiabilité, de durée de vie...?
Parce que là ça marche bien quand même.

[Janosch]

Personne d'autre pour me faire un retour sur mon projet?

Ca m'intéresserait vraiment de savoir ce que vous en pensez, si ça vous semble fiable, intéressant, ou si au contraire c'est tout pourri.
Qu'est ce qu'il y'a a améliorer, et surtout pourquoi?
merci

[antek]

Pour le vendre prêt à l'emploi il faut maîtriser le coût.
Tout rassembler sur une seule carte en virant les supperflus de l'arduino devrait couter moins cher.

[jiherve]

bonsoir
avant de lancer un produit il faut savoir s'il y a un marché !
de plus ici l’essentiel n'est pas dans l'électronique mais dans la modif du mélodica dont je suppute qu'elle n'est pas simple.
JR