Accueil Radioamateur EXCITER pour DRAKE R4C

EXCITER pour DRAKE R4C

0
0
56

Exciter 000

L’idée :

Bernard, F6BLK qui suit mes travaux depuis de nombreuses années m’a suggéré un jour de réfléchir à un complément du récepteur DRAKE R4C pour en faire un émetteur-récepteur.
Le  R4C est vraiment un excellent récepteur malgré son âge et il tient la  comparaison avec bien des plus modernes. Son présélecteur et son pass-band tuning sont absolument époustouflants ainsi que les filtres à quartz FI – 125, 250, 500 Hz – qui garantissent ainsi une qualité de réception exceptionnelle.
L’idée de lui adjoindre un module émission moderne tout en profitant de la technologie actuelle pour simplifier la couverture en fréquence m’a séduit et nous avons foncé têtes baissées dans cette aventure…!
Aventure s’il  en est car depuis bien des années, j’ai laissé de côté les  tubes et les tensions  associées pour me consacrer aux  PIC, Arduino et autres micro-contrôleurs… !
D’un commun accord et naturellement, nous avons nommé ce projet « Exciter R4C ».

Le cahier des charges :

Partie réception :
- Suppression des quartz pour la réception des bandes amateurs
- Couverture générale (toutes les bandes sont couvertes de 1,8 à 30 MHz, y compris le 5 MHz)
- Affichage  de la fréquence sur LCD
- Sélection de la bande et du pas d’incrémentation
- Mode SPLIT
- Mode CW seulement

Partie émission :
- Amplificateur de 15W environ
- Mode CW seul
- Full  Break-in (délai réglable)
- Side-tone intégré

Suppression des quartz du récepteur R4C :

L’examen du schéma met en évidence un connecteur en face arrière nommé « INJ » J7 qui permet d’accéder au premier mélangeur V2.
L’injection direct d’un signal à  cet endroit  permet alors de s’affranchir du pré-mixer V6,  de l’oscillateur Q12 et des quartz associés.
La fréquence du signal injecté devra permettre son amplification par la  chaine FI à 5645 KHz, en d’autre terme, la fréquence de l’injection sera égale   à la  fréquence de réception + 5645 kHz.

Injection

L’Oscillateur :

Le choix est maintenant vaste : DDS, PLL….et le Si5351 a été rapidement retenu car sa mise en œuvre est très simple et son coût plus qu’abordable.
La plupart des modules se commandent par une interface I2C, 3 sorties indépendantes en fréquence et en niveau sont disponibles.

IMG_6712

Le contrôleur :
Le nombre limité d’entrées / sorties  nous a fait choisir l’Arduino NANO,  une valeur sûre  facile à mettre en œuvre.

L’affichage :

L’affichage est confié à un LCD 4 X 20 équipé d’une interface I2C réduisant le nombre de fils et simplifiant le  câblage  associé.

La carte contrôleur :

C’est la carte qui regroupe les éléments décrits ci-avant et qui va permettre d’interfacer l’Exciter au récepteur.
Le  schéma est le suivant :

Carte Gestion_Réelle_020

fichier pdf Carte Gestion_Réelle_020

Quelques particularités :

La commande de MUTE :

La fonction MUTE permet la désensibilisation du récepteur lors du passage en émission. Le connecteur MUTE situé en face arrière est court-circuité par défaut et on peut mesurer une tension continue de -70V court-circuit enlevé et récepteur inhibé. Cette tension est appliqué aux circuits du CAG.

MUTE
Il sera donc nécessaire d’appliquer une tension nulle dans le mode réception (Rx) et une tension de -70V en émission (Tx).
La  manipulation de tensions aussi élevées dans un environnement « 5V » n’est pas sans poser quelques difficultés.
La commutation MUTE est assurée par un MOSFET canal P (Q1)  IRFP5210 dont la gate reçoit 0 ou -5V en fonction du mode Rx/Tx.
La génération du -5V est  confié à un convertisseur DC/DC MAX889 (U8) qui possède une entrée  SHDN (Shut Down)  qui va permettre d’appliquer le -5V au MOSFET par une commande 0/5V de l’Arduino au rythme du signal COM issu du PTT.

La commande de polarisation du PA :

Les différents étages du  PA sont alimentés en permanence en +12 et un MOSFET IRF5210 (Q2) commandé par Q3 (2N7000) permet d’appliquer le +12V a l’entrée polarisation du PA au rythme  du signal  COM issu du PTT autorisant alors l’émission.

Réglage de la puissance émission :

Une simple diode PIN en série avec la sortie émission du Si5351 permet le réglage de la puissance d’émission par un potentiomètre en face avant.

