GUIA BASICA ARDUINO

MANUAL INTRODUCTORIO AL
ARDUINO UNO
PROYECTO DE INSTRUMENTACION ELECTRONICA
ALUMNO DE ING. FISICA: CRISTIAN MONZON COELLO
2013

INTRODUCCIÓN AL ARDUINO
Arduino es una plataforma de electrónica abierta (open-source) para la creación de
prototipos basada en software y hardware libre, flexible y fácil de usar. Enfocada a un
público no experto como artistas, diseñadores, entusiastas de la electrónica, o cualquier
interesado en crear entornos u objetos interactivos. Está basada en una placa con un micro
controlador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en
proyectos multidisciplinares.
El proyecto Arduino fue concebido en Italia en el año 2005, sus creadores son el zaragozano
David Cuartielles, ingeniero electrónico y docente de la Universidad de Mälmo, Suecia y
Massimo Banzi, italiano, diseñador y desarrollador Web. Su nombre viene del nombre del
bar “Bar di Re Arduino” donde Massimo Banzi pasaba algunas horas, el cual a su vez viene
del nombre de un antiguo rey italiano allá por el año 1002.
Este proyecto acerca la electrónica a la gente común, pues hace frente a la programación
compleja y cerrada de las plataformas especializadas existentes, con una plataforma propia,
que utiliza software y hardware libre, además de presentarse como la solución para iniciar
en el mundo de la electrónica/robótica con un bajo coste.
Arduino es una herramienta para hacer que los ordenadores puedan sentir y controlar el
mundo físico a través de tu ordenador personal. Es una plataforma de desarrollo de
computación física que puede tomar información del entorno a través de sus pines de
entrada, para esto toda una gama de sensores puede ser usada y puede afectar aquello que
le rodea controlando luces, motores y otros actuadores. El microcontrolador en la placa
Arduino se programa mediante el lenguaje de programación Arduino (basado en Wiring) y
el entorno de desarrollo Arduino (basado en Processing).
Hay multitud de diferentes versiones de placas Arduino: Como el Arduino UNO, así como el
Duemilanove, que usan Atmel ATmega328. La anterior Diecimila, y las primeras unidades
de Duemilanove usaban el Atmel ATmega168, mientras que las placas más antiguas usan
el ATmega8. El Arduino Mega está basado en el ATmega1280. Además de muchas placas
otras placas copias de Arduino, también son compatibles y legales debido a la filosofía
abierta del Arduino.

ARDUINO SHIELDS
 El concepto de los shields nos permite apilar placas con diferentes funcionalidades,
proporcionando flexibilidad al Arduino, para adaptarse a diferentes proyectos
rápidamente, basta comprar el shield requerido. Ejemplos:
_Shield Xbee - Este shield permite conectar inalámbricamente varios Arduino a
distancias de 100 pies en edificios y 300 pies en el exterior usando el módulo
Maxstream Xbee Zigbee.
_Shield Motores- Este shield permite a Arduino controlar motores eléctricos de
corriente continua, servos y motores paso a paso y leer encoders.
_Shield Ethernet - Este shield permite a una placa Arduino conectarse a una red
Ethernet y tener acceso a y desde Internet.
 Muchas empresas ofrecen diferentes tipos de shields, acuerdo a lo que se requeriera
obtener. Y si no se encontrara un shield adecuado, usted lo puede construir
adaptándolo a la placa.

ESPECIFICACIONES TECNICAS DEL ARDUINO UNO
 Microcontrolador ATmega328
 Voltaje de operación 5V
 Voltaje de entrada (recomendado) 9-12 V
 Voltaje de entrada (limite) 6-20 V
 Digital I/O Pins 14 (con 6 salidas PWM)
 Entradas analógicas Pins 6
 DC corriente I/O Pin 40 mA
 DC corriente 3.3V Pin 50 Ma
 Conversor USB - Serie (chip FTDI)
 Memoria Flash 32 KB (2 KB para el boot loader)
 SRAM 1 KB
 EEPROM 512 byte
 Velocidad de reloj 16 MHz

