İşleme ile Seri İletişim
Seri sınıfı
Seri iletişimi kullanma işlemleri İşlemde sınıfta tanımlanır Serial.Bunları bir programda kullanmak için yapılacak ilk işlem (kroki) bunu koda dahil etmek olacaktır import processing.serial.*;.
Sınıf Serial Belirtilen parametrelere bağlı olarak beş farklı kurucuya sahiptir. Gerekli olan tek parametre ana nesnedir (ebeveyn) genellikle sınıfın ana programına (örneğin program penceresi) karşılık gelir PApplet. Normalde olduğu gibi ebeveyn, yazılan program olacaktır ( kroki akım), bu ilk zorunlu parametrenin değeri şöyle olacaktır: this.
Yapıcıya aktarılabilecek diğer beş parametre şunlardır: ① hız, ② seri portun adı ③ eşitlik protokolde kullanılır, ④ veri bitleri ve ⑤ durma bitleri. Gerekli ana nesneye ek olarak en sık iletilen parametreler bağlantı noktası adı ve hızıdır.
La seri iletişim hızı bir tam sayıdır (int) O varsayılan değeri 9600'dür bu parametre yapıcıya aktarılmazsa.
Seri portlar mevcut. Liste yöntemi
El bağlantı noktası adı sistem tarafından belirlenen forma sahiptir, bu şekilde, örneğin Linux dağıtımları şöyle bir şey olacak /dev/ttyS4 / dev / ttyACM3 o /dev/ttyUSB1 (bağlantı noktası türüne bağlı olarak), Windows'ta ise şöyle bir şey olacaktır: COM12. Bir bağlantı noktası bir aygıtla fiziksel olarak ilişkilendirilmediği sürece program normalde hangi bağlantı noktasını kullanacağını bilemez. Bağlantı noktasını seçmenin yaygın bir yolu, mevcut olanların bir listesini almak, bunu kullanıcıya göstermek ve kullanmak istediklerini seçmelerine izin vermektir. Yöntem Serial.list() metin dizelerinin bir vektörünü döndürür (String) sistemde mevcut olan bağlantı noktalarının adlarıyla birlikte.
|
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());
}
|
Kütüphane tarafından varsayılan olarak kullanılan bağlantı noktası Serial yöntemle döndürülenlerden ilki list (kesinlikle COM1 Windows veya /dev/ttyS0 en GNU / Linux). Üzerinde çalışılan donanımın kesin olarak bilindiği çok sınırlı bağlamlar dışında (kiosk modundaki bir sistem gibi), genellikle atlanmaz ve hedef bağlantı noktası açıkça belirtilir.
Yukarıdaki ekran görüntüsü bir sistemin çıktısını göstermektedir GNU / Linux dört seri bağlantı noktasına sahip olan RS-232 (ttyS0 a ttyS3) ve iki türden beş adaptör (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Seri bağlantı noktalarına erişmek için kullanıcının normalde sistemin onları atadığı gruba ait olması gerekir. tty o dışarı arama. Yukarıdaki görselin ekran görüntüsünde seri bağlantı noktalarının listelendiğini görebilirsiniz. ls /dev/tty[ASU]* -la gruba ait dışarı arama üzerinde okuma ve yazma erişim izinleri olan.
Seri protokol parametreleri
La eşitlik seri iletişim ile ifade edilir İşlemde karakter olarak (char) şu değerleri alabilir: ① N (Yok) algılamamak için eşitlik, ② E (Üstelik) olduğunu belirtmek için eşlik biti eşit, ③ O (garip) olduğunu belirtmek için eşlik biti tuhaf, ④ M (işaret) her zaman yapmak için eşlik biti ve ⑤ S (uzay) her zaman birini yapmak eşlik biti. Yapıcıya parametre olarak aktarılmazsa varsayılan değer: N (olmadan eşitlik).
sayısı Veri bitleriVarsayılan olarak sekiz olan, çerçevenin her temel biriminde iletilen net veri yükünü (karakter veya bazen sözcük olarak adlandırılır) oluşturan bit sayısını belirtir. Veri bitlerinin sayısını gösteren parametre bir tamsayı (int).
Son olarak, beşinci olası parametre şu şekilde ifade edilen son işaretin süresini gösterir: bitleri durdur (bitleri durdur), temsil edilen bir sayı olarak gösterilir kayan nokta (float) değerleri alabilen 1.0 (parametre yapıcıya aktarılmazsa varsayılan değer), 1.5ya da 2.0.
Seri sınıfının yapıcıları
Aşağıdaki liste, sınıf yapıcısına aktarılabilecek farklı parametre kombinasyonlarını göstermektedir. Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Seri iletişimi sonlandırın. Durdurma yöntemi.
Örnekleme sırasında atanan seri bağlantı noktasını serbest bırakmak için Serial, diğer sistem uygulamalarının da kullanabileceği şekilde iletişimler sonlandırılır. stop, parametreleri almayan.
|
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
}
|
Seri port üzerinden veri gönderin. Yazma yöntemi
Veri göndermek için sınıf Serial de İşlemde yöntemi içerir write hangi ① metin dizelerinin iletilebileceği (String), ② bayt veya ③ bayt vektörleri (byte[]). Bunu hatırlamak ilginç byte en İşlemde (At Java) -128 ile 127 arasında bir tamsayıyı temsil eder ve varsayılan olarak dizeler kodlamayı kullanır 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
}
|
Seri porttan veri oku
Veriler seri port üzerinden alınırken programın diğer görevleri yerine getirebilmesi için, genellikle bir tampon Gelen verileri toplayın ve uygun olduğunda okuyun. Genellikle çok verimli olmasa da, mevcut tüm verileri yüklemek için uygulamayı durdurabilirsiniz; Ancak en yaygın olanı, bilginin her yinelemesinde, geldikçe okunması olacaktır. draw, belirli bir miktar mevcut olduğunda veya özel bir kod alındığında.
Tamponda mevcut olan veri miktarı. Mevcut yöntem
Verilerin ulaşıp ulaşmadığını bilmek tampon dizi, yöntem available bu alanda zaten depolanmış olan bayt sayısını döndürür tampon. Her iki durumda da okuma işlemleri özel bir değer döndürebilir (örneğin, -1 o null) veri yüklemeye çalışırken tampon boş olduğunda seri.
|
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”);
}
|
Her seferinde bir bayt yükleyin. Okuma yöntemi
Sınıfın ana yöntemleri Serial Bir seri port tarafından alınan bilgilerin okunmasına yarayan cihazlar "tip" tipindedir read» Temel olarak alınan bilgiyi ilettikleri veri türüne göre aralarında farklılık gösterir.
read seri porttan alınan byte'ları 0 ile 255 arasında bir değer olarak iletmek için kullanılır. Veri türü olarak byte de İşlemde 128 ile 127 arasında değil, -0 ile 255 arasındaki aralığı temsil ediyorsa, bir int tarafından döndürülen aralığı temsil etmek için read. ile okumayı denerseniz read y el tampon dize boş, değeri döndürür -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());
}
}
|
Seri bağlantı noktasından karakterleri okuyun. ReadChar yöntemi
Yöntem readChar benzer read ancak biçiminde bir değer döndürür char yerine int. Dahili olarak, char en İşlemde (At Java) iki bayt ile saklanır; okuma sırasında döndürülecek değer seçilir. readChar Bir tampon boş seri 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());
}
}
|
Bir metin dizesi yükleyin. readString ve readStringUntil yöntemleri.
Yöntem readString bir nesne döndürür String mevcut tüm verilerden oluşturulmuştur. tampon danışmanlık sırasında seri.
Yöntem readString seri port tarafından alınan baytların şu formatta olduğunu varsayarak metin dizesini oluşturur ASCII dolayısıyla bu okuma yöntemi diğer kodlamalar için kullanılamaz.
Eğer konu okumakla ilgiliyse tampon ile seri readString boş olduğunda dönüş değeri null.
Yöntem readStringUntil a ekle readString yüklenen bilgileri geri döndürme yeteneği tampon parametre olarak iletilen özel bir karaktere (kod) göre bölünen seri. Alınan bilgilerin bu şekilde okunması, alınan bilgilerin yorumlanmasına yardımcı olan hem ayırıcıları hem de sonlandırıcıları ayırt etmemizi sağlar.
Yöntem readStringUntil geri getir null ne zaman tampon serisi kendisine iletilen bağımsız değişkende belirtilen kodu (bir bayt) bulamıyor.
|
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şağıdaki kodda Arduino seri port üzerinden üç mesaj gönderir. İlk ikisi bir sekmede bittiği için konsolda görünecekler. İşlemdeüçüncüsü ise seri port üzerinden gönderilmesine rağmen okunmayacaktır. readStringUntil(9) bir sekmede bitmediği için (kodla 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()
{
}
|
Veri bloklarını okuyun. ReadBytes ve readBytesUntil yöntemleri.
Yukarıda görülen yöntemler, belirli formatlardaki verileri okumak, ham veri bloklarını okumak veya burada belirtilmeyen bir formattaki verileri okumak için kullanılır. İşlemde yöntemler kullanılır readBytes y readBytesUntil
Yöntem readBytes mevcut verileri okumaya çalışın tampon seri. Yönteme hiçbir parametre aktarılmazsa readBytes mevcut tüm veriler okunur ve bir vektöre döndürülür (byte[]). Parametre olarak bir tam sayı iletilirse, bu sayının gösterdiği maksimum bayt sayısı okunur ve bunlar da vektör olarak döndürülür.
Kullanmanın üçüncü bir yolu var readBytes, daha verimli, bu da bir bayt vektörünü argüman olarak alır, içeriğin içine alındığı tampon seri. Bu şekilde kullanma readBytes bir tamsayı döndürür (int) okunan bayt sayısını temsil eder.
Yöntem readBytesUntil benzer şekilde çalışır ancak baytın değerini temsil eden bir ilk parametre içerir. tampon, okumanın sonunu gösterecektir. Bu yöntemde okunacak maksimum bayt sayısını belirleyen parametre, miktar özel kod tarafından belirleneceği için bir anlam ifade etmemektedir.
Yöntemin işleyişini test etmek için readBytes için aşağıdaki kodu varsayalım. Arduino seri port üzerinden bir metin gönderir.
|
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()
{
}
|
Aşağıdaki örnek program İşlemde seri porttan metni 32 baytlık bloklar halinde okur (TOTAL_BYTES). Çalıştığını doğrulamak için, onu konsol aracılığıyla karakter olarak gösterir ve alınan baytların türünü zorlar. 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şağıdaki ekran görüntüsünde konsolda nasıl görüntülendiklerini görebilirsiniz. İşlemde (maksimum) 32 baytlık bloklar halinde yüklenen veriler (TOTAL_BYTES) her zaman. Ancak daha önce konuşulan bir sorun var: Arduino ayetlerini gönderiyordu Federico García Lorca biçiminde metin olarak kodlanmış örneğin UTF-8, kullanılan bu değil İşlemde (Java), ne tercih edersin UTF-16 yani rütbeye uymayanlar ASCII yazdırılabilir öğeler yanlış yorumlanır.
Bu sorunu çözmek için karakter setleri yüklenebilir (karakter kümesi) ve yeni bir nesne tanımlayın String kodlamayla temsil edilmeye zorlamak UTF-8 aşağıdaki örnek kodda gösterildiği gibi.
|
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));
}
}
}
|
Alınan en son verileri okuyun. Last ve lastChar yöntemleri.
Okuma yöntemlerinin geri kalanı ("tür read») bilgilerini yüklerler tampon seri geldiği sırayla (FIFO), bu iki yöntemle ulaşılan son bayt tampon seri. Yöntem last son baytın değerini bir olarak döndürür int y lastChar değeri olarak döndürür char.
Seri arabellek yönetimi
Şu ana kadar görülen yöntemler mükemmel şekilde işlevsel olsa da, seri bağlantı noktasına erişimden yararlanmanın her zaman en iyi yolunu temsil etmezler. Verileri yüklemek için periyodik olarak veri durumunu kontrol etmeleri gerekir. tampon seriyi açın ve kodun yinelenen bir bölümünde bulunan verileri okuyun. Genellikle daha verimli bir yol, verileri yalnızca mevcut olduğunu bildiğiniz zaman okumaktır.
Veri alındığında seri bağlantı noktasını okuyun. Seri olay.
Erişmek için tampon Veri alındığında seri, yöntem tanımı aracılığıyla yönetilerek Seri olayından yararlanılabilir. serialEvent. Bu yöntem, kendisini argüman olarak başlatan seri bağlantı noktasını kullanır.
|
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());
}
|
Seri arabelleği boyutlandırın. Tampon yöntemi.
Yararlı bir veri bloğunu oluşturan bayt sayısını biliyorsanız, bu veri okuma tarzını daha da optimize edebilirsiniz. tampon seri yoluyla serialEvent. Yöntem buffer depolanacak bayt sayısını ayarlamanıza olanak tanır. tampon Bir Seri etkinlik başlatmadan önce. Yöntem, parametre olarak bayt sayısını temsil eden bir tam sayı bekler.
|
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());
}
}
|
Bir değer alınana kadar arabelleği doldurun. BufferUntil yöntemi.
Yöntem çağrısını ayarlamak yerine serialEvent bir miktar veri için tampon, yöntemle bufferUntil özel bir değer gelene kadar verileri depolayacak ve ardından Seri olayını yükseltecek şekilde yapılandırabilirsiniz. Bu yönteme iletilen parametre bir int çağrısının ürettiği değeri temsil eden 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
}
|
Arabellekte saklanan verileri silin. Açık yöntem.
yöntem ile clear Şu anda mevcut olan verileri silebilirsiniz. tampon. Bu yöntem, örneğin öncekinden kalan verileri göz ardı ederek yeni bir veri alım oturumu başlatmak için kullanılabilir.
Seri port üzerinden veri okumak için Tipik İşleme uygulaması
Son olarak, nesnenin işlemlerini özetlemek uygundur Serial de İşlemde daha yaygın olarak kullanılanlar, seri port üzerinden veri alımının tipik bir örneğini inceleyerek bunlarla bir grafik çizerler (bu durumda yığılmış alanlar).
Seri kitaplığı içe aktar
|
1
|
import processing.serial.*;
|
Veri protokolünü (ayırıcıları) belirleyin
|
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
|
Serial sınıfının nesnesini belirleyin
|
1
|
Serial conexion_sensores;
|
Kullanılan seri bağlantı noktasını ayarlayarak Seri sınıfı nesnesini örnekleyin
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Seri bağlantı noktası arabelleğini yapılandırma
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Seri olay için bir işleyici uygulama
|
1
|
void serialEvent(Serial serie)
|
Seri arabelleği oku
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Alınan verileri koşullandırın
|
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]);
}
|
Seri iletişimi sonlandır
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Aşağıdaki örnek kod, seri port üzerinden alınan değerlerle bir alan grafiği oluşturan, aşağıdaki animasyonun gösterdiğine benzer, işlevsel (çok basit olmasına rağmen) bir uygulamayla bu özeti göstermektedir.
Programın geri kalanında kaybolmamak ve dikkatleri seri iletişime odaklamak için İşlemde, önceki işlemlere karşılık gelen kod satırları vurgulanır.
|
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];
}
}
|
Yorum Ekle