Последовательная связь с обработкой
Серийный класс
Операции по использованию последовательной связи в Обработка определены в классе Serial.Первая операция, которую необходимо выполнить для их использования в программе (эскиз) будет включать его в код с помощью import processing.serial.*;.
Класс Serial Он имеет пять разных конструкторов в зависимости от указанных параметров. Единственный обязательный параметр — родительский объект (родителя), что обычно соответствует основной программе (скажем, окну программы) класса PApplet. Как обычно, родителем будет написанная программа ( эскиз текущий), значение этого первого обязательного параметра будет this.
Остальные пять параметров, которые можно передать конструктору: ① скорость, ② имя последовательного порта, ③ соотношение используемые в протоколе: ④ биты данных и ⑤ стоповые биты. Наиболее часто передаваемыми параметрами, помимо обязательного родительского объекта, являются имя порта и скорость.
La скорость последовательной связи является целым числом (int) что по умолчанию значение 9600 если этот параметр не передан конструктору.
Доступны последовательные порты. Метод списка
El имя порта имеет форму, определяемую системой, таким образом, например в Дистрибутивы Linux будет что-то вроде / dev / ttyS4 / dev / ttyACM3 o / dev / ttyUSB1 (в зависимости от типа порта), а в Windows это будет что-то вроде COM12. Если порт физически не связан с устройством, программа обычно не знает, какой порт использовать. Обычный способ выбора порта — получить список доступных портов, показать его пользователю и позволить ему выбрать тот, который он хочет использовать. Метод Serial.list() возвращает вектор текстовых строк (String) с именами портов, доступных в системе.
|
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());
}
|
Порт, используемый библиотекой по умолчанию Serial является первым из возвращаемых методом list (конечно COM1 в Windows или / dev / ttyS0 en GNU / Linux). За исключением очень ограниченных случаев, когда оборудование, с которым работаете, строго известно (например, система в режиме киоска), оно обычно не опускается и порт назначения явно указывается.
На скриншоте выше показаны выходные данные системы. GNU / Linux который имеет четыре последовательных порта RS-232 (ttyS0 a ttyS3) и пять адаптеров двух типов (ttyACM0 a ttyACM1 y ttyUSB0 a ttyUSB2).
Чтобы получить доступ к последовательным портам, пользователь должен принадлежать к группе, к которой его назначает система, обычно терминал o дозвон. На скриншоте выше вы можете видеть, что последовательные порты, перечисленные с ls /dev/tty[ASU]* -la принадлежат к группе дозвон который имеет права доступа на чтение и запись.
Параметры последовательного протокола
La соотношение последовательной связи выражается в Обработка как персонаж(char), который может принимать значения: ① N (никто), чтобы не обнаружить соотношение, ② E (даже), чтобы указать, что бит четности четный, ③ O (странный), чтобы указать, что бит четности нечетно, ④ M (отметка), чтобы всегда делать бит четности и ⑤ S (космосе), чтобы всегда делать один бит четности. Значение по умолчанию, если оно не передано конструктору в качестве параметра, равно N (грех соотношение).
Количество биты данных, которое по умолчанию равно восьми, указывает количество битов, составляющих чистую полезную нагрузку данных (называемую символом или иногда словом), которая передается в каждой базовой единице кадра. Параметр, указывающий количество бит данных, выражается целым числом (int).
Наконец, пятый возможный параметр указывает продолжительность итоговой оценки, выражаемую как стоп-биты (стоп-биты), который обозначается числом, представленным в плавающая запятая (float), которые могут принимать значения 1.0 (значение по умолчанию, если параметр не передается конструктору), 1.5или 2.0.
Конструкторы класса Serial
В следующем списке показаны различные комбинации параметров, которые можно передать конструктору класса. Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
Завершить последовательную связь. Метод остановки.
Чтобы освободить последовательный порт, назначенный при создании экземпляра Serial, и что другие системные приложения могут его использовать, связь завершается методом stop, который не получает параметров.
|
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
}
|
Отправьте данные через последовательный порт. Метод записи
Для отправки данных класс Serial de Обработка включает в себя метод write с помощью которого можно передавать ① текстовые строки (String), ② байты или ③ байт-векторы (byte[]). Интересно это вспомнить byte en Обработка (В Java) представляет целое число от -128 до 127, и по умолчанию строки используют кодировку 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
}
|
Чтение данных из последовательного порта
Чтобы программа могла выполнять другие задачи во время получения данных через последовательный порт, ее обычно сохраняют в буфер данные, которые поступают, и читать их, когда это необходимо. Хотя обычно это не очень эффективно, вы можете остановить приложение, чтобы загрузить все доступные данные; Однако наиболее распространенным будет чтение информации по мере ее поступления, либо на каждой итерации draw, когда в наличии определенное количество или получен специальный код.
Объем данных, доступных в буфере. Доступный метод
Чтобы узнать, поступили ли данные буфер сериал, метод available возвращает количество байтов, которые уже были сохранены в этом буфер. В любом случае операции чтения могут возвращать специальное значение (например, -1 o null) при попытке загрузить данные из буфер серия, когда пуста.
|
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”);
}
|
Загружайте по одному байту за раз. Метод чтения
Основные методы класса Serial которые служат для чтения информации, полученной последовательным портом, относятся к типу read» которые различаются между собой, главным образом, типом данных, в которых они доставляют полученную информацию.
read используется для доставки байтов, полученных последовательным портом, в виде значения от 0 до 255. В качестве типа данных byte de Обработка представляет диапазон от -128 до 127, а не от 0 до 255, необходимо использовать int чтобы представить диапазон, возвращаемый read. Если вы попытаетесь прочитать с read y el
буфер строка пуста, возвращает значение -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());
}
}
|
Чтение символов из последовательного порта. Метод чтенияЧар
Метод readChar это похоже read но он возвращает значение в формате char вместо int. Как и внутренне, char en Обработка (В Java) хранятся в двух байтах, значение, выбранное для возврата при чтении с помощью readChar из буфер пустая серия это 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());
}
}
|
Загрузите текстовую строку. Методы readString и readStringUntil.
Метод readString возвращает объект String формируется на основе всех данных, имеющихся в буфер серия на момент консультации.
Метод readString создает текстовую строку, предполагая, что байты, полученные последовательным портом, имеют формат ASCII поэтому этот метод чтения нельзя использовать для других кодировок.
Если речь идет о чтении буфер серия с readString когда пусто, возвращаемое значение null.
Метод readStringUntil добавить в readString возможность возврата информации, загруженной в буфер серии, разбивая ее по специальному символу (коду), который передается в качестве параметра. Такой способ чтения полученной информации позволяет выделить как разделители, так и терминаторы, помогающие интерпретировать полученную информацию.
Метод readStringUntil вернуть null когда в буфер series не находит код, указанный в переданном ей аргументе (один байт).
|
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
}
}
}
|
В следующем коде для Arduino отправляет три сообщения через последовательный порт. Первые два заканчиваются вкладкой, поэтому они появятся в консоли. Обработка, а третий, хотя и будет отправлен через последовательный порт, не будет прочитан с помощью readStringUntil(9) поскольку он не заканчивается вкладкой (с кодом 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()
{
}
|
Чтение блоков данных. Методы readBytes и readBytesUntil.
Описанные выше методы используются для чтения данных в определенных форматах, для чтения блоков необработанных данных или в формате, который не предусмотрен в Обработка используются методы readBytes y readBytesUntil
Метод readBytes попробуйте прочитать данные, доступные в буфер ряд. Если методу не передан параметр readBytes все доступные данные считываются и возвращаются в векторе (byte[]). Если в качестве параметра передается целое число, считывается максимальное количество байтов, указанное этим числом, и они также возвращаются в виде вектора.
Есть третий способ использования readBytes, более эффективный, который принимает в качестве аргумента вектор байтов, в который помещается содержимое буфер ряд. Этот способ использования readBytes возвращает целое число (int), который представляет количество прочитанных байтов.
Метод readBytesUntil работает аналогичным образом, но включает первый параметр, представляющий значение байта, который, если он найден в буфер, укажет на окончание чтения. В этом методе параметр, определяющий максимальное количество читаемых байт, не имеет смысла, поскольку это количество будет определяться специальным кодом.
Проверить работу метода readBytes Предположим, что следующий код для Arduino который отправляет текст через последовательный порт.
|
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()
{
}
|
Следующий пример программы для Обработка читает текст из последовательного порта блоками по 32 байта (TOTAL_BYTES). Чтобы убедиться, что он работает, он показывает его через консоль в виде символов, заставляя тип полученных байтов 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]);
}
}
}
}
|
На следующем скриншоте вы можете увидеть, как они отображаются в консоли. Обработка данные, загруженные блоками по (максимум) 32 байта (TOTAL_BYTES) каждый раз. Но есть проблема, о которой уже говорилось: Arduino отправлял стихи Федерико Гарсиа Лорка примера, закодированного как текст в формате UTF-8, который не тот, который используется Обработка (Java), что Вы предпочитаете UTF-16 так что те, кто не соответствует званию ASCII printable интерпретируются неправильно.
Чтобы решить эту проблему, можно загрузить наборы символов (кодировок) и определите новый объект String заставляя его быть представленным с помощью кодировки UTF-8 как показано в следующем примере кода.
|
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));
}
}
}
|
Прочтите последние полученные данные. Методы Last и LastChar.
В то время как остальные методы чтения («тип read») они загружают информацию буфер серии в том же порядке, в котором они поступили (FIFO), с помощью этих двух методов последний байт, достигший буфер ряд. Метод last возвращает значение последнего байта в виде int y lastChar возвращает значение в виде char.
Управление последовательным буфером
Хотя рассмотренные до сих пор методы вполне функциональны, они не всегда представляют собой лучший способ использования доступа к последовательному порту. Для загрузки данных им необходимо периодически проверять состояние буфер серии и прочитать данные, доступные в повторяющейся части кода. Как правило, более эффективный способ — читать данные только тогда, когда вы знаете, что они доступны.
Прочитайте последовательный порт при получении данных. Серийное событие.
Чтобы получить доступ к буфер Serial при получении данных событие Serial можно использовать, управляя им через определение метода. serialEvent. Этот метод использует последовательный порт, который запускает его, в качестве аргумента.
|
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());
}
|
Размер последовательного буфера. Буферный метод.
Если вы знаете количество байтов, составляющих блок полезных данных, вы можете дополнительно оптимизировать этот стиль чтения данных. буфер серия через serialEvent. Метод buffer позволяет установить количество байтов, которые будут храниться в буфер перед запуском серийного мероприятия. Метод ожидает в качестве параметра целое число, обозначающее количество байтов.
|
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());
}
}
|
Заполняйте буфер до тех пор, пока не будет получено значение. Метод bufferUntil.
Вместо установки вызова метода serialEvent за количество данных в буфер, с помощью метода bufferUntil вы можете настроить сохранение данных до тех пор, пока не поступит специальное значение, а затем вызвать событие Serial. Параметр, передаваемый этому методу, представляет собой int которое представляет значение, полученное в результате вызова 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
}
|
Удалить данные, хранящиеся в буфере. Ясный метод.
методом clear Вы можете удалить данные, которые в данный момент находятся в буфер. Этот метод можно использовать, например, для запуска нового сеанса приема данных, игнорируя данные, оставшиеся от предыдущего.
Типичное приложение обработки для чтения данных через последовательный порт
Наконец, удобно повторить операции объекта Serial de Обработка которые используются чаще, просматривая типичный пример получения данных через последовательный порт и рисуя с их помощью график, в данном случае составные области.
Импортируйте последовательную библиотеку
|
1
|
import processing.serial.*;
|
Определить протокол данных (разделители)
|
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
|
1
|
Serial conexion_sensores;
|
Создайте экземпляр объекта класса Serial, установив используемый последовательный порт.
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
Настройте буфер последовательного порта
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
Реализуйте обработчик события Serial.
|
1
|
void serialEvent(Serial serie)
|
Чтение последовательного буфера
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
Условие полученных данных
|
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]);
}
|
Завершить последовательную связь
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
Приведенный ниже пример кода иллюстрирует это резюме с помощью функционального (хотя и очень простого) приложения, которое генерирует график областей со значениями, полученными через последовательный порт, что-то похожее на то, что показывает следующая анимация.
Чтобы не потеряться в остальной части программы и сосредоточить внимание на последовательной связи с Обработка, выделяются строки кода, соответствующие предыдущим операциям.
|
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];
}
}
|
Оставить комментарий