[Construction] Le monde des microcontrôleurs

[jpparisy]

Étant donné la simplicité des circuits, le cablage est aussi très simple.

Une première solution est de souder directement les différents cables en l'air sur un support de circuit intégré (CI) à huit broches. Il faut utiliser, de préférence, un support de type "tulipe", ayant de meilleurs contacts.

Une autre solution, un peu plus sophistiquée et permettant de faire de nombreux essais sans avoir à souder à chaque fois, est de monter le support de CI sur une plaquette d'essai à bande cuivrée comme celle ci :



puis monter de chaque côté du support deux rangées de picots de barrette mâle sécable de type HE14 :



enfin, souder un cable de servo : le plus (fil rouge) sur la broche 1, le moins (fil noir) sur la broche 8 et le signal (fil blanc ou jaune) sur la broche 4.

La réalisation finale ressemble à ceci :



Les connexions aux dispositifs se feront avec des cables de servos.

Le cablage des BS170 peut aussi se faire sur ce genre de plaquette avec des picots reliés aux broches.

[jpparisy]

À utiliser sur un manche proportionnel avec retour au centre.

Le chenillard est un des programmes servant à l'appentissage de la programmation des MCU.
Il allume des LEDs les unes après les autres en cycle continu.

Le programme que je propose fait varier la vitesse de clignotement en fonction de la position d'un manche proportionnel. Au neutre, le clignotement est lent, quand le manche est poussé dans un sens ou dans l'autre, le clignotement s'accélère.

Je sais, c'est bête et ça ne sert pas à grand chose, mais ça m'amuse toujours.

Le schéma est le même que les précédents, seul le programme change.



Télécharger les fichiers source et hex.

[jpparisy]

À utiliser sur un manche proportionnel avec retour au centre.

Au départ, tous les canaux sont à 0 V.

Lorsque le manche est poussé à fond dans un sens, la sortie 1 passe à 5 V, lorsque le manche revient au neutre, la sortie 1 repasse à 0 V.

Lorsque le manche est poussé à fond dans le sens opposé, c'est la sortie 4 qui passe à 5 V.

Les sorties 2 et 3 sont activées quand le manche est positionné à mi-course dans un sens ou dans l'autre.

Le schéma électronique :



L'entrée "Signal" est à brancher sur une voie commandée par un manche avec retour au centre.

La broche "Config" définit le fonctionnement des sorties 2 et 3.

• Lorsqu'elle est reliée au 5 V, chaque sortie agit comme une bascule et conserve sa valeur après le retour au neutre, pour changer la valeur, il faut positionner le manche une deuxième fois à mi-course dans le même sens.
• Lorsqu'elle est reliée au 0 V, chaque sortie repasse à zéro lorsque le manche revient au centre.

Télécharger les fichiers source et hex.

[minimaxi]

Merci, des petits montages faciles à réaliser et sympa à voir fonctionner, voilà qui me va bien.

[Bud.fr]

Salut à Tous, salut JPparisy

Tu vas nous faire une suite ???

Par exemple, comment brancher des périphériques autour.

Je sais que pour une Led (normale de base), il faut rajouter en série une résistance de 470 Ohms, ou bien une de 330 Ohms pour plus de luminosité ...

Mais pour un relais, qu'est qu'on met autour ???
Pareil pour ces fameux MOSFET, ou pour un transistor de base, comment définir les valeurs ????

Pas d'urgence

A+

[jpparisy]

La suite va venir, ll faut juste que je rédige le texte.

Mais, déjà deux choses : je ne parlerai pas des transistors classiques comme interface avec le MCU car ils ont besoin d'un courant traversant la base et nécessitent des résistances pour régler le gain, les MOSFET, n'ont besoin que d'une tension de commande et ne nécessitent aucun composant supplémentaire.

Je ne parlerai pas non plus des relais car nous ne travaillons qu'avec du courant continu et, là encore, les MOSFET les remplacent avantageusement, avec une gamme d'intensité commandée plus étendue et un coût bien plus bas.

[jpparisy]

Je pensais ne pas avoir besoin d'en parler, mais vous êtes plusieurs à me demander mon avis.

