Tutorial y ejercicios de arduino.

http://arduino.cc/es/Reference/HomePage
Tutorial de Arduino UNO:
Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un
entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.
Por otro lado el software consiste en un entorno de desarrollo que implementa el lenguaje de
programación Processing/Wiring que se basa en C/C++.y el cargador de arranque (boot loader) que
corre en la placa.
Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, puede utilizarse
libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.
Entradas y Salidas
Cada uno de los 14 pines digitales del Arduino puede ser usado como entrada o salida digital, usando
funciones pinMode(), digitalWrite() y digitalRead() . Operan a 5 voltios. Cada pin puede proporcionar o
recibir un máximo de 40 mA y tiene una resistencia interna “pull-up” (desconectada por defecto) de 2050 KOhms. Además, algunos pines tienen funciones especiales:
Pines serie Rx y Tx : Sirven para recibir transmitir datos (TTL), están conectados al chip FTDI, el cual
hace conversion de USB a serie- TTL.
Interruptores externos: 2 y 3. Estos pines pueden ser configurados para disparar un interruptor en un
valor bajo, un margen creciente o decreciente, o un cambio de valor. Con la función attachInterrupt().
PWM: 3, 5, 6, 9, 10 y 11. Proporcionan salida PWM de 8 bits con la función analogWrite() .
I ²C: 4 (SDA) y 5 (SCL): El software Arduino incluye una librería Wire para simplifcar el uso del bus I
²C. Son buses para comunicarse con otros dispositivos. Soportan comunicación con libreria Wire. Esta
libreria se utiliza para comunicarse con elementos TWI (Two Wire Interfaces) que tienen mas velocidad.
SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan comunicación SPI, la cual,
aunque proporcionada por el hardware subyacente, no está actualmente incluida en el lengua je Arduino.
LED: 13. Hay un LED empotrado conectado al pin digital 13. Cuando el pin está a valor HIGH, el LED
está encendido, cuando el pin está a LOW, está apagado.
Tiene 6 entradas analógicas, cada una de las cuales proporciona 10 bits de resolución (por ejemplo
1024 valores diferentes). Por defecto miden 5 voltios desde tierra, aunque es posible cambiar el valor
más alto de su rango usando el pin ARF y algún código de bajo nivel. Además, algunos pines tienen
funcionalidad especializada:
AREF: Voltaje de referencia para las entradas analógicas. Usado con analogReference(). Es para
entradas analógicas. Nos permite dar a la placa un voltaje de referencia al suministrarle una alimentación
externa. si queremos medir el voltaje con un rango maximo de 3,3v, alimentariamos 3,3v en el pin
AREF con un regulador de voltaje IC. entonces el ADC representaria 3,22 mV.
http://littlebirdelectronics.com/products/voltage-regulator-33v.
Reset. Pone esta linea a LOW para resetear el microcontrolador. Típicamente usada para añadir un
botón de reset a dispositivos que bloquean a la placa principal.
Alimentación
Puede ser alimentado vía la conexión USB o con una fuente de alimentación externa. El origen de la
alimentación se selecciona automáticamente. Las fuentes de alimentación externas (no-USB) pueden ser
tanto un transformador o una batería. El transformador se puede conectar usando un conector jack
macho de 2.1mm con centro positivo en el conector hembra de la placa. Los cables de la batería puede
conectarse a los pines Gnd y Vin en los conectores de alimentación (POWER).
Los pines de alimentación son los siguientes:
-VIN. La entrada de voltaje a la placa Arduino cuando se esta usando una fuente externa de
alimentación (en opuesto a los 5 voltios de la conexión USB). Se puede proporcionar voltaje a través de
este pin.
-5V. La fuente de voltaje estabilizado usado para alimentar el microcontrolador y otros componentes de
la placa. Esta puede provenir de VIN a través de un regulador integrado en la placa, o proporcionada
directamente por el USB o otra fuente estabilizada de 5V.
-3V3. Una fuente de voltaje a 3.3 voltios generada en el chip FTDI integrado en la placa. La corriente
máxima soportada 50mA.
-GND. Pines de toma de tierra.
Arduno UNO
La Placa Arduno UNO tiene un micro controlador ATMEGA16U2-MU que utiliza como conversor
USB en vez del chip FTDI que utilizaban las antiguas placas. ademas tiene un procesador micro
controlador Atemega328, siendo mas rapida y optima que las antiguas Arduino Duemilanove y la
Diecimila con micro controlador Atemega168.
Instalación del Software Arduino
En Windows 7 instrucciones:
http://arduino.cc/en/Guide/Windows
http://www.dynamoelectronics.com/categoryblog/158-como-instalar-driver-arduino-uno.html
http://www.ajpdsoft.com/modules.php?name=News&file=article&sid=570
Drivers FTDI:
http://www.ftdichip.com/Drivers/VCP.htm
Entorno de Desarrollo
Arduino (Arduno Software)
para
El entorno de Desarrollo Arduino está constituido por un
editor de texto para escribir el código, un área de
mensajes, una consola de texto, una barra de
herramientas con botones para las funciones comunes, y
una serie de menús. Permite la conexión con el hardware
de Arduino para cargar los programas y comunicarse con
ellos.
Estructura de Programación
Por lo general un programa en Arduino constará de 3 partes:
1. Declaración de variables.
2. Función de inicialización. (setup)
3. Función de Loop. (Programa)
Declaración de Variables
Las variables son expresiones que almacenan valores, como las capturas o lecturas de los valores de
entrada de un pin analógico o sensor. Inicializas o das valor a una variable, haciéndola igual al valor que
quieres almacenar. Colocadas al principio del código pueden ser utilizadas en todo el programa.
Declaración de funciones
Las funciones te permiten crear piezas modulares de código, de forma que se puedan realizar ciertas
rutinas y retornar al área de código desde donde se realizó la llamada a la función. Colocadas al
principio del código pueden ser utilizadas en todo el programa.
Función de inicialización.
void setup() La función setup() es llamada justo en el momento en que el programa comienza. Se utiliza
para inicializar variables, definir los modos de entrada o salida de los pines, indicar librerías, etc.
Función de Loop. (Programa)
void loop() Después de crear la sección setup(), que inicializa y asigna los valores iniciales, la sección
loop() hace precisamente lo que su nombre indica en inglés(bucle), y se repite continuamente,
permitiendo que tu programa mute y responda. Se usa para controlar de forma activa la tarjeta Arduino.
El tiempo del bucle, varía según el número de instrucciones que contenga. Y se puede conocer y
controlar con las funciones de temporización (millis(), delay(), etc).
Arduino y Circuitos Basicos
1. Sensor de Luz con un LDR y Arduino
En arduino vamos a construir un Divisor de Voltaje para controlar el pulso de apagado y encendido de
un LED con un sensor LDR.
Un sensor de luz se compone de un LDR
como parte de un divisor de tensión resistivo.
Ejemplo:
Componentes:



1 LDR
1 Resistencia de 1kΩ
Un par de cables
Conexiones:
Programación:
En la variable val se almacenan los valores del LDR que al ser una “cantidad analógica” serán de 0 a
1023.
La Programación en Arduino es la siguiente:
//Analog Read_LDR_Print
int LightPin = 3; // selecciona el pin de entrada para el sensor de luz
int ledPin = 13; // selecciona el pin 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
Serial.begin(9600); // abre el puerto serie a 9600 bps
}
void loop() {
val = analogRead(LightPin);
// read the value from the sensor
digitalWrite(ledPin, HIGH); // enciende el LED
delay(val);
// detiene el programa por un tiempo
digitalWrite(ledPin, LOW);
// apaga el LED
delay(val);
// detiene el programa por un tiempo
int sensorValue = analogRead(A3); // lee el pin analogo 3
Serial.println(sensorValue); // imprime valores entre 0 y 1023 que recibe del pin
analogo 3
}
CÓPIA EL PROGRAMA EN EL ENTORNO ARDUINO, COMPÍLALO Y QUÉMALO (cárgalo en el
arduino)
Funciones de Programación:
Pines digitales:
pinMode(pin, mode): Configura el pin especificado para que se comporte como una entrada (input) o
una salida (output).
digitalWrite(pin, value): Asigna el valor de salida HIGH o LOW al pin especificado.
int digitalRead(pin): Lee o captura el valor de entrada del pin especificado, dará valores HIGH o
LOW. Devuelve un valor de tipo entero HIGH(1) o LOW (0).
Pines analógicos:
int analogRead(pin): Lee o captura el valor de entrada del especificado pin analógico, la tarjeta
Arduino realiza una conversión analógica a digital de 10 bits. Esto quiere decir que mapeará los
valores de voltaje de entrada, entre 0 y 5 voltios, a valores enteros comprendidos entre 0 y 1023. Esto
proporciona una resolución en la lectura de: 5 voltios / 1024 unidades, es decir, 0.0049 voltios (4.9
mV)por unidad. Los pines analógicos son solo de entrada por lo tanto no necesitan ser declarados como
modo INPUT (entrada) o OUTPUT (salida).
Serial: El arduino se comunica por serie vía USB con nuestro ordenador a través del chip FTDI. La
comunicación serial se puede utilizar para hacer un debugging (saber lo que está pasando en nuestro
programa) o para comunicarnos con otros programas. En nuestro taller lo utilizaremos para leer los
valores analógicos. Lo primero que hay que hacer es abrir el puerto y definir la velocidad con la que se
nos vamos a comunicar con en Arduino: void setup() { Serial.begin(9600); // Velocidad de la
transmisión y apertura del puerto } La velocidad para comunicarnos con el Monitor serial es 9600
Baudios. Con otros dispositivos puede ser otra, por ejemplo el protocolo MIDI sería a 31250 Baudios.
Intrucciones Seriales:
* Serial.begin(speed) //define el baudrate de la comunicación serie que se inicia
* Serial.print(data) // envía data como dato serial y aparece en el monitor serial.
* Serial.print("mensaje") // envía la palabra "mensaje" como dato serial y aparece en el monitor serial.
* Serial.println(data) // envía data como dato serial con un cambio de linea y retorno de carro y
aparece en el monitor serial.
EJERCICIO 1- Modifica el programa anterior para que, utilizando las instrucciones seriales, aparezca
en el monitor serial detrás de cada valor procedente de la LDR el mensaje "sobre el nivel de oscuridad
maximo que es 1023".
EJERCICIO 2- Vuelve a modificar el programa creando otra variable llamada tempo que almacene el
valor de tiempo de espera marcado en delay pero en segundos y que lo muestre en el monitor serial
indicando también las unidades.Ejemplo de mensaje: “Espera 0.884 segundos”
Para ello necesitas los siguientes datos:
 La variable tempo ha de funcionar en todo el programa y contendrá decimales, por lo tanto al