Le  délai QSK :

Le  signal  issu du keyer n’est pas directement exploitable  pour le full break-in car il est nécessaire de créer un signal « enveloppe » correspondant à l’envoi de plusieurs points au traits avant de rebasculer en réception.
Un monostable CD4098 (U5 :A) assure cette fonction tout en autorisant le  réglage du délai. Le signal issu de U5 est appliqué à l’Arduino pour la commutation Rx/Tx des différents étages.

Le Side-tone :

Bien que la plupart des keyers soient équipés d’un side-tone, la note audio générée fait plus penser à un cri de goret  qu’à une sinusoïde.. ! Un oscillateur pont de Wien a été utilisé pour générer l’audio, un amplificateur à LM386 et un petit haut-parleur complètent le circuit.

Commutation émission/réception :

La présence de tension élevées dans le R4C(+150V) a rapidement été exploitée pour réaliser un circuit permettant le full break-in et baptisé cellule T/R. Aucun relais n’est utilisé, seuls des MOSFET et des diodes 1N4007 assurent la commutation émission / réception.
La puissance maximale du PA étant de 25W, ceci correspond à une centaine de volts crête/crête et la tension de 150V est suffisante pour bloquer les diodes. Les diodes utilisées sont des diodes redresseuses classiques.
Le schéma ci-dessous est très largement inspiré de la description de WA5BDU :

TR Final

fichier pdf TR Final

001

L’amplificateur linéaire :

Il  utilise le très répandu schéma de G6ALU à base de MOSFET HF :

G6ALU_PA

La sensibilité permet d’utiliser directement une des sorties du Si5351;  la puissance est de l’ordre de 10 à 25W  sous 12V en fonction de la bande en service.
Le  module existait et a été réutilisé d’une réalisation précédente.

 

AR PA 2

Les filtres passe-bas :

Indispensables pour réduire les harmoniques du PA, le  pack de filtres passe-bas est commandé par la carte contrôleur. 4 fils suffisent pour commander les 6 filtres grâce à un circuit de décodage intégré. L’alimentation est en +5V.

Le   logiciel :

La boucle du programme scrute en permanence les poussoirs, l’encodeur et le keyer et active les modules correspondants.
La commande des filtres est liée à la bande en service.
La difficulté principale a été la mise au point de la partie SPLIT.
Le  niveau de chacune des trois sorties du Si5351 est  réglable mais n’a pas été implémenté pour un réglage par l’opérateur. Si nécessaire, il  conviendra de modifier le programme.

L’intégration :

L’intégration d’un tel nombre de modules dans un boîtier n’est pas sans poser quelques difficultés. Il faut autant que possible  conserver un accès facile à chacun des modules pour une éventuelle mise au point,  ce qui n’est pas toujours très aisé.

Dos face avant 0 1_chantier 01P1130269Exciter 000
Il sera donc prudent de valider le fonctionnement de chacun des modules avant de les installer dans le  boîtier. Quelques itérations, parfois accompagnées de modifications ont été nécessaire pour achever à distance ce projet. La plupart des broches du nano ont du être découplées car malgré la puissance réduite du PA,  l’Arduino resettait à partir  de 18MHz.
A l’usage, le récepteur R-4C se comporte parfaitement bien, la précision de l’affichage est parfaite, l’utilisation du double VFO est d’une grande souplesse. Bref, l’utilisation est particulièrement agréable et a déjà permis de nombreuses liaisons.
Gérard F6EHJ & Bernard F6BLK

 

Le programme :

//**************************************************************************

// *************************** EXCITER R4C**********************************

//**************************************************************************
// L’EXCITER R4C est un module qui permet le remplacement des quartz du DRAKE R4C
// et couvrir ainsi toutes les bandes de 1.8 à 30 MHz.
// Par ailleurs,un exciter suivi d’un PA et des filtres passe-bas associés,
// constitue la partie émission.
// Lorsque les deux  oscillateurs – réception et émission – sont couplés,
// le fonctionnement s’apparente à un transceiver classique où une variation
// de la fréquence de réception entraine la même variation de la fréquence d’émission.
// En mode « SPLIT »,les oscillateurs réception et émission sont distincts, la sélection
// du VFO actif devant être effectuée.
//
// L’ensemble est piloté par un arduino NANO.
// Il prend en charge l’afficheur LCD 4×20 et les poussoirs
// PAS,BANDES+ (UP), BANDES- (DWN), SPLIT, et VFO A/B.
// Un réglage de la puissance de sortie du PA est disponible en face avant.

