http://electronica.mercadolibre.com.

mx/placa-arduino-severino

Qu se hace con estas placas? Lo genial de arduino es que las placas en cuestin vienen con
una memoria flash a la que tu le cargas un programa. El programa se lo cargas por USB y puede
ser cualquier cosa. Por ejemplo puedes programar tu placa para encender una luz, activar un
ventilador o incluso ir tan lejos como para crear tu propio robot. Con un poco de creatividad y
conocimientos verdaderamente mnimos de arduino puedes crear prcticamente cualquier cosa.
Si buscas por Youtibe Arduino encontrars decenas de videos de proyectos hechos utilizando una
de estas placas. Puedes ponerle uno o varios motores a las placas, adherirle un sensor infrarrojo
para controlarlo con el mando a distancia, crear un brazo animatrnico etc.
Se trata de una comunidad abierta de desarrolladores con su propio entorno de desarrollo que gira
en torno a estas placas. Es una forma divertida y fcil de adentrarse tanto al mundo de la
electrnica como al mundo de la programacin a la vez que estimulamos el aprendizaje de nuevas
herramientas.
http://www.ethek.com/arduino-que-es-y-para-que-sirve/




proyectos utilizando arduino (no manches en pocas palabras electrnica + programacin = crea lo
que desees)
http://www.hojaderouter.com/tecnologia/hardware/diez-cosas-increibles-que-podras-hacer-por-
ti-mismo-con-arduino/6665





No manxes checa esta pagina
http://www.electronicaestudio.com/arduino_productos.htm






http://platea.pntic.mec.es/~mhidalgo/edubasica/01arduino/arduino01.html














































Aplicaciones con Arduino.
Introduccin a la plataforma Arduino.
Hoy es: Mie 28.05.2014 CRTL+D, para volver a visitarnos. Creado por: V.
Garca.
Tema:
Buscar


Idioma

PROLOGO.
Arduino es una plataforma de cdigo abierto, basada en una sencilla
placa con entradas y salidas analgicas y digitales, posee adems de
una memoria No-voltil cuya capacidad depende de la versin de
microcontrolador utilizado, los primeros disponan de 8Mbytes, sin
embargo se puede intercambiar por otros de gama mayor 16Mbytes
o ms. El entorno de desarrollo est basado en el lenguaje
Processing/Wiring.
Mediante los pines de entrada/salida, puede recibir seales de gran
variedad de sensores, de modo que puede interactuar en su entorno,
controlando luces, motores o actuadores, trabajando de manera
autnoma o a travs de un programa corriendo en un computador
(por ejemplo, Macromedia Flash, Processing, etc.). Est compuesto
por un micro controlador Atmel AVR que viene pre-programado con
una secuencia de arranque (Boot Loader), con el que se puede
actuar sobre el contenido de la memoria, por lo que no necesita un
programador externo.
El protocolo de comunicacin que utiliza Arduino es el RS232 serie.
Los protocolos de comunicacin, se han desarrollado para que las
mquinas pueden enviar y recibir datos a/de otras mquinas. Cada
protocolo se compone de un conjunto de normas que definen cmo
se representan los datos. El protocolo RS232 serie, es un viejo
protocolo bien establecido en la dcada de 1960. Que ha sido
ampliamente reemplazado por protocolos ms rpidos y ms
avanzado como el USB.
Sin embargo, sigue siendo ampliamente utilizado a travs de
emulacin de software - en gran parte debido a su fcil aplicacin.
Configurar una conexin en serie, consiste en especificar un puerto
(COM en Windos, / dev / Linux, OS X) y una velocidad de
comunicacin para cada dispositivo o mquina. Arduino, tambin
dispone y utiliza el protocolo va USB para comunicarse, con un
computador externo.
La presentacin, es un tema que ya est muy desarrollado por los
propios creadores y una larga lista de entusiastas que venimos
utilizando esta plataforma, por dicho motivo no me extender ms.
APLICACIONES.
Entre las aplicaciones, debido a las posibilidades que presentan sus
entradas, nos permite utilizar una gran variedad de sensores, como
se ha dicho. Para no repetirme con proyectos de los primeros pasos
en esta plataforma, aqu daremos un pequeo salto y voy a describir
cmo controlar un rel, luego veremos como podemos leer la
posicin de un potencimetro (ms corto pot), ms tarde, veremos
como controlar el giro de un servomotor. Esto es slo el arranque de
una aventura con la compaa de nuestro Arduino.
Control de un rel.
Un conmutador.
Leer la posicin de un potencimetro.
Control de un servo.
Ejemplo 1.
Ejemplo 2.
Motor DC.
MATERIALES NECESARIOS.
Es conveniente disponer de un mnimo de componentes para llevar
a cabo las presentes prcticas, a continuacin, sigue una lista de
los componentes msrelevantes:

Placa
Arduino

Rel de 2
circuitos

Pot lineal de
10K.

Mini pulsador.

IC LM293b

Diodo LED

Servomoto
r estndar

Motor DC

Transistor

Resistencias

Adaptador red

Cablecillo
rgido.
CONTROL DE UN REL.
Para empezar , una aplicacin sencilla, sta consiste en activar un
rel mediante un sensor. El sensor puede ser cualquiera que se
adapte a las necesidades del proyecto. En ente caso, vamos a utilizar
un simple mini pulsador de los que podemos encontrar en el
comercio o si lo preferimos en multitud de equipos que ya no nos
sirven y de los cuales podemos recuperar dichos pulsadores entre
otros componentes. Un rel cuya tensin de trabajo puede ser de
12V, undiodo de proteccin que puede ser un 1N4148 o en su
defecto un 1N4001.

