Principios de La Electronica y Arduino (Sergio) Español Español JM20352 Col

Gracias a todas las
publicaciones a las que he

podido acceder via web
Teoría Básica de la Corriente
Continua.
Creado por V. García.
Introducción.
Son muchas las páginas en la red que hablan de las resistencias y cómo
identificarlas por sus colores, todas muy buenas y con la misma información,
pero en muy pocas se encuentra el pilar de la electrónica, aquel enunciado
conocido por todo el mundo, en cambio, por unas u otras causas se olvida y
es que erróneamente damos por sentado que se conoce. Siempre puede
empezar por el principio, si le interesa le invitamos a que siga próximo enlace
de apuntes de la electricidad.
Hay muchos que nos piden que les indiquemos dónde han de buscar para
aprender los principios de la electrónica, por este motivo aquí se va a tratar
de documentar en parte estos principios y de esta forma aquellos, se inicien,
estamos seguros que será así.
Este es el principal motivo por el que nos propusimos crear esta página que,
creemos no pasará desapercibida, estamos convencidos que habrá muchos
visitantes que acudan a ella para tomar nota y a lo mejor, alguno, hasta
aprende algo sobre los fundamentos básicos de electrónica. Ya en la lección
9, se hizo un esbozo de los principios de la corriente eléctrica, en ella se dice:
Corriente eléctrica.
"He de mencionar aquí que, esta es la definición que recuerdo desde que
empecé mis estudios de electricidad y posteriormente electrónica, decía así:
- Cuando se mueven cargas eléctricas de un mismo signo, se
establece una corriente eléctrica. La corriente eléctrica, es el flujo
de electrones por los conductores eléctricos, por los cuales se
mueven fácilmente, debido a la diferencia de potencial creada por
un generador de corriente eléctrica.
Los generadores eléctricos son dispositivos en los que, a expensas
del consumo de energía mecánica, calorífica o química, se efectúa el
trabajo necesario para desplazar los electrones por un circuito
cerrado y ponerlos en movimiento, venciendo la resistencia que el
generador y conductores oponen a su paso.
La corriente eléctrica se definió por un flujo de electrones positivos y
se fijo un sentido convencional de circulación de la corriente, desde
el polo positivo al negativo, posteriormente se observó que, en los
metales los portadores de cargas negativas son electrones, los
cuales fluyen en sentido contrario al convencional. -
En el Sistema Internacional, la unidad de intensidad (I) de la corriente
eléctrica es el amperio, representado por el símbolo A y es la intensidad de
una corriente tal que hace fluir cada segundo un culombio. [Q = I x t]
Fuerza electromotriz.
Conocida como f. e. m. es el impulso que se desarrolla en los generadores
eléctricos, absorbiendo los electrones de un polo (+) y acumulándolos al otro
polo (-). La unidad de fuerza electromotriz es el voltio (V). Es la f. e. m. de un
generador que establezca una corriente de un amperio en un circuito cuya
resistencia total (interna del generador más la del circuito) (R) de un Ohmio,
se puede calcular por la conocida Ley de Ohm: V = I x R.
Se pueden distinguir dos tipos de electricidad, la electricidad estática y la
electricidad dinámica. La electricidad dinámica puede ser de corriente
continua (CC) o corriente alterna (CA).
Corriente Continua.
La Corriente Continua implica un flujo de carga que fluye siempre en una sola
dirección. Los electrones en el circuito se mueven siempre en la misma
dirección, del polo positivo al polo negativo. Si la corriente se mueve a
impulsos, siempre que lo haga en una sola dirección es Corriente Continua.
Corriente Alterna.
La Corriente Alterna se comporta como su nombre indica. El flujo de
electrones del circuito se desplazan primero en una dirección y luego en
sentido opuesto, de forma alterna. Esto se consigue alternando la polaridad
del voltaje del generador o alternador. La Corriente Alterna, se puede
transmitir a grandes distancias mediante elevadas tensiones que reducen las
pérdidas en los cables. "
Para una mejor descripción vamos a considerar una instalación eléctrica, así
pues, cuando ésta se pone en funcionamiento podemos decir que está
constituida al menos por un circuito cerrado, por el cual circula una corriente
que le permite su funcionamiento. Partiendo de este enunciado como luego
se verá, los circuito pueden estar formados por distintas ramas que por su
formación se dividen en circuitos serie, circuitos paralelo y a su vez pueden
estar formados por la combinación de ambos tipos combinados entre sí.
Todos los circuitos se rigen por unas reglas naturales a las que los hombre
les hemos dado el rango de leyes. Estas leyes se basan en la llamada Ley de
Ohm que es quien la descubrió, de esta Ley se derivan todas las demás y
estas leyes son las que, nos permiten conocer anticipadamente los resultados
que se prevén dándolos por buenos, en otros casos se encargan de evitarnos
largos procesos que no llevarían a ninguna parte, ya que con el calculo
desarrollado nos dicen la inviabilidad del proyecto. Y sin más dilación, vamos
a ocuparnos de los siguientes temas:
La Ley de Ohm
Circuitos serie
Circuitos paralelo
Circuitos mixtos
El shunt
Las Leyes de Kirchoff
Divisores de tensión
La Ley de Ohm
George Simon Ohm, descubrió en 1827 que la corriente en un circuito de
corriente continua varía directamente proporcional con la diferencia de
potencial, e inversamente proporcional con la resistencia del circuito. La ley
de Ohm, establece que la corriente eléctrica (I) en un conductor o circuito, es
igual a la diferencia de potencial (V) sobre el conductor (o circuito), dividido
por la resistencia (R) que opone al paso, él mismo. La ley de Ohm se aplica a
la totalidad de un circuito o a una parte o conductor del mismo.
I=V/R ;
V=IxR
En los circuitos de corriente continua, puede resolverse la relación entre la
corriente, voltaje, resistencia y potencia con la ayuda de un gráfico de
sectores, este diagrama ha sido uno de los más socorridos:
Fig. 01
En este grafico puede apreciarse que hay cuatro cuadrantes que

representan: V Voltaje, I Corriente, R Resistencia y W Potencia. De modo
que, conociendo la cantidad de dos cualesquiera, nos permite encontrar el
otro valor. Por ejemplo, si se tiene una resistencia de 1k y en sus extremos se
mide una tensión de 10 Voltios, entonces la corriente que fluye a través de la
resistencia será V/R = 0'01A o 10mA.
De forma similar, la potencia absorbida por esta resistencia será el cociente
de V2 / R = 0'1Wat o 100mWat, otra forma de hallar la potencia es con el
producto de V x I o sea, 10V x 0'01 = 0'1Wat, con esto se confirma lo dicho.
Polaridad de una tensión

Dependiendo del flujo de la corriente en un circuito, una tensión tendrá una
polaridad. Se establece que, el polo positivo en un circuito es el que
corresponde al punto del que fluye la corriente del generador. La dirección de
la corriente se indica con una flecha, como se muestra a continuación:
Fig. 02
Así, el lado de la resistencia dónde los flujos entran en la resistencia será el

polo positivo del voltaje, el polo negativo es donde los flujos salen hacia fuera.
Si la resistencia es de 5 Ω y la corriente es de 2 amperios, entonces el voltaje
o la diferencia de potencial sería 10 voltios.
En electrónica, es normal hablar sobre la diferencia de potencial (d.d.p.) con
referencia a un punto que normalmente es cero. Si este punto no fuera cero,
entonces su valor se indicaría claramente, pero por conveniencia, la mayoría
de los sistemas tienen una tierra común o masa que normalmente son ceros
voltios.
Los circuitos serie

La corriente en un circuito serie es absolutamente la misma en todos sus
puntos. Esto es fácil deducirlo al aplicar el principio de que la resistencia total
de un circuito es la suma de todas y cada una de las resistencias que lo
forman, dicho de otra forma, en el circuito que se muestra a continuación la
corriente que lo atraviesa es de 2 mA, para su comprobación partimos de
sumar las tres resistencias que lo forman, 2k Ω + 4k Ω + 6k Ω =12k Ω si la
tensión que aplicamos es de 24V, al aplicar la formula, encontramos que la
intensidad es de 0'002 A o sea, 2mA. Para el cálculo de la resistencia total en
un circuito serie se utiliza esta formula general: RT= R1 + R2 + R3...
Fig. 03
En este caso no hemos considerado la resistencia interna R i de la fuente de
corriente por ser muy pequeña, así como el decremento de la resistencia en
las resistencias con el calor provocado por el paso de la corriente, sin
embargo si esta Ri por cualquier circunstancia fuera más considerable, esto
podría manifestarse con un bajo rendimiento del circuito. Veremos un caso
concreto.
En el caso de una batería la cual presenta 12V al medir sus terminales y en
cambio al conectar al circuito la carga de una lámpara de coche (12V
100mA), no funciona y sin embargo no está fundida, al medir la corriente de
consumo observamos que es de tan sólo 0'05 A. Qué está ocurriendo. Un
técnico sospecharía de la carga de la batería y estando la lámpara conectada
pasaría a medir la tensión de la batería, obteniendo una lectura de 6V con un
consumo de 0'05A.
Dado que la lámpara no se enciende su filamento no se calienta y
consecuentemente su resistencia no varía (caso ideal), en estas condiciones
el cociente de la tensión de 6V por la corriente de 0'05A nos indica que la
resistencia de la lámpara es de 120Ω, lo esperado. La batería no está a plena
carga, con lo que la lámpara se encendería.
Otro ejemplo de ayuda con los cálculos. Dos lámparas que indican, 220V -
60W y 220V - 40W respectivamente se encuentran conectadas en serie a una
línea de 220V. Qué potencia se transforma en cada lámpara. Ver figura 04.
Fig. 04
Estos son los cálculos:
Fig. 05
Las pequeñas variaciones son debidas a las fracciones decimales
despreciadas.
Circuitos paralelos.
Los circuitos paralelos se caracterizan por estar formados por dispositivos
cuyas respectivas resistencias están en paralelo respecto a la tensión de
alimentación. La particularidad de un elemento que está en paralelo con otro
es que la tensión en ambos es la misma, en cambio la corriente total del
circuito es la suma de la corriente que atraviesa cada carga. Para calcular la
resistencia total de un circuito paralelo, la formula que utilizaremos es la que
sigue:
De esta formula como regla general se desprende que, la resistencia total

que ofrecen distintas cargas resistivas en un circuito paralelo, es siempre
menor que la resistencia de menor valor. La forma del circuito paralelo, se
aprecia en la figura 06, donde las resistencias pueden representar las cargas
de distintos elementos. Aplicando la regla general comentada a la figura 06, la
resistencia total será: 1'0909 k Ω.
Fig. 06
Un nuevo ejemplo puede aclarar más el tema. Entre los puntos A y B del
circuito siguiente se aplica una tensión de 12 V. Qué intensidad circulará por
el circuito, cual es la intensidad en cada resistencia y de qué potencia debe
ser cada resistencia.
Fig. 07
El calculo nos indica que la resistencia total es de 56'38 Ω y de este resultado
obtendremos la solución del resto. Así que, la intensidad que atraviesa R1
será el cociente de la tensión por la resistencia que será 0'1A, en R2 será de
0'066A y en R3 será de 0'046A, por lo tanto la corriente en el punto A o en el
B será la suma de estos, es decir 0'212A o sea 212 mA.
Hallar el consumo total, es fácil aplicando la formula adecuada. Si aplicamos
PT = I2 * R = 2'55W y si aplicamos PT = V * I = 2'54W como vemos en la
práctica es el mismo resultado. La potencia de R1 es de 1'2Wat, la de R2 es
de 0'792Wat y la de R3 es de 0'552Wat, al sumar estas potencias
encontramos la coincidencia con la potencia total de 2'544Wat.
Circuitos mixtos.
Estos circuitos son combinaciones del tipo serie y paralelo, su resolución
resulta ser un poco más laboriosa, sin embargo, el nivel de dificultad sigue
siendo el mismo. Para comprender mejor la dinámica a seguir pondremos un
ejemplo que nos ayude a comprenderlo mejor.
La propuesta es, con los datos presentados en la figura 08, queremos
conocer el valor de R1, la tensión E del Generador, la corriente total IT que
suministra al circuito y la PT.
Fig. 08
Cálculos:
Como siempre ayudándonos del gráfico del principio, vamos a dar solución al
problema planteado. Primero la tensión entre A-B será el producto entre R3 y
la corriente que la atraviesa 2A que, nos da 120V. V A-B = 120V.
La intensidad en R2, ahora es fácil de hallar, es el cociente de la tensión A-B y
su resistencia, esto es 1A. En cuanto a la corriente que fluye por R 1 es,
también el cociente del cuadrado de la tensión A-B y la potencia en R1=
360W, esto nos da para R1 = 40 Ω.
De aquí obtenemos la intensidad que la atraviesa, esto nos indica que la
intensidad en R1 es de 3A. Así podemos saber que, la corriente total del
circuito es de 6A que atraviesan a R4 y la tensión en sus extremos (B-C) será
de 54V. La potencia total se obtiene del producto de: PT =174 * 6
=1044W
La tensión del generador G, sabiendo que su resistencia interna es 1  , la
tensión en G es, V= 6 * 1 = 6V, que sumados a los 174 nos da 180V, en el
interior de G la tensión es 180 pero G tiene una resistencia interior de 1  así
al exterior sólo presenta los 174V.
Resistencia de absorción.
Cuando necesitamos conectar un equipo a un generador o fuente de tensión,
cuya tensión es mayor de la que exige el circuito, podemos poner una
resistencia en serie que reduzca la tensión de diferencia. Esta resistencia
toma el nombre de resistencia de absorción, su cálculo se lleva a cabo con
esta formula:
Ra =
Resistencia de
Vd - Vu absorción
Ra = ------------- Vd = Tensión
disponible
I Vu = Tensión útil
I = Corriente
necesaria
El shunt.
Es el acoplamiento de una resistencia a un galvanómetro, si llamamos R s a la
resistencia del shunt y Rg a la del galvanómetro, así como Is e Ig a las
intensidades del shunt y del galvanómetro respectivamente, entonces
evidentemente la intensidad total IT será:
I = Is + Ig ; y también
Is * Rs = Ig * Rg
En electricidad y electrónica es bastante corriente utilizar un 'shunt' que

consiste en una resistencia derivada que se agrega a un dispositivo de
medida para que la intensidad de la corriente que lo atraviesa sea menor que
la intensidad de línea. Sea r g la resistencia interna del galvanómetro, en
general y rs la del shunt, ver figura 09.
Fig. 09
Por definición se le denomina poder multiplicador m, a la relación entre la
intensidad de línea I y la intensidad ig de G y es la constante por la que hay
que multiplicar ig para obtener la intensidad de línea I.
I
m = ------- ; [1
ig ]
I = ig +
ix
que dividiendo por ig;

ix
m = 1+ ------ [
- 2]
ig
y teniendo en cuenta que la caída de tensión en ambas ramas es idéntica;
rg + ig = rs + ix
que igualando con la expresión [2],
rg
ix
----- = ----- =
[3]
m -1
rs
ig
rg
rs =-------- [4]
m-1
Esta última es la expresión de la resistencia del shunt en función de la
resistencia del galvanómetro y del poder multiplicador.
Así, en muchas ocasiones conviene utilizar un miliamperímetro o un

voltímetro para medir magnitudes eléctricas que requieren una escala más
alta que la que ofrece el instrumento. Para esto es necesario, como se ha
dicho, añadirle una resistencia. Al cociente del valor máximo de la nueva
escala dividido por el valor máximo de la escala primaria, es lo que se llama
factor de multiplicación como se obtiene en la formula [2].
[2
a]
La cual podemos recordar mejor con esta nueva formula [2a].
Resistencia de compensación.
En muchas ocasiones, ocurre que en medidas eléctricas hay que 'shuntar' un
miliamperímetro sin que varíe la resistencia intercalada en el circuito, evitando
de este modo que se falsee la lectura, para ello, se coloca en serie con el
galvanómetro y el shunt una resistencia Rx (resistencia de compensación), tal
que el nuevo conjunto presente una resistencia rg idéntica a la que
presentaba el galvanómetro sólo.
Fig. 10
rg * r s
--------- + RX =
rg
rg + rs
de donde;
[
5]
Shunt universal.
El shunt universal tiene la ventaja de presentar varios multiplicadores en el
mismo medidor, pudiendo elegir uno u otro según convenga. Su esquema
(utilizado en los amperímetros), se muestra a continuación:
Fig. 11
Veamos otro método con una evidente diferencia en la construcción. En esta
ocasión según se aprecia en la figura 06, siguiente todas las resistencias se
encuentran de algún modo sometidas al paso de la corriente, la cual dispone
de dos caminos para su recorrido, pero como siempre una imagen mejor que
...
Fig. 06
La corriente I (en la entrada de 500µA) recorre dos caminos, uno por 460µA y
por el otro 40µA, como se ve y hemos comentado. Para obtener más
información sobre los cálculos específicos recomendamos visitar la
documentación puentes de medida.
Las Leyes de Kirchoff

