Seriell kommunikation med bearbetning
Serieklassen
Operationerna för att använda seriell kommunikation i Bearbetning definieras i klassen Serial.Den första operationen att utföra för att använda dem i ett program (skiss) kommer att vara att införliva den i koden med import processing.serial.*;.
Klass Serial Den har fem olika konstruktörer beroende på de angivna parametrarna. Den enda nödvändiga parametern är det överordnade objektet (förälder) som vanligtvis motsvarar klassens huvudprogram (säg programfönstret). PApplet. Som normalt kommer föräldern att vara programmet som skrivs (den skiss aktuell), kommer värdet på denna första obligatoriska parameter att vara this.
De andra fem parametrarna som kan skickas till konstruktören är ① hastigheten, ② namnet på serieporten ③ paritet som används i protokollet, ④ databitarna och ⑤ stoppbitarna. De parametrar som oftast skickas, förutom det obligatoriska överordnade objektet, är portnamnet och hastigheten.
La seriell kommunikationshastighet är ett heltal (int) som är standardvärdet 9600 om denna parameter inte skickas till konstruktorn.
Seriella portar tillgängliga. Listmetoden
El portnamn har den form som systemet bestämmer, på detta sätt, till exempel i Linux-distributioner det blir något liknande /dev/ttyS4 / dev / ttyACM3 o / dev / ttyUSB1 (beroende på porttyp), medan det på Windows kommer att vara något liknande COM12. Om inte en port är fysiskt associerad med en enhet vet programmet normalt inte vilken port som ska användas. Ett vanligt sätt att välja port är att skaffa en lista över de tillgängliga, visa den för användaren och låta dem välja den de vill använda. Metoden Serial.list() returnerar en vektor av textsträngar (String) med namnen på de portar som finns tillgängliga 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 används som standard av biblioteket Serial är den första av de som returneras av metoden list (säkert COM1 på Windows eller /dev/ttyS0 en GNU / Linux). Förutom i mycket begränsade sammanhang där hårdvaran som arbetas med är strikt känd (som ett system i kioskläge), utelämnas den vanligtvis inte och destinationsporten anges uttryckligen.
Skärmdumpen ovan visar resultatet av ett system GNU / Linux som har fyra seriella portar RS-232 (ttyS0 a ttyS3) och fem adaptrar av två typer (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
För att komma åt serieportarna måste användaren tillhöra den grupp som systemet tilldelar dem, normalt tty o uppringning. I skärmdumpen av bilden ovan kan du se att serieportarna listade med ls /dev/tty[ASU]* -la tillhör gruppen uppringning som har läs- och skrivbehörighet.
Seriella protokollparametrar
La paritet av seriell kommunikation uttrycks i Bearbetning som karaktär (char) som kan ta värdena: ① N (ingen) för att inte upptäcka paritet, ② E (även) för att indikera att paritetsbit är jämnt, ③ O (udda) för att indikera att paritetsbit är udda, ④ M (markera) för att alltid göra paritetsbit och ⑤ S (plats) att alltid göra en till paritetsbit. Standardvärdet, om det inte skickas till konstruktorn som en parameter, är N (utan paritet).
Antalet databitar, som är åtta som standard, indikerar antalet bitar som utgör nettodatanyttolasten (kallas ett tecken eller ibland ett ord) som sänds i varje basenhet i ramen. Parametern som anger antalet databitar uttrycks som ett heltal (int).
Slutligen, den femte möjliga parametern anger varaktigheten av slutmärket, uttryckt som stoppbitar (stoppbitar), vilket anges som ett tal representerat i flytpunkt (float) som kan ta värdena 1.0 (standardvärdet om parametern inte skickas till konstruktorn), 1.5en 2.0.
Konstruktörer av seriell klass
Följande lista visar de olika kombinationerna av parametrar som kan skickas till klasskonstruktorn Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Avsluta seriell kommunikation. Stoppmetoden.
För att frigöra serieporten, tilldelad vid instansiering Serial, och att andra systemapplikationer kan använda det, avslutas kommunikationen med metoden stop, som inte tar emot parametrar.
|
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
}
|
Skicka data via serieporten. Skrivmetoden
För att skicka data, klassen Serial de Bearbetning innehåller metoden write med vilka ① textsträngar kan överföras (String), ② byte eller ③ byte vektorer (byte[]). Det är intressant att komma ihåg det byte en Bearbetning (Vid java) representerar ett heltal mellan -128 och 127 och som standard använder strängar kodningen 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
}
|
Läs data från serieporten
För att programmet ska kunna utföra andra uppgifter medan data tas emot via serieporten är det vanligt att lagra i en buffert den data som kommer in och läs den när så är lämpligt. Även om det vanligtvis inte är särskilt effektivt, kan du stoppa programmet för att ladda all tillgänglig data; Det vanligaste är dock att läsa informationen när den kommer, antingen i varje iteration av draw, när en viss mängd är tillgänglig eller en speciell kod har mottagits.
Mängden data tillgänglig i bufferten. Den tillgängliga metoden
Att veta om data har kommit fram till buffert serien, metoden available returnerar antalet byte som redan har lagrats i denna buffert. I båda fallen kan läsoperationer returnera ett speciellt värde (som t.ex -1 o null) när du försöker ladda data från buffert serie när den är 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”);
}
|
Ladda en byte i taget. Läsmetoden
Klassens huvudsakliga metoder Serial som används för att läsa informationen som tas emot av en seriell port är de av "typ read» som skiljer sig mellan dem, främst genom vilken typ av data de levererar den mottagna informationen i.
read används för att leverera de byte som tas emot av serieporten som ett värde mellan 0 och 255. Som datatyp byte de Bearbetning representerar intervallet mellan -128 och 127 och inte mellan 0 och 255, är det nödvändigt att använda en int för att representera intervallet som returneras av read. Om du försöker läsa med read och buffert strängen är tom, returnerar värde -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());
}
}
|
Läs tecken från serieporten. ReadChar-metoden
Metoden readChar es liknande a read men det returnerar ett värde i format char istället för en int. Som internt, den char en Bearbetning (Vid java) lagras med två byte, det värde som valts att returnera vid läsning med readChar en buffert tom serie är 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());
}
}
|
Ladda en textsträng. Metoderna readString och readStringUntil.
Metoden readString returnerar ett objekt String bildas av alla tillgängliga uppgifter i buffert serien vid tidpunkten för konsultationen.
Metoden readString skapar textsträngen förutsatt att de byte som tas emot av serieporten är i formatet ASCII så denna läsmetod kan inte användas för andra kodningar.
Om det handlar om att läsa buffert serie med readString när det är tomt är returvärdet null.
Metoden readStringUntil Lägg till readString möjligheten att returnera information som laddats in i buffert serie som delar upp den med ett specialtecken (kod) som skickas som en parameter. Detta sätt att läsa den mottagna informationen gör att vi kan särskilja både separatorer och terminatorer som hjälper till att tolka den mottagna informationen.
Metoden readStringUntil ta tillbaka null när i buffert series hittar inte koden som anges i argumentet som skickas till den (en 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öljande kod för Arduino skickar tre meddelanden via serieporten. De två första slutar på en flik, så de kommer att visas i konsolen. Bearbetning, medan den tredje, även om den kommer att skickas via serieporten, inte kommer att läsas med readStringUntil(9) eftersom det inte slutar på en flik (med kod 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()
{
}
|
Läs datablock. Metoderna readBytes och readBytesUntil.
Metoderna som visas ovan används för att läsa data med specifika format, för att läsa block av rådata eller med ett format som inte tillhandahålls i Bearbetning metoder används readBytes y readBytesUntil
Metoden readBytes försök att läsa informationen som finns tillgänglig i buffert serier. Om ingen parameter skickas till metoden readBytes all tillgänglig data läses och returneras i en vektor (byte[]). Om ett heltal skickas som en parameter läses maximalt antalet byte som indikeras av detta nummer och de returneras också som en vektor.
Det finns ett tredje sätt att använda readBytes, effektivare, som tar som argument en byte-vektor i vilken innehållet i buffert serier. Detta sätt att använda readBytes returnerar ett heltal (int) som representerar antalet byte som har lästs.
Metoden readBytesUntil fungerar på ett liknande sätt men inkluderar en första parameter som representerar värdet på byten som, om den finns i buffert, indikerar slutet av läsningen. I den här metoden är parametern som bestämmer det maximala antalet byte som kommer att läsas inte meningsfull eftersom mängden kommer att bestämmas av specialkoden.
För att testa metodens funktion readBytes Låt oss anta följande kod för Arduino som skickar ett textmeddelande genom 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öljande exempelprogram för Bearbetning läser text från serieporten i 32-byte block (TOTAL_BYTES). För att verifiera att det fungerar, visar det det genom konsolen som tecken, vilket tvingar typen av byte som tas emot att 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 följande skärmdump kan du se hur de visas i konsolen Bearbetning data som har laddats i block om (maximalt) 32 byte (TOTAL_BYTES) varje gång. Men det finns ett problem som redan har pratats om: Arduino har skickat verserna av Federico García Lorca av exemplet kodat som text i format UTF-8, som inte är den som används Bearbetning (java), vad föredrar du UTF-16 så de som inte motsvarar rangen av ASCII utskrivbara tolkas felaktigt.
För att lösa detta problem kan teckenuppsättningarna laddas (teckenuppsättning) och definiera ett nytt objekt String tvingar den att representeras med kodning UTF-8 som visas i följande exempelkod.
|
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));
}
}
}
|
Läs de senaste mottagna uppgifterna. De sista och sistaChar-metoderna.
Medan resten av läsmetoderna (typ read») de laddar informationen om buffert serie i samma ordning som den har kommit (FIFO), med dessa två metoder den sista byten som har nått buffert serier. Metoden last returnerar värdet för den sista byten som en int y lastChar returnerar värdet som ett char.
Seriell bufferthantering
Även om metoderna som vi sett hittills är perfekt funktionella, representerar de inte alltid det bästa sättet att utnyttja åtkomst till serieporten. För att ladda data måste de regelbundet kontrollera statusen för buffert serien och läs tillgänglig information i en upprepad del av koden. Ett generellt sett mer effektivt sätt är att läsa data först när du vet att den är tillgänglig.
Läs serieporten när data tas emot. Seriehändelsen.
För att komma åt buffert seriell när data tas emot, kan seriehändelsen utnyttjas genom att hantera den genom metoddefinitionen serialEvent. Den här metoden använder den seriella porten som startar den som ett 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());
}
|
Storlek på den seriella bufferten. Buffertmetoden.
Om du vet antalet byte som utgör ett block av användbar data kan du optimera denna stil att läsa data ytterligare. buffert serie igenom serialEvent. Metoden buffer låter dig ställa in antalet byte som ska lagras i buffert innan du startar en seriehändelse. Metoden förväntar sig som en parameter ett heltal som representerar antalet 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 bufferten tills ett värde tas emot. Metoden bufferUntil.
Istället för att ställa in metodanropet serialEvent för en mängd data i buffert, med metoden bufferUntil du kan konfigurera att lagra data tills ett speciellt värde kommer och sedan höja seriehändelsen. Parametern som skickas till denna metod är a int som representerar värdet som genereras av samtalet till 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
}
|
Radera data som lagrats i bufferten. Den tydliga metoden.
med metoden clear Du kan radera data som för närvarande finns i buffert. Denna metod kan till exempel användas för att starta en ny datamottagningssession och ignorera data som finns kvar från den föregående.
Typisk bearbetningsprogram för att läsa data genom serieporten
Slutligen är det bekvämt att rekapitulera objektets operationer Serial de Bearbetning som är vanligare, går igenom ett typiskt exempel på att ta emot data via den seriella porten för att rita en graf med dem, i det här fallet med staplade områden.
Importera seriebiblioteket
|
1
|
import processing.serial.*;
|
Bestäm 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
|
Bestäm objektet för klassen Serial
|
1
|
Serial conexion_sensores;
|
Instantiera klassobjektet Serial genom att ställa in den seriella porten som används
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Konfigurera den seriella portbufferten
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Implementera en hanterare för seriehändelsen
|
1
|
void serialEvent(Serial serie)
|
Läs seriell buffert
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Betinga mottagna 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]);
}
|
Avsluta seriell kommunikation
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Exempelkoden nedan illustrerar denna sammanfattning med en funktionell (även om den är väldigt enkel) applikation som genererar ett områdesdiagram med de värden som tas emot via serieporten, något liknande vad följande animation visar.
För att inte gå vilse i resten av programmet och fokusera uppmärksamheten på seriell kommunikation med Bearbetning, är kodraderna som motsvarar föregående operationer markerade.
|
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];
}
}
|
Post kommentar