// UART-brug vir data-uitruiling tussen
// RigExpert AA-30 ZERO antenna en kabel ontleder en Arduino Uno
//
// Ontvang van die Arduino, stuur na AA-30 ZERO.
// Ontvang van AA-30 ZERO, stuur na die Arduino.
//
// 26 Junie 2017, Rig Expert Ukraine Bpk.
//
1TP42Sluit "SoftwareSerial.h" in
#definieer RX0_Pin 0
#definieer TX0_Pin 1
#define RX1_Pin 4
#definieer TX1_Pin 7#definieer HW_SERIAL#ifndef HW_SERIAL
Sagtewarereeks NUL(RX1_Pin, TX1_Pin); // RX, TX
#endifnietig stel op() {
#ifdef HW_SERIAL
pinMode(RX0_Pin, INPUT);
pinMode(TX0_Pin, UITVOER);pinMode(RX1_Pin, INPUT);
pinMode(TX1_Pin, UITVOER);
#else
NUL.begin(38400); // init AA kant UART
NUL.spoel()
Reeks.begin(38400); // init PC kant UART
Reeks.spoel();
#endif
}

nietig lus() {
#ifdef HW_SERIAL
//digitalWrite(TX0_Pin, digitalRead(RX1_Pin));
//digitalWrite(TX1_Pin, digitalRead(RX0_Pin));
as (PIND & (1 << 4)) PORTD |= (1 << 1); anders PORTD &= ~(1 << 1);
as (PIND & (1 << 0)) PORTD |= (1 << 7); anders PORTD &= ~(1 << 7);

#else  
as (NUL.beskikbaar()) Reeks.skryf(NUL.lees()); // datastroom van AA na rekenaar
as (Reeks.beskikbaar()) NUL.skryf(Reeks.lees()); // datastroom van rekenaar na AA
#endif  
}

// 3D-visualisering vir SWR-metings
// Vir RigExpert AA-30 ZERO antenna en kabel ontleder met Arduino Uno
//
// Ontvang data van AA-30 ZERO en maak 'n oppervlak
// wat 'n visualisering van SWR as 'n funksie van tyd is
//
// 26 Junie 2017, Rig Expert Ukraine Bpk.
//
invoer verwerking.reeks.*;Reeks NUL;
int stap; // Kommunikasie protokol stappe (0 – stel Freq; 1 – stel Reeks; 2 – begin metings)int maxSamples = 100; // Aantal punt om te meet
int maxSets = 50; // Tyddiepte
dryf punte[][]; // Metingsdata
int monster; // huidige monster
int stel; // huidige datastel
int kleure[]; // kurwe kleur
int totaal; // totale monsters verkry
boolean gereed; // skerm herteken indien Waar
int Frekwensie; // huidige Frekwensie
int Reeks; // huidige reeks// Kode om opdrag na Analyzer te stuur
nietig serialiseer(String cmd) {
int len = cmd.lengte();
int charPos = 0;
terwyl (len— != 0) {
NUL.skryf(cmd.charAt(charPos));
charPos++;
}
}// SWR-berekeningsfunksie
// Z0 – Stelselimpedansie (dws 50 vir 50 Ohm stelsels)
// R – gemeet R-waarde
// X – gemete X-waarde
dryf berekenSWR(dryf Z0, dryf R, dryf X) {
dryf SWR, Gamma;
dryf XX = X * X;
dryf noemer = (R + Z0) * (R + Z0) + XX;
as (noemer == 0) {
terugkeer 1E9;
} anders {
dryf l = (R – Z0) * (R – Z0);
dryf t = (l + XX);
t = t / noemer;
Gamma = sqrt(t); // altyd >= 0
// LET WEL:
// Gamma == -1 volledige negatiewe refleksie, wanneer die lyn kortgesluit is
// Gamma == 0 geen refleksie, wanneer die lyn perfek ooreenstem
// Gamma == +1 volledige positiewe refleksie, wanneer die lyn oopkring is
as (Gamma == 1.0) {
SWR = 1E9;
} anders {
SWR = (1 + Gamma) / (1 – Gamma);
}
}

// gee waardes terug
as ((SWR > 200) || (Gamma > 0.99)) {
SWR = 200;
} anders as (SWR < 1) {
SWR = 1;
}
terugkeer SWR;
}