declararla hay que indicárselo colocando float delante de tempo.
 La función delay trabaja en milisegundos.
 Los operadores matemáticos para realizar operaciones son los ya conocidos: + , - , * , /
2. Multiled y potenciometro con Arduino
Observa el siguiente esquema de montaje de 10 leds conectados a la placa en las conexiones digitales.
Nosotros lo vamos a montar solo con 5 leds. Creamos un divisor de voltaje y controlamos el encendido
y apagado de los leds con una resistencia variable de 10k.
Circuito:
Programación:
//Mi multiled potenciometro:
// estas son costantes:
const int analogPin = A0;
// el pin al que el potenciometro esta conectado
const int ledCount = 5;
// el numero de leds en la barra
int ledPins[] = {2, 3, 4, 5, 6};
//describe el orden de los numeros de pines
donde conectamos los leds
void setup() {
// hace un conteo en bucle sobre todos los pines enviandolos todos a salida
for (int thisLed = 0; thisLed <= ledCount; thisLed++) {
pinMode(ledPins[thisLed], OUTPUT);
}
}
void loop() {
// lee el potenciometro:
int sensorReading = analogRead(analogPin);
// mapea el resultado de rango desde 0 hasta el numero de leds:
int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
// Hace un conteo en bucle sobre todos los leds:
for (int thisLed = 0; thisLed <= ledCount; thisLed++) {
// si la cantidad de elementos es menor que el nivel,
// encienda el pin para estos elementos:
if (thisLed < ledLevel) {
digitalWrite(ledPins[thisLed], HIGH);
}
// apague todos los pines mayores al ledlevel:
else {
digitalWrite(ledPins[thisLed], LOW);
}
}
}
CÓPIA EL PROGRAMA EN EL ENTORNO ARDUINO, COMPÍLALO Y QUÉMALO (cárgalo en el
arduino)
Funciones de Programación:
Control del Flujo de Programa, Condicionales If
Cuando se quiere que el microcontrolador haga algo dependiendo de alguna condición se utilizara la
instrucción If. La instrucción If verifica la condición del enunciado escrito entre paréntesis y si esta
condición es verdadera hará las acciones que estén entre las claves.
If (expresión)
{ Hacer esto ; y esto también ; }
Donde la expresión puede ser evaluada por cualquiera de estas opciones:
a == b (a es igual a b)
a != b (a no es igual a b)
a < b (a es menor que b)
a > b (a es mayor que b)
a <= b (a es menor que o igual a b)
a >= b (a es mayor que o igual a b)
If-Else-If.
if (A < 500)
{ // Hacer esto }
else if (B >= 1000)
{ // Haz lo otro }
else { // Haz lo que te parezca }
Map: Re-mapea un número desde un rango hacia otro. Ésto significa que, un valor (value) con respecto
al rango fromLow-fromHight será mapeado al rango toLow-toHigh. Vamos, una especie de regla de tres.
Estructuras de repetición FOR
Las instrucción FOR ejecuta en un loop varias instrucciones de código, y lo hacen un determinado
número de veces, el número de veces que se realizan depende de el número de ciclos que determinemos
en el encabezado de la instrucción. En el siguiente ejemplo las instrucciones instrucc1, 2, 3,4,5 se
ejecutarán 10 veces, después de la décima seguirá el flujo del programa.
FOR (i=1; 1 <= 10; i ++)
{ instrucc 1 ; instrucc 2 ; instrucc 3 ; instrucc 4 ; instrucc 5 ; }
Declaración FOR: La declaración for es usada para repetir un bloque encerrado entre llaves. El bucle
for tiene tres partes o argumentos en su inicialización: for
(initialization;
//función(es); }
condition;
increment)
{
Realiza el control sobre una secuencia de repetición. Se
compone de tres partes: init (inicializado de la variable
local), test (condición) , y update (actualización del valor la
variable local), cada parte debe ser separada por punto y
coma “;”. El bucle continua hasta que la condición
establecida se cumple (es verdad) o no (falsa). Es útil
cuando se usa en combinación con vectores y operar sobre grupo de datos/pines.
EJERCICIO 3- Aprovechando lo aprendido en el ejemplo anterior, intenta completar el siguiente
programa para que consigamos el efecto de las luces de KITT el coche fantástico. Para ello utiliza el
montaje de leds anterior. El potenciómetro lo puedes quitar pues no lo necesitamos.
El coche fantastico
/* Coche fantástico 1*/
int pinArray[] = {2, 3, 4, 5, 6};
int count = 0;
int timer = 70;
void setup(){
for (count=0;count<=5;count++) {
pinMode(
);
}
}
void loop() {
for (count=0;
;
) {
digitalWrite(
);
delay(
);
digitalWrite(pinArray[count], LOW);
delay(
);
}
for (count=7;count>=0;
) {
);
);
);
);
}
}
SEÑAL TIPO PWM
La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width
modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de
una señal periódica.
PWM tiene diferentes usos:






Atenuación de un LED.
Disponer de una salida analógica; si la salida digital está filtrada, esto proveerá de un voltaje
entre el 0% y el 100%.
Generar señales de audio.
Proveer de un control de velocidad variable para motores.
Generar una señal modulada, por ejemplo para utilizar un LED infrarojo para control remoto.
Control paso a paso de Motores servo con una resolucion de 8 bits.
Si prendemos y apagamos la señal de alimentación de la carga (led o motor) lo suficientemente rápido
como para que el parpadeo no se note, podríamos “simular” la variación de luminosidad de un led o el
cambio en la velocidad del motor:
Esto funciona siempre y cuando no
hagamos este “switcheo” más lento de
30 veces por segundo. A partir de ahí
el “blink” del led se empezará a notar
y el ojo humano captará ese parpadeo.
En el caso de un motor, éste se
moverá en una forma pulsante. Lo que
se hace con PWM es variar
dinámicamente el “duty cycle” de
manera que el tiempo de alta
disminuya o aumente y en proporción
inversa, el de baja aumente o disminuya dependiendo de si queremos una led más atenuado o más
brillante, o un motor más lento o más rápido, respectivamente. Esto lo podemos ver en un ejemplo
práctico con Arduino, un led y una resistencia de 220 ohms.
3. Variar la intensidad de un LED usando un salida PWM
El circuito es el siguiente:
El LED está conectado al pin digital del Arduino con una
resistencia de 220 Ohms. La pata corta siempre a tierra y la positiva,
más larga del lado de la resistencia. La resistencia se coloca con el
fin de proteger el led. Enviamos valores entre 0 y 255. Arduino lee
estos Bytes y los representa como luminocidad del led a través de
pulsos PWM. Los valores irán gradualmente de 0 a 255, ya que
PWM es una “simulación” de analógico, en la que 0 = 0 Voltios y
255 = 5Voltios. Lo que hace el PWM es ir de estado alto (5 V) a
estado bajo (0 V.) en una determinada frecuencia, esa frecuencia
determina una media que el LED interpreta como analógica. Para
programar en arduino el control de dimmerizado del Led es
necesario utilizar un pin que genére PWM, en este ejemplo
utilizamos el pin 9.
Sketck Arduino:
// Dimmer auto LED
int contador = 0; // variable
int pin = 9; // pin 9 que puede generar PWM
void setup()
{ // No tenemos que declarar que es una salida analógica
}
void loop() { for(contador = 0 ; contador <= 255; contador ++) // ciclo para ir
subiendo el voltaje desde 0 a 5 voltios
{
analogWrite(pin, contador); // PWM
delay(15);
}
delay(600);
}
Funciones de Programación:
Analogwrite()
Escribe un valor analógico (PWM) en un pin. Puede ser usado para controlar la luminosidad de un LED
o la velocidad de un motor.
Después de llamar a la función analogWrite(), el pin generará una onda cuadrada estable con el ciclo de
trabajo especificado hasta que se vuelva a llamar a la función analogWrite() (o una llamada a las
funciones digitalRead() o digitalWrite() en el mismo pin). La frecuencia de la señal PWM sera de
aproximadamente 490 Hz.
EJERCICIO 4- Modifica el sketch anterior para que el led, además de aumentar su intensidad, la
disminuya de la misma forma, de tal manera que se encienda y se apague progresivamente de
forma cíclica.
4. Variar la intensidad de un LED desde el teclado
En el mismo montaje que el ejercicio anterior, también podemos controlar el PWM con un programa
(monitor serial) que se comunique con arduino a través del puerto serial del ordenador introduciendo
valores variables a través del teclado . El puerto serial se comunica con el sistema binario en palabras de
8 bits (bytes).
Sabiendo esto, para enviar información a través del puerto serial, debemos convertir nuestra información
ASCII a información binaria, y para eso utilizamos la función byte. Un byte representa valores desde 0
hasta 255. Por eso, los datos que enviamos desde un a través del serial, son valores comprendidos en
este rango. En este caso Programamos en Arduino:
Sketch de Arduino:
//Dimmer LED
const int ledPin = 9;
// El pin al que el LED está conectado
void setup()
{
// Inicializamos puerto serie a 9600 bps:
Serial.begin(9600);
// inicializamos el ledPin como salida:
pinMode(ledPin, OUTPUT);
}
void loop() {
byte brightness;
// chequeamos que los datos hayan sido enviados por el ordenador:
if (Serial.available()) {
// Lee el byte mas reciente (debe ser entre 0 y 255):
brightness = Serial.read();
// Determina la luminosidad del LED:
analogWrite(ledPin, brightness);
}
}
Funciones de programación
byte: Un byte almacena un número sin signo de 8-bit, desde 0 hasta 255.
Ejemplo:
byte b = B10010; // “B” es el formateador binario (B10010 = 18 decimal)
Serial:
read(): Lee los datos entrantes del puerto serie.
available(): Devuelve el número de bytes (caracteres) disponibles para ser leidos por el puerto serie. Se
refiere a datos ya recibidos y disponibles en el buffer de recepción del puerto (que tiene una capacidad
de 128 bytes).Materiales
EJERCICIO 5- Con la ayuda del condicional if-else-if visto anteriormente y la función
serial.print(), modifica el sketch anterior para que a cada valor que introduzcamos, aparezca en el
monitor serial un mensaje sobre la intensidad del brillo del led (BRILLO ALTO, BRILLO BAJO…)
Motor Servo
Un motor servo es un dispositivo actuador que tiene la capacidad de ubicarse en cualquier posición
dentro de su rango de operación, y de mantenerse estable en dicha posición.
Consta de un motor de corriente continua, con una caja reductora y un circuito de control, para su
posicionamiento.
Los servos estandar llevan 3 cables : tensión, tierra y control. Se mueven en función de pulsos que le
enviamos a traves del cable de control y estos pulsos que le enviamos son los que establecen la posición
del servo. El servo espera pulsos cada 20 milisegundos para tener una idea correcta de la posición que ha
de tener. En general los servos giran unos 180 grados, aunque hay algunos que giran más. Tienen una
amplitud de pulsos de entre 0.5 y 2.5 milisegundos para establecer la posición. Los servomotores hacen
uso de la modulación por ancho de pulsos (PWM) para controlar la dirección o posición de los motores
de corriente continua. La mayoría trabaja en la frecuencia de 50 hercios, así las señales PWM tendrán un
periodo de veinte milisegundos. La electrónica dentro del servomotor responderá al ancho de la señal
modulada. Si los circuitos dentro del servomotor reciben una señal de entre 0,5 a 1,4 milisegundos, este
se moverá en sentido horario; entre 1,6 a 2 milisegundos moverá el servomotor en sentido antihorario;
1,5 milisegundos representa un estado neutro para los servomotores estándares.
PPM
PPM o -Pulse Position Modulation es un código implementado en la lbrería de servos. Es como un
PWM pero con un duty cycle muy bajo, para servos utiliza 50Hz en vez de 490Hz. Esto permite utilizar
varios servos a la vez. Funciona de la siguiente manera: El tiempo de duración del pulso es: 2ms, en el
cual se determina la posición del servo. Esta secuencia es repetida 50 veces por segundo. El punto limite
de la izquierda 1 ms, punto medio 1.5 ms y punto limite de la derecha 2 ms. Servo #1: Far Left
Command: Time ON = 1 + 0.0 ms = 1.0 ms Servo #2: Neutral Command: Time ON = 1 + 0.5 ms = 1.5
ms Servo #3: Far Right Command: Time ON = 1 + 1.0 ms= 2.0 ms.
En los siguientes tutoriales podemos encontrar una alternativa sencilla de conectar el motor servo a la
placa Arduino:
http://arduino.cc/es/Tutorial/Sweep
http://blog.bricogeek.com/noticias/tutoriales/tutorial-control-de-servomotores/
En estos tutoriales vemos que el motor es conectado directamente a los 5 v y GND de la placa arduino.
Esto funciona muy bien con mini-motores o en el caso en que hagamos movimientos ocacionales y
sutiles. En el caso en que queramos hacer movimientos rapidos en bucle, es preferible conectar el motor
a una fuente eléctrica DC externa de 5v ya que el motor podria pedir mas corriente de la que la placa
Arduino le pueda dar. Los pines de salida de Arduino pueden entregar hasta 40 mA, sin embargo, los
motores pueden tener peaks de alrededor de 700mA.
Circuito:
Conexión Motor servo: Cable negro ó marron al (-) de la fuente eléctrica externa y a GND de Arduino.
Cable Rojo al (+) de la fuente eléctrica externa. Cable Blanco ó Amarillo al Pin PWM de Arduino.
5. Controlando la posición de un Motor Servo
En este ejemplo el motor Servo gira 180 grados
gracias al Sketch de Arduino. El motor es conectado
a una fuente de poder externa y la señal de control
es enviada por el pin digital 9.
sketch de Arduino:
#include <Servo.h>
Servo myservo; // creamos un objeto servo
para controlar nuestro servo
int pos = 0; // variable para almacenar la
posición del servo
void setup()
{
myservo.attach(9); // atribuye al pin 9 el objeto servo
}
void loop()
{
for(pos = 0; pos < 180; pos += 1) // avanza de 0 a 180 grados
{ // en saltos de un grado
myservo.write(pos); // mueve a la posición de la variable 'pos'
delay(20); // espera 20ms
}
for(pos = 180; pos>=1; pos-=1) // va de 180 a 0 grados
{
myservo.write(pos);
delay(20);
}
}
Funciones de Programación
Usos standard de la libreria Servo
attach(int): Convierte el pin en un servo driver. Este remplaza al pinMode.
detach(): Libera un pin del servo driving.
write(int): Da el angulo del servo en grados, 0 a 180.
read(): Devuelve el valor al ultimo write().
attached(): Devuelve 1 si el servo está conectado.
EJERCICIO 6- Modifica el sketch anterior para que me permita introducir el ángulo de giro
desde el teclado y que además aparezca en el monitor serial un mensaje con el ángulo en el que se
encuentra en ese momento el servo.