Este es el circuito que necesitara para activar un rel de 12V
controlado por una salida digital del Arduino, en l se puede ver los
componentes que se utilizan habitualmente, el diodo D1, evita la
destruccin del transistor por la contra corriente producida por la
induccin del rel. Se ha utilizado un rel de dos circuitos, para
producir el efecto memoria, es decir, cuando se ceba el rel, el
contacto secundario, al cual se ha intercalado el pulsador 'reset', el
circuito de activacin permanece activo hasta que se pulsa ste
pulsador que corta el circuito de retencin o memoria.
EL ESQUEMA.
El esquema es muy simple, se puede apreciar en la imagen
de abajo, generada con la ayuda del programa gratuito fritzing.

Ahora, lo primero que hemos de hacer es abrir el editor de
texto habitual (o Notepad), vamos a escribir nuestro programa para
que al presionar el pulsador el rel se active. Si lo desea,
puede copiar y pegar el contenido del archivo del programa que
encontrar aqu, gurdelo con el nombre "pulsador.pde", crguelo en
el IDE de Arduino y verifique su sintaxis y lo puede cargar en su
Arduino.
Pulsador.
CDIGO: SELECCIONAR TODO
/*
* Pulsador.pde
*
* Autor: V. Garca
* Cambia estado de un rel, conectado al pin digital
13, con un transistor
* si es necesario, cuando presionas un pulsador
conectado al pin 7.
* Se desconecta al liberar el pulsador.
*/

int switchPin = 2; // elige el pin 2 de entrada
(para un botn)
int relePin = 8; // elige el pin 13 para el rel
int val = 0; // variable para leer el estado de
pin2

void setup () {
pinMode (relePin, OUTPUT); // declara relePin como
salida
digitalWrite(switchPin, HIGH); // activa la rpa al
pin 2
pinMode (switchPin, INPUT); // declara el botn como
entrada
}

void loop () {
val = digitalRead (switchPin); // lee valor de la
entrada
if (val == HIGH) { // comprueba si la entrada es
ALTA (botn libre)
digitalWrite (relePin, LOW); // si, cambia y
desactiva el rel.
} else {
digitalWrite (relePin, HIGH); // no, cambia y activa
el rel.
}
}
QU HEMOS HECHO?
El primer apartado corresponde al nombre del archivo, la
descripcin, fecha y autor; todo esto se pone entre lneas
comentadas, es decir, cada lnea est precedida por dos barras "//
comentario" o en su caso "/* comentarios */". Esta sera una seccin
que servira:
/*
* Pulsador
*
* Autor: V. Garcia
* Cambia estado de un rel, conectado al pin digital 13, con un transistor
* si es necesrario, cuando presionas un pulsador conectado al pin 7.
* Se desconecta al liberar el pulsador.
*/
El principiante, debe utilizar una cabecera similar para sus
proyectos. A continuacin, se deben declarar los archivos a incluir as
como, las variables que se utilizaran en el programa.
Es bastante normal el uso de libreras que incorpora la plataforma
Arduino, como: servos.h, timer.h, rtc.h u otras, dependiendo de las
necesidades del programa. En esta actividad, no se utilizan libreras
extras, debido a lo sencillo del proyecto. La forma de utilizar las
libreras es como se ve en el siguiente ejemplo:
#include <Servo.h> // esto indica que utiliza la librera servo.h
En la siguientes lneas se declaran las distintas variables. Vemos
que se declara como entero (int) el valor del pin digital 2, donde se
leer el estado del pulsador. Tambin se declara, como entero (int)
el pin digital 11, donde aplicaremos el rel o mejor dicho, el
transistor que manejar el rel. Utilizaremos el transistor por dos
razones, por si la corriente que necesita el rel es mayor que la que
proporciona la salida del Arduino y por que nos sirve de separador de
las corrientes inducidas, por la bibina del rel.
int switchPin = 2; // pin digital de entrada para switch
int relePin = 8; // pin digital de salida para rel
La siguiente seccin, se encarga de configurar los pines
involucrados en el proyecto e inicia el puerto serie, si intervienen las
comunicaciones serie.
void setup() { // esta seccin, slo se lee una vez, cuando empieza el programa.
pinMode(switchPin, INPUT); // declara el botn como entrada
digitalWrite(switchPin, HIGH); // activa la rpa al pin 2
pinMode(relePin, OUTPUT); // declara relePin como salida
// Serial.begin(9600); // inicia la comunicacin Serial. Si fuera necesario.
}
Configurar, con el pinMode(switchPin, INPUT);, le indicamos al
programa que el pin digital 2 estar en modo entrada.
Con digitalWrite(switchPin, HIGH);se activa la RPA (resistencia
polarizacin interna a alto), esto fuerza al pin2 a ver un H, si no es
presionado el pulsador. Con pinMode(relePin, OUTPUT); se
declara el pin digital 8 como salida. Y si interviene la comunicacin,
con Serial.begin(9600); le indicamos que, inicie la comunicacin
con la consola a 9600 baudios/s, en este caso. Lase la gua de
Arduino, para ms detalle. Esta rutina del seup(), se lee una sola
vez, al iniciar el programa o despus de un rest.
Ahora, se aadiran las distintas rutinas que intervinieran en el
proyecto, no es el caso en este proyecto. Las rutinas, si las hay, se
leen una vez, al iniciar el programa o despus de un rest y
posteriormente cuantas veces sea necesario, al ser llamadas por el
flujo del programa.
Por ltimo, se abre el bucle o loop() (lazo) en donde se repetir
indefinidamente el flujo del programa, hasta que lo abortemos con
un reset o corte de tensin.
void loop()
{
val = digitalRead (switchPin); // lee valor de la entrada
if (val == HIGH) { // comprueba si la entrada es ALTA
(botn liberado)
digitalWrite (relePin, LOW); // si, cambia y desactiva el rel.
} else {
digitalWrite (relePin, HIGH); // no, cambia y activa el rel.
}
}
Se observa que el rel se activa mientras est presionado el
pulsador y se desactiva al ser liberado ste. Esto confirma que el
programa hace lo que preveamos, sin embargo, ahora, vemos que,
esto realmente no es lo que queramos (el programa no adivina lo
que queremos), lo que nos ira mejor es que se activara el rel con
una pulsacin y con una segunda pulsacin se desactivara.
Por lo tanto, tenemos que modificar en parte el programa ya que
este, realmente responde a la accin del pulsador mientras este es
presionado y lo que queremos es un conmutador.

