Programación de Funciones de Control de Movimiento en Arduino

Curso Fundamentos de Desarrollo de Hardware con Arduino

Contenido del curso

Bienvenida al curso

Introducción al hardware libre

Sensores, Actuadores y Procesadores

Introducción a la electrónica

Manos a la obra

Automatización de procesos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:09

Programación de Funciones de Control de Movimiento en Arduino

Curso Fundamentos de Desarrollo de Hardware con Arduino

Clase 37 de 38

Clase 37 / 38

Recursos

Controla un robot móvil con confianza: aprende a crear funciones void para mover motores, configurar pines HIGH/LOW, leer un sensor con digitalRead y aplicar velocidad con analogWrite. Verás cómo estructurar la lógica mínima (MVP) para avanzar o girar al detectar obstáculos, con prácticas de depuración sobre la marcha.

¿Qué aprenderás sobre funciones y movimiento en Arduino?

Crearás funciones globales para mover el robot: avanzar (derecho), girar a la izquierda (giroizquierda) y girar a la derecha (giroderecha). Estas funciones no van en setup ni en loop: se declaran de forma global, debajo de las variables. Se usan como procedimientos que cambian estados de pines, por eso se definen con tipo void y sin argumentos.

Declarar funciones fuera de setup y loop evita errores de alcance.
Usar HIGH/LOW define el sentido de giro por motor.
El giro más rápido se logra invirtiendo el sentido de una llanta mientras la otra sigue hacia adelante.

¿Cómo declarar funciones void fuera de setup y loop?

Escribe: tipo de retorno, nombre y paréntesis vacíos.
Dentro de llaves, configura pines con digitalWrite.

Ejemplo:

void derecho() {
  digitalWrite(MOTOR1A, HIGH);
  digitalWrite(MOTOR1B, LOW);
  digitalWrite(MOTOR2A, LOW);
  digitalWrite(MOTOR2B, HIGH);
}

¿Cómo se controla cada motor con HIGH/LOW?

Motor derecho: un pin en HIGH y el opuesto en LOW para avanzar.
Motor izquierdo: igual, pero invirtiendo para reversa.
Al girar a la izquierda, la llanta derecha sigue adelante y la izquierda va en reversa.

void giroizquierda() { // invierte el motor izquierdo
  digitalWrite(MOTOR1A, LOW);
  digitalWrite(MOTOR1B, HIGH);
  digitalWrite(MOTOR2A, LOW);
  digitalWrite(MOTOR2B, HIGH);
}

void giroderecha() { // invierte el motor derecho
  digitalWrite(MOTOR1A, HIGH);
  digitalWrite(MOTOR1B, LOW);
  digitalWrite(MOTOR2A, HIGH);
  digitalWrite(MOTOR2B, LOW);
}

¿Cómo se gira a la izquierda o derecha invirtiendo un motor?

Izquierda: invierte el motor izquierdo y mantiene el derecho hacia adelante.
Derecha: invierte el motor derecho y mantiene el izquierdo hacia adelante.
Así, el prototipo gira sobre su eje con rapidez.

¿Cómo se implementa la lógica MVP con el sensor y PWM?

Se plantea una lógica simple: si el sensor no detecta, el robot avanza; si detecta, gira a la izquierda. Para ello, se lee el estado con digitalRead en una variable entera y se decide con if/else. La velocidad se fija con analogWrite a un valor medio, por ejemplo 127, en ambos pines PWM.

Variable para el estado: int sensor_uno_state = 0;.
Lectura: sensor_uno_state = digitalRead(SENSOR1);.
Decisión: si es HIGH, avanzar; si no, girar.
Velocidad uniforme: analogWrite(PWM1, 127); analogWrite(PWM2, 127);.

Ejemplo:

int sensor_uno_state = 0;

void loop() {
  sensor_uno_state = digitalRead(SENSOR1);

  if (sensor_uno_state == HIGH) { // no detecta obstáculo
    derecho();
  } else { // detecta obstáculo
    giroizquierda();
  }

  analogWrite(PWM1, 127);
  analogWrite(PWM2, 127);
}

¿Qué significa HIGH y LOW en Arduino?

Representan lógicos 1 y 0, respectivamente.
El sensor entrega HIGH cuando no detecta y LOW cuando detecta.
Úsalos en comparaciones en lugar de 1 y 0.

¿Por qué usar else en lugar de else if?

El sensor tiene dos estados: basta con if y else.
Reduce complejidad y errores.

¿Cómo asignar velocidad media con analogWrite?

analogWrite(pinPWM, 127) define un ciclo de trabajo medio.
Aplica el mismo valor a los dos PWM para que ambas llantas coincidan en velocidad.

