// UART-brygga för datautbyte mellan
// RigExpert AA-30 ZERO antenn & kabelanalysator och Arduino Uno
//
// Tar emot från Arduino, skickar till AA-30 ZERO.
// Tar emot från AA-30 ZERO, skickar till Arduino.
//
// 26 juni 2017, Rig Expert Ukraine Ltd.
//
1TP42Inkludera "SoftwareSerial.h"
#define RX0_Pin 0
#define TX0_Pin 1
#define RX1_Pin 4
#define TX1_Pin 7#define HW_SERIAL#ifndef HW_SERIAL
Programvaruserie NOLL(RX1_Pin, TX1_Pin); // RX, TX
#endiftomhet uppstart() {
#ifdef HW_SERIAL
pinMode(RX0_Pin, INPUT);
pinMode(TX0_Pin, OUTPUT);pinMode(RX1_Pin, INPUT);
pinMode(TX1_Pin, OUTPUT);
#else
NOLL.Börja(38400); // init AA sida UART
NOLL.spola()
Serie.Börja(38400); // init PC sida UART
Serie.spola();
#endif
}

tomhet slinga() {
#ifdef HW_SERIAL
//digitalWrite(TX0_Pin, digitalRead(RX1_Pin));
//digitalWrite(TX1_Pin, digitalRead(RX0_Pin));
om (PIND & (1 << 4)) PORTD |= (1 << 1); annan PORTD &= ~(1 << 1);
om (PIND & (1 << 0)) PORTD |= (1 << 7); annan PORTD &= ~(1 << 7);

#else  
om (NOLL.tillgängligt()) Serie.skriva(NOLL.läsa()); // dataström från AA till PC
om (Serie.tillgängligt()) NOLL.skriva(Serie.läsa()); // dataström från PC till AA
#endif  
}

// 3D-visualisering för SWR-mätningar
// För RigExpert AA-30 ZERO antenn & kabelanalysator med Arduino Uno
//
// Tar emot data från AA-30 ZERO och gör en yta
// som är en visualisering av SWR som funktion av tid
//
// 26 juni 2017, Rig Expert Ukraine Ltd.
//
importbearbetning.serie-.*;Seriell NOLL;
int steg; // Kommunikationsprotokollssteg (0 – ställ in frekvens; 1 – ställ in intervall; 2 – startmätningar)int maxSampler = 100; // Antal punkter att mäta
int maxSets = 50; // Tidsdjup
flyta poäng[][]; // Mätdata
int prov; // aktuellt prov
int uppsättning; // aktuell datamängd
int färger[]; // kurvfärg
int total; // totala prover som förvärvats
boolesk redo; // skärm ritad om om det är sant
int Frekvens; // aktuell Frequency
int Räckvidd; // aktuellt intervall// Kod för att skicka kommando till Analyzer
tomhet serialisera(Sträng cmd) {
int len = cmd.längd();
int charPos = 0;
medan (len— != 0) {
NOLL.skriva(cmd.charAt(charPos));
charPos++;
}
}// SWR-beräkningsfunktion
// Z0 – Systemimpedans (dvs. 50 för 50 Ohm-system)
// R – uppmätt R-värde
// X – uppmätt X-värde
flyta beräknaSWR(flyta Z0, flyta R, flyta X) {
flyta SWR, Gamma;
flyta XX = X * X;
flyta nämnare = (R + Z0) * (R + Z0) + XX;
om (nämnare == 0) {
lämna tillbaka 1E9;
} annan {
flyta l = (R – Z0) * (R – Z0);
flyta t = (l + XX);
t = t / nämnare;
Gamma = sqrt(t); // alltid >= 0
// NOTERA:
// Gamma == -1 fullständig negativ reflektion, när linjen är kortsluten
// Gamma == 0 ingen reflektion, när linjen är perfekt matchad
// Gamma == +1 fullständig positiv reflektion, när linjen är öppen
om (Gamma == 1.0) {
SWR = 1E9;
} annan {
SWR = (1 + Gamma) / (1 – Gamma);
}
}

// returnerar värden
om ((SWR > 200) || (Gamma > 0.99)) {
SWR = 200;
} annan om (SWR < 1) {
SWR = 1;
}
lämna tillbaka SWR;
}

