Komunikasi Serial dengan Pemrosesan
Kelas Serial
Operasi untuk menggunakan komunikasi serial di Pengolahan didefinisikan di kelas Serial.Operasi pertama yang dilakukan untuk menggunakannya dalam suatu program (sketsa) akan memasukkannya ke dalam kode dengan import processing.serial.*;.
Kelas Serial Ini memiliki lima konstruktor berbeda tergantung pada parameter yang ditunjukkan. Satu-satunya parameter yang diperlukan adalah objek induk (induk) yang biasanya berhubungan dengan program utama (misalnya, jendela program) kelas PApplet. Biasanya induknya adalah program yang sedang ditulis (the sketsa saat ini), nilai parameter wajib pertama ini adalah this.
Lima parameter lain yang dapat diteruskan ke konstruktor adalah ① kecepatan, ② nama port serial ③ keseimbangan digunakan dalam protokol, ④ bit data dan ⑤ bit stop. Parameter yang paling sering dilewati, selain objek induk yang diperlukan, adalah nama port dan kecepatan.
La kecepatan komunikasi serial adalah bilangan bulat (int) Bahwa defaultnya adalah nilai 9600 jika parameter ini tidak diteruskan ke konstruktor.
Port serial tersedia. Metode daftar
El nama pelabuhan mempunyai bentuk yang ditentukan oleh sistem, misalnya dalam Distribusi Linux itu akan menjadi sesuatu seperti /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (tergantung jenis portnya), sedangkan di Windows akan seperti ini COM12. Kecuali jika port secara fisik dikaitkan dengan perangkat, program biasanya tidak mengetahui port mana yang akan digunakan. Cara umum untuk memilih port adalah dengan mendapatkan daftar port yang tersedia, menunjukkannya kepada pengguna dan mengizinkan mereka memilih port yang ingin mereka gunakan. Metode Serial.list() mengembalikan vektor string teks (String) dengan nama port yang tersedia di sistem.
|
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 yang digunakan secara default oleh perpustakaan Serial adalah yang pertama dikembalikan oleh metode ini list (pasti COM1 pada Windows atau /dev/ttyS0 en GNU / Linux). Kecuali dalam konteks yang sangat terbatas di mana perangkat keras yang digunakan benar-benar diketahui (seperti sistem dalam mode kios), biasanya tidak dihilangkan dan port tujuan ditunjukkan secara jelas.
Tangkapan layar di atas menunjukkan keluaran suatu sistem GNU / Linux yang memiliki empat port serial RS-232 (ttyS0 a ttyS3) dan lima adaptor dari dua jenis (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Untuk mengakses port serial, biasanya pengguna harus menjadi anggota grup yang ditugaskan oleh sistem tty o panggilan keluar. Pada tangkapan layar gambar di atas Anda dapat melihat port serial yang terdaftar ls /dev/tty[ASU]* -la milik kelompok panggilan keluar yang memiliki izin akses baca dan tulis pada mereka.
Parameter protokol serial
La keseimbangan komunikasi serial dinyatakan dalam Pengolahan sebagai karakter (char) yang dapat mengambil nilai: ① N (tak satupun) untuk tidak mendeteksi keseimbangan, ② E (bahkan) untuk menunjukkan bahwa sedikit paritas genap, ③ O (aneh) untuk menunjukkan bahwa sedikit paritas ganjil, ④ M (tanda) untuk selalu membuat sedikit paritas dan ⑤ S (ruang) untuk selalu menjadikannya sedikit paritas. Nilai defaultnya, jika tidak diteruskan ke konstruktor sebagai parameter, adalah N (tanpa keseimbangan).
Jumlah bit data, yang secara default berjumlah delapan, menunjukkan jumlah bit yang membentuk muatan data bersih (disebut karakter atau terkadang kata) yang dikirimkan di setiap unit dasar frame. Parameter yang menunjukkan jumlah bit data dinyatakan sebagai bilangan bulat (int).
Terakhir, parameter kelima yang mungkin menunjukkan durasi tanda akhir, dinyatakan sebagai hentikan bit (berhenti sedikit), yang ditunjukkan sebagai angka yang diwakili dalam titik mengambang (float) yang dapat mengambil nilai 1.0 (nilai default jika parameter tidak diteruskan ke konstruktor), 1.5, atau 2.0.
Konstruktor kelas Serial
Daftar berikut menunjukkan berbagai kombinasi parameter yang dapat diteruskan ke konstruktor kelas Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Akhiri komunikasi serial. Metode berhenti.
Untuk melepaskan port serial, yang ditetapkan saat membuat instance Serial, dan agar aplikasi sistem lain dapat menggunakannya, komunikasi diakhiri dengan metode tersebut stop, yang tidak menerima parameter.
|
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
}
|
Kirim data melalui port serial. Metode penulisan
Untuk mengirim data, kelas Serial de Pengolahan menggabungkan metode tersebut write dengan mana ① string teks dapat ditransmisikan (String), ② byte atau ③ byte vektor (byte[]). Sangat menarik untuk mengingat hal itu byte en Pengolahan (Pada Jawa) mewakili bilangan bulat antara -128 dan 127 dan, secara default, string menggunakan pengkodean 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
}
|
Membaca data dari port serial
Agar program dapat melakukan tugas lain saat data diterima melalui port serial, biasanya disimpan di a penyangga data yang tiba dan membacanya bila diperlukan. Meskipun biasanya tidak terlalu efisien, Anda dapat menghentikan aplikasi untuk memuat semua data yang tersedia; Namun, hal yang paling umum adalah membaca informasi yang diterima, baik di setiap iterasi draw, ketika jumlah tertentu tersedia atau kode khusus telah diterima.
Jumlah data yang tersedia di buffer. Metode yang tersedia
Untuk mengetahui apakah data sudah sampai penyangga seri, metodenya available mengembalikan jumlah byte yang telah disimpan di dalamnya penyangga. Dalam kedua kasus tersebut, operasi baca dapat mengembalikan nilai khusus (misalnya -1 o null) saat mencoba memuat data dari penyangga seri saat kosong.
|
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”);
}
|
Muat satu byte pada satu waktu. Metode membaca
Metode utama kelas Serial yang berfungsi untuk membaca informasi yang diterima oleh port serial adalah yang bertipe " read» Yang berbeda di antara mereka, terutama berdasarkan jenis data yang digunakan untuk menyampaikan informasi yang diterima.
read digunakan untuk mengirimkan byte yang diterima oleh port serial sebagai nilai antara 0 dan 255. Sebagai tipe data byte de Pengolahan mewakili rentang antara -128 dan 127 dan bukan antara 0 dan 255, maka perlu menggunakan a int untuk mewakili rentang yang dikembalikan oleh read. Jika Anda mencoba membaca dengan read dan penyangga string kosong, mengembalikan nilai -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());
}
}
|
Membaca karakter dari port serial. Metode readChar
Metode readChar serupa a read tapi itu mengembalikan nilai dalam format char bukannya a int. Secara internal, itu char en Pengolahan (Pada Jawa) disimpan dengan dua byte, nilai yang dipilih untuk dikembalikan saat membaca readChar sebuah penyangga seri kosong adalah 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());
}
}
|
Memuat string teks. Metode readString dan readStringUntil.
Metode readString mengembalikan sebuah objek String terbentuk dari seluruh data yang tersedia di penyangga seri pada saat berkonsultasi dengannya.
Metode readString membuat string teks dengan asumsi bahwa byte yang diterima oleh port serial berada dalam format ASCII jadi metode membaca ini tidak dapat digunakan untuk pengkodean lainnya.
Jika ini tentang membaca penyangga seri dengan readString ketika kosong, nilai yang dikembalikan adalah null.
Metode readStringUntil Tambahkan readString kemampuan untuk mengembalikan informasi yang dimuat ke dalam penyangga seri membaginya dengan karakter khusus (kode) yang diteruskan sebagai parameter. Cara membaca informasi yang diterima ini memungkinkan kita membedakan pemisah dan terminator yang membantu menafsirkan informasi yang diterima.
Metode readStringUntil bawa kembali null ketika di penyangga seri tidak menemukan kode yang ditentukan dalam argumen yang diteruskan ke sana (satu 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
}
}
}
|
Dalam kode berikut untuk Arduino mengirimkan tiga pesan melalui port serial. Dua yang pertama diakhiri dengan tab, sehingga akan muncul di konsol. Pengolahan, sedangkan yang ketiga, meskipun dikirim melalui port serial, tidak akan dibaca readStringUntil(9) karena tidak diakhiri dengan tab (dengan 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()
{
}
|
Baca blok data. Metode readBytes dan readBytesUntil.
Cara-cara yang terlihat di atas digunakan untuk membaca data dengan format tertentu, untuk membaca blok data mentah atau dengan format yang tidak disediakan dalam Pengolahan metode digunakan readBytes y readBytesUntil
Metode readBytes coba baca data yang tersedia di penyangga seri. Jika tidak ada parameter yang diteruskan ke metode readBytes semua data yang tersedia dibaca dan dikembalikan dalam vektor (byte[]). Jika bilangan bulat dilewatkan sebagai parameter, jumlah maksimum byte yang ditunjukkan oleh nomor ini akan dibaca dan juga dikembalikan sebagai vektor.
Ada cara ketiga untuk digunakan readBytes, lebih efisien, yang menggunakan vektor byte sebagai argumen yang berisi konten penyangga seri. Cara penggunaan ini readBytes mengembalikan bilangan bulat (int) yang mewakili jumlah byte yang telah dibaca.
Metode readBytesUntil bekerja dengan cara yang serupa tetapi menyertakan parameter pertama yang mewakili nilai byte itu, jika ditemukan di penyangga, akan menunjukkan akhir pembacaan. Dalam metode ini, parameter yang menentukan jumlah maksimum byte yang akan dibaca tidak masuk akal karena jumlahnya akan ditentukan oleh kode khusus.
Untuk menguji pengoperasian metode ini readBytes Mari kita asumsikan kode berikut untuk Arduino yang mengirimkan teks melalui port serial.
|
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()
{
}
|
Berikut contoh program untuk Pengolahan membaca teks dari port serial dalam blok 32-byte (TOTAL_BYTES). Untuk memverifikasi bahwa ini berfungsi, ini menunjukkannya melalui konsol sebagai karakter, memaksa jenis byte yang diterima 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]);
}
}
}
}
|
Pada tangkapan layar berikut, Anda dapat melihat tampilannya di konsol Pengolahan data yang telah dimuat dalam blok (maksimum) 32 byte (TOTAL_BYTES) setiap saat. Namun ada masalah yang telah dibicarakan: Arduino telah mengirimkan ayat-ayat Federico García Lorca dari contoh yang dikodekan sebagai teks dalam format UTF-8, yang bukan yang digunakan Pengolahan (Jawa), apa yang Anda sukai UTF-16 jadi mereka yang tidak sesuai dengan pangkat tersebut ASCII dapat dicetak diinterpretasikan secara salah.
Untuk mengatasi masalah ini, rangkaian karakter dapat dimuat (rangkaian karakter) dan tentukan objek baru String memaksanya untuk direpresentasikan dengan pengkodean UTF-8 seperti yang ditunjukkan pada contoh kode berikut.
|
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));
}
}
}
|
Baca data terbaru yang diterima. Metode last dan lastChar.
Sedangkan metode membaca lainnya (“type read») mereka memuat informasi penyangga seri dalam urutan yang sama dengan saat tiba (FIFO), dengan dua metode ini byte terakhir yang telah mencapai penyangga seri. Metode last mengembalikan nilai byte terakhir sebagai a int y lastChar mengembalikan nilai sebagai a char.
Manajemen buffer serial
Meskipun metode yang terlihat sejauh ini berfungsi sempurna, metode tersebut tidak selalu mewakili cara terbaik untuk mengeksploitasi akses ke port serial. Untuk memuat data, mereka perlu memeriksa statusnya secara berkala penyangga seri dan membaca data yang tersedia di bagian kode yang berulang. Cara yang umumnya lebih efisien adalah dengan membaca data hanya jika Anda mengetahui data tersebut tersedia.
Baca port serial saat data diterima. Acara berseri.
Untuk mengakses penyangga serial ketika data diterima, acara Serial dapat dieksploitasi dengan mengelolanya melalui definisi metode serialEvent. Metode ini menggunakan port serial yang meluncurkannya sebagai argumen.
|
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());
}
|
Ukuran buffer serial. Metode penyangga.
Jika Anda mengetahui jumlah byte yang membentuk blok data yang berguna, Anda dapat lebih mengoptimalkan gaya membaca data ini. penyangga seri melalui serialEvent. Metode buffer memungkinkan Anda mengatur jumlah byte yang akan disimpan di penyangga sebelum meluncurkan acara Serial. Metode ini mengharapkan bilangan bulat sebagai parameter yang mewakili jumlah 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());
}
}
|
Isi buffer sampai nilai diterima. Metode bufferUntil.
Daripada mengatur pemanggilan metode serialEvent untuk sejumlah data di penyangga, dengan metode bufferUntil Anda dapat mengonfigurasi untuk menyimpan data hingga nilai khusus tiba dan kemudian menaikkan acara Serial. Parameter yang diteruskan ke metode ini adalah a int yang mewakili nilai yang dihasilkan oleh panggilan ke 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
}
|
Hapus data yang disimpan di buffer. Metode yang jelas.
dengan metode clear Anda dapat menghapus data yang ada saat ini di penyangga. Metode ini dapat digunakan, misalnya, untuk memulai sesi penerimaan data baru dengan mengabaikan sisa data dari sesi sebelumnya.
Aplikasi Pemrosesan yang khas untuk membaca data melalui port serial
Akhirnya, akan lebih mudah untuk merekapitulasi operasi objek tersebut Serial de Pengolahan yang lebih umum digunakan, melalui contoh umum penerimaan data melalui port serial untuk menggambar grafik dengannya, dalam hal ini area bertumpuk.
Impor perpustakaan Serial
|
1
|
import processing.serial.*;
|
Menentukan protokol data (pemisah)
|
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
|
Tentukan objek kelas Serial
|
1
|
Serial conexion_sensores;
|
Buat instance objek kelas Serial dengan mengatur port serial yang digunakan
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Konfigurasikan buffer port serial
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Menerapkan pengendali untuk acara Serial
|
1
|
void serialEvent(Serial serie)
|
Baca buffer serial
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Kondisikan data yang diterima
|
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]);
}
|
Akhiri komunikasi serial
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Contoh kode di bawah mengilustrasikan ringkasan ini dengan aplikasi fungsional (walaupun sangat sederhana) yang menghasilkan grafik area dengan nilai yang diterima melalui port serial, mirip dengan yang ditampilkan animasi berikut.
Agar tidak tersesat dalam sisa program dan memusatkan perhatian pada komunikasi serial dengan Pengolahan, baris kode yang sesuai dengan operasi sebelumnya akan disorot.
|
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];
}
}
|
Posting