🔧 PICkit 3 & MPLAB X IDE

Introduction — Les outils indispensables

Pour programmer un microcontrôleur PIC, vous avez besoin de trois éléments essentiels qui forment la chaîne de développement complète :

• MPLAB X IDE — L'environnement de développement intégré officiel de Microchip. C'est l'éditeur de code, le gestionnaire de projet et l'interface avec le programmateur. Il est gratuit et disponible sur Windows, macOS et Linux.
• Compilateur XC8 — Le compilateur qui transforme votre code C en fichier binaire (.hex) compréhensible par le microcontrôleur. La version gratuite (Free) suffit largement pour tous les projets — elle produit du code fonctionnel, simplement un peu moins optimisé que les versions payantes.
• PICkit 3 (ou PICkit 4) — Le programmateur/débogueur matériel qui transfère le fichier .hex dans la mémoire Flash du PIC via le protocole ICSP (In-Circuit Serial Programming). C'est le lien physique entre votre PC et le microcontrôleur.

Ce tutoriel vous guide pas à pas à travers l'installation, la configuration et la première utilisation de ces trois outils.

🔌 Le PICkit 3 — Programmateur et débogueur

Qu'est-ce que le PICkit 3 ?

Le PICkit 3 est un programmateur/débogueur USB officiel de Microchip. Il permet de programmer la quasi-totalité des microcontrôleurs PIC 8 bits, 16 bits et dsPIC, ainsi que les microcontrôleurs de la famille AVR récemment ajoutée au catalogue Microchip. Il se connecte au PC via USB et au PIC via un connecteur 6 broches.

PICkit 3 vs PICkit 4 : lequel choisir ?

Les 6 broches du connecteur PICkit

Le PICkit 3/4 utilise un connecteur 6 broches au pas de 2.54 mm. Voici le brochage standard :

📥 Installation de MPLAB X IDE

Étape 1 : Téléchargement

Rendez-vous sur le site officiel Microchip : microchip.com/mplab/mplab-x-ide. Cliquez sur « Downloads » et sélectionnez la version correspondant à votre système d'exploitation :

• Windows — Fichier .exe (~900 Mo)
• macOS — Fichier .dmg (~750 Mo)
• Linux — Fichier .tar (~800 Mo, 64 bits uniquement)

Un compte Microchip gratuit peut être nécessaire pour accéder au téléchargement.

Étape 2 : Installation Windows

1. Lancez l'installateur MPLABX-vX.XX-windows-installer.exe en tant qu'administrateur.
2. Acceptez le contrat de licence.
3. Choisissez le dossier d'installation (par défaut : C:\Program Files\Microchip\MPLABX\).
4. Sélectionnez les composants à installer. Gardez les options par défaut qui incluent l'IDE, MPLAB IPE (l'outil de programmation standalone) et les pilotes USB.
5. Attendez la fin de l'installation (~5 min selon votre PC).
6. Redémarrez votre ordinateur si demandé — c'est nécessaire pour que les pilotes USB du PICkit soient correctement chargés.

Étape 3 : Installation macOS

1. Ouvrez le fichier .dmg téléchargé.
2. Double-cliquez sur l'installateur .app.
3. macOS peut bloquer l'exécution : allez dans Préférences Système → Sécurité et Confidentialité → « Ouvrir quand même ».
4. Suivez l'assistant d'installation.

Étape 4 : Installation Linux

1. Extraire l'archive : tar -xf MPLABX-vX.XX-linux-installer.tar
2. Rendre le script exécutable : chmod +x MPLABX-vX.XX-linux-installer.sh
3. Lancer en root : sudo ./MPLABX-vX.XX-linux-installer.sh
4. Ajouter votre utilisateur au groupe pour accéder au PICkit : sudo usermod -aG plugdev $USER
5. Déconnectez-vous et reconnectez-vous pour appliquer les permissions.

📥 Installation du compilateur XC8

MPLAB X est l'IDE, mais il a besoin d'un compilateur pour transformer votre code C en fichier .hex. Pour les PIC 8 bits (PIC10, PIC12, PIC16, PIC18), le compilateur officiel est XC8.

Téléchargement

Rendez-vous sur microchip.com/mplab/compilers et téléchargez la dernière version de XC8 pour votre OS.