tomhet uppstart() {
Frekvens = 115000000;
Räckvidd = 230000000;
prov = 0;
uppsättning = –1;
steg = 0;
poäng = ny flyta[maxSets + 1][maxSampler + 1];
färger = ny int[maxSets + 1];
redo = falsk;
total = 0;

bakgrund(0);
stroke(120, 240, 255, 255);
slagvikt(1);
storlek(640, 480, P3D);

printArray(Serie.lista());
// Ersätt COM-namnet med ett som matchar dina villkor
NOLL = ny Serie(detta, "COM21", 38400);
NOLL.buffertTills(13);
dröjsmål(1000);
serialisera("SW0\r\n“);
}

tomhet ritaSurface() {
redo = falsk;
lampor();
flyta sp = 0.001 * frameCount;
kamera((bredd / 3) * synd(sp), 0, 800, bredd / 2, höjd / 2, 0, 0, 1, 0);

bakgrund(0, 0, 0);
textstorlek(30);
fylla(255, 255, 255);
// —————- Axel ———————
stroke(255, 255, 255, 128);
linje(0, höjd, 0, bredd höjd, 0);

linje(0, 0, 0, 0, höjd, 0);
linje(bredd, 0, 0, bredd höjd, 0);

linje(0, höjd, 5 * maxSets, 0, höjd, 0);
linje(bredd / 2, höjd, 5 * maxSets, bredd / 2, höjd, 0);
linje(bredd höjd, 5 * maxSets, bredd, höjd, 0);

// —————- Frekv. markörer —————-
stroke(255, 255, 255, 128);
linje(bredd / 2, 0, 0, bredd / 2, höjd, 0);
textJustera(CENTRUM);
text(Frekvens / 1E3 + "kHz", bredd / 2, höjd, 5 * maxSets);
text(((Frekvens / 1E3) – (Räckvidd / 2E3)) + "kHz", 0, höjd, 5 * maxSets);
text(((Frekvens / 1E3) + (Räckvidd / 2E3)) + "kHz", bredd höjd, 5 * maxSets);

// —————– Lägets titel ——————
textJustera(VÄNSTER);
textstorlek(36);
text("SWR som funktion av tidsdiagram", 0, –100, 0);
textstorlek(30);
om (musY < höjd / 5) {
om (mouseX < bredd / 2) {
fylla(255, 0, 0);
textJustera(RÄTT);
text("F = " + Frekvens / 1E3 + "kHz", bredd / 2 – 50, –50, 0);
fylla(255, 255, 255);
textJustera(VÄNSTER);
text("Räckvidd = " + Räckvidd / 1E3 + "kHz", bredd / 2 + 50, –50, 0);
} annan {
fylla(255, 255, 255);
textJustera(RÄTT);
text("F = " + Frekvens / 1E3 + "kHz", bredd / 2 – 50, –50, 0);
fylla(255, 0, 0);
textJustera(VÄNSTER);
text("Räckvidd = " + Räckvidd / 1E3 + "kHz", bredd / 2 + 50, –50, 0);
}
} annan {
fylla(255, 255, 255);
textJustera(RÄTT);
text("F = " + Frekvens / 1E3 + "kHz", bredd / 2 – 50, –50, 0);
textJustera(VÄNSTER);
text("Räckvidd = " + Räckvidd / 1E3 + "kHz", bredd / 2 + 50, –50, 0);
}

// Få extremum
flyta minV = 1E9;
flyta maxV = –1E9;
för (int i = 0; i  < uppsättning; i++) {
för (int j = 0; j  < maxSampler + 1; j++) {
om (poäng[i][j] > maxV) maxV = poäng[i][j];
om (poäng[i][j] > maxV) minV = poäng[i][j];
}
}

println("Min = " + minV + "; Max = " + maxV);
minV = 1;
om (maxV < 2) maxV = 2;
annan om (maxV < 5) maxV = 5;
annan om (maxV < 10) maxV = 10;
annan maxV = 100;
flyta hK = bredd / maxSampler;
flyta vK = höjd / (maxV – minV);
flyta zK = 2;

// —————– Rita horisontella markörer —————–
fylla(255, 255, 255);
textJustera(RÄTT);
linje(0, höjd – vK, 0, bredd höjd – vK, 0); // SWR = 2
text("SWR = 2.0", 0, höjd – vK, 0);
linje(0, höjd – 2 * vK, 0, bredd höjd – 2 * vK, 0); // SWR = 3
text("SWR = 3.0", 0, höjd – 2 * vK, 0);
linje(0, höjd – 4 * vK, 0, bredd höjd – 4 * vK, 0); // SWR = 5
text("SWR = 5.0", 0, höjd – 4 * vK, 0);

// Rita upp linjerna
för (int i = 0; i < uppsättning; i++) {
om (färger[i] % 5 == 0) stroke(255, 0, 0, 255 * i / uppsättning);
annan stroke(120, 240, 255, 255 * i / uppsättning);

för (int j = 1; j < maxSampler + 1; j++) {
// rita endast om SWR < 100.0
om (poäng[i][j – 1] < 100) {
linje((j – 1) * hK, höjd – (poäng[i][j – 1] – 1) * vK, jag * zK, j * hK, höjd – (poäng[i][j] – 1) * vK, jag * zK);  // Process inkommande data void serialEvent(Serial p) { String inString; inString = p.readString(); if (inString.indexOf(“OK”) >= 0) {
}
}
}
} tomhet dra() {
om (redo) {
ritaSurface();
}
}
växla (steg) {
fall 0: serialisera("FQ" + Frekvens + “\r\n“);
steg = 1;
ha sönder;

fall 1: serialisera("SW" + Räckvidd + “\r\n“);
steg = 2;
ha sönder;

fall 2: serialisera("FRX" + str(maxSampler) + “\r\n“);
steg = 0;
prov = 0;
om (uppsättning == maxSets) {
// skift kurvor bakåt
för (int i = 1; i < maxSets + 1; i++) {
färger[i – 1] = färger[i];
för (int j = 0; j < maxSampler + 1; j++) {
poäng[i – 1][j] = poäng[i][j];
}
}
} annan {
uppsättning++;
}
färger[uppsättning] = total++;
redo = Sann;
ha sönder;
}

} annan {
flyta[] nums = flyta(dela(inString, ‘,’));
om (nums.längd == 3) {
flyta SWR = beräknaSWR(50, nums[1], nums[2]);
poäng[uppsättning][prov] = SWR;
prov++;
}
}
}

