Les périphériques des microcontrôleurs

[jpparisy]

Pour faire tourner le moteur, le programme de commande doit donc exécuter les instructions d'activation des électro-aimants dans le bon ordre et avec la bonne temporisation, pour que le rotor ait le temps de se positionner entre deux pas.

• Pour faire tourner dans le sens horaire, la séquence est "A, "B", "C" et "D".
• Pour faire tourner en sens inverse, la séquence est "A", "D", "C" et "B".
• Pour faire tourner dans le sens horaire avec des demi-pas, la séquence est "A, "A+B", "B", "B+C", "C", "C+D", "D" et "D+A".
• Pour faire tourner en sens inverse avec des demi-pas, la séquence est "A", "A+D", "D", "D+C", "C", "C+B", "B" et "B+A".

Dans le cas d'un moteur unipolaire, les sorties "A" à "D" sont directement reliées à des transistors commandant les électro-aimants.

Dans le cas d'un moteur bipolaire, les sorties "A" à "D" sont reliées aux entrées des deux ponts en H, pour pouvoir activer avec la bonne polarité les couples de bobines "A+C" et "B+D".

Dans le programme, les valeurs sont rangées dans un tableau, indiquant les bits du port à positionner. Le tableau est parcouru dans l'ordre croissant pour le sens horaire et dans l'ordre décroissant pour le sens inverse. Par exemple :

extern bit half_step, two_phase;
static signed int position = 0;
static void delay_step (void);

signed int one_step (signed char direction)
{
    static const char step_2[4] = {0b0011, 0b0110, 0b1100, 0b1001,};
    static const char step_4[4] = {0b0001, 0b0010, 0b0100, 0b1000,};
    static const char step_8[8] = {0b0001, 0b0011, 0b0010, 0b0110,
                                   0b0100, 0b1100, 0b1000, 0b1001,};

    position += direction;
    if (half_step)
        PORTA = step_8[position & 0b0111];
    else if (two_phase)
        PORTA = step_2[position & 0b0011];
    else
        PORTA = step_4[position & 0b0011];
    delay_step ();
    return position;
}

Ce sous-programme déplace le moteur d'un pas à chaque appel, il est appelé autant de fois que nécessaire. Le bit 0 du port est relié à "A", le bit 1 à "B", le bit 2 à "C" et le bit 3 à "D".

• L'argument "direction" ne peut prendre que les valeurs -1, 0 ou 1, il augmente ou diminue la position courante, suivant son signe.
• La variable "position" définit la position courante du moteur. Sa valeur est renvoyée au programme appelant.
• Dans le cas d'un fonctionnement en demi-pas, indiqué par le bit "half_step", les bits du port à activer sont pris dans le tableau "step_8", indexé par les 3 derniers bits (valeur variant de 0 à 7) de la variable "position".
• Dans le cas d'un fonctionnement en double-phase, indiqué par le bit "two_phase", les bits du port à activer sont pris dans le tableau "step_2", indexé par les 2 derniers bits (valeur variant de 0 à 3) de la variable "position".
• Sinon, ils sont pris dans le tableau "step_4", indexé par les 2 derniers bits (valeur variant de 0 à 3) de la variable "position".
• Le sous-programme "delay_step()" introduit un temps d'attente propre au modèle de moteur utilisé et à la vitesse désirée.

Un programme complet est prévu dans les descriptions de montage pour le PIC 12F675. Il utilisera le moteur 28BYJ-48, que l'on trouve un peu partout à moins de $3.00, port compris, avec son driver basé sur un circuit ULN2003, sa prise et 4 LEDs de contrôle.

 

[jpparisy]

Ce moteur est vendu un peu partout à moins de $3.00, port compris, avec son driver basé sur un circuit ULN2003, sa prise et 4 LEDs de contrôle :

Évidemment, à ce prix, il ne faut pas s'attendre à une grande qualité de réalisation. Voici deux photos de l'intérieur :

 

[jpparisy]

Un afficheur 7 segments est un périphérique de sortie utilisable par un MCU, permettant d'afficher une valeur numérique. Il se présente sous divers types, tailles et couleurs. Il peut être composé d'un seul afficheur ou de blocs de 2, 3, 4 (ou plus) afficheurs.

Il existe deux modèles dans les blocs de 4 afficheurs : un pour réaliser des instruments de mesure, où il y a 4 points décimaux et un autre pour réaliser une horloge, où les deux diodes superposées entre les deux afficheurs du milieu remplacent les points décimaux.

Voici, par exemple un afficheur quadruple, monté sur une plaquette d'essais :

Il est constitué de huit LEDs, nommées selon le dessin ci-dessous :

Lorsqu'on a affaire à un bloc d'afficheurs, les cathodes ou les anodes des LEDs de chaque afficheur sont reliées ensemble, comme dans les schémas ci-dessous :

Le schéma du haut montre un montage à cathodes communes (CC, Common Cathode), celui du dessous un montage à anodes communes (CA, Common Anode).

Le dessin ci-dessous montre le brochage vu de dessus d'un bloc de 4 afficheurs à cathodes communes :

Programmation

Pour afficher un nombre à plusieurs chiffres, nous devons afficher chaque chiffre successivement, en alimentant pendant un certain temps les LEDs des segments A à DP et la broche commune du chiffre à afficher. Si la vitesse de changement est suffisamment élevée, la persistance rétinienne ne permet pas de distinguer de clignotement. Par exemple, ce sous-programme, activé par un timer, permet de piloter un bloc de quatre afficheurs à cathodes communes :

void update_display (void)
{
    static unsigned char i = 3;

    i = (i+1) & 0x03;                           // i varying from 0 to 3
    PORTB = 0b00010000 << i;                    // activate each display according to i
    display_digit (i);                          // write the digit[i] on the ith display.
}

Pour dessiner correctement un chiffre, nous avons besoin d'une table indiquant les segments à allumer. C'est ce qui est réalisé dans le sous-programme suivant, toujours pour des afficheurs à cathodes communes :

void display_digit (unsigned char i)
{
     static const unsigned char drawing[] =
/*        .GFEDCBA                                    */
    {   0b00111111,        // 0        *       A
        0b00000110,        // 1        *     -----
        0b01011011,        // 2        *    |     |
        0b01001111,        // 3        *  F |     | B
        0b01100110,        // 4        *    |  G  |
        0b01101101,        // 5        *     -----
        0b01111101,        // 6        *    |     |
        0b00000111,        // 7        *  E |     | C
        0b01111111,        // 8        *    |  D  |
        0b01101111,  };    // 9        *     -----   o DP

    PORTC = drawing[digits[i]];
    RC7 = dpoint[i];
}

Réalisation pratique

Chaque LED nécessite un courant d'une dizaine de mA, il faut donc intercaler une résistance de limitation entre la sortie du MCU et la broche de l'afficheur. Il existe des réseaux de huit résistances, qui se présentent sous la forme d'un circuit intégré de 16 broches et évitent donc d'avoir à positionner et souder chaque résistance une à une.

La broche commune peut nécessiter un courant pouvant aller jusqu'à 90 mA, ce que le MCU pourrait ne pas être capable de fournir. Il faut donc intercaler, dans ce cas, un petit MOSFET entre les sorties du MCU et chaque broche commune, comme dans le schéma ci-dessous :

 

[subliminal66]

Bonsoir, je possède un controleur de marque "mystery" c'est un 30A, que je souhaite faire fonctionner sur un monocoque en série 400.
Je me demander si je peux le programmer juste avec ma radio aux sons des beeps, ou il faut obligatoirement une carte ?

Merci