nietig stel op() {
Frekwensie = 115000000;
Reeks = 230000000;
monster = 0;
stel = –1;
stap = 0;
punte = nuut dryf[maxSets + 1][maxSamples + 1];
kleure = nuut int[maxSets + 1];
gereed = onwaar;
totaal = 0;

agtergrond(0);
beroerte(120, 240, 255, 255);
slagGewig(1);
grootte(640, 480, P3D);

printArray(Reeks.lys());
// Vervang COM-naam met een wat by jou voorwaardes pas
NUL = nuut Reeks(hierdie, "COM21", 38400);
NUL.bufferTot(13);
vertraging(1000);
serialiseer("SW0\r\n“);
}

nietig teken Oppervlakte() {
gereed = onwaar;
ligte();
dryf sp = 0.001 * raamtelling;
kamera((breedte / 3) * sonde(sp), 0, 800, breedte / 2, hoogte / 2, 0, 0, 1, 0);

agtergrond(0, 0, 0);
teksgrootte(30);
vul(255, 255, 255);
// —————- As ———————
beroerte(255, 255, 255, 128);
lyn(0, hoogte, 0, breedte hoogte, 0);

lyn(0, 0, 0, 0, hoogte, 0);
lyn(breedte, 0, 0, breedte hoogte, 0);

lyn(0, hoogte, 5 * maxSets, 0, hoogte, 0);
lyn(breedte / 2, hoogte, 5 * maxSets, breedte / 2, hoogte, 0);
lyn(breedte hoogte, 5 * maxSets, breedte, hoogte, 0);

// —————- Frekw. merkers —————-
beroerte(255, 255, 255, 128);
lyn(breedte / 2, 0, 0, breedte / 2, hoogte, 0);
teksBelyning(SENTRUM);
teks(Frekwensie / 1E3 + "kHz", breedte / 2, hoogte, 5 * maxSets);
teks(((Frekwensie / 1E3) – (Reeks / 2E3)) + "kHz", 0, hoogte, 5 * maxSets);
teks(((Frekwensie / 1E3) + (Reeks / 2E3)) + "kHz", breedte hoogte, 5 * maxSets);

// —————– Modus titel ——————
teksBelyning(LINKS);
teksgrootte(36);
teks("SWR as 'n funksie van tyd Grafiek", 0, –100, 0);
teksgrootte(30);
as (muisY < hoogte / 5) {
as (muisX < breedte / 2) {
vul(255, 0, 0);
teksBelyning(REGS);
teks("F =" + Frekwensie / 1E3 + "kHz", breedte / 2 – 50, –50, 0);
vul(255, 255, 255);
teksBelyning(LINKS);
teks("Bereik = " + Reeks / 1E3 + "kHz", breedte / 2 + 50, –50, 0);
} anders {
vul(255, 255, 255);
teksBelyning(REGS);
teks("F =" + Frekwensie / 1E3 + "kHz", breedte / 2 – 50, –50, 0);
vul(255, 0, 0);
teksBelyning(LINKS);
teks("Bereik = " + Reeks / 1E3 + "kHz", breedte / 2 + 50, –50, 0);
}
} anders {
vul(255, 255, 255);
teksBelyning(REGS);
teks("F =" + Frekwensie / 1E3 + "kHz", breedte / 2 – 50, –50, 0);
teksBelyning(LINKS);
teks("Bereik = " + Reeks / 1E3 + "kHz", breedte / 2 + 50, –50, 0);
}

// Kry ekstremums
dryf minV = 1E9;
dryf maksV = –1E9;
vir (int i = 0; i  < stel; i++) {
vir (int j = 0; j  < maxSamples + 1; j++) {
as (punte[i][j] > maksV) maksV = punte[i][j];
as (punte[i][j] > maksV) minV = punte[i][j];
}
}

drukln("Min = " + minV + “; Maksimum = " + maksV);
minV = 1;
as (maksV < 2) maksV = 2;
anders as (maksV < 5) maksV = 5;
anders as (maksV < 10) maksV = 10;
anders maksV = 100;
dryf hK = breedte / maxSamples;
dryf vK = hoogte / (maksV – minV);
dryf zK = 2;

// —————– Teken horisontale merkers ——————
vul(255, 255, 255);
teksBelyning(REGS);
lyn(0, hoogte – vK, 0, breedte hoogte – vK, 0); // SWR = 2
teks("SWR = 2.0", 0, hoogte – vK, 0);
lyn(0, hoogte – 2 * vK, 0, breedte hoogte – 2 * vK, 0); // SWR = 3
teks("SWR = 3.0", 0, hoogte – 2 * vK, 0);
lyn(0, hoogte – 4 * vK, 0, breedte hoogte – 4 * vK, 0); // SWR = 5
teks("SWR = 5.0", 0, hoogte – 4 * vK, 0);

// Stip die lyne
vir (int i = 0; i < stel; i++) {
as (kleure[i] % 5 == 0) beroerte(255, 0, 0, 255 * i / stel);
anders beroerte(120, 240, 255, 255 * i / stel);

vir (int j = 1; j < maxSamples + 1; j++) {
// teken slegs as SWR < 100.0
as (punte[i][j – 1] < 100) {
lyn((j – 1) * hK, hoogte – (punte[i][j – 1] – 1) * vK, ek * zK, j * hK, hoogte – (punte[i][j] – 1) * vK, ek * zK);  // Proses inkomende data leem serialEvent(Serial p) { String inString; inString = p.readString(); if (inString.indexOf(“OK”) >= 0) {
}
}
}
} nietig teken() {
as (gereed) {
teken Oppervlakte();
}
}
skakelaar (stap) {
geval 0: serialiseer("FQ" + Frekwensie + “\r\n“);
stap = 1;
breek;

geval 1: serialiseer("SW" + Reeks + “\r\n“);
stap = 2;
breek;

geval 2: serialiseer("FRX" + str(maxSamples) + “\r\n“);
stap = 0;
monster = 0;
as (stel == maxSets) {
// skuif kurwe terug
vir (int i = 1; i < maxSets + 1; i++) {
kleure[i – 1] = kleure[i];
vir (int j = 0; j < maxSamples + 1; j++) {
punte[i – 1][j] = punte[i][j];
}
}
} anders {
stel++;
}
kleure[stel] = totaal++;
gereed = waar;
breek;
}

} anders {
dryf[] nums = dryf(verdeel(inString, ‘,’));
as (nums.lengte == 3) {
dryf SWR = berekenSWR(50, nommers[1], nommers[2]);
punte[stel][monster] = SWR;
monster++;
}
}
}

