vendredi, février 7, 2025
AntennesArduinoElectroniqueRéalisationsSatellites

Arduino et la radio : à la poursuite des satellites Version Site & Azimut.

Par Gilles F1EFW

Dans un premier temps voir où revoir le précédent article sur l’automatisation d’un rotor Azimut, c’est ICI

Pour ajouter un système d’élévation, nous allons seulement ajouter un rotor traversant (le mât traverse le rotor pour être retenu par une butée à bille) et 2 relais (AliExpress).

Voilà un modèle actuellement sur le bon coin (60€)

Les 2 rotors ont été entièrement démontés, nettoyés, graissés.
Dans les pupitres de commande, je me suis contenté de garder les transformateurs pour les moteurs et les condensateurs.
On va fixer le rotor d’élévation sur le rotor d’azimut avec une petite platine métallique, c’est tout pour la mécanique !

Pour l’électronique, on va câbler 2 relais supplémentaires (par rapport à la version précédente) pour piloter notre nouveau rotor.

Le boitier de commande : sur la gauche l’afficheur et les 2 transfos (les 2 moteurs n’ont pas les mêmes tensions d’alimentations), en haut à droite l’Arduino, en dessous les 4 relais (gauche / droite / haut / bas).

Vue du bornier de raccordement, 2 x 3 fils pour les moteurs, 2 x 3 fils pour les potentiomètres.

L’avant du boitier, juste un afficheur, la ligne du haut est la position envoyée par le logiciel de poursuite, la ligne du bas la position des antennes (en fait la lecture de la tension des potentiomètres)

Le programme est simplifié et documenté, il suffit de le recopier dans « L’IDE Arduino » et de le téléverser.

///////////////////////////////////////////////
// Pilotage rotor azimut à l'aide de WispDDE //
//          Gilles PLATRET F1EFW             //
///////////////////////////////////////////////

// On ajoute une librairie qui va nous aider pour l'affichage

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

// On déclare quelques variables A_ pour affichage 

String Lecture_Port_USB, A_AZI, A_ELE, A_Potar_Azi, A_Potar_Ele ;
int AZI, ELE, Potar_Azi, Potar_Ele;
int pin0 = A0,pin1 = A1 ;

// On initialise le programme 

void setup() {
  
  lcd.begin(16, 2);
  Serial.begin(9600); // vitesse avec le port de communication
  
// Les relais Azimut
  pinMode(5, OUTPUT); // relais 1
  pinMode(6, OUTPUT); // relais 2
  digitalWrite(5, HIGH); // relais au repos en effet ils sont inversés
  digitalWrite(6, HIGH); //  HIGH repos LOW travail

// Les relais Elevation
  pinMode(3, OUTPUT); // relais 1
  pinMode(4, OUTPUT); // relais 2
  digitalWrite(3, HIGH); // relais au repos en effet ils sont inversés
  digitalWrite(4, HIGH); //  HIGH repos LOW travail
  
  AZI=0,ELE=0;
}

// On commence à bosser 