ARDUINO UNO
La tarjeta Arduino UNO, es una placa basada en el microprocesador ATmega328. Tiene 13
pines para entradas/salidas digitales (6 de estas pueden ser usadas como salidas PWM), 6
pines para entradas analógicas, además de un puerto serial que permite realizar
comunicación con periférico una conexión USB. También tiene un pulsador para resetear
cualquier fallo que exista en los procesos que se vayan a realiza con la tarjeta. Una vez
programado el Arduino, no necesita estar conectado al PC.
Pines de alimentation (Power Pins)
Bien alimentemos al Arduino mediante la conexión USB o mediante una fuente externa
(recomendada de 9-12V), vamos a tener unas salidas de tensión continua debido a unos
reguladores de tensión y condensadores de estabilización.
Estos pines son:
 VIN: se trata de la fuente tensión de entrada que contendrá la tensión a la que
estamos alimentando al Arduino mediante la fuente externa.
 5V: fuente de tensión regulada de 5V, esta tensión puede venir ya sea de pin VIN a
través de un regulador interno, o se suministra a través de USB o de otra fuente de
5V regulada.
 3.3V: fuente de 3.3 voltios generados por el regulador interno con un consumo
máximo de corriente de 50mA.
 GND: pines de tierra.
Digital Inputs/Outputs
 Cada uno de los 14 pines digitales se puede utilizar como una entrada o salida. Cada
pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia de pull-
up (desconectado por defecto) de 20 a 50 kOhm. Sólo pueden leer/escribir dos
valores. 0(LOW) y 1(HIGH). En el caso de Arduino, se trabaja con una lógica de 0-5V.
Suele tomarlos valores como HIGH cuando son mayores a 1,5V.
Además, algunos pines tienen funciones especializadas como:
 Pin 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y la transmisión (TX) de datos serie
TTL.
 Pin 2 y 3. Interrupciones externas. Se trata de pines encargados de interrumpir el
programa secuencial establecido por el usuario.
 Pin 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines son de apoyo a la
comunicación SPI.
 Pin 13. LED. Hay un LED conectado al pin digital 13. Cuando el pin es de alto valor, el
LED está encendido, cuando el valor está bajo, es apagado.

 Pin 3, 5, 6, 9, 10 y 11. PWM (modulación por ancho de pulso) que emiten pulsos de
5V para que Vmedia sea de un valor determinado. Constituyen 6 bits de salida PWM
con la función analogWrite (). PWM es muy utilizado para controlar la velocidad de
motores o la intensidad de diodos LED. También es utilizado para indicar el ángulo de
giro de un servomotor.
Analog Inputs
El Arduino posee 6 entradas analógicas, etiquetadas desde la A0 a A5, cada una de las
cuales ofrecen 10 bits de resolución (es decir, 1024 estados). Por defecto, tenemos una
tensión de 5V, pero podemos cambiar este rango utilizando el pin de AREF y utilizando la
función analogReference(), donde le introducimos una señal externa de continua que la
utilizara como referencia.

INSTALACION DEL ARDUINO
 El IDE Arduino funciona en Windows, Mac OS X y Linux solo se tiene que descargar
de: http://arduino.cc/es/Main/Software para el sistema operativo empleado.
Windows XP, vista, 7
Si tu computador tiene de sistema operativo Windows en versión 7, Vista o XP, debes
realizar la siguiente sucesión de sencillos pasos:
 Conectar la placa Arduino Uno al PC y ver este aviso. No nos debemos pre-ocupar
 Visitar Panel de control y luego Administrador de dispositivos, allí buscar la siguiente
opción
 Click derecho sobre Dispositivo desconocido y luego sobre la opción Actua-lizar
software del controlador.

 Ingresar a la opción Buscar software de controlador en el equipo
 Examinar y buscar la carpeta de Arduino previamente descomprimida. Dentro de esa
carpeta acceder a la carpeta Drivers y dar Aceptar

 Una vez buscamos la carpeta de Drivers le damos Siguiente
 A veces en algunas máquinas aparecerá esta ventana:

 Recibimos la confirmación del Puerto COM asignado, este número de Puerto COM es
