F8EOZ » PIC

Fréquencemètre à microcontrôleur PIC – Révision 1

admin — Wed, 30 Jul 2014 16:24:58 +0000

Figure 1 – Le circuit câblé

J’ai réalisé une version plus compacte du fréquencemètre à insérer dans le boîtier du transceiver que je suis en train de construire. Le circuit figure 1 est câblé sur une plaque d’époxy FR4 pastillée, étamée double face de 5×7 cm. L’afficheur LCD est enfiché sur cette plaque. Quatre vis sont prévues pour le fixer sur le panneau avant du futur boîtier. Le firmware fcounter14 n’a pas été modifié il est disponible en téléchargement en version source et Hexa. L’utilisation des boutons-poussoirs évite toute modification du firmware (voir description), le fréquencemètre est utilisable dans différentes configurations matérielles:

choix du mode: avec ou sans IF, LO+IF, LO-IF, IF-LO, (avec LO = ocillateur local, IF = fréquence intermédiaire),
valeur de la fréquence IF.

Le PIC16F84 et a été flashé avec mon programmateur. Au cours de cet exercice de soudure j’ai noté 2 erreurs sur le schéma initial que j’ai corrigées:

R5 = 470 Ω et non 22 kΩ,
R6 = 22 kΩ et non 27 kΩ.

J’ai aussi ajouté une résistance de 75 Ω pour le rétroéclairage de l’afficheur. Voici le schéma corrigé disponible en téléchargement révision 1:

Figure 2 – Schéma du fréquencemètre révision 1

Il faut noter aussi que je n’ai pas câblé sur ce circuit toute la partie concernant le régulateur 5V bien qu’il figure sur le schéma. J’évite ainsi la redondance du circuit d’alimentation. La tension de 5V est fournie par une alimentation solide et bien filtrée, montée sur un circuit séparé qui alimente aussi le VFO.

Index des articles de la catégorie microcontroleur

Fréquencemètre à microcontrôleur PIC – Réalisation

admin — Mon, 09 Jan 2012 18:12:17 +0000

Le circuit imprimé
Le circuit imprimé a été monté sur plaque époxy à pastilles. Sa réalisation ne pose pas de problème particulier. Je n’ai pas poussé la miniaturisation. On pourrait faire plus petit en superposant l’afficheur au circuit imprimé.

Circuit imprimé vu de dessus

La face avant présente l’interrupteur on/off, la prise BNC d’entrée, les boutons de setup. La face arrière présente la fiche pour l’adaptateur secteur.

Circuit imprimé vu de dessous

Le circuit peut être, soit alimenté par pile pour être portable, soit par adaptateur secteur en utilisation de laboratoire. Remarquez les entretoises qui ne sont que de simples chevilles bon marché, coupées à dimension!

Le boîtier
La coque du boîtier a été réalisé avec de la tôle d’alu de 10/10. Les parties internes latérales sont des morceaux d’alu de 15/10. Les faces avant et arrière sont 2 plaques d’époxy cuivrées. L’ensemble est tenu par de simples vis à tôle.

Boîtier

Télécharger le fichier Kicad du schèma .
Télécharger les fichiers source et hexa du fréquencemètre .

Liens
Fréquencemètre à microcontrôleur PIC
Fréquencemètre à microcontrôleur PIC – Description
Fréquencemètre à microcontrôleur PIC – Structure du programme
Fréquencemètre à microcontrôleur PIC – Mesure
Fréquencemètre à microcontrôleur PIC – Commande de l’afficheur LCD
Fréquencemètre à microcontrôleur PIC – Réalisation

Fréquencemètre à microcontrôleur PIC – Mesure

admin — Sat, 07 Jan 2012 12:21:56 +0000

La routine de mesure est le coeur du fréquencemètre. A chaque boucle du programme elle est appelée 2 fois:
- pour l’auto calibrage,
- pour la mesure réelle.

