fbpixel
Controla un motor CC con Arduino

Controla un motor CC con Arduino

Uno de los principales objetivos de la robótica es que el robot se mueva. Por un rotación continua en cuanto a las ruedas de un robot se puede utilizar un motor de corriente continua. En este tutorial, prorgamamos un Arduino para que pueda manejar la velocidad y la dirección de rotación de un motor cc.

Prerrequisitos: Programa con Arduino 

Material

  • Ordenador
  • Arduino UNO
  • Cable USB
  • SN754410
  • Breadboard
  • Motor CC
  • jumper cables

Motor CC

Los motores de corriente continua a menudo se usan con una caja de engranajes para aumentar el torque mientras se mantienen las pequeñas dimensiones. El motor DC es bastante simple de usar. Para que funcione, lo único que hay que hacer es aplicarle voltaje. La señal y el nivel de voltaje determinarán la velocidad y la dirección de rotación.

Para modular el señal de voltaje applicada al motor se puede usar un puente de transistores o H-bridge.

H-bridge

El H-bridge es un semiconductor que puede distribuar el voltaje según las señales en sus entradas.Se puede representar como cuatro interruptores que redireccionan la corriente.

El componente usada en este tutorial es le semiconductor SN754410NE. Tiene dos salidas que le permiten conducir dos motores. .

Desripción de los pines.:

  • GND están conectados entre sí y al proyecto.
  • + 5V recibe la energía para el circuito lógico, generalmente connectado a la salida 5V de Arduino
  • M1 Enable y M2 Enable se utilizan para activar los puentes. Recibieron un voltaje ALTO(HIGH) / BAJO(LOW) del Arduino.
  • M1 / M2 Forward, M1 / ​​M2 Reverse recibe las señales PWM y corresponde a las direcciones del motor.
  • Pin +Motor Power IN recibe la alimentación (5,6, 7V, etc.)
  • Pines de motor 1 y el motor 2 están conectados a los cables dellos motores.

al seleccionar un componente, siempre preste atención a los límites de voltaje y corriente de operación

N.B.: Hay tarjetas disponibles para facilitar la conexión, como el módulo L298N.

Diagrama de conexión

Arduino puede ser alimentada por la computadora.

Programación

Código básico

Para controlar el motor, el H-bridge debe estar activado y una señal PWM debe ser enviada a los pines Forward o Reverse según la dirección de rotación.

// Constants
const int enableBridge1 = 2;
const int MotorForward1 = 3;
const int MotorReverse1 = 5;

// Variables
int Power = 80; //Motor velocity between 0 and 255

void setup(){
  pinMode(MotorForward1,OUTPUT);
  pinMode(MotorReverse1,OUTPUT);
  pinMode(enableBridge1,OUTPUT);
}

void loop(){
  digitalWrite(enableBridge1,HIGH); // Active pont en H

  // Tourne dans le sens direct pendant 2 secondes
  
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward1,Power);
  delay(2000);
  
  // Tourne dans le sens indirect pendant 3 secondes
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,Power);
  delay(3000);
  
  //Arrête le moteur pendant 1 seconde
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,0);
  digitalWrite(enableBridge1,LOW); 
  delay(1000);
}

Funciones

Cuando una systema tiene varios dispositivos similares, es una buena práctica crear sub-funciones para aclarar el código principal.

// Constants
const int enableBridge = 2;
const int MotorForward = 3;
const int MotorReverse = 5;

// Variables
int Power = 80; //Vitesse du moteur entre 0 et 255

void setup(){
  dcBegin();
}

void loop(){
  dcForward(Power);
  delay(2000);
  
  dcReverse(Power);
  delay(3000);
  
  dcStop();
  delay(1000);
}

void dcBegin(){
  // Initialise les pines utilisées pour le moteur
  pinMode(MotorForward,OUTPUT);
  pinMode(MotorReverse,OUTPUT);
  pinMode(enableBridge,OUTPUT);
  }

void dcForward(int P){
  digitalWrite(enableBridge,HIGH); // Active pont en H
  // Tourne dans le sens Forward à la vitesse spécifiée par P
  analogWrite(MotorReverse,0);
  analogWrite(MotorForward,P);
}

void dcReverse(int P){
  digitalWrite(enableBridge,HIGH); // Active pont en H
  // Tourne dans le sens Reverse à la vitesse spécifiée par P
  analogWrite(MotorForward,0);
  analogWrite(MotorReverse,P);
}