¿Qué buenas prácticas y depuración del sketch conviene aplicar?

Conviene compilar y verificar frecuentemente mientras avanzas. Se detectaron errores de nombres como giro deeecha o giro izquiera, que se corrigieron a giroderecha y giroizquierda. También se puede cargar el sketch aunque no haya conexiones, para validar que compila sin fallos antes de pasar al cableado en el protoboard.

Declara funciones de control como globales.
Usa nombres consistentes en funciones y variables.
Verifica el sketch con frecuencia.
Mantén una versión MVP: avanza si no detecta, gira si detecta.
Ajusta PWM según necesites estabilidad o respuesta.

¿Tienes dudas sobre la lógica o quieres proponer otra estrategia de giro? Cuéntalo en los comentarios y comparte tu enfoque.

Juan David Arango Morales

Hace 6 años

Hola a todos y Profe

Comparto codigo de mi robot evasor de obstaculos

#include <SoftwareSerial.h>

SoftwareSerial BT(0, 1); // RX | TX

long Distancia, Duracion; int Direccion = 2; int DistanciaMinima = 10; int i=1; int Velocidad=150;

int MotorD1I = 6; int MotorD2I = 9; int MotorD1D = 10; int MotorD2D = 11;

int MotorT1I = 5; int MotorT2I = 4; int MotorT1D = 3; int MotorT2D = 2;