// Ändra frekvens- och intervallvärden med mushjulet
tomhet mushjul(MouseEvent-händelse) {
flyta e = händelse.getCount();
om (musY < höjd / 5) {
om (mouseX < bredd / 2) { // Ändra Frekv. if (Frekvens > 1E5) {
Frekvens += e * 100000;
ritaSurface();
}
} annan {
// Ändra intervall
om (Räckvidd > 1E5) {
Räckvidd += e * 1E5;
ritaSurface();
}
}
}
}

NOLL = ny Serie(detta, "COM16", 115200);

// UART-brygga för datautbyte mellan
// RigExpert AA-30 ZERO antenn & kabelanalysator och Arduino Uno
//
// Tar emot från Arduino, skickar till AA-30 ZERO.
// Tar emot från AA-30 ZERO, skickar till Arduino.
//
// 26 juni 2017, Rig Expert Ukraine Ltd.
//
1TP42InkluderaProgramvaruserie NOLL(4, 7); // RX, TX
//
// Modifierad av WB9RAA Ed March
// 6 januari 2018
//
// pratar med AA-30 Zero på 38 400 baud och
// gör data lämpliga för ett kalkylbladsdiagram
//
// Sopa alla skinkband i ca 10K Frekv. steg
// Beräknar SWR i farten så varje textrad
// skickas är: "Freq,R,X,SWR \r\n"
// blandat med OK och fq sw frx kommandon också
// Kompilerad med Arduino IDE 1.8.5
// total sveptid är cirka 25 sekunder för 160M-10M band.
//
// Snabbare plotter med "frx3" på alla band så att endast Edge och Center Freqs skrivs ut.
// Andra idéer, svep 1..30 Mhz och skriv bara ut F,R,X,SWR när swr är under 2.0
//int j;
röding 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
{ “” }, // Slutmarkör //14
//

};