muy importante tenerlo en cuenta a la hora de programar.
MAC OS X (v. 10.3.9 o posterior)
1. Descargar el entorno Arduino.
Para programar la placa Arduino necesitas el entorno Arduino.
Descarga la última versión desde http://www.arduino.cc/en/Main/Software.
Cuando termine la descarga, descomprime el archivo descargado. Asegurate de conservar
la estructura de carpetas. Haz doble click en la carpeta para abrirla. Debería haber archivos
y subcarpetas en su interior.
2. Instalar los drivers USB.
Si estas usando un Arduino USB, necesitarás instalar los drivers para el chip FTDI de la placa.
Estos pueden encontrarse en el directorio drivers de la distribución Arduino. Si tienes un
Mac más antiguo como un Powerbook, iBook, G4 o G5, deberías usar los drivers PPC:
FTDIUSBSerialDriver_v2_1_9.dmg. Si tienes un Mac más nuevo como un MacBook, Mac
Book Pro o Mac Pro, necesitas los drivers de Intel: FTDIUSBSerialDriver_v2_2_9_Intel.dmg.
Haz doble click para montar la imagen del disco y ejecutar el FTDIUSBSerialDriver.pkg
La última versión en drives: http://www.ftdichip.com/Drivers/VCP.htm.

GNU/Linux
Estas instrucciones se centran en la distribución Ubuntu1, para más información sobre
cómo instalar el entorno Arduino en otras distribuciones visitar
http://www.arduino.cc/playground/Learning/Linux.
1. Ejecutar el Gestor de Paquetes Synaptic (en Sistema > Administración).
2. Primero necesitas habilitar los repositorios ‘’Universe’’ y ‘’Multiverse’’ para que puedas
acceder a todos los paquetes que necesitas.
Ir a Configuración > Repositorios.
 Haz click en Añadir.
 Marca ‘’Software restringido por copyright o cuestiones legales (multiverse)’’ y
‘’Software libre mantenido por la comunidad (universe)’’ y haz click en Añadir.
 Haz click en Cerrar y click en Cerrar en el diálogo ‘’Los repositorios han cambiado’’.
3. Haz click en el botón Recargar de la barra de herramientas.
4. Marca para instalar: ‘’sun-java5-jre’’, ‘’gcc-avr’’, ‘’avr-libc’’.
5. Haz click en Aplicar en la barra de herramientas.
6. Haz click en Aplicar en el cuadro de diálogo. Esto instalará los paquetes seleccionados.
7. Acepta la licencia de Java.
8. Espera hasta completar la instalación: el cuadro de diálogo dirá _Cambios aplicados_. Haz
click en Cerrar.
9. Cierra Synaptic.
10. Descarga la distribición de GNU/Linux de Arduino desde
http://www.arduino.cc/en/ Main/Software. Haz doble click en el archivo .zip y arrastra la
carpeta que contiene a algún lugar (por ejemplo el Escritorio).
11. Ejecuta el Terminal (en Aplicaciones > Accesorios).
12. Escribe ‘’sudo update-alternatives -config java’’ y presiona Enter. Teclea el número de
opción que tiene ‘’java-1.5.0-sun’’ en él y presiona Enter. Esto hará de la versión de Java de
Sun la predeterminada de tu sistema (necesaria porque la versión GNU todavía no soporta
todo lo necesitado por el entorno Arduino).
13. Haz doble click en ‘’arduino’’ en el directorio de aplicación de Arduino. Esto debería
lanzar un diálogo preguntando dónde guardas los archivos de tus rutinas de Arduino. Un
directorio ‘’Arduino’’ en tu carpeta home es la ubicación típica. Haz click en OK. El entorno
Arduino debería abrirse.

CONOCIENDO EL ENTORNO DE DESARROLLO DE ARDUINO
El entorno Arduino no precisa instalación, se lanza desde la misma carpeta en la que se
haya descargado, haciendo doble clic en “arduino.exe”.
Una vez se ha iniciado el entorno, aparecerá la ventana principal, que contiene las
siguientes partes principales (luego se verán con detalle cada una de ellas)

