Projets:Perso:2011:TortueSimple:POC1 - Revision history

Clément: /* Plans, schéma & code */

2012-10-08T23:13:15Z

‎Plans, schéma & code

Clément: /* Description */

2012-10-08T23:11:38Z

‎Description

Clément: /* Orga */

2012-10-08T23:07:27Z

‎Orga

Clément: remise en forme

2012-10-08T23:01:54Z

remise en forme

Show changes

Clément: 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..."

2012-10-04T21:25:57Z

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..."

New page

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 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.

On envisage plusieurs solutions 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:
*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.
* 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:
* 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 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

Mail:
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
R2 (variable selon la brique pluggée).
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,
oui: l'adc d'un pti micro pourrave sait taper des valeurs à genre
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
prendre plein de mux, prendre un ou plusieurs microcontrolleurs qui
ont assez d'entrées analog directement, ou bien prendre des adc
externes qui s'interfacent sur un bus série type SPI toussa). Note:
dans un microcontroleur classique, en interne, il y a un mux
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.

Bon sinon ensuite pour creuser le design tel que proposé, le jeu est
de fixer la valeur de R1, et les 80 valeurs possibles de R2 pour que
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
un micro pas trop mal, ou un adc externe). Le but du jeu est donc de
répartir les Uslot équitablement sur ta dynamique de mesure ; pour
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
ca coute, qu'est ce qu'on veut faire des datas, quelle
performances/vitesse on a besoin, etc etc etc blablabla.

@@ Line 113: / Line 113: @@
 = Plans, schéma & code =
 TODO
 = Fabrication =

@@ Line 40: / Line 40: @@
 = Description =
-== Front end analogique ==
+== Proto de brique ==
-=== mode de mesure ===
+== 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

@@ Line 3: / Line 3: @@
 = Orga =
 TODO:
-* Emptty: fabrication brique
+* clmnt: fabrication board commande + tests connectique brique
-* Clmnt: fabrication board
+* emptty: expédition proto brique à clmnt
+* clmnt: commande mouser de stuff (done)
-* 04 octobre 2012: commande mouser de stuff
+* emptty: fabrication proto brique (done ; tu postes le source kekpart ? pic or it didnt happen)
 = Principe =