Description de la routine de mesure
La fréquence à mesurer est appliquée sur RA4/T0CKI. La routine est chargée de relever à chaque cycle le compteur TMR0. La représentation d’une fréquence maximum de 50 MHz nécessite en binaire, 25 bits, il faut donc utiliser 4 compteurs de 8 bits soit 32 bits. Comme TMR0 est limité à 8 bits, elle détecte le débordement de TMR0 en comparant sa valeur avec la valeur stockée au cycle précédent TMR0_old. Quand TMR0 < TMR0_old, elle reporte la retenue aux niveaux supérieurs. La durée d’un cycle de la routine de mesure est de 25 us avec un PIC 16F84 à 4 MHz. J’ai choisi cette durée qui est sous-multiple de 275 us, durée de l’auto calibrage, et de 500 ms durée de la mesure réelle.
Paramètres:
gateLow = nombre de cycles bas,
gateHigh = nombre de cycles haut,
Durée de la mesure = gateHigh x gateLow x 25us
Compteur Binary Frequency Counter = BFC3 (32 bits), BFC2, BFC1, BFC0 (LSB)
TMR0_old = valeur de TMR0 du cycle précédent, initialisée à zéro.

Auto calibrage
Il permet de régler le prescaler pour la mesure réelle. L’auto calibrage consiste à effectuer une mesure pendant 275us avec le prescaler = 256. A l’issue de cette mesure, nous obtenons dans le compteur BFC0 une approximation de la gamme de fréquence en MHz.
1 MHz x 275us / 256 = 1,07 => BFC0 = 1
2 MHz x 275us / 256 = 2,14 => BFC0 = 2
3 MHz x 275us / 256 = 3,22 => BFC0 = 3
…
10 MHz x 275us / 256 = 10,74 => BFC0 = 10
…
20 MHz x 275us / 256 = 21,48 => BFC0 = 21
…
50 MHz x 275us / 256 = 53,71 => BFC0 = 53
Remarque: compte-tenu de la durée de mesure de 275us et le la valeur du prescaler de 256, les fréquences < 1 x 256 / 275 soit 0,930908 MHz donneront BFC0 = 0.
Vous pouvez vérifier le résultat de l’auto calibrage sur l’afficheur. Dans le programme source rechercher la ligne ;#define AUTORANGE_TEST. Cette ligne est inactivée en commentaire. Rendez cette ligne active. Ré assemblez et vérifiez en connectant au fréquencemètre un VFO par exemple.

Calcul du pré diviseur (prescaler PS)
Le calcul est effectué simplement en examinant le bit de poids fort de BFC0 de la façon suivante:
bit 7 = 1 | 128 à 255 MHz et au dessus inutilisé
bit 6 = 1 | 064 à 128 MHz inutilisé
bit 5 = 1 | 032 à 064 MHz | PS = 5 | 64:1
bit 4 = 1 | 016 à 032 MHz | PS = 4 | 32:1
bit 3 = 1 | 008 à 016 MHz | PS = 3 | 16:1
bit 2 = 1 | 004 à 008 MHz | PS = 2 | 8: 1
bit 1 = 1 | 002 à 004 MHz | PS = 1 | 4:1
bit 0 = 1 | 000 à 002 MHz | PS = 1 | 4:1
Remarque: je n’ai pas utilisé la valeur PS=0. En effet, lors de mes essais avec cette valeur, j’obtenais une mesure erronée que je ne m’explique pas. Si un lecteur à la solution je suis preneur!

Vérifions la mesure maximum possible pour chaque gamme de fréquence, pour une durée de mesure de 500 ms:
64 MHz = 64 000 000 x 0,5 / 64 = 500 000 =   07 A1 20 (16)
32 MHz = 32 000 000 x 0,5 / 32 = 500 000 =   07 A1 20 (16)
16 MHz = 16 000 000 x 0,5 / 16 = 500 000 =   07 A1 20 (16)
08 MHz = 08 000 000 x 0,5 / 08 = 500 000 =   07 A1 20 (16)
04 MHz = 04 000 000 x 0,5 / 04 = 500 000 =   07 A1 20 (16)

Mesure réelle
Après l’auto calibrage, la mesure réelle est faite pendant 500 ms. Le résultat est ensuite multiplié une première fois par 2 (simple décalage à gauche avec report du bit de retenu) pour obtenir une valeur rapportée à une seconde. Ce résultat et encore multiplié par 2, autant de fois que l’indique le prescaler pour obtenir la valeur définitive de la fréquence en Hz. A cette valeur est éventuellement ajoutée ou ôtée IF selon l’option MODE du setup. La valeur binaire obtenue et ensuite transformée en décimal codé binaire dans BCD9 (MSB) à BCD0 (LSB) puis affichée.