Las dos primeras leyes establecidas por Gustav R. Kirchhoff (1824-1887) son
indispensables para los cálculos de circuitos, estas leyes son:
1. La suma de las corrientes que entran, en un nudo o punto de unión de un
circuito es igual a la suma de las corrientes que salen de ese nudo. Si
asignamos el signo más (+) a las corrientes que entran en la unión, y el signo
menos (-) a las que salen de ella, entonces la ley establece que la suma
algebraica de las corrientes en un punto de unión es cero:
(suma algebraica de I) Σ I = 0 (en la unión)
2. Para todo conjunto de conductores que forman un circuito cerrado, se
verifica que la suma de las caídas de tensión en las resistencias que
constituyen la malla, es igual a la suma de las f.e.ms. intercaladas.
Considerando un aumento de potencial como positivo (+) y una caída de
potencial como negativo (-), la suma algebraica de las diferencias de
potenciales (tensiones, voltajes) en una malla cerrada es cero:
(suma algebraica de E) Σ E - Σ I*R = 0 (suma algebraica de
las caídas I*R, en la malla cerrada)
Como consecuencia de esto en la práctica para aplicar esta ley, supondremos
una dirección arbitraria para la corriente en cada rama. Así, en principio, el
extremo de la resistencia, por donde penetra la corriente, es positivo con
respecto al otro extremo. Si la solución para la corriente que se resuelva,
hace que queden invertidas las polaridades, es porque la supuesta dirección
de la corriente en esa rama, es la opuesta.
Por ejemplo:
Fig. 12
Las flechas representan la dirección del flujo de la corriente en el nudo. I1
entra a la unión, considerando que I2 e I3 salen. Si I1 fuera 20 A e I3 fuera 5 A,
I2 tendría 15 A, según la ley de voltaje de I1=I2 + I3. La ley de Kirchoff para los
voltajes es, la suma de voltajes alrededor de un circuito cerrado es igual a
cero. Esto también puede expresarse como la suma de voltajes de un circuito
cerrado es igual a la suma de voltajes de las fuentes de tensión:
Fig. 13
En la figura anterior, la suma de las caídas de voltaje en R1, R2 y R3 deben
ser igual a 10V o sea, 10V =V1+ V2+ V3. Aquí un ejemplo:
Fig. 14
Las corrientes de I2 e I3 y la resistencia desconocida R3 centran todos los

cálculos, usando la teoría básica de la corriente continua. La dirección del
flujo de la corriente está indicado por las flechas.
 El voltaje en el lado izquierdo (la resistencia R1 de 10 Ω), está

saliendo del terminal superior de la resistencia.
 La d. d. p. en esta resistencia R 1 es de I1 * R o sea, 5 voltios.
Esto está en oposición de los 15 voltios de la batería.
 Por la ley de kirchoff del voltaje, la d. d. p. por la resistencia
R2 de 10 Ω es así 15-5 o sea, 10 voltios.
 Usando la ley Ohm, la corriente a través de la resistencia R2
10 Ω es entonces (V/R) 1 amperio.
 Usando la ley de Kirchoff de la corriente y ahora conociendo
el I1 e I3, el I2 se encuentra como I3=I1+I2 por consiguiente el
amperaje de I2= 0.5A.
 De nuevo, usando la ley de Kirchoff del voltaje, la d. d. p. para
R3 puede calcularse como, 20 = I2*R3 +10. El voltaje por R3 (el
I2*R3) es entonces 10 voltios. El valor de R3 es (V/I) o 10/0.5 o
20Ω.
Otro ejemplo:
Supongamos que queremos saber la potencia de cada fuente de tensión y la
potencia que disipa cada resistencia en el siguiente circuito:
Para resolver el problema planteado en este circuito, debemos plantear las

ecuaciones de cuatro mallas como se muestra en la siguiente figura.
Para simplificar las ecuaciones en principio suprimimos las fuentes de

corriente.
Malla1: V1 + Im1*VR1 + Im1*VR2 + Im1/VR3 - Im2*VR3 = 0
Malla2: Im2*VR3 - Im1*VR3 + Im2*VR4 = 0
Malla3: Im3*VR4 - Im2*VR5 - Im4*VR5 + Im3*VR6 - Im4*VR6 = 0
Malla4: -V2 + Im*VR6 - Im3*VR6 - Im3*VR5 + Im4*VR7 + Im4*VR8 = 0
De donde:
Im1 = A12, Im2 = A1, Im4 = A2
A3 = Im1 - Im2, A4 = Im2 - Im3, A56 = Im3 - Im4
Planteadas las ecuaciones, podremos calcular sus variables y resolveremos
como ya es habitual en estos casos.
Los Divisores de corriente

La corriente que entra a un nodo sale dividida en dos partes, la corriente a
través de una rama sale como se muestra debajo:
Fig.14
para I1 y
para I2
Los Divisores de tensión.
Fig. 15
Puede calcularse el voltaje en R1 usando la ecuación:
Puede calcularse el voltaje en R2 usando la ecuación:

ARDUINO
Pinmode
Analogwrite(jumper,valor)
Digitalread(ledpin,High o low)
DigitalWrite(valor ej.potenciometro)
Project 1 - LEDS
01_Blink
Esquema en Fritzing
Abrimos Arduino y una vez dentro de el, pulsamos el boton OPEN (El que tiene
la flechita hacia
arriba), vamos al submenu DIGITAL y abrimos el ejemplo BLINK.
Codigo del ejemplo Blink de Arduino
int ledPin = 13; // LED conectado en el pin digital 13

// El Setup () solo se lee UNA vez (como en Processing).
void setup() {
pinMode(ledPin, OUTPUT); // Declaramos el pin donde tenemos el Led como SALIDA
}
// El Loop () se lee constantemente.
void loop () {
digitalWrite(ledPin, HIGH); // Encendemos el LED (HIGH → Le pasamos los 5 voltios)
delay(1000); // Esperamos 1000 milisegundos (1 seg)
digitalWrite(ledPin, LOW); // Apagamos el LED (LOW → Le pasamos 0 voltios)
delay(1000); // Esperamos 1000 milisegundos (1 seg)
}
El uso de Leds es muy util para monitorizar acciones y comprobar que

funcionan conexiones o
sensores. En este ejemplo, el LED solo tiene dos posiciones, o encendido o
apagado, ya que lo estamos
controlando con un pin DIGITAL (que solo admite esas dos posiciones). Sin
embargo, un LED puede
adoptar mas estados como veremos mas adelante.
TrAFFIC LIGHTS
We are now going to create a set of UK traffic lights
that will change from green to red, via amber, and
back again, after a set
length of time using the
4-state system. This
project could be used
on a model railway to
make a set of working

traffic lights or for a
childʼs toy town.
What you will need
Breadboard
Red Diffused LED
Yellow Diffused LED
Green Diffused LED
3 x 220Ω Resistors
Jumper Wires
Connect it up
This time we have connected 3 LEDʼs with the Anode
of each one going to Digital Pins 8, 9 and 10, via a
220Ω resistor each.
We have taken a jumper wire from Ground to the
Ground rail at the top of the breadboard and a ground
wire goes from the Cathode leg of each LED to the
common ground rail.
Enter the code
Enter the following code, check it and upload.
If youʼve read up on Projects 1 & 2 then this code will
be self explanatory as will the hardware.
In the next project, we are going add to this project by
including a set of pedestrian lights and adding a push
button to make the lights interactive.
/ / Proj ect 3 - T raf fi c Li g ht s

i nt l edD el ay = 10000; / / d elay i n b etween chang es
i nt redPi n = 10;
i nt yel l owPi n = 9;
i nt g reenPi n = 8;
voi d set up( ) {
pi nM ode( red Pi n, O UT PUT ) ;
pi nM ode( yell owPi n, O UT PUT ) ;
pi nM ode( g reenPi n, O UT PUT ) ;
}
voi d l oop( ) {
/ / t urn t he red li g ht on
di g it al W rit e( redPi n, H I GH ) ;
del ay(l edD el ay) ; / / wait 5 second s
di g it al W rit e( yel l owPi n, H I GH ) ; // t urn on yell ow
del ay( 2000) ; // wai t 2 second s
di g it al W rit e(g reenPi n, H I GH ) ; // t urn g reen on
di g it al W rit e( redPi n, L OW ) ; // t urn red of f
di g it al W rit e( yel l owPi n, L OW ) ; / / t urn yel l ow of f
del ay(l edD el ay) ; / / wait l ed D el ay m il li second s
di g it al W rit e( yel l owPi n, H I GH ) ; // t urn yell ow on
di g it al W rit e(g reenPi n, L O W) ; / / t urn g reen off
del ay( 2000) ; // wai t 2 second s
di g it al W rit e( yel l owPi n, L OW ) ; / / t urn yel l ow of f
/ / now our l oop repeat s
}
FADING
/*
Fade
This example shows how to fade an LED on pin 9

using the analogWrite() function.
This example code is in the public domain.
*/
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
void setup() {
// declare pin 9 to be an output:
pinMode(9, OUTPUT);
}
void loop() {
// set the brightness of pin 9:
analogWrite(9, brightness);
// change the brightness for next time through the loop:

brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:

if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
03_Coche Fantastico
Esquema en Fritzing
Codigo del ejemplo Arrays de Arduino
int timer = 100; // Variable para controlar el retardo del loop (100 milisegundos)
int ledPins[] = { 2, 3, 4, 5, 6, 7 }; // Array de los pines donde conectaremos los LEDs
int pinCount = 6; // Longitud de la Array
void setup() {
int thisPin; // Variable temporal
// La Array esta numerada desde 0 hasta (pinCount – 1), es decir de 0 a 5

// Usamos un bucle FOR para inicializar cada pin como SALIDA
for (int thisPin = 0; thisPin < pinCount; thisPin++) {
pinMode(ledPins[thisPin], OUTPUT);
}
}
void loop() {
/* Bucle FOR para ir encendiendo de uno en uno los leds. Funciona asi:
Para el PRIMER led...lo enciendo durante los milisegundos que he indicado con la variable
timer...y lo apago...enciendo el SEGUNDO led, etc...
*/

digitalWrite(ledPins[thisPin], HIGH);
delay(timer);
digitalWrite(ledPins[thisPin], LOW);
}
Para el ULTIMO led...lo enciendo durante los milisegundos que he indicado con la variable
timer...y lo apago...enciendo el PENULTIMO led, etc...
*/
for (int thisPin = pinCount - 1; thisPin >= 0; thisPin --) {

// Encendemos el LED
delay(timer);
// Apagamos el LED
}
}
Idem poetnciometro y arrays:
int potPin = 2; // varible jumper potenciomtro analoguica

int valor=0; // varaible valor pot
int timerMapeado;
//int timer = 60; // Variable para controlar el retardo del loop (100 milisegundos)
int ledPins[] = { 2, 3, 4, 5, 6, 7 }; // Array de los pines donde conectaremos los LEDs
int pinCount = 6; // Longitud de la Array
void setup() {
Serial.begin(9600);
int thisPin; // Variable temporal
// La Array esta numerada desde 0 hasta (pinCount – 1), es decir de 0 a 5
// Usamos un bucle FOR para inicializar cada pin como SALIDA
pinMode(ledPins[thisPin], OUTPUT);
}
}
void loop() {
valor = analogRead(potPin);
timerMapeado = map(valor,0,1023,50,200);
Para el PRIMER led...lo enciendo durante los milisegundos que he indicado con la variable
timer...y lo apago...enciendo e l SEGUNDO led, etc...
*/
delay(timerMapeado);
// Serial.println(timerMapeado);
}
/* Bucle FOR para ir encendiendo de uno en un o los leds. Funciona asi:
Para el ULTIMO led...lo enciendo durante los milisegundos que he indicado con la variable
timer...y lo apago...enciendo el PENULTIMO led, etc...
*/
for (int thisPin = pinCount - 1; thisPin >= 0; thisPin --) {
// Encendemos el LED
delay(timerMapeado);
// Apagamos el LED
}
}
Fading
En este sencillo experimento vamos a provocar que un led se apague poco a
poco.
Una posible traduccion al español del "Fading" es "Desvanecimiento".
Codigo
int value = 0; // variable para conservar el valor actual
int ledpin = 9; // Led conectado al pin 9
void setup()
{
// Nada que configurar
}
void loop()
{
for(value = 0 ; value <= 255; value+=5) // Desvanecimiento del led desde el minimo al maximo
{
analogWrite(ledpin, value); // Configura un valor (rangeo desde 0 a 255)
delay(30); // Espera 30 milisegundos para ver el efecto
}
for(value = 255; value >=0; value -=5) // desvanecimiento desde el maximo al minimo
{
analogWrite( ledpin, value);
delay(30);
}
}
Pulsadores
Introducción
Que son los pulsadores. Pulsadores o interruptores, hay toneladas de ellos en su
casa. Un interruptor es un dispositivo simple con dos posiciones, EN y AP
(ENcendido y APagado). Una clase de interruptor que usted usa cada día es el
interruptor de la luz. Cuando conecta, dentro del interruptor, dos cables son unidos,
lo que permite fluir a la corriente que enciende la luz o la tostadora se caliente.
Cuando lo desconecta, los dos cables son desunidos y corta el flujo de la corriente.
Esto esta muy bien pero creo que esto no es lo que interesa aquí.
En definitiva, se trata de un mecanismo simple (los hay muy sofisticados),
constituido por un par de contactos eléctricos que se unen o separan por medios
mecánicos. En electricidad, los falsos contactos que se producen el ser utilizados
normalmente, en algunos casos produce una chispa debido a la corriente que
atraviesa los contactos, provocando que quemen en parte y ennegreciendo los
contactos eléctricos, lo que a la larga acaba deteriorando dichos contactos. La
chispa se produce siempre al separar los contactos (desconectar), en ocasiones
parece que también salta al conectarlos, eso es debido a los rebotes mecánicos que
se producen al cambiar de estado.
Esto que en electricidad se considera normal, en electrónica es un verdadero nido
de problemas, debido a dichos falsos contactos. Por su propia naturaleza, al
cambiar de posición un interruptor, los contactos chocan entre sí y esto significa una
serie de falsos contactos que se reproducen de un modo sin control, por lo que se
generan los temidos rebotes (debounce en inglés), estos rebotes, se producen
incluso cuando unimos dos cables desnudos, simulando un interruptor o pulsador.
Pulsadores.
Estos pequeños pulsadores son un 1/4 " por cada lado, son bastante económicos
y se pueden 'pinchar' directamente en una placa de prototipado. Estos dispositivos
mecánicos tienen 4 patillas, que pueden hacernos pensar que hay 4 cables que son
EN y AP, pero de hecho, dos de cada lado en realidad dentro están unidos. Por
tanto realmente, este pulsador es solamente un pulsador de 2 cables.
Como digo, en electrónica los rebotes suelen fastidiar a los intrépidos recién
iniciados que creen en la teoría y sin embargo se salta este punto en muchas
ocasiones, lo que les lleva a recordar la importancia que tiene el antirrebote.
Resistencias de polarización.
Cuando nos de desenvolvemos en el entorno de los microcontroladores, nos
encontramos con un término poco común, me refiero a la polarización de una E/S,
debemos saber que hay dos tipos de polarización, polarización alta la resistencia va
conectada a + (5V) (término inglés Pullup) o polarización baja la resistencia va
conectada a masa - (0V) (término inglés Pulldown). Siguen dos esquemas de estos
términos:
Resistencia polarización baja. Resistencia polarización alta.
Si disponemos los tres componentes del esquema para realizar el circuito que
representa, cada vez que se presione el pulsador, el LED irá a EN (encender) y al
ser liberado el pulsador el LED irá a AP (apagar).
El efecto de rebote mecánico que produce inevitablemente, el pulsador al ser

presionado o al soltarlo, no permite apreciar el parpadeo en este sencillo montaje,
debido a la velocidad con que se produce el parpadeo del LED, simplemente por
que es inapreciable por el ojo humano. El ojo humano tiene una persistencia de
alrededor de 0'1 de segundo. Vamos a seguir con otros ejemplos para ver este
efecto y como evitarlo.
Pulsador.
Vamos a hacer nuestra primera prueba de botón (pulsador) conectando un LED en
nuestra tarjeta Arduino. El símbolo del esquema para un pulsador de botón es algo
diferente que el mostrado. Prepare un LED rojo y una resistencia de 10K Ohms, así
como el pulsador de botón y construya un montaje del esquema en su tabla de
prototipado cerca del Arduino.
Ha llegado la hora de ponernos a programar, llegados aquí, deberíamos decidir

