// UART most pro výměnu dat mezi
// Anténa a kabelový analyzátor RigExpert AA-30 ZERO a Arduino Uno
//
// Přijímá z Arduina, odesílá na AA-30 ZERO.
// Přijímá z AA-30 ZERO, odesílá do Arduina.
//
// 26. června 2017, Rig Expert Ukraine Ltd.
//
1TP42 Zahrnuje „SoftwareSerial.h“
#define RX0_Pin 0
#define TX0_Pin 1
#define RX1_Pin 4
#define TX1_Pin 7#definujte HW_SERIAL#ifndef HW_SERIAL
SoftwareSerial ZERO(RX1_Pin, TX1_Pin); // RX, TX
#endifprázdnota založit() {
#ifdef HW_SERIAL
pinMode(RX0_Pin, INPUT);
pinMode(TX0_Pin, VÝSTUP);pinMode(RX1_Pin, INPUT);
pinMode(TX1_Pin, VÝSTUP);
#else
NULA.začít(38400); // init UART na straně AA
NULA.spláchnout()
Seriál.začít(38400); // init UART na straně PC
Seriál.spláchnout();
#endif
}

prázdnota smyčka() {
#ifdef HW_SERIAL
//digitalWrite(TX0_Pin, digitalRead(RX1_Pin));
//digitalWrite(TX1_Pin, digitalRead(RX0_Pin));
-li (PIND & (1 << 4)) PORTD |= (1 << 1); jiný PORTD &= ~(1 << 1);
-li (PIND & (1 << 0)) PORTD |= (1 << 7); jiný PORTD &= ~(1 << 7);

#else  
-li (NULA.dostupný()) Seriál.napsat(NULA.číst()); // datový tok z AA do PC
-li (Seriál.dostupný()) NULA.napsat(Seriál.číst()); // datový tok z PC do AA
#endif  
}

// 3D vizualizace pro měření SWR
// Pro RigExpert AA-30 ZERO anténu a kabelový analyzátor s Arduino Uno
//
// Přijme data z AA-30 ZERO a vytvoří povrch
// což je vizualizace SWR jako funkce času
//
// 26. června 2017, Rig Expert Ukraine Ltd.
//
zpracování importu.seriál.*;Sériová NULA;
int krok; // Kroky komunikačního protokolu (0 – nastavení frekvence; 1 – nastavení rozsahu; 2 – zahájení měření)int maxVzorky = 100; // Počet bodů k měření
int maxSets = 50; // Časová hloubka
plovák body[][]; // Údaje o měření
int vzorek; // aktuální ukázka
int soubor; // aktuální soubor dat
int barvy[]; // barva křivky
int celkový; // celkový počet získaných vzorků
boolean připraven; // obrazovka se překreslí, pokud je True
int Frekvence; // aktuální frekvence
int Rozsah; // aktuální rozsah// Kód pro odeslání příkazu do analyzátoru
prázdnota serializovat(Řetězec cmd) {
int len = cmd.délka();
int charPos = 0;
zatímco (len— != 0) {
NULA.napsat(cmd.charAt(charPos));
charPos++;
}
}// Funkce výpočtu SWR
// Z0 – Impedance systému (tj. 50 pro 50 Ohm systémy)
// R – naměřená hodnota R
// X – naměřená hodnota X
plovák vypočítatSWR(plovák Z0, plovák R, plovák X) {
plovák SWR, Gamma;
plovák XX = X * X;
plovák jmenovatel = (R + Z0) * (R + Z0) + XX;
-li (jmenovatel == 0) {
vrátit se 1E9;
} jiný {
plovák l = (R – Z0) * (R – Z0);
plovák t = (l + XX);
t = t / jmenovatel;
Gamma = sqrt(t); // vždy >= 0
// POZNÁMKA:
// Gamma == -1 úplný negativní odraz, při zkratu vedení
// Gamma == 0 bez odrazu, když je čára dokonale přizpůsobena
// Gamma == +1 kompletní pozitivní odraz, když je linka rozpojená
-li (Gamma == 1.0) {
SWR = 1E9;
} jiný {
SWR = (1 + Gamma) / (1 – Gamma);
}
}

// návratové hodnoty
-li ((SWR > 200) || (Gamma > 0.99)) {
SWR = 200;
} jiný -li (SWR < 1) {
SWR = 1;
}
vrátit se SWR;
}

