Robótica y Manufactura

Integrada
LABORATORIO N° 16

Programación del robot

Integrantes:

Obando Rojas, Yutmer Clin

Perez Anchiraico, Leonardo Franco

Vargas Garibay, Juan Andy

Sección: A

Fecha de realización: 08/07/2023

Fecha de presentación: 08/07/2023

2023
 ÍNDICE DE CONTENIDOS

1. Fundamento Teórico............................................................................................................ 4
ESP-32............................................................................................................................... 4
Arduino IDE........................................................................................................................ 5
Robots cartesianos.............................................................................................................6
2. Desarrollo.............................................................................................................................7
Figura 1. Gripper sujetando la ficha............................................................................. 9
Figura 2. Gripper soltando la ficha en la rampa......................................................... 10
3. Conclusiones...................................................................................................................... 11
 ÍNDICE DE FIGURAS

Figura 1. Gripper sujetando la ficha 8

Figura 2. Gripper soltando la ficha en la rampa 9
 1. Fundamento Teórico

ESP-32

ESP32 es un microcontrolador de bajo costo y bajo consumo de energía que combina Wi-Fi

y Bluetooth de doble modo. Fue desarrollado por Espressif Systems y es una evolución del

ESP8266, otro microcontrolador muy popular en el campo de la electrónica de bajo costo y

el Internet de las cosas (IoT).

El ESP32 cuenta con un procesador de doble núcleo, lo que le permite manejar tareas más

complejas y ejecutar múltiples hilos de manera eficiente. Además, tiene una amplia gama

de interfaces y periféricos, como UART, SPI, I2C, PWM, ADC, entre otros, lo que lo hace

muy versátil y adecuado para una variedad de aplicaciones.

Una de las características más destacadas del ESP32 es su capacidad para conectarse a

redes Wi-Fi y Bluetooth. Esto permite la comunicación inalámbrica con otros dispositivos y

la conexión a Internet. Además, el ESP32 es compatible con una amplia gama de

protocolos y estándares de comunicación, lo que lo hace compatible con diferentes

sistemas y dispositivos.

El ESP32 se utiliza ampliamente en proyectos de IoT, domótica, automatización del hogar,

monitoreo remoto, wearables y muchas otras aplicaciones donde se requiere una

conectividad inalámbrica y un control de bajo nivel. Además, hay una comunidad activa de

desarrolladores que han creado bibliotecas y herramientas para programar el ESP32, lo

que facilita su uso y desarrollo de proyectos.

Arduino IDE

Arduino IDE (Integrated Development Environment) es un entorno de desarrollo integrado

utilizado para programar y cargar código en las placas Arduino. Fue creado

específicamente para facilitar el desarrollo de proyectos con Arduino, una plataforma de

prototipado electrónico de código abierto.

Arduino IDE proporciona una interfaz gráfica sencilla y fácil de usar que permite a los

usuarios escribir, compilar y cargar código en las placas Arduino de manera rápida y

sencilla, incluso sin tener conocimientos profundos de programación. Es compatible con los

diversos modelos de placas Arduino y se ejecuta en diferentes sistemas operativos, como

Windows, macOS y Linux.

El entorno Arduino IDE utiliza un lenguaje de programación basado en C/C++ y proporciona

una serie de librerías y funciones predefinidas que simplifican la programación y permiten el

acceso a los pines y periféricos de la placa Arduino, como sensores, actuadores, pantallas,

comunicación serial, entre otros.

Además de escribir y compilar el código, Arduino IDE también permite cargar el programa

resultante en la placa Arduino a través de un cable USB. Esto facilita el proceso de

prototipado y prueba de proyectos, ya que los usuarios pueden realizar cambios en el

código, compilarlo y cargarlo en la placa de manera rápida para ver los resultados en

tiempo real.

Arduino IDE también ofrece herramientas de depuración básicas y un monitor serial que

permite visualizar los mensajes y datos enviados o recibidos a través del puerto serial de la

placa Arduino.
Robots cartesianos

Los robots cartesianos, también conocidos como robots de coordenadas rectangulares, son

una categoría de robots industriales que utilizan un sistema de coordenadas cartesianas

para moverse y realizar tareas en un espacio tridimensional. Estos robots se caracterizan

por tener tres ejes lineales ortogonales (X, Y, Z) que se mueven en dirección horizontal,

vertical y perpendicular al suelo respectivamente.

A diferencia de otros tipos de robots industriales, como los robots SCARA o los robots

articulados, los robots cartesianos se mueven mediante el desplazamiento de sus ejes

lineales de manera independiente y controlada. Esto les permite moverse de manera

precisa y repetitiva en una configuración rectangular, siguiendo una trayectoria definida por

las coordenadas cartesianas.

Los robots cartesianos son comúnmente utilizados en aplicaciones de montaje,

manipulación, soldadura, corte, grabado y ensamblaje en la industria manufacturera.

Debido a su estructura rígida y diseño simple, son capaces de manejar cargas pesadas y

realizar movimientos rápidos y precisos.

Además, los robots cartesianos suelen ser programados utilizando software específico que