void setup() { // put your setup code here, to run once: #define TriggerCentro 8 //Salida #define TriggerDerecho 13 //Salida #define TriggerIzquierdo A3 //Salida

#define EcoCentro 7 //Entrada #define EcoDerecho 12 //Entrada #define EcoIzquierdo A2 //Entrada

pinMode(TriggerCentro, OUTPUT); pinMode (EcoCentro, INPUT); pinMode(TriggerDerecho, OUTPUT); pinMode (EcoDerecho, INPUT); pinMode(TriggerIzquierdo, OUTPUT); pinMode (EcoIzquierdo, INPUT); Serial.begin(9600);

pinMode(MotorD1D,OUTPUT); pinMode(MotorD2D,OUTPUT); pinMode(MotorD1I,OUTPUT); pinMode(MotorD2I,OUTPUT); pinMode(MotorT1I,OUTPUT); pinMode(MotorT2I,OUTPUT); pinMode(MotorT1D,OUTPUT); pinMode(MotorT2D,OUTPUT); pinMode(9,HIGH);

  Serial.begin(9600); 
Serial.println("Listo");    
BT.begin(38400);

} void loop() { if (BT.available()) Serial.write(BT.read());

if (Serial.available()) BT.write(Serial.read()); // put your main code here, to run repeatedly: Serial.println(MedirDistacia(Direccion)); for(i=1; i<4; i++) { if (MedirDistacia(i) < DistanciaMinima) { Girar(i); delay(50); Atras(); } else { Adelante(Velocidad); } } }

float MedirDistacia (int Direccion) { switch (Direccion) { case 1: //Derecho delay(10); //limpiar canal digitalWrite(TriggerDerecho,HIGH); delayMicroseconds(10); digitalWrite(TriggerDerecho,LOW); Duracion = pulseIn(EcoDerecho,HIGH); break; case 2: //Centro delay(10); //limpiar canal digitalWrite(TriggerCentro,HIGH); delayMicroseconds(10); digitalWrite(TriggerCentro,LOW); Duracion = pulseIn(EcoCentro,HIGH); break; case 3: //Izquierdo delay(10); //limpiar canal digitalWrite(TriggerIzquierdo,HIGH); delayMicroseconds(10); digitalWrite(TriggerIzquierdo,LOW); Duracion = pulseIn(EcoIzquierdo,HIGH); break; } Distancia = (Duracion/2)/29; return Distancia; }

void Parada(){ analogWrite(MotorD1D,0); digitalWrite(MotorD2D,LOW); analogWrite(MotorD1I,0); digitalWrite(MotorD2I,LOW); analogWrite(MotorT1I,0); analogWrite(MotorT2I,0); analogWrite(MotorT1D,0); analogWrite(MotorT2D,0); } void Adelante(int Velocidad){ int Vel = Velocidad;

analogWrite(MotorD1D,Vel);
digitalWrite(MotorD2D,LOW);
analogWrite(MotorD1I,Vel - 30);
digitalWrite(MotorD2I,LOW);
analogWrite(MotorT1I,Vel - 30);
analogWrite(MotorT2I,0);
analogWrite(MotorT1D,Vel);
analogWrite(MotorT2D,0);

} void Atras(){
digitalWrite(MotorD1D,LOW); digitalWrite(MotorD2D,HIGH); digitalWrite(MotorD1I,LOW); digitalWrite(MotorD2I,HIGH); digitalWrite(MotorT1I,LOW); digitalWrite(MotorT2I,HIGH); digitalWrite(MotorT1D,LOW); digitalWrite(MotorT2D,HIGH); } void Izquierda(int Velocidad){ int Vel = Velocidad;

analogWrite(MotorD1D,Vel);
digitalWrite(MotorD2D,LOW);
analogWrite(MotorD1I,0);
digitalWrite(MotorD2I,LOW);
analogWrite(MotorT1I,0);
analogWrite(MotorT2I,0);
analogWrite(MotorT1D,Vel);
analogWrite(MotorT2D,0);

} void Derecha(int Velocidad){ int Vel = Velocidad;

analogWrite(MotorD1D,0);
digitalWrite(MotorD2D,LOW);
analogWrite(MotorD1I,Vel);
digitalWrite(MotorD2I,LOW);
analogWrite(MotorT1I,Vel);
analogWrite(MotorT2I,0);
analogWrite(MotorT1D,0);
analogWrite(MotorT2D,0);

}

void Girar(int i) { if (i == 1) {

Izquierda(Velocidad);

} if (i == 2) {

Derecha(Velocidad);

} if (i == 3) {

Derecha(Velocidad);

} }

Juan Pablo Ramos Catalogne

Hace 3 años

Hola compañéro. Haz hecho una disertación de conocimiento que está buena para entender. Muchas gracias.

Comentarios (14)14 comentarios

José Ricardo Romo Gutiérrez

Hace 8 años

Ricardo Celis

Profesor

Jhon Harvy Acosta

David Tello Sosa

Hace 7 años

Emanuel Moreno Manriquez

Angel Uriel Morales Cardoso

Vicente Perez de Sevilla

Hace 5 años

Jess Key

Hace 2 meses

Jaime de Jesús Meza Estrada

Hace 7 meses

José Manuel Robles Espinosa

Jaime Sánchez

Angel Solis

Josue Ramos

JUAN JOSE LIZCANO TOVAR

Ricardo Portillo

Jonathan Macalupu Reyes

Hace 9 años

Benjamin Ignacio Barrera Vásquez

Jorge Gens Abujas

Bienvenida al curso

Servidor Web Asíncrono con ESP8266 y Arduino

Fundamentos de Desarrollo de Hardware con Arduino

Introducción al hardware libre

Arduino: Desarrolla Prototipos Interactivos con Microcontroladores

Desarrollo de Prototipos de Hardware: Diseño y Fabricación

Diseño Mecánico de Hardware con SolidWorks y Herramientas Paramétricas

Desarrollo de Interfaces y Prototipos con QT en Sistemas Embebidos

Limitaciones de Arduino en productos finales

Selección de Arduino para Envío de Datos a Servidor

Fundamentos de Desarrollo de Hardware con Arduino

Proyectos con Arduino: Componentes y Materiales Necesarios

Sensores, Actuadores y Procesadores

Sensores y Actuadores: Fundamentos para Automatización con Arduino

Cómo los robots ven a través de sensores

Tipos de Sensores y sus Aplicaciones en Robótica y Electrónica

Clasificación y Aplicaciones de Actuadores en la Industria

Introducción a la electrónica

Conceptos básicos de electricidad y electrónica para Arduino

Resistencias y capacitores en electrónica básica

Componentes Electrónicos Básicos: LEDs, Transistores y Circuitos Integrados

Uso de la Ley de Ohm para Conectar LEDs sin Quemarlos

Manos a la obra

Conociendo los Puertos y Alimentación del Arduino Uno

Funcionamiento de la Protoboard para Prototipado Electrónico

Programación Básica en Arduino: Primeros Pasos con LED y Código

Declarar variables para pines de Arduino

Creación y Uso de Librerías en Arduino

Uso del Potenciómetro para Control de LED con Arduino

Comunicación Serial en Arduino: Uso del Monitor Serial

Cómo PWM simula voltaje analógico

Cómo Arduino simplifica el PWM

Uso de Botones con Resistencia Pull-Up en Arduino

Monitor temperatura con Arduino y LM35

Cálculo del Multiplicador para Convertir Lecturas de Sensor a Celsius

LCD 16x2 con Arduino sin conexión PC

Programación de Semáforos con Arduino y Sensores

Automatización de procesos

Motores con Arduino y puente H L293D

Cómo funciona un servomotor con Arduino

Potenciómetro controla servomotor en Arduino

Proyecto: Construcción y Programación de un Robot de Evasión de Obstáculos

Programación de Funciones de Control de Movimiento en Arduino

Robot sensor Pololu: lógica inversa y ciclo while

Programación de Funciones de Control de Movimiento en Arduino