Difference between revisions of "Projets:Perso:2011:TortueSimple:POC1"

From Electrolab
Jump to: navigation, search
(Created page with "Posage en vrac de stuff à réorganiser. 04 octobre 2012: commande mouser de stuff On part sur l'idée de briques. Les caractéristiques/expression du besoin sont les suivante...")
 
(Plans, schéma & code)
 
(3 intermediate revisions by one user not shown)
Line 1: Line 1:
Posage en vrac de stuff à réorganiser.
+
Description du proof of concept #1: interface de contrôle.
  
04 octobre 2012: commande mouser de stuff
+
= Orga =
 +
TODO:
 +
* clmnt: fabrication board commande + tests connectique brique
 +
* emptty: expédition proto brique à clmnt
 +
* clmnt: commande mouser de stuff (done)
 +
* emptty: fabrication proto brique (done ; tu postes le source kekpart ? pic or it didnt happen)
  
 +
= Principe =
 +
On rappelle l'objectif de ce sous système: fournir une interface conviviale pour la programmation de la tortue.
  
 
On part sur l'idée de briques. Les caractéristiques/expression du besoin sont les suivantes:
 
On part sur l'idée de briques. Les caractéristiques/expression du besoin sont les suivantes:
Line 11: Line 18:
 
Le principe d'identification des briques est d'intégrer une résistance de valeur donnée, que l'interface de contrôle va mesurer pour retrouver le type de la brique.
 
Le principe d'identification des briques est d'intégrer une résistance de valeur donnée, que l'interface de contrôle va mesurer pour retrouver le type de la brique.
  
On envisage plusieurs solutions techniques:
+
= Choix techniques =
*A: utilisation d'un seul microcontroleur (à définir ; typiquement un 'duino) avec front end constitué de multiplexeurs analogiques pour la mesure, et de registre à décalage pour piloter chacune des leds témoin d'activité
+
*B: utilisation de plusieurs microcontroleurs, chacun avec de quoi mesurer quelques emplacements + piloter leur éclairage ; mise en réseau de ces sous modules/pilotage par un module maitre
+
*C: utilisation de convertisseurs adc externes (type SPI) (+ éventuellement un I/O expander pour piloter les leds) => constitution de modules slave d'I/O, pilotés par un seul microcontroleur central.
+
  
Critiques:
+
== vitesse de rafraichissement des valeurs ==
*B: A priori, il n'y a pas besoin de patate pour le calcul pour un sous ensemble d'emplacements, et avoir à gérer plusieurs microcontroleurs semble overkill.
+
Pas déterminé a priori ; il faut que ce soit réactif, donc qu'un événement soit détecté en moins de 100ms environ.
* rien n'empeche dans l'approche A d'etre également modulaire (cad, de mettre les mux sur des petits modules indépendants et avoir une seule carte centrale de pilotage).
+
  
La bonne question à poser est donc plutot:
+
== Monolithique ou plusieurs boards ==
* est-ce qu'on fait une carte de controle "monolithique", cad tous les composants sont sur une seule et meme carte, de fait moins extensible, mais plus facile à monter/fabriquer, ou bien est-ce qu'on prévoit d'emblé une carte master, de controle, et un ensemble de cartes slaves interfacant chacune un sous ensemble d'emplacements.
+
Est-ce qu'on fait une carte de controle "monolithique", cad tous les composants sont sur une seule et meme carte, ou bien est-ce qu'on prévoit d'emblé une carte master, de controle, et un ensemble de cartes slaves interfacant chacune un sous ensemble d'emplacements ?
* est-ce qu'on utilise les channel d'adc du microcontroleur (et donc des mux analogiques), ou bien des adc externes connectés sur bus de donnée type SPI
+
  
 +
Une seule board est de fait moins extensible, mais plus facile à monter/fabriquer. Si tout fit, autant partir sur une seule board.
  
 +