Para que la computadora reconozca a la placa Arduino, primero tenenos que configurar el
tipo de placa una vez abierta la aplicación nos vamos a Tools>Board>Arduino UNO
Además de elegir el puerto serial en el cual trabajamos, en este caso el COM30, nos vamos
a: Tools>Serial Port>COM 30

PROGRAMACIÓN DE UN ARDUINO
Vamos a comenzar a programar Arduino.
Arduino utiliza una mezcla curiosa de lenguajes de programación. Esta implementado en
Java, pero para programar los chips utiliza C++.
Un programa diseñado para ejecutarse sobre un Arduino se conoce como sketch, que
podríamos traducir como “boceto” o “borrador”. Un sketch siempre tiene la misma
estructura.
Además el IDE de Arduino, nos permite adjuntar librerías como en el lenguaje C++, por
ejemplo si queremos adjuntar la librería EEPROM, escribimos en la parte superior, como
cabecera del sketch:
#include <EEPROM.h>
Para ver más librerías nos vamos a: Sketch >Importar Libreria>…..

FUNCIONES BÁSICAS
 E/S DIGITALES
pinMode(pin,modo)
Configura el pin especificado para comportarse como una entrada (INPUT) o una salida
(OUTPUT).
Ejm: pinMode(Pin13, OUTPUT)
digitalWrite(pin,valor)
Asigna el valor HIGH (5V) o LOW (0V) a un pin digital.
Ejm: digitalWrite(Pin13 , HIGH);
digitalRead(pin)
Lee el valor de un pin digital especificado, HIGH o LOW.
Ejm: val = digitalRead(Pin13);
 E/S ANALÓGICAS
analogRead(pin)
Lee el valor de tensión en el pin analógico especificado. La placa Arduino posee 6 canales
conectados a un conversor analógico digital de 10 bits. Esto significa que convertirá
tensiones entre 0 y 5 voltios a un número entero entre 0 y 1023. Esto proporciona una
resolución en la lectura de: 5 voltios / 1024 unidades, es decir, 0.0049 voltios (4.9mV) por
unidad. El rango de entrada puede ser cambiado usando la función analogReference().
Ejm: val = analogRead(Pin3)
analogWrite(pin,valor)
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 será de
aproximadamente 490 Hz. los valores de analogRead van desde 0 a 1023 y los valores de
analogWrite van desde 0 a 255
Parametros:
 pin: Es el pin en el cual se quiere generar la señal PWM.
 valor: El ciclo de trabajo deseado comprendido entre 0 (siempre apagado) y 255
(siempre encendido).
Ejm: val = analogRead(analogPin);
analogWrite(ledPin, val / 4);

 COMUNICACIÓN SERIE
Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros dispositivos.
Todas las placas Arduino tienen al menos un puerto serie Serial. Se comunica a través de los
pines digitales 0 (RX) y 1 (TX), así como con el ordenador mediante USB. Por lo tanto, si
utilizas estas funciones, no puedes usar los pines 0 y 1 como entrada o salida digital.
Puedes utilizar el monitor serial del Arduino para comunicarte con la placa. Haz clic en el
botón del monitor de puerto serie en la barra de herramientas y selecciona la misma
velocidad en baudios utilizada en la llamada a begin().
Serial.begin(speed)
Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos
en serie. Para comunicarse con el ordenador, utilice una de estas velocidades: 300, 1200,
2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200.
Ejm: Serial.begin(9600);
Serial.read()
Lee los datos entrantes del puerto serie.
Ejm; Byte = Serial.read();
Serial.print(val,[format])
Imprime los datos al puerto serie como texto ASCII.
val: el valor a imprimir de cualquier tipo
format: especifica la base (formato) a usar; los valores permitidos son BYTE, BIN (binarios o
base 2), OCT (octales o base 8), DEC (decimales o base 10), HEX (hexadecimales o base 16).
Para números de coma flotante, este parámetro especifica el número de posiciones
decimales a usar. Ejemplos:
o Serial.print(78) imprime "78"
o Serial.print(78, DEC) imprime "78”
o Serial.println(1.23456, 2) imprime "1.23"
Serial.println(val,[format])
Imprime los datos al puerto serie como texto ASCII seguido de un retorno de carro (ASCII
13, o 'r') y un carácter de avance de línea (ASCII 10, o 'n'). Ejemplos:
o Serial.println(analogValue); // imprime como ASCII decimal
o Serial.println(analogValue, HEX);// imprime como ASCII hexadecimal
Serial.available()
Devuelve el número de bytes (caracteres) disponibles para ser leídos 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). Ejemplo:
if (Serial.available() > 0) {
} //realiza la lectura del puerto serie

