// Bridge UART per lo scambio di dati tra
// RigExpert AA-30 ZERO antenna e analizzatore di cavi e Arduino Uno
//
// Riceve da Arduino, invia a AA-30 ZERO.
// Riceve da AA-30 ZERO, invia ad Arduino.
//
// 26 giugno 2017, Rig Expert Ukraine Ltd.
//
#include “SoftwareSerial.h”
#define RX0_Pin 0
#define TX0_Pin 1
#define RX1_Pin 4
#define TX1_Pin 7#define HW_SERIAL#ifndef HW_SERIAL
SoftwareSerial ZERO(RX1_Pin, TX1_Pin); //RX,TX
#endifvuoto impostare() {
#ifdef HW_SERIAL
pinMode(RX0_Pin, INGRESSO);
pinMode(TX0_Pin, USCITA);pinMode(RX1_Pin, INGRESSO);
pinMode(TX1_Pin, USCITA);
1TP42 Telse
ZERO.inizio(38400); // init lato AA UART
ZERO.sciacquone()
Seriale.inizio(38400); // avvia UART lato PC
Seriale.sciacquone();
#endif
}

vuoto ciclo continuo() {
#ifdef HW_SERIAL
//digitalWrite(TX0_Pin, digitalRead(RX1_Pin));
//digitalWrite(TX1_Pin, digitalRead(RX0_Pin));
Se (PIND & (1 << 4)) PORTD |= (1 << 1); altro PORTD &= ~(1 << 1);
Se (PIND & (1 << 0)) PORTD |= (1 << 7); altro PORTD &= ~(1 << 7);

1TP42 Telse  
Se (ZERO.a disposizione()) Seriale.scrivere(ZERO.leggere()); // flusso di dati da AA a PC
Se (Seriale.a disposizione()) ZERO.scrivere(Seriale.leggere()); // flusso di dati dal PC all'AA
#endif  
}

// Visualizzazione 3D per misurazioni SWR
// Per RigExpert AA-30 ZERO antenna e analizzatore di cavi con Arduino Uno
//
// Riceve dati da AA-30 ZERO e crea una superficie
// che è una visualizzazione dell'SWR in funzione del tempo
//
// 26 giugno 2017, Rig Expert Ukraine Ltd.
//
elaborazione delle importazioni.seriale.*;Seriale ZERO;
int fare un passo; // Fasi del protocollo di comunicazione (0 – imposta Freq; 1 – imposta Range; 2 – avvia misurazioni)int maxSamples = 100; // Numero di punti da misurare
int maxSet = 50; // Profondità temporale
galleggiante punti[][]; // Dati di misurazione
int campione; // campione corrente
int impostare; // set di dati corrente
int colori[]; // colore della curva
int totale; // campioni totali acquisiti
booleano pronto; // schermo ridisegnato se True
int Frequenza; // Frequenza corrente
int Allineare; // intervallo corrente// Codice per inviare il comando ad Analyzer
vuoto serializzare(Stringa cmd) {
int len = cmd.lunghezza();
int charPos = 0;
mentre (len— != 0) {
ZERO.scrivere(cmd.charAt(charPos));
charPos++;
}
}// Funzione di calcolo SWR
// Z0 – Impedenza del sistema (ovvero 50 per sistemi da 50 Ohm)
// R – valore R misurato
// X – valore X misurato
galleggiante computeSWR(galleggiante Z0, galleggiante R, galleggiante X) {
galleggiante ROS, Gamma;
galleggiante XX = X * X;
galleggiante denominatore = (R + Z0) * (R + Z0) + XX;
Se (denominatore == 0) {
Restituzione 1E9;
} altro {
galleggiante l = (R – Z0) * (R – Z0);
galleggiante t = (l + XX);
t = t / denominatore;
Gamma = sqrt(t); // sempre >= 0
// NOTA:
// Gamma == -1 riflessione negativa completa, quando la linea è in cortocircuito
// Gamma == 0 nessuna riflessione, quando la linea è perfettamente abbinata
// Gamma == +1 riflessione positiva completa, quando la linea è a circuito aperto
Se (Gamma == 1.0) {
ROS = 1E9;
} altro {
ROS = (1 + Gamma) / (1 – Gamma);
}
}

// restituisce i valori
Se ((ROS > 200) || (Gamma > 0.99)) {
ROS = 200;
} altro Se (ROS < 1) {
ROS = 1;
}
Restituzione ROS;
}