prázdnota založit() {
Frekvence = 115000000;
Rozsah = 230000000;
vzorek = 0;
soubor = –1;
krok = 0;
body = Nový plovák[maxSets + 1][maxVzorky + 1];
barvy = Nový int[maxSets + 1];
připraven = Nepravdivé;
celkový = 0;

Pozadí(0);
mrtvice(120, 240, 255, 255);
zdvih Hmotnost(1);
velikost(640, 480, P3D);

printArray(Seriál.seznam());
// Nahraďte název COM takovým, který odpovídá vašim podmínkám
NULA = Nový Seriál(tento, "COM21", 38400);
NULA.vyrovnávací pamětiDokud(13);
zpoždění(1000);
serializovat("SW0\r\n“);
}

prázdnota drawSurface() {
připraven = Nepravdivé;
světla();
plovák sp = 0.001 * počet snímků;
Fotoaparát((šířka / 3) * hřích(sp), 0, 800, šířka / 2, výška / 2, 0, 0, 1, 0);

Pozadí(0, 0, 0);
velikost textu(30);
vyplnit(255, 255, 255);
// —————- Osa ————————
mrtvice(255, 255, 255, 128);
čára(0, výška, 0, šířka výška, 0);

čára(0, 0, 0, 0, výška, 0);
čára(šířka, 0, 0, šířka výška, 0);

čára(0, výška, 5 * maxSets, 0, výška, 0);
čára(šířka / 2, výška, 5 * maxSets, šířka / 2, výška, 0);
čára(šířka výška, 5 * maxSets, šířka, výška, 0);

// —————- Frekv. markery ------
mrtvice(255, 255, 255, 128);
čára(šířka / 2, 0, 0, šířka / 2, výška, 0);
zarovnání textu(CENTRUM);
text(Frekvence / 1E3 + "kHz", šířka / 2, výška, 5 * maxSets);
text(((Frekvence / 1E3) – (Rozsah / 2E3)) + "kHz", 0, výška, 5 * maxSets);
text(((Frekvence / 1E3) + (Rozsah / 2E3)) + "kHz", šířka výška, 5 * maxSets);

// —————– Název režimu ——————
zarovnání textu(VLEVO, ODJET);
velikost textu(36);
text(„Graf SWR jako funkce času“, 0, –100, 0);
velikost textu(30);
-li (hnědý < výška / 5) {
-li (mouseX < šířka / 2) {
vyplnit(255, 0, 0);
zarovnání textu(ŽE JO);
text("F =" + Frekvence / 1E3 + "kHz", šířka / 2 – 50, –50, 0);
vyplnit(255, 255, 255);
zarovnání textu(VLEVO, ODJET);
text("Rozsah =" + Rozsah / 1E3 + "kHz", šířka / 2 + 50, –50, 0);
} jiný {
vyplnit(255, 255, 255);
zarovnání textu(ŽE JO);
text("F =" + Frekvence / 1E3 + "kHz", šířka / 2 – 50, –50, 0);
vyplnit(255, 0, 0);
zarovnání textu(VLEVO, ODJET);
text("Rozsah =" + Rozsah / 1E3 + "kHz", šířka / 2 + 50, –50, 0);
}
} jiný {
vyplnit(255, 255, 255);
zarovnání textu(ŽE JO);
text("F =" + Frekvence / 1E3 + "kHz", šířka / 2 – 50, –50, 0);
zarovnání textu(VLEVO, ODJET);
text("Rozsah =" + Rozsah / 1E3 + "kHz", šířka / 2 + 50, –50, 0);
}

// Získejte extrémy
plovák minV = 1E9;
plovák maxV = –1E9;
pro (int i = 0; i  < soubor; i++) {
pro (int j = 0; j  < maxVzorky + 1; j++) {
-li (body[i][j] > maxV) maxV = body[i][j];
-li (body[i][j] > maxV) minV = body[i][j];
}
}

println("Min =" + minV + “; Max = " + maxV);
minV = 1;
-li (maxV < 2) maxV = 2;
jiný -li (maxV < 5) maxV = 5;
jiný -li (maxV < 10) maxV = 10;
jiný maxV = 100;
plovák hK = šířka / maxVzorky;
plovák vK = výška / (maxV – minV);
plovák zK = 2;

// —————– Kreslení vodorovných značek —————–
vyplnit(255, 255, 255);
zarovnání textu(ŽE JO);
čára(0, výška – vK, 0, šířka výška – vK, 0); // SWR = 2
text("SWR = 2,0", 0, výška – vK, 0);
čára(0, výška – 2 * vK, 0, šířka výška – 2 * vK, 0); // SWR = 3
text("SWR = 3,0", 0, výška – 2 * vK, 0);
čára(0, výška – 4 * vK, 0, šířka výška – 4 * vK, 0); // SWR = 5
text("SWR = 5,0", 0, výška – 4 * vK, 0);

// Nakreslete čáry
pro (int i = 0; i < soubor; i++) {
-li (barvy[i] % 5 == 0) mrtvice(255, 0, 0, 255 * i / soubor);
jiný mrtvice(120, 240, 255, 255 * i / soubor);

pro (int j = 1; j < maxVzorky + 1; j++) {
// kreslení pouze pokud SWR < 100.0
-li (body[i][j – 1] < 100) {
čára((j – 1) * hK, výška – (body[i][j – 1] – 1) * vK, i * zK, j * hK, výška – (body[i][j] – 1) * vK, i * zK);  // Zpracování příchozích dat void serialEvent(Serial p) { String inString; inString = p.readString(); if (inString.indexOf(“OK”) >= 0) {
}
}
}
} prázdnota kreslit() {
-li (připraven) {
drawSurface();
}
}
přepínač (krok) {
případ 0: serializovat("FQ" + Frekvence + “\r\n“);
krok = 1;
přestávka;

případ 1: serializovat("SW" + Rozsah + “\r\n“);
krok = 2;
přestávka;

případ 2: serializovat("FRX" + str(maxVzorky) + “\r\n“);
krok = 0;
vzorek = 0;
-li (soubor == maxSets) {
// posun křivek zpět
pro (int i = 1; i < maxSets + 1; i++) {
barvy[i – 1] = barvy[i];
pro (int j = 0; j < maxVzorky + 1; j++) {
body[i – 1][j] = body[i][j];
}
}
} jiný {
soubor++;
}
barvy[soubor] = celkový++;
připraven = skutečný;
přestávka;
}

} jiný {
plovák[] nums = plovák(rozdělit(inString, ‘,’));
-li (nums.délka == 3) {
plovák SWR = vypočítatSWR(50, num[1], num[2]);
body[soubor][vzorek] = SWR;
vzorek++;
}
}
}