UN CONMUTADOR.
Como todos sabemos, un conmutador tiene dos estados estables,
los cuales se cambian con una accin mecnica externa. Esto mismo
lo llevaremos a nuestro entorno Arduino. Las primeras lneas como
siempre, describen lo que hace el programa, en segundo lugar, estn
las variables, usaremos nombres intuitivos, fciles de comprender
como switchPin para el pulsador, outPin para la salida y otros que se
comentan en el propio programa. Haremos uso de una funcin de
tiempo como es millis(), para controlar el siempre presente
problema de los rebotes lo que se conoce en ingls como bouncing.
En la configuracin (setup), aprovecharemos las posibilidades que
nos presentan los pines digitales, esto no slo lo haremos para
evitarnos una resistencia, como son las RPA (resistencias de
polarizacin a alto), si no, para verificar la importancia que tiene este
detalle, pero eso lo veremos ms tarde.
RECOMENDACIONES
Es importante recordar las recomendaciones al respecto de los
pines configurados como salida (OUTPUT) con pinMode() se dice
que estn, en estado de baja impedancia. Esto significa que puede
proporcionar una cantidad sustancial de corriente a otros circuitos.
Los pines del Atmega pueden proporcionar corriente positiva o
proporcionar corriente negativa de hasta 40 mA (miliamperios) a
otros dispositivos o circuitos. Esta es suficiente corriente para la
brillante luz de un LED (no se olvide de la resistencia en serie) o para
utilizar muchos sensores por ejemplo; sin embargo, no es
conveniente utilizar las salidas directamente en los dispositivos con
inductancias, como rels, solenoides o motores.
Los cortocircuitos en los pines de Arduino o intentos de extraer
mucha corriente de ellos, pueden daar o destruir los transistores de
salida en el pin, pudiendo daar completamente el chip Atmega. A
menudo, esto se traducir en un pin del microcontrolador "muerto",
pero el resto del chip seguir funcionando adecuadamente. Por esta
razn es buena idea conectar los pines de salida a otros
dispositivos con resistencias de 470 o 1k, limitando la corriente
mxima que desde los pines es requerida para una aplicacin
particular. Veamos el cdigo.
Ads by OnlineBrowserAdvertisingAd Options
Conmutador.
CDIGO: SELECCIONAR TODO
/* conmutador.pde
*
* Cada vez el pin de entrada va de BAJO a ALTO
(p.ej. debido a apretar un botn),
* el pin de salida bascular de BAJO a ALTO o de
ALTO a BAJO. Hay un retraso
* mnimo entre basculados, para evitar los rebotes
del circuito.
* (as no haremos caso del ruido).
*
* Modificado por V. Garca 30062009 23:10H
*
* Funciona correctamente, emplea 2.514 bytes.
*
*/

// variables.
int switchPin = 2; // input pin2 (switch o
pulsador)
int outPin = 8; // pin8 output del pin2
int estado = 0; // estado actual del pin de
salida
int previo = 0; // lectura anterior del pinX de
entrada
int reading; // lectura actual del pin de
entrada

// las siguientes variables son para el tiempo,
medido en miliseconds.
long time = 0; // la ultima vez que el pin de
salida fue basculado
long debounce = 500; // el tiempo de rebote,
aumenta si la salida parpadea

void setup() // Configuramos los pines
{
pinMode(switchPin, INPUT); // pone como entrada
el pin2
digitalWrite(switchPin, HIGH); // activa la rpa del
pin 2
pinMode(outPin, OUTPUT); // pone el pin 8 como
salida
Serial.begin(9600); // activa
comunicaciones serie
}

