Projets:Perso:2011:TortueSimple:POC1

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.