// Les sorties du Si5351 attaque respectivement l’injection et le PA. Cette dernière sortie
// est à niveau variable via une diode PIN et un potentiomètre accessible à l’utilisateur.
// L’alimentation +5 pour le Si5351 est obtenue par un convertisseur DC/DC 12/5V

//**************************************************************************
// Version V01 : Ajout mémorisation dernière bande utilisée.
//**************************************************************************
// Version V02 du 18/03/2020 : Ajout de la bande 60m
//**************************************************************************
// Version V10 du 21/03/2020 : Modification (profonde) pour prise en compte
//  Mode Tx multibandes.
//**************************************************************************
// Version V11 du 23/03/2020 :
// Introduction interruption
// Utilisation LCD avec interface I2C
// Changement routine encodeur
// Implémentation SPLIT et double VFO
// Prise en compte platine filtres passe-bas Kiev
// Portage sous Arduino MEGA PRO
// Suppression circuits hard commande de filtres PA
//**************************************************************************
// Retour sous Arduino NANO
// Adoption du Si5351 en remplacement de la platine AD9850
//**************************************************************************
// Version EXCITER R4C_01 du 02/04/2020 :
// Premiers essais avec hardware réel
// Inversion de la sortie COM suie à interruption
// Ajout synchronisation des fréquences en mode SPLIT suite à changement de bande
// Mise à jour des différents flags
// Il subsiste une anomalie à la mise en marche en ce qui concerne la fréquence
// INIT qui est décalée de -pas
// Ceci est du à la boucle ENCODE.
// Sachant qu’au prochain changement de bande,la fréquence INIT est correcte,
// Cette anomalie a été laissée dans l’état.
// Dans la configuration 8MA,la puissance de sortie sur la voie TX est de +10dBm
// et de +11,5dBm à 12,5dBm sur la voie RX.
// La puissance minimale par potentiomètre est de -20dBm.
//**************************************************************************
// 04/04/2020 – Pas de changement de version.(Covid 19)
// Modification hardware du monostable U5 par utilisation de l’entrée -T
// enlieu et place de l’entrée +T. La configuration initiale générant un pulse
// sur le front montant.
// Modification ISR correspondante par inversion du signal COM
// LM386 audio validé. Elimination du claquement de commutation par ajout
// 100uF sur ligne +8V d’alimentation de l’oscillateur side-tone (sortie Q9).
//  06/04/2020
// Modification de la fonction TUNE par utilisation de D4 connectée sur le poussoir.
// La mise à 0 de D4 active le signal COM pour le TUNE.
//**************************************************************************
//R4C_02 du 07/04/2020 (Covid 19)…!
// Après pas mal de déboires avec l’utilisation des interruptions pour le keyer,
// une scrutation « classique » a été choisie.
// Ajout de l’affichage Rx/RX sur LCD
// Finition affaichage LCD
// Suppression du pas 2Hz
//**************************************************************************

//R4C_b01 du 19/05/2020 (pseudo-déconfinement! ça craint)
// pagaille chez les poussoirs Pas, Up, Down.
// On fait le ménage en redéfinissant ces trois variables qui deviennent :
// int poussoir Pas = 5; int poussoir Bande_UP = 7; int poussoir Bande_DWN = 6;
// modifications des lignes 154 à 159
//**************************************************************************
//R4C_OP_10 du 27/06/2020
// Introduction commutation sortie Ck_11 du SI5351
// La sortie Ck_1 qui est la sortie Tx, n’est activée qu’en mode Tx
//**************************************************************************
//R4C_OP_30 du 28/06/2020
//Prise en compte du signal KEYER sur l’entrée D3 afin de passer en émission
// avec ce signal.
// L’émission est réalisée par génération du signal CK_1 du Si5351
//Vers le PA ainsi que de la génération du signal COM activant les circuits
//de BIAS PA, MUTE et CELLULE TR
//**************************************************************************
//R4C_OP_40 du 29/06/2020
//Nettoyage code et variables
//Ajout commentaires
//**************************************************************************
// R4C_OP_41_b Reprise modifications des poussoirs 29/06/2020. v41b

//**************************************************************************
// Si5351
#include « si5351.h »
#define ref_osc_freq 12000000ULL // Il s’agit de la fréquence de l’oscillateur embarqué
// sur le module Si5351
#define corr +17000ULL // Il s’agit d’une correction de la fréquence de sortie (étalonnage)
Si5351 si5351;
//On ne déclare pas l’adresse I2C qui est définie dans la bibliothèque et égale à 0×60
//I2C
#include <Wire.h> // lib I2C pour l’afficheur LCD et le Si5351

