1. Analyse du système de mesure

Le circuit se divise en 2 parties :

• la mesure, qui est analysée ici,
• l’affichage qui peut être au choix réalisé par un galvanomètre ou un affichage numérique.

Le circuit de mesure est composé de 2 transformateurs T1 et T2 et de 2 résistances de 50Ω.
T1 est un transformateur abaisseur de courant placé en série avec la source.
T2 est un transformateur de tension placé en parallèle à la charge.

1.1. Paramètres du système

Zc : impédance nominale le charge = 50Ω.
Pqro : Puissance maximum délivrée par la source de courant = 25W. C’est ma puissance maximum QRO.
Pqro = Uc²/2Zc où Uc = Tension crête,
On en déduit Uc = √(Pqro*2Z) = √(Pqro*100) = 10√(Pqro) = 10√25 = 50V.
Pour obtenir 50V crête sur 50Ω il faut I crête = 1A.
N: rapport de transformation de T1 et T2.
Je veux obtenir Ua=5V maximum à l’entrée de mon système d’affichage. Cette valeur est bien au-dessus du seuil de conduction des diodes Schottky 5v>>0,2V. J’ai aussi choisi cette valeur pratique et compatible avec une entrée ADC d’un microcontrôleur PIC ou autre (qui pourrait remplacer le galvanomètre).
On en déduit le rapport de transformation N = 50V/5V = 10.

Figure 1 – Circuit équivalent avec une charge de 50 Ohms

1.2. Schéma équivalent

Le schéma équivalent modélisé sur LTSPICE figure 1 est constitué:

• d’un générateur de courant I1 délivrant 1A/N crête qui représente T1,
• d’un générateur de tension V2 = I1*Zc/N = 50V/N à la charge nominale qui représente T2,
• d’une résistance R1 = 50Ω en parallèle à I1,
• d’une résistance R2 = 50Ω en série avec V2.

1.3. Paramètres du modèle

Les éléments indiqués permettent d’adapter le système à votre cas de figure:

• z : impédance de la charge entrée sous forme de liste de différentes valeurs en module,
• Imax =1A : intensité du courant crête délivré par la source,
• N =10 : rapport de transformation de T1 et T2,
• v = (z*Imax)/N tension délivrée par le générateur de tension.

Figure 2 – Circuit équivalent avec une charge de 150 Ohms

1.4. Mesures effectuées

Outre les graphes des tensions et courants du système, le modèle calcule:

• Vm : tension crête au point M (tension réfléchie),
• Vp : tension crête au point P (tension incidente ou directe),
• ρ = Vm/Vp,
• ROS = (1+ρ)/(1-ρ),

Attention à la polarité de I1 et V2. Les courants de I1 et V2 s’annulent. En cas d’inversion Vp et Vm sont inversés.
Les résultats sont enregistrés dans le fichier Error Log de LTSPICE.

Ci-dessus, figure 1 le résultat obtenu avec une charge de 50Ω. On obtient les valeurs nominales :

• aucun courant dans R1, I1 ne débite pas,
• IR2 = 0,1A (puissance moyenne dissipée dans R2 = 0,25W)
• Vm = 0
• Vp = 5V
• ROS = 1

Figure 2, désadaptation importante avec une charge de 150Ω:

• I1 débite du courant dans R1 = 0,1A
• IR2 = 2A (puissance moyenne dissipée dans R2 = 1W)
• Vm = 5V
• Vp = 10V
• ROS = 3

L’appareil ne doit pas être utilisé au delà de cette valeur.
Plus la désadaptation est grande, plus le courant augmente. Il y a risque de destruction de l’appareil en cas de branchement sans charge (Zc infinie).

Figure 3 – Schéma du circuit

2. Schéma du circuit

Figure 3, le schéma réalisé avec le logiciel libre KiCad disponible ici.

Remarque
Le circuit d’affichage est doublé pour alimenter les 2 canaux ADC d’un microcontrôleur (en prévision). Il peut être simplifié à un seul canal si on n’envisage pas ce montage en plaçant l’inverseur sur les points M et P.

2.1. Calcul des composants

Le ROS-mètre est calculé sur mesure avec ce cahier des charges :

• 5W mini en QRP
• 25W maxi en QRO
• galvanomètre 100uA, avec cette échelle graduée jusqu’à 100 il est très facile de calculer le rapport de tension qui donne le ROS.