que tipo de entrada utilizar, analógica o digital. Para no demorar más el tema,
haremos la prueba con un pin digital, ya que se trata de un pulsador que presentará
1 o 0, lo conectamos a +5V a través de una resistencia y para mantener el consumo
del LED, lo conectamos con una resistencia (de 270 Ohm) para limitar su consumo
dentro de términos admisibles de las salidas de Arduino (sobre los 20mA).
Analizaremos el esquema, he elegido la RPB polarización a bajo (Pulldown), por
simular el efecto de un estado 0 (L) en descanso del pulsador, lo que en buena
lógica es 0, es apagado y lo que es 1, es encendido, del mismo modo, cuando
presione el pulsador irá a 1, el LED se encenderá, permaneciendo apagado a 0 el
resto del tiempo, ¡lógico!. El resto del circuito, no tiene demasiado interés.
El código.
En primer lugar, quiero recordar al lector que debe documentar sobre la marcha
los códigos, esto hará que no pierda tiempo posteriormente, cuando quiera reutilizar
alguna rutina de este listado, para no volver a escribir tanto código.
Como siempre, es buena costumbre darle un nombre al principio del archivo
dentro del mismo y una pequeña descripción de que hace o para que sirve, fecha de
creación, autor, etc. Así que empecemos.
Este es el listado del código que utilizaremos en esta ocasión, servirá para el caso.
Como se ve, es propiedad de Massimo Banzi (gracias). Copiar este código y
guardarlo con el nombre pulsador03.pde en la carpeta destino de vuestros ejemplos
o ejercicios, para comprobar su funcionamiento.
/* Pulsador y LED
*
* Detectar si el botón ha sido presionado o no y encender
* el LED en consecuencia.
*
* Basado en un código de: Massimo Banzi
*
*/
int inPin = 10; // pin del pulsador
void setup() // establecer la configuración de pines a usar.

{
Serial.begin(9600); // Inicializa el puerto serie a 9600 baudios
pinMode(inPin, INPUT); // Inicializa el pin 10 como entrada digital
}
void loop() // Lazo que se repite indefinidamente

{
Serial.print("Estado de l pulsador: "); // muestra el "Estado del pulsador: "
Serial.println(digitalRead(inPin)); // imprime el estado del (pulsador)
// y lo muestra en decimal (0/1)
delay (50); // toma un poco de tiempo.
}
Este es un código escueto, corto que, funciona, sin embargo prefiero un código
que 'diga más', algo más completo y didáctico, si es posible. Como el que sigue:
/* Pulsador
*
* Detectar si el botón ha sido presionado o no y encender
* el LED en consecuencia.
*
* Basado en un código de: Massimo Banzi
*
*/
int inPin = 10; // pin del pulsador

int ledPin = 2; // pin del LED
int value = 0; // valor que tomara el pulsador
void setup() // establecer la configuración de pines a usar.

{
Serial.begin(9600); // Inicializa el puerto serie a 9600 baudios
pinMode(inPin, INPUT); // Inicializa el pin 10 como entrada digital
pinMode(ledPin, OUTPUT); // Inicializa el pin 2 como salida digital
}
void loop() // Lazo que se repite indefinidamente

{
value = digitalRead(inPin); // Lee el valor de la entrada digital (pulsador)
Serial.print("Estado del pulsador: "); // muestra el "Estado del pulsador: "
Serial.print(value, DEC); // imprime el estado del (pulsador)
// y lo muestra en decimal (0/1)
digitalWrite(ledPin, value); // enciende el LED cuando el value es = 1.
}
Análisis.
Como se aprecia, las líneas están comentadas en su mayoría, tampoco es
necesario pasarse, aquí lo hago, para que se pueda entender por los no iniciados.
En primer lugar, se declaran las variables globales que, se usaran en cualquier
parte del programa, se designan los nombres que damos a los pines de E/S y a las
variables de estado o lo que se haya previsto como tal. Seguidamente, el módulo de
configuración de los pines como E/S y si utilizaremos el puerto serie para
comunicación que, utilizará el programa void setup(), siguen si hay las rutinas
generales, aquí esta su sitio, en otro caso, se llega al lazo principal que se ejecutará
sin descanso, estoy refiriéndome al módulo void loop(), con el que se da por
terminado el código.
voi d s e tu p( )
Tenemos que decirle a Arduino que ponga el pin que designamos para el
pulsador, como entrada. Esto es bastante fácil, empleando pinMode () para usar la
ENTRADA, para leer el pulsador o en su lugar de SALIDA para leer el el valor del
pin. Por cierto, el módulo void setup() sólo se leerá una vez, cuando se inicia o
reinicia la ejecución del programa.
Le ctu r a D i gi tal.
Podemos usar el nuevo procedimiento digitalRead (), que solamente toma como
entrada el pin a examinar. El procedimiento digitalRead () devuelve un resultado
cada vez que es leído. Dicho resultado es 0 (BAJO) o 1 (ALTO) dependiendo de lo
que vio cuando miró el voltaje del pin. En este caso, leemos el pin y luego pasamos
el resultado como una entrada a otro procedimiento, println (), por ejemplo.
Seguramente podríamos usar una variable para guardar el resultado de digitalRead
() y luego usar aquella variable como entrada al println () pero esto es mucho más
directo.
. . .
pinMode(switchpin, INPUT); // hace switchpin, pin de entrada.
pinMode(ledpin, OUTPUT); // hace ledpin, pin de salida.
. . .
. . .
Serial.println(digitalRead(switchpin)); // imprime el estado
del (pulsador)
. . .
El caso de la variable se verá más adelante.
value = digitalRead(inPin); // Lee el valor de la entrada digital
(pulsador)
Serial.print(value); // imprime el estado del (pulsador)
Es cr i tu r a Di gi tal .
Con el procedimiento DigitalWrite() pondremos el voltaje en un pin a ALTO 5V o a
BAJO masa 0V y luego usaremos DigitalRead() para preguntar si aquel pin es
ALTO o BAJO. Este procedimiento se usa normalmente como salida, mayormente
en el módulo void loop(), como tendremos ocasión de comprobar.
Compilar el código.
Utilizando el software, libre de Arduino. Copie y pegue el código del ejercicio, en la
zona habilitada para este fin. Conecte la tarjeta Arduino a su computadora (PC) y
pulse el icono (nº1) de Verify.
Iconos de Arduino.
Si todo va bien, el código saldrá bien, sin errores, a continuación pulse el icono de
Upload to I/O board (es el nº 6), esta vez también cargará el programa que acaba
de compilar en la memoria del Atmega (Arduino) y ahora, pulse el Serial Monitor
(nº 7) para ven en la parte inferior cómo se muestra el estado del pulsador.
Compilar el programa.
Cargar el programa en el Arduino.

Monitorear resultado
En el monitor, se aprecia que mientras no se presiona el pulsador, la salida es 0 y
cada vez que se presiona, al hacer contacto, se muestra un 1, lo que demuestra si
se ha presionado o no el pulsador.
Verifique que cuando el botón es presionado, enciende el LED y cuando el botón
es liberado, el LEd se apaga. Si no le funciona, trate de usar declaraciones println
para eliminar fallos de su proyecto. Cuando usted aprieta el botón, hace que
imprima un mensaje. Así usted puede decir si la mitad de entrada funciona o si no
funciona la mitad de salida. Ahora puede guardar el archivo pulsando el icono (nº5)
-El mejor modo de destruir completamente un microcontrolador como Arduino es,
alimentarlo con voltajes demasiado altos. ¡Asegúrese que sus voltajes de entrada
están entre 0 y 5V! ¡Nunca conecte la batería 9V directamente en un pin de entrada,
esto freirá el pin y posiblemente destruirá al microcontrolador Arduino!
Ahora, desconecte el Arduino de su computador y cambie el sistema de
alimentación del Arduino, por medio de una pila de 9V, conecte dicha pila al Arduino
y ya puede presionar el botón. El LED debería encenderse cuando el pulsador es
presionado (la corriente es capaz de fluir) y vuelve a apagarse cuando se ha
liberado el pulsador (la corriente no es capaz de fluir), esto demuestra que el
Arduino una vez cargado el programa, puede funcionar de forma autónoma.
Si, ya se, el monitor tiene un 'problema' está mostrando continuamente la misma
respuesta "Estado del pulsador: 0" y sólo cambia a "Estado del pulsador: 1" en
el momento en que se presiona el pulsador y seguidamente se repite el "Estado del
pulsador: 0". Vaya, no es un grave problema, ya que todo funciona como se
esperaba, la salvedad de lo que muestra el monitor. Como no es un verdadero
problema no le daremos más importancia por el momento. El programa hace lo que
se esperaba.
El caso principal es que seguimos sin apreciar el tan mencionado rebote
(debuncing). En el próximo ejemplo veremos cómo se produce dicho efecto.
Tercer ejercicio.
En este momento, vamos a desarrollar el código que nos permita constatar el
efecto rebote. Para este fin, he aprovechado un código de un maestro en esta
materia como es H. Barragan, sólo he hecho unas pequeñas modificaciones para
que se aprecie con más detalle lo que ocurre al ejecutar el programa.
/*
Pulsador Conmutador
original: by BARRAGAN <http://barraganstudio.com>
El pin usado como entrada es conectado a un pulsador y el pin

usado como salida al LED. Cuando el pulsador es presionado,
parpadea el LED, el LED debería apagarse cuando el pulsador es
liberado.
Se puede ver el efecto rebote (debouncing)
Revisado 26 Julio 2009

por V. Garcia.
*/
int direction = 1; // usado para el ciclo de parpadeo

int switchPin = 8; // pin digital para unir el interruptor
int ledPin = 2; // pin para conectar el LED
void setup() {
Serial.begin(9600); // establece comunicacion serie
pinMode(switchPin, INPUT); // pone el pin digital 8 como la entrada
pinMode(ledPin, OUTPUT); // pone el pin digital 2 como la salida
}
void loop()
{
if(digitalRead(switchPin) == HIGH) // si el interruptor es presionado
{
direction *= -1; // alterna entre 1 o -1
if (direction == 1) // para decidir conectar o no la luz
{
digitalWrite(ledPin, HIGH); // conecta la luz
}
else
{
digitalWrite(ledPin, LOW); // desconecta la luz
}
Serial.print(direction);
delay(20); // espera 20 milliseconds
}
}
Aunque está bien comentado, describiré lo que hace el programa, sobre todo, en
el punto que más define el efecto rebote. El punto determinante del programa se
encuentra justo en la orden direction *= -1; , es la responsable de cambiar su
estado, en cada paso del programa por ese punto. Y esto se produce muy
velozmente (depende del reloj del micro). No se ha provocado nada nuevo, tan solo
se ha puesto de relieve el efecto que habitualmente ocurre con un contacto
mecánico.
Mantenga el pulsador presionado por un momento. Que ocurre. Que sucede. Que
el LED parece que parpadea, sólo lo parece, que va, realmente parpadea, dicen que
alguno no ha visto parpadear a nadie tan rápido ¡Un momento! Calma. Si, parpadea,
es lo que ocurre normalmente, cuando un contacto no se protege contra los rebotes.
Eso es lo que yo pretendía demostrar con tanto listado de código y aquí está.
Primero las variables:
// Aquí irán los #includes XXXXXX.h si se usan y la definición de
variables.