Limites et précision
Avec une durée de mesure de 500 ms, la plus petite fréquence mesurable serait théoriquement de 2 Hz. Toutefois avec PS minimum = 4, la fréquence minimum mesurable = 1 x 4 / 0.5 = 8 Hz.
Précision:
- gamme 04 MHz = 008 Hz,
- gamme 08 MHz = 016 Hz,
- gamme 16 MHz = 032 Hz,
- gamme 32 MHz = 064 Hz,
- gamme 64 MHz = 128 Hz.

Modification de la durée du cycle de base de la routine de mesure
Avec une fréquence d’horloge de 10 MHz la routine ne doit pas être modifiée. Vous pouvez modifier les paramètres gateLow et gateHigh pour obtenir une durée proche de 256 us pour l’auto calibrage et une durée exacte de 500 ms pour la mesure réelle. Ainsi avec un quartz de 10 MHz, si le cycle de base = 10 us au lieu de 25 us, vous pouvez choisir 26 x 10 us = 260 us (> 256 us) pour l’auto calibrage et 200 x 250 x 10 us = 500 000 us = 500 ms pour la mesure réelle.

Si cela n’est pas suffisant il faut adapter la routine. Pour cela il faut distinguer les instructions nécessaires et suffisantes de celles qui sont là pour faire perdre du temps (nop en général). Voici la formule du cycle de base de notre routine:
cycle de base = 4p + (10+a)np + (3+b)p(n-1) + 2p + (3+c)(p-1) + 2 + 3
où
n = gateLow,
p = gateHigh,
a = temps perdu,
b = temps perdu,
c = temps perdu,
Les valeurs fixes 4, 10, 2, 3 sont la durée des instructions nécessaires avec une horloge de 4 MHz.

Avec ces valeurs pour obtenir un cycle de base de 25 us, poser n = 1 et p = 1, il vient:
cycle de base = 25 us = 4 + (10 + a) + 0 + 2 + 0 + 2 + 3 => a = 4,
poser n = 2 et p = 1, il vient
2 cycles de base = 50 us = 4 + (10 + 4)2 + (3 + b)1 + 2 + 0 + 2 + 3 => b = 8,
poser n = 1 et p = 2, il vient
2 cycles de base = 50 us = 4×2 + (10 + 4)2 + 0 + 2×2 + (3+ c) + 2 + 3 => c = 2, d’où
cycle de base = 4p + (10+4)np + (3+8)p(n-1) + 2p + (3+2)(p-1) + 2 + 3.
C’est la formule qui est utilisée dans ce programme.
a est obtenu avec 4 instructions nop, b avec 8 nop, c avec un goto supplémentaire.

Supposons par exemple une fréquence d’ horloge qui diviserait par 4 la durée des instructions et un cycle de base = 8 us, durée choisie car sous-multiple de 256 et 500000 qui peut être obtenu en faisant gateLow = 250 et gateHigh = 250 (chaque compteur est limité à 255).
Cycle de base = 8 us = p + (2.5 + a)np + (0.75 + b)p(n-1) + 0.5p + (0.75+c)(p-1) + 0.5 + 0.75,
avec n = 1 p = 1, il vient
cycle de base = 8us = 1 + (2.5 + a) + 0 + 0.5 + 0 + 0.5 + 0.75 => a = 2.75,
avec n = 2 et p = 1, il vient
2 cycles de base = 16 us = 1 +(2.5 + 2.75)2 + (0.75 + b) + 0.5 + 0 + 0.5 + 0.75 = b = 2,
avec n = 1 et p = 2, il vient
2 cycles de base = 16 us = 2 +(2.5 + 2.75)2 + 0 + 0.5×2 + (0.75+c) + 0.5 + 0.75 => c = 0.5, d’où
cycle de base = 8us = p + (2.5 + 2.75)np + (0.75 + 2)p(n-1) + 0.5p + (0.75+0.5)(p-1) + 0.5 + 0.75.
Avec ces valeurs pour l’auto calibrage = 256 us = 32 x 8 us, n = 32 et p = 1, il vient
32 cycles de base = 1 + (2.5 + 2.75)32 + (0.75 + 2)31 + 0.5 + 0 + 0.5 + 0.75 = 256 us C.Q.F.D.
La mesure réelle = 500 ms = 62500 x 8 us, n = 250 et p = 250, il vient
62500 cycles de base = 250 + (2.5 + 2.75)62500 + (0.75 + 2)250×249 + 0.5×250 + (0.75+0.5)249 + 0.5 + 0.75 = 500 000 us C.Q.F.D.
a pourrait être obtenu avec 11 nop, b avec 8 nop, c en laissant le même goto supplémentaire.

