Professional Documents
Culture Documents
Programa.
***************************************************************************************************
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int onTime = 2500;
int offTime = 1000;
digitalWrite(motorPin, HIGH);
delay (onTime);
digitalWrite(motorPin, LOW);
delay (offTime);
}
PRÁCTICA 2. CONTROLAR LA VELOCIDAD DEL MOTOR CON LA FUNCIÓN
ANALOGWRITE(PIN, VALOR).
analogWrite(pin, valor).
***************************************************************************************************
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int onSpeed = 200;
int onTime = 2500;
int offSpeed = 50; // a number between 0 (stopped) and 255 (full speed)
int offTime = 1000; //the number of milliseconds for the motor to turn off for
analogWrite(motorPin, onSpeed); // turns the motor On
delay(onTime); // waits for onTime milliseconds
analogWrite(motorPin, offSpeed); // turns the motor Off
delay(offTime); // waits for offTime milliseconds
}
PRÁCTICA 3. ACELERAMOS Y DESACELERAMOS EL MOTOR.
Ahora usamos un bucle para acelerar y frenar el motor, usando del mismo modo la
función analogwrite(), que en el caso anterior.
*************************************************************************************************************
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int delayTime = 50;
tor
for(int i = 0; i <256; i++){ //aceleramos
analogWrite(motorPin, i);
delay(delayTime);
}
for(int i = 255; i>= 0; i--){ //frenamos
analogWrite(motorPin, i);
delay(delayTime);
}
}
PRÁCTICA 4. USAMOS AHORA UN POTENCIÓMETRO PARA VARIAR LA
VELOCIDAD DEL MOTOR.
Pues porque esta función devuelve un valor comprendido entre 0 y 1024 (10 bits) y la
función analogWrite () toma valores comprendidos entre 0 y 255 (8 bits).
***************************************************************************************************
*****************************************************
int motorPin = 9;
int potPin=0;
int potValue;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
potValue = analogRead(potPin) / 4;
analogWrite(motorPin, potValue);
}
PRÁCTICA 5. USAMOS AHORA UN SERVOMOTOR.
***************************************************************************************************
#include <servo.h>
Servo myservo; // creamos un objeto servo para controlar nuestro servo
int pos = 0; // variable para almacenar la posición del servo
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
for(pos = 0; pos <180; pos += 1) // avanza de 0 a 180 grados
{ // en saltos de un grado
myservo.write(pos); // mueve a la posición de la variable 'pos'
delay(15); // espera 15ms
}
for(pos = 180; pos>=1; pos-=1) // va de 180 a 0 grados
{
myservo.write(pos);
delay(15);
}
}
PRÁCTICA 6.
Vamos a controlar la velocidad y el sentido de un motor DC a través de un
potenciómetro desde Arduino.
Material
Arduino Uno
Motor DC
Potenciómetro
L293D (driver motores)
Fuente alimentación externa
Motor DC
El estator es la parte mecánica del motor donde están los polos del imán.
El rotor es la parte móvil del motor con devanado y un núcleo, al que llega la
corriente a través de las escobillas.
Cuando la corriente eléctrica circula por el devanado del rotor, se crea un campo
electromagnético. Este interactúa con el campo magnético del imán del estator. Esto
deriva en un rechazo entre los polos del imán del estator y del rotor creando un par de
fuerza donde el rotor gira en un sentido de forma permanente.
Si queremos cambiar el sentido de giro del rotor, tenemos que cambiar el sentido
de la corriente que le proporcionamos al rotor; basta con invertir la polaridad de la
pila o batería.
L293D
Para controlar un motor DC desde Arduino, tendremos que usar un driver para
motores para proporcionarle más corriente al motor ya que las salidas del Arduino
sólo dan 40mA. De esta manera, con el driver podemos alimentar el motor con una
fuente de alimentación externa.
¿Qué es el puente en H?
Hasta este punto sabemos cómo controlar el sentido de giro del motor DC a través del
L293D. Pero ¿y la velocidad de giro? En este proyecto lo que haremos es controlar la
velocidad y el giro del motor con un solo potenciómetro.
Para hacerlo utilizaremos el PWM (véase PWM). Sabemos que hay que atacar los
pins 2 y 7 del L293D desde dos salidas del Arduino. En estas dos salidas habrá un
PWM a cada una. Pero tenemos que invertir un PWM. ¿Qué quiere decir invertir?
Pues que cuando en un PWM tengamos un pulso a un valor alto, en el otro PWM el
mismo pulso sea valor bajo. En la imagen lo entenderemos de una manera más
gráfica.
Pins 4,5,12,13 del L293D a masa.
Juntar las masas del Arduino y de la fuente de alimentación externa.
Pin 8 del L293D a 9V de la fuente de alimentación externa. Es el voltaje que
proporciona al motor.
Pin 16 del L293D a 5V. Es la alimentación del L293D, pude alimentarse
directamente desde la alimentación que proporciona el Arduino.
El potenciómetro pude ser de cualquier valor.
PROGRAMA
1
2
3
4
5 int pin2=9; //Entrada 2 del L293D
6 int pin7=10; //Entrada 7 del L293D
7 int pote=A0; //Potenciómetro
8
int valorpote; //Variable que recoge el valor del potenciómetro
9
int pwm1; //Variable del PWM 1
10
int pwm2; //Variable del PWM 2
11
12
void setup()
13
{
14
//Inicializamos los pins de salida
15
pinMode(pin2,OUTPUT);
16
pinMode(pin7, OUTPUT);
17
}
18
19 void loop()
20 {
21
22 //Almacenamos el valor del potenciómetro en la variable
23 valorpote=analogRead(pote);
24
25 //Como la entrada analógica del Arduino es de 10 bits, el rango va de 0 a 1023.
26 //En cambio, la salidas del Arduino son de 8 bits, quiere decir, rango entre 0 a
27 255.
28 //Por esta razón tenemos que mapear el número de un rango a otro usando este código.
29 pwm1 = map(valorpote, 0, 1023, 0, 255);
30 pwm2 = map(valorpote, 0, 1023, 255, 0); //El PWM 2 esta invertido respecto al PWM 1
31
32 //Sacamos el PWM de las dos salidas usando analogWrite(pin,valor)
33 analogWrite(pin2,pwm1);
34 analogWrite(pin7,pwm2);
35
36 }
37
38
39