Laboratorio - Robótica móvil
Materia
Introducción a la robótica - Semestre 02-2022
Profesor
Jovani Alberto Jimenez Builes
Monitor
Alejandro Quiroz Estrada
Integrantes:
Juan Diego Marín Rodríguez
Bolkar Leimar Ocampo Montoya
Cristian David Quinchia Ramirez
Juan Jose Salazar Cardona
UNIVERSIDAD NACIONAL DE COLOMBIA
SEDE MEDELLÍN
FACULTAD DE MINAS
Introducción
La robótica móvil son robots capaces de moverse autónomamente y de ejecutar
determinadas acciones. Podemos utilizar diferentes herramientas para sus
aplicaciones, entre ellas el arduino, con esto tiene un espectro de aplicación casi
ilimitado ya que, gracias a la tecnología inteligente se pueden utilizar aparatos
respectivos de muy diversas maneras, tales como sensores, puente H y demás para
hacer que los robots móviles se muevan y realicen diferentes funciones. A pesar de
que la robótica móvil actualmente aún se encuentra en un estadio relativamente
temprano de su desarrollo, hace varios años que se utilizan prototipos y productos en
serie en diferentes sectores.
Para este trabajo se realizaron cuatro ensambles, uno de ellos sin sensor, y tres con
sensores aplicando diferentes funcionalidades, en donde se adquirieron nuevos
conocimientos respecto a las aplicaciones de la robótica móvil; Incluso tocó soldar el
robot oruga para que funcionara correctamente.
Práctica
Materiales:
• Robot (Carro)
• Puente H
• Cables
• Protoboard
• Baterías
• Arduino UNO
• Sensor de gas
• Sensor de calor
• Sensor de proximidad
Procedimiento
Conectamos el Puente H a los motores de las ruedas del carro las cuales eran unas
ruedas de tipo oruga, también hacemos conexión al arduino en el cual usaremos el
puerto VIN para el Puente H, el pin GND y pines analogicos y digitales para sensores,
conectamos una línea de tierra en la protoboard para tener todo más ordenado, luego
generamos el código para qué el carro se mueva ya sea en línea recta o hacia los
lados según sea nuestra necesidad.
Coche sin sensores
Sensor de gas
Para la primera aplicación haremos el ensamble del primer sensor qué será el sensor
de gas, al detectar gas comenzará a girar sobre su propio eje hacia la derecha durante
4 segundos si deja de detectar gas o indeterminadamente si lo detecta
constantemente.
https://www.youtube.com/shorts/JKTxzTpdv-A
Código implementado
Sensor de gas:
Para poder dar uso de ese sensor se pensó en la funcionalidad de que al momento de
detectar una cantidad considerable de gas, se procediera a encender las llantas del
vehículo para generar un desplazamiento y que la persona notara que había un
aumento de gas en el aire. Esto se hizo definiendo un valor mínimo de gas para
encender el motor obtenido luego de pruebas de mediciones sobre el ambiente.
El código implementado sería:
Definición de variables
#define MQ1 (0) //define la entrada analogica para el sensor
#define RL_VALOR (5) //define el valor de la resistencia mde carga en
kilo ohms
#define RAL (9.83) // resistencia del sensor en el aire limpio / RO,
que se deriva de latabla de la hoja de datos
#define GAS_LP (0)
String inputstring = ""; //Cadena recibida desde el PC
float LPCurve[3] = { 2.3, 0.21, -0.47 };
float Ro = 10;
// definimos las variables que van conectadas al motor
int E2 = 7;
int M2 = 6;
int E1 = 5;
int M1 = 4;
Funciones para la calibración del sensor de gas
float calc_res(int raw_adc) {
return (((float)RL_VALOR * (1023 - raw_adc) / raw_adc));
}
float Calibracion(float mq_pin) {
int i;
float val = 0;
for (i = 0; i < 50; i++) { //tomar múltiples muestras
val += calc_res(analogRead(mq_pin));
delay(500);
}
val = val / 50; //calcular el valor medio
val = val / RAL;
return val;
}
float lecturaMQ(int mq_pin) {
int i;
float rs = 0;
for (i = 0; i < 5; i++) {
rs += calc_res(analogRead(mq_pin));
delay(50);
}
rs = rs / 5;
return rs;
}
int porcentaje_gas(float rs_ro_ratio, int gas_id) {
if (gas_id == GAS_LP) {
return porcentaje_gas(rs_ro_ratio, LPCurve);
}
return 0;
}
int porcentaje_gas(float rs_ro_ratio, float *pcurve) {
return (pow(10, (((log(rs_ro_ratio) - pcurve[1]) / pcurve[2]) +
pcurve[0])));
}
Setup de los motores y calibración del sensor de gas
void setup() {
pinMode(E2, OUTPUT); // Input4 conectada al pin
pinMode(M2, OUTPUT); // Input3 conectada al pin
pinMode(E1, OUTPUT); // Input4 conectada al pin
pinMode(M1, OUTPUT); // Input3 conectada al pin
Serial.begin(9600);
Serial.println("Iniciando ...");
//configuracion del sensor
Serial.print("Calibrando sensor de gas...\n");
//Calibrando el sensor. Por favor de asegurarse que el sensor se
encuentre en una zona de aire limpio mientras se calibra
Calibracion(MQ1);
Serial.print("Calibracion finalizada...\n");
}
Lógica de ejecución
void loop() {
int lectura_gas = 0;
lectura_gas = porcentaje_gas(lecturaMQ(MQ1) / Ro, GAS_LP);
Serial.println(lectura_gas);
if (lectura_gas >= 500) {
// Motor gira en un sentido
digitalWrite(E2, HIGH);
digitalWrite(M2, LOW);
digitalWrite(E1, HIGH);
digitalWrite(M1, LOW);
delay(4000);
// Motor no gira
digitalWrite(M2, LOW);
digitalWrite(M1, LOW);
digitalWrite(E2, LOW);
digitalWrite(E1, LOW);
}
}
Sensor calor
En la siguiente aplicación usaremos el sensor de calor el cual detectara el calor
humano en adelante y cada qué el lo detecte girara sobre su propio eje, con un
funcionamiento similar al de la aplicación anterior.
https://www.youtube.com/shorts/gnyYg-XFPL0
Código sensor de calor
Para poder dar uso de ese sensor se pensó en la funcionalidad de que al momento de
detectar una cantidad considerable de temperatura alta, se procediera a encender las
llantas del vehículo para generar un desplazamiento. Esto se hizo definiendo un valor
mínimo de calor para encender el motor obtenido luego de pruebas de mediciones
sobre el ambiente.
El código implementado sería:
Definición de variables
// definimos las variables que van conectadas al motor
int E2 = 7;
int M2 = 6;
int E1 = 5;
int M1 = 4;
Setup de los motores
void setup() {
pinMode(E2, OUTPUT); // Input4 conectada al pin
pinMode(M2, OUTPUT); // Input3 conectada al pin
pinMode(E1, OUTPUT); // Input4 conectada al pin
pinMode(M1, OUTPUT); // Input3 conectada al pin
Serial.begin(9600);
}
Lógica de ejecución:
void loop() {
int valorSensor = analogRead(A2);
Serial.println(valorSensor);
if (valorSensor >= 300) {
// Motor gira en un sentido
digitalWrite(E2, HIGH);
digitalWrite(M2, LOW);
digitalWrite(E1, HIGH);
digitalWrite(M1, LOW);
delay(4000);
// Motor no gira
digitalWrite(M2, LOW);
digitalWrite(M1, LOW);
digitalWrite(E2, LOW);
digitalWrite(E1, LOW);
}
}
Sensor de proximidad
En la siguiente aplicación tendremos un sensor de proximidad qué se moverá hasta
encontrarse con un objeto; y esto lo hará sobre su propio eje, similar a las aplicaciones
anteriores.
https://www.youtube.com/shorts/XJFXsQpg8Og
Sensor de proximidad (ultrasonido):
Para este caso definimos un caso de uso que consiste en detener el motor cuando se
detecte una señal a menos de 15 CM, acorde a los datos obtenidos por el sensor
ultrasónico. Esto con el fin de evitar choques del carro con agentes externos.
El código implementado sería:
Definición de variables
int E2 = 7;
int M2 = 6;
int E1 = 5;
int M1 = 4;
const int Trigger = 2; //Pin digital 2 para el Trigger del sensor
const int Echo = 3; //Pin digital 3 para el Echo del sensor
Setup de los motores y sensor de proximidad
void setup() {
pinMode(E2, OUTPUT); // Input4 conectada al pin 4
pinMode(M2, OUTPUT); // Input3 conectada al pin 5
pinMode(E1, OUTPUT); // Input4 conectada al pin 4
pinMode(M1, OUTPUT); // Input3 conectada al pin 5
Serial.begin(9600);
pinMode(Trigger, OUTPUT); //pin como salida
pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW); //Inicializamos el pin con 0
}
Lógica de ejecución:
void loop() {
long tiempo; //timepo que demora en llegar el eco
long distancia; //distancia en centimetros
digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);
tiempo = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso
distancia = tiempo / 59; //escalamos el tiempo a una distancia en
cm
Serial.println(distancia);
while (distancia >= 15) {
digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);
tiempo = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso
distancia = tiempo / 59;
Serial.println(distancia);
if (distancia >= 15) {
digitalWrite(E2, HIGH);
digitalWrite(M2, LOW);
digitalWrite(E1, HIGH);
digitalWrite(M1, LOW);
} else {
digitalWrite(M2, LOW);
digitalWrite(M1, LOW);
digitalWrite(E2, LOW);
digitalWrite(E1, LOW);
}
}
}
Conclusiones
La robótica móvil tiene una amplia gama de aplicaciones, en donde existe una extensa
cantidad de herramientas para combinar y utilizar con un arduino, sensores y un coche.
Los ensambles aquí presentados sólo son una pequeña muestra de las funcionalidades
que puede llegar a tener la robótica móvil, y actualmente existen dispositivos con
integraciones e inteligencias artificiales tan complejas que satisfacen las necesidades
del ser humano en la actualidad.
Se generaron muchas fallas al momento de hacer el montaje, el coche inicial tenía
problemas y se tuvo que cambiar por un segundo coche (robot oruga), las baterías
tenían voltaje pero se quedaban sin corriente rápidamente, fallas de código y de
voltaje, pero al final se logró realizar todos los ensambles y adquirir una buena cantidad
de experiencia con todos los obstáculos presentados.
