Proyecto barra-bola con procesamiento de imágenes y controlador

PID

1. Introducción
El procesamiento digital de imágenes es un campo fascinante que forma parte de nuestra vida
diaria. En sus inicios el procesamiento de imágenes estaba restringido a campos de
investigación de ciencias de la computación, matemáticas y astronomía. Lo que constituía una
labor tardada, impredecible y cara, se ha convertido en una disciplina en si misma, con la
ayuda de microprocesadores baratos, dispositivos de gran memoria y componentes de
procesamiento de señales; volviéndose así una herramienta invaluable en diversas
aplicaciones, tales como robótica control industrial, telecomunicaciones, medicina, etc.

Al considerar el procesamiento de imágenes como una disciplina, el objetivo es visualizar o

evaluar estadísticamente algunos aspectos de la imagen que no se muestran en su forma
original. Dado que las imágenes monocromáticas y las de color pueden ser representadas
matemáticamente como funciones determinísticas espaciotemporales, se desarrolló una
formulación matemática completa y compleja, además de equipo especializado, incluyendo
procesadores digitales de propósito especifico y periféricos de computadora.
 2. Objetivos
- Lograr que los alumnos conozcan los principios básicos y avanzados de los procesos
de interpretación automática de imágenes el funcionamiento de los algoritmos
existentes y sus aplicaciones, con el objeto de poder asesorar y decidir
profesionalmente sobre esta temática.

- Aprender a utilizar aplicaciones como Matlab (para el procesamiento de imágenes) y

Arduino (para controlar sistemas con PID)

3. Herramientas a usar

MATLAB
MATLAB (abreviatura de MATrix LABoratory, "laboratorio de matrices") es una herramienta de
software matemático que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de
programación propio (lenguaje M). Está disponible para las plataformas Unix, Windows, Mac

OS X y GNU/Linux .

ARDUINO

Arduino (anteriormente conocido como Genuino a nivel internacional hasta octubre 2016), es
una compañía open source y open hardware, así como un proyecto y comunidad internacional
que diseña y manufactura placas de desarrollo de hardware para construir dispositivos
digitales y dispositivos interactivos que puedan sensar y controlar objetos del mundo real.

MOTOR PASO A PASO BIPOLAR

Un motor paso a paso (también llamado stepper) es un dispositivo electromagnético que convierte
impulsos eléctricos en movimientos mecánicos de rotación. La principal característica de estos
motores es que se mueven un paso por cada impulso que reciben. Normalmente los pasos
pueden ser de 1,8º a 90º por paso, dependiendo del motor. Por ejemplo: un motor paso a paso
que se mueve 2º cada paso, quiere decir que para completar una vuelta (360º) tendrá que dar
(360º/2ºpor paso) 180 pasos.
Son motores con mucha precisión, que permiten quedar fijos en una posición (como un
servomotor) y también son capaces de girar libremente en un sentido u otro (como un motor DC).

PUENTE H

Módulo L298N Driver Puente H L298. Módulo puente H L298N es una tarjeta para el control de
motores de corriente directa, motores a pasos, solenoides y en general cualquier otra carga
inductiva. Puede manejar cargas de 2 Amperios constantes.

4. Parte teórica
MOVER MOTOR PASO A PASO CON ARDUINO
Cuando circula corriente por una o más bobinas del estator se crea un campo magnético creando
los polos Norte-Sur. Luego el rotor se equilibrará magnéticamente orientando sus polos Norte-Sur
hacia los polos Sur-Norte del estator. Cuando el estator vuelva a cambiar la orientación de sus
polos a través de un nuevo impulso recibido hacia sus bobinas, el rotor volverá a moverse para
equilibrarse magnéticamente. Si se mantiene esta situación, obtendremos un movimiento giratorio
permanente del eje. El ángulo de paso depende de la relación entre el nombre de polos
magnéticos del estator y el nombre de polos magnéticos del rotor.

Hay dos tipos de motores paso a paso: los unipolares y los bipolares.
Los bipolares se componen de 2 bobinas y los unipolares de 4 bobinas. Para diferenciarlos
físicamente basta con observar el número de terminales de cada motor. Los bipolares siempre
tienen 4 terminales, dos para cada bobina, y los unipolares normalmente tienen 6 terminales, dos
para cada bobina y los otro dos son los comunes de estas. Hay motores unipolares con 5
terminales en que los dos comunes están unidos internamente.
Secuencia para controlar motores paso a paso Bipolares
Un motor paso a paso bipolar necesita invertir la corriente que circula por sus bobinas en una
secuencia determinada para provocar el movimiento del eje.

Controlar motor paso a paso Bipolar con Arduino

Como hemos explicado antes, los motores bipolares son más complejos de controlar ya que el
flujo de corriente tiene que cambiar de dirección a través de las bobinas con una secuencia
determinada. Para esto debemos conectar cada una de las dos bobinas en un puente en H (H-
Bridge).
Controlador PID
De la documentación existente sobre sistemas de control, podemos destacar la siguiente ecuación.