== Un seul ou plusieurs microcontroleurs ==
 +
Est-ce qu'on utilise un seul microcontroleur, potentiellement avec front end ou périphériques externes, ou bien est-ce qu'on prévoit d'utiliser plusieurs uC (qui ne nécessitent pas de front end/périphériques externes) ?
  
Mail:
+
A priori, il n'y a pas besoin de patate pour le calcul pour un sous ensemble d'emplacements, et avoir à gérer plusieurs microcontroleurs semble overkill.
Ca reste un crobard... faut vérifier que ca tient/fait le job, mais
+
dans l'esprit... ya de ca.
+
  
On a donc 96 fois un pont diviseur avec R1 (fixe, dans le support) et
+
== ADC interne/externe ==
R2 (variable selon la brique pluggée).
+
Est-ce qu'on utilise les channel d'adc du microcontroleur (et donc des mux analogiques), ou bien des adc externes connectés sur bus de donnée type SPI ?
6 mux analogiques 16 vers 1 permettent de mesurer la tension de ces 96
+
ponts diviseurs.
+
Ils sont commandés par des signaux ABCD (aiguillage : si ABCD = 0000
+
sortie connectée à entrée0, ABCD = 0001, sortie connectée à entrée 1
+
,etc)
+
La sortie de chaque mux va vers une entrée adc du microcontroleur.
+
Les signaux de controle des mux sont tous reliés ensemble. Genre, pour
+
ABCD = 0000, sur l'entrée adc0 du micro, tu vas scanner l'entrée 0 du
+
mux1 (donc slot01), sur l'entrée adc1 du micro tu scannes l'entrée 0
+
du mux2 (donc slot 17), etc.
+
  