//EPROM pour mémorisation bande courante
#include <EEPROM.h>

// LCD I2C
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0×27, 20, 4);// Adresse I2C 0×27 , 20 colonnes et 4 lignes
//**************************************************************************

//**************************************************************************
//Definition variables globales

unsigned long currentmilli = 0;// compteur timer
unsigned long previousmilli = 0;// compteur timer
unsigned long LD;//Mot de chargement du Si5351 en 1/100 Hz
unsigned long LD_R;
unsigned long LD_T;
long F_RX;  // Fréquence de réception en Hz
long F_TX;  // Fréquence d’émission en Hz
int PAS;//Valeur max 10000Hz
byte pas;//Valeur max 5
byte NRBANDE = 1;//Valeur max 11
byte ones, tens, hundreds, thousands, tenthousands, hundredthousands, millions ;
byte flag_split;//Valeur 0 ou 1
byte var_split;//Valeur max 2
byte var_VFO;// Valeur max 2
byte flag_VFO;//Valeur 0 ou 1
byte z = LOW;// 0 ou 1
byte encoder1PinALast = LOW;// 0 ou 1
//**************************************************************************
// Nouvelle définition des poussoirs
int poussoirPas = 5;
int poussoirBande_UP = 7;
int poussoirBande_DWN = 6;
int poussoirSplit = 9;
int poussoirVfo = 10;
int poussoirTune = 4;

//Sortie COM (Commutation Tx)
int COM = 8;

// Entrée INT
int INT = 2;

// Entrée KEYER
int KEY = 3;

//Encodeur
int encoder1PinB = 11;
int encoder1PinA = 12;

// Commande filtres PA
int OUT_A = A3;
int OUT_B = A2;
int OUT_C = A1;
int OUT_D = A0;
//***************************************************************
void setup()
{
Serial.begin(9600);
Wire.begin();
lcd.init();
lcd.backlight();
delay(100);

// INIT Si5351

// Ajuster « corr » si nécessaire à la ligne 75 pour caler la fréquence
si5351.init(SI5351_CRYSTAL_LOAD_8PF, ref_osc_freq, corr);//transmission des paramètres
// à destination du Si5351 zet particulièrement la fréquence de l’oscillateur et
// la correction de fréquence définies aux lignes 85 et 87

//Réglage des niveaux de sortie du Si5351 :
// 4 réglages sont possibles : 2, 4, 6 et 8mA
// correspondant à un maximum de 10dB de variation
// 2mA=3dBm
// 4mA=9dBm
// 6mA=11dBm
// 8mA=12dBm
// Attention à mA qui s’écrit ici MA

//Pour l’émission le niveau 3dBm (2MA) est suffisant pour le PA
si5351.drive_strength(SI5351_CLK0, SI5351_DRIVE_8MA); //CLK0 = Injection R4C (shift 5645kHz)
si5351.drive_strength(SI5351_CLK1, SI5351_DRIVE_2MA); //CLK1 = Signal Émission vers PA
//—————————————————————-
//  PIN DIVERSES -
pinMode(COM, OUTPUT);// Commande TX
pinMode(KEY, INPUT);// Entrée KEYER (pas de pullup car assuré par R9 de U5:A)
pinMode(INT, INPUT);// Entrée issue de U5 pas de pull-up
pinMode(OUT_A, OUTPUT);
pinMode(OUT_B, OUTPUT);
pinMode(OUT_C, OUTPUT);
pinMode(OUT_D, OUTPUT);
//—————————————————————-
//  PIN ENCODER – Toutes les pin sont en entrée avec PULL UP
pinMode (encoder1PinA, INPUT_PULLUP);// pull-up même si encodeur allimenté (à contrôler)
pinMode (encoder1PinB, INPUT_PULLUP);// pull-up même si encodeur allimenté (à contrôler)
//—————————————————————-
//  PIN POUSSOIRS  – Toutes les pins sont en entrée avec PULL UP
pinMode (poussoirPas, INPUT_PULLUP);
pinMode (poussoirBande_UP, INPUT_PULLUP);
pinMode (poussoirBande_DWN, INPUT_PULLUP);
pinMode (poussoirSplit, INPUT_PULLUP);
pinMode (poussoirVfo, INPUT_PULLUP);
pinMode (poussoirTune, INPUT_PULLUP);
//****************************************************************
//Message d’accueil
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(« ******************** »);
lcd.setCursor(0, 3);
lcd.print(« ******************** »);
lcd.setCursor(5, 1);
lcd.print(« F6EHJ »);
lcd.setCursor(4, 2);
lcd.print(« v.41b 04/2020″);
delay(2000);
lcd.clear();
lcd.setCursor(7, 2);
lcd.print(« Pas= »);
lcd.setCursor(0, 3);
lcd.print(« R-4C Exciter   F6BLK »);
//——————————————————————
//VALEURS INIT
//  NRBANDE = 3; // bande 5,500 kHz
//  EEPROM.put(0, NRBANDE);// à utiliser pour l’INIT d’un Arduino
// décommenter ces deux ligne si la fréquence affichéee =00000.00
// lors du premier téléchargement de l’Arduino. Dans ce cas, l’EEPROM est vide
// Ce qui est normal.
// L’affichage et la sélection de la fréquence lors de la mise sous tension est réalisée
// par la lecture de l’EEPROM qui contient le N° de bande.
// Cette valeur est mémorisée par écriture dans l’EEPROM à chaque changement de bande
// dans les modules MBANDE_UP et MBANDE_DWN
NRBANDE = EEPROM.read(0);// Lecture du N° de bande dans l’EEPROM
NRBAND(); // charge la bande
pas = 3; // pas 100Hz
pasSelect(); // charge le pas

}
//************************************************************************

