Serijinis ryšys su apdorojimu
Serijinė klasė
Serijinio ryšio naudojimo operacijos Apdorojimas yra apibrėžti klasėje Serial.Pirmoji operacija, kurią reikia atlikti norint juos naudoti programoje (eskizas) bus įtraukti jį į kodą su import processing.serial.*;.
Klasė Serial Jame yra penki skirtingi konstruktoriai, priklausomai nuo nurodytų parametrų. Vienintelis būtinas parametras yra pirminis objektas (tėvas), kuri paprastai atitinka pagrindinę klasės programą (tarkime, programos langą). PApplet. Paprastai rašoma programa bus tėvas ( eskizas srovė), šio pirmojo privalomo parametro reikšmė bus this.
Kiti penki parametrai, kuriuos galima perduoti konstruktoriui, yra ① greitis, ② nuosekliojo prievado pavadinimas ③ paritetas naudojami protokole, ④ duomenų bitai ir ⑤ stop bitai. Dažniausiai perduodami parametrai, be reikalingo pirminio objekto, yra prievado pavadinimas ir greitis.
La nuosekliojo ryšio greitis yra sveikasis skaičius (int) Tai numatytoji reikšmė yra 9600 jei šis parametras konstruktoriui neperduodamas.
Galimi nuoseklieji prievadai. Sąrašo metodas
El uosto pavadinimas turi sistemos nustatytą formą tokiu būdu, pavyzdžiui, in „Linux“ paskirstymai bus kažkas panašaus /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (priklausomai nuo prievado tipo), o „Windows“ tai bus kažkas panašaus COM12. Jei prievadas nėra fiziškai susietas su įrenginiu, programa paprastai nežinos, kurį prievadą naudoti. Įprastas būdas pasirinkti prievadą yra gauti galimų prievadų sąrašą, parodyti jį vartotojui ir leisti pasirinkti tą, kurį nori naudoti. Metodas Serial.list() grąžina teksto eilučių vektorių (String) su sistemoje galimų prievadų pavadinimais.
|
1
2
3
4
5
6
7
8
9
|
// Mostrar los puertos serie disponibles en el sistema
import processing.serial.*;
void setup()
{
noLoop(); // No iterar (no llama a draw periódicamente)
println(Serial.list());
}
|
Prievadas, kurį pagal numatytuosius nustatymus naudoja biblioteka Serial yra pirmasis iš grąžinamų metodu list (tikrai COM1 „Windows“ arba „Windows“ /dev/ttyS0 en GNU / Linux). Išskyrus labai ribotus atvejus, kai aparatinė įranga, su kuria dirbama, yra griežtai žinoma (pvz., sistema kiosko režimu), ji paprastai nepraleidžiama, o paskirties prievadas yra aiškiai nurodytas.
Aukščiau pateikta ekrano kopija rodo sistemos išvestį GNU / Linux kuris turi keturis nuosekliuosius prievadus RS-232 (ttyS0 a ttyS3) ir penki dviejų tipų adapteriai (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Kad galėtų pasiekti nuosekliuosius prievadus, vartotojas turi priklausyti grupei, kuriai sistema juos priskiria, paprastai tty o skambinti. Aukščiau esančio vaizdo ekrano kopijoje matote, kad nuoseklieji prievadai yra išvardyti su ls /dev/tty[ASU]* -la priklauso grupei skambinti kuri turi skaitymo ir rašymo prieigos prie jų leidimus.
Serijinio protokolo parametrai
La paritetas serijinio ryšio yra išreikšta Apdorojimas kaip personažas (char), kuris gali įgauti reikšmes: ① N (nė vienas), kad neaptiktumėte paritetas, ② E (net) nurodyti, kad pariteto bitas yra lygus, ③ O (nelyginis) nurodyti, kad pariteto bitas yra nelyginis, ④ M (ženklas), kad visada padarytumėte pariteto bitas ir ⑤ S (erdvė), kad visada būtų vienas pariteto bitas. Numatytoji reikšmė, jei neperduota konstruktoriui kaip parametras, yra N (be paritetas).
Apie numeris duomenų bitai, kuris pagal numatytuosius nustatymus yra aštuoni, nurodo bitų, sudarančių grynąjį naudingąjį duomenų kiekį (vadinamas simboliu arba kartais žodžiu), kuris perduodamas kiekviename pagrindiniame kadro vienete, skaičių. Duomenų bitų skaičių nurodantis parametras išreiškiamas sveikuoju skaičiumi (int).
Galiausiai penktasis galimas parametras nurodo galutinio pažymio trukmę, išreikštą kaip stop bitai (stop bitai), kuris nurodomas kaip skaičius, pavaizduotas slankusis kablelis (float), kuris gali priimti vertes 1.0 (numatytoji reikšmė, jei parametras neperduodamas konstruktoriui), 1.5, arba 2.0.
Serijinės klasės konstruktoriai
Šiame sąraše rodomi skirtingi parametrų deriniai, kuriuos galima perduoti klasės konstruktoriui Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Nutraukti nuoseklųjį ryšį. Stabdymo metodas.
Norėdami atlaisvinti nuoseklųjį prievadą, priskirtą generuojant Serial, ir kad kitos sistemos programos gali jį naudoti, ryšiai nutraukiami naudojant metodą stop, kuri negauna parametrų.
|
1
2
3
4
5
6
7
8
9
10
|
import processing.serial.*;
Serial serie;
void setup()
{
noLoop(); // No iterar
serie=new Serial(this,“/dev/ttyUSB0”,9600); // Usar un puerto USB con un adaptador UART
serie.stop(); // Detiene las comunicaciones serie y libera el puerto ttyUSB0 para otros usos
}
|
Siųskite duomenis per nuoseklųjį prievadą. Rašymo.metodas
Norėdami siųsti duomenis, klasė Serial de Apdorojimas apima metodą write su kuria galite perduoti ① teksto eilutes (String), ② baitų arba ③ baitų vektoriai (byte[]). Įdomu tai prisiminti byte en Apdorojimas (Tuo Java) reiškia sveiką skaičių nuo -128 iki 127 ir pagal numatytuosius nustatymus eilutės naudoja kodavimą UTF-16.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
import processing.serial.*;
Serial serie;
String texto=“Ohm”;
void setup()
{
noLoop();
serie=new Serial(this,“/dev/ttyUSB0”,9600); // Usar un puerto USB con un adaptador UART
serie.write(texto); // Envía el texto “Ohm”
serie.write(10); // Envía un fin de línea \n que corresponde con el ASCII 10
serie.write(200); // Envía el valor -56 ¡Es un byte, va de -128 a 127! (200-256=-56)
serie.stop(); // Detiene las comunicaciones serie y libera el puerto ttyUSB0 para otros usos
}
|
Skaityti duomenis iš nuosekliojo prievado
Kad programa galėtų atlikti kitas užduotis, kol duomenys gaunami per nuoseklųjį prievadą, įprasta saugoti a buferis gautus duomenis ir prireikus juos perskaitykite. Nors paprastai tai nėra labai efektyvu, galite sustabdyti programą, kad įkeltumėte visus turimus duomenis; Tačiau dažniausiai bus perskaityta informacija, kai ji gaunama, arba kiekvienoje iteracijoje draw, kai yra tam tikras kiekis arba gautas specialus kodas.
Buferyje turimų duomenų kiekis. Galimas metodas
Norėdami sužinoti, ar gauti duomenys buferis serija, metodas available grąžina jau išsaugotų baitų skaičių buferis. Bet kuriuo atveju skaitymo operacijos gali grąžinti specialią reikšmę (pvz., -1 o null), kai bandote įkelti duomenis iš buferis serija, kai tuščia.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(1); // Llama a draw una vez por segundo
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
print(“Hay “);
print(serie.available());
println(” bytes en el buffer serie”);
}
|
Įkelkite po vieną baitą. Skaitymo metodas
Pagrindiniai klasės metodai Serial kurie naudojami nuosekliojo prievado gautai informacijai skaityti, yra „tipo read» kurie skiriasi daugiausia pagal duomenų, kuriais jie pateikia gautą informaciją, tipą.
read naudojamas baitų, gautų iš nuosekliojo prievado, pateikti kaip reikšmę nuo 0 iki 255. Kaip duomenų tipas byte de Apdorojimas reiškia intervalą nuo -128 iki 127, o ne nuo 0 iki 255, būtina naudoti int kad pavaizduotų grąžintą diapazoną read. Jei bandysite skaityti su read ir buferis eilutė tuščia, grąžina vertę -1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(10); // Llama a draw 10 veces por segundo
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>0)
{
println(serie.read());
}
}
|
Skaityti simbolius iš nuosekliojo prievado. ReadChar metodas
Metodas readChar yra panašus į read bet grąžina reikšmę formatu char vietoj a int. Kaip ir viduje, char en Apdorojimas (Tuo Java) yra saugomi su dviem baitais, o vertė pasirenkama grąžinti skaitant readChar pagal buferis tuščia serija 0xFFFF o -1.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>0)
{
print(serie.readChar());
}
}
|
Įkelkite teksto eilutę. Metodai readString ir readStringUntil.
Metodas readString grąžina objektą String sudarytas iš visų turimų duomenų buferis serijos konsultacijos metu.
Metodas readString sukuria teksto eilutę, darant prielaidą, kad baitai, gauti iš nuosekliojo prievado, yra tokio formato ASCII todėl šis skaitymo metodas negali būti naudojamas kitoms koduotėms.
Jei kalbama apie skaitymą buferis serija su readString kai tuščia, grąžinama vertė yra null.
Metodas readStringUntil Pridėti prie readString galimybė grąžinti įkeltą informaciją buferis seriją, padalijančią ją specialiu simboliu (kodu), kuris perduodamas kaip parametras. Toks gautos informacijos skaitymo būdas leidžia atskirti ir separatorius, ir terminatorius, kurie padeda interpretuoti gautą informaciją.
Metodas readStringUntil sugrąžink null kai į buferis serija neranda jai perduotame argumente nurodyto kodo (vienas baitas).
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import processing.serial.*;
Serial serie;
String mensaje;
void setup()
{
frameRate(5);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>1)
{
mensaje=serie.readStringUntil(9); // Lee los datos del buffer hasta encontrar un tabulador
if(mensaje!=null) // Si la respuesta no es null ya ha llegado el tabulador y el mensaje está completo
{
println(“Mensaje recibido: “+mensaje); // Mostrar el mensaje si ha llegado completo
}
}
}
|
Šiame kode skirta Arduino per nuoseklųjį prievadą siunčia tris pranešimus. Pirmieji du baigiasi skirtuke, todėl jie bus rodomi konsolėje. Apdorojimas, o trečiasis, nors ir bus siunčiamas per nuoseklųjį prievadą, nebus skaitomas readStringUntil(9) nes jis nesibaigia skirtuku (su kodu ASCII 9).
|
1
2
3
4
5
6
7
8
9
10
11
12
|
void setup()
{
Serial.begin(9600);
while(!Serial);
Serial.print(“Primer mensaje\t”);
Serial.print(“Segundo mensaje\t”);
Serial.print(“Tercer mensaje”); // Este mensaje no llega porque no termina en tabulador
}
void loop()
{
}
|
Skaityti duomenų blokus. ReadBytes ir readBytesUntil metodai.
Aukščiau aprašyti metodai naudojami duomenims nuskaityti tam tikrais formatais, neapdorotų duomenų blokams arba formatu, kuris nenumatytas Apdorojimas naudojami metodai readBytes y readBytesUntil
Metodas readBytes pabandykite perskaityti pateiktus duomenis buferis serija. Jei metodui neperduotas joks parametras readBytes visi turimi duomenys nuskaitomi ir grąžinami vektoriumi (byte[]). Jei kaip parametras perduodamas sveikasis skaičius, nuskaitomas maksimalus šiuo skaičiumi nurodytas baitų skaičius ir jie taip pat grąžinami kaip vektorius.
Yra ir trečias naudojimo būdas readBytes, efektyvesnis, o tai kaip argumentą ima baitų vektorių, į kurį įtraukiamas turinys buferis serija. Šis naudojimo būdas readBytes grąžina sveikąjį skaičių (int), kuris parodo nuskaitytų baitų skaičių.
Metodas readBytesUntil veikia panašiai, bet apima pirmąjį parametrą, nurodantį baito vertę, kuri, jei randama buferis, parodys skaitymo pabaigą. Taikant šį metodą, parametras, nustatantis maksimalų nuskaitomų baitų skaičių, neturi prasmės, nes kiekis bus nustatomas pagal specialų kodą.
Norėdami patikrinti metodo veikimą readBytes Tarkime, kad šis kodas Arduino kuri siunčia tekstą per nuoseklųjį prievadą.
|
1
2
3
4
5
6
7
8
9
10
|
void setup()
{
Serial.begin(9600);
while(!Serial);
Serial.println(“En Viena hay diez muchachas, un hombro donde solloza la muerte y un bosque de palomas disecadas. Hay un fragmento de la mañana en el museo de la escarcha. Hay un salón con mil ventanas.”);
}
void loop()
{
}
|
Toliau pateikiamas programos pavyzdys Apdorojimas nuskaito tekstą iš nuosekliojo prievado 32 baitų blokais (TOTAL_BYTES). Kad patikrintų, ar jis veikia, jis rodomas per konsolę kaip simbolius, priversdamas gautų baitų tipą char.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import processing.serial.*;
Serial serie;
byte bloque_datos[];
static byte TOTAL_BYTES=32;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
bloque_datos=new byte[TOTAL_BYTES];
}
void draw()
{
if(serie.available()>0)
{
bloque_datos=serie.readBytes(TOTAL_BYTES);
if(bloque_datos!=null)
{
for(byte numero_byte=0;numero_byte<bloque_datos.length;numero_byte++)
{
print((char)bloque_datos[numero_byte]);
}
}
}
}
|
Toliau pateiktoje ekrano kopijoje galite pamatyti, kaip jie rodomi konsolėje Apdorojimas duomenys, kurie buvo įkelti (ne daugiau kaip) 32 baitų blokais (TOTAL_BYTES) kiekvieną kartą. Tačiau yra problema, apie kurią jau buvo kalbėta: Arduino siuntė eiles Federico Garcia Lorca pavyzdžio, užkoduoto kaip tekstas formatu UTF-8, kuris nėra naudojamas Apdorojimas (Java), kas jums labiau patinka UTF-16 taigi tie, kurie neatitinka rango ASCII spausdinami yra interpretuojami neteisingai.
Norėdami išspręsti šią problemą, galima įkelti simbolių rinkinius (charsetas) ir apibrėžti naują objektą String verčiant jį pavaizduoti su koduote UTF-8 kaip parodyta toliau pateiktame kodo pavyzdyje.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import processing.serial.*;
import static java.nio.charset.StandardCharsets.*;
Serial serie;
byte bloque_datos[];
static byte TOTAL_BYTES=32;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
bloque_datos=new byte[TOTAL_BYTES];
}
void draw()
{
if(serie.available()>0)
{
bloque_datos=serie.readBytes(TOTAL_BYTES);
if(bloque_datos!=null)
{
print(new String(bloque_datos,UTF_8));
}
}
}
|
Skaityti naujausius gautus duomenis. Paskutinis ir paskutinisChar metodai.
Nors kiti skaitymo metodai („tipas read») jie įkelia informaciją buferis serija ta pačia tvarka, kokia buvo gauta (FIFO), naudojant šiuos du metodus, paskutinis baitas, pasiekęs buferis serija. Metodas last grąžina paskutinio baito reikšmę kaip a int y lastChar grąžina reikšmę kaip a char.
Serijinio buferio valdymas
Nors iki šiol matyti metodai puikiai veikia, jie ne visada yra geriausias būdas išnaudoti prieigą prie nuosekliojo prievado. Norėdami įkelti duomenis, jie turi periodiškai tikrinti būseną buferis seriją ir perskaitykite turimus duomenis pasikartojančioje kodo dalyje. Paprastai efektyvesnis būdas yra skaityti duomenis tik tada, kai žinote, kad jie yra prieinami.
Skaityti nuoseklųjį prievadą, kai gaunami duomenys. Serialinis renginys.
Norėdami pasiekti buferis serijinis, kai gaunami duomenys, serijos įvykį galima išnaudoti valdant jį per metodo apibrėžimą serialEvent. Šis metodas kaip argumentą naudoja nuoseklųjį prievadą, kuris jį paleidžia.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
print(comunicaciones.readChar());
}
|
Nustatykite serijinio buferio dydį. Buferio metodas.
Jei žinote baitų, sudarančių naudingų duomenų bloką, skaičių, galite toliau optimizuoti šį duomenų skaitymo stilių. buferis serija per serialEvent. Metodas buffer leidžia nustatyti baitų, kurie bus saugomi, skaičių buferis prieš pradedant serijinį renginį. Metodas kaip parametrą tikisi sveikojo skaičiaus, nurodančio baitų skaičių.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import processing.serial.*;
Serial serie;
void setup()
{
//noLoop();
serie=new Serial(this,“/dev/ttyUSB0”,9600);
serie.buffer(32); // Esperar a recibir 32 bytes antes de lanzar el evento Serial
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
while(comunicaciones.available()>0)
{
print(comunicaciones.readChar());
}
}
|
Užpildykite buferį, kol gausite vertę. BufferUntil metodas.
Užuot nustatę metodo iškvietimą serialEvent už tam tikrą duomenų kiekį buferis, su metodu bufferUntil galite sukonfigūruoti saugoti duomenis, kol gausite specialią reikšmę, ir tada padidinti serijos įvykį. Šiam metodui perduotas parametras yra a int kuri atspindi skambučio sukurtą vertę serialEvent.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import processing.serial.*;
Serial serie;
void setup()
{
serie=new Serial(this,“/dev/ttyUSB0”,9600);
serie.bufferUntil(9); // Espera a recibir un tabulador (ASCII 9) antes de llamar a serialEvent
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
println(comunicaciones.readString()); // Imprime en una línea diferente cada valor separado originalmente por tabuladores
}
|
Ištrinkite buferyje saugomus duomenis. Aiškus metodas.
su metodu clear Galite ištrinti šiuo metu esančius duomenis buferis. Šis metodas gali būti naudojamas, pavyzdžiui, norint pradėti naują duomenų priėmimo seansą, ignoruojant duomenis, likusius iš ankstesnio.
Įprasta apdorojimo programa, skirta duomenims skaityti per nuoseklųjį prievadą
Galiausiai patogu apibendrinti objekto operacijas Serial de Apdorojimas dažniausiai naudojami, pateikiant tipinį duomenų gavimo per nuoseklųjį prievadą pavyzdį, kad su jais būtų nubrėžtas grafikas, šiuo atveju sukrautų sričių atveju.
Importuokite serijos biblioteką
|
1
|
import processing.serial.*;
|
Nustatyti duomenų protokolą (atskyriklius)
|
1
2
|
static final String SEPARADOR=“\t”; // Los datos de cada sensor se separan con un tabulador
static final char TERMINADOR=10; // Cada grupo de datos se termina con un código ASCII 10 → Nueva línea → \n
|
Nustatykite serijos klasės objektą
|
1
|
Serial conexion_sensores;
|
Sukurkite serijos klasės objektą, nustatydami naudojamą nuoseklųjį prievadą
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Sukonfigūruokite nuosekliojo prievado buferį
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Įdiekite serijinio įvykio tvarkyklę
|
1
|
void serialEvent(Serial serie)
|
Skaityti serijinį buferį
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Kondicionuokite gautus duomenis
|
1
2
3
4
5
|
float[] valor=new float[texto_valor.length];
for(int numero_valor=0;numero_valor<texto_valor.length;numero_valor++)
{
valor[numero_valor]=parseFloat(texto_valor[numero_valor]);
}
|
Nutraukti nuoseklųjį ryšį
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Žemiau pateiktas pavyzdinis kodas iliustruoja šią santrauką su funkcine (nors ir labai paprasta) programa, kuri generuoja srities grafiką su reikšmėmis, gaunamomis per nuoseklųjį prievadą, panašiai kaip rodoma toliau pateiktoje animacijoje.
Kad nepasiklystumėte likusioje programos dalyje ir sutelktumėte dėmesį į serijinį ryšį su Apdorojimas, paryškintos kodo eilutės, atitinkančios ankstesnes operacijas.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
import processing.serial.*;
static final byte ROJO=0,VERDE=1,AZUL=2,OPACIDAD=3;
static final int CANTIDAD_SENSORES=3;
static final int CANTIDAD_VALORES=20;
static final String NOMBRE_FONDO=“fondo.png”;
static final int[][] COLOR_LINEA={{0x44,0x88,0xCC,0xFF},{0xFF,0xAA,0x00,0xFF},{0xCC,0x44,0xAA,0xFF}};
static final int[][] COLOR_AREA={{0x44,0x88,0xCC,0x88},{0xFF,0xAA,0x00,0x88},{0xCC,0x44,0xAA,0x88}};
static final int[] COLOR_FONDO={0xFF,0xFF,0XFF};
static final float GROSOR_LINEA=2.0;
static final float DIAMETRO_MARCA=8.0;
static final float VALOR_MINIMO=0.0; // Valor mínimo de la suma de todos los componentes
static final float VALOR_MAXIMO=100.0; // Valor máximo de la suma de valores
static final String SEPARADOR=“\t”; // Los datos de cada sensor se separan con un tabulador
static final char TERMINADOR=10; // Cada grupo de datos se termina con un código ASCII 10 → Nueva línea → \n
Serial conexion_sensores;
float[][] valor_sensor=new float[CANTIDAD_SENSORES][CANTIDAD_VALORES];
float coeficiente_valor;
float[] vertical_area=new float[CANTIDAD_VALORES];
float[] vertical_marca=new float[CANTIDAD_VALORES];
PImage fondo;
void setup()
{
size(792,396,P2D); // El tamaño de la ventana no se puede establecer con variables en setup (usar settings)
surface.setResizable(false);
surface.setTitle(“consumo relativo comparado”);
noLoop();
smooth(4);
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
conexion_sensores.bufferUntil(TERMINADOR);
for(int numero_sensor=0;numero_sensor<CANTIDAD_SENSORES;numero_sensor++)
{
for(int numero_valor=0;numero_valor<CANTIDAD_VALORES;numero_valor++)
{
valor_sensor[numero_sensor][numero_valor]=0.0;
}
}
fondo=loadImage(NOMBRE_FONDO);
coeficiente_valor=height/(VALOR_MAXIMO–VALOR_MINIMO);
//strokeCap(ROUND); // El modo del final de líneas por defecto es redondeado
//ellipseMode(CENTER); // Por defecto el modo de elipse es desde el centro
if(DIAMETRO_MARCA>GROSOR_LINEA) // Si la marca no es visible hay que configurar el tipo de esquina
{
strokeJoin(ROUND); // El modo de esquina por defecto es en ángulo
}
}
void draw()
{
for(int numero_valor=0;numero_valor<valor_sensor[0].length;numero_valor++)
{
vertical_area[numero_valor]=height;
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
vertical_area[numero_valor]-=(valor_sensor[numero_sensor][numero_valor]–VALOR_MINIMO)*coeficiente_valor;
}
vertical_marca[numero_valor]=vertical_area[numero_valor];
}
if(fondo==null)
{
background(COLOR_FONDO[ROJO],COLOR_FONDO[VERDE],COLOR_FONDO[AZUL]);
}
else
{
image(fondo,0,0);
}
strokeWeight(GROSOR_LINEA);
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
stroke
(
COLOR_LINEA[numero_sensor][ROJO],
COLOR_LINEA[numero_sensor][VERDE],
COLOR_LINEA[numero_sensor][AZUL],
COLOR_LINEA[numero_sensor][OPACIDAD]
);
fill
(
COLOR_AREA[numero_sensor][ROJO],
COLOR_AREA[numero_sensor][VERDE],
COLOR_AREA[numero_sensor][AZUL],
COLOR_AREA[numero_sensor][OPACIDAD]
);
beginShape();
for(int numero_valor=valor_sensor[numero_sensor].length–1;numero_valor>=0;numero_valor—)
{
vertex(numero_valor*width/(valor_sensor[numero_sensor].length–1),vertical_area[numero_valor]);
}
for(int numero_valor=0;numero_valor<valor_sensor[numero_sensor].length;numero_valor++)
{
vertical_area[numero_valor]+=(valor_sensor[numero_sensor][numero_valor]–VALOR_MINIMO)*coeficiente_valor;
vertex(numero_valor*width/(valor_sensor[numero_sensor].length–1),vertical_area[numero_valor]);
}
endShape(CLOSE);
if(DIAMETRO_MARCA>0)
{
noStroke();
fill
(
COLOR_LINEA[numero_sensor][ROJO],
COLOR_LINEA[numero_sensor][VERDE],
COLOR_LINEA[numero_sensor][AZUL],
COLOR_LINEA[numero_sensor][OPACIDAD]
);
for(int numero_valor=0;numero_valor<valor_sensor[numero_sensor].length;numero_valor++)
{
ellipse
(
numero_valor*width/(valor_sensor[numero_sensor].length–1),
vertical_marca[numero_valor],
DIAMETRO_MARCA,
DIAMETRO_MARCA
);
vertical_marca[numero_valor]=vertical_area[numero_valor];
}
}
}
}
void stop() // Al terminar un Applet. No hay garantía de que se ejecute y, como estas operaciones se realizan al terminar, en realidad no son necesarias y solo se incluyen para recordar el uso de clear y stop
{
conexion_sensores.clear(); // Solo para ilustrar la posibilidad de borrar los datos que queden en el buffer
conexion_sensores.stop(); // Solo para ilustrar la posibilidad de terminar las comunicaciones serie y liberar el puerto que se está usando
}
void serialEvent(Serial serie)
{
String[] texto_valor=serie.readString().split(SEPARADOR);
float[] valor=new float[texto_valor.length];
for(int numero_valor=0;numero_valor<texto_valor.length;numero_valor++)
{
valor[numero_valor]=parseFloat(texto_valor[numero_valor]);
}
nuevo_valor(valor_sensor,valor);
redraw();
}
void nuevo_valor(float[][] valor_sensor, float[] valor)
{
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
for(int numero_valor=1;numero_valor<valor_sensor[0].length;numero_valor++)
{
valor_sensor[numero_sensor][numero_valor–1]=valor_sensor[numero_sensor][numero_valor];
}
valor_sensor[numero_sensor][valor_sensor[0].length–1]=valor[numero_sensor];
}
}
|
Rašyti komentarą