vuoto impostare() {
Frequenza = 115000000;
Allineare = 230000000;
campione = 0;
impostare = –1;
fare un passo = 0;
punti = nuovo galleggiante[maxSet + 1][maxSamples + 1];
colori = nuovo int[maxSet + 1];
pronto = falso;
totale = 0;

sfondo(0);
colpo(120, 240, 255, 255);
ictusPeso(1);
taglia(640, 480, P3D);

printArray(Seriale.elenco());
// Sostituisci il nome COM con uno che corrisponda alle tue condizioni
ZERO = nuovo Seriale(questo, “COM21”, 38400);
ZERO.bufferUntil(13);
ritardo(1000);
serializzare(“SW0\r\n“);
}

vuoto drawSurface() {
pronto = falso;
luci();
galleggiante sp = 0.001 * frameCount;
telecamera((larghezza / 3) * peccato(sp), 0, 800, larghezza / 2, altezza / 2, 0, 0, 1, 0);

sfondo(0, 0, 0);
dimensione del testo(30);
riempire(255, 255, 255);
// —————- Asse ———————
colpo(255, 255, 255, 128);
linea(0, altezza, 0, larghezza altezza, 0);

linea(0, 0, 0, 0, altezza, 0);
linea(larghezza, 0, 0, larghezza altezza, 0);

linea(0, altezza, 5 * maxSet, 0, altezza, 0);
linea(larghezza / 2, altezza, 5 * maxSet, larghezza / 2, altezza, 0);
linea(larghezza altezza, 5 * maxSet, larghezza, altezza, 0);

// —————- Freq. marcatori —————-
colpo(255, 255, 255, 128);
linea(larghezza / 2, 0, 0, larghezza / 2, altezza, 0);
textAlign(CENTRO);
testo(Frequenza / 1E3 + "kHz", larghezza / 2, altezza, 5 * maxSet);
testo(((Frequenza / 1E3) – (Allineare / 2E3)) + "kHz", 0, altezza, 5 * maxSet);
testo(((Frequenza / 1E3) + (Allineare / 2E3)) + "kHz", larghezza altezza, 5 * maxSet);

// —————– Titolo modalità ——————
textAlign(SINISTRA);
dimensione del testo(36);
testo("SWR in funzione del grafico del tempo", 0, –100, 0);
dimensione del testo(30);
Se (topoY < altezza / 5) {
Se (topoX < larghezza / 2) {
riempire(255, 0, 0);
textAlign(GIUSTO);
testo(“F = “ + Frequenza / 1E3 + "kHz", larghezza / 2 – 50, –50, 0);
riempire(255, 255, 255);
textAlign(SINISTRA);
testo("Intervallo = " + Allineare / 1E3 + "kHz", larghezza / 2 + 50, –50, 0);
} altro {
riempire(255, 255, 255);
textAlign(GIUSTO);
testo(“F = “ + Frequenza / 1E3 + "kHz", larghezza / 2 – 50, –50, 0);
riempire(255, 0, 0);
textAlign(SINISTRA);
testo("Intervallo = " + Allineare / 1E3 + "kHz", larghezza / 2 + 50, –50, 0);
}
} altro {
riempire(255, 255, 255);
textAlign(GIUSTO);
testo(“F = “ + Frequenza / 1E3 + "kHz", larghezza / 2 – 50, –50, 0);
textAlign(SINISTRA);
testo("Intervallo = " + Allineare / 1E3 + "kHz", larghezza / 2 + 50, –50, 0);
}

// Ottieni gli estremi
galleggiante minV = 1E9;
galleggiante maxV = –1E9;
per (int io = 0; io  < impostare; io++) {
per (int j = 0; j  < maxSamples + 1; j++) {
Se (punti[io][j] > maxV) maxV = punti[io][j];
Se (punti[io][j] > maxV) minV = punti[io][j];
}
}

println(“Minimo = “ + minV + “; Massimo = “ + maxV);
minV = 1;
Se (maxV < 2) maxV = 2;
altro Se (maxV < 5) maxV = 5;
altro Se (maxV < 10) maxV = 10;
altro maxV = 100;
galleggiante HK = larghezza / maxSamples;
galleggiante VK = altezza / (maxV – minV);
galleggiante zK = 2;

// —————– Disegna marcatori orizzontali —————–
riempire(255, 255, 255);
textAlign(GIUSTO);
linea(0, altezza – VK, 0, larghezza altezza – VK, 0); // ROS = 2
testo("SWR = 2.0", 0, altezza – VK, 0);
linea(0, altezza – 2 * VK, 0, larghezza altezza – 2 * VK, 0); // ROS = 3
testo("SWR = 3.0", 0, altezza – 2 * VK, 0);
linea(0, altezza – 4 * VK, 0, larghezza altezza – 4 * VK, 0); // ROS = 5
testo("SWR = 5.0", 0, altezza – 4 * VK, 0);

// Traccia le linee
per (int io = 0; io < impostare; io++) {
Se (colori[io] % 5 == 0) colpo(255, 0, 0, 255 * io / impostare);
altro colpo(120, 240, 255, 255 * io / impostare);

per (int j = 1; j < maxSamples + 1; j++) {
// disegna solo se SWR < 100.0
Se (punti[io][j – 1] < 100) {
linea((j – 1) * HK, altezza – (punti[io][j – 1] – 1) * VK, io * zK, j * HK, altezza – (punti[io][j] – 1) * VK, io * zK);  // Elabora i dati in entrata void serialEvent(Serial p) { String inString; inString = p.readString(); if (inString.indexOf(“OK”) >= 0) {
}
}
}
} vuoto disegnare() {
Se (pronto) {
drawSurface();
}
}
interruttore (fare un passo) {
Astuccio 0: serializzare("FQ" + Frequenza + “\r\n“);
fare un passo = 1;
rompere;

Astuccio 1: serializzare(“SW” + Allineare + “\r\n“);
fare un passo = 2;
rompere;

Astuccio 2: serializzare("FRX" + str(maxSamples) + “\r\n“);
fare un passo = 0;
campione = 0;
Se (impostare == maxSet) {
// sposta indietro le curve
per (int io = 1; io < maxSet + 1; io++) {
colori[io – 1] = colori[io];
per (int j = 0; j < maxSamples + 1; j++) {
punti[io – 1][j] = punti[io][j];
}
}
} altro {
impostare++;
}
colori[impostare] = totale++;
pronto = VERO;
rompere;
}

} altro {
galleggiante[] num = galleggiante(diviso(inStringa, ‘,’));
Se (num.lunghezza == 3) {
galleggiante ROS = computeSWR(50, num[1], num[2]);
punti[impostare][campione] = ROS;
campione++;
}
}
}

