Seriell kommunikasjon med prosessering
Serieklassen
Operasjonene for å bruke seriell kommunikasjon i i prosess er definert i klassen Serial.Den første operasjonen som skal utføres for å bruke dem i et program (skisse) vil være å inkorporere den i koden med import processing.serial.*;.
Klasse Serial Den har fem forskjellige konstruktører avhengig av parameterne som er angitt. Den eneste nødvendige parameteren er det overordnede objektet (forelder) som vanligvis tilsvarer hovedprogrammet (for eksempel programvinduet) til klassen PApplet. Som normalt vil forelderen være programmet som skrives (den skisse gjeldende), vil verdien av denne første obligatoriske parameteren være this.
De andre fem parameterne som kan sendes til konstruktøren er ① hastigheten, ② navnet på serieporten ③ paritet brukt i protokollen, ④ databitene og ⑤ stoppbitene. De mest brukte parameterne, i tillegg til det nødvendige overordnede objektet, er portnavnet og hastigheten.
La seriell kommunikasjonshastighet er et heltall (int) enn standard til verdien 9600 hvis denne parameteren ikke sendes til konstruktøren.
Serieporter tilgjengelig. Listemetoden
El portnavn har formen bestemt av systemet, på denne måten, for eksempel i Linux-distribusjoner det blir noe sånt som /dev/ttyS4 / dev / ttyACM3 o / dev / ttyUSB1 (avhengig av porttype), mens på Windows vil det være noe sånt COM12. Med mindre en port er fysisk knyttet til en enhet, vil programmet normalt ikke vite hvilken port som skal brukes. En vanlig måte å velge porten på er å få en liste over de tilgjengelige, vise den til brukeren og la dem velge den de vil bruke. Metoden Serial.list() returnerer en vektor av tekststrenger (String) med navnene på portene som er tilgjengelige på systemet.
|
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());
}
|
Porten som brukes som standard av biblioteket Serial er den første av de som returneres av metoden list (sikkert COM1 på Windows eller /dev/ttyS0 en GNU / Linux). Bortsett fra i svært begrensede sammenhenger der maskinvaren det jobbes med er strengt kjent (for eksempel et system i kioskmodus), utelates den vanligvis ikke, og destinasjonsporten er uttrykkelig angitt.
Skjermbildet ovenfor viser utdataene til et system GNU / Linux som har fire serielle porter RS-232 (ttyS0 a ttyS3) og fem adaptere av to typer (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
For å få tilgang til de serielle portene må brukeren tilhøre gruppen som systemet tildeler dem, normalt tty o oppringing. I skjermbildet av bildet ovenfor kan du se at serieportene som er oppført med ls /dev/tty[ASU]* -la tilhører gruppen oppringing som har lese- og skrivetilgangstillatelser.
Seriell protokollparametere
La paritet av seriell kommunikasjon kommer til uttrykk i i prosess som en karakter (char) som kan ta verdiene: ① N (none) for ikke å oppdage paritet, ② E (til og med) for å indikere at paritetsbit er jevn, ③ O (Odd) for å indikere at paritetsbit er rart, ④ M (merke) for alltid å lage paritetsbit og ⑤ S (plass) å alltid lage en til paritetsbit. Standardverdien, hvis den ikke sendes til konstruktøren som en parameter, er N (uten paritet).
Antallet databiter, som er åtte som standard, indikerer antall biter som utgjør nettodatanyttelasten (kalt et tegn eller noen ganger et ord) som overføres i hver grunnleggende enhet i rammen. Parameteren som indikerer antall databiter er uttrykt som et heltall (int).
Til slutt angir den femte mulige parameteren varigheten av sluttmerket, uttrykt som stoppbiter (stoppbiter), som er angitt som et tall representert i flytende punkt (float) som kan ta verdiene 1.0 (standardverdien hvis parameteren ikke sendes til konstruktøren), 1.5en 2.0.
Konstruktører av seriell-klassen
Følgende liste viser de forskjellige kombinasjonene av parametere som kan sendes til klassekonstruktøren Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Avslutt seriell kommunikasjon. Stoppmetoden.
For å frigjøre den serielle porten, tildelt ved instansiering Serial, og at andre systemapplikasjoner kan bruke det, avsluttes kommunikasjon med metoden stop, som ikke mottar parametere.
|
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
}
|
Send data gjennom den serielle porten. Skrivemetoden
For å sende data, klassen Serial de i prosess inkorporerer metoden write som du kan overføre ① tekststrenger med (String), ② byte eller ③ byte vektorer (byte[]). Det er interessant å huske det byte en i prosess (At Java) representerer et heltall mellom -128 og 127, og strenger bruker som standard kodingen 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
}
|
Les data fra seriell port
For at programmet skal kunne utføre andre oppgaver mens data mottas gjennom serieporten, er det vanlig å lagre i en buffer dataene som kommer og les dem når det passer. Selv om det vanligvis ikke er veldig effektivt, kan du stoppe programmet for å laste inn alle tilgjengelige data; Det vanligste vil imidlertid være å lese informasjonen etter hvert som den kommer, enten i hver iterasjon av draw, når et visst antall er tilgjengelig eller en spesiell kode er mottatt.
Mengde data tilgjengelig i bufferen. Den tilgjengelige metoden
For å vite om data har kommet til buffer serien, metoden available returnerer antall byte som allerede er lagret i denne buffer. I begge tilfeller kan leseoperasjoner returnere en spesiell verdi (som f.eks -1 o null) når du prøver å laste inn data fra buffer serie når den er tom.
|
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”);
}
|
Last inn én byte om gangen. Lesemetoden
Klassens hovedmetoder Serial som tjener til å lese informasjonen mottatt av en seriell port er de av "type read» som skiller seg mellom dem, hovedsakelig av typen data de leverer informasjonen som mottas.
read brukes til å levere bytene mottatt av serieporten som en verdi mellom 0 og 255. Som datatype byte de i prosess representerer området mellom -128 og 127 og ikke mellom 0 og 255, er det nødvendig å bruke en int for å representere området returnert av read. Hvis du prøver å lese med read og buffer strengen er tom, returnerer verdi -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());
}
}
|
Les tegn fra serieporten. ReadChar-metoden
Metoden readChar ligner på read men det returnerer en verdi i format char i stedet for en int. Som internt char en i prosess (At Java) lagres med to byte, verdien som er valgt å returnere ved lesing med readChar en buffer tom serie er 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());
}
}
|
Last inn en tekststreng. ReadString og readStringUntil-metodene.
Metoden readString returnerer et objekt String dannet av alle tilgjengelige data i buffer serien på tidspunktet for konsultasjon.
Metoden readString oppretter tekststrengen forutsatt at bytene som mottas av den serielle porten er i formatet ASCII så denne lesemetoden kan ikke brukes for andre kodinger.
Hvis det handler om å lese buffer serie med readString når tom, er returverdien null.
Metoden readStringUntil legge til readString muligheten til å returnere informasjon lastet inn i buffer serie som deler den med et spesialtegn (kode) som sendes som en parameter. Denne måten å lese den mottatte informasjonen på gjør at vi kan skille både skilletegn og terminatorer som hjelper til med å tolke informasjonen som mottas.
Metoden readStringUntil Bring tilbake null når i buffer serien finner ikke koden spesifisert i argumentet som ble sendt til den (én byte).
|
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
}
}
}
|
I følgende kode for Arduino sender tre meldinger gjennom serieporten. De to første ender i en fane, så de vises i konsollen. i prosess, mens den tredje, selv om den vil bli sendt gjennom den serielle porten, ikke vil bli lest med readStringUntil(9) siden det ikke ender i en fane (med kode 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()
{
}
|
Les datablokker. ReadBytes og readBytesUntil-metodene.
Metodene vist ovenfor brukes til å lese data med bestemte formater, for å lese blokker med rådata eller med et format som ikke er gitt i i prosess metoder brukes readBytes y readBytesUntil
Metoden readBytes prøv å lese dataene som er tilgjengelige i buffer serie. Hvis ingen parameter sendes til metoden readBytes alle tilgjengelige data leses og returneres i en vektor (byte[]). Hvis et heltall sendes som en parameter, blir maksimalt antall byte angitt med dette tallet lest og de returneres også som en vektor.
Det er en tredje måte å bruke readBytes, mer effektiv, som tar som argument en byte-vektor der innholdet i buffer serie. Denne måten å bruke readBytes returnerer et heltall (int) som representerer antall byte som er lest.
Metoden readBytesUntil fungerer på lignende måte, men inkluderer en første parameter som representerer verdien av byten som, hvis den finnes i buffer, vil indikere slutten av lesingen. I denne metoden gir ikke parameteren som bestemmer det maksimale antallet byte som skal leses mening siden mengden vil bli bestemt av spesialkoden.
For å teste funksjonen til metoden readBytes La oss anta følgende kode for Arduino som sender en tekst gjennom serieporten.
|
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()
{
}
|
Følgende eksempelprogram for i prosess leser tekst fra serieporten i 32-byte blokker (TOTAL_BYTES). For å bekrefte at den fungerer, viser den den gjennom konsollen som tegn, og tvinger typen byte som mottas til å 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]);
}
}
}
}
|
I det følgende skjermbildet kan du se hvordan de vises i konsollen i prosess dataene som er lastet inn i blokker på (maksimalt) 32 byte (TOTAL_BYTES) hver gang. Men det er et problem som allerede har blitt snakket om: Arduino har sendt versene til Federico García Lorca av eksemplet kodet som tekst i format UTF-8, som ikke er den som brukes i prosess (Java), hva foretrekker du UTF-16 så de som ikke samsvarer med rangeringen av ASCII utskrivbare tolkes feil.
For å løse dette problemet kan tegnsettene lastes (tegnsett) og definer et nytt objekt String tvinger den til å bli representert med koding UTF-8 som vist i følgende eksempelkode.
|
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));
}
}
}
|
Les de siste dataene som er mottatt. De siste og sisteChar-metodene.
Mens resten av lesemetodene ("type read») de laster inn informasjonen til buffer serie i samme rekkefølge som den har kommet (FIFO), med disse to metodene den siste byten som har nådd buffer serie. Metoden last returnerer verdien av den siste byten som en int y lastChar returnerer verdien som en char.
Seriell bufferhåndtering
Selv om metodene som er sett så langt er perfekt funksjonelle, representerer de ikke alltid den beste måten å utnytte tilgangen til den serielle porten på. For å laste inn dataene, må de med jevne mellomrom sjekke statusen til buffer serie og les dataene som er tilgjengelige i en repeterende del av koden. En generelt mer effektiv måte er å lese dataene bare når du vet at de er tilgjengelige.
Les den serielle porten når data mottas. Seriehendelsen.
For å få tilgang til buffer seriell når dataene mottas, kan seriehendelsen utnyttes ved å administrere den gjennom metodedefinisjonen serialEvent. Denne metoden bruker serieporten som starter den som et argument.
|
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());
}
|
Størrelse på seriebufferen. Buffermetoden.
Hvis du vet antall byte som utgjør en blokk med nyttige data, kan du optimalisere denne stilen for å lese dataene ytterligere. buffer serie gjennom serialEvent. Metoden buffer lar deg angi antall byte som skal lagres i buffer før du starter en seriehendelse. Metoden forventer som en parameter et heltall som representerer antall byte.
|
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());
}
}
|
Fyll bufferen til en verdi er mottatt. BufferUntil-metoden.
I stedet for å sette metodekallet serialEvent for en mengde data i buffer, med metoden bufferUntil du kan konfigurere til å lagre data til en spesiell verdi kommer og deretter øke seriehendelsen. Parameteren som sendes til denne metoden er en int som representerer verdien produsert av oppfordringen til 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
}
|
Slett dataene som er lagret i bufferen. Den klare metoden.
Med metoden clear Du kan slette dataene som for øyeblikket er i buffer. Denne metoden kan for eksempel brukes til å starte en ny datamottaksøkt og ignorere gjenværende data fra den forrige.
Typisk behandlingsprogram for lesing av data gjennom den serielle porten
Til slutt er det praktisk å rekapitulere operasjonene til objektet Serial de i prosess som er mer vanlig, går gjennom et typisk eksempel på mottak av data gjennom serieporten for å tegne en graf med dem, i dette tilfellet med stablede områder.
Importer seriebiblioteket
|
1
|
import processing.serial.*;
|
Bestem dataprotokoll (separatorer)
|
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
|
Bestem objektet til seriell-klassen
|
1
|
Serial conexion_sensores;
|
Instantier Serial-klasseobjektet ved å angi serieporten som brukes
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Konfigurer den serielle portbufferen
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Implementer en behandler for seriehendelsen
|
1
|
void serialEvent(Serial serie)
|
Les seriell buffer
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Betingelse for mottatte data
|
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]);
}
|
Avslutt seriell kommunikasjon
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Eksempelkoden nedenfor illustrerer dette sammendraget med en funksjonell (men veldig enkel) applikasjon som genererer en arealgraf med verdiene som mottas gjennom serieporten, noe som ligner på det følgende animasjon viser.
For ikke å gå seg vill i resten av programmet og fokusere oppmerksomheten på seriell kommunikasjon med i prosess, er kodelinjene som tilsvarer de tidligere operasjonene uthevet.
|
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];
}
}
|
Legg inn kommentar