BRAZO ROBOTICO AUTOMATA Y MANUAL CODIGO

Empezaremos explicando un poco toda la programacion:

Estructura de un programa

La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones, estamentos o instrucciones.

void setup() //Primera Parte { estamentos; } void loop() //Segunda Parte { estamentos; }

En donde setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se ejecutará cíclicamente (de ahí el término loop -bucle-). Ambas funciones son necesarias para que el programa trabaje.

La función de configuración (setup) debe contener la declaración de las variables. Es la primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para configurar o inicializar pinMode (modo de trabajo de las E/S), configuración de la comunicación en serie y otras.

La función bucle (loop) siguiente contiene el código que se ejecutara continuamente (lectura de entradas, activación de salidas, etc) Esta función es el núcleo de todos los programas de Arduino y la que realiza la mayor parte del trabajo.

setup()

La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya declaración que ejecutar. Así mismo se puede utilizar para establecer el estado inicial de las salidas de la placa.

void setup() { pinMode(pin, OUTPUT); // configura el 'pin' como salida digitalWrite(pin, HIGH); // pone el 'pin' en estado HIGH }

loop()

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre, se ejecuta de forma cíclica, lo que posibilita que el programa esté respondiendo continuamente ante los eventos que se produzcan en la placa.

void loop() {

digitalWrite(pin, HIGH); // pone en uno (on, 5v) el 'pin'

delay(1000); // espera un segundo (1000 ms)

digitalWrite(pin, LOW); // pone en cero (off, 0v.) el 'pin'

delay(1000);

}

Funciones

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado. Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. Las funciones se declaran asociadas a un tipo de valor "type". Este valor será el que devolverá la función, por ejemplo 'int' se utilizará cuando la función devuelve un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra "void", que significa "función vacía". Después de declarar el tipo de dato que devuelve la función se debe escribir el nombre de la función y entre paréntesis se escribirán, si es necesario, los parámetros que se deben pasar a la función para que se ejecute.

type nombreFunción(parámetros) { instrucción; }

La función siguiente devuelve un número entero, delayVal() se utiliza para poner un valor de retraso en un programa que lee una variable analógica de un potenciómetro conectado a una entrada de Arduino. Al principio se declara como una variable local, 'v' recoge el valor leído del potenciómetro que estará comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el valor 'v' y se retornaría al programa principal. Esta función cuando se ejecuta devuelve el valor de tipo entero 'v'.

int delayVal() { int v; // crea una variable temporal 'v' v= analogRead(pot); // lee el valor del potenciómetro v /= 4; // convierte 0-1023 a 0-255 return v; // devuelve el valor final }

{} entre llaves

Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para los bloques de programación setup(), loop(), if.., etc.

type funcion() { instrucciones; }

Una llave de apertura "{" siempre debe ir seguida de una llave de cierre "}", si no es así el programa dará errores.

El entorno de programación de Arduino incluye una herramienta de gran utilidad para comprobar el total de llaves. Sólo tienes que hacer click en el punto de inserción de una llave abierta e inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).

; punto y coma

El punto y coma ";" se utiliza para separar instrucciones en el lenguaje de programación de Arduino. También se utiliza para separar elementos en una instrucción de tipo "bucle for".

int x = 13; /* declara la variable 'x' como tipo entero de valor 13 */

Nota: Olvidaos de poner fin a una línea con un punto y coma o se producirá en un error de compilación. El texto de error puede ser obvio, y se referirá a la falta de una coma, o puede que no. Si se produce un error raro y de difícil detección lo primero que debemos hacer es comprobar que los puntos y comas están colocados al final de las instrucciones.

**/... / bloque de comentarios**

Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el programa que se utilizan para las descripciones del código o comentarios que ayudan a comprender el programa. Comienzan con / * y terminan con * / y pueden abarcar varias líneas.

/* esto es un bloque de comentario no se debe olvidar cerrar los comentarios estos deben estar equilibrados */

Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de Arduino pueden ser utilizados con generosidad. También pueden utilizarse para "comentar" bloques de código con el propósito de anotar informaciones para depuración y hacerlo mas comprensible para cualquiera.

Nota: Dentro de una misma línea de un bloque de comentarios NO se puede escribir otro bloque de comentarios (usando /*..*/).

// línea de comentarios

Una línea de comentario empieza con // y terminan con la siguiente línea de código. Al igual que los comentarios de bloque, los de línea son ignoradas por el programa y no ocupan espacio en la memoria.

// esto es un comentario

Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más información acerca de lo que hace ésta o para recordarla más adelante.

CODIGO FINAL:

Explicado por partes, para el mejor entendimiento.

Despues de la explicacion del codigo, esta publicado el codigo completo, sin interrupciones.

Librería del LCD:

Antes que hagamos algo el programador, es mejor aprender a descargar librerias e incluirlas.

Asi no perderemos tiempo en hacerlo al momento justo de un programa y entorpecer la programacion, ya que aveces algunas librerias podria no sar la que quieriamos o nesecitabamos usar.

¿Que es una librería de arduino?

Las librerías son colecciones de código que facilitan la interconexión de sensores, pantallas, módulos electrónicos, etc.

El entorno de arduino ya incluye algunas librerías de manera que se facilite, por ejemplo, mostrar texto en pantallas LCD.

Existen cientos de librerías desarrolladas por terceros en internet, que nos ayudarán a conectar prácticamente cualquier dispositivo a nuestras tarjetas con arduino.

Para saber como utilizar una librería, es necesario consultar la referencia oficial de arduino o el sitio web desde el cual descargamos la librería, también podemos consultar los ejemplos que vienen con las librerías si es que no encontramos más documentación.

Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP:

Un archivo .cpp (código de C++)
Un archivo .h o encabezado de C
Un archivo Keywords.txt
Muy posiblemente la librería incluye un archivo readme con información adicional sobre la librería para el desarrollador.
Directorio de sketch de ejemplo (opcional).

Librerias : https://www.arduino.cc/en/Reference/Libraries

¿Como instalar una librería de Arduino?

1.- Ubicar y descargar la librería de arduino que requerimos.

Normalmente nos encontraremos con archivos en formato ZIP.

2.- Abrir el IDE de Arduino y hacer click en Programa > Include Librery > Ass .ZIP Library en la barra de menu.

En este proyecto solo usaremos esa libreria, por eso pondré como ejemplo LiquidCrystal pero es igual para cualquier libreria que nesecitemos declarar.

Una vez que tenemos la libreria, la buscamos de esta manera y la incluimos dentro de nuestro programa.

Como veran los 2 procesos son muy parecidos.

Link de la libreria para el LCD

https://www.arduino.cc/en/Reference/LiquidCrystal

Si todo ha salido bien nos deberia haber aparecido esto:

#include <LiquidCrystal.h>

Incluimos la librería LiquiddCrystal.h y definimos los pines a usar del Arduino.

Esta librería LiquiddCrystal.h permite a una placa Arduino controlar las pantallas de LiquidCrystal (LCD) basadas en el Hitachi HD44780 (o un chipset compatible), que se encuentra en la mayoría de las pantallas LCD basadas en texto.

La biblioteca funciona con el modo de 4 o 8 bits (es decir, usando 4 o 8 líneas de datos además de las rs, enable y opcionalmente las líneas de control rw).

Declaramos las Variables:

Declaramos las Constantes Variables:

En el Setup ()

Acá en el Setup ingresamos lo que necesitamos que se inicie en el arranque.

Ejemplo: para inicializar variables, modos de pin, iniciar utilizando bibliotecas, etc.

La función de configuración sólo se ejecutará una vez, después de cada encendido o reinicio de la placa Arduino.

En el Void Loop ()

Rutinas y SubRutinas:

Sistema Automatizado de las Teclas:

Esta SubRutina verifica si alguna de las 4 teclas esta activada y si es así ejecuta acciones, de lo contrario no hace nada y queda en espera, apagando el habilitador de los motores paso a paso, ahorrando energía, y también selecciona la velocidad normal para la acción y da aviso visual al LCD de que se está ejecutando en automático y a la velocidad normal.

Tecla1

Estas 4 teclas accionadas en simultaneo o individualmente, ejecutan acciones preestablecidas.

Vea como las 4 subrutinas son muy parecidas, aunque los motores se ejecutan casi en el mismo orden, pero distintos giros (Horario y AntiHorario), haciendo que ejecute la automatización programada.

También selecciona la velocidad normal para la acción y da aviso visual al LCD de que se está ejecutando en automático y a la velocidad normal.

Como habrán notado, Tecla1, Tecla2, Tecla3 y Tecla4 son subrutinas.

ACLARACION

Tenga en cuenta que la automatizacion, dependiendo las distancias de las teclas respecto a los motores y sus ejes, las coordenadas pueden variar, pero es solo cuestion de ir regulando de a poco.

Verán que no es muy dificial calibrar.

Aumentando o disminuyendo los valores dentro del ciclo for podremos girar unos grados mas o menos segun sea el caso.

EJEMPLO:

for (int i = o; i <= 140; i++{ MotorVerticalIzquierda;}

Cambiando el 140 por 70, girará la mitad de lo que estaba girando.

Luego debe volver a posicionar, asi que si giramos por ejemplo 70 a la izquierda, ahora debe girar 70 a la derecha, pero luego de mover el otro motor paso a paso.

Movimiento de los 2 motores Paso a Paso (Giro Horario y Giro AntiHorario)

Acá no daremos tantos detalles ya que es mucha matemática, solo lo importante.

Elige la dirección de giro, (Horario o AntiHorario) = (Dirección, LOW) o (Dirección, HIGH)

Luego con estos valores:

Pasos por vuelas se divide en nuestro caso por el divisor (128).

Pasos por periodo lo divide a 0.65

Step, LOW y Step, HIGH son los pasos del motor.

Todo esto en resumen es lo que da los distintos pulsos para mover el motor.

Las 5 Velocidades

Como hemos visto en más arriba las entradas M0, M1, M2 del driverA4988 son las que manejan los pasos y micropasos.

Siendo estos los que mueven el motor con un pulso los distintos grados.

Tabla Real:

Tabla del proyecto:

Estos distintos micropasos son muy útiles, porque a veces necesitamos más velocidad, pero otras veces necesitamos mayor precisión.

En este proyecto declaramos la Constante Variable

Pasos por vueltas en 200

Y un giro completo tiene 360°

Si dividimos 360° en 200 pasos nos da un Angulo de 1.8° por paso.

Que es la resolución de la mayoría de los motores nemas 17.

Para la automatización, lo dejaremos LOW, HIGH, LOW, a 1/4 de pasos, así no es tan lento, pero teniendo bastante precisión.

Los pasos más lentos son los de más precisión, y los pasos más rápidos son menos precisos dificultando a veces el exacto posicionamiento.

El paso 1/16 es el más apropiado para usar, cuando las tareas demanden mucha precisión.

Ejemplo:

Si lo tenemos a velocidad normal LOW, HIGH, LOW, a 1/4 de pasos, nos daría estos resultados:

1/4 de 1 x 200 x 1.8° = 0.25 x 200 x 1.8°= 50 x 1.8° = 90°

Como verán LOW, HIGH, LOW, a 1/4 de pasos nos da un giro de 90°, pero recuerden que nosotros usamos un divisor de 128 y también dividimos el paso de periodo a 0.65, así que con un solo pulso no girará 90° sino muchísimo menos.

El Joystick Analógico

Lee las coordenadas de X e Y, y las declara dentro de PosicionX y PosicionY.

Luego ya que los motores paso a paso se encuentran en estado de espera, esta rutina verifica que los valores estén en ciertos valores para que se ejecuten, y den aviso también al LCD de que esta en manual, también habilita los motores solo si algunas de las coordenadas superan ciertos límites, así ahorramos energía en los momentos de espera.

Si se da las condiciones mencionadas ejecutara las acciones que están establecidas individualmente en cada coordenada de X e Y girando el motor en sentido Horario o AntiHorario según sea el caso.

El uso del Joystick es muy útil en estos proyectos, por ejemplo, el más utilizado es el de poder poner a punto el posicionamiento de los motores para que ejecuten automatizaciones con total precisión, ya que unos pocos grados o milímetros desplazados cualquiera de los 2 motores paso a paso podría significar la falla en la tarea a realizar y quedando en un bucle infinito o tal vez la rotura de alguna parte mecánica dependiendo en que se utilice.

Por ejemplo:

En este proyecto cuando presionemos una tecla, la automatización debería volver a presionarlo para apagar el ciclo, pero ese grado o milímetro mal posicionado haría que no pueda concretar la rutina, y al volver al punto de retorno, detectaría nuevamente la tecla que no pudo accionar y volvería a ejecutar la acción infinitamente, así hasta que corrijamos el error o presionemos la tecla nosotros.

Más adelante solucionaremos este inconveniente y que se autorregule el posicionamiento con sensores, estuve pesando mucho en hacerlo, pero como el proyecto es chico, el uso de más cables cerca de los motores, entorpeceria mucho, así que por el momento lo postergo, hasta la próxima.

Velocidad del Joystick Analógico

Lee el estado del BotonR3 del Joystick para variar la velocidad.

Compara el estado actual del BotonR3 del Joystick con el estado anterior y si es distinto incrementa su valor.

Luego guarda el nuevo valor.

La secuencia real es así:

Por defecto arranca en 3 (VELOCIDAD NORMAL)

Con un pulso del BotonR3 del Joystick pasa a 4 y cambia la velocidad a (LENTO).

Con otro pulso del BotonR3 del Joystick pasa a 5 y cambia la velocidad a (MUY LENTO).

Con otro pulso del BotonR3 del Joystick pasa a 6 "pero" como hay un IF que dice que si el contador es mayor a 5 debe volver su valor a 1, así que pasa a 1 y cambia la velocidad a (MUY RAPIDO).

Con otro pulso del BotonR3 del Joystick pasa a 2 y cambia la velocidad a (RAPIDO).

Con un pulso del BotonR3 del Joystick pasa a 3 y cambia la velocidad a (NORMAL).

Y así vamos repitiendo el ciclo indefinidamente.

Originalmente había pensado en 2 botones distintos uno que suba y otro que baje la velocidad, pero pensé en aprovechar el BotonR3 del Joystick, ya que no tenía otro uso.

Avisos Visuales del LCD: (Automático o Manual) + (Velocidades)

En esta parte tampoco entrare en muchos detalles ya que son solo subrutinas de aviso al LCD y con solo mirar se podrá apreciar que hace cada una de ellas.

Lcd.setCursor(Columna, Filas); esta parte del código selecciona desde donde comienza a cargar el texto en el LCD (Imprimir).

Ejemplo:

Las coordenadas (0,0) se ubica arriba a la izquierda, en la primera fila, y primera columna.

Las coordenadas (1,1) se ubica arriba a la izquierda, en la segunda fila, y segunda columna.

Las coordenadas (10,3) se ubica abajo en el centro, en la cuarta fila, y decima columna.

Lcd. print("Texto"); texto a cargar (Imprimir).

Para evitar usar el clear para borrar decidí, llenar los espacios en blanco con el símbolo de espacio hasta completar las 20 columnas, así evito errores.

Código Completo en formato de Texto

// Esquema de las teclas, respecto al el brazo robotico.

// Tenga en cuenta que la automatizacion,

// dependiendo las distancias de las teclas respecto a los motores y sus ejes,

// las coordenadas pueden variar, pero es solo cuestion de ir regulando de a poco.

//***************************

//** *

//** (1) (4) * Tecla 1 y 2

//** *

//** (M) * Motores

//** *

//** (2) (3) * Teclas 3 y 4

//** *

//***************************

//----------------------------------------------------------------------------------------------------------------------------

#include <LiquidCrystal.h>

//----------------------------------------------------------------------------------------------------------------------------

LiquidCrystal lcd(25, 27, 29, 31, 33, 35);

//----------------------------------------------------------------------------------------------------------------------------

int PasosM0 = 6; // Pin 6 Habilitador de los pasos del Driver A4988 = M0

int PasosM1 = 7; // Pin 7 Habilitador de los pasos del Driver A4988 = M1

int PasosM2 = 8; // Pin 8 Habilitador de los pasos del Driver A4988 = M2

//----------------------------------------------------------------------------------------------------------------------------

int CoordenadaX = A0; // Pin Analogico A0 Comando X del joystick

int CoordenadaY = A1; // Pin Analogico A1 Comando Y del joystick

//----------------------------------------------------------------------------------------------------------------------------

const int BotonR3 = 24; // Pin 24 conectado el pulsador R3 del joystick

//----------------------------------------------------------------------------------------------------------------------------

const int LedMuyRapido = 26; // Pin para LED Rojo

const int LedRapido = 28; // Pin para LED Naranja

const int LedNormal = 30; // Pin para LED Amarillo

const int LedLento = 32; // Pin para LED Verde

const int LedMuyLento = 34; // Pin para LED Azul

//----------------------------------------------------------------------------------------------------------------------------

int ContadorPulsosBotonR3 = 2; // Contador con 0 asi cuando arranca comienza con velocidad normal de las pulsaciones de botón R3 del joystick

//----------------------------------------------------------------------------------------------------------------------------

int EstadoDelBotonR3 = 0; // Estado actual del botón R3 del joystick

//----------------------------------------------------------------------------------------------------------------------------

int UltimoEstadoDelBotonR3 = 0; // Estado anterior del botón R3 del joystick

//----------------------------------------------------------------------------------------------------------------------------

int Habilitador = 13; // Pin 13 Habilitador de los Driver A4988

//----------------------------------------------------------------------------------------------------------------------------

int Dividisor = 128; // Divisor de los pasos por vueltas Ideal 128

//----------------------------------------------------------------------------------------------------------------------------

const int Step1 = 9; // Pin Stepper Motor Paso a paso 1

const int Step2 = 11; // Pin Stepper Motor Paso a paso 2

//----------------------------------------------------------------------------------------------------------------------------

const int Direccion1 = 10; // Pin Direccion motor Paso a paso 1

const int Direccion2 = 12; // Pin Direccion motor Paso a paso 2

//----------------------------------------------------------------------------------------------------------------------------

int Boton1 = 5; // Definimos el pin de la entrada a la tecla 1

int Boton2 = 2; // Definimos el pin de la entrada a la tecla 2

int Boton3 = 3; // Definimos el pin de la entrada a la tecla 3

int Boton4 = 4; // Definimos el pin de la entrada a la tecla 4

//----------------------------------------------------------------------------------------------------------------------------

const int PasosRPM1 = 200; // Velocidad en RPM 60 a 600, 200 Ideal

const int PasosRPM2 = 200; // Velocidad en RPM 60 a 600, 200 Ideal

//----------------------------------------------------------------------------------------------------------------------------

const int PasosPorVueltas1 = 200; // Pasos por vuelta de nuestro motor 200 es una vuelta 1.8° 50 a 400 Ideal 200

const int PasosPorVueltas2 = 200; // Pasos por vuelta de nuestro motor 200 es una vuelta 1.8° 50 a 400 Ideal 200

//----------------------------------------------------------------------------------------------------------------------------

// Con la velocidad y el numero de pasos por vuelta, podemos calcular el periodo con el que debemos actuar sobre el pin Steepper.

// PasosPeriodo = 600 * (PasosRPM / 60 ) / PasosPorVueltas; // 100 a 600 Ideal 200

//----------------------------------------------------------------------------------------------------------------------------

const int PasosPeriodo1 = 300 * (PasosRPM1 / 100) / PasosPorVueltas1;

const int PasosPeriodo2 = 300 * (PasosRPM2 / 100) / PasosPorVueltas2;

//----------------------------------------------------------------------------------------------------------------------------

int PosicionX = 0; // Posicion X del jostick

int PosicionY = 0; // Posicion Y del jostick

//----------------------------------------------------------------------------------------------------------------------------

void setup() {

//----------------------------------------------------------------------------------------------------------------------------

Serial.begin(9600); // Habilitamos el monitor serie a 9600

//----------------------------------------------------------------------------------------------------------------------------

lcd.begin(20, 4);

//----------------------------------------------------------------------------------------------------------------------------

pinMode(Habilitador, OUTPUT); // Habilitamos como salida

//----------------------------------------------------------------------------------------------------------------------------

pinMode(PasosM0, OUTPUT); // Habilitamos como salida

pinMode(PasosM1, OUTPUT); // Habilitamos como salida

pinMode(PasosM2, OUTPUT); // Habilitamos como salida

//----------------------------------------------------------------------------------------------------------------------------

pinMode( Boton1 , INPUT) ; // Botones como entradas

pinMode( Boton2 , INPUT) ; // Botones como entradas

pinMode( Boton3 , INPUT) ; // Botones como entradas

pinMode( Boton4 , INPUT) ; // Botones como entradas

//----------------------------------------------------------------------------------------------------------------------------

pinMode(Step1, OUTPUT); // Vamos a escribir sobre los pines Stepper que son salidas

pinMode(Step2, OUTPUT); // Vamos a escribir sobre los pines Stepper que son salidas

//----------------------------------------------------------------------------------------------------------------------------

pinMode(Direccion1, OUTPUT); // Vamos a escribir sobre los pines Direccion que son salidas

pinMode(Direccion2, OUTPUT); // Vamos a escribir sobre los pines Direccion que son salidas

//----------------------------------------------------------------------------------------------------------------------------

pinMode(CoordenadaX, INPUT); // Declarar pines como entrada jostick X analogico

pinMode(CoordenadaY, INPUT); // Declarar pines como entrada jostick Y analogico

//----------------------------------------------------------------------------------------------------------------------------

pinMode(BotonR3, INPUT_PULLUP);// Inicializar el pin del botón como entrada , Resistencia de pullup interna.

//----------------------------------------------------------------------------------------------------------------------------

pinMode(LedMuyRapido, OUTPUT); // Inicializa el pin 26 del LED Rojo como una salida

pinMode(LedRapido, OUTPUT); // Inicializa el pin 28 del LED Naranja como una salida

pinMode(LedNormal, OUTPUT); // Inicializa el pin 30 del LED Amarillo como una salida

pinMode(LedLento, OUTPUT); // Inicializa el pin 32 del LED Verde como una salida

pinMode(LedMuyLento, OUTPUT); // Inicializa el pin 34 del LED Azul como una salida

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

void loop() {

AvisoSistemaManual();

//----------------------------------------------------------------------------------------------------------------------------

VelocidadConJoystick(); // Accion

//----------------------------------------------------------------------------------------------------------------------------

Joystick(); // Accion

//----------------------------------------------------------------------------------------------------------------------------

SistemaAutomatizadoTeclas(); // Accion

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

void SistemaAutomatizadoTeclas() {

//----------------------------------------------------------------------------------------------------------------------------

int Valor1 = digitalRead(Boton1) ; // Leemos los Valores de las teclas

int Valor2 = digitalRead(Boton2) ; // Leemos los Valores de las teclas

int Valor3 = digitalRead(Boton3) ; // Leemos los Valores de las teclas

int Valor4 = digitalRead(Boton4) ; // Leemos los Valores de las teclas

//----------------------------------------------------------------------------------------------------------------------------

if (Valor1 < 1 '' Valor2 < 1 '' Valor3 < 1 '' Valor4 < 1 ) // Condicion para habilitar los motores, velocidad y acciones

//----------------------------------------------------------------------------------------------------------------------------

{

//----------------------------------------------------------------------------------------------------------------------------

digitalWrite(Habilitador, LOW); // Habilita corriente a los Motores PAP

//----------------------------------------------------------------------------------------------------------------------------

VelocidadNormal(); // Selecciona la velocidad de los Motores PAP

AvisoSistemaAutomatico();

AvisoConMovimiento();

//----------------------------------------------------------------------------------------------------------------------------

Tecla1Normal(); // Accion

Tecla2Normal(); // Accion

Tecla3Normal(); // Accion

Tecla4Normal(); // Accion

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

else

//----------------------------------------------------------------------------------------------------------------------------

{

//----------------------------------------------------------------------------------------------------------------------------

digitalWrite(Habilitador, HIGH); // Desabilita corriente a los Motores PAP

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

void Tecla3Normal() {

VelocidadNormal(); // Selecciona la velocidad del motor PAP

AvisoLCDVelocidad3();

int Valor3 = digitalRead(Boton3) ; // Leemos el Valor de la tecla

if (Valor3 < 1 ) { // Si el valor es menor a 1

delay(500); // Pone un tiempo de medio segundo antes de comenzar

for (int i = 0; i <= 255; i++) { // Cantidad de pusos

MotorVerticalDerecha(); // Accion de un motor PAP y giro expecifico

}

delay(500);

for (int i = 0; i <= 210; i++) {

MotorHorizontalIzquierda();

}

delay(500);

for (int i = 0; i <= 210; i++) {

MotorHorizontalDerecha();

}

delay(500);

for (int i = 0; i <= 255; i++) {

MotorVerticalIzquierda();

}

//----------------------------------------------------------------------------------------------------------------------------

void Tecla2Normal() {

VelocidadNormal();

AvisoLCDVelocidad3();

int Valor2 = digitalRead(Boton2) ;

if (Valor2 < 1 ) {

delay(500);

for (int i = 0; i <= 130; i++) {

MotorVerticalDerecha();

}

delay(500);

for (int i = 0; i <= 220; i++) {

MotorHorizontalDerecha();

}

delay(500);

for (int i = 0; i <= 220; i++) {

MotorHorizontalIzquierda();

}

delay(500);

for (int i = 0; i <= 130; i++) {

MotorVerticalIzquierda();

}

//----------------------------------------------------------------------------------------------------------------------------

void Tecla1Normal() {

VelocidadNormal();

AvisoLCDVelocidad3();

int Valor1 = digitalRead(Boton1) ;

if (Valor1 < 1 ) {

delay(500);

for (int i = 0; i <= 140; i++) {

MotorVerticalIzquierda();

}

delay(500);

for (int i = 0; i <= 210; i++) {

MotorHorizontalIzquierda();

}

delay(500);

for (int i = 0; i <= 210; i++) {

MotorHorizontalDerecha();

}

delay(500);

for (int i = 0; i <= 140; i++) {

MotorVerticalDerecha();

}

//----------------------------------------------------------------------------------------------------------------------------

void Tecla4Normal() {

VelocidadNormal();

AvisoLCDVelocidad3();

int Valor4 = digitalRead(Boton4) ;

if (Valor4 < 1 ) {

delay(500);

for (int i = 0; i <= 270; i++) {

MotorVerticalIzquierda();

}

delay(500);

for (int i = 0; i <= 220; i++) {

MotorHorizontalDerecha();

}

delay(500);

for (int i = 0; i <= 220; i++) {

MotorHorizontalIzquierda();

}

delay(500);

for (int i = 0; i <= 270; i++) {

MotorVerticalDerecha();

}

//----------------------------------------------------------------------------------------------------------------------------

// Movimientos de las 2 posiciones de cada Motor PAP

//----------------------------------------------------------------------------------------------------------------------------

void MotorHorizontalIzquierda() {

digitalWrite(Direccion1, HIGH);

for (uint32_t i = 0; i < PasosPorVueltas1 / Dividisor ; i++) {

digitalWrite(Step1, HIGH);

delay(PasosPeriodo1 / 0.65 );

digitalWrite(Step1, LOW);

delay(PasosPeriodo1 / 0.65 );

}

//----------------------------------------------------------------------------------------------------------------------------

void MotorHorizontalDerecha() {

digitalWrite(Direccion1, LOW);

for (uint32_t i = 0; i < PasosPorVueltas1 / Dividisor ; i++) {

digitalWrite(Step1, HIGH);

delay(PasosPeriodo1 / 0.65 );

digitalWrite(Step1, LOW);

delay(PasosPeriodo1 / 0.65 );

}

//----------------------------------------------------------------------------------------------------------------------------

void MotorVerticalIzquierda() {

digitalWrite(Direccion2, HIGH);

for (uint32_t i = 0; i < PasosPorVueltas2 / Dividisor ; i++) {

digitalWrite(Step2, HIGH);

delay(PasosPeriodo2 / 0.65 );

digitalWrite(Step2, LOW);

delay(PasosPeriodo2 / 0.65 );

}

//----------------------------------------------------------------------------------------------------------------------------

void MotorVerticalDerecha() {

digitalWrite(Direccion2, LOW);

for (uint32_t i = 0; i < PasosPorVueltas2 / Dividisor ; i++) {

digitalWrite(Step2, HIGH);

delay(PasosPeriodo2 / 0.65 );

digitalWrite(Step2, LOW);

delay(PasosPeriodo2 / 0.65 );

}

//----------------------------------------------------------------------------------------------------------------------------

// Configuracion de las Distintas Velocidades del Driver A4988

// segun la configuracion de las entradas M0, M1, M2

// Tabla de la Verdad

// M0 M1 M2 Pasos

// 0 0 0 Completo

// 1 0 0 1/2

// 0 1 0 1/4

// 1 1 0 1/8

// 1 1 1 1/16

// Binario = 000 = paso = Completo

// Binario = 100 = paso = 1/2

// Binario = 010 = paso = 1/4

// Binario = 110 = paso = 1/8

// Binario = 111 = paso = 1/16

// M0 = Pin N' 6 = Naranja

// M1 = Pin N' 7 = Marron

// M2 = Pin N' 8 = Lila

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadMuyRapido() {

digitalWrite(PasosM0, LOW);

digitalWrite(PasosM1, LOW);

digitalWrite(PasosM2, LOW);

digitalWrite(LedMuyRapido, HIGH); // Enciende el LED Rojo

digitalWrite(LedRapido, LOW); // Apaga el LED Naranja

digitalWrite(LedNormal, LOW); // Apaga el LED Amarillo

digitalWrite(LedLento, LOW); // Apaga el LED Amarillo

digitalWrite(LedMuyLento, LOW); // Apaga el LED Azul

}

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadRapido() {

digitalWrite(PasosM0, HIGH);

digitalWrite(PasosM1, LOW);

digitalWrite(PasosM2, LOW);

digitalWrite(LedMuyRapido, LOW); // Apaga el LED Rojo

digitalWrite(LedRapido, HIGH); // Enciende el LED Naranja

digitalWrite(LedNormal, LOW); // Apaga el LED Amarillo

digitalWrite(LedLento, LOW); // Apaga el LED Amarillo

digitalWrite(LedMuyLento, LOW); // Apaga el LED Azul

}

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadNormal() {

digitalWrite(PasosM0, LOW);

digitalWrite(PasosM1, HIGH);

digitalWrite(PasosM2, LOW);

digitalWrite(LedMuyRapido, LOW); // Apaga el LED Rojo

digitalWrite(LedRapido, LOW); // Apaga el LED Naranja

digitalWrite(LedNormal, HIGH); // Enciende el LED Amarillo

digitalWrite(LedLento, LOW); // Apaga el LED Amarillo

digitalWrite(LedMuyLento, LOW); // Apaga el LED Azul

}

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadLento() {

digitalWrite(PasosM0, HIGH);

digitalWrite(PasosM1, HIGH);

digitalWrite(PasosM2, LOW);

digitalWrite(LedMuyRapido, LOW); // Apaga el LED Rojo

digitalWrite(LedRapido, LOW); // Apaga el LED Naranja

digitalWrite(LedNormal, LOW); // Apaga el LED Amarillo

digitalWrite(LedLento, HIGH); // Enciende el LED Amarillo

digitalWrite(LedMuyLento, LOW); // Apaga el LED Azul

}

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadMuyLento() {

digitalWrite(PasosM0, HIGH);

digitalWrite(PasosM1, HIGH);

digitalWrite(PasosM2, HIGH);

digitalWrite(LedMuyRapido, LOW); // Apaga el LED Rojo

digitalWrite(LedRapido, LOW); // Apaga el LED Naranja

digitalWrite(LedNormal, LOW); // Apaga el LED Amarillo

digitalWrite(LedLento, LOW); // Apaga el LED Amarillo

digitalWrite(LedMuyLento, HIGH); // Enciende el LED Azul

}

//----------------------------------------------------------------------------------------------------------------------------

void Joystick() {

//----------------------------------------------------------------------------------------------------------------------------

PosicionX = analogRead(CoordenadaX); // Lee posicion de X

PosicionY = analogRead(CoordenadaY); // Lee posicion de Y

//----------------------------------------------------------------------------------------------------------------------------

if (PosicionX > 950 '' PosicionX < 60 '' PosicionY > 950 '' PosicionY < 60 )

//----------------------------------------------------------------------------------------------------------------------------

{

//----------------------------------------------------------------------------------------------------------------------------

AvisoSistemaManual();

digitalWrite(Habilitador, LOW); // Habilita corriente a los Motores PAP

AvisoConMovimiento();

//----------------------------------------------------------------------------------------------------------------------------

} else {

digitalWrite(Habilitador, HIGH); // Desabilita corriente a los Motores PAP

AvisoSinMovimiento();

//----------------------------------------------------------------------------------------------------------------------------

}

if (PosicionX > 950) {

MotorHorizontalIzquierda();

}

//----------------------------------------------------------------------------------------------------------------------------

if (PosicionX < 60) {

MotorHorizontalDerecha();

}

//----------------------------------------------------------------------------------------------------------------------------

if (PosicionY < 60) {

MotorVerticalIzquierda();

}

//----------------------------------------------------------------------------------------------------------------------------

if (PosicionY > 950) {

MotorVerticalDerecha();

}

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

void VelocidadConJoystick() {

//----------------------------------------------------------------------------------------------------------------------------

EstadoDelBotonR3 = digitalRead(BotonR3);

//----------------------------------------------------------------------------------------------------------------------------

if (EstadoDelBotonR3 != UltimoEstadoDelBotonR3) // Compara el estado del botón con su estado anterior

{

//----------------------------------------------------------------------------------------------------------------------------

if (EstadoDelBotonR3 == HIGH) // si el estado ha cambiado, incrementar el contador

{

//----------------------------------------------------------------------------------------------------------------------------

ContadorPulsosBotonR3++; // si el estado actual es ALTO entonces el botón incrementa

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

UltimoEstadoDelBotonR3 = EstadoDelBotonR3; // Guarda el estado actual como el último estado,para el próximo bucle

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 == 1) {

AvisoLCDVelocidad1();

VelocidadMuyRapido(); // Velocidad Muy Rapido

}

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 == 2) {

AvisoLCDVelocidad2();

VelocidadRapido(); // Velocidad Rapido

}

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 == 3) {

AvisoLCDVelocidad3();

VelocidadNormal(); // Velocidad Normal

}

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 == 4) {

AvisoLCDVelocidad4();

VelocidadLento(); // Velocidad Lento

}

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 == 5) {

AvisoLCDVelocidad5();

VelocidadMuyLento();

}

//----------------------------------------------------------------------------------------------------------------------------

if (ContadorPulsosBotonR3 > 5) {

AvisoLCDVelocidad1();

ContadorPulsosBotonR3 = 1;

}

//----------------------------------------------------------------------------------------------------------------------------

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoLCDVelocidad1() {

lcd.setCursor(0, 3); // lcd.setCursor(Columna, Fila);

lcd.print("Velocidad "); // Texto

lcd.setCursor(10, 3);

lcd.print("Muy Rapido");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoLCDVelocidad2() {

lcd.setCursor(0, 3);

lcd.print("Velocidad ");

lcd.setCursor(10, 3);

lcd.print("Rapido ");

}

void AvisoLCDVelocidad3() {

lcd.setCursor(0, 3);

lcd.print("Velocidad ");

lcd.setCursor(10, 3);

lcd.print("Normal ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoLCDVelocidad4() {

lcd.setCursor(0, 3);

lcd.print("Velocidad ");

lcd.setCursor(10, 3);

lcd.print("Lento ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoLCDVelocidad5() {

lcd.setCursor(0, 3);

lcd.print("Velocidad ");

lcd.setCursor(10, 3);

lcd.print("Muy Lento ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoSistemaManual() {

lcd.setCursor(0, 2);

lcd.print("Sistema Manual ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoSistemaAutomatico() {

lcd.setCursor(0, 2);

lcd.print("Sistema Automatico ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoConMovimiento() {

lcd.setCursor(0, 0);

lcd.print(" ATENCION! PELIGRO! ");

lcd.setCursor(0, 1);

lcd.print(" MOTORES EN MARCHA ");

}

//----------------------------------------------------------------------------------------------------------------------------

void AvisoSinMovimiento() {

lcd.setCursor(0, 0);

lcd.print(" ZONA ASEGURADA!!! ");

lcd.setCursor(0, 1);

lcd.print(" MOTORES DETENIDOS ");

}

//----------------------------------------------------------------------------------------------------------------------------

Codigo nuevo: es una variacion del anterior, mejorado.