// Změňte hodnoty frekvence a rozsahu pomocí kolečka myši
prázdnota kolečko myši(Událost MouseEvent) {
plovák E = událost.getCount();
-li (hnědý < výška / 5) {
-li (mouseX < šířka / 2) { // Změna frekvence if (Frekvence > 1E5) {
Frekvence += E * 100000;
drawSurface();
}
} jiný {
// Změna rozsahu
-li (Rozsah > 1E5) {
Rozsah += E * 1E5;
drawSurface();
}
}
}
}

NULA = Nový Seriál(tento, "COM16", 115200);

// UART most pro výměnu dat mezi
// Anténa a kabelový analyzátor RigExpert AA-30 ZERO a Arduino Uno
//
// Přijímá z Arduina, odesílá na AA-30 ZERO.
// Přijímá z AA-30 ZERO, odesílá do Arduina.
//
// 26. června 2017, Rig Expert Ukraine Ltd.
//
1TP42 včetněSoftwareSerial ZERO(4, 7); // RX, TX
//
// Upravil WB9RAA Ed March
// 6. ledna 2018
//
// mluví s AA-30 Zero rychlostí 38 400 baudů a
// upraví data vhodná pro tabulkový graf
//
// Zamete všechny ambasády s frekvencí asi 10K. kroky
// Vypočítá SWR za běhu, takže každý řádek textu
// odesláno je: “Freq,R,X,SWR \r\n”
// také smíchané s příkazy OK a fq sw frx
// Kompilováno s Arduino IDE 1.8.5
// celková doba rozmítání je asi 25 sekund pro pásma 160M-10M.
//
// Rychlejší vykreslování s „frx3“ na všech pásmech, takže se tisknou pouze okrajové a středové frekvence.
// Další nápady, sweep 1..30 Mhz a tiskněte F,R,X,SWR pouze tehdy, když je swr pod 2.0
//int j;
char HamBands[][35] = {
{ “\r\nver\r\n“ } , //0
{ „1900000 fq\r\n200 000 sw\r\nfrx20\r\n“ }, //1{ „3750000 fq\r\n500 000 sw\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

{ „7150000 fq\r\n300 000 sw\r\nfrx35\r\n“ }, //7

{ „10125000 fq\r\n50 000 sw\r\nfrx10\r\n“ }, //8

{ "fq14150000."\r\n300 000 sw\r\nfrx30\r\n“ }, //9

{ "fq18118000."\r\n100 000 sw\r\nfrx10\r\n“ }, //10

{ „fq21225000\r\n450 000 sw\r\nfrx45\r\n“ }, //11

{ „fq24940000\r\n100 000 sw\r\nfrx10\r\n“ }, //12

{ „fq28985000\r\n1970000 sw\r\nfrx50\r\n“ }, //13
{ “” }, // Značka konce //14
//

};