Donc, à mon avis à moi que j'ai , il vaut mieux utiliser un programmateur ICSP, qui permet de programmer le MCU sans le démonter et, de préférence, compatible avec MPLAB IDE.

Celui que je préfère est le Microchip PicKit2, sans accessoire. Il est plus cher que d'autres, mais je suis sûr que le produit sera suivi !

Avec le soft fourni, il peut aussi servir d'analyseur logique à trois voies, pour vérifier l'état des signaux.

Il est disponible chez Microchip, bien sûr, mais aussi chez Radio-Spares. Avec le port gratuit le week end, il coûte 30.32 EUR.

Il en existe une copie, fabriquée par Cytron et disponible ici, légérement moins cher que l'original : 25.97 EUR, port compris. C'est très bien fait : MPLAB IDE ne voit aucune différence.

Si on cherche un peu sur Ebay (chercher "pickit2"), on trouve un clone chinois au prix imbattable de $18.82, port compris. Chez le même vendeur, on trouve ce programmateur et une plaque avec trois supports ZIF, permattant de programmer le MCU hors circuit, pour le prix de $28.31, port compris. Je ne sais pas du tout ce que valent ces produits.

Pour programmer le MCU hors circuit, il est tout à fait possible de fabriquer soi même la plaquette, on trouve, toujours sur Ebay, des supports ZIF (chercher "ZIF socket") pour moins de $2.00, port compris.

Voir ce site (en anglais) qui propose une réalisation. Les deux photos ci dessous en sont extraites.



C'est simple et de bon goût, avec un support ZIF, ce serait le grand luxe !

[jpparisy]

Un microcontrôleur (MCU) a besoin d'être programmé pour fonctionner correctement. Il existe plusieurs langages de programmation, je vais utiliser le langage C pour les différents exemples car ce langage est (relativement ) compréhensible et utilisable sur pratiquement tous les MCU existants.

Je n'ai pas l'intention de donner un cours de programmation, il existe de très bons tutoriels pour ça sur le web. Je donnerai plutôt des bouts de code, un peu comme des briques à assembler, avec quelques explications.

Mais avant d'entrer dans le sujet de la programmation immédiatement, il faut parler plus en détail du MCU.

Un MCU est un micro ordinateur, complet et autonome. Il est composé d'une unité de calcul (CPU), de différentes mémoires (flash pour ranger le code du programme, SRAM pour ranger les données, quelque fois EEPROM pour conserver les données même lorsque le MCU est mis hors tension), de ports d'entrées et de sorties et de registres internes permettant de configurer son fonctionnement.

L'essentiel de la programmation consiste donc à lire ou écrire des registres.

Je vais décrire plus particuliérement l'utilisation du PIC12F509 de Microchip, qui est un composant très courant et d'un prix abordable. Il a une capacité de 1024 mots de programme, 41 octets de mémoire de données, un port en entrée seulement et 5 ports pouvant être utilisés indépendamment en entrée ou en sortie. Il possède un oscillateur interne de 4 Mhz d'une précision de 1 % et ne nécessite donc pas de quartz pour fonctionner. Tout ce dont il a besoin pour être opérationnel est une source d'alimentation comprise entre 2 V et 5.5V. Sa vitesse d'exécution est de 1 Mips (million d'instructions par secondes).

[jpparisy]

Il y a neuf registres, mais nous n'utiliserons que quatre d'entre eux, les autres étant gérés par le compilateur. Il y a aussi un mot de 12 bits de configuration, appelé "fusibles", valorisé à la compilation.

1. Le registre OPTION est accessible en écriture. Les bits de ce registre qui nous intéressent sont les suivants :
   
   
   • bit 5 T0CS : source du signal pour TMR0,
   • bit 4 T0SE : type de déclenchement pour TMR0,
   • bit 3 PSA : assignation du diviseur pour TMR0,
   • bit 2-0 PS<2:0> : valeur du diviseur, utilisé par TMR0. Les valeurs de division sont les suivantes :
     

     0x0 =	1:2
     0x1 =	1:4
     0x2 =	1:8
     0x3 =	1:16
     0x4 =	1:32
     0x5 =	1:64
     0x6 =	1:128
     0x7 =	1:256

   Exemple :
   

       OPTION = ~T0CS & ~PSA & (T0SE | 0x2);