// Cambia i valori di frequenza e intervallo con la rotellina del mouse
vuoto rotellina del mouse(Evento MouseEvent) {
galleggiante e = evento.getCount();
Se (topoY < altezza / 5) {
Se (topoX < larghezza / 2) { // Cambia freq. se (Frequenza > 1E5) {
Frequenza += e * 100000;
drawSurface();
}
} altro {
// Cambia intervallo
Se (Allineare > 1E5) {
Allineare += e * 1E5;
drawSurface();
}
}
}
}

ZERO = nuovo Seriale(questo, “COM16”, 115200);

// Bridge UART per lo scambio di dati tra
// RigExpert AA-30 ZERO antenna e analizzatore di cavi e Arduino Uno
//
// Riceve da Arduino, invia a AA-30 ZERO.
// Riceve da AA-30 ZERO, invia ad Arduino.
//
// 26 giugno 2017, Rig Expert Ukraine Ltd.
//
#includeSoftwareSerial ZERO(4, 7); //RX,TX
//
// Modificato da WB9RAA Ed marzo
// 6 gennaio 2018
//
// parla con AA-30 Zero a 38.400 baud e
// rende i dati adatti al grafico di un foglio di calcolo
//
// Spazza tutte le bande radioamatoriali in circa 10K Freq. passi
// Calcola l'SWR al volo quindi ogni riga di testo
// inviato è: "Freq,R,X,SWR \r\n"
// mescolato anche con i comandi OK e fq sw frx
// Compilato con Arduino IDE 1.8.5
// il tempo di scansione totale è di circa 25 secondi per le bande 160M-10M.
//
// Grafici più veloci con "frx3" su tutte le bande in modo che vengano stampate solo le frequenze Edge e Center.
// Altre idee, sweep 1..30 Mhz e stampa solo F, R, X, SWR quando swr è inferiore a 2.0
//int j;
char HamBands[][35] = {
{ “\r\nver\r\n“ } , //0
{ “fq1900000\r\nsw200000\r\nfrx20\r\n“ }, //1{ “fq3750000\r\nsw500000\r\nfrx50\r\n“ }, //2{ “fq5331900\r\nsw2800\r\nfrx3\r\n“ }, //3
{ “fq5347900\r\nsw2800\r\nfrx3\r\n“ }, //4
{ “fq5358900\r\nsw2800\r\nfrx3\r\n“ }, //5
{ “fq5404900\r\nsw2800\r\nfrx3\r\n“ }, //6

{ “fq7150000\r\nsw300000\r\nfrx35\r\n“ }, //7

{ “fq10125000\r\nsw50000\r\nfrx10\r\n“ }, //8

{ “fq14150000\r\nsw300000\r\nfrx30\r\n“ }, //9

{ “fq18118000\r\nsw100000\r\nfrx10\r\n“ }, //10

{ “fq21225000\r\nsw450000\r\nfrx45\r\n“ }, //11

{ “fq24940000\r\nsw100000\r\nfrx10\r\n“ }, //12

{ “fq28985000\r\nsw1970000\r\nfrx50\r\n“ }, //13
{ “” }, // Indicatore di fine //14
//

};