// Verander frekwensie- en omvangwaardes met die muiswiel
nietig muiswiel(MouseEvent gebeurtenis) {
dryf e = gebeurtenis.getCount();
as (muisY < hoogte / 5) {
as (muisX < breedte / 2) { // Verander frek. if (Frekwensie > 1E5) {
Frekwensie += e * 100000;
teken Oppervlakte();
}
} anders {
// Verander reeks
as (Reeks > 1E5) {
Reeks += e * 1E5;
teken Oppervlakte();
}
}
}
}

NUL = nuut Reeks(hierdie, "COM16", 115200);

// UART-brug vir data-uitruiling tussen
// RigExpert AA-30 ZERO antenna en kabel ontleder en Arduino Uno
//
// Ontvang van die Arduino, stuur na AA-30 ZERO.
// Ontvang van AA-30 ZERO, stuur na die Arduino.
//
// 26 Junie 2017, Rig Expert Ukraine Bpk.
//
1TP42Sluit inSagtewarereeks NUL(4, 7); // RX, TX
//
// Gewysig deur WB9RAA Ed Maart
// 6 Januarie 2018
//
// praat met AA-30 Zero teen 38 400 baud en
// maak data geskik vir 'n sigbladplot
//
// Vee alle hambande in ongeveer 10K Freq. stappe
// Bereken SWR on the fly so elke reël teks
// gestuur is: “Freq,R,X,SWR \r\n”
// vermeng met OK en fq sw frx opdragte ook
// Saamgestel met Arduino IDE 1.8.5
// totale veegtyd is ongeveer 25 sekondes vir 160M-10M bande.
//
// Vinniger plotte met “frx3” op alle bande sodat Slegs Edge en Center Freqs gedruk word.
// Ander idees, vee 1..30 Mhz en druk slegs F,R,X,SWR wanneer swr onder 2.0 is
//int j;
char HamBands[][35] = {
{ “\r\nver\r\n“ } , //0
{ “fq1900000\r\nsw200000\r\nfrx20\r\n“ }, //1{ “fq3750000\r\nsw500 000\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\nsw300 000\r\nfrx35\r\n“ }, //7

{ “fq10125000\r\nsw50 000\r\nfrx10\r\n“ }, //8

{ “fq14150000\r\nsw300 000\r\nfrx30\r\n“ }, //9

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

{ “fq21225000\r\nsw450 000\r\nfrx45\r\n“ }, //11

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

{ “fq28985000\r\nsw1970000\r\nfrx50\r\n“ }, //13
{ “” }, // Eindmerker //14
//

};