Installation

1. Lancez l'installateur XC8.
2. Acceptez la licence.
3. Quand il vous demande le type de licence, choisissez « Free ». La version gratuite est parfaitement fonctionnelle — elle compile du code correct, simplement avec moins d'optimisations que les versions Pro ou Standard.
4. Laissez le chemin d'installation par défaut.
5. Cochez « Add xc8 to the PATH environment variable » si proposé.
6. Terminez l'installation.

Autres compilateurs XC

✅ Vérifier l'installation

Après avoir installé MPLAB X et XC8, vérifions que tout fonctionne :

1. Lancez MPLAB X IDE.
2. Allez dans Tools → Options → Embedded → Build Tools (ou sur Mac : MPLAB X → Preferences).
3. Vous devez voir XC8 listé dans la section « Toolchain ». Si ce n'est pas le cas, cliquez sur « Scan for Build Tools » ou ajoutez manuellement le chemin vers le compilateur.
4. Branchez votre PICkit 3 en USB. La LED verte du PICkit doit s'allumer.
5. Vérifiez dans Tools → Options → Embedded → Generic Settings que le PICkit 3 est détecté comme outil de programmation.

🆕 Créer votre premier projet

Suivez ces étapes pour créer un projet de LED clignotante sur le PIC12F683 :

Étape 1 : Nouveau projet

1. Ouvrez MPLAB X IDE.
2. Allez dans File → New Project.
3. Sélectionnez Categories : Microchip Embedded → Projects : Standalone Project.
4. Cliquez Next.

Étape 2 : Sélectionner le microcontrôleur

1. Dans le champ « Device », tapez PIC12F683 (ou PIC16F877A selon votre projet).
2. Le composant apparaît dans la liste déroulante. Sélectionnez-le.
3. Cliquez Next.

Étape 3 : Sélectionner le programmateur

1. Dans la section « Tool », sélectionnez votre PICkit :
2. Si le PICkit est branché : il apparaît avec son numéro de série (ex : « PICkit3 – SN:BUR123456789 »).
3. Si vous n'avez pas encore le PICkit : sélectionnez « Simulator » pour tester la compilation sans matériel.
4. Cliquez Next.

Étape 4 : Sélectionner le compilateur

1. Dans la liste, sélectionnez XC8 (vX.XX).
2. Si XC8 n'apparaît pas, retournez vérifier l'installation (section précédente).
3. Cliquez Next.

Étape 5 : Nommer et sauvegarder

1. Donnez un nom au projet (ex : LED_Clignotante_PIC12).
2. Choisissez le dossier de sauvegarde.
3. Cochez « Set as main project ».
4. Cliquez Finish.

📝 Ajouter un fichier source C

