• 12 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 16/05/2019

Découvrez les interfaces et les périphériques d'un microcontrôleur

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Cas d'un simple port I/O pour gérer une LED

Explorons en pratique une première application à microcontrôleur pour gérer une diode électroluminescente, ou LED.

Sur la carte qui nous accompagnera à plusieurs reprises, la LED est connectée directement à un port du microcontrôleur. Le chapitre 1.1.1 a déjà évoqué ce cas. En particulier, la fiche constructeur du microcontrôleur indique que chaque port peut fournir jusqu’à 25 mA, ce qui est suffisant pour notre LED. D’ailleurs, une résistance est placée en série pour limiter le courant.

LEDs implantées sur la carte de développement à microcontrôleur
LED implantées sur la carte de développement à microcontrôleur.

Le code, ici écrit en langage C, prépare les ports D7 et D0 pour fournir une tension en sortie :

Code simple pour le pilotage d'une LED et résultat de la simulation
Code simple pour le pilotage d'une LED, et résultat de la simulation.

La tension sera alors de 5V ou bien de 0V. Avec 5V, la LED sera parcourue par un courant de 5 mA. 
Le code va exécuter une boucle infinie avec 8 étapes. Le port D7 est fixé à la valeur logique haute, et la LED s’allume avec 5V aux bornes du circuit. Après une attente, c’est le port D0 qui passe au 1 logique. Ensuite, les ports sont successivement mis à la valeur logique basse, et la LED s’éteint.

Le code C complet a déjà été mentionné dans le chapitre 1.1.1. Il est répété ici pour vous permettre simplement de refaire sa simulation sous le logiciel MPLab X. Ce code est indépendant de l'architecture du microcontrôleur Microchip pour les versions supérieures au PIC16. Par exemple? le PIC18F45K20 de la carte de développement l'accepte sans rien retoucher.

/*
* File: main.c
* Author: ballard
*
* Created on April 25, 2018, 8:31 AM
*/
#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#define _XTAL_FREQ 8000000
// BEGIN CONFIG
// CONFIG1H
#pragma config FOSC = INTIO67 // Oscillator Selection bits (Internal oscillator block, CLKOUT function on RA6, port function on RA7)
#pragma config FCMEN = OFF // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)
// CONFIG2L
#pragma config PWRT = OFF // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = SBORDIS // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
#pragma config BORV = 30 // Brown Out Reset Voltage bits (VBOR set to 1.8 V nominal)
// CONFIG2H
#pragma config WDTEN = OFF // Watchdog Timer Enable bit (WDT is controlled by SWDTEN bit of the WDTCON register)
#pragma config WDTPS = 32768 // Watchdog Timer Postscale Select bits (1:32768)
// CONFIG3H
#pragma config CCP2MX = PORTC // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
#pragma config PBADEN = ON // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)
#pragma config LPT1OSC = OFF // Low-Power Timer1 Oscillator Enable bit (Timer1 configured for higher power operation)
#pragma config HFOFST = ON // HFINTOSC Fast Start-up (HFINTOSC starts clocking the CPU without waiting for the oscillator to stablize.)
#pragma config MCLRE = OFF // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)
// CONFIG4L
#pragma config STVREN = ON // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = OFF // Single-Supply ICSP Enable bit (Single-Supply ICSP enabled)
#pragma config XINST = OFF // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))
// CONFIG5L
#pragma config CP0 = OFF // Code Protection Block 0 (Block 0 (000800-001FFFh) not code-protected)
#pragma config CP1 = OFF // Code Protection Block 1 (Block 1 (002000-003FFFh) not code-protected)
#pragma config CP2 = OFF // Code Protection Block 2 (Block 2 (004000-005FFFh) not code-protected)
#pragma config CP3 = OFF // Code Protection Block 3 (Block 3 (006000-007FFFh) not code-protected)
// CONFIG5H
#pragma config CPB = OFF // Boot Block Code Protection bit (Boot block (000000-0007FFh) not code-protected)
#pragma config CPD = OFF // Data EEPROM Code Protection bit (Data EEPROM not code-protected)
// CONFIG6L
#pragma config WRT0 = OFF // Write Protection Block 0 (Block 0 (000800-001FFFh) not write-protected)
#pragma config WRT1 = OFF // Write Protection Block 1 (Block 1 (002000-003FFFh) not write-protected)
#pragma config WRT2 = OFF // Write Protection Block 2 (Block 2 (004000-005FFFh) not write-protected)
#pragma config WRT3 = OFF // Write Protection Block 3 (Block 3 (006000-007FFFh) not write-protected)
// CONFIG6H
#pragma config WRTC = OFF // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) not write-protected)
#pragma config WRTB = OFF // Boot Block Write Protection bit (Boot Block (000000-0007FFh) not write-protected)
#pragma config WRTD = OFF // Data EEPROM Write Protection bit (Data EEPROM not write-protected)
// CONFIG7L
#pragma config EBTR0 = OFF // Table Read Protection Block 0 (Block 0 (000800-001FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR1 = OFF // Table Read Protection Block 1 (Block 1 (002000-003FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR2 = OFF // Table Read Protection Block 2 (Block 2 (004000-005FFFh) not protected from table reads executed in other blocks)
#pragma config EBTR3 = OFF // Table Read Protection Block 3 (Block 3 (006000-007FFFh) not protected from table reads executed in other blocks)
// CONFIG7H
#pragma config EBTRB = OFF // Boot Block Table Read Protection bit (Boot Block (000000-0007FFh) not protected from table reads executed in other blocks)
// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.
//END CONFIG
/*
*
*/
int main(int argc, char** argv) {
TRISDbits.TRISD7 = 0; //RD7 as Output PIN
TRISDbits.TRISD0 = 0; //RD0 as Output PIN
while(1)
{
PORTDbits.RD7 = 1; // LED ON
__delay_ms(50); // 1 Second Delay
PORTDbits.RD0 = 1; // LED ON
__delay_ms(50); // 1 Second Delay
PORTDbits.RD7 = 0; // LED OFF
__delay_ms(50); // 1 Second Delay
PORTDbits.RD0 = 0; // LED OFF
__delay_ms(50); // 1 Second Delay
}
return (EXIT_SUCCESS);
}