void loop()
{
reading = digitalRead(inPin);

// solo si la entrada va de BAJO a ALTO y hemos
esperado tiempo suficiente
// para que ningn rrebote afecte al circuito, el
pin de salida bascular y
// recordar desde cuando.
if (reading == HIGH && previo == LOW && millis()+100
- time > debounce) {
if (estado == HIGH) {
estado = LOW;
time = millis();
}
else {
estado = HIGH;
time = millis();
}
}
digitalWrite(outPin, estado);
previo = reading;
}
Por seguridad ponga una resistencia limitadora de 270 y un LED
conectados entre el pin digital 8 y masa. Se puede apreciar que,
cuando presiona el pulsador se enciende el LED y si vuelve a pulsar,
se apaga el LED, ahora permanece en cada estado hasta que se
produce una nueva pulsacin, justo lo que queramos. De nuevo, si lo
desea, puede copiar y pegar el contenido del archivo de este
programa que encontrar aqu, gurdelo con el nombre
"conmutador.pde" para poder recordarlo con facilidad.
Ahora, como ya coment antes, vamos a ver la importancia de las
RPA's. Para lo cual, haremos un pequeo cambio en el programa, se
trata de comentar las dos lnea que siguen:
digitalWrite(inPin, HIGH); // activa la rpa del pin 2
pinMode(outPin, OUTPUT); // pone el pin 8 como salida
debe quedar as:
// digitalWrite(inPin, HIGH); // activa la rpa del pin 2
// pinMode(outPin, OUTPUT); // pone el pin 8 como salida
Lo debe compilar de nuevo y ejecutarlo. Qu ha notado? Cuando
acerca la mano al pulsador, se cambia el estado del LED y adems el
LED no se enciende con la misma potencia.
En primer lugar, es tan sensible que, influye la capacidad de la
mano con el conductor del pin 2 al pulsador, esto hace que haya una
incertidumbre de estabilidad, parece descontrolado. Sin duda, la RPA
tiene su importancia.
En cuanto a la indefinicin del estado de salida del pin digital 8,
hace que la tensin de salida sea inferior a la de alimentacin y ste
es el efecto que produce, parece de poca importancia, pero no debe
descuidar este detalle, puede llevarle a innecesarios quebraderos de
cabeza.
Ya puede sustituir el diodo LED, por un transistor BC549 o similar y
conecte el rel en el colector, como muestra el circuito de arriba. Los
negativos de las tensiones utilizadas, siempre deben unirse . Con
esto, terminamos la presente prctica, como siempre, si desea
alguna aclaracin, puede hacerme llegar su consulta en, este
enlace.

EL POTENCIMETRO.
Como ya dije al principio, este es el momento de leer la posicin de
un pot. Seguramente esta pensando, para que sirve leer la posicin
de un pot. Para que mediante un programa (soft), lograr mover el
eje de un motor, una cantidad de grados, es una respuesta posible o
igualmente controlar la velocidad del motor. Cmo? Ya tiene ms
respuestas, como estos ejemplos!. Eso esta bien. Aclarado esto,
podemos seguir. Observe la figura que sigue. Que le sugiere.

Hay infinidad de programas en la red que, muestran como hacer
esto, por lo tanto, no hay necesidad de "inventar" nada nuevo. Ya
que no voy a mejorar nada, con permiso del autor (no consultado),
voy a exponer uno de esos ejemplos, para que sirva a mi propsito
que es avanzar en este documento. Sin ms prembulos:
Los extremos del potencimetro se conectan al +5V y a masa 0V. El
punto central, se conecta a una entrada analgica pin2 (pin0 - pin3),
con la ayuda de un voltmetro se puede leer la tensin de salida, los
valores as obtenidos, los procesaremos y esperemos a ver los
resultados obtenidos. Realmente, hemos hecho un divisor de tensin,
el programa leer los valores de tensin de la entrada por el pin
analgico 2 conectado al terminal central del pot. El valor ledo as,
vara de 0 a 5.000mV y es proporcional a la posicin de mando del
potencimetro, por ese motivo debe utilizarse un pot lineal. El valor
obtenido se puede analizar a travs de la conexin serie que se
controlar visualmente mediante la pantalla del monitor.
Aclaremos esto de los pines analgicos, estas entradas analgicas
en Arduino son manejadas por un convertidor analgico/digital de 10
bits, por lo que entregan a su salida, valores entre 0 y 1023 (2^10 -
1=1023). As que, la tensin que entrega el pot a la entrada
analgica, en la funcin analogRead, variar entre 0 (cuando est a
0V) y 1023 (cuando est a 5V).
Veamos un cdigo que nos sirva de partida para nuestro propsito.
EL CDIGO.
El programa se basa en un simple cdigo, con el cual, una entrada
analgica recibe las variaciones de niveles de tensin que
posteriormente convierte a nmeros que podemos interpretar. Este
ejemplo, muestra cmo se desvanece un LED conectado al pin 9, no
olvide utilizar la funcin analogWrite(). Este cdigo que sigue, es
de dominio pblico.
Dimer 1
CDIGO: SELECCIONAR TODO
// Enciende un LED con PWM segn pos. potencimetro

int potPin = 2; // seleccionar el pin de entrada
analgico 2 para el pot
int ledPin = 9; // seleccionar el pin de salida
digital 9 para el LED (PWM)
int val = 0; // variable para almacenar el
valor capturado desde el sensor

void setup() {
Serial.begin(9600); // sets the
serial port to 9600
pinMode(ledPin, OUTPUT); // declara el ledPin en
modo salida
}