void dcStop(){
  // Arrête le moteur et désactive le pont en H
  analogWrite(MotorForward,0);
  analogWrite(MotorReverse,0);
  digitalWrite(enableBridge,LOW); 
}

Puede contralar cualquier motor cc con este código. Modifícalo para obtener la función deseada

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Controla un Servo con Arduino

Controla un Servo con Arduino

Uno de los principales objetivos de la robótica es que el robot se mueva. Por eso, es muy común utilizar motores eléctricos y particularmente servomotores. En este artículo, programamos el Arduino para que pueda manejar un servomotor e iremos más allá en el uso de bibliotecas que incluyen Servo.h.

Prerrequisitos: Programa con Arduino

Material

  • Ordenador
  • Arduino UNO
  • Cable USB
  • Cable M/M x3
  • Servomotor x1

Servomotor

Los servomotores son pequeños concentrados de tecnología que combinan mecánica y electrónica. Ampliamente utilizados en la creación de modelos, robótica y otras aplicaciones. Toman su nombre del hecho de que puede controlar a sí mismo su posición (o su velocidad).

Los servomotores se componen de un motor de CC, una caja de reducción y electrónica integrada para controlar la posición mediante una señal de modulación de ancho de pulso (en inglés: PWM – Pulse Width Modulation).

Diagrama de conexión

El servomotor se alimenta mediante el cable negro / marrón tierra (GND) y el cable rojo (+ 5V); y es impulsado por una señal PWM enviada por el cable amarillo / blanco (terminal 9). Dependiendo de la cantidad y la potencia del servomotor utilizado, puede ser alimentado por el terminal 5V del Arduino. Arduino puede ser alimentada por la computadora a través del puerto USB.

Si el servomotor excede la capacidad del microcontrolador, se debe utilizar una fuente de alimentación externa.

Código básico

Para controlar el servomotor en posición, debemos enviar una señal de modulación de ancho de pulso.

//Constants
#define UPDATE_TIME 20

//Parameters
int servoPin = 9;
int pulse = 1500;

void setup() {
  // Initialization
  pinMode(servoPin,OUTPUT);
  Serial.begin(9600); 
}

void loop() {
  // main
  digitalWrite(servoPin,HIGH);
  delayMicroseconds(pulse);
  digitalWrite(servoPin,LOW);
  delay(UPDATE_TIME);
}

Una forma más elegante de hacerlo es convertir la posición del servo en ancho de pulso. Para hacer eso, se requiere un poco de matemáticas.

  • 5V durante 500µs (0,5ms) corresponden a 0 grados
  • 5V durante 1500µs (1,5ms) corresponden a 90 grados
  • 5V durante 2500µs (1,5ms) corresponden a 180 grados

Una vez que se establezca la fórmula, podemos implementar una función para convertir la posición en PWM.

//Constants
#define UPDATE_TIME 20

//Parameters
int servoPin = 9;
int angle = 1500;

void setup() {
  // Initialization
  pinMode(servoPin,OUTPUT);
  Serial.begin(9600); 
}

void loop() {
  // main
  digitalWrite(servoPin,HIGH);
  delayMicroseconds(convertAngleToImp(angle));
  digitalWrite(servoPin,LOW);
  delay(UPDATE_TIME);
}

// Declare function
int convertAngleToImp(int ang){
  float a = 2000/180;
  float b = 500;

  return int(a*ang+b);
}

Se pueden escribir códigos más complejos en Arduino usando este conocimiento básico y algunas bibliotecas como la biblioteca Servo.h.

En este ejamplo, usamos la funcion digitalWrite() para mostrar el principio de la señal PWM. En la práctica, usamos analogWrite() para activar LEDs o servomotores.

//Déclaration des constantes
#define UPDATE_TIME 20

//Déclaration des paramètres
int servoPin = 9;


void setup() {
  // Code d'initialisation
  pinMode(servoPin,OUTPUT);
  Serial.begin(9600); // Initialise la communication série PC/Arduino
}

void loop() {
  // Code principal
  for(int i=0;i<180;i++){
    analogWrite(servoPin,convertirAngleEnPWM(i));
    delay(UPDATE_TIME);
  }
delay(200);
  for(int i=180;i>=0;i--){
    analogWrite(servoPin,convertirAngleEnPWM(i));
    delay(UPDATE_TIME);
  }
 delay(200);
}

// Déclaration d'un sous fonction
int convertirAngleEnPWM(int ang){
  float a = 255.0/180.0;
  return (a*ang);
}

Servo control utilizando Servo.h