Les transformateurs T1 et T2 sont des FT50-43. Sur chacun, on bobine 10 tours de fil 0,6mm. La spire unique est constituée par la passage du câble coaxial RG58.

2.1.1. Calcul du potentiomètre de tarage

Pour obtenir la sensibilité maximum il faut que le potentiomètre de tarage Rv fasse dévier l’aiguille du galvanomètre à pleine échelle.
On calcule à 25W : Ia max = 100uA = 5V/Rv ou Rv=5V/0,1mA = 50kΩ.
Cependant il faut se prémunir contre une désadaptation importante et, puisque l’appareil est limité à un ROS de 3 qui donne une tension de mesure de 10V,
on calcule Rv = 10V/0,1mA = 100kΩ. On obtient à la valeur nominale une lecture pleine échelle à mi-course du potentiomètre.
A 5W En utilisation QRP, de la même façon on calcule Uc = 10√5 = 22,36V.
Avec le même rapport de transformation Ua = 22,36/10 = 2,23V qui reste encore au dessus du seuil de conduction des diodes Schottky.
On obtient 2,23/0,1 = 22,3kΩ pleine échelle soit 1/4 de tour de Rv.

3. Limites

En dessous de 1W, sauf à avoir un grande désadaptation de la charge, la tension réfléchie n’est plus mesurable.

Figure 4 – Courbe de puissance transmise

4. Mesures

Plutôt que de parler de ROS, je préfère exprimer la puissance transmise P = Pi-Pr, figure 4.
On pose ρ = Vr/Vi.
Puisque ρ est un rapport de tension à la même impédance on peut écrire ρ² = Pr/Pi.
En ramenant à l’unité Pi si Pi ≠ 0 on écrit
P/Pi = 1-Pr/Pi = 1-ρ²

Exemple si Vr = 20 et Vi = 100 alors ρ=0,2.
P/Pi = 1-0,2*0,2 = 0,96 ou 96% et Puissance perdue = 4%.

Le fichier Graph est disponible ici.

Il n’est pas toujours possible d’obtenir un ROS de 1.
L’écart d’un point S correspond à un rapport de puissance de 4.
Si Vr/Vi= 0,5 (ROS = 3) alors la puissance transmise = 75%
Si nous sommes reçu S9 avec 100W émettre avec 75W se traduira par une baisse de 1/3 de point S.

Figure 5 – Courbe du rapport de transformation

5. Utilisation

Toujours connecter une charge.
Au départ inverseur sur Vref et potentiomètre au maximum de résistance.
Si tout va bien, inverseur sur Vdir. Tourner le potentiomètre jusqu’à avoir une lecture pleine échelle (100 sur mon galvanomètre).
Inverseur sur Vref. Calculer ρ = Vref/Vdir.

Pour changer le rapport de transformation utiliser le graphe ci-contre figure 5, disponible ici.

6. Montage

Le boîtier de base provient d’une alimentation de PC HS. Le circuit est réalisé en l’air (pas de gravure). Une petite plaque époxy cuivrée sert de support aux cosses sur lesquelles sont soudés les composants au plus court.
Les 2 transformateurs sont séparés par un écran fait d’une plaque d’époxy cuivrée double face, soudée perpendiculairement à la plaque de base.
Le blindage du RG58 doit être enlevé au plus court. Une seule extrémité est soudée à la masse, voir photos ci-dessous.

Index des articles de la catégorie labo-de-l-om

• Alimentation linéaire régulée ajustable 13,8V – 34V contrôlée en courant
• Générateur HF 3MHz à 30MHz
• ROS-mètre

Elle est le fruit d’un travail commun avec Michel F6FEO qui m’a apporté son conseil éclairé pendant la réalisation.

1. Schéma

Ci-dessous figure 1, Le schéma de l’alimentation réalisé avec le logiciel libre KiCad. Il est le résultat de la fusion d’un schéma fourni par Michel F6FEO portant notamment sur le contrôle de l’intensité, et d’un autre paru dans le W1FB QRP Notebook page 27 figure 3-1 qui traite du bruit dans les alimentations.

Le coeur du montage est un régulateur de tension intégré de type LM338K,  version ancienne en boîtier TO-3 qui supporte 50W . Une version plus récente en boîtier TO-220 du LM3338T, supporte 25W.  Attention sur ebay circulent de fausses versions du lm338K. Les fichiers KiCad sont disponibles ici .

