Sériová komunikácia so spracovaním
Sériová trieda
Operácie na použitie sériovej komunikácie spracovanie sú definované v triede Serial.Prvá operácia vykonaná na ich použitie v programe (skica) bude začleniť ho do kódu s import processing.serial.*;.
Trieda Serial Má päť rôznych konštruktorov v závislosti od uvedených parametrov. Jediným povinným parametrom je nadradený objekt (rodič), ktorý zvyčajne zodpovedá hlavnému programu (povedzme oknu programu) triedy PApplet. Ako zvyčajne bude rodičom program, ktorý sa píše ( skica prúd), hodnota tohto prvého povinného parametra bude this.
Ďalších päť parametrov, ktoré možno odovzdať konštruktorovi, sú ① rýchlosť, ② názov sériového portu ③ parita použité v protokole, ④ dátové bity a ⑤ stop bity. Najčastejšie odovzdávanými parametrami, okrem požadovaného rodičovského objektu, sú názov portu a rýchlosť.
La rýchlosť sériovej komunikácie je celé číslo (int) predvolená hodnota je 9600 ak sa tento parameter neodovzdá konštruktorovi.
K dispozícii sú sériové porty. Metóda zoznamu
El názov portu má formu určenú systémom, týmto spôsobom napríklad v Linuxové distribúcie bude to niečo podobné /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (v závislosti od typu portu), zatiaľ čo na Windowse to bude niečo ako COM12. Ak nie je port fyzicky spojený so zariadením, program zvyčajne nevie, ktorý port má použiť. Bežným spôsobom výberu portu je získať zoznam dostupných portov, ukázať ho používateľovi a umožniť mu vybrať si ten, ktorý chce použiť. Metóda Serial.list() vráti vektor textových reťazcov (String) s názvami portov dostupných v systéme.
|
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());
}
|
Port, ktorý knižnica štandardne používa Serial je prvý z tých, ktoré metóda vráti list (určite COM1 na Windows alebo /dev/ttyS0 en GNU / Linux). S výnimkou veľmi obmedzených kontextov, v ktorých je hardvér, s ktorým sa pracuje, presne známy (napríklad systém v režime kiosku), sa zvyčajne nevynecháva a cieľový port je výslovne uvedený.
Snímka obrazovky vyššie zobrazuje výstup systému GNU / Linux ktorý má štyri sériové porty RS-232 (ttyS0 a ttyS3) a päť adaptérov dvoch typov (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Na prístup k sériovým portom musí používateľ normálne patriť do skupiny, do ktorej ich systém priradí tty o vytočiť. Na snímke obrazovky vyššie môžete vidieť, že sériové porty sú uvedené s ls /dev/tty[ASU]* -la patria do skupiny vytočiť ktorý má na nich prístupové oprávnenia na čítanie a zápis.
Parametre sériového protokolu
La parita sériovej komunikácie je vyjadrené v spracovanie ako postava (char), ktorý môže nadobúdať hodnoty: ① N (nikto), aby ste nezistili parita, ② E (i) na označenie toho paritný bit je párne, ③ O (nepárny) na označenie toho paritný bit je nepárne, ④ M (značka) vždy urobiť paritný bit a ⑤ S (priestor), aby sa vždy jedna paritný bit. Predvolená hodnota, ak nie je odovzdaná konštruktorovi ako parameter, je N (bez parita).
Počet dátové bity, čo je štandardne osem, označuje počet bitov, ktoré tvoria čisté dátové zaťaženie (nazývané znak alebo niekedy slovo), ktoré sa prenáša v každej základnej jednotke rámca. Parameter označujúci počet dátových bitov je vyjadrený ako celé číslo (int).
Nakoniec piaty možný parameter udáva trvanie výslednej známky, vyjadrené ako stop bity (stop bity), ktoré je označené ako číslo zastúpené v s pohyblivou rádovou čiarkou (float), ktoré môžu nadobudnúť hodnoty 1.0 (predvolená hodnota, ak sa parameter neodovzdá konštruktorovi), 1.5alebo 2.0.
Konštruktéri triedy Serial
Nasledujúci zoznam zobrazuje rôzne kombinácie parametrov, ktoré možno odovzdať konštruktorovi triedy Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Ukončite sériovú komunikáciu. Metóda zastavenia.
Na uvoľnenie sériového portu priradeného pri vytváraní inštancie Seriala že ho môžu používať iné systémové aplikácie, komunikácia sa ukončí touto metódou stop, ktorý neprijíma parametre.
|
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
}
|
Posielajte dáta cez sériový port. Metóda zápisu
Ak chcete odoslať údaje, trieda Serial de spracovanie zahŕňa metódu write pomocou ktorých je možné prenášať ① textové reťazce (String), ② bajtov alebo ③ bajtových vektorov (byte[]). Je zaujímavé si to pripomenúť byte en spracovanie (Na Jáva) predstavuje celé číslo medzi -128 a 127 a reťazce štandardne používajú kódovanie 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
}
|
Čítanie údajov zo sériového portu
Aby mohol program vykonávať iné úlohy, kým sú dáta prijímané cez sériový port, je obvyklé ukladať do a nárazník údaje, ktoré prichádzajú, a v prípade potreby ich prečítajte. Aj keď to zvyčajne nie je príliš efektívne, môžete aplikáciu zastaviť a načítať všetky dostupné údaje; Najbežnejšou vecou však bude čítanie informácií tak, ako prichádzajú, a to buď v každej iterácii draw, keď je k dispozícii určité množstvo alebo bol prijatý špeciálny kód.
Množstvo údajov dostupných vo vyrovnávacej pamäti. Dostupná metóda
Ak chcete vedieť, či údaje prišli nárazník séria, metóda available vráti počet bajtov, ktoré už boli v ňom uložené nárazník. V oboch prípadoch môžu operácie čítania vrátiť špeciálnu hodnotu (ako napr -1 o null) pri pokuse o načítanie údajov z nárazník séria, keď je prázdna.
|
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”);
}
|
Načítajte jeden bajt naraz. Metóda čítania
Hlavné metódy triedy Serial ktoré slúžia na čítanie informácií prijatých sériovým portom sú typu „ read» ktoré sa medzi sebou líšia najmä typom údajov, v ktorých doručujú prijaté informácie.
read sa používa na doručenie bajtov prijatých sériovým portom ako hodnoty medzi 0 a 255. Ako typ údajov byte de spracovanie predstavuje rozsah medzi -128 a 127 a nie medzi 0 a 255, je potrebné použiť int aby reprezentoval rozsah vrátený read. Ak sa pokúsite čítať s read a nárazník reťazec je prázdny, vráti hodnotu -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());
}
}
|
Čítajte znaky zo sériového portu. Metóda readChar
Metóda readChar je podobný read ale vráti hodnotu vo formáte char namiesto a int. Rovnako ako interne, char en spracovanie (Na Jáva) sú uložené s dvomi bajtmi, pričom hodnota, ktorá sa má vrátiť pri čítaní s readChar О nárazník je prázdna séria 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());
}
}
|
Načítať textový reťazec. Metódy readString a readStringUntil.
Metóda readString vráti objekt String vytvorené zo všetkých údajov dostupných v nárazník série v čase konzultácie.
Metóda readString vytvorí textový reťazec za predpokladu, že bajty prijaté sériovým portom sú vo formáte ASCII takže tento spôsob čítania nemožno použiť pre iné kódovania.
Ak ide o čítanie nárazník séria s readString keď je prázdny, návratová hodnota je null.
Metóda readStringUntil pridať k readString schopnosť vrátiť informácie načítané do nárazník séria, ktorá ho rozdeľuje špeciálnym znakom (kódom), ktorý sa odovzdáva ako parameter. Tento spôsob čítania prijatých informácií nám umožňuje rozlíšiť oddeľovače aj terminátory, ktoré pomáhajú interpretovať prijaté informácie.
Metóda readStringUntil priniesť späť null keď v nárazník séria nenájde kód špecifikovaný v argumente, ktorý jej bol odovzdaný (jeden bajt).
|
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
}
}
}
|
V nasledujúcom kóde pre Arduino odošle tri správy cez sériový port. Prvé dva končia na karte, takže sa zobrazia v konzole. spracovanie, zatiaľ čo tretí, hoci bude odoslaný cez sériový port, nebude načítaný readStringUntil(9) pretože nekončí na karte (s kódom 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()
{
}
|
Čítanie blokov údajov. Metódy readBytes a readBytesUntil.
Vyššie uvedené metódy sa používajú na čítanie údajov so špecifickými formátmi, na čítanie blokov nespracovaných údajov alebo s formátom, ktorý nie je uvedený v spracovanie používajú sa metódy readBytes y readBytesUntil
Metóda readBytes skúste si prečítať údaje dostupné v nárazník séria. Ak sa do metódy neodovzdá žiadny parameter readBytes všetky dostupné údaje sa načítajú a vrátia vo vektore (byte[]). Ak sa ako parameter odovzdá celé číslo, načíta sa maximálny počet bajtov označený týmto číslom a vrátia sa aj ako vektor.
Existuje tretí spôsob použitia readBytes, efektívnejšie, ktoré berie ako argument bajtový vektor, do ktorého je obsah nárazník séria. Tento spôsob použitia readBytes vráti celé číslo (int), ktorý predstavuje počet prečítaných bajtov.
Metóda readBytesUntil funguje podobným spôsobom, ale obsahuje prvý parameter, ktorý predstavuje hodnotu bajtu, ktorý, ak sa nachádza v nárazník, bude indikovať koniec čítania. Pri tejto metóde nedáva parameter, ktorý určuje maximálny počet bajtov, ktoré sa budú čítať, zmysel, pretože množstvo bude určené špeciálnym kódom.
Na testovanie fungovania metódy readBytes Predpokladajme nasledujúci kód pre Arduino ktorý posiela text cez sériový port.
|
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()
{
}
|
Nasledujúci príklad programu pre spracovanie číta text zo sériového portu v 32-bajtových blokoch (TOTAL_BYTES). Aby sa overilo, že funguje, zobrazí ho cez konzolu ako znaky, čím sa vynúti typ prijatých bajtov 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]);
}
}
}
}
|
Na nasledujúcej snímke obrazovky môžete vidieť, ako sa zobrazujú v konzole spracovanie údaje, ktoré boli načítané v blokoch (maximálne) 32 bajtov (TOTAL_BYTES) vždy. Je tu však problém, o ktorom sa už hovorilo: Arduino posiela verše z Federico García Lorca príkladu zakódovaného ako text vo formáte UTF-8, ktorý nie je použitý spracovanie (Jáva), čomu dávaš prednosť utf-16 takže tí, ktorí nezodpovedajú hodnosti ASCII vytlačiteľné sú nesprávne interpretované.
Na vyriešenie tohto problému je možné načítať znakové sady (znaková sada) a definujte nový objekt String prinútiť ho reprezentovať kódovaním UTF-8 ako je uvedené v nasledujúcom príklade kódu.
|
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));
}
}
}
|
Prečítajte si najnovšie prijaté údaje. Metódy last a lastChar.
Zatiaľ čo ostatné metódy čítania („typ read») načítajú informácie o nárazník séria v rovnakom poradí, v akom prišla (FIFO), pri týchto dvoch metódach posledný bajt, ktorý dosiahol nárazník séria. Metóda last vráti hodnotu posledného bajtu ako a int y lastChar vráti hodnotu ako a char.
Správa sériovej vyrovnávacej pamäte
Hoci doteraz videné metódy sú dokonale funkčné, nie vždy predstavujú najlepší spôsob, ako využiť prístup k sériovému portu. Aby mohli načítať údaje, musia pravidelne kontrolovať stav nárazník série a prečítajte si údaje dostupné v opakujúcej sa časti kódu. Všeobecne efektívnejší spôsob je čítať údaje len vtedy, keď viete, že sú k dispozícii.
Čítajte sériový port po prijatí údajov. Seriálové podujatie.
Pre prístup k nárazník sériový, keď sa prijmú dáta, udalosť Serial sa dá využiť riadením prostredníctvom definície metódy serialEvent. Táto metóda používa ako argument sériový port, ktorý ju spúšťa.
|
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());
}
|
Veľkosť sériovej vyrovnávacej pamäte. Metóda vyrovnávacej pamäte.
Ak poznáte počet bajtov, ktoré tvoria blok užitočných údajov, môžete tento štýl čítania údajov ďalej optimalizovať. nárazník cez sériu serialEvent. Metóda buffer umožňuje nastaviť počet bajtov, ktoré budú uložené v nárazník pred spustením sériového podujatia. Metóda očakáva ako parameter celé číslo, ktoré predstavuje počet bajtov.
|
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());
}
}
|
Naplňte zásobník, kým sa neobdrží hodnota. Metóda bufferUntil.
Namiesto nastavenia volania metódy serialEvent pre množstvo údajov v nárazník, s touto metódou bufferUntil môžete nakonfigurovať ukladanie údajov, kým nepríde špeciálna hodnota, a potom vyvolať udalosť Serial. Parameter odovzdaný tejto metóde je a int čo predstavuje hodnotu produkovanú volaním 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
}
|
Vymažte údaje uložené vo vyrovnávacej pamäti. Jasná metóda.
S metódou clear Môžete vymazať údaje, ktoré sú momentálne v nárazník. Táto metóda môže byť použitá napríklad na spustenie novej relácie príjmu dát ignorujúc dáta zostávajúce z predchádzajúcej relácie.
Typická aplikácia na spracovanie údajov na čítanie údajov cez sériový port
Na záver je vhodné rekapitulovať operácie objektu Serial de spracovanie ktoré sú bežnejšie používané, pričom prechádzajú typickým príkladom príjmu dát cez sériový port, aby sa s nimi nakreslil graf, v tomto prípade naskladaných oblastí.
Importujte sériovú knižnicu
|
1
|
import processing.serial.*;
|
Určite dátový protokol (oddeľovače)
|
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
|
Určite objekt triedy Serial
|
1
|
Serial conexion_sensores;
|
Vytvorte inštanciu objektu triedy Serial nastavením použitého sériového portu
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Nakonfigurujte vyrovnávaciu pamäť sériového portu
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Implementujte obsluhu pre udalosť seriálu
|
1
|
void serialEvent(Serial serie)
|
Prečítajte si sériovú vyrovnávaciu pamäť
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Upravte prijaté údaje
|
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]);
}
|
Ukončite sériovú komunikáciu
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Príklad kódu nižšie ilustruje toto zhrnutie s funkčnou (hoci veľmi jednoduchou) aplikáciou, ktorá generuje plošný graf s hodnotami, ktoré sa prijímajú cez sériový port, niečo podobné tomu, čo ukazuje nasledujúca animácia.
Aby ste sa nestratili vo zvyšku programu a zamerali pozornosť na sériovú komunikáciu s spracovanie, sú zvýraznené riadky kódu, ktoré zodpovedajú predchádzajúcim operáciám.
|
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];
}
}
|
Pridať komentár