//************************************************************************
// On scrute en permanence si les poussoirs  ont été actionnés
//et si l’encodeur a été manœuvré.
//On scrute également si le keyer est activé pour passer en émission

void loop()
{

currentmilli = millis();
// la fonction millis, permet d’introduire un délai SANS que
// le déroulement du programme ne s’arrête, contrairement à l’instruction DELAY.
//————————————————————————
ENCODE();// On scrute l’encodeur à chaque tour de boucle
//————————————————————————

// Traitement du signal KEYER
// C’est le signal KEYER qui va déclencher l’émission au rythme de la manipulation
// Le déclenchement de l’émission s’effectue en deux temps :
// Le keyer génère un front HAUT en sortie de U5 (INT) qui est appliqué en D2
// Au reçu de ce front, le signal COM est généré (lignes 290 à 295)et les circuits d’émission (BIAS PA, MUTE, Cellule TR) sont activés.
// Simultanément, la descente du signal KEYER appliqué en D3 va déclencher la génération du signal émission Ck_1 du Si5351.
// Ce signal ne sera généré que pendant la durée de D3 à l’état bas, c’est à dire au rythme des points et traits du KEYER.
// Lorsque le signal KEYER revient à l’état haut pendant « un certain temps » défini par le pot « délay QSK »,
//Le signal INT revient à zéro entraînant la descente de COM et l’arrêt des circuits d’émission.
//En résumé, le signal COM « enveloppe » les traits et points émis par le KEYER.
//Le Si5351 émission (CK_1) est activé au rythme des points et des traits alors que les circuits d’émission sont activés pendant
//et ENTRE les points et les traits et même un petit peu de temps après en fonction du delay QSK.
// OUF…!

if (digitalRead(KEY) == LOW)// keyer actif par front bas en D3 ?
{
si5351.output_enable(SI5351_CLK1, 1);// OUI, on active la sortie CK_1 du Si5351
}
else
{
si5351.output_enable(SI5351_CLK1, 0);// NON, on inhibe la sortie CK_1 du Si5351
}

// Traitement du signal INT

if (digitalRead(INT) == HIGH)// Le signal KEYER a fait monter le signal INT
{
digitalWrite(COM, HIGH);// On active les circuits émission (MUTE, BIAS et CELLUEL TR)
}
// SI INT==LOW on rest en réception (implicitement sans ELSE).
//————————————————————————
// On scrute les poussoirs tous les 200ms pour économiser la ressource CPU
//Car on n’est pas vraiment pressé pour scruter.

if ((currentmilli – previousmilli) >= 200)
{
MBANDE_UP();
MBANDE_DWN();
SPLIT();
VFO();
MPAS();
TUNE();

// On change l’affichage Tx/Rx toutes les 200ms également
if (digitalRead(COM) == HIGH)
{
lcd.setCursor(18, 2);
lcd.print(« Tx »);
}
else
{
lcd.setCursor(18, 2);
lcd.print(« Rx »);

}
previousmilli = millis();
}
}
//******************************************************************
// **********************  Fonctions  *******************************
//********************************************************************
//Scrutation encodeur
//—————————————————————————
// ON utilise deux modules distincts pour la scrutation de l’encodeur :
// Un pour le VFO de réception et l’autre pour le VFO d’émission
// En mode SPLIT, on affiche la fréquence d’émission sous la fréquence
// de réception.
// Il est alors possible de sélectionner le VFO actif et de faire varier
// sa fréquence à l’aide de l’encodeur.

