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

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

}

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


¡Crea tu página web gratis! Esta página web fue creada con Webnode. Crea tu propia web gratis hoy mismo! Comenzar