void loop() {
val = analogRead(potPin); // lee el valor del
sensor
analogWrite(ledPin, val); // enciende LED
Serial.print(val);
Serial.println(" ");
delay(20); // detiene
el programa por un tiempo determinado.
}
Copie, pegue y guarde este cdigo con el nombre leepot.pde.
Ahora, compile, cargue el programa al Arduino y compruebe el
resultado. Cuando mueve el eje del pot el brillo del LED vara, sin
embargo no parece estar dentro de lo esperado, debera ir ms fino,
no le parece.
Porque ocurre que, cuando debera estar el LED apagado del todo,
est parpadeando. Esto se debe a que el valor que se lee del pot. se
convierte en fracciones de 0-1023, esto entra en conflicto, puesto
que el valor mximo de un byte es 255. Este es el motivo por el que,
encontramos como cuatro puntos de apagado o encendido al girar de
un extremo a otro el eje del pot. Esto lo podemos comprobar
simplemente realizando la prueba que sigue:
analogWrite(ledPin, val/4); // enciende LED. Dividimos 1024 por 4, para obtener de 0
a 255
Y volvemos a compilar, cargar y por fin comprobamos que ahora s,
obtenemos el resultado que esperbamos. Hay un detalle que no
debe pasar desapercibido, me refiero al funcin
utilizada analogWrite() por la anterior digitalWrite(), esto es as,
para que podamos aprovechar la Modulacin por Ancho de
Pulso PWM (en ingls Pulse Width Modulation) que llevan algunos de
los pines de salida del Arduino. Para obtener ms informacin,
consulte la pgina de la biblioteca Arduino.
As que, el cdigo final es el siguiente:
Dimer 2
CDIGO: SELECCIONAR TODO
/*
* PotDimer
* ---------
*
* Uso de un potenciometro para adjustar el brillo
del LED PWM's
*
* Como el mximo valor de salida del convertidor es
255, el
* valor leido del pot, tenemos que vividirlo por 4
* de esta forma podremos mostrar sus valores.
*
*/

int potPin = 2; // selec. el pin entrada del
potencimetro
int ledPin = 9; // selec el pin para el LED
int val = 0; // variable para guardar el
valor ledo por el sensor

void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin
como OUTPUT
Serial.begin(9600);
}

void loop() {
val = analogRead(potPin); // lee el valor del
sensor
analogWrite(ledPin, val/4); // pone el ledPin
encendido
Serial.print(val); // imprime valor del
pot y vuelve al panel de depuracin
Serial.println(" ");
delay(20); // espera 20 seg
}
Ahora s, copie, pegue y guarde o descargue el cdigo de aqu, dele
el nombre por ejemplo potdimer.pde, compile, cargue y compruebe
que, ahora s, obtenemos el resultado que esperbamos. El LED
realmente se desvanece (fading), en la medida que variamos el eje
del pot. o al contrario, se enciende. Esto, nos servir en el caso de
los servos?.

SERVOMOTOR.
Una simple descripcin de un servomotor puede ser esta: es un
pequeo motor elctrico que, puede ser controlado para que gire a
una posicin angular especfica y mantenerse estable en dicha
posicin. Algo ms concreto, el servo, consta de un motor de
corriente continua, con una caja reductora y un circuito de control,
para su posicionamiento. Los servomotores tienen tres hilos:
alimentacin, tierra o masa, y seal de control. El cable de
alimentacin suele ser rojo y debe ser conectado al pin de 5V, el
cable negro se conecta a masa (0V) y el cable de control puede ser
de color amarillo, naranja o blanco, por el que se aplican los pulsos
para su control.
Existen un gran nmero de aplicaciones que vienen utilizando este
tipo de servomotores, por ejemplo controles de juguetes, mquinas
herramienta, robots, etc. entre otras. Actualmente, con la
proliferacin de los micro controladores como Arduino o PIC entre
otros, se viene desarrollando una gran cantidad de aplicaciones, cuyo
lmite es la imaginacin.

Vista de la caja reductora y engranajes.
Cuando haya que utilizar un servomotor, se deben tener en cuenta,
un mnimo de factores bsicos a considerar como:
Recorrido de giro o sea, intervalo angular, 0 - 180 grados o 360 grados (giro completo).
Velocidad de giro.
Par (torque o fuerza) que el servo puede generar.
Tamao, peso, coste, etc.
Como hemos visto, los servo-motores tienen engranajes reductores
integrados y un eje que se puede controlar con precisin. Los servos
estndar, permiten que el eje se controle con precisin en ngulos de
pocos grados, por lo general entre 0 y 180 grados. Los servos de
rotacin continua permiten la rotacin del eje a distintas velocidades.
El control de parada, se puede realizar de forma automatizada (soft)
o mediante la accin de un pot que permite modificar el ngulo de
giro con cierta precisin. Para una descripcin ms detallada debe
visitar este sitio. Tambin puede visitar el artculo sobre, cmo trucar
un servo conservando la electrnica, en
este blog. o trucar_servo_futaba_s3003.pdf, aqu