Cas d'un relais à contacts secs

Vous allez remarquer maintenant que gérer un relais électromagnétique est presque aussi simple que le cas de la LED, à quelques détails près que nous allons décrire.

Le relais électromagnétique nécessite un courant important ; de ce fait, sa commande ne peut pas être connectée directement à un port de microcontrôleur. Un transistor bipolaire permet de résoudre ce problème.  Vous le voyez sur la figure ci -dessous sur le circuit imprimé : le relais sera alimenté sous 12V ; un régulateur de tension linéaire est ajouté, de manière à produire une tension de 5V pour l'alimentation du microcontrôleur. Une autre partie des petits composants est située sur l’autre face de la carte imprimée.

Carte d'interface pour la commande d'un relais à contacts secs et son schéma électrique
Carte d'interface pour la commande d'un relais à contacts secs, et son schéma électrique.
Carte d'interface et carte de développement à microcontrôleur
Carte d'interface et carte de développement à microcontrôleur.

Le relais électromagnétique est piloté par le bit 7 du port D. Dans notre expérience, la valeur logique du port D est contrôlée par un bouton poussoir (BP1). Le bouton poussoir imposera une valeur logique basse (0 logique) au bit 0 du port B (RB0), à chaque appui. Quand le bouton poussoir est relâché, le bit 0 du port B (RB0) est lu à une valeur logique haute.

Code d'activation du bit 7 du port D à partir d'un bouton poussoir
Code d'activation du bit 7 du port D à partir d'un bouton poussoir.

Le programme exécute une boucle d’instructions. Le code met à zéro une variable relative à une temporisation (tempo). Ensuite, une instruction « bit test file, skip if clear »btfsc PORT B, 0 lit le bit 0 du port B (RB0) et saute l’instruction suivante  (goto main_prg)  si la valeur est nulle (c'est-à-dire, si le bouton poussoir BP1 est appuyé). Comme ce n’est pas le cas sur la figure ci-dessus, l’instruction suivante renvoie au début de la boucle.

Dans le cas où le bouton poussoir BP1 est appuyé, le bit 0 du port B (RB0) est lu à une valeur logique nulle (0). L’instruction « bit test file, skip if clear » saute l’instruction suivante. Les bits 0 et 1 du port D (RD0 et RD1) sont mis au 1 logique (5V), donc deux LED s’allument, et le relais est fermé.

Dans l’exemple, une temporisation d’une seconde est exécutée pour permettre de relâcher ou pas le bouton poussoir : call Tempo_Ws.

Vous arrivez à la fin de cette première partie. Vous avez découvert l'intérêt des microcontrôleurs, ses besoins électriques selon le type de moteur et ses interfaces et périphériques. Rendez-vous dans la partie suivante où nous nous intéresserons à l'alimentation électrique de ces systèmes.

Exemple de certificat de réussite
Exemple de certificat de réussite