Soros kommunikáció feldolgozással
A soros osztály
A soros kommunikáció használatához szükséges műveletek Feldolgozás osztályban vannak meghatározva Serial.Az első művelet a programban való használatukhoz (vázlat) az lesz, hogy beépítsük a kódba import processing.serial.*;.
Osztály Serial Öt különböző konstruktorral rendelkezik a megadott paraméterektől függően. Az egyetlen kötelező paraméter a szülőobjektum (szülő), amely általában az osztály fő programjának (mondjuk a programablaknak) felel meg PApplet. Mint általában, a szülő lesz az írandó program (a vázlat áram), ennek az első kötelező paraméternek az értéke lesz this.
A másik öt paraméter, amely átadható a konstruktornak: ① a sebesség, ② a soros port neve ③ a paritás a protokollban használt ④ adatbitek és ⑤ stop bitek. A leggyakrabban átadott paraméterek a szükséges szülőobjektum mellett a portnév és a sebesség.
La soros kommunikációs sebesség egy egész szám (int), amely alapértelmezett értéke 9600 ha ezt a paramétert nem adjuk át a konstruktornak.
Soros portok állnak rendelkezésre. A lista módszere
El port neve a rendszer által meghatározott formája van, ilyen módon, például in Linux disztribúciók valami ilyesmi lesz /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (port típusától függően), míg Windowson valami ilyesmi lesz COM12. Hacsak egy port nincs fizikailag társítva egy eszközhöz, a program általában nem tudja, melyik portot használja. A port kiválasztásának gyakori módja az elérhető portok listájának beszerzése, megmutatása a felhasználónak, és lehetővé téve, hogy kiválassza a használni kívánt portot. A módszer Serial.list() szöveges karakterláncok vektorát adja vissza (String) a rendszeren elérhető portok nevével.
|
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());
}
|
A könyvtár által alapértelmezés szerint használt port Serial a metódus által visszaadottak közül az első list (biztosan COM1 Windows vagy /dev/ttyS0 en GNU / Linux). Azon nagyon korlátozott kontextusok kivételével, amelyekben a dolgozott hardver szigorúan ismert (például kioszk módban lévő rendszer), általában nem hagyják ki, és a célportot kifejezetten feltüntetik.
A fenti képernyőképen egy rendszer kimenete látható GNU / Linux amelynek négy soros portja van RS-232 (ttyS0 a ttyS3) és öt kétféle adapter (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
A soros portok eléréséhez a felhasználónak abba a csoportba kell tartoznia, amelyhez a rendszer hozzárendeli őket, általában tty o tárcsázás. A fenti kép képernyőképen látható, hogy a soros portok listája a következővel: ls /dev/tty[ASU]* -la csoporthoz tartoznak tárcsázás amely olvasási és írási hozzáférési jogosultsággal rendelkezik rajtuk.
Soros protokoll paraméterei
La paritás soros kommunikáció - ban kifejezve Feldolgozás mint karakter (char), amely a következő értékeket veheti fel: ① N (egyik sem), hogy ne észlelje a paritás, ② E (még), jelezve, hogy a paritás bit páros, ③ O (páratlan), jelezve, hogy a paritás bit páratlan, ④ M (jel), hogy mindig a paritás bit és ⑤ S (hely), hogy mindig az egyik a paritás bit. Az alapértelmezett érték, ha nem adjuk át paraméterként a konstruktornak, az N (nélkül paritás).
Száma adatbitek, amely alapértelmezés szerint nyolc, a keret egyes alapegységeiben továbbított nettó adatterhelést alkotó bitek számát jelzi (amelyet karakternek vagy néha szónak neveznek). Az adatbitek számát jelző paraméter egész számként van kifejezve (int).
Végül az ötödik lehetséges paraméter a végső jegy időtartamát jelzi, kifejezve stop bitek (stop bitek), amely számként van jelölve lebegőpont (float), amely felveheti az értékeket 1.0 (az alapértelmezett érték, ha a paramétert nem adjuk át a konstruktornak), 1.5egy 2.0.
A Serial osztály konstruktőrei
A következő lista az osztálykonstruktornak átadható paraméterek különböző kombinációit mutatja be Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Soros kommunikáció befejezése. A stop módszer.
A példányosításkor hozzárendelt soros port felszabadítása Serial, és hogy más rendszeralkalmazások is használhatják, a kommunikáció megszakad a metódussal stop, amely nem kap paramétereket.
|
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
}
|
Adatok küldése a soros porton keresztül. Az írás.módszer
Adatküldéshez az osztály Serial de Feldolgozás magában foglalja a módszert write amellyel ① szöveges karakterláncokat küldhet (String), ② bájt vagy ③ bájt vektorok (byte[]). Érdekes erre emlékezni byte en Feldolgozás (A Jáva) egy -128 és 127 közötti egész számot jelöl, és alapértelmezés szerint a karakterláncok a kódolást használják 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
}
|
Adatok olvasása a soros portról
Annak érdekében, hogy a program más feladatokat is el tudjon végezni, miközben a soros porton keresztül adat érkezik, általában a ütköző a beérkező adatokat, és szükség esetén olvassa el. Bár általában nem túl hatékony, leállíthatja az alkalmazást az összes rendelkezésre álló adat betöltéséhez; A legáltalánosabb azonban az lesz, hogy az információt beérkezésükkor olvassuk, akár minden iterációban draw, ha egy bizonyos mennyiség elérhető, vagy speciális kód érkezett.
A pufferben elérhető adatok mennyisége. Az elérhető módszer
Hogy megtudja, megérkeztek-e adatok ütköző sorozat, a módszer available az ebben már tárolt bájtok számát adja vissza ütköző. Mindkét esetben az olvasási műveletek visszaadhatnak egy speciális értéket (pl -1 o null), amikor adatokat próbál betölteni innen ütköző sorozat üresen.
|
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”);
}
|
Egyszerre egy bájt betöltése. Az olvasási módszer
Az osztály főbb módszerei Serial amelyek a soros porton keresztül fogadott információk olvasására szolgálnak, a "típusú read» amelyek elsősorban az adattípusban különböznek egymástól, amelyekben a kapott információt továbbítják.
read A soros port által kapott bájtok 0 és 255 közötti értékként történő kézbesítésére szolgál. Adattípusként byte de Feldolgozás a -128 és 127 közötti tartományt jelenti, és nem a 0 és 255 közötti tartományt, akkor egy int által visszaadott tartomány reprezentálásához read. Ha azzal próbálsz olvasni read és ütköző string üres, értéket ad vissza -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());
}
}
|
Karakterek olvasása a soros portról. A readChar metódus
A módszer readChar hasonló a read de formátumban ad vissza értéket char a helyett int. Mint belsőleg, a char en Feldolgozás (A Jáva). readChar a ütköző üres sorozat 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());
}
}
|
Töltsön be egy szöveges karakterláncot. A readString és a readStringUntil metódusok.
A módszer readString objektumot ad vissza String a rendelkezésre álló összes adatból alakult ki ütköző sorozat a konzultáció időpontjában.
A módszer readString létrehozza a szöveges karakterláncot, feltételezve, hogy a soros port által fogadott bájtok formátumban vannak ASCII így ez az olvasási módszer nem használható más kódolásokhoz.
Ha arról van szó, hogy elolvassa a ütköző sorozattal readString üresen a visszatérési érték null.
A módszer readStringUntil add hozzá readString az a képesség, hogy visszaadja a betöltött információkat ütköző sorozat, amely egy paraméterként átadott speciális karakterrel (kóddal) osztja fel. A kapott információ olvasásának ez a módja lehetővé teszi, hogy megkülönböztetjük az elválasztókat és a terminátorokat, amelyek segítik a kapott információ értelmezését.
A módszer readStringUntil Hozd vissza null amikor a ütköző sorozat nem találja a neki átadott argumentumban megadott kódot (egy bájt).
|
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
}
}
}
|
A következő kódban a Arduino három üzenetet küld a soros porton keresztül. Az első kettő egy lapon végződik, így megjelennek a konzolon. Feldolgozás, míg a harmadik, bár a soros porton keresztül kerül elküldésre, nem kerül beolvasásra readStringUntil(9) mivel nem tabulátorra végződik (kóddal 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()
{
}
|
Adatblokkok olvasása. A readBytes és readBytesUntil metódusok.
A fent látható módszereket arra használják, hogy meghatározott formátumú adatokat, nyers adatblokkokat vagy olyan formátumot olvassanak, amelyet nem ír elő Feldolgozás módszereket alkalmaznak readBytes y readBytesUntil
A módszer readBytes próbálja meg elolvasni a rendelkezésre álló adatokat ütköző sorozat. Ha nem adunk át paramétert a metódusnak readBytes minden elérhető adat beolvasásra és visszaadásra kerül egy vektorban (byte[]). Ha egy egész számot adunk át paraméterként, akkor legfeljebb az ezzel a számmal jelzett bájtok számát olvassuk be, és azokat vektorként is visszaadjuk.
Van egy harmadik felhasználási mód is readBytes, hatékonyabb, ami argumentumként vesz egy bájtvektort, amelybe a tartalma a ütköző sorozat. Ez a felhasználási mód readBytes egész számot ad vissza (int), amely a beolvasott bájtok számát jelenti.
A módszer readBytesUntil hasonló módon működik, de tartalmaz egy első paramétert, amely annak a bájtnak az értékét jelenti, amely, ha megtalálható a ütköző, jelzi az olvasás végét. Ebben a módszerben nincs értelme annak a paraméternek, amely meghatározza a beolvasandó bájtok maximális számát, mivel a mennyiséget a speciális kód határozza meg.
A módszer működésének tesztelésére readBytes Tegyük fel a következő kódot Arduino amely szöveget küld a soros porton keresztül.
|
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()
{
}
|
Az alábbi példaprogram a Feldolgozás szöveget olvas be a soros portról 32 bájtos blokkokban (TOTAL_BYTES). Annak ellenőrzésére, hogy működik-e, a konzolon keresztül karakterként jeleníti meg, így a kapott bájtok típusát 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]);
}
}
}
}
|
A következő képernyőképen láthatja, hogyan jelennek meg a konzolon Feldolgozás az adatok, amelyeket (maximum) 32 bájtos blokkokban töltöttek be (TOTAL_BYTES) mindig. De van egy probléma, amiről már volt szó: Arduino verseit küldte Federico García Lorca a példa szövegként kódolva formátumban UTF-8, amely nem a használt Feldolgozás (Jáva), Mit szeretsz jobban UTF-16 tehát akik nem felelnek meg a rangnak a ASCII nyomtatható hibásan értelmezik.
A probléma megoldásához a karakterkészletek betölthetők (karakterkészlet), és definiáljon egy új objektumot String kódolással való ábrázolására kényszerítve UTF-8 az alábbi példakód szerint.
|
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));
}
}
}
|
Olvassa el a legfrissebb kapott adatokat. Az utolsó és lastChar metódus.
Míg a többi olvasási mód (a "típus read») töltik be a ütköző sorozat ugyanabban a sorrendben, ahogyan megérkezett (FIFO), ezzel a két módszerrel az utolsó bájt, amely elérte a ütköző sorozat. A módszer last az utolsó bájt értékét adja vissza, mint a int y lastChar visszaadja az értéket, mint a char.
Soros pufferkezelés
Bár az eddig látott módszerek tökéletesen működőképesek, nem mindig jelentik a legjobb módot a soros porthoz való hozzáférés kihasználására. Az adatok betöltéséhez rendszeresen ellenőrizniük kell az adatok állapotát ütköző sorozatot, és olvassa el a kód ismétlődő részében elérhető adatokat. Általában hatékonyabb módszer, ha csak akkor olvassuk ki az adatokat, ha tudjuk, hogy azok elérhetők.
Olvassa be a soros portot, amikor adat érkezik. A sorozatos esemény.
Ahhoz, hogy hozzáférjen a ütköző soros, amikor az adat érkezik, a Serial esemény a metódusdefiníción keresztül történő kezelésével kihasználható serialEvent. Ez a metódus azt a soros portot használja argumentumként, amelyik elindítja.
|
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érje meg a soros puffert. A puffer módszer.
Ha ismeri a hasznos adatblokkot alkotó bájtok számát, tovább optimalizálhatja az adatok olvasásának ezt a stílusát. ütköző sorozaton keresztül serialEvent. A módszer, a metódus buffer lehetővé teszi a fájlban tárolt bájtok számának beállítását ütköző sorozatos esemény elindítása előtt. A metódus paraméterként egy egész számot vár, amely a bájtok számát jelenti.
|
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öltse fel a puffert, amíg meg nem érkezik egy érték. A pufferUntil metódus.
A metódushívás beállítása helyett serialEvent a ütköző, a módszerrel bufferUntil beállíthatja, hogy az adatokat addig tárolja, amíg egy speciális érték meg nem érkezik, majd emelje fel a Serial eseményt. A metódusnak átadott paraméter a int amely a hívás által termelt értéket képviseli 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
}
|
Törölje a pufferben tárolt adatokat. Az egyértelmű módszer.
A módszerrel clear Törölheti az aktuálisan tárolt adatokat ütköző. Ez a módszer használható például új adatfogadási munkamenet indítására, figyelmen kívül hagyva az előzőből megmaradt adatokat.
Tipikus feldolgozó alkalmazás adatok soros porton keresztüli olvasására
Végül célszerű összefoglalni az objektum műveleteit Serial de Feldolgozás amelyeket gyakrabban használnak, végigmegyünk egy tipikus példán az adatok soros porton keresztül történő fogadására, hogy grafikont rajzoljunk velük, jelen esetben halmozott területekről.
Importálja a soros könyvtárat
|
1
|
import processing.serial.*;
|
Az adatprotokoll (elválasztók) meghatározása
|
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
|
Határozza meg a Serial osztály objektumát
|
1
|
Serial conexion_sensores;
|
Példányosítsa a Serial class objektumot a használt soros port beállításával
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Konfigurálja a soros port puffert
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Valósítson meg egy kezelőt a soros eseményhez
|
1
|
void serialEvent(Serial serie)
|
Soros puffer olvasása
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Kondicionálja a kapott adatokat
|
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]);
}
|
Soros kommunikáció befejezése
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Az alábbi példakód egy funkcionális (bár nagyon egyszerű) alkalmazással szemlélteti ezt az összefoglalót, amely egy területdiagramot generál a soros porton keresztül kapott értékekkel, valami hasonló ahhoz, amit a következő animáció mutat.
Annak érdekében, hogy ne vesszen el a program többi részében, és összpontosítsa a figyelmet a sorozatos kommunikációra Feldolgozás, az előző műveleteknek megfelelő kódsorok kiemelve jelennek meg.
|
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];
}
}
|
Hozzászólás Comment