nietig stel op()
{
NUL.begin(38400); // init AA kant UART
NUL.spoel();
NUL.stelTimeout(2500);
Reeks.begin(38400); // init PC kant UART
Reeks.spoel();
vertraging(50);
j = 0;
Reeks.drukln(“\r\n\nThe AA-30Zero Project Ver.20180107A deur Ed March WB9RAA\n“);
Reeks.drukln(“\nGebruik die RigExpert 'AA-30 Zero' Antenna-analiseerder\nSkandeer alle 1..30Mhz Ham-bande.\nWanneer klaar Druk / om weer te hardloop. Andersins tik opdragte na AA-30 Zero\n“);
Reeks.drukln("AA-30 Zero Commands");
Reeks.drukln(“ver : KRY VERSIE VAN AA FIRMWARE”);
Reeks.drukln(“fq1234567 : STEL SENTRUMFREKWENSIE IN HERTZ ex. fq7150000");
Reeks.drukln(“sw300000 : STEL SWEEPREEKS IN HERTZ ex. sw300000 vee 300Khz van begin tot einde”);
Reeks.drukln(“frx123 : BEGIN VEEG en F,R,X Totaal van 123 reëls. frx3 gee 3 reëls BEGIN,MIDDEL,END\n“);
}
lank tmo = 250;

nietig lus()
{
as (NUL.beskikbaar())
{
Snaar s = NUL.leesStringTot(‘\n‘);
s.vervang(“\r“, “”);
Reeks.skryf(s.c_str()); // datastroom van AA na rekenaar

int i = s.INHOUDSOPGAWE van(‘,’);
as (i > 0)
{
// Ontleed string in vlotte R & X
i++;
dryf R = s.substring(i).om te dryf();
int ii = s.substring(i).INHOUDSOPGAWE van(‘,’);
dryf X = s.substring(i + ii + 1).om te dryf();
//
// Bereken SWR vanaf R & X
//
dryf XX = X * X;
dryf Rm = (R – 50) * (R – 50);
dryf Rp = (R + 50) * (R + 50);
dryf N = sqrt(Rm + XX);
dryf D = sqrt(Rp + XX);
dryf G = N / D;
dryf vswr = (1 + G) / (1 – G);
// Aangesien ons nie floats kan druk nie, kry ons int & breuk as INT's
// 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;
as (v1 < 0)
{
v1 = 99;
v2 = 0;
}
char Z[50];
sprintf(Z, “,%d.%02d”, v1, v2); // bereken swr as string
Reeks.skryf(Z); // voeg by string
}
Reeks.skryf(“\r\n“); // en eindig soos dit was met CR LF
tmo = 250;
}
as (Reeks.beskikbaar())
{
char c1 = Reeks.lees();
as (c1 == ‘/’)
{
j = 0;
}
anders
{
NUL.skryf(c1); // datastroom van rekenaar na AA
}
tmo = 250;
}
vertraging(1);
as (—tmo < 0)
{
as (HamBands[j][0] != 0)
{
vir (int i = 0; HamBands[j][i] != 0; i++)
{
int hfst = HamBands[j][i];
Reeks.skryf(hfst);
NUL.skryf(hfst);
as (hfst == ‘\n‘)
{
vir (int d = 0; d < 50; d++)
{
vertraging(1);
as (NUL.beskikbaar())
{
Reeks.skryf(NUL.lees()); // datastroom van AA na rekenaar
}
}
}
}
tmo = 250;
j++;
}
}
}