1. Dans le panneau « Projects » à gauche, faites un clic droit sur « Source Files ».
2. Sélectionnez New → C Source File.
3. Nommez le fichier main (l'extension .c est ajoutée automatiquement).
4. Cliquez Finish.

Collez le code suivant pour un test de LED clignotante sur le PIC12F683 :

// Configuration du PIC12F683
#pragma config FOSC = INTOSCIO  // Oscillateur interne, GP4/GP5 GPIO
#pragma config WDTE = OFF       // Watchdog désactivé
#pragma config PWRTE = ON        // Power-up timer activé
#pragma config MCLRE = OFF       // MCLR interne
#pragma config CP = OFF          // Protection code désactivée
#pragma config CPD = OFF         // Protection EEPROM désactivée
#pragma config BOREN = ON        // Brown-out reset activé
#pragma config IESO = OFF        // Internal/External switchover OFF
#pragma config FCMEN = OFF       // Fail-safe clock monitor OFF

#include <xc.h>

#define _XTAL_FREQ 4000000   // 4 MHz

void main(void) {
    OSCCON = 0b01100000;  // Oscillateur interne 4 MHz
    ANSEL  = 0x00;         // Toutes les broches en numérique
    CMCON0 = 0x07;         // Comparateur OFF
    TRISIO = 0b00111110;  // GP0 en sortie
    GPIO   = 0x00;         // Toutes les sorties à 0

    while(1) {
        GPIObits.GP0 = 1;   // LED ON
        __delay_ms(500);
        GPIObits.GP0 = 0;   // LED OFF
        __delay_ms(500);
    }
}

🔨 Compiler le projet

1. Cliquez sur le bouton « Build Project » (icône marteau 🔨) dans la barre d'outils, ou appuyez sur F11.
2. Observez la console Output en bas de l'écran. Si tout va bien, vous verrez le message :

BUILD SUCCESSFUL (total time: Xs)

En cas d'erreur, la console affiche le numéro de ligne et la description de l'erreur. Les erreurs les plus courantes sont :

• « undefined identifier » — Vérifiez que #include <xc.h> est bien en tête du fichier et que le bon device est sélectionné.
• « can't find 0x... words for psect » — Le code dépasse la mémoire Flash. Optimisez ou passez à un PIC plus grand.
• « _XTAL_FREQ not defined » — Ajoutez #define _XTAL_FREQ 4000000 avant d'utiliser __delay_ms().

Informations de compilation utiles

Après la compilation, la console affiche un résumé de l'utilisation mémoire :

Memory Summary:
    Program space        used    42h (    66) of   800h words   (  3.2%)
    Data space           used     5h (     5) of    80h bytes   (  3.9%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)

Ces informations vous indiquent combien de mémoire Flash (programme) et de RAM (données) votre code utilise par rapport à la capacité totale du PIC.

🔗 Câblage ICSP sur breadboard

Avant de programmer, vous devez connecter le PICkit 3 à votre circuit. Voici le câblage pour le PIC12F683 :

Connexions PICkit 3 → PIC12F683

Option : Alimenter le circuit par le PICkit

Le PICkit 3 peut fournir l'alimentation au circuit (jusqu'à ~30 mA). Pour activer cette option dans MPLAB X :

1. Faites un clic droit sur le nom du projet → Properties.
2. Dans la section de gauche, sélectionnez votre PICkit (PICkit 3 ou PICkit 4).
3. Dans l'onglet Power, cochez « Power target circuit from PICkit ».
4. Réglez la tension sur 5.0V (ou 3.3V si votre circuit le nécessite).
5. Cliquez OK.

C'est la méthode la plus pratique pour les circuits simples sur breadboard car elle élimine le besoin d'une alimentation externe.

🚀 Programmer le PIC

Le moment de vérité ! Voici comment transférer votre programme dans le microcontrôleur :

1. Vérifiez que le PICkit est branché en USB et que le câblage ICSP est correct.
2. Dans MPLAB X, cliquez sur « Make and Program Device Main Project » (icône flèche verte vers le bas ⬇️), ou appuyez sur le raccourci correspondant.
3. MPLAB X va d'abord compiler le code (si nécessaire), puis tenter de communiquer avec le PIC via le PICkit.
4. Si la communication réussit, vous verrez dans la console :

Connecting to MPLAB PICkit 3...
Firmware Suite Version.....01.56.09
Firmware type..............Enhanced Midrange

Target detected
Device ID Revision = 6

Programming...
Programming/Verify complete

Votre PIC est maintenant programmé ! Si vous avez câblé une LED sur GP0, elle devrait clignoter immédiatement.

🔧 Dépannage — Erreurs fréquentes

« Target device was not found »

• Vérifiez le câblage ICSP (5 fils dans le bon ordre).
• Vérifiez que le PIC est correctement inséré sur la breadboard (encoche vers le haut).
• Activez « Power target circuit from PICkit » dans les propriétés du projet si le circuit n'a pas d'alimentation externe.
• Essayez avec une vitesse de programmation plus lente : Project Properties → PICkit 3 → Program Options → cochez « Low Speed ».

« VDD voltage level error »

• Le PICkit détecte une tension VDD trop basse ou incohérente.
• Vérifiez le câblage VDD et VSS.
• Si vous utilisez une alimentation externe ET le PICkit, assurez-vous que les tensions sont compatibles (les deux à 5V).
• Ajoutez un condensateur de découplage 100nF entre VDD et VSS, au plus près du PIC.

« Unable to program device — Verify failed »