Vimos que se pueden crear funciones para reutilizar el código fácilmente en el mismo archivo. Esas funciones se pueden poner en la biblioteca, archivos externos, que también se pueden usar en cualquier aplicación. Se utilizan para organizar y aclarar el código y para evitar copiar y pegar. La biblioteca se puede usar agregando una línea de código simple (y leyendo la documentación para usarla correctamente) #include.

//Libraries
#include <Servo.h>

//Constants
#define UPDATE_TIME 15
#define MAX_POS 180
#define MIN_POS 0

//Parameters
int servoPin = 9;
int pulse = 1500;

//Variables
Servo myServo;  // create servo object

int pos=0;    // variable contenant la position du servomoteur

void setup() {
  myServo.attach(servoPin); 
}

void loop() {
  for (pos = MIN_POS; pos <= MAX_POS; pos += 1) { 
    myServo.write(pos);              
    delay(UPDATE_TIME);                       
  }
  for (pos = MAX_POS; pos >= MIN_POS; pos -= 1) { 
    myServo.write(pos);             
    delay(UPDATE_TIME);                      
  }
}

Crea tu propia biblioteca ServoLib.h

La biblioteca se puede crear cuando se usa el mismo código para varias aplicaciones. Para crear una biblioteca, se deben escribir dos archivos en C (archivo .cpp y .h). El archivo .H, llamado header contiene declaraciones  de clases, variables y de funciones. Esos archivos deben guardarse con el mismo nombre que la carpeta principal y colocarse en el directorio: .Documents/Arduino/libraries.

Archivo ServoLib.h

#ifndef ServoLib_h
#define ServoLib_h

//Constants
#define UPDATE_TIME 15
#define MAX_POS 180
#define MIN_POS 0
#define MAX_PULSE_WIDTH 2500
#define MIN_PULSE_WIDTH 500

//Class
class ServoLib
{
 public:
  ServoLib(); //constructeur
  int servoPin; //broche du servomoteur
  void attach(int pin); 
  void sendPosition(int value);
  int convertAngleToImp(int ang);
  void applyImp(int pulse);
};

#endif

Archivo ServoLib.cpp

#include <ServoLib.h>

ServoLib::ServoLib(){}

void ServoLib::attach(int pin){
  servoPin=pin;
  pinMode(servoPin,OUTPUT);
}

void ServoLib::sendPosition(int value){
  int pulse=0;
  if (value<MIN_POS)
    value=MIN_POS;
  else if (value>MAX_POS)
    value=MAX_POS;

  value=map(value,MIN_POS,MAX_POS,MIN_PULSE_WIDTH,MAX_PULSE_WIDTH);
  pulse=this->convertAngleToImp(value);
  this->applyImp(pulse);
}

void ServoLib::applyImp(int pulse){
  digitalWrite(servoPin,HIGH);
  delayMicroseconds(pulse);
  digitalWrite(servoPin,LOW);
  delay(UPDATE_TIME);
}

int ServoLib::convertAngleToImp(int ang){
  float a = 2500/180;
  float b = 500;

  return int(a*ang+b);
}

Puede anadir un archivo .txt que cambia el color de los variables o funciones en el IDE.

#######################################
# Syntax Coloring Map ServoLib
#######################################

#######################################
# Datatypes (KEYWORD1)
#######################################

ServoLib  KEYWORD1  ServoLib

#######################################
# Methods and Functions (KEYWORD2)
#######################################
attach KEYWORD2
sendPosition  KEYWORD2
convertAngleToImp KEYWORD2
applyImp KEYWORDS2

#######################################
# Constants (LITERAL1)
#######################################
UPDATE_TIME LITERAL1
MIN_POS LITERAL1
MAX_POS LITERAL1
MIN_PULSE_WIDTH LITERAL1
MAX_PULSE_WIDTH LITERAL1

Sin keywords.txt

Con keywords.txt

Cuando vuelve a cargar el software IDE, la biblioteca recién creada está disponible en Menú> Bosquejo> Incluir biblioteca

El código se puede simplificar de la siguiente manera:

//Library
#include "ServoLib.h"

//Parameters
int servoPin = 9;

//Variables
ServoLib myServo;  

int pos=0; 

void setup() {
  myServo.attach(servoPin);
}

void loop() {
  for (pos = MIN_POS; pos <= MAX_POS; pos += 1) {
    myServo.sendPosition(pos);
    delay(UPDATE_TIME);
  }
  for (pos = MAX_POS; pos >= MIN_POS; pos -= 1) {
    myServo.sendPosition(pos);             
    delay(UPDATE_TIME);                      
  }
}

Próximas etapas

Funetes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código