permite definir las coordenadas y trayectorias de movimiento. Esto facilita la programación

y el control del robot, ya que los operadores pueden especificar las posiciones exactas a las

que se debe mover el robot en el espacio de trabajo.

 2. Desarrollo

A continuación se muestra el código con el que se ha programado el ESP-32 utilizado, que

a través de la interfaz IO industrial pueda controlar los movimientos tanto del eje X, eje Z y

del gripper. Este microcontrolador funciona con las salidas del PLC S7-300, 1Y1, 1Y2, 2Y1

y 3Y1, por lo que el PLC se encarga del control del módulo y el ESP32 exclusivamente del

movimiento de los motores, teniendo en cuenta los finales de carrera para evitar colisiones.

//PINES INTERFAZ - PINES ESP 32

#define IN0 12
#define IN1 13
#define IN2 23
#define IN3 22
#define IN4 14
#define IN5 27
#define ADC4 32
#define ADC5 33
#define OUT0 18
#define OUT1 16
#define OUT2 4
#define OUT3 5
#define OUT4 17
// LIBRERIA DE CONTROL DE SERVOMOTOR PARA ESP32
#include <ESP32Servo.h>
Servo servo;
//#define OUT5 2 PIN PARA DISPLAY

void setup() {
pinMode(IN0,INPUT); // 1Y1
pinMode(IN1,INPUT); // 1Y2
pinMode(IN2,INPUT); // 2Y1
pinMode(IN3,INPUT); // 3Y1
pinMode(IN4,INPUT); // FINAL DE CARRERA DERECHA
pinMode(IN5,INPUT); // FINAL DE CARRERA IZQUIERDA
pinMode(ADC4,INPUT); // FINAL DE CARRERA ARRIBA
pinMode(ADC5,INPUT); // FINAL DE CARRERA ABAJO
pinMode(OUT0,OUTPUT); // MOTOR DERECHA
pinMode(OUT1,OUTPUT); // MOTOR IZQUIERDA
pinMode(OUT2,OUTPUT); // MOTOR ABAJO
pinMode(OUT3,OUTPUT); // MOTOR ARRIBA
 servo.attach(OUT4); // GRIPPER
//pinMode(OUT5,OUTPUT); // PIN PARA DISPLAY

void loop() {
int FCR = digitalRead(IN4); // EJE X FINAL DE CARRERA RIGHT
int FCL = digitalRead(IN5); // EJE X FINAL DE CARRERA LEFT
int FCU = analogRead(ADC4); // EJE Z FINAL DE CARRERA UP
int FCD = analogRead(ADC5); // EJE Z FINAL DE CARRERA DOWN
int XR = digitalRead(IN0); // 1Y1
int XL = digitalRead(IN1); // 1Y1
int ZD = digitalRead(IN2); // 2Y1
int SG = digitalRead(IN3); // 3Y1
int ADCLIM = 300; //UMBRAL DE APROX 3V PARA ENTRADAS ANALOGICAS

// 1Y1 ON - MOTOR EJE X DERECHA

if (XR==1 & FCR==0){
digitalWrite(OUT0,HIGH);
digitalWrite(OUT1,LOW);
} else{
digitalWrite(OUT0,LOW);
digitalWrite(OUT1,LOW);
}
// 2Y1 ON - MOTOR EJE X IZQUIERDA
if (XL==1 & FCL==0){
digitalWrite(OUT1,HIGH);
digitalWrite(OUT0,LOW);
} else{
digitalWrite(OUT1,LOW);
digitalWrite(OUT0,LOW);
}
// 2Y1 ON - MOTOR EJE Z ABAJO
if (ZD==1){
if(FCD<ADCLIM){
digitalWrite(OUT2,HIGH);
digitalWrite(OUT3,LOW);
}else{
digitalWrite(OUT2,LOW);
digitalWrite(OUT3,LOW);
}
// 2Y1 OFF - MOTOR EJE Z ARRIBA
 }else{
if(FCU<ADCLIM){
digitalWrite(OUT2,LOW);
digitalWrite(OUT3,HIGH);
}else{
digitalWrite(OUT2,LOW);
digitalWrite(OUT3,LOW);
}

}
// 3Y1 OFF - GRIPER ABIERTO
if(SG==0){
servo.write(10);
// 3Y1 ON - GRIPPER CERRADO
}else{
servo.write(80);
}
}

Figura 1. Gripper sujetando la ficha

 Figura 2. Gripper soltando la ficha en la rampa

Video de funcionamiento: https://youtube.com/shorts/9iCdDlTeDrw?feature=share

3. Conclusiones

- Un ESP32, al contar con una interfaz de entrada/salida (IO), tiene la capacidad de

comunicarse y conectarse con un Controlador Lógico Programable (PLC). También

con esta misma interfaz puede simular a un PLC convencional.

- Utilizando los acoples y diseños adecuados, los motores eléctricos pueden emular

de manera efectiva los actuadores neumáticos, lo que permite sustituirlos y

prescindir así de la necesidad de alimentación neumática.