• Le PIC pourrait être endommagé ou protégé (bit CP activé dans un ancien programme).
• Essayez d'abord un « Erase » complet : dans MPLAB IPE (accessible via Tools → MPLAB IPE dans MPLAB X), cliquez sur « Erase ».
• Si le problème persiste, le PIC pourrait être défectueux. Testez avec un autre chip.

« Failed to get Device ID »

• Le mauvais microcontrôleur est sélectionné dans le projet. Vérifiez que le device correspond au PIC physique.
• Le câblage MCLR/VPP est incorrect ou absent.
• Le PIC n'est pas alimenté.

📦 MPLAB IPE — Programmer sans l'IDE

MPLAB IPE (Integrated Programming Environment) est un outil standalone installé avec MPLAB X. Il permet de programmer un PIC directement à partir d'un fichier .hex, sans ouvrir le projet complet dans l'IDE. C'est utile pour :

• Production — Programmer rapidement plusieurs PIC avec le même firmware.
• Distribution — Donner le fichier .hex à quelqu'un qui n'a pas le code source.
• Dépannage — Tester la communication avec le PICkit indépendamment de l'IDE.

Pour l'utiliser : lancez MPLAB IPE, sélectionnez le device, cliquez « Connect », chargez le fichier .hex avec « Browse », puis cliquez « Program ». C'est tout.

🐛 Utiliser le débogueur

Le PICkit 3 est aussi un débogueur : il permet d'exécuter votre programme pas à pas, de placer des points d'arrêt (breakpoints) et d'inspecter les variables et registres en temps réel.

Comment déboguer

1. Dans les propriétés du projet, assurez-vous que l'outil sélectionné est le PICkit (pas le Simulator).
2. Cliquez sur « Debug Main Project » (icône triangle vert avec un insecte 🐛), ou appuyez sur la touche correspondante.
3. Le programme est chargé dans le PIC en mode debug.
4. Utilisez les boutons de la barre de débogage :
   • Pause — Suspend l'exécution.
   • Step Over (F8) — Exécute la ligne courante et passe à la suivante.
   • Step Into (F7) — Entre dans une fonction appelée.
   • Continue (F5) — Reprend l'exécution jusqu'au prochain breakpoint.
   • Reset (Ctrl+F5) — Redémarre le programme depuis le début.
5. Pour ajouter un breakpoint, cliquez dans la marge gauche de l'éditeur à côté du numéro de ligne. Un point rouge apparaît.

⚡ Astuces et bonnes pratiques

Raccourcis clavier MPLAB X essentiels

Bonnes pratiques de projet

• Un projet par programme — Ne mélangez pas plusieurs programmes dans un même projet. Créez un projet séparé pour chaque exercice ou montage.
• Nommez clairement vos fichiers — main.c est standard, mais pour des projets multiples, utilisez des noms descriptifs : led_blink.c, adc_read.c, pwm_motor.c.
• Commentez votre code — Les bits de configuration (#pragma config) et les registres ont des noms cryptiques. Commentez chaque ligne de configuration pour vous y retrouver plus tard.
• Sauvegardez les #pragma config séparément — Pour les projets PIC16F877A avec beaucoup de bits de configuration, créez un fichier config.h dédié.
• Compilez souvent — Ne codez pas 200 lignes avant de compiler. Compilez à chaque petite étape pour localiser les erreurs facilement.

🔄 Alternatives au PICkit 3

Si le PICkit 3 n'est pas disponible ou trop cher, voici d'autres options pour programmer les PIC :

• PICkit 4 — Le successeur officiel, plus rapide et compatible avec les PIC les plus récents. Recommandé si vous achetez neuf.
• Clones PICkit 3/4 — Disponibles sur AliExpress/Amazon pour 8 à 20 €. Fonctionnent bien avec MPLAB X pour les PIC courants (12F, 16F, 18F).
• K150 — Programmateur d'entrée de gamme (~5 €) avec son propre logiciel. Ne fonctionne pas avec MPLAB X mais permet de charger un fichier .hex. Limité en fonctionnalités (pas de débogage).
• SNAP — Le MPLAB SNAP est un programmateur/débogueur récent de Microchip, plus abordable que le PICkit 4 (~15 € original). Supporte PIC et AVR.
• ICD 4 — Le débogueur professionnel de Microchip (~200 €). Réservé aux professionnels et laboratoires universitaires.