De la ecuación, podemos hacer las siguientes afirmaciones:

● e(t) es el error de la señal.
● u(t) salida del controlador y entrada de control al proceso.
● Kp es la ganancia proporcional.
● Ti es la constante de tiempo integral.
● Td es la constante de tiempo derivativa.

Para tener una idea más clara, recurrimos al siguiente diagrama

Del diagrama de flujo determinamos lo siguiente:

● El primer bloque de control (proporcional) consiste en el producto entre la señal de error y la

constante proporcional, quedando un error en estado estacionario casi nulo.

● El segundo bloque de control (integral) tiene como propósito disminuir y eliminar el error en estado
estacionario, provocado por el modo proporcional. El control integral actúa cuando hay una desviación
entre la variable y el punto de consigna, integrando esta desviación en el tiempo y sumándola a la
acción proporcional.

● El tercer bloque de control (Derivativo) considera la tendencia del error y permite una repercusión
rápida de la variable después de presentarse una perturbación en el proceso

5. Desarrollo
 Programación con Matlab y Arduino:

Matlab(conexión con la cámara por ip)

%% Conexión con la cámara
% Adquision de imagenes
clc
clear all
close all
%webcamlist
cam = webcam(2); %conectar con webcam externa
%preview(cam) %previsualizacion
%% Comunicación serial
%envio de datos
clc
delete(instrfind({'port'},{'COM3'}));
Arduino_Serial = serial('COM3','BaudRate',9600);
fopen(Arduino_Serial); %abre el puerto
%% Obtencion de coordenadas para recortar la imagen
im = snapshot(cam);
imshow(im);
[x y] = ginput(2);
%%
%*************** BARRA Y BOLA **********************%
Posicion = 0;
%************* Envio de setPoint **************
Im = snapshot(cam);
Im = Im(y(1):2:y(2),x(1):2:x(2),:);
imshow(Im);
[x1 y1] = input(1);
text(x1,y1,'O','color','b','FontSize',14)
setPoint = uint8((x1*50)/((x(2)-x(1))/2))
fwrite(Arduino_Serial,setPoint,'uint8');
flushoutput(Arduino_Serial);
pause(0.5)
%**************** BUCLE DE EJECUCION CONTINUA *************%
while 1
%%%
inicio = fscanf(Arduino_Serial,'%u'); % Test de recibo de dato
%Conmienza el procesamiento y el posterior envio del sensado de la
bola
if(inicio == 1)
%***** OBTENCION DEL LA IMAGEN Y RECORTE *******%
Captura = snapshot(cam);
%recorta la imagen para una mayor velocidad de procesamiento
Im = Captura(y(1):2:y(2),x(1):2:x(2),:);
%******* TRATAMIENTO DE LA IMAGEN ********%
 %Imagen RGB a HSV
Im_hsv = rgb2hsv(Im);
%Extrae el canal del color
Im_h = Im_hsv(:,:,1);

%impixel(imh) %retorna los valores de la intensidad de los

%pixeles en el
%punto donde se dio click (calibracion)
%Binariza la imagen, pixeles con el dato en el rango a 1 el %resto 0

Im_green = Im_h>=(138/360) & Im_h<=(158/360); %Rango para

color verde

%Elimina falsos objetos con área de 75 pixeles

Im_green_bin = bwareaopen(Im_green,75);
Rombo = strel('disk',5);
Im_green_bin = imerode(Im_green_bin,Rombo);

%figure(2)
%imshow(Im_green_bin)
%hold on %Sobrescribe en la imagen

%Etiquetado del objeto en la imagen para su extraccion de

%parametro
%con regionprops
%Por recomendacion se usa la instruccion logical que %convierte
%cualquier valor de una matriz distinto de cero en 1, y %cero en 0

Im_etiqueta = logical(Im_green_bin);

%Ubicacion del objeto, se obtiene su centro

Parametro_obj =regionprops(Im_etiqueta,'Centroid');

Posicion=(Parametro_obj(1).Centroid(1)*50)/((x(2)x(1))/2);

%***COMUNICACION (ENVIO DE LA POSICION DE BOLA EN BARRA) *****%

fwrite(Arduino_Serial,Posicion,'uint8');

%Envia la posición

flushoutput(Arduino_Serial);

%Limpia el buffer de salida

 %*********** TEXTO DE IMAGEN ***********%