//—————————————————————————
void ENCODE()// On sélectionne quel VFO doit être activé.
{
if (flag_split == 1)
{
if (flag_VFO == 1)
{
ENCODE_1();
}
if (flag_VFO == 0)
{
ENCODE_0();
}
}
else
{
ENCODE_0();
}
}
//******************************************************************
// L’incrémentation ou la décrémentation unitaire de la fréquence est égale au PAS
void ENCODE_0()// VFO RX (A)
{
z = digitalRead(encoder1PinA);
if ((encoder1PinALast == LOW) && (z == HIGH)) {
if (digitalRead(encoder1PinB) == LOW) {
F_RX = F_RX + PAS;
FTW_DDS_R();

} else {
F_RX = F_RX – PAS;
FTW_DDS_R();
}
}
encoder1PinALast = z;
}

//—————————————————————————
void ENCODE_1()// VFO TX (B)
{
z = digitalRead(encoder1PinA);
if ((encoder1PinALast == LOW) && (z == HIGH)) {
if (digitalRead(encoder1PinB) == LOW) {
F_TX = F_TX + PAS;
FTW_DDS_T();

} else {
F_TX = F_TX – PAS;
FTW_DDS_T();
}
}
encoder1PinALast = z;
}

//*************************************************************************
// Scrutation Poussoirs
//*************************************************************************
// Poussoir SPLIT

//Le poussoir SPLIT étant fugitif et unique, à chaque pression sur le poussoir,
//il faut changfer d’état.
// L’état courant est mémorisé dans les variables var_split et flag_split
// à chaque appui sur le poussoir, on incrémente la varaible var_split
// si elle avait la valeur 1, sa valeur devient 2 et dans ce cas, on met
//les variables var_split et flag_split à 0
//Si elle avait la valeur 0, sa valeur devient 1 et dans ce cas on positionne
//les deux variables à 1
//A la prochaine pression sur le poussoir on se retrouve dans un des deux cas
//qui inverse les valeurs courantes quelques soient ces valeurs.
//Les opérations complémentaires réalisées dans ce module sont :
// Mise à jour du LCD par affichage ou effacement de la seconde ligne
//contenant la fréquence d’émission
//Mise a égalité des fréquences émission et réception
//Chargement de la fréquence de réception dans le SI5351 émission
//quand on quitte le SPLIT

void SPLIT()
{
if (digitalRead(poussoirSplit) == LOW)
{
var_split++;

if (var_split == 2)
{
var_split = 0;
flag_split = 0;
lcd.setCursor(0, 1);
lcd.print(«                  « );
F_TX = F_RX;
FTW_DDS_T();
}
else
{
var_split = 1;
flag_split = 1;
F_TX = F_RX;
showFreqT();
lcd.setCursor(0, 0);
lcd.print(«   « );
lcd.setCursor(0, 0);
lcd.print(« -> »);
}
}
}
//————————————————————————–
// Poussoir VFO A/B
//Il s’agit de comander la fréquence d’émission OU la fréquence de réception avec l’encodeur
//Cette fonction ne fonctionne qu »en mode SPLIT, c’est d’ailleurs la première chose que l’on teste
//via l’état de flag_split qui est mis à jour dans le module SPLIT
//La technique de gestion est identique au module SPLIT
//On utilise les deux variables var_VFO et flag_VFO.
//Dans un cas on utilise le VFO Rx (FTW_DDS_R) et dans l’autre le VFO Tx (FTW_DDS_T)