2. Le registre TMR0 est accessible en lecture et écriture. C'est un compteur perpétuel, lorsqu'il a atteint la valeur 255, il repasse à zéro la fois suivante. La fréquence de comptage dépend de la valeur du diviseur du registre OPTION, si le diviseur n'est pas utilisé, TMR0 va ajouter 1 toutes les microsecondes (noté usec dans le code), si la valeur du diviseur est 0x0, TMR0 va ajouter 1 toutes les 2 µs, etc.
   
   
3. Le registre TRIS est accessible en écriture. Les six derniers bits indiquent la direction des ports, un bit à 0 indique que le port correspondant est en sortie, un bit à 1 indique que le port correspondant est en entrée.
   
   
   
   
4. Le registre GPIO est accessible en lecture et écriture. En fonction de la valeur du registre TRIS, il permet de lire ou d'écrire les ports. Il peut être accédé d'une manière globale ou pour chaque port individuellement.
   
   Les ports correspondent aux six derniers bits du registre, quand un bit est à 1, le port correspondant prend la valeur de la tension d'alimentation, quand le bit est à 0, le port prend la valeur 0 V.
   
   
   
   Il faut noter que le port GP3 est accessible uniquement en lecture et n'est donc pas concerné par les valeurs écrites dans ce registre.
   
   Le nom des ports individuels est :
   
   • GP0 (broche 7).
   • GP1 (broche 6).
   • GP2 (broche 5).
   • GP3 (broche 4).
   • GP4 (broche 3).
   • GP5 (broche 2).
   
   Une valeur 1 correspond à la tension d'alimentation sur la broche, une valeur 0 correspond à 0 V sur la broche.

Exemple :

    TRIS = 0b101000; // configurer GP3 et GP5 en entree, tous les autres en sortie
    GPIO = 0; // tous les ports en sortie a 0 V
    GPIO = 0b000011;  // GP0 et GP1 a 5 V, tous les autres a 0 V
    GP1 = 1; // GP1 a 5V

Note : je laisserai les commentaires en anglais la prochaine fois : ce sera plus lisible que du français sans les lettres accentuées !

[jpparisy]

C'est l'exemple le plus simple, à brancher sur une voie proportionnelle :

• manche au centre, tout est éteint,
• manche en haut, un port est allumé,
• manche en bas, un autre port est allumé.

Pour faire cela, nous avons besoin de mesurer le temps du signal de la voie en sortie du récepteur.

Lorsque le manche est au centre (neutre), le signal dure 1500 µs, en haut, il dure 2000 µs, en bas, il dure 1000 µs.

Le signal est répété toutes les 20000 ou 22500 µs, suivant l'émetteur.

Pour mesurer le temps, nous avons le registre TMR0. Dans cet exemple, nous allons le diviser par 8 (8 µs par impulsion de comptage), ce qui nous permet de mesurer un temps variant de 0 à 255 * 8 = 2040 µs.

Voici donc le début du programme :

#include <htc.h>
#include <pic.h>
#include <pic12f509.h>

// set fuse bits
 __CONFIG(MCLRE_OFF & CP_OFF & WDT_OFF & OSC_IntRC);

unsigned char cnt;

main (void)
{
    OPTION = ~T0CS & ~PSA & (nGPWU | nGPPU | T0SE | 0x2);

Je n'explique pas les valeurs dans les bits de configuration, ils sont à prendre tels quels.

La ligne "unsigned char cnt;" déclare une variable numérique non signée d'une longueur de huit bits et non une variable de type caractère (ça n'existe pas en C, toutes les variables et constantes sont numériques, écrire "x = 'a' + y;" est une instruction parfaitement valide).

La ligne "main (void)" et l'accolade sur la ligne qui suit marquent le début du code exécutable.

Les bits du registre OPTION sont aussi à prendre tels quels.

La valeur 0x2 à la fin de la ligne indique la division par 8 pour le registre TMR0.