Nota: En todos los ejemplos que se presentan en este artculo,
recomiendo utilizar la librera #include <Servo.h> de la versin
0018 o posterior. No se presenta el enlace en este sitio, para no
inducir a error.
De esta forma ya tendremos acceso a una serie de comandos del
servo
como: myservo, myservo.attach(#); myservo.write(pos); etc.
Veamos un par de ejemplos que ilustren estos comandos entre otros,
donde pos es un valor entre 0 y 180 aproximadamente.
Como se aprecia en la imagen anterior, para las prximas prcticas
y puesto que la placa Arduino puede manejar directamente hasta
seis servos, necesitamos estos componentes; un Arduino, un
potencimetro y un servo-motor estndar (he utilizado el S3000 de
Futaba, por tener algunos en el cajn), con un margen de giro de 0-
180. Esto bastar, espero, para comprender cmo controlar un
servo.
Porque me he decidido por el control del servomotor antes que del
motor DC, es una cuestin de practica, ya que Arduino tiene
capacidad para manejar un servo (realmente hasta seis) en cada una
de las salidas dotadas de PWM, lo cual permite la conexin directa
del servo al pin elegido, no es por otra cuestin. Dicho esto, voy a
seguir con lo propuesto.
En el IDE de Arduino disponemos de la librera Servo.h, resultar
hasta cierto punto sencillo el control de un servo como vamos a
comprobar. Empezaremos por algo sencillo, en el propio IDE Arduino
viene un ejemplo que vamos a utilizar.

EJEMPLO 1.
Ejercicio-1. Veamos un ejemplo de control de un servo, cdigo
que, he tomado de la web de Barragan, he reducido un poco el
cdigo, para mi propsito. En este cdigo, se aplica la seal PWM que
dirigimos al pin digital 9. Como se puede comprobar no tenemos
ningn modo de influir externamente en lo que hace el programa. En
l, el servo, gira en un sentido y al llegar al final predeterminado
(180), inicia un retroceso hasta volver al punto predeterminado
(0), as de simple, no hay ms. El que sigue es el cdigo.
Ads by OnlineBrowserAdvertisingAd Options
Sweep (Barrido)
CDIGO: SELECCIONAR TODO
// Sweep (Barrido)
// ejemplo 1
// by BARRAGAN <http://barraganstudio.com>

#include <Servo.h>

Servo myservo; // create servo object to control a
servo
// a maximum of eight servo objects can be created

int pos = 0; // variable to store the servo
position

void setup() {
myservo.attach(9); // attaches the servo on pin 9
to the servo object
}

void loop() {

for(pos = 0; pos < 75; pos += 1) // goes from
0 degrees to 180 degrees
{ // in steps
of 1 degree
myservo.write(pos); // tell servo to go to
position in variable 'pos'
delay(15); // waits 15ms for
the servo to reach the position
}
for(pos = 75; pos>=1; pos-=1) // goes from 180
degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to
position in variable 'pos'
delay(15); // waits 15ms for
the servo to reach the position
}
}
En el cdigo de barrido, porque se trata de un barrido, como el
limpia parabrisas de un coche. Un recorrido en un sentido y acto
seguido cambia el sentido y hace otro barrido o recorrido. Con la
seal PWM se controla el punto de ajuste de posicin, no la
velocidad.
En el cdigo, el punto de ajuste de posicin (pos) cambia en un
grado cada 15 milisegundos. No tiene mucho sentido un cambio
mayor de 15 milisegundos, porque el perodo PWM, base de los
servos es de unos 20 milisegundos.
Para controlar la velocidad del barrido, se necesita controlar la
rapidez con que cambia el punto de ajuste. Por ejemplo un
incremento de 3 grados (pos += 3), har un barrido tres veces ms
rpido (naturalmente, sujeto a la velocidad mxima del servo en
uso).
Por lo tanto, este ejemplo tiene una aplicacin muy concreta y para
mi propsito no es exactamente lo que esperaba. Voy a realizar
algunos cambios a continuacin.
Ejercicio-2. Pretendo aplicar al servo, una salida de Modulacin de
Ancho de Pulso y mediante la variacin de una seal analgica
(potencimetro), modificar el ancho del pulso, con lo cual variar el
ngulo de giro del servo motor.
Cdigo.
Vamos a controlar el giro de un servomotor conectado a un pin
analgico. Mediante la seal analgica del potencimetro, leda por el
pin analgico 2 (analogPin), regularemos el ngulo de giro del servo
segn el giro del eje del potencimetro. En este ejemplo, para
reducir el cdigo, se utiliza la libreraServo.h.
Servo con pot.
CDIGO: SELECCIONAR TODO
/*
* potservo.pde
*
* by V. Garcia <http://www.hispavila.com>
* Controlar un servo con Arduino, se utiliza un pot
en el pin analogico 2
* el servo se conecta al pin 9 (PWM).
* Utilizando Arduino v0018, funciona bien. Si
utiliza la ver. 0013, debe
* cambiar la librera Servo en
Harware/libreries/Servo, para que funcione.
*/

#include <Servo.h> //include the servo libary

Servo myservo; // crea el objeto servo para
control del servo
// a maximum of eight servo objects can be created
int analogPin = 2;
int = 2; // Valor devuelto por
el sensor analogico (pot.)
int pos = 0; // variable para guardar
posicin del servo

void setup() {
myservo.attach(9); // attaches the servo on pin 9
to the servo object
}