Dans le Debugger de MPLAB, il y a un excellent outil qui s’appelle StopWatch qui permet de connaître la durée exacte de notre routine. Indiquer au préalable la valeur de la fréquence horloge en choisissant Setting dans le menu du Debugger.

Ci-dessous la routine de mesure qui finalement contient peu d’instructions.

;********************************************************************************
; Parameters : gate time high = p, gate time low = n
; Gate time = 4p + (10+4)np + (3+8)p(n-1) + 2p + (3+2)(p-1) + 2 + 3
; One step = 25 us with XTAL = 4 MHz
; 275 us = 1 x 11 x 25 us => p = 1, n = 11
; 500 ms = 100 x 200 x 0.025 ms => p = 100, n = 200
;********************************************************************************
Measure
    BANK1
    movwf    OPTION_REG     ;
    BANK0
    clrf    BFC0-1         ; clear 16 bits counter
    clrf    BFC0-2         ; clear 24 bits counter
    clrf    BFC0-3         ; clear 32 bits counter

    bcf     PORTA,0x03
    movf    gateHigh,w
    movwf   countHigh
    clrf    TMR0_old
    clrf    TMR0
    COUNT_START    ; start count
M05 movfw   gateLow         ; |
    movwf   countLow        ; | = 4p
    goto    M20             ; |
M10 ; c
    goto M05                ; = 2(p-1)
    ; b = 8 nop
M15 nop                     ; |
    nop                     ; |
    nop                     ; |
    nop                     ; |  = 8p(n-1)
    nop                     ; |
    nop                     ; |
    nop                     ; |
    nop                     ; |

M20 movf    TMR0,w         ; TMR0 rollover ?    ; |
    subwf   TMR0_old,f     ; TMR0_old - TMR0    ; |
    btfss   STATUS,Z       ; 0 = no change      ; |
    goto    M25                                 ; |
    nop                                         ; |
    nop                                         ; |
    nop                                         ; |
    goto    M30                                 ; |
M25 btfsc   STATUS,C    ; TMR0 < TMR0_old ?     ; | = (10+4)np
    incf    BFC0-1,f    ; 16 bits counter       ; |
    btfsc   STATUS,Z                            ; |
    incf    BFC0-2,f    ; 24 bits counter       ; |
M30 movwf   TMR0_old                            ; |
    ; a = 4 nop
    nop                                         ; |
    nop                                         ; |
    nop                                         ; |
    nop                                         ; |

    decfsz  countLow,f          ; = 2p
    goto    M15                 ; = 3p(n-1)
    decfsz  countHigh,f         ; = 2
    goto    M10                 ; = 3(p-1)
    COUNT_STOP                  ; = 3
    ; last value
    movf    TMR0,w       ; test for TMR0 rollover
    movwf   BFC0         ; save 8 bits counter
    subwf   TMR0_old,f
    btfsc   STATUS,Z     ; rollover ?
    goto    M_35         ; no
    btfsc   STATUS,C
    incf    BFC0-1,f     ; 16 bits counter
    btfsc   STATUS,Z
    incf    BFC0-2,f     ; 24 bits counter
M_35
    retlw   0x00

Télécharger le fichier Kicad du schèma .
Télécharger les fichiers source et hexa du fréquencemètre .

Liens
Fréquencemètre à microcontrôleur PIC
Fréquencemètre à microcontrôleur PIC – Description
Fréquencemètre à microcontrôleur PIC – Structure du programme
Fréquencemètre à microcontrôleur PIC – Mesure
Fréquencemètre à microcontrôleur PIC – Commande de l’afficheur LCD
Fréquencemètre à microcontrôleur PIC – Réalisation

Fréquencemètre à microcontrôleur PIC – Structure du programme

admin — Sat, 17 Dec 2011 08:38:07 +0000