Figure 1 – Schéma de l’alimentation

2. Le transformateur

J’ai opté pour une alimentation de type linéaire et non à découpage, l’abaissement de la tension secteur se fait grâce à un transformateur de type 230 V / 25 V provenant de Radiospare.
Le modèle Nuovem référence 0225P1-2-025,   torique a deux enroulements secondaires 2x25V à 112,5VA chaque. Les 2 enroulements du secondaire sont câblés en série (fils repérés par couleur voir daatasheet) pour être utilisés en redressement double alternance avec 2 diodes qui nécessite un point milieu. Ainsi  chaque secondaire pourrait supporter un courant théorique Imax=112,5/25=4,5A. Le transformateur est calculé large.

3. Redressement et filtrage

Chaque diode supporte la moitié du courant maximal de charge I=3/2=1,5A et supporte 2 fois la tension crête du secondaire = 25×1,414×2=71V.

Le filtrage pourrait être fait par un condensateur chimique de 6800 uF 63 V. Parce que je les avais en stock j’ai utilisé 2 condensateurs de 4700uF montés en parallèle. En règle générale on adopte une valeur comprise entre 1000 uF et 2000 uF par ampère, qui garantit une ondulation résiduelle assez faible en sortie.

4. Protection

Le primaire est relié à la terre. Il est protégé par un fusible à retard 2AT . Cela peut paraître beaucoup mais l’appel de courant pour la charge des condensateurs de filtrage est tellement fort à la mise sous tension que j’ai grillé bon nombre de fusibles avant de trouver la bonne valeur (merci Michel). Le secondaire est protégé par un fusible à retard 5AT. Tous les condensateurs ont une tension de service de 63V sauf les 2 condensateurs du primaire du transformateur qui ont une tension de service 1kV et les condensateurs en parallèle sur les diodes de redressement qui ont une tension de service de 100V.

Figure 2 – Courbe isopuissance 50W 25W

5. Limites de fonctionnement

Si un tel régulateur permet de faire une construction simple, il faut en connaître les limites. Toutes les combinaisons tension, courant ne sont pas possibles. Il faut l’utiliser en connaissance.

Une partie de la puissance est dissipée par le régulateur en chaleur. Elle est égale au produit de la différence de tension entre son entrée et sa sortie (Vs-Ve) par le courant I qui le traverse. La tension présente à l’entrée du régulateur est ici fixe. On la calcule Ve=25Vx1,414 – 1.5V=34V (37V réellement mesuré à vide). Supposons une tension de sortie réglée à 14 V, la différence de tension entre entrée et sortie du régulateur est alors  34V – 14V=20V. Si le courant demandé en sortie est de 1A, la dissipation de puissance du régulateur est 20V x 1A=20W.  Cette puissance à dissiper est très grande, néanmoins elle est compatible avec le régulateur mais il faut un radiateur suffisant si on ne veut pas que le régulateur se bloque rapidement par protection contre la surchauffe. Avec un courant de 3A cela ne marcherait pas. Le régulateur LM338 possède une protection thermique, qui empêche l’utilisation du régulateur sous un courant  de 3 A avec une telle différence de tension entre entrée et sortie.

Attention au boîtier. La puissance dissipée maximale est de 25 W en boîtier TO220 ou de 50 W en boîtier TO3.

Pour connaître le domaine d’utilisation de l’alimentation j’ai tracé la courbe d’isopuissance à 50W et 25W, figure 2 ci-dessus.
L’équation qui donne la puissance maximum de 50W dissipée par le régulateur en fonction de la tension de sortie v et le courant i peut s’écrire:
50 = (34-v)i ou  encore v=f(i) = -50/i + 34. Définie pour i∈]0; 5A] et par construction pour v∈[13,8V ; 34V].

Ainsi la puissance dissipée par le régulateur sera < 50W pour v>-50/i + 34.
De même elle sera < 25W pour v>-25/i + 34.

Par exemple si i=2,5A il faudrait v>14V avec un régulateur supportant 50W à condition de dissiper toute la chaleur.

L’alimentation pourrait théoriquement débiter 3A à partir de 17,3V à condition que le régulateur LM338K soit refroidi suffisamment.
En résumé:

• Tension d’entrée=34V
• Puissance maximum dissipée par le LM338K: Pb max =50W
• Puissance maximum dissipée par le LM338T: Pb max =25W
• Intensité du courant maximum: Imax = 0.55A ou 3A
• Puissance en entrée du LM338: Pe = 34 * I
• Puissance en sortie du LM338: Ps = V * I si Pb < Pb max
• Puissance absorbée par le LM338K: Pb = Pe – Ps < 50W
• Puissance absorbée par le LM338T: Pb = Pe – Ps < 25W

Le fichier Graph est disponible ici.

6. Cablâge

A cette puissance, il est important d’utiliser du câble de forte section et d’étamer copieusement le circuit imprimé. J’ai utilisé du câble pour HiFi de 2,5mm² et 0,75mm².
Les connexions des résistances et condensateurs autour du régulateur doivent être faites au plus court et soudées au même point.

7. Réalisation

Le circuit a été scindé en 2 parties. La première est le redresseur, la seconde, la régulation.
Les bobines RFC1 et RFC2 ont été réalisées avec 2 grosses perles de ferrite provenant d’une alimentation de serveur HS. J’ai bobiné 10 tours de fil 0.9mm. L’inductance mesurée=100uH.
Deux galvanomètres, l’un pour la tension en parallèle sur la sortie, l’autre pour le courant en série avec la sortie, sont montés sur le boîtier.
L’alimentation est montée dans un boîtier métallique pour favoriser l’évacuation de la chaleur.
La base du boîtier provient d’une alimentation HS de PC. Le transformateur et le module redresseur sont placés dans le fond du boîtier.
Le module régulateur est placé sur une large cornière alu de 185x40x2mm fixée elle-même sur le panneau arrière.
Ci-dessous les photos montrant les étapes de fabrication.

Index des articles de la catégorie labo-de-l-om

• Alimentation linéaire régulée ajustable 13,8V – 34V contrôlée en courant
• Générateur HF 3MHz à 30MHz
• ROS-mètre

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

L’afficheur peut être utilisé en mode 8 bits (8-bit interface) ou en mode 4 bits (8-bit interface). Dans ce dernier cas, seules les lignes DB4 à DB7 sont utilisées. Le quartet (nibble) de poids fort et écrit puis le quartet de poids faible. C’est cette dernière méthode qui est utilisée ici.

J’ai construit le module d’affichage pour qu’il soit entièrement réutilisable par une autre application. Il comprend un ensemble de routines utilisées au travers de macros. Il comprend les éléments suivants:

Définitions:

#define DECIMALPOINT    '.'            ; decimal symbol : dot, comma, …
#define Number_notLeadingZero     LCDOption,0x07    ; 1 = not leading zero
; NUMBER_FORMAT code
#define    END_FORMAT       0xFF
#define    DOT_FORMAT       0x2E
#define    NINE_FORMAT    0x39
#define    ZERO_FORMAT    0x5A

Variables:

    LCD_TEMP:1    ; LCD subroutines internal use
    LCDOption:1   ; internal register don't use
    LCDIndex:1    ; general purpose index

Macros:
IR_WRITE    commande d’écriture d’instruction

BF_READ    commande de lecture du busy flag

DR_WRITE    commande d’écriture de data

DR_READ    commande de lecture de data

LCDDisplay_NumberF  <MSB_nombre>,  <adresseFormat> afficher un nombre avec format

LCDDisplay_Textl  <adresseTexte> afficher un texte

CURSOR_POS    placer le curseur à la position indiquée dans le registre W

CURSOR_POS l   <position> placer le curseur à la position indiquée en paramètre

LCDSet_Display_Control  contrôle de l’afficheur: curseur ou non, clignotement

SET_NOT_LEADING_ZERO afficher les zéros

Tables:
TABLE_TEXT textes à afficher.
NUMBER_FORMAT format des nombres à afficher.
Attention à l’implantation de ces tables qui modifient PCL, registre de 8 bits, qui est l’adresse basse du compteur ordinal. Ces 2 tables de moins de 256 octets ont été placées pour cela à partir de l’adresse 0×01.

Description de TABLE_TEXT
La première instruction de la table modifie PCL.
Chaque texte commence par une étiquette, se termine par le retour de zéro binaire sous forme:

ETIQUETTE_TEXTE
   DT   "TEXTE"
   RETLW 0

Ci-dessous TABLE_TEXT de notre programme.

;*****************************************************************************
; Text to display
; Relative character address is in W
;*****************************************************************************
TABLE_TEXT
    addwf    PCL ,F ; Jump to character pointed in W register