void loop() {
analogValue = analogRead(analogPin);
myservo.write(analogValue*8/50); // dice al servo
la position en variable "analogValue"
delay(15); // espera 15ms a que servo
reaccione a la posicion
}
El cdigo anterior es sencillo (si utiliza una versin del IDE Arduino,
anterior a la ver. 0018, debe cambiar la librera Servo.h ubicada en
las libreras, para que funcione), el valor ledo, entrada del pin 2
(procede del potencimetro), ser convertido en un byte para indicar
la posicin del servo. El pin de salida (PWM) es el pin 9, al mover el
eje del pot, el servo reaccionar desplazndose en proporcin al total
del giro permitido.
Si dispone de un servo de giro continuo, haga la prueba, con este
cdigo de ejemplo. Observe que, con el eje del pot girado a un
extremo, el servo gira en una direccin y cuando pone el eje del pot
en el otro extremo, el servo cambia tambin de direccin, girando de
forma continua en ambos casos.

Trate de girar el pot lentamente; encontrar un punto en el que el
servo se detiene. Reajuste el punto de giro del servo ajustando el
potencimetro interno del servo (ver imagen anterior), para hacer
coincidir el centro del recorrido del servo e igualar ambos lados de
giro. Uf!, espero se me entienda.

EJEMPLO 2.
En los dos cdigos que hemos descrito en el ejemplo anterior, se ha
utilizado la librera Servo.h mediante la cual se tiene acceso a los
comandos que (aunque, nos es transparente) reducen nuestro
cdigo. En este ejemplo, voy a presentar un cdigo que permita el
mismo resultado, obtenido en el ejemplo anterior, sin dicha librera.
El Cdigo.
Hay diferentes opciones para cubrir este tema, algunas versiones
utilizan el map(), otras en cambio, utilizan otros medios, el caso es,
respetar los parmetros de frecuencia con un perodo de 20ms y la
modulacin por ancho de pulso, PWM entre 0'5 y 2'4 ms.
Utilizando el cdigo de ms arriba y modificando unos detalles,
podemos conseguir mover el eje de un sencillo servo, desde un
extremo al otro de su habitual recorrido. El siguiente es el cdigo:
Servo potenimetro
CDIGO: SELECCIONAR TODO
/*
* Pot_Servo.pde
* ---------
*
* Uso de un potenciometro para mover el servo por
PWM
*
* Como el mximo valor de salida del convertidor es
255, el
* valor leido del potencimetro, tenmos que
vividirlo por 4
* de esta forma podremos mostrar sus valores.
*
*/

int potPin = 2; // selecciona el pin input para
el potenciometro
int ledPin = 9; // selecciona el pin para el
servo
int val = 0; // variable para guardar el
value del sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as
an OUTPUT
Serial.begin(9600);
}

void loop() {
val = analogRead(potPin); // lee el valor desde el
sensor
val = val/4; //
convierte desde 0-1023 en 0-255
analogWrite(ledPin, val); // devuelve el ledPin on
Serial.print(val); // imprime el
valor devuelto pot por el panel debugger
Serial.println(" ");
}
Como se puede comprobar, este cdigo es bastante endeble para su
uso habitual, necesitamos un cdigo ms robusto, con el cual
podamos asegurar el emplazamiento del eje motor del servo en una
posicin ms ajustada al eje del potencimetro. Este cdigo que se
muestra a continuacin puede servir.
Ads by OnlineBrowserAdvertisingAd Options
Servo control
CDIGO: SELECCIONAR TODO
/*
Servo control, con una entrada analgica.

by Tom Igoe
additions by Carlyn Maw & Rob Faludi
Created 28 Jan. 2006
Updated 10 Jun. 2008
http://itp.nyu.edu/physcomp/Labs/Servo
Funciona bien, necesita 2114 bytes
*/

int servoPin = 2; // pin para control
servo motor
int minPulse = 500; // posicion Minima servo
int maxPulse = 2500; // posicion Maxima servo
int pulse = 0; // cantidad de pulsos
del servo

long lastPulse = 0; // el tiempo en
milliseconds del ultimo pulso
int refreshTime = 20; // tiempo necesario entre
pulsos

int analogValue = 0; // valor devuelto por el
sensor
int analogPin = 2; // pin analogico para el
sensor

void setup() {
pinMode(servoPin, OUTPUT); // Set servo pin como
un pin de salida
pulse = minPulse; // Set del valor posicion
motor para el minimo
Serial.begin(9600);
}

void loop() {
analogValue = analogRead(analogPin); // read the
analog input
pulse =
map(analogValue,0,1023,minPulse,maxPulse); //
convert the analog value
// para un rango entre minPulse y maxPulse.
// el nuevo pulso al servo, si el tiempo de
actualizacin (20 ms) han pasado:
if (millis() - lastPulse >= refreshTime) {
digitalWrite(servoPin, HIGH); // Enciende el motor
delayMicroseconds(pulse); // La longitud del
pulso establece la posicin del motor
digitalWrite(servoPin, LOW); // Apaga el
motor
lastPulse = millis(); // guarda el tiempo del
ltimo impulso
}
}
Los valores mnimo (minPulse) y maximo (maxPulse), sern
diferentes dependiendo de su servo motor especfico. Tericamente,
deberan estar entre 1 y 2 milisegundos, pero en la prctica 0,5 a 2,5
milisegundos suele funcionar bien. Pruebe diferentes valores para ver
qu nmeros son los mejores para usted.
Este programa, como bien advierte T. Igoe, utiliza la funcin millis()
para no perder de vista cuando fue impulsado el servo por ltima
vez. As pues, la funcin millis() con el tiempo, produce un error de
desbordamiento (es decir, genera un nmero que es demasiado
grande para caber en una variable long) despus de 5 das. Si usted
est haciendo un programa que tiene que correr por ms de 5 das,
puede ser necesario tomar en cuenta de este dato.