void loop() 
{
  
// Lecture du port de communication.
// au format GS-232 -> ex W127 052
// on extrait les caractères 2a4 Azumuth et 5a8 Elevation (substring)
// et on les convertis en nombres (ToInt)
// On dispose de l'information sous format numérique pour les calculs
// et au format chaine de caractères pour l'affichage

  while(Serial.available()){
    Lecture_Port_USB = Serial.readString();
    
      A_AZI = (Lecture_Port_USB.substring(1, 4));
      A_ELE = (Lecture_Port_USB.substring(5, 8));

      AZI = (A_AZI.toInt());
      ELE = (A_ELE.toInt());
      

    lcd.setCursor(0, 0);
    lcd.print("SAT A:");
    lcd.print(A_AZI);
    lcd.print(" E:");     
    lcd.print(A_ELE);
  }
  
// fin de lecture du port USB

// Lecture du potar_Azumuth
// Potar_Azi varie de 0 a 1024 (0 quand il est à la masse et 1024 quand il reçoit 5V)
// pour convertir en degres on fera theoriquement 1024/360 = 2.84
// Mais pour moi le potar AZIMUT va de 74 à 1020 donc (1020-74)/360 = 2.62
// Le potar ELEVATION va de 780 a 1000 pour faire 90° donc (1000-780)/90 = 2.44

Potar_Azi =  ((analogRead(pin0)-74)/2.62);
Potar_Ele =  ((analogRead(pin1)-780)/2.44);


   lcd.setCursor(0, 1);
   lcd.print("ANT A:");
       
       // pour afficher le nombre sous la forme de 3 caractères
       // c'est pas très élégant .... je ferais mieux plus tard
       
       A_Potar_Azi = String(Potar_Azi);
         if (A_Potar_Azi.length() < 2) {
             A_Potar_Azi = ("00"+ A_Potar_Azi);
              }
              else {
               if (A_Potar_Azi.length() < 3) {
                A_Potar_Azi = ("0"+ A_Potar_Azi);
               }
               }
              lcd.print(A_Potar_Azi);

        A_Potar_Ele = String(Potar_Ele);
         if (A_Potar_Ele.length() < 2) {
             A_Potar_Ele = ("00"+ A_Potar_Ele);
              }
              else {
               if (A_Potar_Ele.length() < 3) {
                A_Potar_Ele = ("0"+ A_Potar_Ele);
               }
               }
              lcd.print(" E:");
              lcd.print(A_Potar_Ele);
           // lcd.print(analogRead(pin1));
                 
   // on ne corrige que tous les 4 degrés et si le satellite est visible (ELE>0)
   // donc si différence des valeurs > 4 on tourne dans un sens
   // si < 4 on tourne dans l'autre sens et si presque égale on stoppe 
   ////////////////////////  AZIMUT //////////////////////////////////////////

    if ((Potar_Azi > AZI)&&(abs(Potar_Azi - AZI)>4)&&(ELE>0)) {
             digitalWrite (5, HIGH);
             digitalWrite (6, LOW);
             }
    if ((Potar_Azi < AZI)&&(abs(Potar_Azi - AZI)>4)&&(ELE>0)) {
             digitalWrite (5, LOW);
             digitalWrite (6, HIGH);
             }
    if ((abs(Potar_Azi - AZI)<5)||(ELE<1)) {  // pour éviter des A/R moteur on peut jouer sur cette valeur
             digitalWrite (5, HIGH);
             digitalWrite (6, HIGH);
             delay (200);
             }

    ////////////////////////  ELEVATION //////////////////////////////////////////

     if ((Potar_Ele > ELE)&&(abs(Potar_Ele - ELE)>4)&&(ELE>0)) {
             digitalWrite (3, HIGH);
             digitalWrite (4, LOW);
             }
    if ((Potar_Ele < ELE)&&(abs(Potar_Ele - ELE)>4)&&(ELE>0)) {
             digitalWrite (3, LOW);
             digitalWrite (4, HIGH);
             }
    if ((abs(Potar_Ele - ELE)<5)||(ELE<1)) {  // pour éviter des A/R moteur on peut jouer sur cette valeur
             digitalWrite (3, HIGH);
             digitalWrite (4, HIGH);
             delay (200);
             }
    
}
     

Les aériens ont été fabriqués à partir de vieilles antennes endommagées, la VHF/144 est composée de 8 éléments, l’UHF/432 de 12 éléments, elles ont été recalculées et réglées pour les fréquences satellites (145.800 et 435/437Mhz).
Elles sont verticales pour simplifier le montage (voir vidéo)

Après quelques essais « au sol » le système a trouvé sa place sur le toit, dés le lendemain j’effectuais les tests réels.

Ci-dessous la vidéo des premiers QSO il y a 5 jours, depuis 8 satellites ont été utilisés (FM et SSB) dans d’excellentes conditions.
j’effectue émission / réception séparées (Simple clé SDR à 10€ et préampli à 5€ en RX), FT857 en TX, le tout est piloté par SDRConsole qui assure à la fois la réception avec correction doppler, l’affichage et la poursuite des satellites ainsi que la correction doppler à l’émission.

Coût de la réalisation, environ 100€, soit 2000€ de moins qu’une installation commerciale …

Toujours à votre disposition pour plus de renseignement, et rendez-vous sur les satellites défilants,
Gilles F1EFW / Formulaire de contact -> ICI

C’est (presque) Noël !