Voilà, notre micro contrôleur est placé dans le circuit (au moins sur le papier!). Nous savons ce qu’il doit faire: compter des impulsions et transmettre le résultat du comptage à l’afficheur. Il est temps maintenant de passer à la programmation du micro contrôleur. Avant de commencer à programmer j’ai « démonté » plusieurs programmes écrits en langage assembleur, traitant notamment, de la commande d’un afficheur, du comptage des impulsions. J’ai aussi consulté les documentations suivantes:
- Note Microchip AN592,
- Note Microchip AN526 PIC16C5x/PIC16Cxx Utility Math Routines,
- How to control a HD44780-based Character-LCD de Peter Ouwehand,
- 50 MHz-Frequenzzähler mit 16F84 und LCD-Display de Sprut,
- The Weeder Frequency Counter PIC 16F84 port by Peter Cousens,
- Fréquencemètre à microcontrôleur de Loïc Lefebvre.

Ces notions étant acquises, j’ai construit ensuite entièrement ma propre version en langage assembleur que je vais maintenant expliquer.

Structure du programme
Le programme est divisé en 4 modules indépendants:
- le fréquencemètre,
- le setup,
- la gestion des options stockées en EEPROM,
- la gestion de l’afficheur LCD.

Le setup et la gestion des options sont optionnels. Si vous supprimez ces modules, le programme fonctionnera simplement avec les valeurs par défaut.

Le module fréquencemètre comprend:
- l’acquisition et le comptage des impulsions, auto calibration (autorange) et mesure,
- la conversion binaire décimal en tenant compte de l’option IF.

Toutes les opérations d’affichage et de gestion de l’afficheur LCD sont effectuées en passant par les routines et macros du module de gestion de l’afficheur. Ce module peut donc être entièrement réutilisé pour un autre programme.

Affichage numérique
L’affichage numérique est réalisé au moyen d’une seule routine utilisant un format d’affichage qu’il est possible simplement d’adapter à ses besoins. Plusieurs formats peuvent être définis dans une table des formats. Ce format permet la suppression des zéros non significatifs, l’insertion d’un point ou d’une virgule décimale, l’insertion d’espaces pour séparer les milliers.

Affichage des textes
L’affichage des textes est réalisé au moyen d’une seule routine et d’une table des textes.

Calculs et conversions
Ils sont réalisés avec les routines de Brian Beard, elles mêmes réalisées d’apès la note AN526 de Microchip.

Le module de gestion des options comprend,
- le chargement en mémoire des options: MODE de fonctionnement et IF,
- la sauvegarde des options dans l’EEPROM en cas de modification par le setup.

Le module de setup est déclenché au premier appui de la touche setup. Il est chargé de la gestion des options MODE et IF.

Racine du programme

;================================================================================
;                                    PROGRAM ROOT
;================================================================================
start

    call    PICinit
    call    LCDinit         ; Initialize LCDisplay
    call    LoadOptions     ; Load options from EEPROM
ProgramLoop
    call    CountFrequency
    call    BinToDec        ; binary to decimal conversion
    call    DisplayCounter
    call    isSetup
    goto    ProgramLoop
;================================================================================
;                                PROGRAM ROOT END
;================================================================================

Fréquencemètre à microcontrôleur PIC – Description

admin — Fri, 16 Dec 2011 14:21:53 +0000

Mon circuit n’est qu’une variante des nombreux schémas publiés sur Internet, comme celui-ci présenté sur Ham Radio India de VU2FD. Je l’ai simplement adapté aux composants dont je disposais et aux ports que je souhaitais utiliser. La figure 1 montre le schéma du circuit qui a été réalisé avec kicad. Il comprend 3 parties:

le préamplificateur,
le micro contrôleur,
l’afficheur.

Figure 1: Schéma du circuit

Pré amplificateur: un seul étage avec un transistor 2N2222.

Micro contrôleurs:
- ports RB4, RB5, RB6, RB7 données à afficher,
- ports RB1, RB2, RB3 signaux de commande de l’afficheur,
- ports RA3, RA4/T0CKI entrée
- ports RA0, RA1 signaux de commande du setup.

Le programme affectera un nom symbolique à chaque ligne de commande et de données. Il sera possible ainsi aux utilisateurs potentiels, d’adapter le programme à son circuit par un simple changement d’assignation et un réassemblage du programme source.