void VFO()
{
if (flag_split == 1)
{
if (digitalRead(poussoirVfo) == LOW)
{
var_VFO++;
if (var_VFO == 2)
{

var_VFO = 0;
flag_VFO = 0;
lcd.setCursor(0, 1);
lcd.print(«   « );
lcd.setCursor(0, 0);
lcd.print(« -> »);
FTW_DDS_R();
}
else
{
var_VFO = 1;
flag_VFO = 1;
lcd.setCursor(0, 0);
lcd.print(«   « );
lcd.setCursor(0, 1);
lcd.print(« -> »);
FTW_DDS_T();
}
}
}
}
//————————————————————————–
// Poussoir BANDE
// Dans ces deux S/P on va tester les butées maxi (10) et mini (1) correspondant au numéro de bande
// La bande sélectionnée est mémorisée en EEPROM
void MBANDE_UP()
{
if (digitalRead(poussoirBande_UP) == LOW)//si le poussoir es pressé
{
NRBANDE++;
delay(200);
if (NRBANDE < 11)// tant que la bande 10 n’est pas atteint (<11)
{
NRBAND();// on appelle le sous-programme de changement de bande
EEPROM.put(0, NRBANDE);//Ecriture EEPROM
delay(100);
}
else
{
NRBANDE = 10;// si on a atteint la bande 10, on reste sur la bande 10
EEPROM.put(0, NRBANDE);//on méméorise la bande en EEPROM (pas forcément indispensable ici)
delay(100);

}
}
//si le poussoir n’est pas pressé on ne fait rien….
}
//————————————————————————–
void MBANDE_DWN()
{
if (digitalRead(poussoirBande_DWN) == LOW)
{
NRBANDE–;
if (NRBANDE == 0)
{
NRBANDE = 1;
EEPROM.put(0, NRBANDE);
delay(200);
}
else
{

NRBAND();
EEPROM.put(0, NRBANDE);
delay(200);
}
}
}
//*************************************************************************
//Changement de bande
//Cette fonction est appelée suite à  pression sur les bouton poussoir BANDE UP/DWN
//et valeur du compteur NRBANDE associé
// Le pack de filtre attend une information codée sur 4 bits afin de sélctionner
// le filtre requis.
// Avant tout changement de filtre, on fera une remise à zéro de tous les relais
// Le S/P se borne à positionner le bon état ‘HIGH’ ou ‘LOW’) sur chacune des sorties
// OUT_A à OUT_D (4 sorties)
// Chaque n° de bande détermine la fréquence INIT (début de bande par exemple)
// Cette fréquence est chargée à la fois dans le VFO de réception et d’émission.

void NRBAND()
{
digitalWrite(OUT_A, 0);// Remise à 0 des relais filtres
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 0);

switch (NRBANDE)

{
case 1:
F_RX = 1800000; // Fréquence début de bande exprimée en Hz
FTW_DDS_R();// chargement  VFO Rx
F_TX = F_RX;// égalité des fréquence Rx et TX quand on change de bande
FTW_DDS_T();// chargement VFO Tx
digitalWrite(OUT_A, 1);// Activation des relais correspondants au filtre actif
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 0);

break;

case 2:
F_RX = 3500000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 0);
digitalWrite(OUT_B, 1);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 0);

break;

case 3:
F_RX = 5351500;// Le filtre pour la bande 5.5 est le filtre 7MHz
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 1);
digitalWrite(OUT_B, 1);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 0);

break;

case 4:
F_RX = 7000000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 1);
digitalWrite(OUT_B, 1);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 0);

break;

case 5:
F_RX = 10100000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 0);
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 1);
digitalWrite(OUT_D, 0);

break;

case 6:
F_RX = 14000000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 1);
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 1);
digitalWrite(OUT_D, 0);

break;

case 7:
F_RX = 18068000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 0);
digitalWrite(OUT_B, 1);
digitalWrite(OUT_C, 1);
digitalWrite(OUT_D, 0);

break;

case 8:
F_RX = 21000000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 1);
digitalWrite(OUT_B, 1);
digitalWrite(OUT_C, 1);
digitalWrite(OUT_D, 0);

break;

case 9:
F_RX = 24900000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 0);
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 1);

break;

case 10:
F_RX = 28000000;
FTW_DDS_R();
F_TX = F_RX;
FTW_DDS_T();
digitalWrite(OUT_A, 1);
digitalWrite(OUT_B, 0);
digitalWrite(OUT_C, 0);
digitalWrite(OUT_D, 1);

break;
}
}
//————————————————————————–
//Pousoir PAS
// Un seul poussoir pour le changement de pas impose un buffer circulaire

void MPAS()
{

if (digitalRead(poussoirPas) == LOW)// si le poussoir est pressé
{

pas++;// on incrémente pas courant
delay(200);
if (pas == 5)// la pas courant était = à 4 et on avait attent le dernier pas
{
pas = 1;// en conséquence, on remet le pas à 1
delay(200);
pasSelect();// on va afficher et charger le 1er pas
}
else
{
pasSelect();// on n’était pas au pas 4 et on va afficher et charger le pas correspondant
}
}
}
//——————————————————–
// SELECTION DU PAS ET AFFICHAGE SUR LCD
//La variable PAS peut prendre une valeur = 10000 et sera donc une INT
void pasSelect()
{
//Pas 1Hz
switch (pas)//Instruction switch / case équivalente à if
{
//——————————————————–
// Pas 10Hz
case 1:

PAS = 10;// c’est la valeur en Hz du pas d’incrémentation
// cette valeur est transmises aux modules ENCODE
lcd.setCursor(11, 2);// mise à jour de l’affichage LCD
lcd.print(«     « );
lcd.setCursor(14, 2);
lcd.print(« Hz »);
lcd.setCursor(12, 2);
lcd.print(PAS);
break;

//——————————————————–
// Pas 100Hz
case 2:

PAS = 100;
lcd.setCursor(11, 2);
lcd.print(«     « );
lcd.setCursor(14, 2);
lcd.print(« Hz »);
lcd.setCursor(11, 2);
lcd.print(PAS);
break;

//——————————————————–
//      Pas 1kHz
case 3:

PAS = 1000;
lcd.setCursor(13, 2);// il y a des petites différences
//entre l’affichage des Hz et des kHz
lcd.print(« kHz »);
lcd.setCursor(11, 2);
lcd.print( » 1″);
break;

//——————————————————–
//      Pas 10kHz
case 4:

PAS = 10000;
lcd.setCursor(12, 2);

lcd.print( » « );
lcd.setCursor(11, 2);
lcd.print(« 10″);
lcd.setCursor(13, 2);
lcd.print(« kHz »);
break;
}
}