Faut voir ensuite si tu sais balayer le tout assez vite (en théorie,
+
A priori, on peut s'en sortir avec un bête front end constitué de multiplexeurs analogiques pour la mesure.
oui: l'adc d'un pti micro pourrave sait taper des valeurs à genre
+
A noter qu'on peut de même piloter chacune des leds témoin d'activité (on pourrait utiliser des I/O expanders I2C/SPI).
plusieurs dizaines de kHz, et il te faut grosso modo 100Hz de
+
rafraichissement pour que ca semble instantané. Mais un micro un peu
+
moins pourrave sait sortir 1MHz. Voir par exemple le nouveau devkit
+
texas instrument avec un joujou sympa ; ca coute 5$ livré chez toi
+
(prix promo). Conseil: commande en deux (limité à ca) et réfléchis
+
plus tard
+
http://www.ti.com/ww/en/launchpad_site/stellaris.html
+
  
Ya ptet des manières plus intelligentes de faire (eg, au lieu de
+
= Description =
prendre plein de mux, prendre un ou plusieurs microcontrolleurs qui
+
On va réaliser 3 protos:
ont assez d'entrées analog directement, ou bien prendre des adc
+
* une brique, contenant une résistance, et adaptée au type de connection sélectionné
externes qui s'interfacent sur un bus série type SPI toussa). Note:
+
* un premier pcb pour la partie détection des briques ; on reste au possible mcu agnostic, au sens, pas de mcu intégré sur cette board.
dans un microcontroleur classique, en interne, il y a un mux
+
* un second pcb qui permet de vérifier la bonne connection (mécanique/électrique) des briques sur la carte de commande.
analogique et un seul module qui sait réellement faire la
+
mesure/conversion. Avoir deux étages de mux est donc un poil
+
fastidieux, maiiis bon si ca fait la job, on s'en tape.
+
  
'fin bon, dans l'esprit, voilà, c'est une propal.
+
== Proto de brique ==
 +
TODO emptty
  
 +
== Front end analogique ==
 +
On va utiliser un pont diviseur par emplacement de mesure, avec une résistance fixe (toujours de la même valeur) à chaque emplacement, et dans chaque brique pouvant être connectée, la seconde résistance, qui complète le pont diviseur.
  
 +
On a besoin de 96 emplacements de mesure, cela peut être réalisé à l'aide de 6 mux analogiques 16 vers 1. Chacun est commandé par 4 signaux de commande (ABCD), et reliant, selon la valeur de ABCD, la sortie X à l'une de ses 16 entrées. A noter qu'une résistance parasite est ajoutée. Ils fonctionnent comme un aiguillage, c'est à dire que si ABCD = 0000, la sortie X est reliée à l'entrée 1 (par une résistance d'environ XXX ohm). Si ABCD = 0001, la sortie X est reliée à l'entrée 2, et ainsi de suite.
 +
Référence typique de ce genre de composants: XXX
  
 +
La sortie de chacun de ces six composants va vers une entrée adc du microcontroleur. On observe qu'il est possible de piloter simultanément tous les mux avec les mêmes signaux de controle.
 +
Ainsi, pour ABCD = 0000, on a:
 +
* le mux 1 relie le slot 01 à sa sortie, elle même reliée à l'entrée adc0 du mcu
 +
* le mux 2 relie le slot 17 à sa sortie, elle même reliée à l'entrée adc1 du mcu
 +
et ainsi de suite. Pour ABCD = 0001, on a:
 +
* le mux 1 relie le slot 02 à sa sortie, elle même reliée à l'entrée adc0 du mcu
 +
* le mux 2 relie le slot 18 à sa sortie, elle même reliée à l'entrée adc1 du mcu
 +
et ainsi de suite.
  
Bon sinon ensuite pour creuser le design tel que proposé, le jeu est
+
Ainsi, pour scanner les 96 emplacements, on doit balayer toutes les valeurs de ABCD = 0000 à ABCD = 1111 (16 valeurs possibles), et à chaque fois, mesurer les 6 entrées analogiques.
de fixer la valeur de R1, et les 80 valeurs possibles de R2 pour que
+
Puisqu'on veut pouvoir rafraichir tous les emplacements en moins de 100ms au total, il faut être capable de faire une mesure analogique en un peu moins d'une milliseconde ; c'est largement à la portée d'un mcu standard.
avec ta résolution d'adc tu arrives à discriminer tous les cas.
+
Si R2 absente, la tension Uslot est à 5v (R1 est dite pull up). Sinon,
+
la tension est:
+
Uslot = 5v * R2/(R1+R2) = 5v * ratio
+
  
Ensuite, tu as un ADC sur 8 bits (voire 10 bits, voire mieux si tu as
+
== Résistances des briques ==
un micro pas trop mal, ou un adc externe). Le but du jeu est donc de
+
Il est nécessaire de pouvoir distinguer 80 types de briques différentes, et donc sélectionner intelligemment 80 valeurs différentes de résistance que l'on pourra identifier par le pont diviseur de tension & l'adc interne du microcontroleur.
répartir les Uslot équitablement sur ta dynamique de mesure ; pour
+
On doit également pouvoir détecter lorsqu'aucune brique n'est branchée.
cela, en général si tu as des résistances entre 1000k et 0.1k, tu
+
prends R2 au milieu en log (eg  10k). Ensuite, si tu as envie d'avoir
+
6 valeurs, tu as donc:
+
* 1000k => ratio proche de 1,
+
* 100k => ratio très sup à 0.5,
+
* 10k => ratio à 0.5,
+
* 1k => ratio très inf à 0.5,
+
*  0.1k => ratio proche de 0,
+
*  null => ratio = 1
+
Bon... là, c'est fait à l'arrache toussa, mais avec un pti
+
tableur/script, tu peux pondre les valeurs kivonbien pour avoir ta
+
répartition des différentes Uslot que t'as envie.
+
  
Braiffe, on en recause. Tfacon faut après mettre en face des combien
+
Partons du principe que la tension d'alimentation est 5v, et que l'adc dispose de 10bits.
ca coute, qu'est ce qu'on veut faire des datas, quelle
+
 
performances/vitesse on a besoin, etc etc etc blablabla.
+
On souhaite donc que le ratio de pont diviseur évolue équitablement de 0 à 1, en 80 steps. Disons de 0.5/80 à 79.5/80.
 +
On va utiliser des résistances environ entre 0.1k ohm et 1000 kohm ; la logique veut que l'on choisisse la résistance fixe à la moyenne (log) de ces deux extrêmes, soit 10kohm.
 +
Ensuite, un tableur permet de trouver les valeurs "idéales" de résistance pour obtenir les ratios successifs, produisant des tensions facilement discriminables en sortie de pont.
 +
L'étape suivante consiste à sélectionner, en lieu et place de ces valeurs "idéales", des valeurs de résistance existant réellement. On constate qu'il est nécessaire de piocher dans la série E96 (valeurs normalisées, résistances précises à 1%) pour se rapprocher suffisamment de l'objectif.
 +
 
 +
Les valeurs de résistance sont les suivantes (en kohm):
 +
0,063 || 0,191 || 0,324 || 0,453 || 0,590 || 0,750 || 0,887 || 1,050 || 1,180 || 1,350
 +
1,520 || 1,690 || 1,870 || 2,050 || 2,210 || 2,430 || 2,550 || 2,800 || 3,010 || 3,240
 +
3,480 || 3,650 || 3,920 || 4,220 || 4,420 || 4,750 || 4,990 || 5,230 || 5,620 || 5,900
 +
6,190 || 6,490 || 6,810 || 7,150 || 7,680 || 8,060 || 8,450 || 8,870 || 9,310 || 9,760
 +
10,20 || 10,70 || 11,30 || 12,10 || 12,40 || 13,00 || 13,70 || 14,70 || 15,40 || 16,50
 +
17,40 || 18,20 || 19,10 || 20,50 || 21,50 || 22,60 || 24,30 || 25,50 || 27,40 || 29,40
 +
30,90 || 33,20 || 35,70 || 38,30 || 41,20 || 45,30 || 48,70 || 53,60 || 59,00 || 66,50
 +
75,00 || 84,50 || 97,60 || 113,0 || 133,0 || 169,0 || 215,0 || 309,0 || 523,0 || 1580
 +
 
 +
Avec une résistance de 10kohm, un adc 10bits (parfait) et une alimentation 5v (parfaite), on obtient les valeurs brutes suivantes:
 +
6  ||  19 ||  32 ||  44 ||  57 ||  71 ||  83 ||  97 || 108 || 122
 +
135 || 148 || 161 || 174 || 185 || 200 || 208 || 224 || 237 || 250
 +
264 || 274 || 288 || 304 || 314 || 329 || 341 || 351 || 368 || 380
 +
391 || 403 || 414 || 426 || 444 || 457 || 469 || 481 || 493 || 505
 +
517 || 529 || 543 || 560 || 566 || 578 || 591 || 609 || 620 || 637
 +
650 || 660 || 671 || 688 || 698 || 709 || 725 || 735 || 749 || 763
 +
773 || 786 || 799 || 811 || 823 || 838 || 849 || 862 || 875 || 889
 +
903 || 915 || 928 || 940 || 951 || 966 || 978 || 991 || 1004 || 1017
 +
 
 +
On peut également évaluer l'influence de la tolérance (1%) des résistances choisies, pour vérifier qu'on saura toujours discriminer chacune des 8 valeurs (plus lorsqu'aucune brique n'est connectée).
 +
Je vous passe le tableau issu du tableur, mais dans le pire des cas, on a une distance de 6 (valeur binaire/brute issue de l'adc), or la majeure partie des adc intégrés aux mcu ont une précision de +/- 1LSB. Yabon.
 +
 
 +
== Pilotage de leds ==
 +
Histoire de ne pas se prendre la tête, on pose une chaine de registres à décalages tout simples (74HC595 ou 75HC675). On pourrait utiliser des drivers de led dédiés (type TLC5940), mais a priori, ils coutent inutilement cher, même s'ils permettent de piloter des leds plus lumineuses, et de faire varier leur intensité facilement.
 +
 
 +
== Connection des briques ==
 +
On cherche la solution la moins onéreuse pour réaliser les supports de brique sur chacun des 96 emplacments. Après moultes recherches & débats, on s'oriente vers des contacts de pile (eg, mouser ref XXX).
 +
Reste à tester sur un bout de pcb si le prototype de brique se plug bien, si le contact électrique se fait correctement, etc.
 +
 
 +
= Liste matos =
 +
Cf [[Projets:Commande_groupee:Mouser20121004|commande mouser]] correspondante.
 +
A noter que pour l'instant, on reste mcu agnostic: seule la partie périphériques nous intéresse dans ce premier prototype.
 +
Comme les plus agguerris l'auront reconnu, prévoir 6 entrées ADC a le bon gout d'être arduino-friendly...
 +
 
 +
= Plans, schéma & code =
 +
 
 +
== Brique ==
 +
TODO emptty (source openscad, pics, comments pour refabriquer)
 +
 
 +
== pcb1: mesure des slots ==
 +
TODO clmnt
 +
 
 +
== pcb2: connection d'une brique ==
 +
TODO clmnt
 +
Nécessite d'avoir une brique sous la main, ainsi que les teuteus de connectique pour pile
 +
 
 +
= Fabrication =
 +
TODO
 +
 
 +
= Tests =
 +
TODO

Latest revision as of 01:13, 9 October 2012

Description du proof of concept #1: interface de contrôle.

Orga

TODO:

  • clmnt: fabrication board commande + tests connectique brique
  • emptty: expédition proto brique à clmnt
  • clmnt: commande mouser de stuff (done)
  • emptty: fabrication proto brique (done ; tu postes le source kekpart ? pic or it didnt happen)

Principe

On rappelle l'objectif de ce sous système: fournir une interface conviviale pour la programmation de la tortue.

On part sur l'idée de briques. Les caractéristiques/expression du besoin sont les suivantes:

  • 96 emplacements
  • 80 types de briques
  • possibilité d'allumer une led (monochrome) par emplacement lorsqu'il est actif

Le principe d'identification des briques est d'intégrer une résistance de valeur donnée, que l'interface de contrôle va mesurer pour retrouver le type de la brique.

Choix techniques

vitesse de rafraichissement des valeurs

Pas déterminé a priori ; il faut que ce soit réactif, donc qu'un événement soit détecté en moins de 100ms environ.

Monolithique ou plusieurs boards

Est-ce qu'on fait une carte de controle "monolithique", cad tous les composants sont sur une seule et meme carte, ou bien est-ce qu'on prévoit d'emblé une carte master, de controle, et un ensemble de cartes slaves interfacant chacune un sous ensemble d'emplacements ?

Une seule board est de fait moins extensible, mais plus facile à monter/fabriquer. Si tout fit, autant partir sur une seule board.

Un seul ou plusieurs microcontroleurs

Est-ce qu'on utilise un seul microcontroleur, potentiellement avec front end ou périphériques externes, ou bien est-ce qu'on prévoit d'utiliser plusieurs uC (qui ne nécessitent pas de front end/périphériques externes) ?

A priori, il n'y a pas besoin de patate pour le calcul pour un sous ensemble d'emplacements, et avoir à gérer plusieurs microcontroleurs semble overkill.

ADC interne/externe

Est-ce qu'on utilise les channel d'adc du microcontroleur (et donc des mux analogiques), ou bien des adc externes connectés sur bus de donnée type SPI ?

A priori, on peut s'en sortir avec un bête front end constitué de multiplexeurs analogiques pour la mesure. A noter qu'on peut de même piloter chacune des leds témoin d'activité (on pourrait utiliser des I/O expanders I2C/SPI).

Description

On va réaliser 3 protos:

  • une brique, contenant une résistance, et adaptée au type de connection sélectionné
  • un premier pcb pour la partie détection des briques ; on reste au possible mcu agnostic, au sens, pas de mcu intégré sur cette board.
  • un second pcb qui permet de vérifier la bonne connection (mécanique/électrique) des briques sur la carte de commande.

Proto de brique

TODO emptty

Front end analogique

On va utiliser un pont diviseur par emplacement de mesure, avec une résistance fixe (toujours de la même valeur) à chaque emplacement, et dans chaque brique pouvant être connectée, la seconde résistance, qui complète le pont diviseur.

On a besoin de 96 emplacements de mesure, cela peut être réalisé à l'aide de 6 mux analogiques 16 vers 1. Chacun est commandé par 4 signaux de commande (ABCD), et reliant, selon la valeur de ABCD, la sortie X à l'une de ses 16 entrées. A noter qu'une résistance parasite est ajoutée. Ils fonctionnent comme un aiguillage, c'est à dire que si ABCD = 0000, la sortie X est reliée à l'entrée 1 (par une résistance d'environ XXX ohm). Si ABCD = 0001, la sortie X est reliée à l'entrée 2, et ainsi de suite. Référence typique de ce genre de composants: XXX

La sortie de chacun de ces six composants va vers une entrée adc du microcontroleur. On observe qu'il est possible de piloter simultanément tous les mux avec les mêmes signaux de controle. Ainsi, pour ABCD = 0000, on a:

  • le mux 1 relie le slot 01 à sa sortie, elle même reliée à l'entrée adc0 du mcu
  • le mux 2 relie le slot 17 à sa sortie, elle même reliée à l'entrée adc1 du mcu

et ainsi de suite. Pour ABCD = 0001, on a:

  • le mux 1 relie le slot 02 à sa sortie, elle même reliée à l'entrée adc0 du mcu
  • le mux 2 relie le slot 18 à sa sortie, elle même reliée à l'entrée adc1 du mcu

et ainsi de suite.

Ainsi, pour scanner les 96 emplacements, on doit balayer toutes les valeurs de ABCD = 0000 à ABCD = 1111 (16 valeurs possibles), et à chaque fois, mesurer les 6 entrées analogiques. Puisqu'on veut pouvoir rafraichir tous les emplacements en moins de 100ms au total, il faut être capable de faire une mesure analogique en un peu moins d'une milliseconde ; c'est largement à la portée d'un mcu standard.

Résistances des briques

Il est nécessaire de pouvoir distinguer 80 types de briques différentes, et donc sélectionner intelligemment 80 valeurs différentes de résistance que l'on pourra identifier par le pont diviseur de tension & l'adc interne du microcontroleur. On doit également pouvoir détecter lorsqu'aucune brique n'est branchée.

Partons du principe que la tension d'alimentation est 5v, et que l'adc dispose de 10bits.

On souhaite donc que le ratio de pont diviseur évolue équitablement de 0 à 1, en 80 steps. Disons de 0.5/80 à 79.5/80. On va utiliser des résistances environ entre 0.1k ohm et 1000 kohm ; la logique veut que l'on choisisse la résistance fixe à la moyenne (log) de ces deux extrêmes, soit 10kohm. Ensuite, un tableur permet de trouver les valeurs "idéales" de résistance pour obtenir les ratios successifs, produisant des tensions facilement discriminables en sortie de pont. L'étape suivante consiste à sélectionner, en lieu et place de ces valeurs "idéales", des valeurs de résistance existant réellement. On constate qu'il est nécessaire de piocher dans la série E96 (valeurs normalisées, résistances précises à 1%) pour se rapprocher suffisamment de l'objectif.

Les valeurs de résistance sont les suivantes (en kohm): 0,063 || 0,191 || 0,324 || 0,453 || 0,590 || 0,750 || 0,887 || 1,050 || 1,180 || 1,350 1,520 || 1,690 || 1,870 || 2,050 || 2,210 || 2,430 || 2,550 || 2,800 || 3,010 || 3,240 3,480 || 3,650 || 3,920 || 4,220 || 4,420 || 4,750 || 4,990 || 5,230 || 5,620 || 5,900 6,190 || 6,490 || 6,810 || 7,150 || 7,680 || 8,060 || 8,450 || 8,870 || 9,310 || 9,760 10,20 || 10,70 || 11,30 || 12,10 || 12,40 || 13,00 || 13,70 || 14,70 || 15,40 || 16,50 17,40 || 18,20 || 19,10 || 20,50 || 21,50 || 22,60 || 24,30 || 25,50 || 27,40 || 29,40 30,90 || 33,20 || 35,70 || 38,30 || 41,20 || 45,30 || 48,70 || 53,60 || 59,00 || 66,50 75,00 || 84,50 || 97,60 || 113,0 || 133,0 || 169,0 || 215,0 || 309,0 || 523,0 || 1580

Avec une résistance de 10kohm, un adc 10bits (parfait) et une alimentation 5v (parfaite), on obtient les valeurs brutes suivantes: 6 || 19 || 32 || 44 || 57 || 71 || 83 || 97 || 108 || 122 135 || 148 || 161 || 174 || 185 || 200 || 208 || 224 || 237 || 250 264 || 274 || 288 || 304 || 314 || 329 || 341 || 351 || 368 || 380 391 || 403 || 414 || 426 || 444 || 457 || 469 || 481 || 493 || 505 517 || 529 || 543 || 560 || 566 || 578 || 591 || 609 || 620 || 637 650 || 660 || 671 || 688 || 698 || 709 || 725 || 735 || 749 || 763 773 || 786 || 799 || 811 || 823 || 838 || 849 || 862 || 875 || 889 903 || 915 || 928 || 940 || 951 || 966 || 978 || 991 || 1004 || 1017

On peut également évaluer l'influence de la tolérance (1%) des résistances choisies, pour vérifier qu'on saura toujours discriminer chacune des 8 valeurs (plus lorsqu'aucune brique n'est connectée). Je vous passe le tableau issu du tableur, mais dans le pire des cas, on a une distance de 6 (valeur binaire/brute issue de l'adc), or la majeure partie des adc intégrés aux mcu ont une précision de +/- 1LSB. Yabon.

Pilotage de leds

Histoire de ne pas se prendre la tête, on pose une chaine de registres à décalages tout simples (74HC595 ou 75HC675). On pourrait utiliser des drivers de led dédiés (type TLC5940), mais a priori, ils coutent inutilement cher, même s'ils permettent de piloter des leds plus lumineuses, et de faire varier leur intensité facilement.

Connection des briques

On cherche la solution la moins onéreuse pour réaliser les supports de brique sur chacun des 96 emplacments. Après moultes recherches & débats, on s'oriente vers des contacts de pile (eg, mouser ref XXX). Reste à tester sur un bout de pcb si le prototype de brique se plug bien, si le contact électrique se fait correctement, etc.

Liste matos

Cf commande mouser correspondante. A noter que pour l'instant, on reste mcu agnostic: seule la partie périphériques nous intéresse dans ce premier prototype. Comme les plus agguerris l'auront reconnu, prévoir 6 entrées ADC a le bon gout d'être arduino-friendly...

Plans, schéma & code

Brique

TODO emptty (source openscad, pics, comments pour refabriquer)

pcb1: mesure des slots

TODO clmnt

pcb2: connection d'une brique

TODO clmnt Nécessite d'avoir une brique sous la main, ainsi que les teuteus de connectique pour pile

Fabrication

TODO

Tests

TODO