Afficheur LCD: JHD162A 2×16 caractères, commandé par le contrôleur SPLC780D équivalent au HD44780. Il est utilisé en mode 4 bits. Le programme envoie donc 2 fois 4 bits pour écrire un caractère. Je n’ai pas utilisé les bornes 15 et 16 du rétro éclairage. Il est toujours possible de le faire en insérant une résistance dont la valeur est à déterminer en fonction de l’afficheur utilisé. L’intensité lumineuse de l’afficheur est réglée au moyen du potentiomètre ajustable P1. L’afficheur a été acheté su Ebay à faible prix.

Setup
Paramètres
- Paramètre MODE : valeur = NO-IF (défaut), LO+IF, LO–IF, IF–LO (LO = oscillateur local).
- ParamètreIF : valeur = 00000 (défaut) à 99999 Khz.

Installation
A la première mise sous tension, les paramètres sont mémorisés avec leur valeur par défaut. La fréquence lue est la valeur directe. L’installation est terminée si on souhaite simplement l’utiliser en lecture directe (sans calcul de FI). Si on souhaite l’utiliser connecté au transceiver, il suffit de passer en mode Setup , de choisir le mode et la valeur de IF qui correspond au transceiver.
Un appui long (>1s) sur le bouton Set fait passer au Setup et affiche la valeur mémorisée du paramètre IF.
Le 1er digit du paramètre IF clignote
Un appui sur le bouton Next fait avancer de 1 la valeur suivante du 1er digit du paramètre IF et ainsi de suite…
Quand on arrive à 9 un appui sur Next fait revenir le digit à 0 et ainsi de suite…
Un appui sur le bouton Set, enregistre la valeur affichée du 1er digit du paramètre IF et passe au 2ème digit suivant du paramètre IF et ainsi de suite…
Au dernier digit, un appui sur le bouton Set enregistre ce digit et fait passer au paramètre MODE.
Un appui sur le bouton Next fait avancer au MODE suivant et ainsi de suite…
Au dernier digit, un appui sur le bouton Set enregistre ce digit et termine le Setup.
Noter que si on souhaite l’utiliser ensuite en lecture directe, par le Setup on sélectionne simplement MODE=NO-FI. La valeur IF reste mémorisée en EEPROM.

Fréquencemètre à microcontrôleur PIC

admin — Thu, 15 Dec 2011 10:30:43 +0000

Je poursuis mon initiation au microcontrôleur avec cette série d’articles consacrée à la réalisation d’un fréquencemètre, de sa conception, en passant par la programmation du firmware embarqué, la réalisation du circuit électronique, jusqu’à la fabrication mécanique de son boitier.

De nombreux exemples existent sur Internet mais pour bien comprendre ce que j’utilise, rien ne vaut l’expérimentation!

L’utilisation d’un microcontrôleur permet d’obtenir un appareil à faible prix. Le circuit électronique d’un tel appareil est assez simple: un microcontrôleur PIC, un afficheur LCD, quelques composants périphériques. La partie la plus complexe réside dans la programmation de son firmware.

Comme je dispose d’un PIC 16F84A, je l’utiliserai dans cette réalisation. La mesure avec le pré diviseur interne peut monter théoriquement jusqu’à 50 MHz. Ce qui correspond à mon domaine d’ utilisation. Par souci d’économie, cet appareil pourra être utilisé en laboratoire ou connecté à un transceiver. Dans ce but, je prévois dans le firmware, un setup qui servira à paramétrer son mode de fonctionnement, soit en mesure directe de la fréquence, soit en tenant compte d’une FI.

Cahier des charges
- plage de mesure jusqu’à 30 MHz,
- gamme de mesure auto calibrable (autorange),
- affichage LCD 2 lignes de 16 caractères,
- setup mesure directe ou avec FI.

Télécharger le fichier Kicad du schèma .
Télécharger les fichiers source et hexa du fréquencemètre .

Liens
Fréquencemètre à microcontrôleur PIC
Fréquencemètre à microcontrôleur PIC – Description
Fréquencemètre à microcontrôleur PIC – Structure du programme
Fréquencemètre à microcontrôleur PIC – Mesure
Fréquencemètre à microcontrôleur PIC – Commande de l’afficheur LCD
Fréquencemètre à microcontrôleur PIC – Réalisation

Mon premier projet PIC – Programmateur sur port parallèle

admin — Wed, 14 Dec 2011 11:16:48 +0000