MOD_0
    DT   "NO IF"  ; Note the zero termination.
    retlw    0
MOD_1
    DT   "LO+IF"  ; Note the zero termination.
    retlw    0
MOD_2
    DT   "LO-IF"  ; Note the zero termination.
    retlw    0
MOD_3
    DT   "IF-LO"  ; Note the zero termination.
    retlw    0
MODE_LABEL
    DT    "MODE:"
    retlw    0
IF_LABEL
    DT    "IF:"
    retlw    0
UNDERFLOW_ERROR
    DT    "Underflow Error"
    retlw    0
MHz_UNIT
    DT    "MHz"
    retlw    0
TABLE_TEXT_END
    retlw    0
;
    IF ( (TABLE_TEXT & 0x0FF) >= (TABLE_TEXT_END & 0x0FF) )
        MESSG   "==============Warning - User Defined: Table 'TABLE_TEXT' crosses page boundary in computed jump=============="
    ENDIF

Afficher un texte
L’affichage d’un texte se résume à une seule ligne qui utilise la macro LCDDisplay_Textl. Par exemple pour afficher l’unité de la fréquence:
LCDDisplay_Textl    MHz_UNIT

Cas particulier de la traduction d’un code en texte
Ce cas se pose ici pour l’option MODE du setup qui propose 4 valeurs de 0 à 3. On affiche le code et sa traduction litérale. Ce problème se règle simplement en définissant une table intermédiaire ici appelée MOD_x (placé ici sous TABLE_TEXT) qui retourne l’adresse du texte à afficher dans le registre W. Le texte est affiché directement par la routine (et non la macro) LCDDisplayText de la façon suivante:

    movf    MODindex, w      ; get address from TABLE_TEXT
    call    MOD_x            ; return address MODE option text from TABLE_TEXT in W
    call    LCDDisplayText   ; display text

Table intermédiaire MOD_x:

MOD_x    ; MODindex is in W. Return TABLE_TEXT address into W register
    addwf    PCL ,F ; Jump to character pointed to in W register
    retlw    MOD_0 - TABLE_TEXT - 1
    retlw    MOD_1 - TABLE_TEXT - 1
    retlw    MOD_2 - TABLE_TEXT - 1
    retlw    MOD_3 - TABLE_TEXT - 1

Description de NUMBER_FORMAT
La première instruction de la table modifie PCL.
Chaque format commence par une étiquette, se termine par le retour de oxFF sous forme:

ETIQUETTE_FORMAT
   DT   "FORMAT"
   RETLW 0xFF

Description du format
Le format sert à supprimer les zéros non significatifs, à indiquer la position du point décimal, à insérer des espaces pour séparer les milliers.
Z = supprime un zéro non significatif (leading zero). Dès qu’un chiffre différent de zéro est atteint ce code devient inactif.
. = point décimal, insère le caractère défini par DECIMALPOINT et inactive Z.
9 = insère le chiffre quel que soit sa valeur et inactive Z.
espace (valeur par défaut) = insère un espace.
L’affichage du nombre commence par la gauche (MSB) et s’arrête au dernier 9 s’il existe ou sinon au dernier Z. Le nombre doit être sous forme Décimal Codé Binaire étendu ( pas de nombre en ASCII).

Ci-dessous NUMBER_FORMAT de notre programme.

;*****************************************************************************
; Number format
; Relative format code address is in W
;*****************************************************************************
NUMBER_FORMAT
    addwf    PCL ,F ; Jump to character pointed in W register
FORMAT_MHz
    DT   "Z Z99.999 999"  ; Note the FF termination.
    retlw    0xFF
FORMAT_IF
    DT   "99.999"  ; Note the FF termination.
    retlw    0xFF
FORMAT_MOD
    DT   "9"  ; Note the FF termination.
    retlw    0xFF
NUMBER_FORMAT_END
    retlw    0xFF
;
    IF ( (NUMBER_FORMAT & 0x0FF) >= (NUMBER_FORMAT_END & 0x0FF) )
        MESSG   "==============Warning - User Defined: Table 'NUMBER_FORMAT' crosses page boundary in computed jump=============="
    ENDIF

Ci-dessous la routine d’affichage d’un nombre.