%text(70,20,{'posicion:’int2str(Posicion)},'color','y','FontSize',12)

%text(Parametro_obj(1).Centroid(1),Parametro_obj(1).Centroid(2),'+
',%'color','r','FontSize',12)
%gtext();
%agrega un texto donde se dio click en la imagen

end
flushinput(Arduino_Serial); %Limpia el buffer de
salida
end
Arduino (controlador )

// se uso la librería Stepper para mejorar el procesamiento

y respuesta del sistema a la hora de ejecutar los comandos
para gobernar al motor.

#include <LiquidCrystal_I2C.h>
#include <Stepper.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2);

//pasos que da el motor para completar una revolucion

const int stepsPerRevolution = 200;

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

//IN4,IN3,IN2,IN1
//Punto de consigna
float Setpoint;
//muestras enviadas desde el matlab con el dato de la posicion de
la bola en la barra
byte Matlab;
float error, errSum, datoAnt;
long lastProcess;
//constante del controlador

float kp = 0.4, ki = 0, kd = 3.2;

//acciones del controlador PID
double P, I, D;
//pasos que el PID envia como correpcion
int Pasos;
int posicion = 0;

//variable que define si el dato entrante es el setpoint o la

muestra
boolean setpoint_in = true
int Paso = 0; //pasos que da el motor
int go = 1; //avisa que ya puede enviar otra
muestra
//velocidad de activación de las bobinas del motor
int velocidad = 25;

void setup() {
Serial.begin(9600);
for (int i = 8; i < 12; i++) {
pinMode(i, OUTPUT);
}
//se define la velocidad a la que responde el motor
myStepper.setSpeed(velocidad);
lcd.init();
lcd.clear();
lcd.backlight();
}
void loop() {

if (Serial.available()) {
//el dato entrante es el setpoint
if(setpoint_in == true){
Setpoint = Serial.read();
//solo entra a la primera vez cuando se inicia el
programa
setpoint_in = false;
Serial.flush();
}
else{
Matlab = Serial.read(); //se obtiene la muestra
 /************** PID ********************/
//consigna - sensado = error
error = (Setpoint - Matlab);
float deltaTime = (millis() - lastProcess)/1000.0;
lastProcess = millis();
//Proporcional
P = error * kp;
//Integral
//la accion I actua mientras exista el error

I = I + (error * ki) * deltaTime;

//Derivativo
//Acccion D muestra anterior-muestractual sobre la
derivada
//del tiempo entra muestras
D = (datoAnt - Matlab) * kd / deltaTime;

datoAnt = Matlab;
// Suma todo
Pasos = P + I + D;
/*************** ACTUADOR ***************/
lcd.clear();
lcd.setCursor(10, 1); lcd.print(Pasos);
/**** Limitador de pasos ***********/
if (Pasos > 10) {
Pasos = 10;
}
if (Pasos < -10) {
Pasos = -10;
}
/***********************************/
Paso = posicion - Pasos;
posicion = Pasos;
myStepper.step(-Paso);
lcd.setCursor(0, 1); lcd.print(Setpoint);
lcd.setCursor(0, 0); lcd.print(Matlab);
lcd.setCursor(10, 0);
lcd.print(Paso);
Serial.flush();
}
Serial.println(go);
}
}
Conclusiones

- Al no tener el modelo matemático de la planta a controlar, el proceso de implementar el

controlador PID es relativamente sencillo, solo aplicando las ecuaciones para software, pero es
tedioso el trabajo de calibrar las constantes.
- El procesamiento de imágenes es una herramienta muy útil para el análisis del entorno por medio
de la visión artificial, simplifica el requerimiento de algunos transductores o sensores.
- Al momento del procesamiento, pudo notar que al trabajar con luz artificial, el procesamiento de la
imagen para detectar el objeto presenta inconvenientes según, a cantidad de luz que hay en el
ambiente y los objetos que presenta alrededor del objeto en la escena, lo que obligaba a cambiar
datos en la programación.
- No se logró calibrar el periodo de muestreo, ya que la ejecución el segmento de código que
controla al motor, dependiendo de la velocidad a la que se desea que gire hace que el uC ocupe
más del tiempo mínimo requerido, lo que hace al sistema demorar en responder al cambio de la
variable sensada.
- El procesamiento de imágenes, dependiendo de la cantidad de código a ejecutar y las operaciones
necesarias, tornaba un tanto lento el sensado de la variable a controlar.
- Se tuvieron que suprimir algunas instrucciones y otras reemplazarse por unas de menor cantidad
de operaciones a ejecutar en un lapso de tiempo
- Es preferible controlar un sistema aplicando un control como tal, con toda la teoría que rige la
ingeniería de la automatización, para tener una clara idea que lo que se quiere controlar
- La instrucción regionprops es muy útil al aplicarla a la imagen binarizada, para encontrar
paramentos de los objetos etiquetados, como son el área, el centroide, el perímetro, y otros más.
Lo que simplifico el código para hacerlo manualmente.
Bibliografía
- http://diymakers.es/mover-motores-paso-paso-con-arduino/

- https://la.mathworks.com/products/image/features.html

- https://www.calculadoraconversor.com/conversor-de-colores/

- https://la.mathworks.com/videos/computer-vision-with-matlab-for-object-

detection-and-tracking-

82036.html?elqsid=1529706447302&potential_use=Student

- https://jjchop.wordpress.com/2012/06/15/comunicar-matlab-con-

arduino/
Anexo DATASHEET
ANEXO IMÁGENES