MOTOR DC.
No entrare a describir que es un motor de corriente continua ya
que, este es un conocimiento preliminar que, se supone debe tener
el lector, para poder comprender lo que se describe en esta prctica.
El motor, girar en el momento que se aplique una tensin de rango
adecuado en sus bornes o terminales. Normalmente, los motores
tienen una referencia en su cuerpo que nos indica sus caractersticas.
QU PODEMOS HACER.
Con la capacidad de Arduino, vemos que se pueden controlar
dispositivos de bajo consumo, como los LEDs, servos, etc. sin
embargo, cuando tratamos de mayores consumos, sobre todo, con
cargas con inducciones, como un motor de corriente continua, rels,
etc., por precaucin, se necesita utilizar al menos, un transistor
externo.
Un transistor externo, es increblemente til, con l, se controla una
mayor cantidad de corriente con la pequea aportacin de la seal
procedente de Arduino. Cuando a un transistor NPN, se le conecta la
carga al colector y el emisor a tierra, de modo que aplicamos a la
base, la salida de Arduino del pin elegido, podemos mover el motor
que girar en proporcin a la seal que le entrega el pin.

CONTROLANDO LA VELOCIDAD.
Anteriormente, en un ejemplo, jugamos con el control de brillo de
un LED mediante la modulacin por ancho de pulso (PWM), ahora,
vamos a utilizar la misma caracterstica, para controlar la velocidad
de giro de un pequeo motor de juguete. En el mundo real, vemos
girar un motor de parado a mxima velocidad, variando la tensin
que aplicamos. En el mundo de la electrnica ocurre lo mismo, se
pasa de 0 a 5 voltios y con la informtica se hace, mediante un byte
de 0 a 255.
Con Arduino, se puede utilizar algo llamado, modulacin por ancho
de pulso (PWM), esto se consigue, mediante un A/D de 10bits, se
basa en la capacidad de Arduino para operar muy, muy rpido. En
lugar de controlar directamente la tensin procedente del pin,
Arduino cambiar el pin de encendido a apagado muy rpidamente.
Por ejemplo, si ponemos el PWM de Arduino al 50%, vemos una luz
tenue, debido a la persistencia de nuestros ojos que, no reaccionan
tan rpido como para ver que parpadea, la mitad del ciclo est
apagada y la otra mitad del ciclo est encendida.
El mismo principio, servir a nuestro propsito que, aplicando un
transistor, dotar de una mayor capacidad de carga, al pin de salida
que hayamos elegido, para manejar un motor, como podemos
comprobar con el ejemplo que muestro a continuacin.
Control Motor CC
CDIGO: SELECCIONAR TODO
//
// Funccion: CC_motor_control_pot
//
// Utilizar un potenciometro para controlar un motor
CC

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 2;
// potentiometer connected to analog pin 3
int val = 0; // variable to store the read
value

void setup()
{
pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop()
{
val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, val / 4); // analogRead values
go from 0 to 1023

// analogWrite values from 0 to 255
}
Como puede verse el cdigo utilizado es muy simple, lo que no deja
de tener calidad. El valor que entrega el potencimetro es dividido
por 4, tratando de establecer una relacin entre los valores ledos y
los valores de un byte, de un modo muy simple.
Ahora presento un cdigo algo ms elaborado, con el que se
obtiene un resultado algo ms preciso:
Motor CC pot
CDIGO: SELECCIONAR TODO
//
// Funcin: motor_cc_control_pot
//
// Uso de un potencimetro para controlar un motor
CC

int sensor_pin = 2;
int motor_pin = 9; // un pin digital PWM output

void setup() {
Serial.begin(9600);
pinMode(motor_pin, OUTPUT);
}

void loop() {
long pot_val, motor_speed;
pot_val = analogRead( sensor_pin );

motor_speed = pot_val*255.0/1024.0; // Incluir
decimales

/* Sutil: No utilice valores enteros cono 255 y 1024
aqu.
Compiladores parcos pre-calculan la division entera
del 255/1024 como cero.
*/

analogWrite( motor_pin, motor_speed);
}
Este es un ejemplo, nos permite el control del motor con muy pocos
cambios, hay que resaltar la conversin de los valores ledos del
potencimetro, en esta ocasin se establecen dos parmetros que
incluye punto decimal, esto se sugiere porque algunos compiladores,
suelen entregar cero, al calcular una divisin como 255/1024, por no
admitir decimales no declarados. Una vez ms puede copiar y pegar
en su editor preferido este cdigo y comprobar su efectividad.
Nota. No debemos olvidar que debido a la poca intensidad de las
salidas del Arduino, es necesario utilizar un transistor que nos
permitir una mayor corriente de salida, siempre que apliquemos
una alimentacin externa para completar la puesta en marcha.



En este tutorial, se ha tratado de dar una visin cuantitativa ms
que cualitativa, de las posibilidades que ofrece este sistema, en otros
se estudiarn temas ms especificos, donde se puede tratar en
profundidad cada caso.
Esto es todo, por este simple tutorial. Si tiene inters en leer ms
sobre Arduino, revele esta seccin. (Mostrar/Ocultar)


Volver al dice de artculos Arduino
http://hispavila.com/3ds/atmega/introduino.html