Nous allons lire le signal sur le port GP3 et utiliser GP0 et GP1 pour sortir la valeur.

    TRIS = 0b001000; // GP3 as input, all others as output
    GPIO = 0; // all ports off
    for (cnt = 0; cnt < 5; cnt++) { // wait for five pulses
        do {} while (!GP3); // wait start of pulse
        do {} while (GP3); // wait end of pulse
    }

J'ai configuré tous les ports en sortie dans le registre TRIS, ça pourra toujours servir quand je rajouterai du code plus tard.

L'instruction "for (cnt = 0; cnt < 5; cnt++) {" de la troisième ligne est une boucle qui va s'exécuter 5 fois, l'accolade ouvrante introduit un bloc d'instructions qui s'exécuteront dans le corps de la boucle.

L'instruction "do {} while (!GP3);" de la quatrième ligne est une boucle qui va s'exécuter tant que le port GP3 sera égal à zéro.

L'instruction "do {} while (GP3);" de la cinquième ligne est une boucle qui va s'exécuter tant que le port GP3 sera différent de zéro.

L'accolade de la sixième ligne indique la fin du bloc d'instructions de la boucle "for".

Arrivé à ce point, nous sommes donc sûr qu'il y a bien un signal répétitif qui arrive sur le port GP3. Il n'y a plus qu'à mesurer le temps qu'il dure.

    for (;;) { // loop for ever
        do {} while (!GP3); // wait start of pulse
        TMR0 = 255 - 100; // wait at least 100 * 8 = 800 usec
        do {} while (TMR0 >= 2); // time elapsed, TMR0 has reached 0 
        do {} while (GP3); // wait end of pulse
        cnt = TMR0; // TMR0 is now between 18 and 156, neutral is 88

L'instruction "for (; ; )" de la première ligne est le début d'une boucle infinie, qui s'exécutera tant que le MCU est alimenté.

L'instruction "do {} while (!GP3);" de la deuxième ligne attend que le port GP3 soit différent de zéro.

L'instruction "TMR0 = 255 - 100;" de la troisième ligne range une valeur dans le registre TMR0, qui va continuer à compter à partir de cette valeur. Lorsqu'il repassera par la valeur zéro, 800 µs se seront écoulées. Pourquoi laisser passer ce temps avant de faire la mesure ?

Le registre TMR0 peut prendre 256 valeurs, soit de 0 à 2040 µs. La durée du signal étant de 2000 µs, on pourrait penser qu'en remettant le registre à zéro ce serait suffisant, mais ce temps de 2000 µs est donné avec le trim au neutre, si on met le trim en butée le signal risque d'être plus long et de dépasser la capacité de comptage du registre. Avec ce décalage, je peux mesurer un temps variant de 800 à 2840 µs.

L'instruction "do {} while (TMR0 >= 2);" de la quatrième ligne attend que le registre TMR0 soit repassé par zéro.

L'instruction "do {} while (GP3);" de la cinquième ligne attend que le port GP3 revienne à zéro.

L'instruction "cnt = TMR0;" de la sixième ligne range la valeur du registre TMR0 dans une variable appelée "cnt".

Nous connaissons maintenant la durée du signal, qui est une valeur comprise entre 18 et 156, le neutre étant la valeur 88 (88 * 8 µs + 800 µs = 1504 µs). Nous pouvons alors positionner les ports en fonction de cette valeur.

        if (cnt < 78) { // 1400 usec
            GP0 = 1; // GP0 on
        }
        else if (cnt > 98) { // 1600 usec
                GP1 = 1; // GP1 on
        }
        else {
            GPIO = 0; // all ports off
        }
    }
}

L'instruction "if" sert à tester une condition, si la condition est vraie, l'instruction qui suit est exécutée, sinon c'est l'instruction suivant le mot "else" qui s'exécute.

Les ports sont positionnés par l'opérateur "=", soit individuellement dans le cas "GP1 = 1;", soit globalement dans le cas "GPIO = 0;".

Les accolades des deux dernières lignes marquent respectivement la fin de la boucle "for" et la fin du bloc de code exécutable.

Le fichier source complet est ici.