Seguido del módulo setup() para la configuración de los pines E/S implicados en
el programa y definir el puerto serie para la comunicación (definir el puerto serie, no
es siempre necesario) con el PC por ejemplo.
void setup() {
pinMode(switchPin, INPUT); // pone el pin digital 8 como la
entrada
}
Por cierto, cuando utilizamos los microcontroladores, en ocasiones podemos
utilizar la resistencia de polarización interna del pin indicado. Con esto, ahorramos
las resistencias de polarización externas que anteriormente se comentaron y su
comportamiento es idéntico. Este es un buen momento para utilizar esta posibilidad,
veamos cómo.
void setup()
{
pinMode(switchPin, INPUT);
digita lWrite(switchPin, HIGH); // conecta resistencia de polarización interna a alto (5V)
pinMode(ledPin, OUTPUT);
}
Si hubiera subrutinas en nuestro programa, se pondrían aquí, antes del siguiente
módulo. Como no es el caso, el módulo que sigue es el bucle void loop() que se
ejecutará continuamente.
La d e cl ar aci ón i f( )
Este escenario (sketch), introduce un tipo completamente nuevo y apasionante de
declaración. La declaración if. Esto es, una declaración lógica, que usted puede
recordar de su clase de matemáticas de escuela primaria. Básicamente, hasta
ahora hemos tenido al Arduino haciendo; solamente encienda; parpadear LEDs;
imprima mensajes; etc. Pero ahora queremos que además tome decisiones.
void loop()
{
{
{
Serial.print(" H:"); // muestra la H de Alto.
}
else
{
digitalWrite(ledPin, LOW); // desconecta la luz
Serial.print(" L:"); // muestra la L de Bajo.
}
}
}
La declaración if, es la primera declaración que es condicional, esta sólo controla
las declaraciones si una condición es verdadera. En este caso, las condiciones son
el "botón se ha presionado" o el "botón no es presionado".
Operadores de Comparación:
x == y (x es igual a y)
x != y (x no es igual a y)
x < y (x es menor que y)
x > y (x es mayor que y)
x <= y (x es menor o igual a y)
x >= y (x es mayor o igual a y)
En la primera línea del if, se compara el estado del pin de entrada perteneciente al
pulsador, para saber si se ha pulsado. Si se ha presionado, el estado del pulsador
será 1 (H) y por lo tanto se ejecutará lo que hay dentro del siguiente corchete "{ ....
}"
if(digitalRead(switchPin) == HIGH) // si el interruptor es
presionado
{
. . .
}
En cuyo caso, se conmunta el estado de la variable direction y se consulta si su
valor ahora es 1 (o -1).
if (direction == 1) // nueva comapración. Para
decidir conectar o no el LED
{
digitalWrite(ledPin, HIGH); // conecta el LED
Serial.print(" H:"); // muestra la H de Alto.
}
Si no, se ejecutará lo que sigue a else { , que puede ser lo contrario a la acción
anterior.
else
{
digitalWrite(ledPin, LOW); // desconecta el LED
Serial.print(" L:"); // muestra la L de Bajo.
}
En este caso, también añadimos una salida para el puerto serie que permita ver el
resultado de los dos estados posibles del pulsador.
Serial.print(direction); // imprime el contenido de la variable
'direction'.
Pruebe a comentar la línea delay y vuelva a compilar el código, luego modifique el

valor del paréntesis (expresado en milisegundos) y vuelva a compilar el código cada
vez, aprenderá de la importancia de este parámetro.
El programa de arriba, tal cual, demuestra que mientras se presiona el pulsador, el
LED se enciende e incluso parpadea, aunque la presión sobre el botón sea muy
rápida. Puede que si es muy rápido, a la vista no se aprecie, sin embargo, si
utilizamos el monitor del sistema Arduino, éste delatará el efecto rebote.
Procedamos, una vez cargado el programa en la placa de Arduino, pulse el icono 7
(corresponde al monitor), ahora, intente realizar una rápida presión del pulsador,
qué ocurre, en el monitor se ve, cada letra lleva su valor asociado, como se muestra
en la imagen siguiente.
Presencia de Rebote
Esto es lo que siempre trataremos de evitar. Imaginase por un momento que,
hemos construido de un reloj electrónico y ha llegado el esperado momento de su
puesta en hora. Qué ocurre si al realizar el programa no hemos previsto un sistema
antirrebote, cree usted que puede poner en hora el minutero o acaso el segundero,
sinceramente creo que le costaría incluso poner la hora actual sin más. Piense que
con cada pulsación, se produce un tren de impulsos (observe la imagen anterior)
que el contador del reloj interpretará como pulsos separados, de modo que será una
ardua tarea la puesta en hora.
Volvamos al tema que nos ocupa, vayamos a dar solución a nuestro problema. Si
usted ha hecho los cambios que le he sugerido, habrá notado que al comentar el
delay, aumentan exageradamente el número de rebotes, sin embargo, si aumentó el
valor del tiempo (dentro del paréntesis), por ejemplo, si subimos el valor a 200, se
observa que dejan de producirse rebotes, salvo que mantengamos presionado el
pulsador, cosa a todas luces, innecesaria.
/*
Pulsador Conmutador
original: by BARRAGAN <;http://barraganstudio.com>
El pin usado como entrada es conectado a un pulsador y el pin usado

como salida se conecta al LED. Cuando el pulsador es presionado,
parpadea e l LED, el LED debería apagarse cuando el pulsador es
liberado.
Se puede apreciar el efecto rebote (debouncing)
Revisado 26 Julio 2009

por V. Garcia.
*/

void setup() {
pinMode(switchPin, INPUT); // pone el pin digital 8 como la entrada
}
void loop() {

{
{
Serial.print(" H:");
}
else
{
digitalWrite(ledPin, LOW); // desco necta la luz
Serial.print(" L:");
}
}
A pesar de todo, no es esta la solución definitiva. Hemos de dar con una forma
que de ninguna manera se produzcan rebotes, o al menos que, no dependa de
condiciones circunstanciales dependientes del azahar.
CIRCUITO SIN REBOTES.

He encontrado la forma de evitar los rebotes, en cuanto he considerado cómo
encarar el problema. La solución pasa por leer el estado del botón cuando se
produce el borde ascendente de la tensión a extremos de los contactos del pulsador
e introducir inmediatamente la salida con ese estado, el resto de entradas (se llama
ruido) se inhiben o anulan mediante un lapsus de tiempo. Véase la imagen de
debajo para entender mejor lo dicho.
El lapsus de tiempo se puede variar para que no se lea más que el primer pulso
del tren de pulsos que se generan. Y este es el listado del código que cumple estos
parámetros. Puede copiar y pegar este código que sigue, en su software para
comprobar su efectividad.
/* conmutador.pde (switch)
*
* Cada vez el pin de entrada va de BAJO a ALTO (p.ej. debido a apretar un botón),
* el pin de salida es basculado de BAJO a ALTO o de ALTO a BAJO. Hay un
* retraso mínimo entre basculados para los rebotes del circuito.
* (no hacer caso del ruido).
*
* http://www.arduino.cc/en/Tutorial/Switch
*
* David A. Mellis
* 21 November 2006
*
* Modificado por V.Garcia 29072009 23:10H
*
*
* Funciona correctamente, emplea 2.442 bytes.
*
*/
int inPin = 8; // pin8 entrada

int outPin = 2; // pin2 salida
int previous = LOW; // lectura anterior del pinX de entrada
int state = LOW; // estado actual del pin de salida
int reading; // lectura actual del pin de entrada
// las sig uientes variables son largas por el tiempo medido en miliseconds,
// rápidamente se hará un número más grande que puede ser almacenado en un int.
long time = 0; // la ultima vez que el pin de salida fue basculado
long debounce = 500; // tiempo d e rebote, se aumenta si la salida parpadea
void setup() // Config. pines

{
pinMode(inPin, INPUT);
pinMode(outPin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
reading = digitalRead(inPin);
// si la entrada solamente fuera de BAJO a ALTO y hemos esperado bastante tiempo

// para que ningún ruido afecte al circuito, el pin de salida bascula y
// recuerda el tiempo
if (reading == HIGH && previous == LOW && millis()+100 - time > debounce) {
if (state == HIGH) {
state = LOW;
Serial.print(" Estado Pin: L "); // muestra estado actual de variable state
Serial.println(state);
time = millis();
}
else {
state = HIGH;
Serial.print(" Estado Pin: H "); // muestra estado actual de variable state
Serial.println(state);
time = millis();
}
}
digitalWrite(outPin, state);
previous = reading;
}
El listado del código está bastante comentado, sin embargo hago recordar que en
este listado hay una gran diferencia ante los listados anteriores, consiste en que si
usted mantiene presionado el pulsador, no se modifica nada en la salida. Si viera un
cambio, es debido a que ha cambiado el estado del pulsador, aunque sólo sea por
un inapreciable instante. Ver el resultado que muestra wl monitor.
NUEVO CIRCUITO SIN REBOTES.

Hemos visto un ejemplo que funciona bien basado en la lectura del borde (o
flanco) ascendente, es decir, el primer estado de ABAJO a ARRIBA. Seguidamente
se muestra un nuevo ejemplo que se basa en el borde descendiente, es decir, el
último estado de ARRIBA a ABAJO.
Puede copiar y pegar el siguiente listado del código y guardarlo como
conmutador_ab.pde, en su software para comprobar una vez más que funciona y
además que lo hace al soltar el pulsador.
/*
* conmutador sin rebote (debounced)
*
* Cada vez el pin de entrada va de ALTO a BAJO (p.ej. debido a
liberar un botón),
* el pin de salida es basculado de ALTO a BAJO o de BAJO a ALTO. Hay
un
* retraso mínimo entre basculados para los rebotes del circuito.
*
* 29/07/09
* Autor: V. Garcia
*/
int switchPin = 8; // switch se conecta al pin 8

int ledPin = 2; // el LED se conecta al pin 2
int val; // variable para lectura del estado del pin

int val2; // variable para leer el estado delayed/debounced
int botonStado; // variable para mantener el estado del botón
int lightMode = 0; // Esta la luz EN o AP
void setup() {
pinMode(switchPin, INPUT); // pone el pin switch como entrada
Serial.begin(9600); // Comunicación se rie puesta a 9600bps
botonStado = digitalRead(switchPin); // lee el estado inicial
}
void loop(){
val = digitalRead(switchPin); // lee el valor de entrada y almacénlo en val
delay(10); // 10 milisegundos son una cantidad de tie mpo buena
val2 = digitalRead(switchPin); // lea la entrada otra vez para comprobar saltos
if (val == val2) { // asegúrar que conseguimos 2 lecturas constantes
if (val != botonStado) { // el estado de botón ha cambiado!
if (val == LOW) { // compruebe si el botón es presionado
if (lightMode == 0) { // esta la luz AP?
lightMode = 1; // conecta la luz!
digitalWrite(ledPin, HIGH);
Serial.print("Estado: ");
Serial.println(lightMode);
} else {
lightMode = 0; // apaga la luz!
digitalWrite(ledPin, LOW);
Serial.print("Estado: ");
Serial.println(lightMode);
}
}
}
botonStado = val; // guardar el nuevo estado en la variable
}
}
Véase en la figura que sigue los resultados que se corresponden con lo que se
describe más arriba.
Sin rebotes
A D ESTA CA R.
Que podemos destacar en el procedimiento que se sigue para realizar el código
que evita los rebotes. Si observamos con atención el comportamiento del programa,
veremos que los cambios en la salida del pin #2, se producen justo en lo que se
llama, flanco de bajada o borde de bajada, es decir, no en el momento de la
conexión, si no en el momento de soltar o dejar de presionar.
Compruebe usted el efecto, presiones y mantenga presionado el pulsador, no ha
ocurrido nada, se ha cambiado el estado del LED, ahora, suelte el pulsador, en ese
momento se produce el cambio del LED, vuelva a realizar lo mismo y experimente
que los cambios se producen siempre al ser liberado el pulsador. Considero
probado la eliminación del efecto que se perseguía, el rebote o debounce.
Una vez comprobado que, el programa proporciona los resultados esperados,
puesto que no siempre se tienen que mostrar los resultados en el monitor, se puede
eliminar del código las referencias a la comunicación serie, dejando más compacto
el código.
El lector, nuevamente, con unos pocos cambios puede adaptar este listado a sus
proyectos.
Como siempre, comentarios, criticas y sugerencias para mejorar este artículo, son
bienvenidos y apreciados.
Project2- Led y Botón
Entrada digital
El pulsador es un componente que conecta dos puntos de un circuito cuando
es presionado. En este ejemplo, cuando pulsas el botón se enciende un LED.
Conectamos tres cables a la placa Arduino. El primero conecta una patilla del
pulsador, a través de una resistencia de carga (de 2k2), a la alimentación de
5V. El segundo, va desde la correspondiente patilla del pulsador a masa. Por
último, la tercera se conecta a una entrada/salida digital (en este caso al pin 7)
para leer el estado del botón.
Cuando el pulsador está abierto (sin pulsar), no hay conexión entre sus dos
patillas, por lo que el pin está conectado a los 5v (a través de la resistencia de
carga) por lo que leeremos un valor alto (HIGH).
Cuando el botón está cerrado (pulsado), realiza una conexión entre masa y el
pin, por lo que leeremos un nivel bajo (LOW). (El pin continúa conectado a 5
voltios, pero la resistencia entre ellos hace que el pin esté más cercano a
masa)
Ci r cu i to
Cód i g o
/* invert
* <http://www.arduino.cc/en/Tutorial/Invert>
*
* Enciende o apago un diodo emisor de luz (LED) conectado al pin digital 13,
* cuando se presiona un pulsador conectado al pin digital 7. Esto explica el
* concepto de activo a nivel bajo, que consiste en conectar botones usando
* una resistencia de carga de entre 1k y 10k.
*
*/
int ledPin = 13; // escoge el pin para el LED
int inPin = 7; // elige el pin de entrada (para el pulsador)
int val = 0; // variable para la lectura del estado del pin
void setup() {
pinMode(ledPin, OUTPUT); // configura el LED como salida
pinMode(inPin, INPUT); // y el pulsador como entrada
}
void loop(){
val = digitalRead(inPin); // lee el valor de entrada
if (val == HIGH) { // si la entrada está a nivel alto (botón sin pulsar)...
digita lWrite(ledPin, LOW); // apaga el LED
} else { // si está a nivel bajo (botón pulsado)...
digitalWrite(ledPin, HIGH); // enciende el LED
}
}
También puedes montar este circuito a la inversa, con un pulsador

"Normalmente Cerrado", que significa que el led estará conectado
constantmente hasta que se pulse el botón
Si desconecta el pin digital i/o, el LED parpadeará probablemente de forma

errática. Esto se debe a que la entrada es "flotante" - es decir, que más o
menos al azar, ya sea de retorno alta o baja. Por eso que usted necesita una
resistencia en el circuito.
Circuito
imagen desarollada usando Fritzing.
Esquema:
Código
int ledPin = 13; // Elegimos el pin al que está conectado el LED

int inPin = 2; // Elegimos el pin de entrada (El del pulsador)
int val = 0; // Declaramos una variable que almacenará el estado del pulsador
void setup() {
pinMode(ledPin, OUTPUT); // Declaramos el LED como Salida
pinMode(inPin, INPUT); // Declaramos el Pulsador como Entrada
}
void loop(){
val = digitalRead(inPin); // Leemos el valor de la entrada
if (val == HIGH) { // Si el valor es igual a HIGH (Botón no presionado)
digitalWrite(ledPin, LOW); // Apaga el led
} else { // Y si no
digitalWrite(ledPin, HIGH); // Enciende el led
}
}
Otro ejemplo:
APUNTES
A) La entrada analógica 0, se puede usar como entrada digital (la numero 14).
B) Activar la resistencia de pull-up de esta entrada y conectar el pulsador entre
esta entrada y GND.
C) El comando digitalRead(X) lee la tensión en la resistencia de pull-up de la
entrada X
D) He usado como salida la D13 porque ya tiene conectado un LED integrado
en la placa
EXPLICACIÓN DEL FUNCIONAMIENTO

Code:
int boton = 2;
int led = 13;
void setup(){
pinMode(boton, INPUT);
digitalWrite (boton, HIGH);
pinMode(led, OUTPUT);
digitalWrite(led, LOW);
Serial.begin(115200);
}
void loop(){
if(digitalRead(boton)==HIGH) {
digitalWrite(led,LOW);
} else {
digitalWrite(led,HIGH);
}
}
Project3- potenciometros
Potenciómetro
Descripción:
El potenciometro es un dispositivo electromecánico que consta de una

resistencia de valor fijo sobre la que se desplaza un contacto deslizante, el
cursor, que la divide eléctricamente. Como se muestra en el siguiente gráfico:
Vout=((R1/(R1+R2))*Vin (Aplicando la ley de Ohm)
Un potenciómetro es especificado por su resistencia total, R, entre los

terminales externos 1 y 3; El movimiento del cursor origina un cambio en la
resistencia medida entre el terminal central, 2, y uno cualquiera de los
extremos.
Este cambio de resistencia puede utilizarse para medir desplazamientos

lineales o angulares de una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensión.
Un potenciómetro también puede ser usado como una resistencia variable (o
reostato) de dos terminales, en ese caso, se cortocircuitan dos de las tres patas
del potenciómetro. Ejemplo:
Listado de componentes:
* 1 Potenciómetro de 1kΩ o 100k
* un par de cables.
Circuito:
Se conectan tres cables a la tarjeta Arduino. El primero va a tierra desde uno
de los terminales externos (1 o 3) del potenciómetro. El segundo va desde la
salida de 5 voltios hacia el otro termianl externo del potenciómetro. EL tercero
va desde la entrada analógica #2 hasta el terminal interno del potenciómetro.
Girando el dial o ajustando el potenciómetro, cambiamos el valor de la
resistencia variable. Esto produce oscilaciones dentro del rango de 5 y 0
voltios, que son capturados por la entrada analógica.
Código1:
/* Analog Read
* ------------------
*
* enciende y apaga un LED (light emitting diode) conectado al pin digital #13.
* La cantidad de tiempo que el LED parpadeará depende del
* valor obtenido mediante analogRead(). En este caso al pin analógico #2 se
* encuentra conectado un potenciómetro.
*
*
* Created 1 December 2005
* copyleft 2005 DojoDave <http://www.0j0.org>
* http://arduino.berlios.de
*
*/
int potPin = 2; // seleccionar el pin de entrada analógico para el potenciómetro
int ledPin = 13; // seleccionar el pin de salida digital para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
}
void loop() {
val = analogRead(potPin); // lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende LED
delay(val); // detiene el programa por un tiempo determinado por la variable
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo determinado por la variable
}
Código2:
// potenciometro y led
int potPin = 2;
int ledPin = 13;
int val = 0;
void setup(){
}
void loop() {
val = analogRead(potPin); //lee valor del sensor
val = val/4 ; //convierte de 0 -1023 to 0 -255
analogWrite(ledPin,val); //enciende ledpin
Código3:
Codigo del ejemplo 04_Sensor_Analogico_Potenciometro_SerialPrintln
int potPin = 0; // Potenciometro en el pin ANALOGICO 0

int ledPin = 9; // LED en el pin PWM 9 (los pines PWM permi ten pasar un rango como un
tren de pulsos PWM → Pulse Width Modulation)
int valor; // variable para almacenar el valor capturado desde el potenciometro
int valorMapeado; // variable para almacenar el valor mapeado
void setup() {
Serial.begin (9600); // Abrimos el puerto Serie de Arduino a una velocidad de 9600 baudios
pinMode(ledPin, OUTPUT); // Declaramos el LED como SALIDA
}
void loop () {
// Leemos analogicamente el potenciometro y lo guardamos en la variable valor
valor = analogRead(potPin);
// Mapeamos el valor de la variable valor entre el rango original del po tenciometro (0 →

1023) y lo
pasamos al rango del LED ( 0 → 255 como en la definicion de colores de Processing).
valorMapeado = map(valor,0,1023,0,255);
// Escribimos analogicamente el valorMapeado en el LED

analogWrite(ledPin,valorMapeado);
// Abrimos el Serial Monitor de Arduino y ahi podremos ver que valores le vamos pasando al
LED
Serial.println(valorMapeado);
}
En este ejemplo, vamos a empezar a ver como monitorizar operaciones o
eventos en Arduino,
gracias al Puerto Serie. Esta tecnica nos permitira, posteriormente mandar
datos o acciones a otros
programas como Processing, Grasshopper, Pure Data, Flash, o incluso a un
Iphone/ Ipad o similar … para
dotar de mayor interactividad a nuestra instalacion.
Project4- servos
Funcionamiento de los servomotores y control de estos sobre arduino.

BricoGeek.com!
Todo de una manera sencilla y gráfica para simplificar todo el proceso, siendo
sin duda un buen ejemplo para iniciarse en el uso de Arduino + Servomotores.
No me ha sido posible grabar ningun video para este tutorial, pues aun no
dispongo de un medio de grabación de calidad, pero pronto tendré uno, y
grabaré todo el proceso + pruebas de funcionamiento.
De momento os dejo este tutorial.
Antes de nada, mencionaré los elementos necesarios para completar este

tutorial, todos disponibles en la tienda:
-Arduino Duemilanove o Arduino Mega (El que se usará en este tutorial)
-Servomotor/es (En este caso he usado un servomotor miniaturizado, por su

reducido consumo de energia, apto para arduino)
-Cables M/M para conexión facil, fiable y flexible entre Arduino, ProtoBoard y
Servo, aunque recomiendo cojer el pack de 100, por un precio asequible y no
tener que andar estirando nunca mas (Pack de 100 cables premium M/M)
-Placa de protipado (Si no se dispone ya de una)
Si tenemos todo esto, es el momento de empezar a montar...
Pero antes un poco de teoria sobre servomotores.
La interfaz de conexión del servomotor consta normalmente de 3 cables o

conductores, generalmente de 3 colores distintos,a saber:
-Rojo (+)
-Marrón o Negro (-)
-Azul, Amarillo Naranja u otros (ctrl)
Donde por norma general el cable Rojo es el positivo o fase, el Marrón o Negro
es el tierra o masa, y el restante de varios posibles colores es el señal, que nos
permitirá controlar el servomotor con precisión.
Normalmente el señal de controla con PWM, osea pulsos de ancho modular,

con los que podemos mover con precisión el servomotor a cualquier punto de
su radio de ación.
Y como podemos provocar dichos pulsos?
Pues muy sencillo usando uno de los pines marcados como PWM en arduino.
Vamos pués a conectar nuestro servo con arduino:

Tal como se observa en el gráfico, se conecta el servo al positivo que nos da
arduino, y al GND también proporcionado por nuestro arduino, y por ultimo
conectamos el señal (amarillo) al pin numero 3, marcado como PWM.
Si mas o menos te has enterado de lo explicado ya estarás deduciendo como

va a funcionar :)
Ahora vamos crear un codigo que nos permita mover el servomotor, asi que
atentos:
#include <Servo.h>
Servo servo1; // Crea un Objeto servo

int posicion; // Variable de la posicion del servo
void setup()
{
servo1.attach(3); // Selecionamos el pin 3 como el pin de control para els ervo
}
void loop()
{
posicion = 150; // Establecemos el valor de la posicion a 150º

posicion = map(posicion, 0, 1023, 0, 179); // Establecemos la relacion entre los grados de g
iro y el PWM
/* Con el mapa de valores anterior establecemos una relacin proporcional */
/* entre el pulso minimo 0 con el grado minimo, 0 tambien y el pulso maximo*/
/* 1023 con el grado maximo, 179*/
servo1.write(posicion); // Escribimos la posicion con el mapa de valores al servo
delay(150); // Y le damos un tiempo para que sea capaz de moverse
}
Conectamos nuestro arduino al usb del pc, cargamos este programa con las
conexiones especificadas anteriormente y moveremos nuestro servo a la
posicion 150º
Ejemplo2 servo giro
Cambiamos como experimentación al pin 2 que no es pwm, perteneciente a
una placa Arduino Uno y le aplIcamos el programa para que gire de 10 a 170
grados:
int servoPin = 2; // servo conectado al pin digital 2

int myAngle; // ángulo del servo de 0 -180
int pulseWidth; // anchura del pulso para la func ión servoPulse
void setup()
{
pinMode(servoPin, OUTPUT); // configura pin 2 como salida
}
void servoPulse(int servoPin, int myAngle)
{
pulseWidth = (myAngle * 10) + 600; // determina retardo
digitalWrite(servoPin, HIGH); // activa el servo
delayMicroseconds(pulseWidth); // pausa
digitalWrite(servoPin, LOW); // desactiva el servo
delay(20); // retardo de refresco
}
void loop()
{
// el servo inicia su recorrido en 10º y gira hasta 170º
for (myAngle=10; myAngle<=170; myAngle++)
{
servoPulse(servoPin, myAngle);
}
// el servo vuelve desde 170º hasta 10º
for (myAngle=170; myAngle>=10; myAngle --)
{
servoPulse(servoPin, myAngle);
}
}
Ejemplo3 servo giro con potenciometro
Servo; potenciometro
http://www.youtube.com/watch?v=mOEF1mMKI-A
Servo conexión (+)(-) a la board (+-); conexión amarilla en conexión