vuoto impostare()
{
ZERO.inizio(38400); // init lato AA UART
ZERO.sciacquone();
ZERO.setTimeout(2500);
Seriale.inizio(38400); // avvia UART lato PC
Seriale.sciacquone();
ritardo(50);
j = 0;
Seriale.println(“\r\n\nIl progetto AA-30Zero Ver.20180107A di Ed March WB9RAA\n“);
Seriale.println(“\nUtilizzo dell'analizzatore d'antenna RigExpert 'AA-30 Zero'\nScansiona tutte le bande Ham 1..30Mhz.\nAl termine, premere / per eseguire di nuovo. Altrimenti digita i comandi su AA-30 Zero\n“);
Seriale.println("Comandi Zero AA-30");
Seriale.println("ver : OTTIENI LA VERSIONE DEL FIRMWARE AA");
Seriale.println(“fq1234567 : IMPOSTA FREQUENZA CENTRALE IN HERTZ es. fq7150000”);
Seriale.println(“sw300000 : IMPOSTA INTERVALLO SWEEP IN HERTZ es. sw300000 spazza 300Khz dall'inizio alla fine");
Seriale.println(“frx123 : START SWEEPING restituendo F,R,X Totale di 123 righe. frx3 restituisce 3 righe BEGIN,CENTER,END\n“);
}
lungo tmo = 250;

vuoto ciclo continuo()
{
Se (ZERO.a disposizione())
{
Stringhe = ZERO.readStringUntil(‘\n‘);
S.sostituire(“\r“, “”);
Seriale.scrivere(S.c_str()); // flusso di dati da AA a PC

int io = S.indice di(‘,’);
Se (io > 0)
{
// Analizza la stringa in float R e X
io++;
galleggiante R = S.sottostringa(io).galleggiare();
int ii = S.sottostringa(io).indice di(‘,’);
galleggiante X = S.sottostringa(io + ii + 1).galleggiare();
//
// Calcola SWR da R & X
//
galleggiante XX = X * X;
galleggiante Rm = (R – 50) * (R – 50);
galleggiante Rp = (R + 50) * (R + 50);
galleggiante n = sqrt(Rm + XX);
galleggiante D = sqrt(Rp + XX);
galleggiante G = n / D;
galleggiante vswr = (1 + G) / (1 – G);
// Dal momento che non possiamo stampare float otteniamo int e frazione come INT
// if swr is 4.12 then v1=4 and v2=12 — 1.04 then 1 and 4 printed as 1.04 using %d.%02d
int v1 = vswr;
int v2 = (vswr – v1) * 100;
Se (v1 < 0)
{
v1 = 99;
v2 = 0;
}
char z.z[50];
sprintf(Z, “,%d.%02d”, v1, v2); // calcola swr come stringa
Seriale.scrivere(z.z); // aggiunge alla stringa
}
Seriale.scrivere(“\r\n“); // e terninate come era con CR LF
tmo = 250;
}
Se (Seriale.a disposizione())
{
char c1 = Seriale.leggere();
Se (c1 == ‘/’)
{
j = 0;
}
altro
{
ZERO.scrivere(c1); // flusso di dati dal PC all'AA
}
tmo = 250;
}
ritardo(1);
Se (—tmo < 0)
{
Se (HamBands[j][0] != 0)
{
per (int io = 0; HamBands[j][io] != 0; io++)
{
int cap = HamBands[j][io];
Seriale.scrivere(cap);
ZERO.scrivere(cap);
Se (cap == ‘\n‘)
{
per (int d = 0; d < 50; d++)
{
ritardo(1);
Se (ZERO.a disposizione())
{
Seriale.scrivere(ZERO.leggere()); // flusso di dati da AA a PC
}
}
}
}
tmo = 250;
j++;
}
}
}