BRAZO MECÁNICO
(MEJORADO) CÓDIGO
Código
//*************************************************************************
// Creaciones Stricker Rubén Darío
// E-Mail: stricker1972@yahoo.com.ar
//*************************************************************************
// https://proyectos-arduino.webnode.es/
//*************************************************************************
// PROYECTO:
//*************************************************************************
// Movimiento de 2 Motores Paso a Paso:
// Manual.
// Automático.
// Con Bluetooth.
// Con Joystick.
// Con Acelerómetro.
//*************************************************************************
// MODALIDADES:
//*************************************************************************
// Sistema Automatizado con detección de Teclas Accionadas.
// Sistema Automatizado por Bluetooth.
// Sistema Manual por Bluetooth.
// Sistema Manual Con Joystick.
// Sistema Manual Con Acelerómetro.
//*************************************************************************
// CONEXIONES:
//*************************************************************************
// Para que funcione correctamente el BlueTooch HC05 conectar VCC a 3V3 Volts del Arduino Mega 2560.
// Al momento de compilar se recomienda desconectar el BlueTooch HC05 desde VCC a 3V3 para evitar inconvenientes.
// El pin RXD del Bluetooth HC05 al pin TX0 del Arduino.
// El pin TXD del Bluetooth HC05 al pin RX0 del Arduino.
// El pin STATE del Bluetooth HC05 no lo usaremos.
// El pin EN del Bluetooth HC05 no lo usaremos.
// Aref del Arduino conectar con el pin SL (SLEEP) del Acelerómetro mma7361.
// Aref del Arduino conectar con el pin 3V3 del Acelerómetro mma7361.
// A2 del Arduino conectar con el pin X del Acelerómetro mma7361.
// A3 del Arduino conectar con el pin Y del Acelerómetro mma7361.
// A4 del Arduino connectar con el pin Z del Acelerómetro mma7361.
// El pin GS (G Select) del Acelerómetro mma7361 a 0V.
// El pin ST (Selftest) del Acelerómetro mma7361 a 0V.
// El pin 0g-detect del Acelerómetro mma7361 no lo usaremos.
//*************************************************************************
// Materiales:
//*************************************************************************
// Modulo BlueTooch HC-05 o similar.
// Modulo Acelerómetro mma7361 o similar.
// Arduino Mega 2560.
// 2 Drivers Pololu A4988
// 1 Joystick Analógico con Botón R3
// 1 CI 7805, para el Regulador de tensión.
// 2 Capacitores Cerámicos de 100 nf, para el Regulador de tensión.
// 2 Capacitores Electrolíticos de 1000 uf, para el Regulador de tensión.
// 1 Llave de 1 entrada y 2 salidas o Switch, 1 Led Rojo, 1 Led Verde y 1 Resistencia de 1 K ohm, para mostrar estado alimentación.
// 1 Llave de 1 entrada y 2 salidas o Switch, 1 Led Rojo, 1 Led Verde y 1 Resistencia de 1 K ohm y 1 de 10 K ohm, para cambiar estado entre Joystick o Acelerómetro.
// 5 Leds del mismo color y 1 Resistencia de 1 K ohm, para mostrar posicionamiento del Joystick.
// 1 Led Rojo, 1 Led Verde y 1 Resistencia de 1 K ohm, para mostrar motor en marcha o detenido.
// 1 Led Rojo, 1 Led Naranja, 1 Led Amarillo, 1 Led Verde, 1 Led Azul y 1 Resistencia de 1K ohm, para mostrar velocidad actual.
// Led Azul y 1 Resistencia de 1K ohm, para mostrar acción del BlueTooch.
// APP para usar con el celular. (Bluetooth Monitor), (BT Terminal), hay muchísimas APP gratis.
//*************************************************************************
//----------------------------------------------------------------------
int BotonJoystickAcelerometro = 36; // Definimos el pin 36 al Switch para Selección entre Joystick o Acelerómetro
//----------------------------------------------------------------------
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
//----------------------------------------------------------------------
int PosicionX = 0; // Posición X del joystick
int PosicionY = 0; // Posición Y del joystick
//----------------------------------------------------------------------
int PosicionAcelereometroX = 0; // Posición X del Acelerómetro
int PosicionAcelereometroY = 0; // Posición Y del Acelerómetro
int PosicionAcelereometroZ = 0; // Posición Z del Acelerómetro
//----------------------------------------------------------------------
int ContadorPulsosBotonR3 = 2; // Contador con valor 2 así arranca con velocidad Normal
//----------------------------------------------------------------------
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 Divisor = 128; // Divisor de los pasos por vueltas Ideal 128
//----------------------------------------------------------------------
int Entrada; // Estado del LED Azul de aviso de BlueTooch
//----------------------------------------------------------------------
int LedBlueTooch = 25; // Pin LED Azul de aviso de BlueTooch
//----------------------------------------------------------------------
int LedMotorActivo = 39; // Pin para LED Verde de aviso de motor activo
int LedMotorDesactivo = 41; // Pin para LED Rojo de aviso de motor desactivo
//----------------------------------------------------------------------
int LedMotorEjeCentral = 27; // Pin para LED Naranja de aviso eje en el centro
//----------------------------------------------------------------------
int LedMotorArribaAbajoGiroH = 29; // Pin para LED Naranja de aviso giro de motor
int LedMotorArribaAbajoGiroAH = 35; // Pin para LED Naranja de aviso giro de motor
int LedMotorDerechaIzquierdaH = 33; // Pin para LED Naranja de aviso giro de motor
int LedMotorDerechaIzquierdaAH = 31; // Pin para LED Naranja de aviso giro de motor
//----------------------------------------------------------------------
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 Analógico A0 Comando X del joystick
int CoordenadaY = A1; // Pin Analógico A1 Comando Y del joystick
//----------------------------------------------------------------------
int AcelereometroX = A2; // Pin Analógico A2 Comando X del Acelerómetro
int AcelereometroY = A3; // Pin Analógico A3 Comando Y del Acelerómetro
int AcelereometroZ = A4; // Pin Analógico A4 Comando Z del Acelerómetro
//----------------------------------------------------------------------
const int BotonR3 = 24; // Pin 24 conectado el pulsador R3 del joystick
//----------------------------------------------------------------------
const int LedMuyRapido = 26; // Pin para LED Rojo de aviso de velocidad
const int LedRapido = 28; // Pin para LED Naranja de aviso de velocidad
const int LedNormal = 30; // Pin para LED Amarillo de aviso de velocidad
const int LedLento = 32; // Pin para LED Verde de aviso de velocidad
const int LedMuyLento = 34; // Pin para LED Azul de aviso de velocidad
//----------------------------------------------------------------------
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 Dirección motor Paso a paso 1
const int Direccion2 = 12; // Pin Dirección motor Paso a paso 2
//----------------------------------------------------------------------
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°
const int PasosPorVueltas2 = 200; // Posibles ideales = 50 a 400 -> Ideal 200
//*************************************************************************
void setup() { // Setup (Configuración )
//*************************************************************************
Serial.begin(9600); // Llamamos al Monitor Serie
//----------------------------------------------------------------------
pinMode( Boton1 , INPUT) ; // Botón como entrada
pinMode( Boton2 , INPUT) ; // Botón como entrada
pinMode( Boton3 , INPUT) ; // Botón como entrada
pinMode( Boton4 , INPUT) ; // Botón como entrada
//----------------------------------------------------------------------
pinMode( BotonJoystickAcelerometro , INPUT) ; // Botón como entrada
//----------------------------------------------------------------------
pinMode(CoordenadaX, INPUT); // Declarar pines como entrada joystick X analógico
pinMode(CoordenadaY, INPUT); // Declarar pines como entrada joystick Y analógico
//----------------------------------------------------------------------
pinMode(AcelereometroX, INPUT); // Declarar pines como entrada Acelerómetro X analógico
pinMode(AcelereometroY, INPUT); // Declarar pines como entrada Acelerómetro Y analógico
pinMode(AcelereometroZ, INPUT); // Declarar pines como entrada Acelerómetro Z analógico
//----------------------------------------------------------------------
pinMode(BotonR3, INPUT_PULLUP); // Inicializar el pin del botón como entrada , Resistencia de PullUp interna.
//----------------------------------------------------------------------
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(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(LedBlueTooch, OUTPUT); // Inicializa el pin 25 del LED Azul como una salida
//----------------------------------------------------------------------
pinMode(Direccion1, OUTPUT); // Vamos a escribir sobre los pines Dirección que son salidas
pinMode(Direccion2, OUTPUT); // Vamos a escribir sobre los pines Dirección que son salidas
//----------------------------------------------------------------------
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
//----------------------------------------------------------------------
pinMode(LedMotorActivo, OUTPUT); // Inicializa el pin 39 del LED Verde como una salida
pinMode(LedMotorDesactivo, OUTPUT); // Inicializa el pin 41 del LED Rojo como una salida
//----------------------------------------------------------------------
pinMode(LedMotorArribaAbajoGiroH, OUTPUT); // Inicializa el pin 37 del LED Naranja como una salida
pinMode(LedMotorArribaAbajoGiroAH, OUTPUT); // Inicializa el pin 35 del LED Naranja como una salida
pinMode(LedMotorDerechaIzquierdaH, OUTPUT); // Inicializa el pin 33 del LED Naranja como una salida
pinMode(LedMotorDerechaIzquierdaAH, OUTPUT); // Inicializa el pin 31 del LED Naranja como una salida
//----------------------------------------------------------------------
pinMode(LedMotorEjeCentral, OUTPUT); // Inicializa el pin 31 del LED Amarillo como una salida
//----------------------------------------------------------------------
digitalWrite(LedMotorActivo, LOW); // Enciende el LED Verde
digitalWrite(LedMotorDesactivo, HIGH); // Apaga el LED Rojo
//----------------------------------------------------------------------
digitalWrite(LedMotorArribaAbajoGiroH, LOW); // Apaga el LED Naranja
digitalWrite(LedMotorArribaAbajoGiroAH, LOW); // Apaga el LED Naranja
digitalWrite(LedMotorDerechaIzquierdaH, LOW); // Apaga el LED Naranja
digitalWrite(LedMotorDerechaIzquierdaAH, LOW); // Apaga el LED Naranja
//----------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//----------------------------------------------------------------------
delay(1000); // Tiempo de espera antes de comenzar
//----------------------------------------------------------------------
Serial.println(" 0 = Teclas 1, 2, 3 y 4"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 1 = Tecla 1"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 2 = Tecla 2"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 3 = Tecla 3"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 4 = Tecla 4"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 5 = Motor Fijo > 9 Grados"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 6 = Motor Fijo < 9 Grados"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 7 = Motor Movil > 9 Grados"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 8 = Motor Movil < 9 Grados"); // Referencia de los comandos para usar el BlueTooch
Serial.println(" 9 = Movimiento Programado"); // Referencia de los comandos para usar el BlueTooch
}
//*************************************************************************
void loop() { // Bucle Principal
//*************************************************************************
SeleccionJoystickAcelerometro();
//--------------------------------------------------------------------
AccionBlueTooch(); // Acción BlueTooch
//--------------------------------------------------------------------
VelocidadConJoystick(); // Acción Velocidad
//--------------------------------------------------------------------
SistemaAutomatizadoTeclas(); // Acción Teclas
//--------------------------------------------------------------------
}
//*************************************************************************
void AccionBlueTooch() { // Acción del BlueTooch según sea el caso
//*************************************************************************
if (Serial.available() > 0) { // Verificamos que el monitor serial tenga algún carácter
//--------------------------------------------------------------------
Entrada = Serial.read(); // Leemos la Variable del monitor serial y lo guardamos en Entrada
//--------------------------------------------------------------------
switch (Entrada) { // Variable cuyo valor a comparar según los casos
//--------------------------------------------------------------------
case '0': // Si el caso es X abre el caso
CasoNumero1(); // Acción Tecla 1
CasoNumero2(); // Acción Tecla 2
CasoNumero3(); // Acción Tecla 3
CasoNumero4(); // Acción Tecla 4
break; // Fin del caso
//--------------------------------------------------------------------
case '1': // Si el caso es X abre el caso
CasoNumero1(); // Acción Tecla 1
break; // Fin del caso
//--------------------------------------------------------------------
case '2': // Si el caso es X abre el caso
CasoNumero2(); // Acción Tecla 2
break; // Fin del caso
//--------------------------------------------------------------------
case '3': // Si el caso es X abre el caso
CasoNumero3(); // Acción Tecla 3
break; // Fin del caso
//--------------------------------------------------------------------
case '4': // Si el caso es X abre el caso
CasoNumero4(); // Acción Tecla 4
break; // Fin del caso
//--------------------------------------------------------------------
case '5': // Si el caso es X abre el caso
CasoNumero5(); // Acción Motor Fijo a la Derecha 9 grados
break; // Fin del caso
//--------------------------------------------------------------------
case '6': // Si el caso es X abre el caso
CasoNumero6(); // Acción Motor Fijo a la Izquierda 9 grados
break; // Fin del caso
//--------------------------------------------------------------------
case '7': // Si el caso es X abre el caso
CasoNumero7(); // Acción Motor Móvil a la Derecha 9 grados
break; // Fin del caso
//--------------------------------------------------------------------
case '8': // Si el caso es X abre el caso
CasoNumero8(); // Acción Motor Móvil a la Izquierda 9 grados
break; // Fin del caso
//--------------------------------------------------------------------
case '9': // Si el caso es X abre el caso
CasoNumero9(); // Acción Movimiento Programado
break; // Fin del caso
//--------------------------------------------------------------------
// default: // Predeterminado, por defecto, es opcional.
// Serial.print(" "); // Aviso Acción al monitor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero1() { // Acción del BlueTooch caso Tecla X
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 212; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 212; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 1"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero2() { // Acción del BlueTooch caso Tecla X
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 133; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 133; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 2"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero3() { // Acción del BlueTooch caso Tecla X
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 136; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 136; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 3"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero4() { // Acción del BlueTooch caso Tecla X
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 4"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero5() { // Acción del BlueTooch caso X 18 grados
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
for (int i = 0; i <= 40; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Motor Fijo > 9 Grados"); // Aviso giro al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero6() { // Acción del BlueTooch caso X 18 grados
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
for (int i = 0; i <= 40; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Motor Fijo < 9 Grados"); // Aviso giro al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero7() { // Acción del BlueTooch caso X 18 grados
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
for (int i = 0; i <= 40; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Motor Movil > 9 Grados"); // Aviso giro al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero8() { // Acción del BlueTooch caso X 18 grados
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
for (int i = 0; i <= 40; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Motor Movil < 9 Grados"); // Aviso giro al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void CasoNumero9() { // Acción del BlueTooch caso X Movimiento Programado
//*************************************************************************
digitalWrite(LedBlueTooch, HIGH); // Enciende el LED Azul del BlueTooch
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 200; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 200; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 400; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 400; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 400; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 200; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 200; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
Serial.println("Movimiento Programado"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedBlueTooch, LOW); // Apaga el LED Azul del BlueTooch
//--------------------------------------------------------------------
}
//*************************************************************************
void SistemaAutomatizadoTeclas() { // Acción de las 4 Teclas
//*************************************************************************
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 ) // Condición para habilitar los motores, velocidad y acciones
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
digitalWrite(Habilitador, LOW); // Habilita corriente a los Motores PAP
//--------------------------------------------------------------------
Tecla1(); // Accion
Tecla2(); // Accion
Tecla3(); // Accion
Tecla4(); // Accion
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
else // En caso contrario
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
digitalWrite(LedMotorArribaAbajoGiroH, LOW); // Apaga el LED Rojo Naranja
digitalWrite(LedMotorArribaAbajoGiroAH, LOW); // Apaga el LED Rojo Naranja
digitalWrite(LedMotorDerechaIzquierdaH, LOW); // Apaga el LED Rojo Naranja
digitalWrite(LedMotorDerechaIzquierdaAH, LOW);// Apaga el LED Rojo Naranja
//--------------------------------------------------------------------
digitalWrite(Habilitador, HIGH); // Deshabilita corriente a los Motores PAP
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void Tecla1() { // Acción de la Tecla X
//*************************************************************************
EstadoDelBotonR3 = digitalRead(BotonR3); // Guardamos en EstadoDelBotonR3 el valor del Botón R3
//--------------------------------------------------------------------
if (EstadoDelBotonR3 != UltimoEstadoDelBotonR3) // Comparamos si el estado actual es distinto al anterior
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
if (EstadoDelBotonR3 == HIGH) { // Si Estado del botón R3 es 1
//--------------------------------------------------------------------
ContadorPulsosBotonR3++; // Suma + 1
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
} UltimoEstadoDelBotonR3 = EstadoDelBotonR3; // Cambia el UltimoEstadoDelBotonR3 a EstadoDelBotonR3
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 1) { // Si contador de pulsos del botón R3 = 1
//--------------------------------------------------------------------
VelocidadMuyRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor1 = digitalRead(Boton1) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor1 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 2) { // Si contador de pulsos del botón R3 = 2
//--------------------------------------------------------------------
VelocidadRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor1 = digitalRead(Boton1) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor1 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 31; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 106; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 106; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 31; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 1"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 3) {
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor1 = digitalRead(Boton1) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor1 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 212; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 212; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 1"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 4) {
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor1 = digitalRead(Boton1) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor1 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 120; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 425; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 425; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 120; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 1"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 5) {
//--------------------------------------------------------------------
VelocidadMuyLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor1 = digitalRead(Boton1) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor1 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 250; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 860; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 860; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 250; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 1"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void Tecla2() { // Acción de la Tecla X
//*************************************************************************
EstadoDelBotonR3 = digitalRead(BotonR3); // Guardamos en EstadoDelBotonR3 el valor del Botón R3
//--------------------------------------------------------------------
if (EstadoDelBotonR3 != UltimoEstadoDelBotonR3) // Comparamos si el estado actual es distinto al anterior
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
if (EstadoDelBotonR3 == HIGH) { // Si Estado del botón R3 es 1
//--------------------------------------------------------------------
ContadorPulsosBotonR3++; // Suma + 1
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
} UltimoEstadoDelBotonR3 = EstadoDelBotonR3; // Cambia el UltimoEstadoDelBotonR3 a EstadoDelBotonR3
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 1) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor2 = digitalRead(Boton2) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor2 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 2) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor2 = digitalRead(Boton2) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor2 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 67; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 107; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 107; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 67; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 2"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 3) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor2 = digitalRead(Boton2) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor2 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 133; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 133; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 2"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 4) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor2 = digitalRead(Boton2) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor2 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 263; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 428; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 428; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 263; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 2"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 5) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor2 = digitalRead(Boton2) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor2 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 550; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 860; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 860; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 550; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 2"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void Tecla3() { // Acción de la Tecla X
//*************************************************************************
EstadoDelBotonR3 = digitalRead(BotonR3); // Guardamos en EstadoDelBotonR3 el valor del Botón R3
//--------------------------------------------------------------------
if (EstadoDelBotonR3 != UltimoEstadoDelBotonR3) // Comparamos si el estado actual es distinto al anterior
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
if (EstadoDelBotonR3 == HIGH) { // Si Estado del botón R3 es 1
//--------------------------------------------------------------------
ContadorPulsosBotonR3++; // Suma + 1
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
} UltimoEstadoDelBotonR3 = EstadoDelBotonR3; // Cambia el UltimoEstadoDelBotonR3 a EstadoDelBotonR3
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 1) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor3 = digitalRead(Boton3) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor3 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 2) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor3 = digitalRead(Boton3) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor3 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 68; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 107; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 107; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 68; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 3"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 3) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor3 = digitalRead(Boton3) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor3 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 136; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 136; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 3"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 4) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor3 = digitalRead(Boton3) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor3 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 270; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 420; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 420; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 270; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 3"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 5) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor3 = digitalRead(Boton3) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor3 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 550; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 850; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 850; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 550; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 3"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void Tecla4() { // Acción de la Tecla X
//*************************************************************************
EstadoDelBotonR3 = digitalRead(BotonR3); // Guardamos en EstadoDelBotonR3 el valor del Botón R3
//--------------------------------------------------------------------
if (EstadoDelBotonR3 != UltimoEstadoDelBotonR3) // Comparamos si el estado actual es distinto al anterior
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
if (EstadoDelBotonR3 == HIGH) { // Si Estado del botón R3 es 1
//--------------------------------------------------------------------
ContadorPulsosBotonR3++; // Suma + 1
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
} UltimoEstadoDelBotonR3 = EstadoDelBotonR3; // Cambia el UltimoEstadoDelBotonR3 a EstadoDelBotonR3
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 1) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor4 = digitalRead(Boton4) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor4 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 2) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadRapido(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor4 = digitalRead(Boton4) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor4 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 30; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 106; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 106; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 30; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 4"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 3) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadNormal(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor4 = digitalRead(Boton4) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor4 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 214; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 62; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 4"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 4) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor4 = digitalRead(Boton4) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor4 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 114; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 425; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 425; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 114; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 4"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 5) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Selecciona la velocidad X
//--------------------------------------------------------------------
int Valor4 = digitalRead(Boton4) ; // Guardamos en valor X el valor de la Tecla
//--------------------------------------------------------------------
if (Valor4 == LOW ) { // Si el valor de la Tecla es 0
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso estado motor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
delay(10); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 230; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 870; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 870; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(100); // Tiempo de espera
//--------------------------------------------------------------------
for (int i = 0; i <= 230; i++) { // Cantidad de pulsos para el giro
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
} delay(10); // Tiempo de espera
//--------------------------------------------------------------------
AvisoMotorDesactivo(); // Aviso estado motor
//--------------------------------------------------------------------
Serial.println("Accion en Tecla 4"); // Aviso acción al monitor
//--------------------------------------------------------------------
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void MotorArribaIzquierda() { // Acción Movimiento Posiciones Motor PAP
//*************************************************************************
digitalWrite(LedMotorArribaAbajoGiroH, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
digitalWrite(Direccion1, HIGH); // Dirección valor 1, sentido del giro horario.
//--------------------------------------------------------------------
for (uint32_t i = 0; i < PasosPorVueltas1 / Divisor ; i++) { // Para que el motor pueda hacer un paso
//--------------------------------------------------------------------
digitalWrite(Step1, HIGH); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
digitalWrite(Step1, LOW); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
digitalWrite(LedMotorArribaAbajoGiroH, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
}
//*************************************************************************
void MotorArribaDerecha() { // Acción Movimiento Posiciones Motor PAP
//*************************************************************************
digitalWrite(LedMotorArribaAbajoGiroAH, HIGH); // Enciende el Naranja
//--------------------------------------------------------------------
digitalWrite(Direccion1, LOW); // Dirección valor 0, sentido del giro AntiHorario.
//--------------------------------------------------------------------
for (uint32_t i = 0; i < PasosPorVueltas1 / Divisor ; i++) { // Para que el motor pueda hacer un paso
//--------------------------------------------------------------------
digitalWrite(Step1, HIGH); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
digitalWrite(Step1, LOW); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
digitalWrite(LedMotorArribaAbajoGiroAH, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
}
//*************************************************************************
void MotorAbajoDerecha() { // Acción Movimiento Posiciones Motor PAP
//*************************************************************************
digitalWrite(LedMotorDerechaIzquierdaH, HIGH); // Enciende el LED Naranja
//--------------------------------------------------------------------
digitalWrite(Direccion2, HIGH); // Dirección valor 1, sentido del giro horario.
//--------------------------------------------------------------------
for (uint32_t i = 0; i < PasosPorVueltas2 / Divisor ; i++) { // Para que el motor pueda hacer un paso
//--------------------------------------------------------------------
digitalWrite(Step2, HIGH); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
digitalWrite(Step2, LOW); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
digitalWrite(LedMotorDerechaIzquierdaH, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
}
//*************************************************************************
void MotorAbajoIzquierda() { // Acción Movimiento Posiciones Motor PAP
//*************************************************************************
digitalWrite(LedMotorDerechaIzquierdaAH, HIGH); // Enciende el Naranja
//--------------------------------------------------------------------
digitalWrite(Direccion2, LOW); // Dirección valor 0, sentido del giro AntiHorario.
//--------------------------------------------------------------------
for (uint32_t i = 0; i < PasosPorVueltas2 / Divisor ; i++) { // Para que el motor pueda hacer un paso
//--------------------------------------------------------------------
digitalWrite(Step2, HIGH); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
digitalWrite(Step2, LOW); // Secuencia de los pasos.
//--------------------------------------------------------------------
delay(3); // 3 milésimas de retardo
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
digitalWrite(LedMotorDerechaIzquierdaAH, LOW); // Apaga el LED Naranja
//--------------------------------------------------------------------
}
//*************************************************************************
void VelocidadMuyRapido() { // Acción Velocidad Motor (000)
//*************************************************************************
digitalWrite(PasosM0, LOW); // 0
//--------------------------------------------------------------------
digitalWrite(PasosM1, LOW); // 0
//--------------------------------------------------------------------
digitalWrite(PasosM2, LOW); // 0
//--------------------------------------------------------------------
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() { // Acción Velocidad Motor (100)
//*************************************************************************
digitalWrite(PasosM0, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM1, LOW); // 0
//--------------------------------------------------------------------
digitalWrite(PasosM2, LOW); // 0
//--------------------------------------------------------------------
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() { // Acción Velocidad Motor (010)
//*************************************************************************
digitalWrite(PasosM0, LOW); // 0
//--------------------------------------------------------------------
digitalWrite(PasosM1, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM2, LOW); // 0
//--------------------------------------------------------------------
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() { // Acción Velocidad Motor (110)
//*************************************************************************
digitalWrite(PasosM0, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM1, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM2, LOW); // 0
//--------------------------------------------------------------------
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() { // Acción Velocidad Motor (111)
//*************************************************************************
digitalWrite(PasosM0, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM1, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM2, HIGH); // 1
//--------------------------------------------------------------------
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 SinVelocidad() { // Acción Velocidad Motor (111)
//*************************************************************************
digitalWrite(PasosM0, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM1, HIGH); // 1
//--------------------------------------------------------------------
digitalWrite(PasosM2, HIGH); // 1
//--------------------------------------------------------------------
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, LOW); // Apaga el LED Azul
}
//*************************************************************************
void Joystick() { // Acción Joystick
//*************************************************************************
PosicionX = analogRead(CoordenadaX); // Lee posición de X
PosicionY = analogRead(CoordenadaY); // Lee posición de Y
//--------------------------------------------------------------------
if (PosicionX > 950 '' PosicionX < 60 '' PosicionY > 950 '' PosicionY < 60 ) { // SI alguna posición X/Y supera los limites
//--------------------------------------------------------------------
digitalWrite(Habilitador, LOW); // Habilita corriente a los Motores PAP
digitalWrite(LedMotorEjeCentral, LOW); // Apaga el LED Rojo Naranja
//--------------------------------------------------------------------
AvisoMotorActivo(); // Aviso visual
//--------------------------------------------------------------------
} else { // En caso contrario
AvisoMotorDesactivo(); // Aviso visual
digitalWrite(LedMotorEjeCentral, HIGH); // Enciende el LED Rojo Naranja
digitalWrite(Habilitador, HIGH); // Deshabilita corriente a los Motores PAP
//--------------------------------------------------------------------
}
if (PosicionX > 900) { // SI la posición X supera el limite
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionX < 100) { // SI la posición X supera el limite
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionY < 100) { // SI la posición Y supera el limite
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionY > 900) { // SI la posición Y supera el limite
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void VelocidadConJoystick() { // Acción Velocidad Joystick
//*************************************************************************
EstadoDelBotonR3 = digitalRead(BotonR3); // Guarda el estado en EstadoDelBotonR3
//--------------------------------------------------------------------
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) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyRapido(); // Velocidad Muy Rápido
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 2) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadRapido(); // Velocidad Rápido
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 3) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadNormal(); // Velocidad Normal
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 4) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadLento(); // Velocidad Lento
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 == 5) { // Si contador de pulsos del botón R3 = X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Velocidad Muy Lento
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (ContadorPulsosBotonR3 > 5) { // Si el contador supera el 5
//--------------------------------------------------------------------
ContadorPulsosBotonR3 = 1; // Contador de pulsos vuelve a comenzar en 1
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void Acelerometro()
//*************************************************************************
{
//--------------------------------------------------------------------
int PosicionModificadaX = analogRead(A2); // Lee posición del Acelerómetro X
//--------------------------------------------------------------------
PosicionModificadaX = map(PosicionModificadaX, 320, 800, -10, 10); // Mapeamos la posición X con valores entre -10 y 10
//--------------------------------------------------------------------
int PosicionModificadaY = analogRead(A3); // Lee posición del Acelerómetro Y
//--------------------------------------------------------------------
PosicionModificadaY = map(PosicionModificadaY, 320, 800, -10, 10); // Mapeamos la posición Y con valores entre -10 y 10
//--------------------------------------------------------------------
if (PosicionModificadaX > 2 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Velocidad Muy Lento
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX < -2 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Velocidad Muy Lento
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY > 2 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Velocidad Muy Lento
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY < -2 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadMuyLento(); // Velocidad Muy Lento
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX > 4 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadLento(); // Velocidad Lento
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX < -4 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadLento(); // Velocidad Lento
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY > 4 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadLento(); // Velocidad Lento
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY < -4 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadLento(); // Velocidad Lento
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX > 6 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadNormal(); // Velocidad Normal
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX < -6 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadNormal(); // Velocidad Normal
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY > 6 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadNormal(); // Velocidad Normal
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY < -6 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadNormal(); // Velocidad Normal
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX > 8 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadRapido(); // Velocidad Rápido
//--------------------------------------------------------------------
MotorArribaDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaX < -8 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadRapido(); // Velocidad Rápido
//--------------------------------------------------------------------
MotorArribaIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY > 8 ) { // Si Posición Modificada > X
//--------------------------------------------------------------------
VelocidadRapido(); // Velocidad Rápido
//--------------------------------------------------------------------
MotorAbajoIzquierda(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
if (PosicionModificadaY < -8 ) { // Si Posición Modificada < X
//--------------------------------------------------------------------
VelocidadRapido(); // Velocidad Rapido
//--------------------------------------------------------------------
MotorAbajoDerecha(); // Giro del motor
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//*************************************************************************
void SeleccionJoystickAcelerometro() { // Acción Selección Joystick o Acelerómetro
//*************************************************************************
if (digitalRead(BotonJoystickAcelerometro) == LOW)// Si el estado es HIGH
//--------------------------------------------------------------------
{
//--------------------------------------------------------------------
Acelerometro(); // Acción del Joystick
//--------------------------------------------------------------------
} else { // En caso contrario
//--------------------------------------------------------------------
Joystick(); // Acción del acelerómetro
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
}
//--------------------------------------------------------------------
void AvisoMotorDesactivo() { // Acción Aviso Motor
//*************************************************************************
digitalWrite(LedMotorActivo, LOW); // Apaga el LED Verde
//--------------------------------------------------------------------
digitalWrite(LedMotorDesactivo, HIGH); // Enciende el LED Rojo
//--------------------------------------------------------------------
}
//*************************************************************************
void AvisoMotorActivo() { // Acción Aviso Motor
//*************************************************************************
digitalWrite(LedMotorDesactivo, LOW ); // Apaga el LED Rojo
//--------------------------------------------------------------------
digitalWrite(LedMotorActivo, HIGH); // Enciende el LED Verde
//--------------------------------------------------------------------
}
//*************************************************************************