//———————————————————————
//Calcul FTW ET CHARGEMENT Si5351
//——————————————————————–
void FTW_DDS_R()
{
showFreqR();// Affiche la fréquence sur le LCD

LD_R = (F_RX + 5645600) * 100;
// LD_R est la valeur qui sera chargée dans le Si5351, elle est exprimée en 1/100 de Hz
// d’ou le multiplicateur x100
// La valeur F_RX est issue du module NRBAND.
// A cette valeur est ajoutée la valeur de la fréquence FI du R4C (5645600Hz)
// Ceci uniquement pour la réception.
// Cette valeur pourra être ajustée en fonction des résultats obtenus.

load_R();// chargement du Si5351 Rx
}
//——————————————————————–
void FTW_DDS_T()
// Le Si5351 utilise la sortie CLK0 pour la réception (injection R4C) et la sortie CLK1
// pour l’émission

{
LD_T = (F_TX * 100);// pas de décalage car TX direct
load_T();
if (flag_split == 1)
showFreqT();// Affiche la fréquence sur le LCD
}
//——————————————————————–
void load_R()
{
si5351.set_freq(LD_R, SI5351_CLK0);
}

//——————————————————————–
void load_T()
{
si5351.set_freq(LD_T, SI5351_CLK1);
}
//********************************************************************************************
// AFFICHE LA FREQUENCE SUR LE LCD

void showFreqR()
{

millions = int(F_RX / 1000000);
hundredthousands = ((F_RX / 100000) % 10);
tenthousands = ((F_RX / 10000) % 10);
thousands = ((F_RX / 1000) % 10);
hundreds = ((F_RX / 100) % 10);
tens = ((F_RX / 10) % 10);
ones = ((F_RX / 1) % 10);

if (millions > 9)
{
lcd.setCursor(3, 0);
}
else {
lcd.setCursor(3, 0);
lcd.print( » « );
lcd.setCursor(4, 0);
}
lcd.print(millions);
lcd.print(« . »);
lcd.print(hundredthousands);
lcd.print(tenthousands);
lcd.print(thousands);
lcd.print(« . »);
lcd.print(hundreds);
lcd.print(tens);
lcd.print(ones);
lcd.print( » MHz  « );
}

void showFreqT()
{

millions = int(F_TX / 1000000);
hundredthousands = ((F_TX / 100000) % 10);
tenthousands = ((F_TX / 10000) % 10);
thousands = ((F_TX / 1000) % 10);
hundreds = ((F_TX / 100) % 10);
tens = ((F_TX / 10) % 10);
ones = ((F_TX / 1) % 10);

if (millions > 9) {
lcd.setCursor(3, 1);
}
else {
lcd.setCursor(4, 1);
}
lcd.print(millions);
lcd.print(« . »);
lcd.print(hundredthousands);
lcd.print(tenthousands);
lcd.print(thousands);
lcd.print(« . »);
lcd.print(hundreds);
lcd.print(tens);
lcd.print(ones);
lcd.print( » MHz  « );
}

//*************************************************************************
// Poussoir Tune
void TUNE()
{
if (digitalRead(INT) == LOW)
{
if (digitalRead(poussoirTune) == LOW)
{

digitalWrite(COM, HIGH);
}
else
{
digitalWrite(COM, LOW);

}
}
}
//******************************************************************************
//******************************************************************************

Charger d'autres articles liés
Charger d'autres écrits par f6ehj
Charger d'autres écrits dans Radioamateur

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

Consulter aussi

DRAKE TR7 : SIMPLIFICATION ET PANADAPTER

Le TR7 est un transceiver qui est sorti en 1976 et celui en ma possession porte le numéro …