Para más referencias sobre el lenguaje usado en el IDE de Arduino, además sobre los tipos
de variables a declarar, el manejo de estructura de del programa, la sintaxis empleada en
él, para aprender a usar las librerías y entre otros, podemos ayudarnos con la página web
de Arduino, para una referencia más detallada de los comandos empleados:
http://arduino.cc/es/Reference/HomePage

CARGANDO MI PRIMER PROGRAMA
El primer programa que podemos cargar, muy usado como para empezar en el Arduino,
algo como un ‘’HOLA MUNDO’’ en la placa Arduino, es el prendido y apagado de un led,
usando algún pin digital, en este caso el 13 que tiene una resistencia interna, además de un
led de estado, que se ubica al frente del pin 13 en el Arduino.
Para ello solo tenemos que buscar en el IDE: Archivo>>01.Basics>>Blink
Entonces tenemos, el siguiente programa, el cual lo cargamos con el botón redondo con la
flechita, que está en la parte superior del IDE:
// Blink: Prende un LED por un segundo, y lo apaga por otro segundo, así repetidamente.
int led = 13;
void setup() {
pinMode(led, OUTPUT); // inicializamos el pin 13 con salida
}
void loop() {
digitalWrite(led, HIGH); // enciende el LED
delay(1000); // 1000 milisegundos
digitalWrite(led, LOW); // apaga el LED
delay(1000); // 1000 milisegundos
}

Entonces notamos la intermitencia del foquito, con un periodo de un segundo, tiempo
que podemos variar en el paréntesis de delay( ) del programa.

ENCENDER UN LED CON UN PULSADOR
/*
Encender LED con un pulsador
Oprimir un pulsador y mientras este se mantenga accionado un LED se enciende
*/
int pulsador=2; //Pin donde se encuentra el pulsador, entrada
int led=13; //Pin donde se encuentra el LED, salida
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(pulsador, INPUT); //Configurar el pulsador como una entrada
pinMode(led,OUTPUT); //Configurar el LED como una salida
}
void loop()
{
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH) //Pulsador oprimido
{
digitalWrite(led,HIGH); //Enciende el LED
}
else //Pulsador NO oprimido
{
digitalWrite(led,LOW); //Apaga el LED
}
}

LECTURA SERIAL DE UNA ENTRADA ANÁLOGA
/*
LECTURA SERIAL DE ENTRADA ANÁLOGA
Leer una entrada análoga y mostrar por la pantalla del
Computador (consola serial) el valor luego de girar el potenciómetro
*/
{
Serial.begin(9600); //Inicia comunicación serial
}
void loop()
{
//Guardar en una variable entera el valor del potenciómetro 0 a 1024
int valor= analogRead(A0);
//Imprime en la consola serial el valor de la variable
Serial.println(valor);
//Retardo para la visualización de datos en la consola serial
delay(100);
}