tomhet uppstart()
{
NOLL.Börja(38400); // init AA sida UART
NOLL.spola();
NOLL.setTimeout(2500);
Serie.Börja(38400); // init PC sida UART
Serie.spola();
dröjsmål(50);
j = 0;
Serie.println(“\r\n\nAA-30Zero Project Ver.20180107A av Ed March WB9RAA\n“);
Serie.println(“\nAnvänder RigExpert 'AA-30 Zero' antennanalysator\nSkanna alla 1..30Mhz Ham-band.\nNär du är klar Tryck på / för att köra igen. Skriv annars kommandon till AA-30 Noll\n“);
Serie.println("AA-30 nollkommandon");
Serie.println(“ver : HÄMTA VERSION AV AA FIRMWARE”);
Serie.println(“fq1234567 : STÄLL IN CENTER FREKVENS I HERTZ ex. fq7150000”);
Serie.println(“sw300000 : SÄTT SVEEPORMER I HERTZ ex. sw300000 sveper 300Khz från början till slut”);
Serie.println(“frx123 : BÖRJA SVEPA returnera F,R,X Totalt 123 rader. frx3 returnerar 3 rader BEGIN,CENTER,END\n“);
}
lång tmo = 250;

tomhet slinga()
{
om (NOLL.tillgängligt())
{
Sträng s = NOLL.readStringUntil(‘\n‘);
s.byta ut(“\r“, “”);
Serie.skriva(s.c_str()); // dataström från AA till PC

int i = s.index för(‘,’);
om (i > 0)
{
// Analysera sträng till flyter R & X
i++;
flyta R = s.delsträng(i).att flyta();
int ii = s.delsträng(i).index för(‘,’);
flyta X = s.delsträng(i + ii + 1).att flyta();
//
// Beräkna SWR från R & X
//
flyta XX = X * X;
flyta Rm = (R – 50) * (R – 50);
flyta Rp = (R + 50) * (R + 50);
flyta N = sqrt(Rm + XX);
flyta D = sqrt(Rp + XX);
flyta G = N / D;
flyta vswr = (1 + G) / (1 – G);
// Eftersom vi inte kan skriva ut float får vi int & bråk som 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;
om (v1 < 0)
{
v1 = 99;
v2 = 0;
}
röding z[50];
sprintf(z, “,%d.%02d”, v1, v2); // beräkna swr som sträng
Serie.skriva(z); // lägg till sträng
}
Serie.skriva(“\r\n“); // och avsluta som det var med CR LF
tmo = 250;
}
om (Serie.tillgängligt())
{
röding c1 = Serie.läsa();
om (c1 == ‘/’)
{
j = 0;
}
annan
{
NOLL.skriva(c1); // dataström från PC till AA
}
tmo = 250;
}
dröjsmål(1);
om (—tmo < 0)
{
om (HamBands[j][0] != 0)
{
för (int i = 0; HamBands[j][i] != 0; i++)
{
int kap = HamBands[j][i];
Serie.skriva(kap);
NOLL.skriva(kap);
om (kap == ‘\n‘)
{
för (int d = 0; d < 50; d++)
{
dröjsmål(1);
om (NOLL.tillgängligt())
{
Serie.skriva(NOLL.läsa()); // dataström från AA till PC
}
}
}
}
tmo = 250;
j++;
}
}
}