ANALISIS PARA CONTROL PID

Arduino Signal Analysis with Processing

adrianAugust 20, 2016Arduino, OmniTopic, Programming, Robotics

En muchas ocasiones es necesario de disponer de un osciloscopio para medir y analizar las señales que se ejecutan en nuestros programas con Arduino.
Con razón a un experimento; introduciré un ejemplo de cómo podemos llevar a cabo estos análisis para poderlos ver gráficamente a través
de Processing.
Este ejemplo dispone de un sensor óptico que detecta los flancos de un encoder pegado a una rueda encoder pegado a un motor.

En mi caso tengo un sensor OPTEK; en cualquiera de sus series OPB; que se pueden encontrar facilmente desguazando un ratón con scroll o
impresora viejas. Una vez conseguido, lo tendremos que disponer en un eje giratoria. Para hacer pruebas se puede buscar una manera de medir el paso
de luz o no alternativamente.
Cuando ya lo tengamos conectado, el montaje sobre la placa se realiza como aparece en la siguiente imagen.
Ahora deberemos hacer un programa para leer los estados. Primero voy a proporcionar un código en el que se leen los estados en bajo o en alto. Pero
seguidamente lo haremos con interrupciones, que es una manera mejor de elaborar este control.

Lectura de estado del sensor

1 const int Pin = 2;
2

3 void setup() {

4 Serial.begin(9600);

pinMode(Pin, INPUT_PULLUP);
5
}
6

7
void loop() {
8
bool value = digitalRead(Pin);
9

10
Serial.write( 0xff );
11
Serial.write( (value >> 8) & 0xff );
12
Serial.write( value & 0xff );

13
}

14
Como se puede observar, hay unos Serial.write un poco raros. Estas funciones serán las encargadas de imprimir a través del puerto serie a nuestro
ordenador los valores actualizados de nuestra rueda y Processing los recopilará para desarrollar una gráfica temporal en el que se podrá ver la
evolución de los estados en todo momento.
Copiamos el siguiente código en Processing.
1 import processing.serial.*;

3 Serial port; // Create object from Serial class

int val; // Data received from the serial port

4
int[] values;
5
float zoom;
6

7
void setup()
8
{
9
size(1280, 480);
10
// Open the port that the board is connected to and use the same speed (9600 bps)
11 port = new Serial(this, Serial.list()[0], 9600);

12 values = new int[width];

zoom = 1.0f;
13
smooth();
14
}
15

16
int getY(int val) {
17
return (int)(height - val / 3.0f * (height - 1))-height/3;
18
}
19

20
int getValue() {

21
int value = -1;

22 while (port.available() >= 3) {

23
24 if (port.read() == 0xff) {

25 value = (port.read() << 8) | (port.read());

}
26
}
27
return value;
28
}
29

30
void pushValue(int value) {
31
for (int i=0; i<width-1; i++)
32
values[i] = values[i+1];

33
values[width-1] = value;

34 }

35

36
37 void drawLines() {

38 stroke(255);

39

int displayWidth = (int) (width / zoom);

40

41
int k = values.length - displayWidth;
42

43
int x0 = 0;
44
int y0 = getY(values[k]);
45
for (int i=1; i<displayWidth; i++) {
46
k++;
47
int x1 = (int) (i * (width-1) / (displayWidth-1));

48
int y1 = getY(values[k]);

49
50 line(x0, y0, x1, y1);

51 x0 = x1;

y0 = y1;
52
}
53
}
54

55
void drawGrid() {
56
stroke(255, 0, 0);
57
line(0, height/2, width, height/2);
58
}

59

60
void keyReleased() {

61 switch (key) {

62
63 case '+':

64 zoom *= 2.0f;

println(zoom);
65
if ( (int) (width / zoom) <= 1 )
66
zoom /= 2.0f;
67
break;
68
case '-':
69
zoom /= 2.0f;
70
if (zoom < 1.0f)

71
zoom *= 2.0f;

72 break;

73 }

74 }

75
76 void draw()

77 {

background(0);
78
drawGrid();
79
val = getValue();
80
if (val != -1) {
81
pushValue(val);
82
}
83
drawLines();

84
}

85

86

87
Lectura incremental del sensor
1 const int Pin = 2;

2 int wheel = 0;

bool lastValue;
3

4
void setup() {
5
Serial.begin(9600);
6
pinMode(Pin, INPUT_PULLUP);
7
lastValue = digitalRead(Pin);
8
}
9

10
void loop() {

11
bool value = digitalRead(Pin);

12 if(value != lastValue){

13
14 wheel++;

15 lastValue = value;

}
16
Serial.write( 0xff );
17
Serial.write( (wheel >> 8) & 0xff );
18
Serial.write( wheel & 0xff );
19
}
20

Este código lo único que hace es leer continuamente el valor leido de nuestro sensor y en el momento de cambio de estado sumar uno a la
variable “wheel” que es la encargada de contar en qué parte del giro se encuentra ésta.
Copiamos el siguiente código en Processing en el que solo cambiaremos la escala para poder visualizar un rango amplio de valores.
1 import processing.serial.*;

3 Serial port; // Create object from Serial class

int val; // Data received from the serial port

4 int[] values;

5 float zoom;