Pour réaliser ce premier programmateur, je suis parti du schéma de base de David TAIT supporté par PICPgm et du programmateur présenté sur le site kudelsko.
Je dispose déjà d’une alimentation 12.0V 14.0V fabriquée à partir d’une alimentation de PC H.S. récupérée et d’un CI 74LS06N. A la différence du 74LS07 utilisé dans le schéma de D. TAIT, le 74LS06 est inverseur. Ceci demandera une modification des paramètres de PICPgm pour qu’il reconnaisse automatiquement mon programmateur.

Schéma de base extrait de PICPgm

Schéma modifié
Pour réaliser le schéma, j’ai utilisé le logiciel libre Kicad. La tension de programmation est de 12.7 V. Elle est obtenue au moyen de la diode zener D1 de 12.0 V + la tension Vbe du transistor Q1 BC547. J’ai regroupé sur un connecteur ZIF (acquis sur Ebay à peu de frais) toutes les connexions pour la programmation d’autres PIC. Le PIC 16F84A doit être placé sur les broches 16 à 29 du support ZIF.

Réalisation du circuit
Le circuit a été monté sur une plaque d’ époxy cuivrée, simple face. Il a été réalisé au feutre et avec des transferts. Le connecteur Centronic avec sa nappe de fil, a été récupéré sur un ancien hub d’imprimante au rebut. Un câble d’imprimante relie la prise DB25 du PC au connecteur Centronic du programmateur.

Tests
Pour tester ce programmateur, j’ai utilisé le célèbre petit montage sur platine d’essai qui fait clignoter une diode. Vous en trouverez un exemple sur cet excellent tutoriel.

Pour faire reconnaître automatiquement le programmateur par PICPgm, il faut modifier le fichier qui décrit les interfaces hardware pgmifcfg.xml situé dans le répertoire racine de PICPgm. Insérer les lignes suivantes:

Ces lignes s’obtiennent simplement par un copier, coller des lignes qui décrivent le programmateur « TAIT classic » ci-dessous, puis en modifiant le titre de la balise et en modifiant la propriété invert des balises CLK, DOUT, DIN. Attention à ne pas modifier la description du « TAIT classic ».

Télécharger le fichier Kicad du schèma .

Liens
Mon premier projet PIC
Mon premier projet PIC – Programmateur sur port parallèle

Mon premier projet PIC

admin — Tue, 13 Dec 2011 16:42:48 +0000

Je n’ai jamais utilisé de microcontrôleur. Comme ce composant entre dans la fabrication d’appareils de mesure et notamment du fréquencemètre, je souhaite apprendre à l’utiliser et à le programmer. Il existe plusieurs familles de microcontrôleurs chez différents constructeurs. Lequel choisir? Quels outils de développement choisir?

Cahier des charges
- construire un programmateur,
- utiliser un outil de programmation open source ou une plate forme de développement libre,
- tester le programmateur et le programme avec un petit montage simple.

Choix
Après recherche sur internet, il apparaît que les plus connus sont ceux de la famille AVR d’Atmel et PIC de Microchip. On trouve une documentation importante sur la famille des microcontrôleur PIC et notamment sur la 16F. J’ai acquis sur Ebay quelques PIC16F84A bon marché qu’on dit obsolète mais qui feront très bien l’affaire pour mon apprentissage. Microchip offre une plate-forme de développement MPLAB en langage assembleur MPASM ou en langage C MPLAB C18.

Construire un programmateur USB est l’objectif final mais il nécessite, pour fonctionner un PIC embarquant un firmware. Il me faut d’abord passer par un programmateur plus simple. Le plus facile à construire, avec le plus de chance de succès, semble être le programmateur sur port parallèle. Comme le PIC 16F84 ne se programme pas en basse tension mais demande une tension de programmation comprise entre 12.0V et 14.0V, le programmateur devra fournir cette tension. Le programmateur « TAIT classic » fait bien cela.

Il me faut aussi un utilitaire qui charge le programme dans le microcontrôleur. J’opte pour PICPgm très complet, bien documenté qui supporte le programmateur TAIT. Il a l’avantage de reconnaître automatiquement le programmateur et le PIC.

En résumé:
PIC 16F84A de Microchip.
Programmateur « TAIT classic ».
Plateforme de développement assembleur MPLAB.
Utilitaire de chargement de programme PICPgm.

Liens
Mon premier projet PIC
Mon premier projet PIC – Programmateur sur port parallèle