ESCRITURA SERIAL
/*
ESCRITURA SERIAL
Consiste en escribir por la pantalla del computador (consola serial) una letra predeterminada, la primera vez que se
escriba está un LED se enciende, si se vuelve a escribir por segunda vez el LED se apaga.
*/
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado
{
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
void loop()
{
//Guardar en una variable el valor de la consola serial
leer=Serial.read();
// Si es la letra 'a' y además el LED está apagado
if ( (leer=='a') && (prendido==false) )
{
digitalWrite(led,HIGH); // Enciende el LED
prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'a' y además el LED está encendido
else if ( (leer=='a') && (prendido==true) )
{
digitalWrite(led,LOW); // Apaga el LED
prendido=false; // Actualiza el estado del LED
}
}

ENCENDER UN LED POR PWM
/*
ENCIENDE/APAGA UN LED DE FORMA PROPORCIONAL
Programa que enciende proporcionalmente un LED cuando llega a su máximo punto de brillo comienza a
apagarse proporcionalmente.
*/
int brillo = 0; //Variable de brillo inicia en 0
int variacion = 5; //Variable de incremento configurada de 5 en 5
int led = 9; //Pin donde se encuentra el LED, salida
void setup () // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
void loop () {
// Escritura analoga (PWM) en el LED escribo el valor de brillo
analogWrite(led, brillo);
// Incremento la variable brillo de 5 en 5
brillo = brillo + variacion;
// Nota: PWM ----> 0 - 255
// Si el brillo es 0 o 255
if (brillo == 0 || brillo == 255)
variacion = -variacion; //La variación se vuelve negativa
delay (30); //Tiempo de incremento en el brillo
}

CONTROL ON/OFF CON POTENCIÓMETRO
/*
Control ON/OFF con potenciómetro
Programa que enciende un LED cuando el valor de la entrada análoga comandada por el potenciómetro
está en cierto valor, cuando este valor cambia el LED se apaga, es un sistema con control ON/OFF
*/
{
pinMode(13,OUTPUT); //Configurar el pin 13 como una salida
}
void loop(){
//Guardar en una variable el valor de la lectura análoga
int valor = analogRead(A0);
Serial.println(valor); //Imprime el valor por la consola
//Si el valor es mayor o igual a 500
if (valor >= 500)
{
digitalWrite(13,HIGH); //Enciende el LED en el pin 13
}
//Si el valor es menor a 500
else
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
}

CONTROL DE UN LED CON UNA FOTOCELDA
//Programa que enciende un LED de manera proporcional a la cantidad de luz que incida en una
fotocelda.
{
pinMode(9,OUTPUT); //Configurar el pin 9 como una salida de PWM
}
void loop(){
//Guardar en una variable el valor de la lectura análoga de la fotocelda
int foto = analogRead(A0);
//Verifica el valor máximo y realizar una conversión
int conversion = 780 - foto;
//Condicional para establecer un valor absoluto
if ( conversion < 0)
conversion = conversion * -1; //Multiplicar por -1 porque es negativo
Serial.print("Foto : "); //Imprimir datos del valor de la lectura análoga de la fotocelda
Serial.print(foto);
Serial.println("");
Serial.print("Conv : "); //Imprimir datos del valor de la conversión
Serial.print(conversion);
Serial.println("");
analogWrite(9, conversion); //Escritura análoga de PWM en el LED de acuerdo a la conversión
delay(100); //Retardo para datos en la consola
}

CONTADOR DE PULSOS
//CONTADOR DE PULSOS: Programa que muestra por pantalla (consola serial) el número de veces que el pulsador
//ha sido presionado, se realiza un proceso que de acuerdo al número de pulsos se enciende un LED
int conta = 0; //Variable para guardar el conteo de los pulsos
{
pinMode(2,INPUT); //Configura el pin 2 como una entrada, pulsador
pinMode(13,OUTPUT); //Configura el pin 13 como una salida, LED
}
void loop() {
if ( digitalRead(2) == HIGH ) // Si el pulsador esta oprimido
{
if ( digitalRead(2) == LOW ) // Si el pulsador no está oprimido, flanco de bajada
{
conta++; //Incrementa el contador
Serial.println(conta); //Imprime el valor por consola
delay (100); // Retardo
}
}
if (conta==5) // Si el valor del contador es 5
{
digitalWrite(13,HIGH); //Enciende el LED
}
if (conta==8) // Si el valor del contador es 8
{
digitalWrite(13,LOW); // Apaga el LED
}
}

LED RGB APOYADO DE TABLA DE COLORES
//Programa que hace uso de una función llamada color para generar diversas tonalidades en un LED RGB
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
}
void loop() {
// Llamado a la función Color que recibe
color(255,0,0); //Rojo, 1er posicion: Intensidad Rojo
delay(1000);
color(0,255,0); //Verde, 2da posición: Intensidad Verde
delay(1000);
color(0,0,255); //Azul, 3ra posición: Intensidad Azul
delay(1000);
color(255,255,255); //Blanco
delay(1000);
color(255,0,255); //Magenta
delay(1000);
color(255,128,0); //Naranja
delay(1000);
}
void color(int rojo, int verde, int azul){ //Funcion color
analogWrite(ledRojo, 255-rojo); //Escritura de PWM del color Rojo
analogWrite(ledVerde, 255-verde); //Escritura de PWM del color Verde
analogWrite(ledAzul, 255-azul); //Escritura de PWM del color Azul
}

CONTROL ON/OFF DE UN MOTOR
Para este experimento necesitamos un transistor NPN, para darle potencia al motor, al
pequeño motor. Armamos el siguiente esquema con los componentes con el Arduino.
Tener en cuenta la posición de las patas del transistor de acuerdo al grafico.

CONTROL ON/OFF DE UN MOTOR
/*
Programa que hace uso de un motor y un pulsador, mientras se mantenga pulsado, el motor
debe estar encendido (ON) de lo contrario debe estar apagado (OFF)
*/
int pulsador =7; //Declara Pin del pusaldor
int motor=3; //Declara Pin del motor
{
pinMode(pulsador,INPUT); //El pulsador como una entrada
pinMode(motor,OUTPUT); //El motor como una salida
}
void loop()
{
// Si el pulsador se encuentra oprimido
if(digitalRead(pulsador) == HIGH){
digitalWrite(motor,HIGH); //Enciende el motor
}else{ //si el pulsador no está oprimido
digitalWrite(motor,LOW); //Apaga el motor
}
}

CONTROL POR PWM DE UN MOTOR
/*
Control por PWM de un motor
Programa que hace uso de un motor y la Consola serial de Arduino, tiene la posibilidad de
configurar al motor 5 velocidades distintas, desde el teclado del PC puedes enviarle la
velocidad deseada. Las 5 velocidades se configuran con 5 PWM distintos.
*/
int motor=3; //Declara Pin del motor
{
Serial.begin(9600); //Inicia la comunicacion serial Arduino-PC
}
void loop()
{
// Si hay algun valor en la Consola Serial
if (Serial.available()){
//Variable donde se guarda el caracter enviado desde teclado
char a = Serial.read();
// Si el caracter ingresado esta entre 0 y 5
if (a>='0' && a<='5'){
//Variable para escalar el valor ingresado a rango de PWM
int velocidad = map(a,'0','5',0,255);
//Escritura de PWM al motor
analogWrite(motor,velocidad);
//Mensaje para el usuario
Serial.print("El motor esta girando a la velocidad ");
Serial.println(a);
}else{ // Si el caracter ingresado NO esta entre 0 y 5
//Mensaje para el usuario
Serial.print("Velocidad invalida");
Serial.println(a);
}
}
}

SERVOMOTOR CONTROLADO CON UN POTENCIOMETRO
// Usamos la librería Servo que ya tiene funciones predeterminadas
#include <Servo.h>
Servo miServo; // Creamos un objeto Servo para controlar nuestro servo
int potenciómetro = 0; // Potenciómetro en el Pin Analógico 0
int valor; // Variable para guardar la lectura del potenciómetro
void setup() {
miServo.attach(9); // Conectamos el servo en el Pin PWM 9
}
void loop() {
valor = analogRead(potenciómetro); // Leemos el valor del potenciómetro
valor = map(valor, 0, 1023, 0, 179); // Mapeamos su valor al rango del servo [0-180]
miServo.write(valor); // Le pasamos al servo el valor escalado
delay(15); // Retraso de 15 milisegundos para refrescar el servo
}

GENERAR TONOS CON UN BUZZER
/*
GENERAR TONOS CON UN BUZZER
Programa que hace uso de un buzzer (chicharra) y un potenciómetro, la idea es generar
diversos tonos en el buzzer a partir del estado análogo del potenciómetro. Además se hace
uso de la función tone que es muy útil para generar diversas melodías
*/
int buzzer = 9; //Declara Pin del buzzer
int tono = 0; //Declara Pin del potenciómetro
{
// No se configuran parámetros inciales, pero se debe
// colocar el encabezado de la función setup()
}
void loop()
{
//Variable entera donde se almacena el valor del potenciómetro
int sensor = analogRead(tono);
//Variable donde se escala la frecuencia de 100 a 5000Hz
int frecuencia = map(sensor,0,1023,100,5000);
//Variable entera para guardar el tiempo deseado en ms
int duracion = 250;
//Funcion tone(), que recibe:
// 1ra posición: Pin del elemento sonoro
// 2da posición: Frecuencia deseada en Hz
// 3ra posición: Duración del tono
tone(buzzer, frecuencia, duracion);
//Retardo
delay(100);
}

MEMORIA EEPROM PARA ALMACENAMIENTO
El EEPROM (Electrically-Erasable Programmable Read-Only Memory) que es una memoria
ROM programable y borrable eléctricamente, a diferencia de la EPROM que ha de borrarse
mediante un aparato que emite rayos ultravioletas. Son memorias no volátiles.
Aunque una EEPROM puede ser leída un número ilimitado de veces, sólo puede ser borrada
y reprogramada entre 100.000 y un millón de veces.
Para añadir su librería, la cabecera EEPROM:
Basta con incluir la directiva #include <EEPROM.H> en nuestro código.
FUNCIONES:
EEPROM.write(dirección, valor)
Escribe un valor en la EEPROM.
Dirección (Address): Disponemos de 511 celdas (int)
Valor (Value): Disponemos de 0 a 255 Tipo Byte)
EEPROM.read(dirección)
Lee un valor de la EEPROM
Value (Address): Disponemos de 511 celdas (int)
Retorna: Byte. (Podemos hacer cast a int)

