In questo progetto voglio realizzare un’interfaccia economica e modificabile per comandare il rotore Yaesu G-5500DC con Arduino e Gpredict, come alternativa a soluzioni commerciali già pronte come ERC-DUO o RTC-200.

L’obiettivo è creare un sistema in grado di gestire azimut ed elevazione per il tracking satellitare, mantenendo però la possibilità, a differenza di ERC-DUO o RTC-200, di modificare liberamente il firmware, aggiungere funzioni personalizzate, regolare la logica di movimento e adattare il progetto alle proprie esigenze.

Yaesu G-5500DC: progetto Arduino per tracking satellitare - Parte 3

Prima di passare al movimento automatico verso un target, è necessario calibrare le letture A0 e A1, trasformandole in gradi reali.

Nella fase precedente sono già stati verificati i collegamenti principali:

Il collegamento dei comandi è stato realizzato con un modulo PC817, usando Arduino per attivare i canali corrispondenti ai quattro movimenti del controller Yaesu.

Collegamenti Arduino Mega → modulo PC817

Collegamenti modulo PC817 → DIN 8 External Control Yaesu

Sul modulo PC817 usato in questa prova, le masse G del lato ingressi e del lato uscite risultano collegate tra loro. Questo significa che il modulo non lavora come isolamento galvanico completo, ma resta comunque utile come interfaccia di comando tra Arduino e il controller Yaesu.

Le due letture di posizione non passano dal PC817, ma vanno direttamente ad Arduino:

Il pin 7 del DIN 8 non deve essere collegato.

Calibrazione delle letture A0 e A1

A questo punto Arduino riesce a leggere i valori analogici provenienti dal controller Yaesu:

• Il pin 6 del DIN 8 fornisce il feedback dell’azimut verso A0.

• Il pin 1 del DIN 8 fornisce il feedback dell’elevazione verso A1.

• Il pin 8 del DIN 8 è la massa comune.

Per trasformare questi valori in gradi reali, è necessario eseguire una calibrazione manuale.

Il controller Yaesu deve essere acceso, la DIN 8 poli deve essere collegata alla presa External Control e Arduino deve essere collegato al PC via USB.

In Arduino IDE, cioè il programma Arduino aperto dal Desktop/Menu Start, caricare il seguente sketch nel file rotore_may15a.ino.

const int PIN_AZ = A0;
const int PIN_EL = A1;

int leggiMedia(int pin) {
  long somma = 0;

  for (int i = 0; i < 30; i++) {
    somma += analogRead(pin);
    delay(3);
  }

  return somma / 30;
}

void setup() {
  Serial.begin(9600);

  Serial.println("Calibrazione pronta.");
  Serial.println("Premere S nel Serial Monitor per stampare AZ/EL.");
}

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();

    if (c == 'S' || c == 's') {
      int az = leggiMedia(PIN_AZ);
      int el = leggiMedia(PIN_EL);

      float voltAz = az * (5.0 / 1023.0);
      float voltEl = el * (5.0 / 1023.0);

      Serial.print("AZ A0=");
      Serial.print(az);
      Serial.print(" Volt=");
      Serial.print(voltAz, 3);

      Serial.print("   |   EL A1=");
      Serial.print(el);
      Serial.print(" Volt=");
      Serial.println(voltEl, 3);
    }
  }
}

Dopo avere caricato lo sketch:

1. Aprire il Serial Monitor.

2. Impostare la velocità a 9600 baud.

3. Scrivere S nel campo di invio.

4. Premere Invia.

5. Annotare i valori mostrati per A0 e A1.

Posizioni da misurare

I valori riportati dal mio G-5500DC sono risultati molto lineari e permettono una prima conversione affidabile da lettura analogica a gradi.

Valori misurati

Useremo quindi questa calibrazione provvisoria:

const int AZ_RAW_MIN = 9;
const int AZ_RAW_MAX = 814;
const int EL_RAW_MIN = 5;
const int EL_RAW_MAX = 972;

La conversione in gradi sarà:

float azGradi = (rawAz - AZ_RAW_MIN) * 360.0 / (AZ_RAW_MAX - AZ_RAW_MIN);
float elGradi = (rawEl - EL_RAW_MIN) * 180.0 / (EL_RAW_MAX - EL_RAW_MIN);

Questa prima calibrazione permette di lavorare con:

Nota: il G-5500DC può arrivare anche a 450° in azimut. Se vogliamo sfruttare anche la zona oltre 360°, poi faremo una lettura aggiuntiva a 450°. Per il primo movimento automatico a target, però, possiamo partire tranquillamente con 0–360°.

Primo test dei quattro comandi

Dopo la calibrazione delle letture A0 e A1, ho verificato i quattro comandi principali del rotore direttamente dal Serial Monitor.

Questo test non esegue ancora il tracking automatico: serve solo a confermare che Arduino riesca ad attivare correttamente i comandi RIGHT, LEFT, UP e DOWN attraverso il modulo PC817 e la presa External Control del controller Yaesu.

Caricare questo sketch:

const int PIN_RIGHT = 8;
const int PIN_LEFT  = 9;
const int PIN_UP    = 10;
const int PIN_DOWN  = 11;

void setup() {
  Serial.begin(9600);

  pinMode(PIN_RIGHT, OUTPUT);
  pinMode(PIN_LEFT, OUTPUT);
  pinMode(PIN_UP, OUTPUT);
  pinMode(PIN_DOWN, OUTPUT);

  digitalWrite(PIN_RIGHT, LOW);
  digitalWrite(PIN_LEFT, LOW);
  digitalWrite(PIN_UP, LOW);
  digitalWrite(PIN_DOWN, LOW);

  Serial.println("Test comandi rotore pronto.");
  Serial.println("R = RIGHT, L = LEFT, U = UP, D = DOWN");
  Serial.println("Ogni comando dura 1 secondo.");
}

void loop() {
  if (Serial.available() > 0) {
    char comando = Serial.read();

    if (comando == 'R' || comando == 'r') {
      eseguiComando("RIGHT / CW", PIN_RIGHT);
    }

    if (comando == 'L' || comando == 'l') {
      eseguiComando("LEFT / CCW", PIN_LEFT);
    }

    if (comando == 'U' || comando == 'u') {
      eseguiComando("UP", PIN_UP);
    }

    if (comando == 'D' || comando == 'd') {
      eseguiComando("DOWN", PIN_DOWN);
    }
  }
}

void eseguiComando(const char* nome, int pin) {
  Serial.print(nome);
  Serial.println(" attivo per 1 secondo");

  digitalWrite(pin, HIGH);
  delay(1000);
  digitalWrite(pin, LOW);

  Serial.print(nome);
  Serial.println(" spento");
}

Procedura:

1. Caricare lo sketch con Arduino IDE → Sketch → Verify / Compile, poi premere Upload.

2. Aprire Tools → Serial Monitor a 9600 baud.

3. Inserire la DIN 8 poli nella presa External Control.

4. Accendere il controller Yaesu.

5. Scrivere una lettera alla volta nel Serial Monitor: R, L, U, D.

6. Premere Invia dopo ogni lettera.

Se tutto è corretto, il LED del canale corrispondente sul modulo PC817 si accende per circa 1 secondo e il rotore esegue il movimento richiesto.

Nel mio test tutti e quattro i comandi hanno funzionato correttamente.

A questo punto il sistema hardware può essere considerato operativo: Arduino legge azimut ed elevazione e può comandare tutti e quattro i movimenti del rotore.

Il passo successivo sarà scrivere il firmware di movimento automatico, cioè un programma capace di ricevere un target di azimut/elevazione, leggere la posizione reale e muovere il rotore fino al valore richiesto.

Preparazione per Gpredict e Hamlib

A questo punto l’hardware è stato verificato: Arduino legge azimut ed elevazione e può comandare i quattro movimenti del rotore.

Il passo successivo è fare in modo che Arduino risponda come una piccola interfaccia compatibile Yaesu GS-232B, così da poter essere usato da Hamlib e quindi da Gpredict.

La catena sarà:

Gpredict → rotctld / Hamlib → porta USB Arduino → Arduino Mega → PC817 → controller Yaesu G-5500DC

Prima di usare Gpredict, bisogna installare Hamlib sul PC e individuare la porta seriale assegnata ad Arduino, ad esempio COM5 su Windows.

Il comando di prova sarà simile a questo:

rotctld -m 603 -r COM5 -s 9600 -T 127.0.0.1 -t 4533 -vvvv

Dove COM5 deve essere sostituito con la porta reale di Arduino.

Solo dopo avere verificato che rotctld comunica correttamente con Arduino, si passerà alla configurazione di Gpredict, impostando:

Nella parte 4 verrà caricato su Arduino il firmware minimo compatibile con i comandi principali GS-232B.