prázdnota založit()
{
NULA.začít(38400); // init UART na straně AA
NULA.spláchnout();
NULA.setTimeout(2500);
Seriál.začít(38400); // init UART na straně PC
Seriál.spláchnout();
zpoždění(50);
j = 0;
Seriál.println(“\r\n\nProjekt AA-30Zero Ver.20180107A od Ed March WB9RAA\n“);
Seriál.println(“\nPoužití anténního analyzátoru RigExpert 'AA-30 Zero'\nProhledejte všechna 1..30MHz pásma Ham.\nPo dokončení Stiskněte / pro opětovné spuštění. Jinak zadejte příkazy do AA-30 Zero\n“);
Seriál.println("AA-30 Zero Commands");
Seriál.println(“ver: ZÍSKEJTE VERZI AA FIRMWARE”);
Seriál.println(“fq1234567: SET STŘEDNÍ FREKVENCE V HERTZ ex. fq7150000”);
Seriál.println(“sw300000 : NASTAVTE ROZSAH ZAMETÁNÍ V HERTZ ex. sw300000 zametá 300 kHz od začátku do konce”);
Seriál.println(“frx123: ZAČNĚTE SWEEPING vrací F,R,X Celkem 123 řádků. frx3 vrací 3 řádky BEGIN,CENTER,END\n“);
}
dlouho tmo = 250;

prázdnota smyčka()
{
-li (NULA.dostupný())
{
String s = NULA.readStringUntil(‘\n‘);
s.nahradit(“\r“, “”);
Seriál.napsat(s.c_str()); // datový tok z AA do PC

int i = s.indexOf(‘,’);
-li (i > 0)
{
// Analyzujte řetězec na plovoucí R & X
i++;
plovák R = s.podřetězec(i).toFloat();
int ii = s.podřetězec(i).indexOf(‘,’);
plovák X = s.podřetězec(i + ii + 1).toFloat();
//
// Výpočet SWR z R & X
//
plovák XX = X * X;
plovák Rm = (R – 50) * (R – 50);
plovák Rp = (R + 50) * (R + 50);
plovák N = sqrt(Rm + XX);
plovák D = sqrt(Rp + XX);
plovák G = N / D;
plovák vswr = (1 + G) / (1 – G);
// Protože nemůžeme tisknout floats, dostaneme int & zlomek jako 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;
-li (v1 < 0)
{
v1 = 99;
v2 = 0;
}
char z[50];
sprintf(z, “,%d.%02d”, v1, v2); // výpočet swr jako řetězec
Seriál.napsat(z); // připojit k řetězci
}
Seriál.napsat(“\r\n“); // a terninate jako to bylo u CR LF
tmo = 250;
}
-li (Seriál.dostupný())
{
char c1 = Seriál.číst();
-li (c1 == ‘/’)
{
j = 0;
}
jiný
{
NULA.napsat(c1); // datový tok z PC do AA
}
tmo = 250;
}
zpoždění(1);
-li (—tmo < 0)
{
-li (HamBands[j][0] != 0)
{
pro (int i = 0; HamBands[j][i] != 0; i++)
{
int ch = HamBands[j][i];
Seriál.napsat(ch);
NULA.napsat(ch);
-li (ch == ‘\n‘)
{
pro (int d = 0; d < 50; d++)
{
zpoždění(1);
-li (NULA.dostupný())
{
Seriál.napsat(NULA.číst()); // datový tok z AA do PC
}
}
}
}
tmo = 250;
j++;
}
}
}