digital9(pwm)
Potenciómetro conexión (+-) en mismo zona del borrad(+-), conexión verde en
conexión analog in 3, el voltaje varia entre 0 y 5v de esta forma es una señal
analógica.
#include <Servo.h>
Servo servo;
void setup ()
{
servo.attach (9); //pin de conexion digital servo
void loop ()
{
int val = analogRead(3); //pin conexion analogica potenciometro valor
val = map(val,0,1023,0,179); //reglade3 0 es 0 como 1023 es a 179
servo.write (val);
delay(15);
}
Otro que realiza movimiento del servo al intervalo que adoptemos, depende de
la calidad del mismo.
#include <Servo.h>
Servo myservo; // creamos un objeto servo para controlar nuestro servo
float pos = 90; // variable para almacenar la posición del servo
void setup()
{
myservo.attach(7); // attaches the servo on pin 9 to the servo object
}
void loop()
{
for(pos = 90; pos < 1 10; pos +=.05) // avanza de 0 a 180 grados
{ // en saltos de un grado
myservo.write(pos); // mueve a la posición de la variable 'pos'
delay(800); // espera 15ms
}
for(pos = 1 10; pos>=90; pos -=.05) // va de 180 a 0 grados
{
myservo.write(pos);
delay(800);
}
}
Project4- servos
continous
Funcionan todos los ejemplos ok
http://dukevisualstudies.org/lastmiles/?p=11
So there's a presentation on controlling a basic servo at ITP on the very

subject: class 3 (communication, servos, and pwm). As luck would have
it, I have a continuous rotation servo, which functions a bit differently than
the servo described in the presentation. In short, both types of servos use
pulse width modulation (PWM) but the continuous rotation servo operates
in terms of a "set point" and left and right rotation. You can also control
speed.
UPDATE 2008-8-3: We ended up using "normal" (i.e. non-continuous)

servos. So things work a bit differently now.
The servo is pictured above. I found a pdf with specifications and Basic
Stamp code on Parallax's web site. From the instructions I figured out the
important numbers. The servo wants intervals of 20ms and pulse widths
of 1.5ms if it's going to do nothing. Widths greater than 1.5ms turn the
servo counterclockwise, widths lower than 1.5ms turn the servo
clockwise. When the servo is receiving 1.5ms width pulses, it's possible to
adjust the set point with a tiny Phillips screw driver.
Here's my translation of BASIC Stamp 1 code into Arduino. The code
should make the servo stay still, rotate left, rotate right (and repeat).
Arduino
int servoPin = 7;
void setup()
{
pinMode(servoPin,OUTPUT);
}
void loop()
{
int temp;
for (temp = 0; temp <= 200; temp++)
{
digitalWrite(servoPin,HIGH);
delayMicroseconds(1500); // 1.5ms ajusta el se tpoint del screwdriver
digitalWrite(servoPin,LOW);
delay(20); // 20ms
}
{
delayMicroseconds(1800); // 1.8ms sentido antiagujas reloj
delay(20); // 20ms
}
{
delayMicroseconds(1200); // 1.2ms sentido agujas reloj
delay(20); // 20ms
}
}
That's it!
Otro ejemplo, pulsando teclado ‘a’ ‘s’ ‘spc’ izq dcha parada:
/*
* Serial Port Continuous Rotation Servo - Movement and Speed Control
* --------------
*
* Alteration of the control interface to use < and > keys
* to slew the servo horn left and right. Works best with
* the Linux/Mac terminal "screen" program.
*
* Adapted for Continuous Rotation Servo (Parallax)
* by Orfeus (for http://www.grobot.gr)
* v.200910211932
*
* For Serial Port Terminal on Windows I used PuTTY SSH Client
* ( freeware at http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html )
*
*
*
*
* Created 10 December 2007
* copyleft 2007 Brian D. Wendt
* http://principialabs.com/
*
* Adapted from code by Tom Igoe
* http://itp.nyu.edu/physcomp/Labs/Servo
*
*/
/** Adjust these values for your servo and setup, if necessary **/
int servoPin = 2; // control pin for servo motor
int minPulse = 1170; // maximum servo speed clockwise
int maxPulse = 1770; // maximum servo speed anticlockwise
int turnRate = 75; // servo turn rate increment (larger value, faster rate)
int refreshTime = 20; // time (ms) between pulses (50Hz)
/** The Arduino will calculate these values for you **/
int centerServo; // center servo position
int pulseWidth; // servo pulse width
int moveServo; // raw user input
long lastPulse = 0; // recorded time (ms) of the last pulse
void setup() {
pinMode(servoPin, OUTPUT); // Set servo pin as an output pin
centerServo = maxPulse - ((maxPulse - minPulse)/2);
pulseWidth = centerServo; // Give the servo a stop command
Serial.begin(9600);
Serial.println("Arduino Serial Continuous Rotation Servo Control");
Serial.println(" by Orfeus for GRobot.gr");
Serial.println(" Press < or > to move, spacebar to center");
Serial.println();
}
void loop() {
// wait for serial input
if (Serial.available() > 0) {
// read the incoming byte:
moveServo = Serial.read();
// ASCII '<' is 44, ASCII '>' is 46 (comma and period, really)

if (moveServo == 97) { pulseWidth = pulseWidth + turnRate; }
if (moveServo == 115) { pulseWidth = pulseWidth - turnRate; }
if (moveServo == 32) { pulseWidth = centerServo; }
// stop servo pulse at min and max

if (pulseWidth > maxPulse) { pulseWidth = maxPulse; }
if (pulseWidth < minPulse) { pulseW idth = minPulse; }
// Show me the keys I pressed

//Serial.print("Key pressed: ");
//Serial.println(moveServo);
//print pulseWidth back to the Serial Monitor (comment to undebug)

Serial.print("Pulse Width: ");
Serial.print(pulseWidth);
Serial.println("us");
}
// pulse the servo every 20 ms (refreshTime) with current pulseWidth

// this will hold the servo's rotation and speed till we told it to do something else.
if (millis() - lastPulse >= ref reshTime) {
digitalWrite(servoPin, HIGH); // start the pulse
delayMicroseconds(pulseWidth); // pulse width
digitalWrite(servoPin, LOW); // stop the pulse
lastPulse = millis(); // save the time of the last pulse
}
}
/* Orfeus 200910212001 */
Otro ejemplo, mueve acelerando y desacelerando:
/* mueve a izq y dcha aclerando y decelarando */
int servoPin = 7;
int fullCounter = 1200; // 1.2ms

int stopped = 1500; // 1.5ms
int fullClock = 1800; // 1.8ms
int dirInt = 1500; //stopped to start

int dir = 1; //add 1 ms per loop untill hitting 1800, then -1 until 1200
void setup()
{
}
void loop()
{
delayMicroseconds(dirInt);
delay(20); // 20ms
dirInt += dir;
if(dirInt >= fullClock)
{
dir = -1;
} else if(dirInt <= fullCounter) {
dir = 1;
}
+++++++++++++++++++++++++++++++++++
Otro ejemplo de momento : OK
Un servo normal tiene un potenciómetro que gira cuando lo hace el brazo

del servo y es la forma que tiene de leer la posición en la que está.
Si tu mandas un pulso de 1,5ms el girará hacia la posición en la que el
potenciómetro diga que está en el centro.
Los servos de rotación contínua no tienen ese potenciómetro o bien está
anulado, la única forma de que esté parado es mandando un pulso de
1,5ms; a medida que el pulso aumenta aumentará la velocidad hacia un
lado hasta que con 2.3ms de pulso (según marcas) tienes la velocidad
máxima. Y a 0.7ms la máxima velocidad hacia el otro.
Según esto con tu código debería arrancar el servo a la máxima

velocidad hacia un lado, luego ir bajando la velocidad, parar y después ir
aumentando la velocidad hacia el otro.
Si lo que tu quieres es que el servo se coloque en una posición fija lo que
necesitas es un servo de 180º normal.
Back to top
#include <Servo.h>
int servoPin = 2; // the number of the output pin for the servo
int ledPin = 5;
int angulo = 90; // Valor inicial del servo

int ampl = 900;
int pulso = 0;
long tiempo = 0;
void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output

pinMode(servoPin, OUTPUT);
digitalWrite(ledPin,LOW);
void loop()
{
/* lanzar los pulsos que el servo necesita para controlar su posición, teniendo en cuenta que:
* 90º = 1500us
* 180º = 1500us + ampl
* 0º = 1500us -ampl
*/
pulso = map(angulo,0,180,1500 -ampl,1500+ampl);
delayMicroseconds(pulso);
delay(20);
if ((millis() - tiempo) > 500)
{
angulo = angulo + 5;
tiempo = millis();
if (angulo > 180) {
angulo = 0;
}
}
}
EJEMPLO
Control Servo Rotacion Continua OK
Según el codigo deberia estar quieto (pulso de 1,5ms) y luego girar a los
dos lados. Pero hay un lado al que no gira (izquierda)
Lo conecto al Arduino en GND - +5v - PIN 7, y con el siguiente codigo:
int servoPin = 7;
void setup()
{
}
void loop()
{
int temp;
{
delayMicroseconds(1500); // 1.5ms
delay(20); // 20ms
}
{
delay(20); // 20ms
}
{
delay(20); // 20ms
}
}
Hay unas patitas especiales para esto, así además puedes liberar el
procesador mientras haces otras cosas, prueba el siguiente codigo:
Code:
#define SERVO_MOVEMENT <algun_pin_digital_pwm>
#define CENTER_RANGE 5
// Maneja el avance o retroceso, recibe la velocidad desde -100 a 100 porciento

void throttle(int power)
{
analogWrite(SERVO_MOVEMENT,(power>CENTER_RANGE || power< -CENTER_RANGE) ? map( -
power,-100,100,135,225):0);
}
Es un código utilizado para un pequeño robot, y un servo clásico de 360

grados. Center range es el valor del ajuste centro, como para detenerlo
(algunos servos no son muy precisos, depende del fabricante)
EJEMPLO código para mover motor con ponteciometro: ok
/* MOTOR 360 */
float potPin = 2; //entrada señal potenciometro analogica
int pwmPin = 3; //salida señal servo
int sensorValue;
float calibrate;
void setup() {
pinMode (pwmPin, OUTPUT);
}
void loop() {
sensorValue = analogRead(potPin);
calibrate = map(sensorValue,0,1024,120,240); /*ajustes de ancho pulso segun potenc */
analogWrite (pwmPin, calibrate); /* ancho de pulso segun la conversion analog a digital */
aa
bb
Cc
STEPPERS BIPOLAR
Circuit for Bipolar Stepper Motor

Two Pins
Four Pins
I build a step motor controller based on the schematics found on the Arduino
Web site. First I try the 2 pins one for bipolar stepper motor. I wont be able to
make it work, even less with the library available on the site. Maybe I’m dumb
and I really dont understand something, but this circuit keeps both coils active at
the same time.
So I tried the second circuit, the 4 pins one. With the same library I wasn’t able
to make it work either. So I create a piece of code of my own and I finally
managed to make the motor run correctly.
After that, I realize that I can merge the to circuits to possibly create a PWM
abled bipolar motor controller with the L297D. A somewhat bizzare idea, but I
think it’s possible if we can program the Arduino to send 4 synced PWM signals.
I’ll come back later (maybe never) with this thought. After some research I found
that the TI DRV8811 and the Allegro A3977 are much more appropriate chips to
do microstepping.
But for now, there is my circuit. It’s advantage is that it can release the coils.
Download the schematics (Fritzing format).
The two PNP transistors are connected like the circuit proposed on the Arduino
Web site. Plus, I use the enable pins. So my circuit needs four pins, and I don’t
found a way to use less.
Par ts li s t
 1 x Arduino
 1 x LD290 Quadruple Half H-Bridge
 2 x 1K Ohm Resistors
 2 x 10K Ohm Resistors
 2 x 2N2222 PnP Transistors
 1 x Bipolar Step Motor
There is the sequence to make the motor turn one direction, invert it to make it
turn the other.
Control sequence
CTRL A EN A CTRL B EN B
0 0 1 1
1 1 0 0
0 0 0 1
0 1 0 0
There is my code to control the stepper motor. Like you see in my code I use
direct port command to take less processor time. And I create a function called
in the main loop for each steps. This way the code can do something else when
the motor is running.
/*
St epper M ot or C ont roll er
b y Kevi n Fil t eau 2010 -05- 29
Pl aywit hm yl ed . com
*/
/ / M ot or cont rol l er pi ns.

# defi ne pi nM ot orC t rlA 4
# defi ne pi nM ot orC t rl B 7
# defi ne pi nM ot orE nA 5
# defi ne pi nM ot orE nB 6
/ / D i rect i on const ant s.

# defi ne GOL E FT 0
# defi ne GOR I GH T 1
/ / M ot or stat es and posi ti on.

b ool ean mot orR unni ng = fal se;
i nt mot orMax = 700;
i nt mot orPos = 0;
/ *** *** ** *** *** *** *** *** ** *** *** *** *** *** ** *** *
M O TO R
* *** *** ** *** *** *** *** *** *** ** *** *** *** *** *** ** /
/ / Set up t he m ot or.
voi d mot orSet up() {
pi nM ode( pi nM ot orC t rl A, O UT PUT ) ;
pi nM ode( pi nM ot orC t rl B , O UT PUT ) ;
pi nM ode( pi nM ot orE nA , O UT PUT ) ;
pi nM ode( pi nM ot orE nB , O UT PUT) ;
// E veryb od y t o L OW .
di g it al W rit e( pi nM ot orCt rlA , L OW ) ;
di g it al W rit e( pi nM ot orCt rlB , L O W) ;
di g it al W rit e( pi nM ot orE nA , L O W) ;
di g it al W rit e( pi nM ot orE nB, L O W ) ;
}
/ / Free t he m ot or.
voi d mot orFree( ) {
di g it al W rit e( pi nM ot orE nA , L O W) ;
di g it al W rit e( pi nM ot orE nB, LO W ) ;
}
/ / M ak e t he m ot or spi n one st ep i n t he di rect i on speci f i ed .

/ / Pi ns 7654 -- --
/ / B i nary 0000 0000
voi d mot orSpi n(b ool ean di r) {
st at i c i nt pos = 0; // St arti ng st ep pos.
i nt st epsSeq[ ] = {0xC 0, 0x 30, 0x40, 0x 20}; / / R eg i st ry val ue.

i nt st ;
// Timi ng
stat i c unsi g ned l ong previ ousM il li s;
l ong i nt erval = 3;
i f (m il li s( ) - previ ousMi ll i s > i nt erval ) {

previ ousM il li s = m ill i s() ;
st = st epsSeq[ pos] ;
i f ( d i r == GO LE FT ) {
pos++; if ( pos>3) pos=0;
m ot orPos++;
} el se {
pos- - ; i f( pos<0) pos=3;
m ot orPos -- ;
}
PO R TD &= 0x F;
PO R TD | = st ;
}
/ *** *** ** *** *** *** *** *** ** *** *** *** *** *** ** *** *
M AI N FUNC TI O N S.
* *** *** ** *** *** *** *** *** *** ** *** *** *** *** *** ** /
voi d set up( ) {
mot orSet up() ;
voi d l oop( ) {
mot orSpi n( GO LE FT ) ;
/ / m ot orSpi n( GOR I GH T ) ;
}
And to close this post. Some pictures of the prototype, the finalized circuit board
(useful for the pinout) and a video taken while testing the circuit.
DC motor control using Arduino and L293D
ReplyArduino, ElectronicsFebruary 27th, 2011shajir
We can drive dc motors using an Arduino and an L293D motor controller ic. We can
control two dc motors simultaneously.
The circuit diagram is as follows
The simple code for rotating the dc motor in one direction is as follows.
int ledPin1 = 8;
int ledPin2= 9;
void setup() {
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void loop()
{
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin3, LOW);
delay(5);
}
Arduino, Control, Dc Motor Control, Dc Motors, Direction, L293d, Motor

Controller, Void Setup
PaperStepper(L293D) es un driver de potencia para motores paso a paso
bipolares utilizando el chip L293D o el SN754410.
Entradas de control: 2 TTL (D1 y D2, NO PASO y DIR)
Salidas de potencia 4 (L1,L2,L3 y L4)
Tensión alimentación: 5v
Tensión máxima salida: 36v
Corriente máxima salida: L293D=> 600mA por salida (picos de 1200mA)
SN754410 => 1000mA por salida (picos de 2000mA)
Identificación del tipo de motor

El primer problema con el que nos encontramos al realizar proyectos con motores paso a paso, es
identificar el tipo de motor que tenemos (sobre todo si utilizamos motores de desguace).
Para saber si un motor es "paso a paso", realizaremos la comprobación siguiente: Giraremos con la
mano el eje del motor y deberemos notar que éste ejerce una resistencia al giro a golpes (o pasos).
Existen dos tipos de motores paso a paso: unipolares y bipolares. En los primeros la corriente circula
siempre en el mismo sentido por cada bobina, y en el segundo se alterna cambia el sentido de la
intensidad.
Un modo de identificarlos es contando el número de cables que tiene el motor:
4 cables (bipolar)
Necesariamente será bipolar. Para identificar los terminales, cojemos uno y con un tester medimos el
resto de terminales, si es infinito, pertenece a la otra bobina, y si nó es el otro terminal de la bobina.
6 cables (unipolar-bipolar)
Es probable que sea unipolar.

Para identificar los terminales, cojemos uno y con un tester medimos el resto de terminales, si es infinito,
pertenece a la otra bobina, si con dos cables nos da R es terminal central (5 ó 6). Si con los dos cables
restantes nos da R y 2R, puede ser el borne 1 o 2. Con las otras bobinas haremos lo mismo. De esta
forma tendremos identificados los terminales centrales de cada bobina y sus extremos, pero no podemos
distinguir los extremos. lo que haremos será utilizar el método de ensayo-error.
5 cables (unipolar-bipolar)
En este caso se han unido los terminales intermedios de las dos bobinas. El borne 5 es el único que mide
R con el resto de los cables, el resto de cables (con los que mide 2R) deberemos intercambiarlos en la
placa haste que el motor gire.
Para conectarlo deberemos unir los terminales 5 y 6 y si al conectarlo en la placa el motor no gira,
deberemos alternar los terminales 3 y 4.
NOTA: Una página muy buena sobre motores paso a paso es la siguiente: Tutorial sobre
motores paso a paso
Otra página muy interesante, con un simulación de funcionamiento de diferentes motores paso a paso y
con diferentes tipos de paso (una forma muy fácil de entender los micropasos) y control nos la ofrece
nanotec, una empresa alemana: http://de.nanotec.com/schrittmotor_animation.html
Aunque la página está en alemán, puedes ver una traducción en la imagen inferior. Elige el tipo de motor,
y elige una velocidad de demo.
Descripción
Para la realización de este proyecto nos basaremos en el circuito siguiente:
NOTA
Aunque en el esquema está representado el chip L239B, puedes utilizar el chip SN754410,
más potente y económico.
En este circuito vemos que con sólo 2 pines de control (D1 y D2) controlamos las 4 bobinas del motor
paso a paso (L1,L2,L3 y L4). Esto lo podemos hacer ya que para mover un motor paso a paso debemos
alimentar las bobinas en el orden siguiente:
En esta tabla vemos que los valores del devanado 2 es el invertido del 1 y que los del devanado 4 son los
invertidos del 3, por lo que si invertimos la señal del L1 obtenemos la señal de control necesaria para L2 y
de la misma manera si invertimos la señal de L3 obtendremos la señal de control de L4, con lo que la
tabla para poder mover el motor quedaría de la forma siguiente:
Esta inversión de señal la realizamos en el circuito utilizando 2 transistores Q1 y Q2, que cuando estan
activos (señal IN1 o IN4) derivan a masa las entradas IN2 o IN3 que están a positivo con las resistencia
Pull-Up R1 y R3.
Si utilizas Arduino, no es necesario que envies manualmente los pulsos a cada bobina del motor, tienes la
vida un poco más fácil, ya que dispone de la librería Stepper, que simplifica este proceso. (Tienes más
información en la sección de enlaces).
NOTA: Ten en cuenta que este este circuito necesita dos señales D1 y D2, que deben
activarse según la tabla anterior (o la librería Stepper en Arduino).
ESTE CIRCUITO NO FUNCIONA CON SEÑALES PASO y DIRECCIÓN.
Componentes
2 resistencias de 1K (~0,02x2=0,04€)
2 resistencias de 10K (~0,02x2=0,04€)
1 Zócalo de 16 patillas (0,3€)
1 CI L293D (2,7€) ó SN754410 (1,66€)
un trozo de placa de 11 filas por 14 agujeros. (0,8€)
Cables de colores (0,5€)
3 regletas CI de paso 2,54 (0,4x3=1,2€)
(En la entrada puedes soldar directamente los cables, y en la salida utilizar
una regleta típica de electricista)
El coste total es de unos 5,6€ (con el L293D) ó 4,5€ (con el SN754410)
NOTA
Precios orientativos y aproximados para que sepas si hablamos de millones de dolares o de
céntimos de euro, sin IVA y suministrados por Biltron - 2011
(No tengo nada que ver con Biltron, pero son muy majos les hago publicidad).
Realización
El método Paper consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y
soldadura.
Primero imprimiremos el documento PaperStepper(L293D) (disponible en la parte inferior de esta página

en el apartado de descargas):
Una vez impreso el documento, comprobaremos que la impresión se ha realizado a la escala correcta con
la ayuda de la regla impresa situada en el lateral izquierdo de la hoja. Al colocar a su lado un regla en
centímetros deberán coincidir las marcas.
Si quieres puedes proteger la paperetiqueta con un plástico transparente autoadhesivo:
Después recortamos la Paperetiqueta:

Necesitaremos cortar un trozo de placa de stripboard de 10 filas por 11 agujeros, lo podemos hacer con
un cutter.
Primero marcamos la zona a cortar
Con un cutter cortamos por la línea de agujeros
por ambos lados

NOTA
Si en vez de cortar una línea recta quieres cortar una esquina (como ves en la parte superior
derecha de la imagen anterior), deberás marcar con el cutter bastante por los dos lados.
Alineamos la línea a cortar con el canto de una superficie dura (borde de mesa)
y apretamos suvemente.
Y con una lija conseguimos unos cantos lisos:
Con lo que obtenemos la placa para montar.
NOTA
en la foto ves que he cortado la paperetiqueta un poco más grande que lo indicado para poder
ajustarla a la placa una vez encolada y corregir el descentramiento de los agujeros de la placa.
Ahora aplicaremos adhesivo a la paperetiqueta (suelo utilizar cinta de doble cara)

deberemos colocar la etiqueta sobre la placa. Para que coincidan los agujeros dibujados en la etiqueta
con los agujeros de la placa, utilizo una aguja como guía.
Con una aguja gruesa taladramos todos los agujeros de la paperetiqueta

Podemos comprobar al transluz que hemos taladrado todos los agujeros.
Soldamos los pines, zócalos, puentes y resistencias.

Deberemos prestar atención a los puentes (sobre todo a los que están debajo del zócalo).
El único componente con polaridad es el circuito integrado y los transistores, así que comprobaremos que
el zócalo tiene la zona con marca en la parte superior (como lo indica la paper-etiqueta).
Si no quieres utilizar bornas para soldar en circuito impreso, puedes utilizar una clema de electricista (más
baratas y fáciles de conseguir).
Una vez soldados todos los componentes, y fijándote en la imagen del documento impreso (lado pistas)
puedes cortar con un taladrín y una fresa fina las pistas indicadas (yo hago este paso una vez soldados
todos los elementos para poder tomar como referencia las patillas soldadas):
Y el resultado es ...
Funcionamiento
Si no has descargado y descomprimido el archivo PaperStepperXX.zip, ha llegado el momento de
hacerlo. Lo tienes disponible en el enlace inferior.
Deberás compilar e instalar en el Arduino (o Paperduino) el programa de ejemplo realizado por Tom Igoe
que tienes disponible en el archivo de descargas (/Sketches/PaperStepper2w.pde).
Deberás realizar el siguiente montaje:
NOTA
En mi caso como el motor es de 12v, utilizo una vieja fuente de alimentación de un PC para el
motor y el Arduino se alimenta a través de USB.
Otra posibilidad es alimentar el Arduino y el motor paso a paso con la fuente de Alimentación.
Dependiendo de tu motor, quizás puedas utilizar este circuito con un motor unipolar, como ves en la
imagen, los terminales intermedios de las bobinas (cables blanco y negro) están al aire.
El programa simplemente da un número de vueltas en un sentido, y en otro indefinidamente.
Debes modificar el valor de la linea:
#define motorSteps PASOSVUELTA, donde PASOSVUELTA indica el número de pasos que hay que
suministrar al motor para que el eje de una vuelta completa.
En mi caso al utilizar un motor de paso 3,75grados => 360/3,75=96.
También puede ser necesario que reduzcas la velocidad del motor si éste tiene mucha inercia, reduciendo
el valor de VELOCIDAD de la linea: myStepper.setSpeed(VELOCIDAD)
/*
Stepper Motor Controller
language: Wiring/Arduino
This program drives a unipolar or bipolar stepper motor.

The motor is attached to digital pins 8 and 9 of the Arduino.
The motor moves 100 steps in one direction, then 100 in the other.
Created 11 Mar. 2007

Modified 7 Apr. 2007
by Tom Igoe
*/
// define the pins that the motor is attached to. You can use
// any digital I/O pins.
#include < stepper.h >
#define motorSteps 96 // (360/3,75)change this depending on the number of steps

// per revolution of your motor
#define motorPin1 8
#define motorPin2 9
#define ledPin 13
// initialize of the Stepper library:

Stepper myStepper(motorSteps, motorPin1,motorPin2);
void setup() {
// set the motor speed at 60 RPMS:
myStepper.setSpeed(50);
// Initialize the Serial port:
Serial.begin(9600);
// set up the LED pin:

// blink the LED:
blink(3);
}
void loop() {
// Step forward 100 steps:
Serial.println("Forward");
myStepper.step(96);
delay(500);
// Step backward 100 steps:

Serial.println("Backward");
myStepper.step(-96);
delay(500);
// Blink the reset LED:

void blink(int howManyTimes) {
int i;
for (i=0; i< howManyTimes; i++) {
digitalWrite(ledPin, HIGH);
delay(200);
digitalWrite(ledPin, LOW);
delay(200);
}
}
Y el resultado con un motor bipolar es el siguiente:

Driving a Bipolar Stepper Motor with L293D or
SN754410 (no lo he intentado voy a utilizar
easydriver )
Aug 052010
For Arduino, Wiring and simular Microcontrollers.
Use the L293D Chip to drive a small Stepper Motor.

Use the SN754410 instead if you need higher current.
 Stepper Motor
 Power supply for motor
 L293D or SN754410 controller
 Arduino board, Wiring board or simular
 Prototyping board
 Connector wires
// Arduino Code:
// basic example just to understand what is happening
void setup () {
pinMode( 2 , OUTPUT ) ; // tell Arduino to use pin 2 as OUTPUT
}
void loop () {
// forward
digitalWrite ( 2 , HIGH ) ; // engage magnet on pin
digitalWrite ( 4 , LOW ) ; // disagle magnet on pin
digitalWrite ( 3 , LOW ) ;
delay ( 500 ) ; // wait for 500 milliseconds
digitalWrite ( 4 , HIGH ) ;
delay ( 500 ) ;
delay ( 500 ) ;
delay ( 500 ) ;
// backward
delay ( 500 ) ;
delay ( 500 ) ;
delay ( 500 ) ;
delay ( 500 ) ;
}
// Arduino Code:
// more advanced example
int stepperDelay = 500 ; // delay between steps

int stepperPin1 = 2 ; // arduino digital pin
int stepperPin3 = 3 ;
int stepperPos = 1 ; // magnet number active 1-4
// --------------------------------------------------
void setup () {
// tell Arduino to use pins as OUTPUT
pinMode( stepperPin1 , OUTPUT ) ;
}
// --------------------------------------------------
void loop () {
stepperMotor ( 10 ) ; // go 10 steps forward
stepperMotor ( -10 ) ; // go 10 steps backward
// additional stuff here
}
// --------------------------------------------------
void stepperMotor ( int stepsToGo ) {
for ( int count = 0 ; count < abs (stepsToGo) ; count ++ ) {
digitalWrite ( stepperPin1 , LOW ) ;
if ( stepperPos == 1) digitalWrite ( stepperPin1 , HIGH ) ;
delay ( stepperDelay ) ;
if ( stepsToGo < 0) stepperPos ++ ; else stepperPos -- ;
if (stepperPos > 4) stepperPos = 1 ;
if (stepperPos < 1) stepperPos = 4 ;
}
}
DC Motor Control Using an H-Bridge ok!
Over vi ew
In this tutorial, you'll learn how to control a DC motor's direction using an H-bridge.
To reverse a DC motor, you need to be able to reverse the direction of the current in the motor. The
easiest way to do this is using an H-bridge circuit. There are many different models and brands of H-
Bridge. This tutorial uses one of the most basic, a Texas Instruments L293NE or a Texas Instruments
SN754410.
If you simply want to turn a motor on and off, and don't need to reverse it, for example if you're controlling
a fan, try the tutorial on controlling high current loads with transistors.
Table of Contents (hide)
1. 1.Parts
2. 2.Prepare the breadboard
3. 3.Add a Digital Input (a switch)
4. 4.Find a motor
5. 5.Set up the H-bridge
6. 6.How your H-bridge works
7. 7.Connect the motor to the H-bridge
8. 8.Program the Microcontroller
9. 9.Get creative
Parts 1.
For this lab you'll need:
Solderless breadboard
22-AWG hookup wire

Arduino Microcontroller
module
Light Emiting Diodes, LED
10Kohm resistors
Switch
L293NE
or SN754410 H-bridge
12V DC power supply
DC Motor
Prepare the breadboard 2.
Connect power and ground on the breadboard to power and ground from the microcontroller. On the
Arduino module, use the 5V and any of the ground connections:
(Diagram made with Fritzing - download)
Add a Digital Input (a switch) 3.

Connect a switch to digital input 2 on the Arduino.
Find a motor 4.
Find yourself a DC motor that runs on low DC voltage within the range of 5 - 15V. RadioShack often sells
several small DC motors, the NYU Computer Store on occasion has small a few, the junk shelf is almost
always a goldmine for discarded motors and fans.Asking classmates and second years is another good
approach.
Solder leads to the motor's terminals. With DC motors, there is no polarity regarding the motor terminals so
you can connect it any way you'd like.
Optional: Consider testing your motor with a bench power supply from the equipment room. Ask a teacher
or resident if you need help setting one up. Begin by adjusting the voltage on the bench power supply and
observe its effects. Take note of its speed at different voltages without dipping to low or too high. Running
a motor at a voltage much lower or much higher than what it's rated for could potentially damage or
permanently destroy your motor. When the motor doesn't spin, the voltage is too low. When the motor runs
hot, or sounds like it's straining, the voltage is too high.
Set up the H -bridge 5.

L293NE H-bridge
This example uses an H-bridge integrated circuit, the Texas Instruments L293NE or Texas Instruments
SN754410. There is one in your Physical Computing Kit, and the NYU Computer Store and many
distributors such as Digikey, SparkFun, Mouser and Jameco sell them as well.
How your H -bridge works 6.
The L293NE/SN754410 is a very basic H-bridge. It has two bridges, one on the left side of the chip and
one on the right, and can control 2 motors. It can drive up to 1 amp of current, and operate between 4.5V
and 36V. The small DC motor you are using in this lab can run safely off a low voltage so this H-bridge will
work just fine.
The H-bridge has the following pins and features:
 Pin 1 (1,2EN) enables and disables our motor whether it is give HIGH or LOW
 Pin 2 (1A) is a logic pin for our motor (input is either HIGH or LOW)
 Pin 3 (1Y) is for one of the motor terminals
 Pin 4-5 are for ground
 Pin 6 (2Y) is for the other motor terminal
 Pin 7 (2A) is a logic pin for our motor (input is either HIGH or LOW)
 Pin 8 (VCC2) is the power supply for our motor, this should be given the rated voltage of your
motor
 Pin 9-11 are unconnected as you are only using one motor in this lab
 Pin 12-13 are for ground
 Pin 14-15 are unconnected
 Pin 16 (VCC1) is connected to 5V
Below is a diagram of the H-bridge and which pins do what in our example. Included with the diagram is a
truth table indicating how the motor will function according to the state of the logic pins (which are set by
our Arduino).
For this lab, the enable pin connects to a digital pin on your Arduino so you can send it either HIGH or
LOW and turn the motor ON or OFF. The motor logic pins also connected to designated digital pins on
your Arduino so you can send it HIGH and LOW to have the motor turn in one direction, or LOW and HIGH
to have it turn in the other direction. The motor supply voltage connects to the voltage source for the
motor, which is usually an external power supply. If your motor can run on 5V and less than 500mA, you
can use the Arduino's 5V output. Most motors require a higher voltage and higher current draw than this,
so you might need an external power supply.
Connect the motor to the H -bridge 7.

Connect the motor to the H-bridge as follows:
Or, if you are using an external power for Arduino, you can use Vin pin.
If you need an external power supply, y ou can use any DC power supply or battery from 9 - 15V as long
as your motor can run at that voltage, and as long as the supply can supply as much current as your motor
needs.
Plug an external DC power source into the Arduino's external power input. You may still leave your USB
cable plugged in for quick and easy reprogramming. Whichever motor you use, make sure the power
source is compatible (i.e. don't use a 9V battery for a 3V motor!). The external voltage input is available at
the Vin pin, so you can use it both to power the Arduino, and to power the motor.
If you find that your microcontroller is resetting whenever the motor turns on, add a capacitor across power
and ground close to the motor. The capacitor will smooth out the voltage dips that occur when the motor
turns on. This use of a capacitor is called a decoupling capacitor. Usually a 10 - 100uF capacitor will
work. The larger the cap, the more charge it can hold, but the longer it will take to release its charge.
Program the M icrocontroller 8.

Program the microcontroller to run the motor through the H-bridge:
const int switchPin = 2; // switch input
const int motor1Pin = 3; // H-bridge leg 1 (pin 2, 1A)
const int motor2Pin = 4; // H-bridge leg 2 (pin 7, 2A)
const int enablePin = 9; // H-bridge enable pin
const int ledPin = 13; // LED
void setup() {
// set the switch as an input:
// set all the other pins you're using as outputs:

pinMode(motor1Pin, OUTPUT);
pinMode(enablePin, OUTPUT);
// set enablePin high so that motor can turn on:

digitalWrite(enablePin, HIGH);
// blink the LED 3 times. This should happen only once.

// if you see the LED blink three times, it means that the module
// reset itself,. probably because the motor caused a brownout
// or a short.
blink(ledPin, 3, 100);
}
void loop() {
// if the switch is high, motor will turn on one direction:
if (digitalRead(switchPin) == HIGH) {
digitalWrite(motor1Pin, LOW); // set leg 1 of the H-bridge low
digitalWrite(motor2Pin, HIGH); // set leg 2 of the H-bridge high
}
// if the switch is low, motor will turn in the other direction:
else {
digitalWrite(motor1Pin, HIGH); // set leg 1 of the H-bridge high
digitalWrite(motor2Pin, LOW); // set leg 2 of the H-bridge low
}
}
/*
blinks an LED
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
int i = 0;
for ( i = 0; i < howManyTimes; i++) {
digitalWrite(whatPin, HIGH);
delay(milliSecs/2);
digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}
Once you've seen this code working, try modifying the speed of the motor using the analogWrite() function,
as explained in the Analog Lab. Use analogWrite() on pin 9, the enable pin of the motor, and see what
happens as you change the value of the analogWrite().
Get creative 9.
This is a suggestion for a possible project. You can do any project you wish as long as it demonstrates
your mastery of the lab exercises and good physical interaction.
Use your motor to make something move, vibrate, rise, fall, roll, creep, or whatever you can think of, in
response to user input from a digital input device (switch, floor sensor, tripwire, etc). Look inside moving
toys, you'll find a number of excellent motors and gears you can re-purpose. See the innards of a cymbal
monkey below as an example. Perhaps you can re-design the user interface to a toy, using the
microcontroller to mediate between new sensors on the toy and the motors of the toy. Whatever you build,
make sure it reacts in some way to human action.
Control el circuito integrado L293.
Hemos probado a utilizar un transistor a la salida de un pin de
Arduino y no hemos quedado satisfechos con los resultados. Cabe la
posibilidad de utilizar dos transistores en sendos pines, cada cual
conduciría un borne del motor, como diría, el motor entre dos pines,
pero no quiero perder más tiempo. Es el momento de utilizar el L293,
en una de las aplicaciones que vienen en las hojas de
especificaciones.
Además con el L293, no tiene que preocuparse por la regulación de
una tensión mayor, ya que permite dos fuentes de energía - una
fuente directa, hasta 36 V para los motores y otra de 5V, para
controlar el CI que, puede ser conectada a la fuente de alimentación
ya que el suministro de alimentación del motor proviene es
independiente. En el circuito de abajo, se supone una alimentación
superior para el motor. A continuación se puede ver la disposición de
las conexiones para el chip y el motor. La tabla de verdad muestra la
lógica de la salida.
El puente H, es normalmente un circuito eléctrico que permite aplicar

un voltaje a través de una carga en cualquier dirección a una salida,
por ejemplo, motor. Esto significa que esencialmente puede invertir la
dirección de la corriente y por lo tanto invertir la dirección del motor.
Lo único que a de recordar es que, la conexión a tierra debe ser
compartida, común para ambas fuentes.
En este circuito que sigue, no se trata más que de un control
bidireccional, por lo tanto, no se hace necesario el puente H, lo que
resulta más sencillo en todos los sentidos. Si nos fijamos en la tabla
de verdad que aparece arriba, quedan claras las opciones que nos
presenta, he de resaltar que la entrada EN (patilla 1), puede ser
definitoria.
Veamos cómo es esto, en cualquier momento. Si se aplica un 1 lógico
sobre A1, en la entrada A2, tenemos que aplicar un 0 lógico, esto
hará girar el motor en un sentido predeterminado. Para cambiar el
sentido de giro, y respetando las reglas de la mecánica, primero
pondremos A1 y A2 en un mismo estado lógico y acto seguido
invertiremos el estado inicial, es decir, A1 en 0 lógico y A2 en 1
lógico.
Con independencia del estado lógico de las entradas A1 y A2, si es
necesario detener el motor, simplemente enviamos un estado lógico
bajo (0) a la patilla EN y el motor se para de inmediato. En estas
condiciones no es posible mover el motor, no hasta que, a dicha
entrada EN, le enviemos un 1 lógico, en ese momento, podemos
decidir el sentido de giro o la parada del mismo con los valores
lógicos que apliquemos a las patillas A1 y A2. Aunque, lo esencial de
esta entrada EN, es que si aplicamos una salida PWM a ella,
simplemente podremos regular la velocidad del motor, esta es su
funcionalidad. Ver el esquema eléctrico.
Por seguridad, recomiendo que, conecte una fuente externa de
alimentación de corriente continua a la entrada de alimentación
externa de Arduino, así, puede alimentar el motor y el Arduino.
Además, puede dejar conectado el cable USB, para una fácil y rápida
reprogramación, si fuera necesaria. De esta forma, cualquiera que
sea el motor que utilice, se asegura que la fuente de alimentación es
compatible, naturalmente, no utilice un motor de 5V con una
alimentación de 12V.
El códi go.
La teoría es bastante sencilla. Se trata de poner, un estado lógico 1
en la entrada A1, al mismo tiempo que en la A2 ponemos un 0 lógico.
El código para este caso es sencillo, veamos un ejemplo:
Code:
/*
* motorpwmpot.pde
*
* Hace girar un motor de CC mediante un L293 conectado a los pines digitales
* 7 y 8 controlando la velocidad por PWM sobre el pin Enable del L293 en base
* a la lectura de un potenciometro conectado al pin analógico 2
*
* Basado en un código de: Miguel Grassi
* www.miguelgrassi.com.ar
*
* Modificado por: V. García el 07.02.2011
*
*/
int ledPin = 13; // LED conectado al pin digital 13
int pinA1 = 3; // entrada Motor A 1

int pinB1 = 4; // entrada Motor B 1
int pinEN1 = 9; // entrada EN 1
int pinPot = 2; // Lectura analógica del Potenciometro
int valorPot= 0;
int valorVeloc = 0;
void setup() { // Inicializa los pines de salida

pinMode( pinA1, OUTPUT);
pinMode( pinB1, OUTPUT);
pinMode(pinEN1, OUTPUT);
pinMode(pinPot, INPUT);
digitalWrite(pinEN1, HIGH); // linea es la clave, RPA
Serial.begin(9600);
// El LED parpadea 3 veces. Esto debería ocurrir sólo una vez.

// Si usted ve el parpadeo del LED tres veces, significa que
// se restablecio (reset) el propio módulo. Probablemente porque
// el motor provocó una bajada de voltaje o un corto.
}
void loop() {
digitalWrite( pinA1, HIGH); // Valores ALTO en A y BAJO en B simulaneamente
digitalWrite( pinB1, LOW); // hacen girar el motor 1 hacia ADELANTE
valorPot = analogRead(pinPot); // Lee el valor del potenciometro
valorVeloc = map(valorPot, 0, 1023, 55, 255); //Convierte un valor entre 0 y 1023 al rango 0 -
255
// valorVeloc = valorPot / 4 ; // segunda opción
analogWrite(pinEN1, valorVeloc);// y establece la velocidad del motor con ese valor
}
/* blinks an LED */
void blink(int whatPin, int cuantoTiempo, int milliSecs) {
for (int i = 0; i < cuantoTiempo; i++) {
delay(milliSecs/2);
delay(milliSecs/2);
}
}
El código está bastante bien descrito y no considero necesario entrar
en mayores detalles. Copie el código o si lo prefiere, bájelo de aquí
y cárguelo en el IDE, para comprobar su efectividad.
He realizado este ejemplo, utilizando un escudo para Arduino,
realizado con placa de tiras preformada, como se puede apreciar en
la imagen de abajo, el esquema utilizado corresponde a la imagen
anterior. Sigue una demo del resultado obtenido.
Vídeo.
http://hispavila.com/3ds/atmega/motorescc.html
El L293
El circuito integrado L293B, es un driver de 4 canales, capaz de
proporcionar una corriente de salida de hasta 1A por canal. Cada
canal, se puede controlar por señales de entrada compatibles TTL y
cada pareja de canales dispone de una señal de habilitación que
desconecta las salidas de los mismos.
Ahora, vamos a ocuparnos del código necesario para controlar un
motor de corriente continua con Arduino. He decidido probar una idea
para que los que tengan interés en hacer su primer mini robot,
empiecen con una experiencia que les anime y levante la moral.
La idea es que con un motor de juguete, movamos el eje delantero
de una pequeña caja, cualquier recinto pequeño nos puede servir, en
esta, tiene que alojar las cuatro pilas de 1'5V con su porta pilas, el
propio Arduino, el motor, el soporte del eje y una rueda de giro libre
en todas direcciones. Algo parecido a la imagen.
Las fotos, aunque corresponden a otro ejercicio (cosa que no es

relevante), dan una idea de lo que se describe. La práctica
demostrará cómo mover un objeto (bot-tarrina), con un sólo motor y
un interruptor del tipo 'bumper'. Cuando conectemos la tensión, el
Arduino mandará una señal al motor para que gire, por un tiempo, lo
que hará avanzar el pequeño robot. Cuando éste, encuentre un
obstáculo, lo detectará con el interruptor que tropezará con el objeto
estático, esto producirá una señal/orden en el programa, de modo
que el motor cambiará su dirección de giro por un tiempo
determinado, tras el cual volverá a girar en la dirección de inicio. Las
direcciones son mecánicamente, bastante aleatorias.
Sólo se trata de un ejemplo, de como manejar un pequeño robot con
un mínimo de componentes. El siguiente es el código que se encarga
de realizar estos cambio de desplazamiento. El código como se hace
notar, lo he adaptado a mis necesidades, con un pequeño cambio.
/* Control de un motor DC con puente H
* motorL293h.pde
*
* http://itp.nyu.edu/physcomp/Labs/DCMotorControl
*
* Modificado por V. Garcia el 08.02.2011
*
* Puede adaptarse a un bot con un motor en las ruedas de traccion
* y una rueda de giro libre que pivote cambiando la direccion
*
int switchPin = 2; // entrada del switch

int motor1Pin = 7; // pin 1 del L293
int motor2Pin = 8; // pin 2 del L293
int speedPin = 9; // pin enable del L293
int ledPin = 13; //LED
void setup() {
// pone el switch como una entrada
digitalWrite(switchPin, HIGH);
// pone todos los otros pines usados como salidas
pinMode(speedPin, OUTPUT);
// activa la RPA del pin speedPin para activar el motor

digitalWrite(speedPin, HIGH);
// El LED parpadea 3 veces. Esto debería ocurrir sólo una vez.

// Si usted ve el parpadeo del LED tres veces, significa que
// se restablecio (reset) el propio módulo. Probablemente porque
// el motor provocó una bajada de voltaje o un corto.
}
void loop() {
// si el switch es high, motor gira en una direccion
digitalWrite(motor1Pin, LOW); // pone motor1 del H -bridge low
digitalWrite(motor2Pin, HIGH); // pone motor2 del H -bridge high
}
// si el switch es low, motor gira en la otra direccion:

else {
digitalWrite(motor1Pin, HIGH); // set leg 1 of the H -bridg e high
digitalWrite(motor2Pin, LOW); // set leg 2 of the H -bridge low
blink(switchPin, 2000, 2); // si pulsas switch cambia giro un tiempo
}
}
/* blinks an LED */
void blink(int whatPin, int cuantoTiempo, int milliSecs) {
int i = 0;
for ( i = 0; i < cuantoTiempo; i++) {
delay(milliSecs/2);
delay(milliSecs/2);
}
}
En los ejercicios que se han desarrollado en este documento, aunque
hemos utilizado el circuito integrado L293, tan sólo se ha empleado
de los cuatro, un amplificador para manejar el motor o dos
amplificadores, uno para cada devanado del motor. La parte más
relevante de este circuito integrado, está en utilizar los cuatro
amplificadores de forma que se conoce como Puente-H.
Después de lo tratado hasta el momento, en este documento,

estamos preparados para comprender y emprender el montaje del
L293 en puente-H, para el control de un motor. Es cierto que el
control de motores, también se puede ejercer con un circuito
integrado como es el ULN2003 que integra una matriz de siete
transistores darlington, capaces de entregar hasta 500mA cada uno y
la versión ULN2803, con una matriz de ocho transistores darlington.
Este último, se utiliza en los casos que se tienen que controlar más
de un motor y sobre todo, con motores unipolares.
Los motores que hemos manejado hasta el momento son motores de
corriente continua (DC), en próximos artículos desarrollaremos
controles para motores paso a paso bipolares y unipolares. El control
de un motor unipolar, es más sencillo que el del motor bipolar, debido
a la manera de energizar los devanados.
Esto es todo, por este simple tutorial. Si tiene interés en leer más
sobre Arduino, revele esta sección.
L239D DC Motor Driver & Pin Configuration
Although I’ve only used 1 motor, it is possible to use 2 motors on a single L293D chip,
of course you then have to compensate on the current accordingly to ensure enough
juice for both motors under peak load. Remember that if you use 2 motors, the power
source will be the same voltage but the current needed will be doubled – a good start is
by altering how your batteries are connected in series or parallel.
“The L293D is a monolithic integrated, high voltage, high current, 4-channel driver.”
Basically this means using this chip you can use DC motors and power supplies of up to
36 Volts, thats some pretty big motors and the chip can supply a maximum current of
600mA per channel, the L293D chip is also what’s known as a type of H-Bridge. The
H-Bridge is typically an electrical circuit that enables a voltage to be applied across a
load in either direction to an output, e.g. motor.
This means you can essentially reverse the direction of current and thus reverse the
direction of the motor. It works by having 4 elements in the circuit commonly known as
corners: high side left, high side right, low side right, and low side left. By using
combinations of these you are able to start, stop and reverse the current. You could
make this circuit out of relays but its easier to use an IC – The L293D chip is pretty
much 2 H-Bridge circuits, 1 per side of the chip or 1 per motor.
The bit we really care about in all of this is the 2 input pins per motor that do this logic
and these, more importantly for our needs, can be controlled from the Arduino board.
You also don’t have to worry about voltage regulation so much because it allows for 2
power sources – 1 direct source, upto 36V for the motors and the other, 5V, to control
the IC which can be supplied from the Arduino power supply or since my motor power
supply is only 6V I’m going to use this (if the motor supply was higher I would consider
using a transistor or voltage regulator). The only thing to remember is that the
grounding connection must be shared/ common for both supplies. Below you can see
the pin layout for the chip and the truth table showing the output logic.
Pin 1 Pin 2 Pin 7 Function
High Low High Turn clockwise
High High Low Turn anti-clockwise
High Low Low Stop
High High High Stop
Low Not applicable Not applicable Stop
Generally speaking most DC motors require a lot more current than the Arduino board
can provide for instance the motor that I’m using needs around 5 to 6 Volts. Now I
could use a 12 Volt power source for the Arduino, but then its going to drain quickly
when it has to power everything, especially if I was to add in another motor and a
couple of servos, so instead my Arduino runs off of my 9 Volt power supply I made.
(here)
You’ll need a few capacitors in this circuit to smooth out the power load to the motors
as much as possible to help avoid any spikes and stabalise the current. I’m using a 50
Volt 10 uF capacitor on the power supply – I suggest you do this as the bare minimum.
You could also add in a capacitor for each motor that you use – something like a 220nF
multilayer ceramic capacitor should be OK for the small motors.
Arduino L293D Circuit Components

10K Ohm resistor (Brown, Black, Orange, Gold)
50V 10uF Capacitor
6V DC motor
L293D motor controller/ driver chip (IC)
A switch (push, toggle etc..)
Arduino Deumilanove w/ ATMEGA328
Breadboard / Prototyping board
Jumper/ Connector wires
4x AA battery holder
4x AA batteries
Optional 220nF multilayer ceramic capacitor (Y5V)
Optional 9V DC power supply or use the USB power for the Arduino
Building the L293D motor driver circuit

First lets start with the 16 pins on the L293D chip and what we need to wire these to.
You’ll see that its basically got 2 sides, 1 for each motor.
1. Enables and disables the motor whether it is on or off (high or low) comes from
the Arduino digital PWM pin 9
2. Logic pin for the motor (input is either high or low) goes to Arduino digital pin
4
3. Is for one of the motor terminals can be either +/-
4. Ground
5. Ground
6. Is for the other motor terminal
7. Logic pin for our motor (input is either high or low) goes to Arduino digital
PWM pin 3
8. Power supply for the motor, this should be given the rated voltage of your
motor, so mine is from a 6V supply
9. Enables and disables the 2nd motor on or off (high or low)
10. Logic pin for the 2nd motor (input is either high or low)
11. Is for one of the 2nd motor terminals can be either +/-
12. Ground
13. Ground
14. Is for the 2nd motors other terminal
15. Logic pin for the 2nd motor (input is either high or low)
16. Connected to +5V, in this case the power from motor supply
You can see from my photos how I’ve placed the L293D and wired it according to the
above pins. Next I have my switch on Arduino digital pin 2 and I have the GND pin
from Arduino connected to the GND rail on my breadboard. I also add the capacitor in
between the power supply – making sure that the negative and positive terminals are
correctly aligned. Finally I complete the circuit by adding in wires to carry the current
from one side of the breadboard to the other and I add in the motor and its power
supply.
Arduino L293D code original
So the final bit is to upload the sketch below to the board and give it a test
int switchPin = 2; // switch input

int motor1Pin1 = 3; // pin 2 on L293D
int enablePin = 9; // pin 1 on L293D
void setup() {
// set the switch as an input:
// set all the other pins you're using as outputs:
pinMode(motor1Pin1, OUTPUT);
// set enablePin high so that motor can turn on:
digitalWrite(enablePin, HIGH);
}
void loop() {
digitalWrite(motor1Pin1, LOW); // set pin 2 on L293D low
digitalWrite(motor1Pin2, HIGH); // set pin 7 on L293D high
}
// if the switch is l ow, motor will turn in the opposite direction:
else {
}
}
COMO FUENTE DE ALIMENTACIÓN SE PUEDE PONER UN CARGADOR
SONY ERICSSON CONVENCIONAL DE 5V EN LUGAR DE LAS PILAS
BB
CC
DD
EE
/*
* motordc potenciometro y boton cambia dirección
* Hace girar un motor de CC mediante un L293 conectado a los pines digitales
* 3 y 4 controlando la velocidad por PWM sobre el pin Enable del L293 en base
* a la lectura de un potenciometro conectado al pin analógico 2
*
* Basado en un código de: Miguel Grassi
* www.miguelgrassi.com.ar
*
* Modificado por: sergioc64 el 27.02.201 2
*
*/
int switchPin = 2; // pin digital ;botón cambia sentido

int enablePin = 9; // pin 1 on L293D
int pinPot = 2; //pin potenciometro
int valorPot= 0;
int valorVeloc = 150; //velocidad por defecto
void setup() {
Serial.begin(9600);
pinMode(switchPin, INPUT); // set the switch as an input:
pinMode(motor1Pin1, OUTPUT); // set all the other pins you're using as outputs:
digitalWrite(enablePin, HIGH);// set enablePin high so that motor can turn on:
pinMode(pinPot, INPUT);
}
void loop() {
digitalWrite(motor1Pin1, L OW); // set pin 2 on L293D low
analogWrite(enablePin, valorVeloc);// y establece la velocidad del motor con ese valor
Serial.println(valorVeloc);
}
// if the switch is low, motor will turn in the opposite direction:
else {
valorPot = analogRead(pinPot); // Lee el valor del potenciometro
valorVeloc = map(valorPot, 0, 1023, 55, 255); //Convierte un valor entre 0 y 1023 al rango
0-255
// valorVeloc = valorPot / 4 ; // segunda opción
analogWrite(enablePin, valorVeloc);// y establece la velocidad del motor con ese valor
Serial.print("switch low..");
delay(1000);
Serial.println(valorVeloc);
}
}
EasyDriver 4.2 Tutorial
(FUNCIONA)
Finally I had some time to do a tutorial on the Easydriver v4.2 board. The
following example code is just for demonstrating the board's new functionality. It
is was tested on a sparkfun stepper motor. You will notice in the code that each
time the step mode changes, so to does the delay time between steps and the
number of steps per revolution. The is not absolutely necessary but it helps you
compare the differences between stepping modes.
Make sure you have the serial monitor open in the Arduino IDE when running
this code. This will give you some feedback about the various modes of the
board as they switch on an off.
Note: For real world use I would recommend hard-wiring the MS1 and MS2 pins
to some switches to pull them high or low. This way you can free up some more
pins on your Arduino.
For a tutorial on how to use the Easydriver v3.1 check out this post
CODIGO: ok!
/ // /// /// // /// // /// /// // /// /// // /// // /// /// /// // /// /// // ///
/ / St epper M ot or sk ect h f or use wi th t he EasyD ri ver v4. 2 / /
/ // /// /// // /// // /// /// // /// /// // /// // /// /// /// // /// /// // ///
// D an Thom pson 2010

//
// Use t hi s cod e at your own ri sk.
//
// For all the prod uct d et ail s vi si t htt p:// www. schm al zhaus. com/ E asyD ri ver/
// For t he f ull t ut ori al vi sit htt p:/ / dant hom psonsb l og. bl og spot. com/
/ // /// E D _ v4 St ep M od e C hart // // //
// //
/ / M S1 M S2 R esol uti on //
/ / L L Full st ep ( 2 phase) / /
/ / H L H alf st ep //
/ / L H Q uart er st ep //
/ / H H E i ght h st ep //
// //
/ // /// /// // /// // /// /// // /// /// // /// /
i nt D IR = 3; / / PIN 3 = D IR
i nt STE P = 2; // PI N 2 = STE P
i nt M S1 = 13; // PI N 13 = M S
i nt M S2 = 9; // PI N 9 = M S2
i nt SLE EP = 12; // PIN 12 = SL P
voi d set up( ) {

Seri al .b eg i n( 9600) ; // open t he seri al connect ion at 9600b ps
pi nM ode( D IR , O UT PUT ) ; / / set pi n 3 t o out put
pi nM ode( ST E P, O UT PUT ) ; / / set pi n 2 t o out put
pi nM ode( M S1, O UT PUT ) ; // set pi n 13 t o out put
pi nM ode( M S2, O UT PUT ) ; // set pi n 9 t o out put
pi nM ode( SL EE P, O UT PUT ) ; // set pi n 12 t o output
}
voi d l oop( )
{
i nt modeT ype = 1; / / T hi s num b er i ncreases b y m ult i pl e of 2 each t hroug h t he whi l e
l oop..
// .. t o i d enti f y our st ep m od e t ype.
whil e ( mod eT ype<=8){ // l oops t he f oll owi ng bl ock of cod e 4 ti m es b ef ore repeati ng .
dig it alW rit e( DI R, L O W) ; / / Set t he d irect i on chang e L OW t o H I GH t o g o i n opposi t e
di rect i on
dig it alW rit e(M S1, M S1_ M OD E( m od eT ype) ) ; / / Set st at e of M S1 b ased on t he ret urned val ue f rom t he
M S1_M O DE () swi t ch st at em ent .
dig it alW rit e(M S2, M S2_ M OD E( m od eT ype) ) ; / / Set st at e of M S2 b ased on t he ret urned val ue f rom t he
M S2_M O DE () swi t ch st at em ent .
dig it alW rit e( SLE E P, H I GH) ; / / Set t he Sl eep m od e t o A WA KE.
i nt i = 0; // Set t he count er vari abl e.

whil e(i <(m od eT ype* 200)) // It erat e for 200, t hen 400, t hen 800, t hen 1600 st eps.
// T hen reset t o 200 and st art ag ai n.
{
dig it alW rit e( STE P, L OW ) ; / / T hi s LO W t o H I GH chang e i s what creat es t he. .
dig it alW rit e( STE P, H I GH ) ; // . ." Ri si ng E d g e" so t he easyd ri ver k nows t o when t o st ep.
delayMi crosecond s( 1600/ m od eT ype) ; / / T his d el ay ti m e d et ermi nes t he speed of t he st epper
mot or.
// D el ay short ens f rom 1600 t o 800 t o 400 t o 200 t hen reset s
i ++;
}
modeType = m od eT ype * 2; / / M ul ti pl y t he current m od eT ype val ue b y 2 and m ak e t he resul t
t he new val ue f or m od eT ype.
// T hi s wi ll m ak e t he m od eT ype vari abl e count 1, 2, 4, 8 each t i m e we pass
t houg h t he whi l e l oop.
del ay( 500) ;

}
di g it al W rit e( SLEE P, L O W) ; / / swit ch off t he power t o st epper
Seri al .pri nt( " SL EE PI N G. ." ) ;
del ay( 1000) ;
Seri al .pri nt( " z") ;
del ay( 1000) ;
del ay( 1000) ;
del ay( 1000) ;
Seri al .pri ntl n(" ") ;
di g it al W rit e( SLEE P, H I GH ) ;
Seri al .pri ntl n(" AW AKE !!!" ) ; / / Swit ch on t he powe r t o st epper
del ay( 1000) ;
}
i nt M S1_M OD E (i nt M S1_ St epM od e) { / / A funct i on t hat ret urns a H ig h or L ow st at e num b er for

M S1 pi n
swit ch(M S1_ St epM od e) { / / Swit ch stat em ent f or chang i ng t he M S1 pi n st at e
// D if f erent i nput st ates all owed are 1, 2, 4 or 8
case 1:
M S1_ St epM od e = 0;
Seri al .pri ntl n(" St ep M od e i s Full . .. ") ;
b reak ;
case 2:
Seri al .pri ntl n(" St ep M od e i s H al f. . ." ) ;
b reak ;
case 4:
Seri al .pri ntl n(" St ep M od e i s Q uart er. . ." ) ;
b reak ;
case 8:
Seri al .pri ntl n(" St ep M od e i s Ei g ht h. . ." ) ;
b reak ;
}
ret urn M S1_ St epM od e;
}
i nt M S2_M OD E (i nt M S2_ St epM od e) { / / A funct i on t hat ret urns a H ig h or L ow st at e num b er for

M S2 pi n
swit ch(M S2_ St epM od e) { / / Swit ch stat em ent f or chang i ng t he M S2 pi n st at e
// D if f erent i nput st ates all owed are 1, 2, 4 or 8
case 1:
b reak ;
case 2:
b reak ;
case 4:
b reak ;
case 8:
b reak ;
}
ret urn M S2_ St epM od e;
}
Imagenes:
.

Principios de La Electronica y Arduino (Sergio) Español Español JM20352 Col

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Principios de La Electronica y Arduino (Sergio) Español Español JM20352 Col

Cargado por

Copyright:

Formatos disponibles

Gracias a todas las

publicaciones a las que he

En este grafico puede apreciarse que hay cuatro cuadrantes que

Polaridad de una tensión

Así, el lado de la resistencia dónde los flujos entran en la resistencia será el

Los circuitos serie

De esta formula como regla general se desprende que, la resistencia total

En electricidad y electrónica es bastante corriente utilizar un 'shunt' que

que dividiendo por ig;

Así, en muchas ocasiones conviene utilizar un miliamperímetro o un

Las Leyes de Kirchoff

Las corrientes de I2 e I3 y la resistencia desconocida R3 centran todos los

 El voltaje en el lado izquierdo (la resistencia R1 de 10 Ω), está

Para resolver el problema planteado en este circuito, debemos plantear las

Para simplificar las ecuaciones en principio suprimimos las fuentes de

Los Divisores de corriente

Los Divisores de tensión.

Puede calcularse el voltaje en R2 usando la ecuación:

int ledPin = 13; // LED conectado en el pin digital 13

El uso de Leds es muy util para monitorizar acciones y comprobar que

make a set of working

/ / Proj ect 3 - T raf fi c Li g ht s

This example shows how to fade an LED on pin 9

This example code is in the public domain.

// change the brightness for next time through the loop:

// reverse the direction of the fading at the ends of the fade:

int ledPins[] = { 2, 3, 4, 5, 6, 7 }; // Array de los pines donde conectaremos los LEDs

int pinCount = 6; // Longitud de la Array

int thisPin; // Variable temporal

// La Array esta numerada desde 0 hasta (pinCount – 1), es decir de 0 a 5

for (int thisPin = 0; thisPin < pinCount; thisPin++) {

for (int thisPin = pinCount - 1; thisPin >= 0; thisPin --) {

int potPin = 2; // varible jumper potenciomtro analoguica

El efecto de rebote mecánico que produce inevitablemente, el pulsador al ser

Ha llegado la hora de ponernos a programar, llegados aquí, deberíamos decidir

int inPin = 10; // pin del pulsador

void setup() // establecer la configuración de pines a usar.

void loop() // Lazo que se repite indefinidamente

int inPin = 10; // pin del pulsador

void setup() // establecer la configuración de pines a usar.

void loop() // Lazo que se repite indefinidamente

Cargar el programa en el Arduino.

original: by BARRAGAN <http://barraganstudio.com>

El pin usado como entrada es conectado a un pulsador y el pin

Se puede ver el efecto rebote (debouncing)

Revisado 26 Julio 2009

int direction = 1; // usado para el ciclo de parpadeo

int direction = 1; // usado para el ciclo de parpadeo

Pruebe a comentar la línea delay y vuelva a compilar el código, luego modifique el

original: by BARRAGAN <;http://barraganstudio.com>

El pin usado como entrada es conectado a un pulsador y el pin usado

Se puede apreciar el efecto rebote (debouncing)

Revisado 26 Julio 2009

int direction = 1; // usado para el ciclo de parpadeo

if(digitalRead(switchPin) == HIGH) // si el interruptor es presionado

CIRCUITO SIN REBOTES.

int inPin = 8; // pin8 entrada

void setup() // Config. pines

// si la entrada solamente fuera de BAJO a ALTO y hemos esperado bastante tiempo

NUEVO CIRCUITO SIN REBOTES.

int switchPin = 8; // switch se conecta al pin 8

int val; // variable para lectura del estado del pin

int lightMode = 0; // Esta la luz EN o AP

También puedes montar este circuito a la inversa, con un pulsador