Código de ejemplo (Desde la página oficial de Arduino)
WRITE
#include <EEPROM.H>
void setup() {
for (int i = 0; i < 512; i++)
EEPROM.write(i, i);
}
void loop() { }
READ
#include <EEPROM.H>
int a = 0;
int value;
void setup() {
Serial.begin(9600); }
void loop() {
value = EEPROM.read(a);
Serial.print(a); Serial.print("t");
Serial.print(value); Serial.println();
a = a + 1;
if (a == 512)
a = 0;
delay(500);
}

SENSOR DE TEMPERATURA LM35 CON PANTALLA LCD
En este experimento usaremos el sensor de temperatura LM35 y ademas de un pantalla LCD, de la cual
existe una librería en el Arduino.
El sensor LM35 el cual nos mide una temperatura de -55ºC a 150ºC y una precisión de 0.5ºC a 25ºC; este
sensor es suficientemente completo, se puede utilizar para realizar pequeños inventos o proyectos

#include <LiquidCrystal.h> //Incluir esta libreria para poder usar el lcd
int Ana1 = A0; //Entrada analogica de LM35
LiquidCrystal lcd(12,11,5,4,3,2); //Definimos la pantalla LCD
int Temp = 0;
char Grados = 'Âº';
void setup(){
Serial.begin(9600);
lcd.begin(16,2);
pinMode(13,OUTPUT);
digitalWrite(13, HIGH); //Activamos la retroiluminacion
}
void loop(){
Temp = analogRead(Ana1); //Leemos el valor de la entrada analogica
// Primero transformamos la lectura analógica de tensión a un valor de temperatura
Temp = (5.0 * Temp * 100.0)/1024.0;
Serial.print("Grados: ");//Mostramos los grados en el serial
Serial.print(Temp); Serial.print(Grados);
Serial.println("C");
//Mostramos los grados en la pantalla LCD
lcd.setCursor(0,0); //Con este comando decimos en que linea queremos escribir
lcd.print("Temperatura: ");
lcd.setCursor(0,1);
lcd.print(Temp);
lcd.setCursor(3,1);
lcd.print("°C");
delay(1000); //Al ser temperatura no hace falta leerlo tan seguido
}

GUIA BASICA ARDUINO

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a GUIA BASICA ARDUINO

Similar a GUIA BASICA ARDUINO (20)

Último

Último (20)

GUIA BASICA ARDUINO