Jadaside töötlemisega
Seeriaklass
Jadaside kasutamise toimingud Töötlemine on klassis määratletud Serial.Esimene tehing nende kasutamiseks programmis (eskiis) on lisada see koodi import processing.serial.*;.
Klass Serial Sellel on viis erinevat konstruktorit, sõltuvalt näidatud parameetritest. Ainus nõutav parameeter on põhiobjekt (vanem), mis tavaliselt vastab klassi põhiprogrammile (näiteks programmi aknale). PApplet. Nagu tavaliselt, on kirjutatav programm vanem ( eskiis praegune), on selle esimese kohustusliku parameetri väärtus this.
Ülejäänud viis parameetrit, mida saab konstruktorile edastada, on ① kiirus, ② jadapordi nimi ③ pariteet protokollis kasutatavad ④ andmebitid ja ⑤ stoppbitid. Kõige sagedamini edastatavad parameetrid, lisaks nõutavale põhiobjektile, on pordi nimi ja kiirus.
La jadaside kiirus on täisarv (int) See vaikeväärtus on 9600 kui seda parameetrit konstruktorile ei edastata.
Saadaval jadapordid. Loendi meetod
El sadama nimi on süsteemi poolt määratud kujul sellisel viisil, näiteks sisse Linuxi distributsioonid see saab olema midagi sellist /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (olenevalt pordi tüübist), samas kui Windowsis on see midagi sarnast COM12. Kui port pole seadmega füüsiliselt seotud, ei tea programm tavaliselt, millist porti kasutada. Levinud viis pordi valimiseks on hankida saadaolevate portide loend, näidata seda kasutajale ja lubada tal valida see, mida nad soovivad kasutada. Meetod Serial.list() tagastab tekstistringide vektori (String) süsteemis saadaolevate portide nimedega.
|
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, mida teegi kasutab vaikimisi Serial on esimene meetodiga tagastatutest list (kindlasti COM1 Windowsis või /dev/ttyS0 en GNU / Linux). Välja arvatud väga piiratud kontekstides, kus töötav riistvara on rangelt teada (nt süsteem kioskirežiimis), ei jäeta seda tavaliselt välja ja sihtport on selgelt märgitud.
Ülaltoodud ekraanipilt näitab süsteemi väljundit GNU / Linux millel on neli jadaporti RS-232 (ttyS0 a ttyS3) ja viis kahte tüüpi adapterit (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Jadaportidele juurdepääsuks peab kasutaja kuuluma gruppi, kuhu süsteem need määrab, tavaliselt tty o sissehelistamine. Ülaltoodud pildi ekraanipildil näete, et jadapordid on loetletud koos ls /dev/tty[ASU]* -la kuuluvad rühma sissehelistamine millel on nende lugemis- ja kirjutamisõigused.
Jadaprotokolli parameetrid
La pariteet jadaside väljendatakse Töötlemine tegelasena (char), mis võib võtta järgmised väärtused: ① N (mitte ükski), et mitte tuvastada pariteet, ② E (isegi), et näidata, et pariteedi bitt on paaris, ③ O (imelik), et näidata, et pariteedi bitt on paaritu, ④ M (märk), et alati teha pariteedi bitt ja ⑤ S (ruum), et alati üks neist teha pariteedi bitt. Vaikeväärtus, kui seda ei edastata konstruktorile parameetrina, on N (ilma pariteet).
Arv andmebitid, mis on vaikimisi kaheksa, näitab bittide arvu, mis moodustavad netoandmekoormuse (mida nimetatakse märgiks või mõnikord sõnaks), mis edastatakse kaadri igas põhiühikus. Andmebittide arvu näitav parameeter väljendatakse täisarvuna (int).
Lõpuks näitab viies võimalik parameeter lõpliku hinde kestust, väljendatuna stop bitid (stop bitid), mis on näidatud numbrina, mis on esitatud ujukoma (float), mis võib võtta väärtused 1.0 (vaikeväärtus, kui parameetrit konstruktorile ei edastata), 1.5või 2.0.
Serial klassi konstruktorid
Järgmine loend näitab erinevaid parameetrite kombinatsioone, mida saab klassi konstruktorile edastada Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Lõpetage jadaside. Peatusmeetod.
Instantimisel määratud jadapordi vabastamiseks Serial, ja et teised süsteemirakendused saavad seda kasutada, lõpetatakse side meetodiga stop, mis ei saa parameetreid.
|
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
}
|
Andmete saatmine jadapordi kaudu. Kirjutamismeetod
Andmete saatmiseks klass Serial de Töötlemine hõlmab meetodit write millega saate edastada ① tekstistringe (String), ② baiti või ③ baiti vektoreid (byte[]). Seda on huvitav meenutada byte en Töötlemine (Praegu Java) tähistab täisarvu vahemikus -128 kuni 127 ja vaikimisi kasutavad stringid kodeeringut 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
}
|
Andmete lugemine jadapordist
Et programm saaks jadapordi kaudu andmete vastuvõtmise ajal täita muid toiminguid, salvestatakse tavaliselt a puhver saabuvad andmed ja vajadusel lugege need läbi. Kuigi tavaliselt ei ole see väga tõhus, saate rakenduse peatada, et laadida kõik saadaolevad andmed; Kõige tavalisem on aga teabe lugemine selle saabumisel kas igas iteratsioonis draw, kui teatud kogus on saadaval või on saadud erikood.
Puhvris saadaolevate andmete hulk. Olemasolev meetod
Et teada saada, kas andmed on saabunud puhver seeria, meetod available tagastab sellesse juba salvestatud baitide arvu puhver. Mõlemal juhul võivad lugemistoimingud tagastada spetsiaalse väärtuse (nt -1 o null), kui proovite laadida andmeid puhver seeria kui tühi.
|
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”);
}
|
Laadige üks bait korraga. Lugemise meetod
Klassi peamised meetodid Serial jadapordi poolt vastuvõetud teabe lugemiseks on "tüüpi read» mis erinevad nende vahel peamiselt selle poolest, millist tüüpi andmeid nad saadud teabe edastavad.
read kasutatakse jadapordi poolt vastuvõetud baitide edastamiseks väärtusena vahemikus 0 kuni 255. Andmetüübina byte de Töötlemine tähistab vahemikku -128 ja 127, mitte 0 ja 255 vahel, on vaja kasutada int tagastatud vahemiku esitamiseks read. Kui proovite lugeda koos read ja puhver string on tühi, tagastab väärtuse -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());
}
}
|
Loe tähemärke jadapordist. ReadChar meetod
Meetod readChar See on sarnane read kuid see tagastab väärtuse vormingus char a asemel int. Nagu sisemiselt, char en Töötlemine (Praegu Java) salvestatakse kahe baidiga, mille väärtus valitakse lugemisel tagastamiseks readChar poolt puhver tühi seeria on 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());
}
}
|
Laadige tekstistring. Meetodid readString ja readStringUntil.
Meetod readString tagastab objekti String moodustatud kõigist saadavalolevatest andmetest puhver seeriaga konsulteerimise ajal.
Meetod readString loob tekstistringi, eeldades, et jadapordi poolt vastuvõetud baidid on vormingus ASCII nii et seda lugemismeetodit ei saa kasutada muude kodeeringute jaoks.
Kui jutt on lugemisest puhver seeria koos readString kui tühi, on tagastusväärtus null.
Meetod readStringUntil Lisa readString võime tagastada seadmesse laaditud teavet puhver seeria, mis jagab selle parameetrina edastatava erimärgi (koodi) abil. Selline saadud teabe lugemise viis võimaldab meil eristada nii eraldajaid kui ka terminaatoreid, mis aitavad saadud teavet tõlgendada.
Meetod readStringUntil tagasi tooma null kui sees puhver seeria ei leia talle edastatud argumendis määratud koodi (üks bait).
|
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
}
}
}
|
Järgmises koodis Arduino saadab jadapordi kaudu kolm teadet. Kaks esimest lõpevad vahekaardiga, nii et need kuvatakse konsoolis. Töötlemine, samas kui kolmandat, kuigi see saadetakse jadapordi kaudu, ei loeta readStringUntil(9) kuna see ei lõpe vahekaardiga (koos koodiga 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()
{
}
|
Andmeplokkide lugemine. Meetodid readBytes ja readBytesUntil.
Ülaltoodud meetodeid kasutatakse andmete lugemiseks kindlas vormingus, toorandmete plokkide lugemiseks või vormingus, mis ei ole sätestatud Töötlemine meetodeid kasutatakse readBytes y readBytesUntil
Meetod readBytes proovige lugeda saadaolevaid andmeid puhver seeria. Kui meetodile ei edastata ühtegi parameetrit readBytes kõik saadaolevad andmed loetakse ja tagastatakse vektoris (byte[]). Kui parameetrina edastatakse täisarv, loetakse maksimaalselt selle numbriga näidatud baitide arv ja need tagastatakse ka vektorina.
Kasutamiseks on kolmas viis readBytes, tõhusam, mis võtab argumendina baitvektori, millesse sisu sisestatakse puhver seeria. See kasutusviis readBytes tagastab täisarvu (int), mis tähistab loetud baitide arvu.
Meetod readBytesUntil töötab sarnaselt, kuid sisaldab esimest parameetrit, mis tähistab selle baidi väärtust, mis, kui see leitakse failis puhver, näitab lugemise lõppu. Selle meetodi puhul pole parameetril, mis määrab loetavate baitide maksimaalse arvu, mõtet, kuna summa määratakse spetsiaalse koodiga.
Meetodi toimimise testimiseks readBytes Oletame, et järgmine kood Arduino mis saadab jadapordi kaudu teksti.
|
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()
{
}
|
Järgmine näidisprogramm Töötlemine loeb jadapordist teksti 32-baidiste plokkidena (TOTAL_BYTES). Selle toimimise kontrollimiseks näitab see seda konsooli kaudu märkidena, sundides vastuvõetud baitide tüübi 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]);
}
}
}
}
|
Järgmisel ekraanipildil näete, kuidas neid konsoolis kuvatakse Töötlemine andmed, mis on laaditud plokkides (maksimaalselt) 32 baiti (TOTAL_BYTES) iga kord. Kuid on probleem, millest on juba räägitud: Arduino on saatnud värsse Federico Garcia Lorca vormingus tekstina kodeeritud näitest UTF-8, mida ei kasutata Töötlemine (Java), mida te eelistate UTF-16 nii need, kes ei vasta auastmele ASCII prinditavad on valesti tõlgendatud.
Selle probleemi lahendamiseks saab laadida märgistikke (tähemärk) ja määrake uus objekt String sundides seda esitama kodeeringuga UTF-8 nagu on näidatud järgmises näidiskoodis.
|
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));
}
}
}
|
Lugege viimaseid saadud andmeid. Viimane ja viimane Chari meetod.
Kuigi ülejäänud lugemismeetodid (tüüp read») nad laadivad teabe puhver seeria saabumise järjekorras (FIFO), nende kahe meetodiga viimane bait, mis on jõudnud puhver seeria. Meetod last tagastab viimase baidi väärtuse kui a int y lastChar tagastab väärtuse kui a char.
Jadapuhvri haldus
Kuigi seni nähtud meetodid on täiesti funktsionaalsed, ei ole need alati parim viis jadapordile juurdepääsu ärakasutamiseks. Andmete laadimiseks peavad nad perioodiliselt kontrollima nende olekut puhver seeriat ja lugege koodi korduvas osas saadaolevaid andmeid. Üldiselt tõhusam viis on lugeda andmeid ainult siis, kui teate, et need on saadaval.
Andmete vastuvõtmisel lugege jadaporti. Sariüritus.
Et pääseda juurde puhver jada, kui andmed vastu võetakse, saab jadasündmust ära kasutada, haldades seda meetodi määratluse kaudu serialEvent. See meetod kasutab argumendina jadaporti, mis selle käivitab.
|
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());
}
|
Määrake jadapuhvri suurus. Puhvermeetod.
Kui teate kasulike andmete ploki moodustavate baitide arvu, saate seda andmete lugemise stiili veelgi optimeerida. puhver seeria läbi serialEvent. Meetod buffer võimaldab määrata baitide arvu, mis salvestatakse puhver enne seeriaürituse käivitamist. Meetod eeldab parameetrina täisarvu, mis tähistab baitide arvu.
|
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());
}
}
|
Täitke puhver kuni väärtuse saamiseni. BufferUntil meetod.
Selle asemel, et määrata meetodi kutse serialEvent teatud hulga andmete jaoks puhver, meetodiga bufferUntil saate konfigureerida andmeid salvestama kuni eriväärtuse saabumiseni ja seejärel tõsta seeriasündmust. Sellele meetodile edastatud parameeter on a int mis esindab väärtust, mida kõne tekitab 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
}
|
Kustutage puhvrisse salvestatud andmed. Selge meetod.
Meetodiga clear Saate kustutada andmed, mis praegu on puhver. Seda meetodit saab kasutada näiteks uue andmete vastuvõtuseansi alustamiseks, ignoreerides eelmisest allesjäänud andmeid.
Tüüpiline töötlemisrakendus andmete lugemiseks jadapordi kaudu
Lõpuks on mugav kokku võtta objekti toimingud Serial de Töötlemine mida sagedamini kasutatakse, läbides tüüpilise näite andmete vastuvõtmisest läbi jadapordi, et joonistada nendega graafik, antud juhul virnastatud alade puhul.
Importige jadateek
|
1
|
import processing.serial.*;
|
Määrake andmeprotokoll (eraldajad)
|
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
|
Määrake jadaklassi objekt
|
1
|
Serial conexion_sensores;
|
Looge jadaklassi objekt, määrates kasutatava jadapordi
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Konfigureerige jadapordi puhver
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Rakendage seeriasündmuse käitleja
|
1
|
void serialEvent(Serial serie)
|
Lugege jadapuhvrit
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Konditsioneerige saadud andmed
|
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]);
}
|
Lõpetage jadaside
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Allolev näitekood illustreerib seda kokkuvõtet funktsionaalse (kuigi väga lihtsa) rakendusega, mis genereerib jadapordi kaudu vastuvõetavate väärtustega pindalagraafiku, mis sarnaneb järgmise animatsiooniga.
Et mitte eksida ülejäänud programmis ja keskenduda jadasuhtlusele Töötlemine, on eelmistele toimingutele vastavad koodiread esile tõstetud.
|
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];
}
}
|
Postita kommentaar