void setup()
7
{
8
size(1280, 480);
9
// Open the port that the board is connected to and use the same speed (9600 bps)
10
port = new Serial(this, Serial.list()[0], 9600);
11
values = new int[width];
12
zoom = 1.0f;

13
smooth();

14 }

15

16
17 int getY(int val) {

18 return (int)(height - val / 40.0f * (height - 1));

}
19

20
int getValue() {
21
int value = -1;
22
while (port.available() >= 3) {
23
if (port.read() == 0xff) {
24
value = (port.read() << 8) | (port.read());
25
}

26
}

27 return value;

28 }

29
30

31 void pushValue(int value) {

32 for (int i=0; i<width-1; i++)

values[i] = values[i+1];
33
values[width-1] = value;
34
}
35

36
void drawLines() {
37
stroke(255);
38

39
int displayWidth = (int) (width / zoom);
40

41
int k = values.length - displayWidth;

42
43

44 int x0 = 0;

45 int y0 = getY(values[k]);

for (int i=1; i<displayWidth; i++) {

46
k++;
47
int x1 = (int) (i * (width-1) / (displayWidth-1));
48
int y1 = getY(values[k]);
49
line(x0, y0, x1, y1);
50
x0 = x1;
51
y0 = y1;

52
}

53 }

54

55
56 void drawGrid() {

57 stroke(255, 0, 0);

line(0, height/2, width, height/2);

58
}
59

60
void keyReleased() {
61
switch (key) {
62
case '+':
63
zoom *= 2.0f;
64
println(zoom);

65
if ( (int) (width / zoom) <= 1 )

66 zoom /= 2.0f;

67 break;

68 case '-':
69 zoom /= 2.0f;

70 if (zoom < 1.0f)

zoom *= 2.0f;
71
break;
72
}
73
}
74

75
void draw()
76
{
77
background(0);

78
drawGrid();

79 val = getValue();

80 if (val != -1) {

81 pushValue(val);
82 }

83 drawLines();

}
84

85

86

87

Ahora podremos visualizar el siguiente resultado mientras hacemos girar la rueda. El número de ranuras son 20, y como estamos elaborando un control
de cambio de estados a lectura con ranura y sin ranura, multiplicando por 2 tendremos el giro de una vuelta completa de la rueda. Por ello la escala de
la gráfica está limitada a 40. En el momento que superemos 40 ranuras llegará a arriba del todo.
De todas maneras, hemos comentado que hay un método mejor para recopilar la información de la señal para este caso; y es con interrupciones.
Las interrupciones son unos pines especiales capaces de detectar un evento ocurrido en la señal para ejecutar una acción. Por ejemplo, cada vez que
cambia el estado de un sensor, se puede ejecutar la función sumar una unidad a un contador, como hacemos en el código anterior.
La mayor ventaja de este procedimiento es que la interrupción asociada al pin recoge ese evento e interrumpe la ejecución natural del código para
actualizar ese estado y prioriza la función que se ha declarado dentro de la misma.
Existen 4 eventos dentro de una interrupción.
o LOW –> Dispara la función siempre y cuando el Pin está en bajo.
o CHANGE –> Dispara la función cuando el estado cambia. De bajo a alto o de alto a bajo indiferentemente.
o RISING –> Dispara la función cuando el estado cambia de bajo a alto.
o FALLING –> Dispara la función cuando el estado cambia de alto a bajo.

o HIGH (SOLO PARA ARDUINO DUE) –>Dispara la función siempre y cuando el Pin está en alto.
Hay que tener en cuenta que cada placa tiene un número de interrupciones definidos.Y no es casualidad haber escogido el Pin 2 para este ejercicio, ya
que la placa Arduino UNO, tiene solo dos interrupciones en el PIN 2 y en el PIN 3.
El caso que nuestro código en Arduino quedará de esta nueva forma y ejecutará lo mismo, pero mejor.

1 const byte IntPin = 2;

2 volatile int wheel = 0;

void setup()
4
{
5
6 Serial.begin(9600);

7 attachInterrupt(digitalPinToInterrupt(IntPin), counterwheel, CHANGE);

}
8

9
void loop() {
10

11
Serial.write( 0xff );
12
Serial.write( (wheel >> 8) & 0xff );
13
Serial.write( wheel & 0xff );
14
}
15

16
void counterwheel(){

17
wheel++;

18
19 }

Seguidamente expondré otro ejemplo que se puede realizar para establecer el contador a cero cuando demos una vuelta completa; y de esta manera
podamos visualizarlo en la gráfica en sucesivos giros.

1 const byte IntPin = 2;

2 volatile int wheel = 0;

void setup(){
4
Serial.begin(9600);
5
attachInterrupt(digitalPinToInterrupt(IntPin), counterwheel, CHANGE);
6
}
7

8
void loop() {
9
10

11 Serial.write( 0xff );

12 Serial.write( (wheel >> 8) & 0xff );

Serial.write( wheel & 0xff );

13
if (wheel >= 40){
14
wheel =0;
15
}
16
}
17

18
void counterwheel(){
19
wheel++;

20
}

21
Como se puede ver en la siguiente gráfica, cada subida es una vuelta completa a la rueda.

En la siguiente entrada aprovecharemos este código para

realizar un control con PID.