;*****************************************************************************
; Display a number at cursor position using a table NUMBER_FORMAT
; Format sample: ZZZ Z9 or 99 or 9.999 or 9 999 999 ....
; Start address character must be in FSR
; Start address table NUMBER_FORMAT must be in W
; Number_notLeadingZero = 0 => Leading zeros are not displayed
; Number_notLeadingZero = 1 => zero is not Leading zero
;_______________________________________________________
; ASCII value    x30 x31 x32 x33 x34 x35 x36 x37 x38 x39
; number           0   1   2   3   4   5   6   7   8   9
;_______________________________________________________
;*****************************************************************************
LCDDisplayNumberF
    movwf    LCDIndex                ; Holds format address in table NUMBER_FORMAT
    clrf     LCDOption
LCDDisplayNumberFLoop
    ; is leading Zero ?
    movfw    LCDIndex
    call     NUMBER_FORMAT
    xorlw    0x5A                    ; Check if "Z" format
    btfsc    STATUS, Z
    goto     Z_format                ; yes, ====>
    ; is nine ?
    movfw    LCDIndex
    call     NUMBER_FORMAT
    xorlw    0x39                    ; Check if "9" format
    btfsc    STATUS, Z
    goto     nine_format             ; yes, ====>
    ; is dot ?
    movfw    LCDIndex
    call     NUMBER_FORMAT
    xorlw    0x2E                    ; Check if "." format
    btfsc    STATUS, Z
    goto     dot_format              ; yes, ====>
    ; is end ?
    movfw    LCDIndex
    call     NUMBER_FORMAT
    xorlw    0xFF                    ; Check if at end of format
    btfsc    STATUS, Z
    goto     LCDDisplayNumberFEnd    ; yes, end =====================>

space_format    ; default
    btfss    Number_notLeadingZero   ; is a number 1 to 9 already displayed ?
    goto     nextIndexFormat         ; no, no space to insert
    movlw    ' '                     ; yes, insert a space
    call     LCDputChar4             ; Display character
    goto     nextIndexFormat
dot_format
    SET_NOT_LEADING_ZERO             ; to avoid future Z format
    movlw    DECIMALPOINT            ; insert decimal point
    call     LCDputChar4             ; Display character
    goto     nextIndexFormat
nine_format
    SET_NOT_LEADING_ZERO             ; to avoid future Z format
    goto     displayASCII
Z_format
    btfsc    Number_notLeadingZero   ; is a number 1 to 9 already displayed ?
    goto     displayASCII            ; yes, display digit

    movf     INDF, f                 ; INDF -> INDF, set STATUS bit Z
    btfsc    STATUS, Z
    goto     nextDigit               ; yes digit = 0, leading zero not displayed
    SET_NOT_LEADING_ZERO             ; no, display digit and avoid future Z format
displayASCII
    movf     INDF,W                  ; Digit -> W
    iorlw    030h                    ; ASCII value mask
    call     LCDputChar4             ; Display character
nextDigit
    incf     FSR, f
    nextIndexFormat
    incf     LCDIndex,f              ; Point to next character
    goto     LCDDisplayNumberFLoop
LCDDisplayNumberFEnd

return

Afficher un nombre
L’affichage d’un nombre se résume à une seule ligne qui utilise la macro LCDDisplay_NumberF, par exemple pour afficher la fréquence mesurée:
LCDDisplay_NumberF BCD9, FORMAT_MHz

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

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

• 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.

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

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:

<PgmIf name="Tait Invert PIC Programmer" typ="HVP" connection="LPT">
    <PinCfg name="MCLR" pin="5" invert="1" />
    <PinCfg name="PGM" pin="4" invert="1" />
    <PinCfg name="CLK" pin="3" invert="1" />
    <PinCfg name="DOUT" pin="2" invert="1" />
    <PinCfg name="DIN" pin="10" invert="1" />
</PgmIf>

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 <PgmIf name> et en modifiant  la propriété invert des balises <PinCfg> CLK, DOUT, DIN. Attention à ne pas modifier la description du « TAIT classic ».

<PgmIf name="Tait Classic PIC Programmer" typ="HVP" connection="LPT">
    <PinCfg name="MCLR" pin="4" invert="1" />
    <PinCfg name="PGM" pin="5" invert="1" />
    <PinCfg name="CLK" pin="3" invert="0" />
    <PinCfg name="DOUT" pin="2" invert="0" />
    <PinCfg name="DIN" pin="10" invert="0" />
</PgmIf>

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

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