Вы находитесь на странице: 1из 89

10 proyectos sencillos y explicados para empezar con Arduino 4.

45/5 (29) por Redacción · Publicada ·


Actualizado arduino uno 600x450 - 10 proyectos sencillos y explicados para empezar con Arduino 10
proyectos arduino sencillos para empezar y dos más para especializarse Pequeña introducción Bien si
has llegado hasta aquí dentro de nuestra web sobre Arduino se supone que ya sabes lo que es Arduino,
¡¡en este enlace te lo contamos!!, y lo que más o menos se puede hacer con esta placa pero si aún
tienes dudas de lo qué es en nuestra web tenemos una serie de artículos que te ayudarán a a conocer
este famoso microcontrolador, déjanos que hagamos un pequeño lapsus para comentaros que al final
del artículo os dejaremos los enlaces a esos artículos antes de entrar al tema de los 10 proyectos
Arduino sencillos que en este artículo os traemos. Bien pues después de haber echo este pequeño
lapsus os dejo con los 10 proyectos arduino sencillos para empezar que protagonizan este artículo.
Solo recordaros que si estos proyectos os saben a poco al final del artículo tienes enlaces a otras listas
de proyectos que hemos hecho en nuestra web. Si con el Arduino Starter Kit y los proyectos que trae y
que os enseñamos en un artículo anterior no tenéis suficiente, en este artículo os traemos otros 10
proyectos arduino sencillos, algunos de los cuales son de John Boxall, autor del libro Arduino
Workshop, y que comparte para empezar a trabajar con Arduino. Hemos hecho una breve descripción,
luego si estas interesado en cualquiera de ellos solo tendrás que hacer clic en los enlaces para poder
acceder a los archivos en pdf donde esta todo lo necesario para desarrollar dichos proyectos. En el
libro encontraras un total de 65 proyectos de dificultad muy variada. Esperamos os sean de interés. Son
sobretodos proyectos arduino para principiantes y que se pueden realizar con la placa Arduino Uno o
con Arduino Mega 2560. Antes de nada si has llegado aquí y tienes una Raspberry Pi y buscas
proyectos relacionados con ella pásate por nuestra sección de proyectos y tutoriales para Raspberry Pi.
Antes de empezar. Antes de comenzar a crear proyectos electrónicos con Arduino, debes conocer los
símbolos utilizados en los esquemas. Debes revisar un gráfico de códigos de colores para poder
descifrar los valores de las resistencias. También te vamos a dar algunas sugerencias para la solución
de problemas de hardware y software. Símbolos Esquemáticos en los Proyectos Arduino Cuando se
realizan proyectos de Arduino, a menudo es necesario consultar un esquema. Como ejemplo te
dejamos la siguiente tabla, que muestra los símbolos esquemáticos comunes que puedes encontrar al
construir proyectos de Arduino: simbolos - 10 proyectos sencillos y explicados para empezar con
Arduino Solución de problemas en proyectos Arduino Para comprobar si hay problemas de hardware
debes seguir los siguientes pasos: Comprueba las conexiones de hardware. Busca conexiones abiertas.
La causa más frecuente de problemas es que las cosas simplemente se desconectan. También
comprueba si hay cortocircuitos. Esto puede darse en cualquier lugar los cables están tocando o
conectados a donde no deben. Asegúrate de que estás utilizando las entradas digitales de Arduino para
sensores que proporcionan una salida digital, HIGH o LOW, y entradas analógicas para sensores que
generan una tensión variable. Comprueba la energía. Asegúrate de que tienes suficiente energía y
luego también de que está llegando al lugar correcto. Confirma que las luces indicadoras de encendido
están encendidas. Si estás utilizando componentes externos a tu Arduino pero no parecen estar
funcionando, intenta encenderlos independientemente del Arduino mediante una batería o una fuente
de alimentación externa. Compruebe si hay componentes calientes y olores a quemado. Localiza
cualquier componente que pueda estar demasiado caliente al tacto. Probablemente están cableados
incorrectamente o reciben demasiada energía. Olfatea tus componentes para cualquier cosa que pueda
parecer oler a quemado. Esta es una indicación definitiva de una conexión incorrecta, y debe
desconectar la alimentación de inmediato. Debes cambiar cualquier componente dañado y volver a
revisar el circuito para localizar posibles conexiones incorrectas antes de encender. Comprueba los
valores de salida. Utiliza un multímetro para medir los voltajes de los dispositivos. Asegúrate de que
obtiene +5 voltios para los valores digitales de ALTO o HIGH y 0 voltios para los valores de BAJO o
LOW. Prueba los sensores digitales para asegurarte de que están emitiendo los valores correctos.
Pruebea los sensores analógicos para asegurarte de que están proporcionando una tensión que oscila
entre 0 y 5 voltios. Comprueba sus entradas y salidas digitales. Si has ejecutado demasiada corriente
(más de 40mA) en un pin digital o analógico, has sobrepasado el pin y puede haber dejado de
funcionar. Si sospechas que un pin está muerto, trata de usar un pin adyacente cambiando su código en
consecuencia. Si eso soluciona el problema, es posible que tenga un pin muerto. Problemas de
software Comprueba el código. El problema más común es el punto y coma que falta al final de una
línea. Probablemente el segundo problema más común es un símbolo perdido. Además, busca errores
ortográficos, ortografía incorrecta o un desajuste en letras mayúsculas o minúsculas, ya que el código
Arduino distingue entre mayúsculas y minúsculas. Si hay un error en tu código, el IDE normalmente
resaltará la línea donde ocurrió el error. Utiliza el serial monitor. Utiliza las instrucciones
Serial.println() en los puntos clave de tu código para enviar el contenido de las variables al serial
monitor. También puedes imprimir mensajes en el serial monitor de puntos importantes de tu código.
Es posible que debas agregar una sentencia delay() para darte un momento para que puedas leer los
valores al imprimirlos en la pantalla. Utiliza un simulador o un emulador. Puedes utilizar simuladores
Arduino en linea que imitan el comportamiento de cualquier microcontrolador Arduino. Estas son
herramientas técnicas dirigidas a profesionales y te pueden dar una gran cantidad de información sobre
el código, ya que se está ejecutando en el simulador. También puedes descargar una de estas
herramientas para intentar ejecutar el código en un Arduino virtual en tu ordenador. Un ejemplo de
simulador Arduino es Circuits.io. Echa un vistazo a los foros. El sitio web oficial de Arduino,
Adafruit, Sparkfun y Element14 tienen foros dedicados a Arduino donde los usuarios publican sus
proyectos y ayudan a otros. Esas comunidades están llenas de gente que sólo quiere que sus Arduinos
hagan cosas interesantes. Son casi siempre útiles y de apoyo. Códigos de colores de resistencias
electrónicas Cuando se desarrollan proyectos de electrónica Arduino, a menudo es necesario consultar
un esquema o identificar una resistencia. Utiliza esta tabla para identificar el valor de una resistencia,
en Ohms, de su código de color: Color 1er dígito 2do dígito 3er dígito Multiplicador Tolerancia Negro
0 0 0 1 Marrón 1 1 1 10 1% Rojo 2 2 2 100 2% Naranja 3 3 3 1000 Amarillo 4 4 4 10,000 Verde 5 5 5
100,000 Azul 6 6 6 1,000,000 Violeta 7 7 7 Gris 8 8 8 Blanco 9 9 9 Oro 0.1 5% Plata 0.01 10% Por
ejemplo: Una resistencia de 4,700Ω (4,7KΩ) tendrá rayas amarillas, violeta, naranja y dorada: Color
Amarillo Violeta Naranja Oro Valor 4 7 X 1000 ±5% Y ahora si vamos allá con los proyectos.
Construir un testeador de batería. Se puede usar un Arduino para comprobar la vida de cualquier
batería de menos de 5 voltios. Así que si quieres ver cuanto de energía le queda a tus pilas o baterías
debes construir este probador de baterías basado en Arduino, que puede mostrar la vida de la batería a
través de una serie de LEDs. Vas a necesitar lo siguiente: Un Arduino Uno 3 Resistores (R1 a R3) de
560 Ω 1 resistencia (R4) de 2,2 k Ω 1 LED verde (LED1) 1 LED amarillo (LED2) 1 LED rojo (LED3)
Una Protoboard Varios cables de conexión Un cable Arduino y USB cable Tirar los dados La próxima
vez que esté juegues al parchís con tus amigos o familiares sorprenderles con este aparato sacar los
números a jugar. Este proyecto elige un número aleatorio entre el 1 y el 6 y lo muestra a través del
LED correspondiente. Para este proyecto vas a necesitar: Un Arduino Uno Siete LEDs Siete
resistencias de 100 ohmios (marrón negro marrón) Una resistencia de 100k ohmio 100k (amarillo
negro marrón) Un Interruptor / pulsador físico Tablero de circuitos o protoboard Cable para el tablero
Control de Tráfico Con este proyecto construiremos una especie de semáforo. No sólo muestra rojo,
amarillo, y verde para cada sentido de tráfico en sentido contrario, sino que también incluye un sensor
para ver un coche que se acerca a la carretera de un solo carril, y que cambia la luz a verde si no hay
tráfico que viene en sentido contrario. Vas a necesitar: 2 LEDs rojos (LED1 y LED2) 2 LEDs
amarillos (LED3 y LED4) 2 LEDs verdes (LED5 y LED6) 6 resistencias de 560 Ω (de R1 a R6) 2
resistencias de 10 kΩ (R7 y R8) 2 condensadores de 100 nF (C1 y C2) 2 pulsadores (S1 y S2) Una
placa de medición de tamaño mediano 1 Arduino y un cable USB Varios cables de conexión Un
sencillo cronómetro Dos pulsadores, un tablero, un par de resistencias y algunos cables son todo lo que
se necesita para convertir una placa Arduino en un sencillo cronómetro, aquí tienes la manera. Crear
un bloqueo de teclado Con este proyecto conseguirás usar el Arduino como protector de tu pc. Con
esto lo que conseguirás es bloquear el teclado mediante un código secreto de seis dígitos elegido por el
usuario para bloquearlo en caso de que alguien pretenda entrar sin la clave. Tu propio tanque robot
Este proyecto de Boxall te ayudará a construir un vehículo con apariencia de tanque. El robot tanque
utiliza un pequeño motor para cada banda de rodadura para poder subir por encima de obstáculos. Vas
a necesitar: Un módulo de chasis de tanque Pololu RP5 1 placa de chasis Pololu RP5 6 pilas AA
alcalinas 1 batería de 9 V y cable de toma DC Arduino Uno y cable USB Cambiar la intensidad de un
LED Vamos con un sencillo tutorial de nuestra sección de tutoriales con el que aprenderemos como
cambiar la intensidad de una de las bombillas LED conectadas a nuestro Arduino. Enlace al tutorial.
Un transmisor de lenguaje morse Con este proyecto conseguirás construir un sencillo trasmisor de
Morse con tu placa Arduino. Solo vas a necesitar una placa Arduino, 1 led y una resistencia de
resistencia 220ohm. Un Twitter automatizado Todo el mundo está en Twitter, Así que ¿por qué no
debería tuitear tu Arduino? Aquí tienes la manera de poner a tu placa a mandar tweets.. Enviar
mensajes a teléfonos Con este proyecto podrás enviar mensajes de texto a teléfonos móvil. Construye
un reloj Este es un proyecto más complicado para ello te enlazamos a nuestro artículo en el que vimos
10 maneras de construir un reloj totalmente funcional con tu placa Arduino. Más proyectos, enlaces de
interes Si te has quedado con ganas de conocer más proyectos Arduino aquí te dejamos un listado de
algunos de los que hemos publicado en nuestra web. 8 proyectos arduino para nivel avanzado y no
tanto 5 proyectos para empezar con Arduino este verano 2 divertidos proyectos arduino funcionando
con energía solar 2 proyectos de Arduino para ayudarnos en la cocina 5 proyectos divertidos para
hacer con Arduino y LEGO Categoría de proyectos arduino de nuestra web. Si quieres hacerte con el
Arduino Starter Kit en este enlace lo tienes a buen precio y con el manual totalmente en español. Y en
este artículo nuestro puedes ver los proyectos de dicho tutorial explicados por Massimo Banzi.

Copiado de: https://descubrearduino.com/


Descripción KIT ARDUINO
Este KIT incluye 15 proyectos sencillos que te enseñarán cómo usar ARDUINO para convertir una
IDEA en una REALIDAD.

Gracias a una selección de los componentes eléctricos de uso más comunes, podrás realizar
aplicaciones prácticas empezando por los proyectos más sencillos, diseñados para enseñar los
conceptos básicos de electrónica, hasta los proyectos más complejos con los que podrás interactuar con
el mundo físico a través de sensores y actuadores.

Te proporciona el conocimiento y las herramientas básicas para sacar a la luz tu genio interior y
alimentar tu creatividad para siempre.

CONOCE TUS HERRAMIENTAS. Una introducción a los conceptos que necesitarás para usar el kit.
INTERFACE DE NAVE ESPACIAL. Diseña el panel de control de tu nave espacial.
LOVE-O-METER. Mide cómo de calientes estás.
LÁMPARA DE VARIOS COLORES. Produce colores con una lámpara que usa la luz como entrada.
INDICADOR DE ESTADO DE ÁNIMO. Haz saber a la gente cómo estás.
THEREMIN ÓPTICO. Crea un instrumento musical que puedes tocar moviendo las manos.
INTRUMENTO DE TECLADO. Toca música y haz un poco de ruido con este teclado.
RELOJ DE ARENA DIGITAL. Un temporizador lumínico que evitará que trabajes demasiado.
MOLINILLO MOTORIZADO. Un molinillo de color de vértigo.
ZOÓTROPO. Crea una animación mecánica que podrás reproducir hacia delante y hacia atrás.
BOLA DE CRISTAL. Una herramienta mística para responder todas tus preguntas difíciles.
CERROJO DE PUERTA. Marca el código secreto para abrir la puerta.
LÁMPARA TÁCTIL. Una lámpara que responde a tu tacto.
MODIFICA EL LOGO DE ARDUINO. Controla tu ordenador personal desde tu Arduino.
HACKEAR BOTONES. ¡Crea un botón maestro para todos tus dispositivos!

Comprobarás que no hace falta un montón de mecánica y electrónica complicadas para hacer alfo
realmente divertido, para hacer cosas que respondan al mundo a su alrededor, o para encender la
imaginación de le gente. Todo lo que hace falta es este kit, algunos objetos cotidianos, y tus propias
únicas ideas. Porque los grandes proyectos interactivos necesitan algo más que cables y componentes,
necesitan “makers” listos, como tú.

Necesitarás algunos materiales propios, a medida que vas avanzando con tus proyectos para hacerlos
realmente únicos. Como poco necesitarás una batería de 9v y un ordenador, pero recomendamos tener
a mano algunos materiales básicos de bricolaje, como papel, cinta adhesiva, rotuladores y tijeras. Los
materiales adicionales sugeridos están enumerados en los detalles de cada proyecto.

EL KIT INCLUYE:

1 Libro de proyectos Arduino (170 páginas en castellano)


1 Placa Arduino UNO Rev3
1 Cable USB
1 Breadboard (Protoboard)
1 Adaptador para la batería de 9 Voltios
70 Puentes de conexion para la protoboard
6 Fotoresistencias (VT90N2 LDR)
3 Potenciometros de 10K
10 Pulsadores
1 Sensor de temperatura (TMP36)
1 Sensor de inclinación
1 LCD alfanumerico (16×2 caracteres)
1 LED (Blanco)
1 LED (RGB)
8 LED (Rojo)
8 LED (Verde)
8 LED (Amarillo)
3 LED (Azul)
1 Motor CC 6 y 9 Voltios
1 Servo motor
1 Piezo Buzzer
2 Optoacopladores 4N35
5 Transistores BC547
2 Mosfet IRF520
5 Condensadores 100nF
3 Condensadores 100uF
5 Condensadores 100pF
5 Diodos 1N4007
1Tiras de pines macho (40×1)
20 Resistencias 220 ohm
5 Resistencias 560 ohm
5 Resistencias 1K
5 Resistencias 4.7K
10 Resistencias 10K
5 Resistencias 1M
5 Resistencias 10M
Precio: CONSULTAR PROMOCIONES
Tutorial Arduino # 0004 – Sensor LDR

Autor:

Fecha: 27 noviembre, 2011

Compartir en
facebook

twitter

google

pinterest

# Tutorial Arduino 0004 – Sensor LDR


Bienvenidos a un nuevo tutorial para sacar el máximo partido a vuestro Arduino, comenzamos a
introducir en nuestros proyectos sensores que responderán a situaciones físicas concretas, empecemos
por el LDR!!

 Nivel: Básico
 Coste: < 30 €
 Tiempo: 25′

Parte 1: ¿Qué vamos a hacer?

En este proyecto, vamos a utilizar un LDR (Light Dependent Resistor o resistencia dependiente de la
luz) para simular una hipotética compensación lumínica de 5 niveles, es decir, a través de una resistencia
que varia su valor dependiendo de la luz recibida, aprovecharemos dicha variación para hacer un
programa que nos encienda o apague una serie de LED dependiendo de si hay más luz o menos luz, esto
podríamos extrapolarlo a un sistema de regulación de luz de un jardín con cinco lineas de luz que se
vayan encendiendo según va cayendo la noche compensando progresivamente la deficiencia de luz.

Además le hemos implementado un potenciómetro para ajustar el nivel crítico mínimo de luz que
queremos soportar, a partir del cual se activará nuestro circuito y empezará a aumentar la luz del lugar
progresivamente.

Veamos un video con el resultado final!

Material necesario para este proyecto:

 1 x Arduino Uno
 1 x Protoboard
 1 x LDR
 1 x Potenciómetro 10kΩ
 5 x Diodos LED
 5 x Resistencias 220Ω
 1 x Resistencia 1KΩ
 1 x Juego de Cables

Parte 2: Diseñando el hardware…

En este proyecto lo que queremos conseguir es que, a partir de una resistencia que varía su valor óhmico
en función de que haya más o menos luz, controlar 5 salidas de nuestro Arduino, a las que podríamos
conectar líneas de iluminación para un jardín por ejemplo, de manera que según va anocheciendo,
nuestra iluminación artificial va aumentando.

Además, vamos a colocar un potenciómetro para regular el umbral de luz mínima, a partir del cual,
comenzará a funcionar nuestro circuito de luz artificial para que sea adaptable a cualquier entorno.

Dividamos el circuito en tres partes:

 Salidas
 LDR
 Regulador

Para las salidas, ya hemos aprendido en otros tutoriales como conectar unos diodos LED y como calcular
su resistencia óptima.

En cuanto al LDR, es nuevo para nosotros, en breve tendréis disponible un tutorial sobre este
componente, así que de momento nos vamos a quedar en que funciona como una resistencia variable de
manera que, cuanta más cantidad de luz reciba, menor será su resistencia, para que quede claro, si en un
potenciómetro variábamos la resistencia deslizando un patín por la pista de material resistivo, aquí lo
hará la cantidad de luz que reciba la foto-resistencia.

¿Qué podemos deducir con esto?

Que si añadimos una resistencia más, podemos utilizar el LDR para hacer el ya conocido divisor de
tensión de donde sacaremos la señal para conectar a nuestra entrada analógica de Arduino.
Podemos conectarlo de dos maneras diferentes:

Si utilizamos el LDR como resistencia inferior del divisor de tensión, nos dará la tensión máxima cuando
tengamos el LDR en plena oscuridad, ya que estará oponiendo el máximo de su resistencia al paso de la
corriente derivándose esta por Vout al completo, si lo utilizamos como resistencia superior, el resultado
será el inverso, tendremos la tensión máxima cuando esté completamente iluminado, ya que se
comportará prácticamente como un cortocircuito, con una resistencia de 50Ω o 100Ω.

En este caso lo hemos utilizado como resistencia superior, de manera que cuanta más luz haya, más
tensión tendremos a la entrada de nuestra entrada analógica pudiendo ajustar así, de una manera muy
intuitiva, la tensión de referencia que ahora explicaré.

Como tercera parte del circuito, hemos colocado un potenciómetro configurado como divisor de tensión
para hacer las funciones de regulación del rango de iluminación a partir del cual se activará nuestro
circuito de iluminación.

¿Como hemos conseguido esto?

Primero hay que pensar un par de cosas, nuestra foto-resistencia configurada como divisor resistivo, nos
va a dar 0v cuando este COMPLETAMENTE a oscuras, y +5v cuando esté COMPLETAMENTE
iluminada, situaciones que pueden ser difíciles de conseguir dependiendo del entorno en el que
trabajemos, y por otra parte, ese rango de 0v a 5v habrá que dividirlo en 1024 “pasos” que va a leer
nuestro Arduino, pero quizás solo vayamos a trabajar en 500 o 600 pasos, desperdiciando mucha
resolución.

Para solucionar esto, además de evitar cambiar el programa de Arduino cada vez que lo cambiemos de
entorno, he decido usa una función que nos proporciona Arduino muy internaste, el pin “Aref”

¿Qué es el pin AREF?

Cuando Arduino toma una señal analógica y la convierte a digital en 1024 cachitos, lo hace por defecto
pensando que la señal que va a recibir puede variar entre 0v y 5v lo que nos da aproximadamente un
valor por cada 4,88 mV, pero nosotros podemos decirle que no, que realmente va a trabajar entre 0v y
3v, obteniendo así 1024 cachitos distribuidos entre 0v y 3v, lo que nos da un valor por cada 2,9 mV, es
decir una resolución mucho mayor.
Debemos tener en cuenta que este pin lleva internamente una resitencia de 32KΩ para evitar dañar el
chip, de manera que si vamos a conectar el pin mediante una resistencia fija, se va a producir un nuevo
divisor de tensión, con lo que habrá que calcular la resistencia adecuada para la tensión exacta que
queremos introducir mediante una sencilla fórmula:

Donde:

 Vin = Tensión que introducimos a Vref


 Rinterna = Resistencia interna de Arduino de 32KΩ
 Rexterna = Resistencia mediante la cual alimentamos Vref
 Vrefencia = La tensión sobre que tomará referencia nuestro programa.

De manera que si por ejemplo, estamos introduciendo una tensión de +3v a través de una resistencia de
5KΩ, la tensión real de referencia en nuestro Arduino será de:

(32000/(32000+5000)) x 3 = 2,59v

¿Porqué evita cambiar el programa continuamente?

Por que variando la señal de referencia, le estamos diciendo que nos tome 1024 valores entre 0v una
determinada tensión máxima, y el reparto de esos valores ya los hemos fijado equitativamente en nuestro
programa para que haga una activación progresiva de las líneas de iluminación, por tanto, aunque
tengamos un rango muy bajo de iluminación con el que jugar, de 1v por ejemplo, nos va a distribuir
siempre proporcionalmente la activación de las salidas.

Esa tensión de referencia, será el punto de iluminación a partir del cual, si decrece la luz ambiente,
empezará a decrecer los valores obtenidos en la señal analógica de entrada.

Si ponemos esa referencia muy baja, empezará a funcionar los led con menos luz ambiente que si
ponemos una señal muy alta, recordemos:

 Más luz = Menos Resistencia = Mayor Vout


 Menos luz = Mayor resistencia = Menor Vout

Veamos el esquema eléctrico del circuito al completo:


Y aquí un a posible distribución del circuito en vuestra protoboard:
Parte 3: Programando…

Este programa es algo más largo que los anteriores, pero desgranándolo poco a poco seguro que
seremos capaces de entenderlo.

Primero veamos el código al completo:

/*
Tutorial # 0004 Arduino Academy - Sensor LDR

Conectamos una foto-resistencia a la entrada


analógica para controlar cinco salidas
en función de la luz ambiente.

Este proyecto es de dominio público.


*/

//Aquí almacenamos los datos recogidos del LDR:


int valorLDR = 0;

//Decimos que pines vamos a utilizar para LED


int pinLed1 = 12;
int pinLed2 = 11;
int pinLed3 = 10;
int pinLed4 = 9;
int pinLed5 = 8;

//Y que pin para la LDR


int pinLDR = 0;

void setup()
{
//Establecemos como salida los pines para LED
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Le decimos que vamos a usar una referencia externa


analogReference(EXTERNAL);

void loop()
{
//Guardamos el valor leido en una variable
valorLDR = analogRead(pinLDR);

//Y comenzamos las comparaciones:


if(valorLDR >= 1023)
{
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 823) & (valorLDR < 1023))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 623) & (valorLDR < 823))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 423) & (valorLDR < 623))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 223) & (valorLDR < 423))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}

En este programa os tiene que resultar casi todo conocido de los anteriores proyectos, si no, os
recomiendo echar un vistazo alos anteriores tutoriales Arduino que tenemos en la despensa. La
instrucción que no hemos visto nunca es la siguiente:

analogReference(EXTERNAL);

Con esta instrucción le estamos diciendo a nuestro Arduino, que no use su tensión de referencia por
defecto (+5v) sino la que nosotros introduzcamos por el pin AREF de nuestra placa, como explicamos
en la sección de hardware.

A continuación podemos ver que en el loop, lo primero que hacemos es almacenar la lectura de la entrada
analógica en una variable para luego, dependiendo de los datos obtenidos, hacer una cosa u otra.

valorLDR = analogRead(pinLDR);

Y una vez obtenida la lectura empezamos la discriminación mediante sentencias if.. if else.. else..
Utilizamos if else para añadir varias condiciones seguidas, y un último else para cerrar las condiciones.

En el siguiente diagrama de flujo de programa podemos ver como actuará Arduino a nuestras
comparaciones:
Podríamos haber acortado alguna línea de programa con un par de cambios, pero creo que de esta manera
se entiende mejor dado que estamos empezando, ya habrá tiempo de complicar el tema!

Y eso es todo por hoy!

Y si hay algún resquicio del proyecto que no acabéis de entender, escribir un comentario con vuestras
dudas.

Hasta pronto!!
Tutorial Arduino # 0005 – Sensor de temperatura NTC

Autor:

Fecha: 4 diciembre, 2011

Compartir en
facebook

twitter

google

pinterest

# Sensor de temperatura NTC

Bienvenidos a un nuevo tutorial para sacar el máximo partido a vuestro Arduino, seguimos con los
sensores, en este caso exploramos las posibilidades de un sensor de temperatura NTC:

 Nivel: Básico
 Coste: <30€
 Tiempo: 25′

Os recomiendo leer previamente los anteriores tutoriales por si tenéis dificultades en alguna parte
de este proyecto, o bien, para recordar conceptos de programación ya mostrados.

Parte 1: ¿Que vamos a hacer?

En este proyecto vamos a aprender a implementar un sensor de temperatura a nuestros proyectos


Arduino, en este proyecto simularemos cinco estados de aviso de exceso de temperatura, sobre los cuales
los cuales podríamos conectar cualquier elemento que quisiéramos que actuara llegado dicho nivel,
podríamos conectar circuitos de ventilación de manera que si no consiguieran mitigar el exceso de calor
llegara un punto que desconectara el sistema que estemos monitorizando, en resumen, en cualquier lugar
donde un control de exceso de temperatura sea necesario.

También vamos a controlar la temperatura vía puerto serie, ya que todavía no hemos hablado de cómo
utilizar los LCD en nuestro Arduino, todo llegará.

De nuevo hemos incorporado un pequeño potenciómetro que nos permitirá establecer una temperatura,
a partir de la cual nos vaya dando los avisos (led) en unos intervalos fijados en nuestro programa.

He elegido realizar un programa de aviso de exceso de temperatura, pero igualmente se podría utilizar
el NTC para un sistema en que necesitemos controlar que no descienda la temperatura a partir de un
punto crítico.

Veamos un video que muestra el resultado final:

Material necesario para este proyecto:

 1 x Arduino Uno
 1 x Protoboard
 1 x NTC
 1 x Potenciómetro 10kΩ
 5 x Diodos LED
 5 x Resistencias 220Ω
 1 x Resistencia 1KΩ
 1 x Juego de Cables

Parte 2: Diseñando el hardware…

En este nuevo proyecto Arduino tenemos que conseguir, mediante una NTC (Negative Temperature
Coefficient o Coeficiente de Temperatura Negativo) activar 5 salidas de nuestro Arduino, una de esas
salidas nos mostrará que la temperatura está por debajo del nivel crítico, y a partir de ese nivel, irá
activando una salida tras otra cada dos grados que aumente la temperatura.

Veréis en el video que según va aumentando la temperatura, se van incrementado los LED encendidos,
lo he realizado así por que es más visual para la comprensión del funcionamiento, podréis ver en la
sección de programación que es muy sencillo cambiar esto para que solo active un LED o varios, o lo
que necesitéis.

Además vamos a colocar un potenciómetro para ajusta la temperatura, a partir de la cual, nos empezará
a lanzar los avisos.

Visto esto, estructuremos el circuito en tres partes:

 Entrada de temperatura ambiente.


 Entrada de ajuste mínimo de temperatura.
 Salidas.

Entrada de temperatura ambiente.


Estamos utilizando una NTC, es decir, una resistencia con coeficiente de temperatura negativo respecto
a la variación de su resistencia, esto es que a más temperatura, aumentará la concentración de portadores,
lo que hará que su resistencia sea menor.

La manera de conectar este sensor a nuestro circuito va a ser formando un divisor de tensión con su
salida a una entrada analógica (podéis ver en este ejemplo como funciona una entrada analógica), en el
que nuestra NTC será la resistencia inferior, lo que además nos protegerá de un problema que tienen
estos sensores, cuando la corriente que circula por él es baja, no tenemos ningún problema, pues la
disipación de calor es casi nula (VxI2) pero si la aumentamos, llegamos a un punto en que esa disipación
afecta a la resistencia del sensor, por lo que deducimos que la respuesta de una NTC no es lineal sino
hiperbólica, pero al colocarlo como un divisor de tensión la variación de tensión Vout va a ser
prácticamente lineal.

En cuanto a la otra resistencia que formará el divisor de tensión, utilizaremos una de 1KΩ, esto es así
para aprovechar el rango de muestreo que nos proporciona Arduino con un consumo de corriente
limitado, veamos rápidamente el motivo.

Si recordamos la ecuación del divisor de tensión:

Veremos que si la resistencia máxima de nuestra NTC va a ser 10KΩ, y la fija de 1KΩ, tendremos una
variación de tensión entre 0v y 4,55v. Podéis hacer cuentas vosotros mismos con otros valores y veréis
que si aumentamos la resistencia, disminuye el rango de Vout, y si la disminuimos, aumentará los
consumos de corriente en exceso.

Entrada de ajuste mínimo de temperatura.

Para tener un mando sobre el que ajustar la temperatura mínima, simplemente colocaremos un
potenciómetro dispuesto como divisor de tensión, a una de las entradas analógicas y utilizaremos su
muestreo para mapearlo a nuestro antojo como veremos en la sección de programación.

Salidas.

Para las salidas utilizaremos la ya conocida configuración de LED más resistencia.


De manera que el esquema eléctrico global nos quedaría así:

Y las conexiones en nuestra protoboard…


Parte 3: Programando…

Veamos primero el código al completo:

/*
Tutorial # 0005 Arduino Academy - Sensor NTC

Conectamos una NTC a una entrada


analógica para controlar cinco salidas
en función de la temperatrura.

Además utilizaremos un ponteciómetro para


controlar la temperatura a partir de la cual
se activarán las salidas

Este proyecto es de dominio público.


*/

//Añadimos la librería math.h


#include <math.h>

//Pines para los LED


int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;

//Pines para las entradas analógicas


int analogPin1 = 0;
int analogPin2 = 1;

//Escala de Avisos
int escala = 2;

//Variable para la temperatura de disparo


double tempMin = 0.0;

//Datos para las ecuaciones

float Vin = 5.0; // [V] Tensión alimentación del divisor


float Rfija = 1000; // [ohm] Resistencia fija del divisor
float R25 = 2800; // [ohm] Valor de NTC a 25ºC
float Beta = 3900.0; // [K] Parámetro Beta de NTC
float T0 = 293.15; // [K] Temperatura de referencia en Kelvin

float Vout = 0.0; // [V] Variable para almacenar Vout


float Rntc = 0.0; // [ohm] Variable para NTC en ohmnios

float TempK = 0.0; // [K] Temperatura salida en Kelvin


float TempC = 0.0; // [ºC] Temperatura salida en Celsius

void setup() {

//Comenzamos la comunicación puerto serie


Serial.begin(9600);

//Declaramos pines de salida


pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Y los pines de entrada


pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);

void loop()
{
//Primero leemos el pootenciómetro
tempMin = analogRead(analogPin2);
//Lo mapeamos a valores de -100 a 800
tempMin = map (tempMin, 0, 1023, -100, 800);
//Y lo dividimos entre 10 para darle un decimal
tempMin = tempMin/10;

//Y lanzamos el ajuste establecido via serie


Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");

//Y ahora calculamos la Temperatura

//Primero la Vout del divisor


Vout=(Vin/1024)*(analogRead(analogPin1));

//Ahora la resistencia de la NTC


Rntc=(Vout*Rfija)/(Vin-Vout);

//Y por último la temperatura en Kelvin


TempK = Beta/(log(Rntc/R25)+(Beta/T0));
//Y ahora la pasamos a celsius
TempC = TempK-273.15;

//Y lo mostramos por puerto serie


Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS CELSIUS");
Serial.println();

//Ahora las comparaciones para las salidas


if(TempC < tempMin)
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC <= (tempMin + escala)) & (TempC > tempMin)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC<=(tempMin+(escala*2)))&(TempC>tempMin+escala)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if ((TempC<=(tempMin+(escala*3)))&(TempC>tempMin+(escala*2)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else if (TempC > (tempMin + (escala*4)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}

//Un pequeño delay para no volver loco al puerto serie


delay(500);
}

Empecemos a sacarle brillo!

La primera línea que nos resulta desconocida es:

#include <math.h>

Cuando ponemos #include <librería.h> lo que hacemos es importar las funciones que haya en esa librería
a nuestro programa, en este caso, la librería math.h nos va añadir la posibilidad de realizar operaciones
matemáticas algo más complejas, es como cuando Neo aprendía a hacer cosas en Matrix en segundos..
(punto friki.. sorry).
En arduino tenemos infinidad de librerías que iremos descubriendo poco a poco, sigamos!

Lo siguiente que nos encontramos es la definición de los pines de entrada y de salida, ya sabemos de
sobra a que nos referimos si habéis seguido los anteriores tutoriales.

//Pines para los LED


int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;

//Pines para las entradas analógicas


int analogPin1 = 0;
int analogPin2 = 1;

Pero después de esto declaramos la variable “escala” como entero:

int escala = 2;

Esta variable la utilizaremos para establecer el intervalo que queremos que haya entre alarmas, es decir,
si yo pongo una temperatura de disparo de 20ºC, con una escala de 2 la primera alarma será a 20º, la
segunda a 22º, la tercera a 24º, etc…

Ahora introduciremos los datos para hacer las ecuaciones que nos permitirán, en base a a la lectura de
nuestra entrada analógica conectada al divisor de tensión, calcular la temperatura.

float Vin = 5.0; // [V] Tensión alimentación del divisor


float Rfija = 1000; // [ohm] Resistencia fija del divisor
float R25 = 2800; // [ohm] Valor de NTC a 25ºC
float Beta = 3900.0; // [K] Parámetro Beta de NTC
float T0 = 293.15; // [K] Temperatura de referencia en Kelvin

float Vout = 0.0; // [V] Variable para almacenar Vout


float Rntc = 0.0; // [ohm] Variable para NTC en ohmnios

float TempK = 0.0; // [K] Temperatura salida en Kelvin


float TempC = 0.0; // [ºC] Temperatura salida en Celsius

Veréis que a la hora de definir el tipo de cada variable, tenemos algo nuevo, la variable de tipo “float”,
esta variable es para los números en coma flotante (número decimal), estas variables tienen un valor
máximo 3.4028235E+38, y como mínimo -3.4028235E+38. Ocupan 4bytes (32bits) con una resolución
mucho mayor que los enteros, lo que nos permitirá hacer cálculos bastante precisos, debemos tener en
cuenta no olvidarnos de poner la coma en los números que utilicemos en la operación como vemos en
las líneas de código, de manera que evitemos errores de interpretación en nuestro programa.

En cuanto a los parámetros necesitaremos conocer 2 datos de nuestra NTC que vendrán dispuestos en el
datasheet, una resistencia de referencia a una temperatura determinada, en nuestro caso 2800Ω a 25º y
la Beta de nuestra NTC en Kelvin, para nosotros 3950 K.

Un poco más abajo explicaremos en detalle todo esto.

Un vez finalizada la declaración de variables globales, nos toca “configurar” el setup, de nuevo tenemos
una línea nueva!

Serial.begin(9600);

Esta instrucción nos inicializa la comunicación puerto serie desde Arduino al PC a una velocidad de
9600 baudios (bits por segundo), con esto, cualquier cosa que enviemos lo podremos visualizar en el
monitor de puerto serie de nuestro software de Arduino o cualquier otro.
Luego, como siempre, declaramos que pines van a ser entradas y cuales van a ser salidas.

//Declaramos pines de salida


pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Y los pines de entrada


pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);

Ahora comenzamos con el bucle, en primer lugar leemos la señal de nuestro potenciómetro para
establecer una temperatura de referencia sobre la que comparar la temperatura de la NTC y disparar los
avisos.

Primero leemos el valor del pin analógico 2 y lo almacenamos en tempMin:

tempMin = analogRead(analogPin2);

A continuación tenemos una nueva instrucción:

tempMin = map (tempMin, 0, 1023, -100, 800);

La función map tiene esta estructura:

map(valor, fromLow, fromHigh, toLow, toHigh)

Es decir, como si le dijéramos: Transfórmame “tempMin”, que puede ir


de 0 a 1023 en valores escalonados y proporcionados desde -100 has
800.

Con esto adaptamos la lectura del potenciómetro a un rango de -100 a


800, esto lo hemos hecho así para que al dividir entre 10 el valor:

tempMin = tempMin/10;

Nos devuelva una temperatura de referencia entre -10.0º y +80.0º, con esto podremos ajustar la
temperatura de disparo con una precisión de 0.1º.

A continuación lo que hacemos es mandar por el puerto serie el dato prefijado para tener una
referencia visual del mismo.

Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");

Vemos dos instrucciones nuevas:

Serial.println(); //Imprime y salta a Línea Nueva


Serial.print(); //Imprime en la misma línea
Esto nos enviará por puerto serie cualquier cosa que incluyamos dentro de ( ), si es una variable, con
poner el nombre de la variable es suficiente, como se puede ver con tempMin, pero también podemos
mandar cualquier texto que queramos, siempre que lo incluyamos entre comillas, como se puede ver, yo
lo único que he hecho es crear unas líneas de separación entre la variable que lanzo, para que se lean
mejor los datos vía serie.

Y ahora llega lo más complicado del programa, el cálculo de temperatura a partir de la medida analógica.

Para realizar esto debemos conocer algo de teoría.

Teniendo en cuenta que el fabricante nos da el valor resistivo para una temperatura en concreto (en
nuestro caso 2800Ω para 25º) y la Beta (Temperatura característica del material entre 2000K y 4000K)
podemos utilizar la ecuación que relaciona la resistencia de la NTC y la temperatura para calcular esta
última, primero veamos la ecuación:

Siendo:

 Rt = Resistencia a temperatura T en grados Kelvin (k = ºC + 273,15)


 Ro = Resistencia de referencia a una temperatura To en Kelvin.
 B = Valor Beta de nuestra NTC.
 To = Temperatura de referencia en Kelvin.
 T = Temperatura a medir.

Con esta ecuación podremos saber cual será la resistencia máxima que nos va a dar nuestra NTC al
calcular su curva característica, en nuestro caso, 10KΩ lo que nos sirve para diseñar el divisor de tensión.

Observamos que, si calculamos Rt, tendremos todos los datos para hallar la temperatura en un valor de
resistencia determinado despejando T, veamos la ecuación despejada que utilizaremos en nuestro
programa:
Bien, ya tenemos la ecuación para hallar la temperatura, pero nos faltaría saber cual es la resistencia de
la NTC, para esto primero calcularemos cual es la tensión de entrada de nuestra entrada analógica, es
decir, la Vout de nuestro divisor de tensión:

Con esto hallamos cuanto vale cada bit de la conversión analógico-digital (recordemos que nuestro
conversor divide los 5 voltios entre 1024 cachitos) y lo multiplicamos por la cantidad de bit que nos lee
la entrada analógica, con lo que tenemos la tensión que le está llegando a la entrada analógica.

Una vez tenemos esto, si recordamos la fórmula del divisor de tensión:

Vemos que tenemos todos los datos a excepción de Rinferior, que es justo la resistencia de la NTC que
necesitamos para calcular la temperatura, por lo que despejando nos queda:

Con esto ya tenemos todos los datos para calcular nuestra temperatura a partir de las lecturas de la entrada
analógica, de manera que nos quedará de la siguiente manera al plasmarlo en nuestro programa.

//Primero la Vout del divisor


Vout=(Vin/1024)*(analogRead(analogPin1));

//Ahora la resistencia de la NTC


Rntc=(Vout*Rfija)/(Vin-Vout);

//Y por último la temperatura en Kelvin


TempK = Beta/(log(Rntc/R25)+(Beta/T0));

//Ahora la pasamos a celsius


TempC = TempK-273.15;

Ahora lo único que hacemos es enviarlo como antes he explicado por el puerto serie:

Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Para mostrar las salidas podéis ver que el código es muy similar al del proyecto del diodo LED, si
necesitáis que lo explique no tengo inconveniente, pero no quiero repetir demasiadas cosas en los post,
creo que se entienden muy bien las comparaciones.

El delay que hemos puesto al final es para que los mande la temperatura cada medio segundo por el
puerto serie.

Y esto es todo!!

Como veis vamos aumentando el nivel progresivamente, espero que no sean demasiado bruscos los
cambios, si es así decírmelo!!

Hasta pronto!!
Tutorial Arduino #0002 – E/S DIGITALES

Autor:

Fecha: 14 noviembre, 2011

Compartir en
facebook

twitter

google

pinterest

#0002 – E/S DIGITALES


Bienvenidos a un nuevo tutorial básico sobre Arduino.

Parte 1: ¿Qué vamos a hacer?

En este tutorial de Arduino, vamos a aprender a configurar una entrada digital a la que conectaremos
un pulsador y, con lo aprendido sobre el LED en el anterior tutorial, nos permitirá controlar el encendido
y apagado del diodo.

Veamos el resultado final en un video:


Material necesario para el proyecto:

 1 placa Arduino.
 1 protoboard.
 1 diodo LED.
 1 resistencia 220Ω.
 1 resistencia 10K.
 1 pulsador.

Parte 2: Diseñando el Hardware…

En este proyecto, deberemos interpretar en nuestro programa la lectura de una entrada digital, y en base
a su lectura, activaremos, o no, una salida digital a la que conectamos un diodo LED, es un ejemplo
sencillo, pero que nos permite aclarar un concepto muy importe sobre las entradas digitales, las
resistencias de Pull-Up o Pull-Down.

¿Qué son las resistencias de Pull-Up o Pull-Down?

En nuestro Arduino, las entradas digitales se interpretan de la siguiente manera:

 1 (lógico) = Hight = +5v


 0 (lógico) = Low = 0v

¿Esto quiere decir? Que si tenemos una tensión de +5v aplicada a una entrada, este nos la interpretara
como un 1 (hight) sin lugar a dudas, pero no es así al contrario, si nosotros dejamos dejamos de aplicar
esa tensión a la entrada digital, es posible que recibamos algo de ruido del circuito y que Arduino no nos
lo interprete como un 0 (low) por lo que colocamos una resistencia entre la entrada y masa (GND) que
derive estos ruidos asegurandonos una señal limpia y sin posibles errores, a la resistencia que se conecta
a masa se le llama PULL-DOWN.

De igual manera, si tuviéramos la necesidad de mantener un 1 lógico en una entrada mientras el circuito
está en reposo, se le puede aplicar una resistencia entre la entrada y +5v para asegurarnos que le llega
sufiente tensión como para que sea interpretada correctamente por nuestro Arduino, a esta última se le
denomina PULL-UP.
Aquí podéis ver como se conectaría la resistencia en un circuito básico de 0 o 1 en la entrada 8 de
Arduino.

Una vez conocido esto, el resto del circuito no tiene misterio, deberemos colocar el LED correctamente
polarizado con su resistencia, y el pulsador con una resistencia de PULL DOWN de 10KΩ a masa para
cuando esté en reposo, de manera que cuando pulsemos el botón, llegue una tensión 5v a la entrada 2 de
Arduino y este lo interprete como un 1 lógico, a partir de aquí el programa hará el resto para
proporcionarnos la tensión de salida que activará el diodo LED.

Las conexiones en nuestra protoboard nos quedarían de la siguiente manera:


Para observar con más detalle las conexiones entre componentes se puede observar el siguiente esquema
eléctrico:

Como se puede observar, los pulsadores electrónicos parecen llevar cuatro patillas, pero en realidad sólo
son dos muy largas que salen por los laterales del pulsador para facilitar las conexiones, de manera que
si lo colocamos y el LED se enciende continuamente, es muy posible que lo hayamos conectado mal, si
tenéis un polímetro, colocarlo en modo continuidad y aseguraos de la posición correcta.

Parte 3: Programando…

Comencemos como siempre por el programa completo que posteriormente desglosaremos.

/*
Tutorial #0002 Arduino Academy - E/S DIGITALES

En este proyecto encenderemos un LED conectado


al pin digital 12 cuando presionemos el pulsador
asociado al pin digital 2.

Este proyecto es de dominio público


*/

// Variables estáticas
int pinBoton = 2; // Declaramos la variable pin del Botón
int pinLed = 12; // Declaramos la variable pin del Led

// Variables dinámicas
int estadoBoton = 0; // Variable para estado del botón

void setup() {
// Inicializa el pin del LED como salida:
pinMode(pinLed, OUTPUT);
// Inicializa el pin del botón como entrada:
pinMode(pinBoton, INPUT);
}

void loop(){
// Lee el valor del pin del botón y lo almacena
// en la variable estadoBoton
estadoBoton = digitalRead(pinBoton);

// Chequea si el botón está pulsado:


if (estadoBoton == HIGH) {
// Si es así, enciende el LED:
digitalWrite(pinLed, HIGH);
}

else {
// Si no, lo mantiene apagado:
digitalWrite(pinLed, LOW);
}
}

Como veréis algunas instrucciones ya han sido vistas en el anterior tutorial, así que nos centraremos en
aquellas que son nuevas para nosotros.

En primer lugar podemos observar que antes del setup hemos declarado unas variables globales, y
ademas las hemos organizado en estáticas y dinámicas:

// Variables estáticas
int pinBoton = 2; // Declaramos la variable pin del Botón
int pinLed = 12; // Declaramos la variable pin del Led

// Variables dinámicas
int estadoBoton = 0; // Variable para estado del botón

Para definir una variable imaginemos que queremos comprar una recipiente en el que vamos a guardar
algo, y depende de lo que queramos introducir, tendrá que ser de una manera o de otra, si es líquido, no
puede ser de cartón, si es algo pesado no puede ser frágil… Eso es una variable, un lugar en el que
almacenaremos algo para utilizar en nuestro programa, y si no las declaramos antes de utilizar, es como
si no hiciéramos hueco en nuestra despensa para guardarlas, otra característica es que su inicialización
no siempre es obligatoria, pero es recomendable, esto es como meter una pieza de cada producto que
vayamos a guardar en nuestras cajas, en este caso les hemos asignado un valor desde el principio por las
necesidades del programa.

¿Y como le digo si es de cristal o de cartón?

Definiendo el tipo de variable a utilizar, en este programa hemos utilizado las de tipo int pero existen
muchas más dependiendo de nuestras necesidades que iremos descubriendo en los siguientes programas,
de momento nos quedamos con la siguiente:

 Variable de tipo int: Almacena números enteros con un rango de -32768 a 32767

Al principio de la explicación, las he descrito en primer lugar como variables globales, esto es que al
estar fuera de todo ciclo, pueden ser utilizadas a lo largo de todo el programa ahorrándonos mucho
código, en ejemplos posteriores veremos otros lugares donde declararlas.

Y por último, en lo que respecta a las variables, las he organizado como estáticas, aquellas que serán
constantes en nuestro programa, y dinámicas, aquellas que variaremos su valor en algún lugar del
programa

Como novedad, podemos ver que en lugar de asignar un valor numérico en la instrucción pinMode para
decirle el pin sobre el que queremos trabajar, le hemos asignado una variable, y a la hora de interpretar
el programa, este utilizara lo que hayamos elegido introducir en nuestro recipiente, en este caso el
número entero 12 para la salida del LED y el número entero 2 para la entrada del pulsador.

void setup() {
// Inicializa el pin del LED como salida:
pinMode(pinLed, OUTPUT);
// Inicializa el pin del botón como entrada:
pinMode(pinBoton, INPUT);
}

Para explicar el loop, lo dividiré en dos partes, en primer lugar, tenemos que cada vez que se ejecute el
ciclo loop, lo primero que va a hacer es almacenar en nuestra variable dinámica de tipo int
“estadoBoton”, la lectura del pin 2 de nuestro Arduino.

estadoBoton = digitalRead(pinBoton);

Y ahora llega algo nuevo, el ciclo if… else, este ciclo es un condicional básico en programación, lo que
hace en nuestro programa es comprobar primero si nuestra variable estadoBoton está a 1 lógico, y, a
continuación, con el resultado obtenido de esa comparación, elige un camino u otro, si es que sí, entonces
encenderá el LED poniendo en HIGH, si es que no, entonces pondrá en LOW nuestra salida del LED
apagándolo.

// Chequea si el botón está pulsado:


if (estadoBoton == HIGH) {
// Si es así, enciende el LED:
digitalWrite(pinLed, HIGH);
}

else {
// Si no, lo mantiene apagado:
digitalWrite(pinLed, LOW);
}

Y con esto hemos concluido la explicación del segundo tutorial de Arduino Academy, si ha quedado
algún detalle por aclarar, animaos a mandar vuestros comentarios para así ir mejorando los
proyectos…

Hasta pronto!!!
Tutorial Arduino # 0003 – Entrada Analógica y Salida PWM

Autor:

Fecha: 19 noviembre, 2011

Compartir en
facebook

twitter

google

pinterest

# 0003 – Entrada Analógica y Salida PWM


Bienvenidos a un nuevo tutorial básico sobre Arduino.

 Nivel: Básico
 Coste: < 25 €
 Tiempo: 15′

Parte 1: ¿Qué vamos a hacer?

En este nuevo proyecto vamos a aprender utilizar las entradas analógicas de nuestro pequeño Arduino
Uno para utilizarla en dos ejemplos, primero variaremos la frecuencia de parpadeo de un diodo LED con
un potenciómetro conectado a una entrada analógica y luego utilizaremos el mismo circuito para realizar
una modulación del ancho de un pulso en una salida digital (PWM).

En el siguiente video podemos ver el resultado final de los dos ejemplos…

Material necesario para este proyecto:


 1 x Arduino Uno
 1 x Diodo Led
 1 x Resistencia 470 Ω
 1 x Potenciómetro 1KΩ
 1 x Protoboard
 1 x Juego de cables

Parte 2: Diseñando el Hardware…

En este proyecto Arduino vamos a realizar dos ejemplos con un mismo circuito, la diferencia entre ellos
la observaremos es el apartado de programación, en cuanto a hardware tenemos la novedad de este
proyecto en el uso de un potenciómetro combinado con una entrada analógica, así que primero
aclararemos unos conceptos.

¿Qué es un potenciómetro?

Un potenciómetro es una resistencia de tipo variable con tres patillas, entre las dos de sus extremos
tendremos siempre una resistencia fija dada por del valor máximo de nuestro potenciómetro, pero entre
cualquiera de esos extremos y la patilla central obtendremos la variación de resistencia, tenéis disponible
un tutorial sobre este componente AQUI.

En este proyecto, vamos a utilizar el potenciómetro como un divisor de tensión, primero veamos como
se conecta para que esto sea posible.
Como podemos ver, debemos colocar uno de los extremos a masa, otro a +Vcc y nuestra patilla central
será nuestra tensión de salida regulable, esta salida será la que conectemos a Arduino y que variará de
0v a 5v dependiendo de la posición de nuestro potenciómetro.

Podemos ver la variación de tensión en el siguiente video:

Si estamos utilizando un Arduino Uno, las entradas analógicas vienen identificadas desde A0 hasta A5
como podemos ver en la siguiente imagen:

En cuanto a la salida, colocaremos la ya conocida configuración de LED más resistencia, pero deberemos
tener algo en cuenta, para el primer ejemplo nos daría igual la salida digital a elegir, pero para el segundo
es necesario que seleccionemos una salida con PWM, si tenéis un Arduino Uno, las salidas serán la 3,
5, 6, 9, 10 y 11 como se puede ver en la siguiente imagen:
Pero.. ¿Qué es el PWM?

A menudo necesitaremos algo más que una señal de 0 o 1 en nuestros proyectos, para variar la velocidad
de giro de un motor, para variar la intensidad con la que luce un diodo, para transmitir los grados de giro
de un servo, etc..

Para todo esto, y mucho más, nos servirá el PWM, que emula una señal analógica a partir de una señal
digital.

Las siglas PWM vienen de Pulse Width Modultation, o Modulación de Ancho de Pulso.

Lo que hace este tipo de señal es emitir, en lugar de una señal continua en nuestra salida, emite una serie
de pulsos que podremos variar su duración pero con una frecuencia constante de aproximadamente
490Hz, de manera que la tensión promedio resultante, es directamente proporcional a la duración de
estos dentro del rango de nuestro periodo, es decir, cuanto más juntos estén esos pulsos de +5v, mayor
será la tensión promedio de nuestra salida, y cuanto más distantes sean estos, menor será dicha tensión:
Veamos un video del PWM en acción, observar como se corresponde la intensidad lumínica del LED
con el ancho de pulso observado en el osciloscopio:

La manera de controlar el nivel de salida en nuestro Arduino, la podremos ver en la sección de


programación de este tutorial.

El montaje nos quedaría así en nuestra protoboard:


Aquí podemos ver en detalle el esquema eléctrico:
El circuito en si mismo es muy sencillo, pero en el apartado de programación podremos ver la
versatilidad del mismo para diferentes aplicaciones, así que no esperemos más…

Parte 3: Programando…

El primer ejemplo que vamos a tratar es la adquisición de datos en la entrada analógica A0 para variar
la frecuencia de parpadeo de un diodo LED conectado a una salida digital cualquiera, veamos el código
al completo:

/*
Tutorial # 0003 Arduino Academy - Entrada analógica

Funcionamiento de las entradas analógicas configurando


el pin analógico A0 para tomar datos de una señal.
Esta toma de datos es utilizada para variar la velocidad
de parpadeo de un diodo LED conectado a la salida digital 9.

Este proyecto es de dominio público.


*/

int pinSensor = A0; // Entrada para el potenciómetro.


int pinLed = 9; // Seleccionamos pin para el Led.
int valorSensor = 0; // variable para el valor del sensor.

void setup() {
// Declaramos el pin del Led como salida:
pinMode(pinLed, OUTPUT);
}

void loop() {
// Leemos el valor del sensor y lo almacenamos:
valorSensor = analogRead(pinSensor);
// encendemo el diodo LED:
digitalWrite(pinLed, HIGH);
// Detenemos el programa durante <valorSensor> milisegundos:
delay(valorSensor);
// Apagamos el diodo Led:
digitalWrite(pinLed, LOW);
// Detenemos el programa durante <valorSensor> milisegundos:
delay(valorSensor);
}

En este programa tenemos como novedad la siguiente instrucción:

analogRead(pinSensor)

Esta instrucción nos permite leer cualquier sensor que conectemos al pin analógico establecido en
“pinSensor”, por defecto, nuestra placa Arduino nos realizará una conversión analógico-digital para toda
señal (40mA máximo) de 0v a 5v con una resolución de 10 bit, lo que nos da 210 (1024) valores de
referencia para nuestro programa, siendo 0 en 0v y 1023 en +5v, en posteriores ejemplos veremos como
ese rango de tensión en el que se realizan las mediciones se puede variar para que, por ejemplo, empiece
a lanzarnos valores a partir de 2,2v.

Con esto, y observando un poco el programa, podemor ver que el intervalo entre encendido y apagado
de nuestro diodo LED podrá variar entre 0 y 1023 milisegundos, si quisiéramos aumentar más el tiempo
de los intervalos podríamos aplicar alguna operación matemática al valor de nuestro sensor, por ejemplo,
si añadiéramos la línea de código que se puede observar debajo de la toma de datos del sensor
obtendríamos un incremento del tiempo cuatro veces mayor:

// Leemos el valor del sensor y lo almacenamos:


valorSensor = analogRead(pinSensor);
valorSensor = valorSensor*4;

Sin variar el circuito, vamos a introducir un nuevo código para realizar un ejemplo diferente, en este
proyecto, nuestro diodo LED variará su intensidad lumínica en función del valor que esté aportando el
potenciómetro a nuestra entrada analógica, esto es el llamado efecto fading (desvanecimiento), puede
observarse que se ha elegido la salida número 9, ya que esta sí que es compatible con la opción PWM
como se explica algo más arriba.

Veamos el código al completo:

/*
Tutorial Arduino # 0003 - Efecto Fading

En este tutorial, mostramos como se desvanece un LED


en función del valor recogido en un entrada analógica.

Este proyecto es de dominio público.


*/

int pinSensor = A0; // Entrada para el potenciómetro.


int pinLed = 9; // Seleccionamos pin para el Led.
int valorSensor = 0; // variable para el valor del sensor.

void setup() {
pinMode(pinLed, OUTPUT); // Establecemos el pin como salida.
}

void loop() {
// Leemos el valor del sensor y lo almacenamos:
valorSensor = analogRead(pinSensor);
// Establecemos el valor analógico para la salida PWM
analogWrite(pinLed, valorSensor / 4);
// Detenemos el programa durante 30 milisegundos:
delay(30);
}

Podemos observar una nueva instrucción:

analogWrite(pinLed, valorSensor / 4);

Esta será la instrucción que nos permitirá emular una señal analógica a partir de una digital en nuestros
circuitos, como explicaba algo más arriba.

El rango de salida de esta instrucción varia de 0 a 255, siendo 0 = 0v y 255 = 5v, por lo que es tan sencillo
como introducir un valor determinado para la tensión de salida que nosotros queramos conseguir, si
quisiéramos conseguir 2,5v el valor a asignar sería 127.

Así que lo único que debemos hacer es transformar mediante una simple operación matemática la señal
tomada en nuestro potenciómetro para adaptarla a nuestra salida PWM.

Como hemos visto en el ejemplo anterior, los niveles de entrada son de 0 a 1023, y si los niveles de
salida, deben ser de 0 a 255… Os dejo a vosotros la deducción, y la línea de código por si no caéis en
cuenta.

analogWrite(pinLed, valorSensor / 4);

Esta es una manera algo tosca para realizar esta conversión, más adelante veremos como hay una
instrucción que hace esto por nosotros.

Bueno, eso es todo por el momento!!

Si necesitáis algún tipo de aclaración no dudéis en dejar un comentario!!

Hasta pronto!!!
Componentes – El Potenciómetro

Autor:

Fecha: 23 noviembre, 2011

Compartir en
facebook

twitter

google

pinterest

Bienvenidos a un nuevo tutorial de Arduino Academy en el que vamos a mostrar todos los detalles de
un potenciómetro para aprender a utilizarlo en vuestros proyectos.

Empecemos!

¿Qué es un potenciómetro?

Un potenciómetro es una resistencia de tipo variable con tres patillas, entre las dos de sus extremos
tendremos siempre una resistencia fija dada por del valor máximo de nuestro potenciómetro, pero entre
cualquiera de esos extremos y la patilla central obtendremos la variación de resistencia.

El aumento de resistencia entre la patilla de un extremo y la central, es proporcional a la disminución


entre el otro extremo y la central, esto es, que cuando quitas resistencia de una combinación, pones en
la otra.

Esto es debido a que este tipo de resistencias están formadas por una pista resistiva con dos contactos en
sus extremos y un patín que se desliza de lado a lado al que está conectado nuestra patilla central, estoy
realizando abuso de algún término con fin de no ser extremadamente técnico, quiero que se entienda de
una manera simple su construcción y funcionamiento.

Tenemos varios tipos de potenciómetros:

 Movimiento rotatorio: Suelen tener un radio de giro efectivo de unos 270º y suelen ser usados, cuando
son de tipo mando (más grandes que el de la imagen) para controles de volumen en radios o cualquier
elemento susceptible de ser regulado con un mando giratorio, y cuando son pequeños, para preset (pre-
set = pre-ajuste) de circuitos, es decir, ajustes de fábrica.
 Movimiento lineal: Estos se utilizan, por ejemplo, en ecualizadores de audio.

En cuando a la manera que estos tienen de comportarse a nivel resistivo ante la variación de su eje, los
vamos a clasificar en dos grupos, hay más pero son raramente utilizados, con este par será suficiente
para nuestras necesidades, veamos primero una imagen:

 Lineal: Son aquellos que se comportan de una manera constante en el recorrido de su cursor, es decir,
si desplazamos el eje un 30 %, deberíamos aumentar un 30% la resistencia.
 Logarítmica: Estos son empleados normalmente para audio por su manera asimétrica de comportarse
ante la variación de su eje, al principio sufriremos un incremento de la resistencia muy leve, hasta llegar
a un punto en que el incremento será mucho mayor, viendo la imagen se puede entender fácilmente.
He comentado que se suelen utilizar para audio ya que, según demostró la Ley de Weber-Fechner, el
ser humano no oye de una manera lineal, sino logarítmica, por lo que, para experimentar una sensación
acústica del doble de fuerte, es necesario diez veces más de volumen.

Por último os dejo a continuación el símbolo eléctrico del potenciómetro para identificarlo en los
esquemas eléctricos:

Bueno, eso es todo de momento, recordad que si tenéis algún tipo de duda o consejo podéis
comunicármelo en los comentarios y haremos todo lo posible!

Hasta pronto!!
Tutorial Arduino #0002 – E/S DIGITALES

Autor:

Fecha: 14 noviembre, 2011

Compartir en
facebook

twitter

google

pinterest

#0002 – E/S DIGITALES


Bienvenidos a un nuevo tutorial básico sobre Arduino.

Parte 1: ¿Qué vamos a hacer?

En este tutorial de Arduino, vamos a aprender a configurar una entrada digital a la que conectaremos
un pulsador y, con lo aprendido sobre el LED en el anterior tutorial, nos permitirá controlar el encendido
y apagado del diodo.

Veamos el resultado final en un video:


Material necesario para el proyecto:

 1 placa Arduino.
 1 protoboard.
 1 diodo LED.
 1 resistencia 220Ω.
 1 resistencia 10K.
 1 pulsador.

Parte 2: Diseñando el Hardware…

En este proyecto, deberemos interpretar en nuestro programa la lectura de una entrada digital, y en base
a su lectura, activaremos, o no, una salida digital a la que conectamos un diodo LED, es un ejemplo
sencillo, pero que nos permite aclarar un concepto muy importe sobre las entradas digitales, las
resistencias de Pull-Up o Pull-Down.

¿Qué son las resistencias de Pull-Up o Pull-Down?

En nuestro Arduino, las entradas digitales se interpretan de la siguiente manera:

 1 (lógico) = Hight = +5v


 0 (lógico) = Low = 0v

¿Esto quiere decir? Que si tenemos una tensión de +5v aplicada a una entrada, este nos la interpretara
como un 1 (hight) sin lugar a dudas, pero no es así al contrario, si nosotros dejamos dejamos de aplicar
esa tensión a la entrada digital, es posible que recibamos algo de ruido del circuito y que Arduino no nos
lo interprete como un 0 (low) por lo que colocamos una resistencia entre la entrada y masa (GND) que
derive estos ruidos asegurandonos una señal limpia y sin posibles errores, a la resistencia que se conecta
a masa se le llama PULL-DOWN.

De igual manera, si tuviéramos la necesidad de mantener un 1 lógico en una entrada mientras el circuito
está en reposo, se le puede aplicar una resistencia entre la entrada y +5v para asegurarnos que le llega
sufiente tensión como para que sea interpretada correctamente por nuestro Arduino, a esta última se le
denomina PULL-UP.
Aquí podéis ver como se conectaría la resistencia en un circuito básico de 0 o 1 en la entrada 8 de
Arduino.

Una vez conocido esto, el resto del circuito no tiene misterio, deberemos colocar el LED correctamente
polarizado con su resistencia, y el pulsador con una resistencia de PULL DOWN de 10KΩ a masa para
cuando esté en reposo, de manera que cuando pulsemos el botón, llegue una tensión 5v a la entrada 2 de
Arduino y este lo interprete como un 1 lógico, a partir de aquí el programa hará el resto para
proporcionarnos la tensión de salida que activará el diodo LED.

Las conexiones en nuestra protoboard nos quedarían de la siguiente manera:


Para observar con más detalle las conexiones entre componentes se puede observar el siguiente esquema
eléctrico:

Como se puede observar, los pulsadores electrónicos parecen llevar cuatro patillas, pero en realidad sólo
son dos muy largas que salen por los laterales del pulsador para facilitar las conexiones, de manera que
si lo colocamos y el LED se enciende continuamente, es muy posible que lo hayamos conectado mal, si
tenéis un polímetro, colocarlo en modo continuidad y aseguraos de la posición correcta.

Parte 3: Programando…

Comencemos como siempre por el programa completo que posteriormente desglosaremos.

/*
Tutorial #0002 Arduino Academy - E/S DIGITALES

En este proyecto encenderemos un LED conectado


al pin digital 12 cuando presionemos el pulsador
asociado al pin digital 2.

Este proyecto es de dominio público


*/

// Variables estáticas
int pinBoton = 2; // Declaramos la variable pin del Botón
int pinLed = 12; // Declaramos la variable pin del Led

// Variables dinámicas
int estadoBoton = 0; // Variable para estado del botón

void setup() {
// Inicializa el pin del LED como salida:
pinMode(pinLed, OUTPUT);
// Inicializa el pin del botón como entrada:
pinMode(pinBoton, INPUT);
}

void loop(){
// Lee el valor del pin del botón y lo almacena
// en la variable estadoBoton
estadoBoton = digitalRead(pinBoton);

// Chequea si el botón está pulsado:


if (estadoBoton == HIGH) {
// Si es así, enciende el LED:
digitalWrite(pinLed, HIGH);
}

else {
// Si no, lo mantiene apagado:
digitalWrite(pinLed, LOW);
}
}

Como veréis algunas instrucciones ya han sido vistas en el anterior tutorial, así que nos centraremos en
aquellas que son nuevas para nosotros.

En primer lugar podemos observar que antes del setup hemos declarado unas variables globales, y
ademas las hemos organizado en estáticas y dinámicas:

// Variables estáticas
int pinBoton = 2; // Declaramos la variable pin del Botón
int pinLed = 12; // Declaramos la variable pin del Led

// Variables dinámicas
int estadoBoton = 0; // Variable para estado del botón

Para definir una variable imaginemos que queremos comprar una recipiente en el que vamos a guardar
algo, y depende de lo que queramos introducir, tendrá que ser de una manera o de otra, si es líquido, no
puede ser de cartón, si es algo pesado no puede ser frágil… Eso es una variable, un lugar en el que
almacenaremos algo para utilizar en nuestro programa, y si no las declaramos antes de utilizar, es como
si no hiciéramos hueco en nuestra despensa para guardarlas, otra característica es que su inicialización
no siempre es obligatoria, pero es recomendable, esto es como meter una pieza de cada producto que
vayamos a guardar en nuestras cajas, en este caso les hemos asignado un valor desde el principio por las
necesidades del programa.

¿Y como le digo si es de cristal o de cartón?

Definiendo el tipo de variable a utilizar, en este programa hemos utilizado las de tipo int pero existen
muchas más dependiendo de nuestras necesidades que iremos descubriendo en los siguientes programas,
de momento nos quedamos con la siguiente:

 Variable de tipo int: Almacena números enteros con un rango de -32768 a 32767

Al principio de la explicación, las he descrito en primer lugar como variables globales, esto es que al
estar fuera de todo ciclo, pueden ser utilizadas a lo largo de todo el programa ahorrándonos mucho
código, en ejemplos posteriores veremos otros lugares donde declararlas.

Y por último, en lo que respecta a las variables, las he organizado como estáticas, aquellas que serán
constantes en nuestro programa, y dinámicas, aquellas que variaremos su valor en algún lugar del
programa

Como novedad, podemos ver que en lugar de asignar un valor numérico en la instrucción pinMode para
decirle el pin sobre el que queremos trabajar, le hemos asignado una variable, y a la hora de interpretar
el programa, este utilizara lo que hayamos elegido introducir en nuestro recipiente, en este caso el
número entero 12 para la salida del LED y el número entero 2 para la entrada del pulsador.

void setup() {
// Inicializa el pin del LED como salida:
pinMode(pinLed, OUTPUT);
// Inicializa el pin del botón como entrada:
pinMode(pinBoton, INPUT);
}

Para explicar el loop, lo dividiré en dos partes, en primer lugar, tenemos que cada vez que se ejecute el
ciclo loop, lo primero que va a hacer es almacenar en nuestra variable dinámica de tipo int
“estadoBoton”, la lectura del pin 2 de nuestro Arduino.

estadoBoton = digitalRead(pinBoton);

Y ahora llega algo nuevo, el ciclo if… else, este ciclo es un condicional básico en programación, lo que
hace en nuestro programa es comprobar primero si nuestra variable estadoBoton está a 1 lógico, y, a
continuación, con el resultado obtenido de esa comparación, elige un camino u otro, si es que sí, entonces
encenderá el LED poniendo en HIGH, si es que no, entonces pondrá en LOW nuestra salida del LED
apagándolo.

// Chequea si el botón está pulsado:


if (estadoBoton == HIGH) {
// Si es así, enciende el LED:
digitalWrite(pinLed, HIGH);
}

else {
// Si no, lo mantiene apagado:
digitalWrite(pinLed, LOW);
}

Y con esto hemos concluido la explicación del segundo tutorial de Arduino Academy, si ha quedado
algún detalle por aclarar, animaos a mandar vuestros comentarios para así ir mejorando los
proyectos…

Hasta pronto!!!
Proyectos Arduino para principiantes de la domótica fáciles de hacer
Los proyectos Arduino han logrado establecerse muy rápido como una herramienta muy importante
para los aficionados a las programaciones e informática.

Desde su nacimiento, en el año 2005, en Italia, ha causado un gran revuelo en estandarizar la forma de
acceder y aprender programaciones y electrónica.

Debido a su popularidad, hay innumerables placas Arduino disponibles. Que van desde placas
originales a placas clonadas, con sus diferencias y particularidades que la llevan a ser una aliado
perfecto según el trabajo para el cual se tenga destinado su uso.

Esta sección describirá la importancia de una placa Arduino y de los proyectos con Arduino en
general.

Pincha en la sección que te interesa [Ocultar]

 1 ¿Qué es y para qué sirve un Arduino?


 2 Tipos de componentes en los proyectos Arduino
 3 1. Proyectos Arduino para domótica: robot aspirador casero
 4 2. Proyectos Arduino para control de tráfico: Semáforo
 5 3. Encender las luces con un aplauso
 6 ¿Cuál es el precio de un Arduino?

¿Qué es y para qué sirve un


Arduino?
Un Arduino sirve para realizar tareas electrónicas de una manera sencilla o fácil. Es una
plataforma de hardware libre.

Con Arduino se pueden crear elementos autónomos, ya que puede actuar tanto en el software como en
el hardware, con solo conectarse a dispositivos.

Su estructura se basa en una placa microcontrolador junto a un entorno de desarrollo.

Tipos de componentes en los proyectos Arduino


A continuación, te diremos los tipos de componentes para que tengas una mayor compresión de la
materia:

Sensores

Un sensor es un dispositivo con la cualidad de poder detectar variables de instrumentación como lo son
las magnitudes químicas y físicas, y transformarlas o llevarlas a variables eléctricas.
Entre las variables de instrumentación se encuentran la temperatura, aceleración, presión, entre otros.

Los datos de los sensores los clasifican en:

 Digitales
 Analógicos
 Comunicación por bus.

Los sensores tienen sus propias características, por lo que hay gran variedad y formas de los mismos,
por lo que es recomendable que se revise bien en el momento de adquirir uno y verifique que es un
sensor compatible con el sistema operativo de tu ordenador.

Actuadores

Los actuadores reciben la orden de un Arduino (regulador o controlador) para transformar la energía
hidráulica, neumática o eléctrica y activar una válvula o elemento externo para que genere una función
determinada.

Los actuadores que existen son los electrónicos, Neumáticos, Eléctricos, Hidráulicos, Motores,
bombas; los cuales se encuentran con una conexión a la salida de Arduino.

Elementos de comunicación

Dentro de los diferentes elementos de comunicación, te puedes encontrar:

Como alimentar tus proyectos de Arduino

Tarjetas

Arduino posee diversos modelos de placas, todo depende del uso que se le dé para escoger la que
mejor convenga.

Son placas individualizadas con marcadas diferencias una de las otras, por lo que es indispensable
saber identificarlas. Algunas de las Tarjetas Arduino más usadas son:

Duemilanove: está basada en ATmega168 (datasheet) o ATmega328 (datasheet); posee un


microcontrolador, 14 pines que tienen sus entradas y salidas digitales entre las cuales se consiguen seis
entradas digitales, seis entradas análogas, entrada de alimentación, una cabecera ISCP, conexión USB,
cristal oscilador a 16Mhz y un botón de reset.

En resumen, contiene todo lo que un microcontrolador necesita para funcionar correctamente al solo
conectarlo al ordenador o a una batería para obtener los beneficios de trabajar con un Arduino.

Mega: está basada en ATmeg1280 (datasheet) posee 54 entradas y salidas, de las que se pueden contar
que 16 son digitales, cuatro puertos serie por hardware (UARTS), conexión USB, un cristal oscilador
de 16MHz, conector ICSP, entrada de corriente externa y su botón de reset.
Conoce más…

En este sentido contiene todo lo necesario para poder funcionar correctamente en los proyectos
Arduino como un microcontrolador, que puede ser usado conectado por su puerto USB a un
ordenador o directamente desde su entrada de corriente externa a una batería para que comience a
funcionar.

Nano: es una placa pequeña de ATmega328 (Arduino Nano 3.0) o ATmega 168 (Arduino Nano 2.X).
Es una presentación diferente al Arduino Duemilanove pero con una función similar. Solo se tiene que
conectar a una protoboard.

Una de las diferencias que posee con respecto al Arduino Duemilanove es que no presenta opción para
alimentación externa, funciona solo a través de un cable USB Mini-B. Este dispositivo fue creado y
diseñado por Gravitech.

Pro: el microcontrolador de Pro es ATmega168 (datasheet) o ATmega328 (datasheet). Presenta


versiones variadas como 3.3v/8 MHz y %v/16 MHz. Posee en su estructura 14 entradas y salidas, de
las cuales se pueden contar seis digitales y seis análogas, agujeros para el montaje de tiras de pines,
resonador interno y botón de reset.

El cable con seis pines es para conectar un cable FTDI para poder tener comunicación con un USB y
alimentación externa de energía.

Shields

Es un accesorio que se utiliza para dar funcionalidad a Arduino extra, de describen como placas que se
colocan una encima de la otra, ya que son apilables, lo que permite la ampliación del hardware.

Se debe prever la forma que contengan estos pines y su forma de ensamblajes, ya que hay algunos que
vienen soldados y otros que vienen sueltos y deben ser perfectamente medido el espaciado y solo debe
tener una forma exacta de encajarlo.

La comunicación de Shields con el Arduino se establece por los pines digitales o análogos, o por algún
puerto serie o los mismos pines como interrupción.

1. Proyectos Arduino para domótica: robot aspirador casero


Es un prototipo cuyo control viene dado por Arduino. Usando algoritmos simples que le permiten tener
sensores que detectan los obstáculos.

Para esto cuenta con dos parachoques en la parte de adelante. Tiene en su interior una batería que le
permite el funcionamiento por una hora, la batería que lo alimenta es de litio.

Lleva dos motores de 6V y 20 r.p.m. una torvo ventilador de PC de 12 voltios. Cuenta con un circuito
Step-up que otorga 12V que proviene de la pila de litio que lleva instalada.
Tienen el control por un circuito H-bridge construido con un módulo HG 7881.

Cuenta con unas ruedas de goma especiales, entre las cuales la rueda trasera es giratoria y tiene la
particularidad de contar con dos rodamientos para una mejor rotación.

La base en que está todo lo anterior descrito es de plástico, semejante al de las tablas plásticas que se
usan en la cocina para picar aliños. Lo cual lo hace fácil de modificar para poder sujetar todos los
materiales con seguridad.

2. Proyectos Arduino para control de tráfico: Semáforo


Para montar el circuito se deben contar con los siguientes materiales:

 Un Arduino UNO o parecido.


 Un Protoboard que se usará para conectar los componentes para el circuito.
 Se deben tener seis resistencias de 220 Ω
 Dos resistencias de 10KΩ
 Nueve LEDs, entre los que se necesitarán 3 verdes, 3 amarillos y 3 rojos.
 Dos pulsadores.

Hay que tener gran precisión en el armado del circuito ya que una falla en el mismo puede ocasionar
cortocircuitos y por lo tanto no funcionará adecuadamente el sistema que se quiere instalar.

Una manera de comprobar que todo vaya bien es probar cada vez que se vaya terminando un sistema
para ir viendo si presenta alguna falla y garantizar un buen funcionamiento al final.

Los colores de los LEDs formarán un semáforo, en el cual los pulsadores tendrán sensores de
presencia con lo que encenderán o se apagaran.

El circuito es el siguiente: los cables deberían ser de colores para poder identificarlos con mayor
precisión.

La idea es que los sensores detecten cualquier tipo de movimiento, es como un semáforo que detecta
la presencia de un auto y hace que se activen las demás luces para dar paso seguro al auto en espera.

Es decir, cierra los otros semáforos, es precisamente lo que ocurre en este sistema de luces LEDs.

3. Encender las luces con un


aplauso
Para encender las luces con un aplauso se deben tener los siguientes materiales en los proyectos
Arduino:

 Se necesita un Arduino UNO Rev.3.


 Se debe contar con un cable USB tipo A-B específicamente.
 Un Módulo RELE de 5VDC y Módulo de sensor de sonido.
 Una bombilla normal de bajo consumo como lo son de 10W/220VAC.
 Una pila de 9V para poder alimentar el arduino sin necesidad de utilizar o estar conectado al
ordenador.
 Se deben contar también con cables de conexión.

Se nenecita el uso de un RELE de 5VDC para el encendido de una bobina de 10W/220VAC. Para que
funcionen las salidas NC (Cerrada) y NA (abierta) se realizara un módulo que reconozca el sonido para
que con una palmada se produzca un nivel alto o a más de 5V, lo cual lleve al umbral al RELE y
encienda la bombilla.

En caso de producirse dos palmadas ocurre lo contrario, permite que el sistema se ponga en reposo lo
que lleva al apagado de la bombilla.

Es un proceso quie debe repetirse varias veces para comprobar el buen funcionamiento del sistema y
respuesta adecuada del micrófono incorporado en el sensor para detectar el sonido emitido por las
palmadas.

Si el sistema es digital se debe regular el potenciómetro hasta que el LED L2 incorporado en la placa
deje de lucir y si es un sistema análogo se debe regular igual pero para programar el valor del sensor a
tanteo entre 0 y 1023 ayudado con la visualización a través del monitor de Arduino. Algo importante
en los proyectos Arduino.
¿Qué es la mecatrónica?
Es aquella disciplina que une simultáneamente la ingeniería mecánica de precisión, la electrónica, la
ingeniería de control, ingeniería informática, entre otras áreas cuyo principal objetivo es diseñar y
desarrollar avances tecnológicos que involucren sistemas de control para el diseño de productos o
procesos que permitan facilitar las diversas tareas. La mecatrónica es vista como una carrera del
futuro ya que se acopla a las crecientes necesidades de la ingeniería en el desarrollo y la innovación.

La mecatrónica surge de la necesidad de contar con personas con conocimientos


multidisciplinarios, dada esta necesidad, se convirtió en algo indispensable para los actuales procesos
productivos de la industria, también cabe destacar su eficacia en el ámbito clínico. Con el paso del
tiempo se produjo una interacción de diferentes ramas tecnológicas, originando una nueva aplicación.

Cabe resaltar que la mecatrónica no es una rama de la ingeniería, sino un nuevo concepto que enfatiza
la necesidad de interacción e integración intensiva entre diferentes áreas como son la mecánica,
electrónica, electricidad e informática.

Actualmente se cuenta con muchos desarrollos multidisciplinarios elaborados por sistemas


mecatrónicos, todos ellos con el objetivo de mejorar la calidad de vida a las personas.

¿Por qué estudiar mecatrónica?

Muchos jóvenes están interesados en innovar, construir algún robot, fabricar su propia tecnología y
también muchos se interesan en estudiar ingeniería mecatrónica por diversos motivos. Sin embargo, al
indagar sobre esta carrera comienzan a generarse algunas interrogantes como: ¿Qué trabajo puedo
obtener? ¿La mecatrónica tiene relación con la robótica?

Las personas tienden a confundir la robótica con la mecatrónica, se debe tener presente que todos
los robots son mecatrónicos, pero no todos los sistemas mecatrónicos pueden ser considerados como
robots. En pocas palabras la robótica es una rama de la mecatrónica.

Las oportunidades laborales para un ingeniero mecatrónico son muy grandes ya que
constantemente se requieren en empresas nacionales, privadas y multinacionales de la industria
automotriz, manufacturera, petroquímica, alimentos y electromecánica. Un ingeniero mecatrónico
resalta en la automatización y manufactura
Tutoriales Arduino

Enlaces recomendados

 Instrumentos de medición
 Revista, libros, pdf...
 Escuelas que imparten la carrera de Mecatrónica
 Ver más tutoriales

Tutoriales

Conceptos importantes
 Conceptos básicos de Arduino.
 Las 3 mejores formas de alimentar un Arduino.
 Instalar IDE Arduino.
 Actuadores digitales.
o Entradas digitales.
o Salidas digitales.
o Lectura de señales digitales.
 Actuadores analógicos.
o Entradas analógicas.
o Salidas analógicas.
o Lectura de señales analógicas.
 Comunicación serial.

proyectos para iniciar con arduino


Nivel básico

 Mi primer programa "Blink".


o Encender un LED.
o Secuencia de LEDs.
o Parpadeo de dos LEDs.
 Lectura de un pulsador.
o Pulsador como interruptor
 Optointerruptor
 Lectura de un potenciómetro.
 Sensor de temperatura LM35
 Sensor de iluminación LDR
 Sensor TCRT5000
 Realizar comunicación Serial.
o Imprimir datos por el monitor Serie.
o Recibir datos por el puerto Serie.
 Programación LEDs.
o Fade de un LED.
o Fade de un LED con potenciómetro.
o Fade de un LED con potenciómetro y uso de la función map.
o Encender un LED RGB.
 Uso de Joystick.
 Medir distancia con el sensor HC-SR04.

Nivel Medio

 Desplegando información con Arduino.


o Uso de la LCD 16x2.
 Mostrar datos obtenidos de un sensor en la LCD.
o Display de 7 segmentos.
 Controlar un Servomotor.
 Control de motor CD con L293D.
 Control de motor a pasos con L293D.

Nivel avanzado

 Control de cargas y manejo de cargas.


o Utilizando un Transistor.
 PWM con Transistor.
 Uso del relevador a conexiones CA.
 Utilización del Optoacoplador como actuador.
o Lectura de señales superiores a 5V.
 Control de motor CD con transistor.
 Comunicación Serial con módulo bluetooth y app.
 Display 7 Segmentos utilizando multiplexeo.
Video cable schematics

Index
 Introduction
 VGA to Scart
 VGA to Arcade monitor
 VGA to composite video in black and white
 Jamma to Scart
 Scart to VGA

Introduction
This section contains schematics to build useful video cables to interconnect various types of displays
and devices. Cables VGA to Scart, VGA to Arcade monitor and VGA to composite video in black and
white require the PC video card to output compatible TV and Arcade monitor refresh rates at 15,6 kHz
50/60 Hz. PC video cards do not include these configurations by default but some models can be set
with one of the following tools:

 WinModelines (Windows)
 CRT_EmuDriver (Windows)
 Advance Projects (AdvanceMAME, AdvanceCAB and tools) (multiplatform)
 Soft15khz (Windows)
 WinVGATV - [ Main page ] (Windows)
 Manual registry tweak (Windows)
 X graphics server (Linux)
 PowerStrip (Windows)
 SwitchResX (Mac)
 MS-DOS drivers (MS-DOS)

VGA to Scart
This cable lets you connect a TV set with a RGB capable scart input to the PC VGA output. It is
necessary to set the PC video card to output a 15.6kHz 50/60 Hz signal so that line and frame refresh
frequencies are TV/Arcade monitor compatible as explained in the Introduction.

To determine if your TV set scart socket is RGB capable you can use a DVD player or DTV decoder,
connect it to the scart socket and switch between composite video (CVBS) and RGB modes from the
player configuration menus. Look for subtle differences in picture sharpness or colours (maybe you
must save or exit the configuration menu for the change to take effect), if you can see these changes
then the socket supports RGB. Note: to conclude it supports RGB it is not sufficient to get a picture in
RGB mode but you must notice a subtle difference in picture quality switching between CVBS and
RGB.
To avoid noise in the picture or audio it is strongly recommended to use shielded cable for RGB and
audio signals, shields are drawn in this schematic with dotted lines. To get the best sharpness use 75
ohm video cable.

The connector at the bottom right is a stereo male audio jack to plug to the PC sound card. It brings PC
sounds to your TV speakers.

Note: if you use a standard male-male scart cable and a female socket you must change the following
pins: 20 → 19, 6 → 3 and 2 → 1. This is because a male-male cable connects inputs to outputs.

Connection to a MOLEX PC power plug is required for proper operation unless your TV set allows
manual switching to RGB. It is not enough to be able to switch to scart input, it must allow switching
to RGB mode. Only few sets allow this so I strongly suggest to add these connections so that switching
will be automatic.

There are some alternatives to the MOLEX plug to get the necessary power. All of them only provide
5V so for the 12V cable you can leave it out (you will have to switch your TV manually to its scart
input) or connect it to 5V (some TVs will not switch while others will activate wide screen mode
(16:9), it is fine for wide screen sets but not for normal (4:3) sets where there may be a button or
option to disable wide screen mode).

 VGA port: according to VESA VGA standard, VGA connector pin 9 provides 5V (see numbering in
previous schematic). However some cards do not provide this voltage so check this before you elect
this option.
 USB port: a female USB plug as seen from the front with its contacts on the left hand has 5V available
in the first contact starting from top. You can use a male USB plug to make the connection.
 Old DIN keyboard port: looking at a female connector from the front and with its contacts on the top,
5V are available in the second contact starting from right.
 PS/2 keyboard/mouse port (mini-DIN): looking at a female connector from the front and its groove at
the top, 5V are available in the middle pin on the left side.
With these alternatives you can build a more portable cable and avoid the need to enter a cable inside
your PC.

FAQ
Why the resistors?

Scart and VGA standards specify a set of electrical characteristics (voltages and currents allowed) for
all signals in these ports. All devices are designed according to these standards and operation outside
them may cause damage or wrong operation.

Specifications of synchronization signals for Scart and VGA differ significantly, so they are
incompatible and cannot be connected. There are important differences: scart composite sync expects a
0.3 V sync signal and has a low input impedance of 75 ohm while VGA outputs 5V TTL separate sync
signals and expects high impedance loading.

Given these specifications there is fortunately a very simple solution consisting of two resistors that:

 Drop the voltage output in the VGA port to the 0.3V expected by the TV set - this fixes some problems
like very dark image or unstable sync which would happen mostly on 100Hz TV sets or modern digital
chassis.
 Avoid overloading the video card sync outputs
 Avoid the short circuit that occurs when H and V syncs are connected together and could damage the
video card.
 Mix H and V sync safely and reliably

Can we leave these resistors out?

Resistors are really cheap and in my opinion it is not worth the savings. Without these resistors both
devices may be damaged: the TV set that receives a signal 10 times stronger and the video card that
sees an overload in its sync outputs.

When H and V signals are short circuited together one signal could take over the other and cause
unstable display. Some TV sets measure sync signal strength to adjust picture contrast (this is to
compensate signal drops in cables and connectors) and with a signal 10 times stronger you will get a
picture 10 times darker.

I get just a black screen

99% of times this problem is due to 5V missing from power source (MOLEX or alternative used).
Check the 100 ohm resistor, it should drop the 5V down to around 2V (measured with a TV plugged).
Also make sure the scart socket you are using is RGB capable.

Is it possible to run this circuit from only 12V?

Yes, change the 100 ohm resistor by a 390 ohm 1/2 W resistor. This resistor will get warm, use a 1/2W
rated one.

VGA to Arcade
This cable lets you connect an Arcade monitor to the PC VGA output. This connection is very simple
and does not need any additional component. You must identify the right signal input points on your
monitor, sometimes they are labeled but you can look for its technical manual on the web.
Important: some monitors have switches or jumpers in their boards that must be set according to
input signal. It is important to read its technical manual and set the right settings for your needs. There
are some settings that often cause problems:

 Sync polarity: sets input sync signal polarities, it must be set to match the polarities output by your PC.
In a Modeline, polarities are set with the sign + or − in front of keywords hsync and vsync for
horizontal and vertical sync respectively.
 Standard, medium or high resolution: most games run on standard resolution (15kHz / 16kHz) but
some use medium (25kHz) or high (31kHz) for higher resolutions. You must set this setting according
to the modes you are going to use.
 Separate or composite sync: jamma game boards generate composite sync while a PC uses separate
syncs.
 1Vpp or 5Vpp video signal: some jamma game boards output 5Vpp while PC VGA always outputs 1Vpp.
If this setting is not available it can be compensated by increasing monitor contrast.
 Video terminators or loads: if available you should enable this option.

If your PC does not sense your monitor it is likely your monitor is not loading the RGB signals.
Measure input resistance from one video signal (R, G or B) to ground with an ohmmeter, in 200 ohm
scale it should read around 75 ohm. Some monitors have a switch or jumper to enable loading of video
signals, if yours does not have this setting you can add three 75 ohm resistors from each video signal to
ground as shown below.

If your monitor accepts only composite syncs, it is not recommended to connect H and V signals
together. If you use an ATI card you can enable composite sync in ATI control panel or
WinModelines. Then connect VGA pin 13 to composite sync input (do not connect pin 14). If you still
experience problems you may have to change output polarity from ATI control panel or replacing -
hsync -vsync by +hsync +vsync in all modelines within WinModelines.

For non-ATI video cards, if you experience problems connecting H and V syncs together you can
generate quality composite sync with this circuit:

This circuit fixes sync polarities and will always output negative sync (TV compatible). If you still
have problems try to change to positive syncs by connecting 4070 pin 12 to ground instead of 5V.

4070 chip is very cheap and easy to find at any electronics store. Each manufacturer has its own prefix
so you can find CD4070, HEF4070, MC4070, etc. all of them are the same. It is very important to
connect ground to pin 7 and supply 5V to pin 14. You can get 5V from a MOLEX connector, monitor
supply or any other 5V supply you have around.

This is the chip pin numbering:

VGA to composite video in black and white


This cable lets you connect PC VGA output to a TV or VCR composite video input. Generated signal
is black and white (no colour). You must configure your PC to output the right line and frame refresh
rates as explained in the Introduction.
Pay attention to the polarity of electrolytic capacitor, positive must be connected to PC output and
negative to video input. It works under very small voltages so any voltage rating will do.

This circuit mixes colours following this ITU specification:

Y = 0,222 Red + 0,707 Green + 0,071 Blue

Red objects show up as dark grays and blue is very dark gray. If you think these grays are too dark you
can increase their brightness by removing 100 and 150 ohm resistors or lowering the value of 120 and
390 ohm resistors.

Jamma to Scart
This cable lets you connect an Arcade game board with Jamma interface to a TV scart socket. The
scart socket must be RGB capable.
Note: if you use a standard male-male scart cable and a female socket you must change the following
pins: 20 → 19, 6 → 3 and 2 → 1. This is because a male-male cable connects inputs to outputs.

A similar drawing is published in some other web sites but observe the version shown here has a
modification regarding audio connections. It is recommended to follow this one to avoid damage
to the audio amplifier in your game boards.

If audio sounds too strong or distorted, lower the volume setting on your game board. If it provides no
volume control or does not have a proper range you can put a volume adjustment adding a 10K preset
in the audio wire:

Scart to VGA / Arcade


This cable lets you connect a DVD player, DTV receiver or any other device with RGB scart output
to an Arcade or PC monitor.

To use a PC monitor you must enable Progressive scan in your set top box, if your device does not
have this capability then you cannot use a PC monitor. On the other hand, for an Arcade monitor you
do not need this feature and any box that outputs RGB can be connected.

In both cases it is required that your box outputs RGB signals in its Scart socket. Many but not all
digital devices do that, and in some cases you must enable RGB output within a settings menu. Note: a
VHS VCR or an analogue tuner (satellite / cable / terrestrial) does not offer RGB signals and will not
work with this circuit.

Electrical schematic:
Connection diagram:

Connector shown at bottom right is a female stereo audio jack to plug amplified PC speakers.

Components surrounded by a dotted line are optional: they generate a vertical sync signal but most
monitors do not need it. If your monitor scrolls the picture up or down or does not detect a signal you
will have to add these components.

Start by setting the 4K7 preset at middle range. If your monitor does not sync properly, does not detect
a signal or displays an Out of range message adjust until it works.
If your Arcade monitor has a switch or jumper to set sync polarities try all settings until it works. This
circuit outputs positive H sync and negative V sync.

If it still does not detect a signal or sync properly remove the connection to scart pin 16 and connect
that wire to a 5V supply instead, with ground to transistor emitters (E). The scart output may not
provide enough voltage or current for proper operation.

Note: if you use a standard male-male scart cable and a female socket you must change the following
pins: 20 → 19, 6 → 3 and 2 → 1. This is because a male-male cable connects inputs to outputs.

Project completed on June 2007 by Jeroni Paul.


Descripción

TxapuCNC es una fresadora casera de 2,5D. Es decir permite realizar mecanizados sobre una superficie (X,Y)
a distintas alturas (Z).
En el blog anterior vimos la parte de software, y ahora veremos la de hardware. La descompondremos en dos
partes, la electrónica y la mecánica.

Electrónica
La parte electrónica está realizada fundamentalmente con módulos Paper:

 1 Paperduino (puedes utilizar Perfboard, Stripboard , PCB o un Arduino) con el programa


TxapuCNC_RX cargado.
 3 PaperSteppers (puedes usar L293D, Unipolar, o L298N.)
 1 PaperRelé si quieres gobernar el motor del cabezal desde el programa.
 1 Paper-FTDI para conectar con el PC (si utilizas un Arduino en vez de un Paperduino no lo
necesitarás)
 ... y por supuesto un PC con TxapuCNC_TX (con gambas y GNU-Linux)

NOTA: Si en vez de utilizar drivers PaperStepper, quieres utilizar drivers comerciales (tipo Pololu,Easydriver),
que funcionen mediante señales "STEP" y "DIR", en vez de utilizar el sketch de Arduino TxapuCNC_RX,
deberás utilizar el sketch TxapuCNC_RX_Pololu, que lo puedes descargar aquí.
El esquema de conexionado es el siguiente:

NOTAS

 Puedes elegir otras patillas de entrada-salida modificando el archivo _init.pde dentro de TxapuCNC_RX.
 Puedes utilizar cualquier PaperStepper en función del motor paso a paso que tengas (como ejemplo en los ejes X
e Y se ha representado un motor bipolar y en el eje Z uno unipolar.
 No es necesario utilizar el PaperRelé para comandar el motor del cabezal, puedes hacerlo a mano.
 No es necesario utilizar finales de carrera para los límites máximos y mínimos de cada eje (yo no los he
implementado en la fresadora, soy muy vago) , la fresadora funcionará, pero perderá el sincronismo si llegamos
al tope de algún eje.
 Las entradas de los finales de carrera no tienen una resistencia a 5V ya que todas las patillas de entrada de
Arduino disponen de una resistencia Pull-Up interna. pero parece que esto le da problemas a la gente que no los
utiliza. La solución es conectar las patillas D2-D7 a GND. (perdonad que no lo haya indicado en las imágenes)

NOTAS:
En la imagen anterior se han utilizado 3 paperSteppers L298N con tres motores unipolares, y no se representan los finales
de carrera de los ejes.

Si no utilizas el PaperRelé puedes conectar el taladrín a la salida conmutada de 220v de la fuente de alimentación (el
enchufe del monitor), para que al apagar la fuente se desconecte el cabezal.

El resultado es el siguiente:

y aquí un detalle de la alimentación del taladrín con el paperRelé:


Nota: el cable gris, está conectado internamente al enchufe de 220V conmutado de la fuente ( monitor ).

Nota: El interruptor de la fuente lo he colocado para que sea accesible (es conveniente que la fuente esté colocada con el
ventilador hacia adelante para que el polvo y virutas del mecanizado no entren en la fuente).

Mecánica
Puedes utilizar la fresadora que quieras, pero yo he elegido la Mantis-CNC, una fresadora realizada con madera
según las indicaciones de David Carr en su blog: make your bot

Los materiales que necesitarás son los siguientes:

Puedes descargar los planos de fabricación en la zona de descargas.


Los planos se pueden imprimir sobre una hoja DIN-A3 y pegarlas sobre la madera.

NOTA: Los planos están hechos para madera de 13mm de espesor, si utilizas otros espesores, hay que recortar la
diferencia en los laterales (la base es de 276mm x 276mm)

NOTA: Al imprimir ten presente que los planos Mantis_Componentes_xx están preparados para imprimir sobre hojas
DIN-A3, y el plano Mantis_Laser está preparado para imprimir sobre una hoja de 800x400, ten cuidado de no tener
activada la opción "Ajustar a tamaño de página" al imprimir o los planos no estarán a escala. Una vez impresos puedes
comprobar que están a escala sabiendo que la base es de 276x276mm.
Las piezas puedes hacerlas a partir de una pieza de madera contrachapeada de 15mm de 800x400mm (8,10€ en
Leroy Merlín) o en MDF de 16mm 800x400mm(5,5€ en Leroy Merlín). Y puedes cortarlas tu mismo con una
sierra de calar. (recuerda en ajustar los planos al espesor de la madera, o recortar los laterales para que encajen
con la base).
Para que las varillas queden paralelas, te aconsejo que unas las piezas por parejas y las taladres
simultáneamente (algunas piezas tienen unos pequeños agujeros de posicionado).
Si quieres, puedes encargar que te la corten por laser, también en la zona de descargas dispones de un archivo
DXF preparado para ser cortado en una madera de 800x400:

Nota: he añadido un plano de conjunto para facilitar el montaje, este plano no está incluido en el archivo zip
de descargas. Para acceder a él haz click en la imagen inferior.

Para fijar el taladrín, puedes quitar la tuerca de plástico que suelen tener en la parte delantera, medir su diámetro
y comprobar que coincide con el mío. posteriormente tienes que realizar un agujero para poder introducir un
tornillo de apriete.

En la realización de la fresadora he realizado las siguientes txapuzas:


En vez de utilizar un motor con su adaptador, la he adaptado a un taladrín para simplificar la fabricación.

Ya que hoy en día se pueden encontrar taladrines a bastante bajo precio:

En vez de utilizar un eje roscado con su tuercas especiales antiholguras que son bastante caras, he comprado 1
metro de varilla roscada de métrica 8 (paso 1,25) a 1,3€ y tuercas normales M8 (bueno por unos céntimos más
las compré de latón para intentar disminuir el rozamiento) por 1,2€. Para disminuir en lo posible las holguras
entre la varilla y las tuercas, he colocado dos tuercas en cada eje.

Las tuercas (al igual que los casquillos) las he fijado con "araldit rápido" (resina epoxi), mezclado con polvos
talco para intentar hacer el adhesivo un poco más espeso. Con un palillo he ido retocándolo para que no se
expanda demasiado. Es necesario que la varilla roscada esté introducida en las tuercas para que éstas
permanezcan alineadas. Aquí vemos las tuercas del eje Z.

Las tuercas inferiores de la mesa (eje Y)


Y la fijación de las tuercas (fotografía desde abajo,debajo del motor paso a paso) del eje X:

La fijación de los motores X e Y es un poco demasiado "txapuzas", los fijé provisionalmente y como funcionó
así lo dejé. Pero posteriormente he descubierto las barritas de adhesivo epoxi, que creo que se podrían fijar
como el motor del eje Z.

La fijación del motor del eje Z la realicé primeramente con burlete adhesivo y adhesivo de doble cara (el "taco"
y el "verde" que se utiliza para las protecciones en pelota mano) pero tenía demasiada holgura (como la unión
eje-varilla era rígida creí que era mejor que el motor tuviera algo de movimiento). Lo que hice es fijar de forma
rígida el motor con barritas adhesivas epoxi (dependiendo como la aplastes consigues el ángulo y posición
correcto del motor) y realizar una unión flexible con la varilla mediante mangueras de PVC.
Como he comentado, para el acoplamiento del eje del motor con la varilla roscada he utilizado dos métodos:
Para el primero he utilizado un casquillo de plástico:

Taladré un agujero pasante con una broca del mismo diámetro que el eje del motor pasos a paso, y luego volví a
taladrar hasta la mitad con una broca un poco más pequeña que el diámetro de la varilla roscada, de forma que
se al introducir la varilla roscada se genere rosca en la pieza de plástico.
De esta forma la varilla se rosca por un extremo y entra a presión por el otro en el eje del motor. (acoplamiento
eje X)

Este sistema tiene la desventaja de que la unión es rígida y no absorbe los descentramientos del taladrado de los
agujeros y desviaciones de la varilla (si te fijas la varilla del eje Y está muy torcida). A pesar de que funciona
creo que es mejor el segundo sistema:

Para este acoplamiento he utilizado dos trozos de manguera flexible de PVC:


Uno pequeño, de diámetro interior igual al eje del motor paso a paso, y de longitud igual a la longitud del eje del
motor paso a paso. Y otro del doble de longitud y de diámetro interior aproximado al eje y al exterior del tubo
pequeño:
Primero introducimos el tubo pequeño en el eje del motor:

Sobre él colocamos el tubo grande

Introducimos la varilla roscada. dependiendo de la separación entre el eje y la varilla roscada variaremos la
flexibilidad de la unión. Quizás tengas que calentar el tubo para aumentar su flexibilidad y poder introducirlo.
Finalmente, (si es necesario), con un alambre impedimos que las mangueras deslicen, haciendo una Txapu-
abrazadera (acoplamiento eje Z y eje Y).

Nota: para el acoplamiento del eje Y, puse un poco de cinta aislante entre el eje y el tubo de PVC, pero con el alambre no
es necesario.

Creo que es bueno hacer unos "agujeros de acceso" en la madera de la base para permitir arreglar la máquina sin
tener que desmontarla completamente.
Si no encuentras cojinetes de deslizamiento (no es necesario que tengan valona, yo los utilicé porque los tenía
disponibles), creo que se podrían moldear con la barrita de epoxi cubriendo previamente el eje con film plástico
(o tal vez aceite y moviéndolos hasta que se sequen para que no se peguen al eje).

Si nó, siempre puedes comprar unos cojinetes IGUS (11@1,13€/Ud):


Realización casera de casquillos
Si no tienes casquillos, puedes hacerte tú unos. Sólo necesitas los siguientes componentes: Una pistola de
adhesivo térmico y papel de aluminio.

Cortaremos un réctángulo de papel de aluminio (el utilizado para envolver alimentos) de una longitud suficiente
para que de 3 vueltas a la varilla de deslizamiento.
Envolvemos el papel de aluminio sobre la varilla y lo fijamos con cello.

Ahora con la pistola termoadhesiva vamos recubriendo el aluminio, girando lentamente la varilla.
Una vez frío, (podemos enfriarlo con agua), lo sacamos de la varilla, y eliminamos las dos vueltas de aluminio
que no se han fijado al adhesivo. De esta forma conseguimos que tenga la holgura adecuada, y se deslice sin
problemas.

El resultado es el siguiente:
Al hacer manualmente los casquillos, al unirlos sobre las plataformas deslizantes (con la varilla introducida,
desde luego), habrá que fijarse que las varillas queden completamente horizontales sobre la plataforma.
Enlaces de Interés
Blog de David Carr donde se explica como construir una fresadora casera: make your bot.
Página de EMC2, dedicada al mecanizado en linux.

RepRap, creación de una máquina autoreplicante. Realización de piezas por deposición de material.

ReplicatorG, programa para producir código para RepRap a partir de ficheros stl
Contraptor realización de una fresadora utilizando perfiles perforados.

Aplicación en "processing" utilizada por contraptor para enviar archivos Gcode al controlador Arduino.
Gcodetools: Plug-in para inkscape que genera Gcode a partir del dibujo vectorial que hayamos dibujado (casi
todos los archivos de ejemplo de TxapuCNC_TX los he creado con este fantástico plug-in).
HersheyFonts: Plugin para inkscape que genera textos con carácteres de una linea simple, ideales para
simplificar el mecanizado.
PyCAM: Programa que genera archivos Gcode a partir de archivos STL (3D) o Archivos DXF o SVG (2D).

PaperStepper L298N: Uno de los drivers posibles para utilizar en TxapuCNC.


PaperStepper L293: Otro de los drivers posibles para utilizar en TxapuCNC (Yo he utilizado éste para la
realización de la fresadora).
PaperStepper Unipolar: Otro de los drivers posibles para utilizar en TxapuCNC.
PaperStepper Unipolar: Otro de los drivers posibles para utilizar en TxapuCNC.
PaperStepperChino: Adaptador para usar un driver Standar (chino) en TxapuCNC.
PaperRelé: Placa utilizada para gobernar el motor del cabezal.
PaperduinoStripboard: Posible placa de Arduino para controlar TxapuCNC.
PaperduinoPerfboard: Posible placa de Arduino para controlar TxapuCNC.
PaperduinoPCB: Posible placa de Arduino para controlar TxapuCNC.
CableFTDI: Si utilizas un Paperduino, será necesario que tengas un cable USB-RS232(TTL) para comunicarte con
el PC.

mister_mst de forocoches está haciendo una TxapuCNC, mira sus progresos aquí

Galería
San ha realizado una evolución, (con la mesa de trabajo más grande y con otro modo de fijar las tuercas) del
TxapuCNC:

Teneis más fotos de su trabajo en:


https://docs.google.com/#folders/folder.0.0B82NJbZaMceIODBjYjU5NDYtYTg0Mi00N2NlLWIwN2YtZTI2MjFjM
mYwMDE5

Y los planos en formato PDF y Autocad realizados por Zumel los teneis aquí

(21b TxapuCNC Planos evolucionados.zip)

Teneis más información de sus trabajos en Forocoches


Información legal

1. Propiedad intelectual
Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia
Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la
misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas
eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir
responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos
informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así
como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a
consecuencia de errores, defectos u omisiones en la información facilitada.
Descargas
Los planos, archivos para mecanizado, esquemas e instrucciones están disponibles en el siguiente enlace:

11036

Si tienes problemas con el enlace anterior, aquí puedes descargar todos los archivos de txapuzas
5 proyectos Arduino para iniciarse en el mundo Maker
Comentarios(18)
Luis del Valle Hernández
Cuando empezamos a trabajar con el Hardware Libre el primer proyecto que hacemos es encender
un LED. Luego pasamos a mover motores, medir la temperatura o ver los datos en una pantalla LCD.

En este artículo te voy a explicar 5 proyectos Arduino que no sólo te van a enseñar a utilizar esta
placa, también serán útiles en tu día a día. En ocasiones nos preguntamos ¿para qué quiero aprender
Arduino?, pues aquí te doy 5 ejemplos prácticos para introducirte. En ellos aprenderás
electrónica, montaje de circuitos y como no, programación.

A lo largo de estos 5 proyectos Arduino podrás entender conceptos básicos como salidas y entradas
digitales y analógicas, utilización de diferentes componentes y cómo programar Arduino a través de
su código nativo.

También podrás aplicarlo a algún lenguaje visual como Scratch o Snap! e incluso con Visualino.

Indice de contenidos

 1 5 proyectos Arduino para introducirte en el mundo Maker


 2 Comprueba las pilas con Arduino
 3 Sensor aparca coches
 4 Semáforo inteligente
 5 Theremín con LDR
 6 Dado eléctrico
 7 Proyecto Halloween con Arduino

5 proyectos Arduino para introducirte en el mundo Maker


En los 5 proyectos Arduino he realizado la misma secuencia de pasos. Lo primero una descripción
donde te explico, brevemente, qué es lo que hace y que situación queremos resolver. Luego explico el
objetivo donde explico los requerimientos y funcionalidades. Por último veremos los componentes de
todos diseños con Arduino.

Aunque tengas todo bien explicado y puedas construirlo siguiendo los tutoriales, te aconsejo que una
vez hayas leído la descripción y el objetivo, intentes hacerlo por ti mismo. Es un ejercicio práctico
muy bueno para asentar los conocimientos sobre la computación física.
Material necesario

En los 5 proyectos Arduino te doy un listado de los diferentes componentes electrónicos que vas a
necesitar. Pero además de esos componentes, necesitarás lo siguiente.

 Arduino UNO o similar


 Cable USB para conectar Arduino
 Protoboard
 Cables

Comprueba las pilas con Arduino


Este sistema nos permitirá comprobar las típicas pilas que tenemos en multitud de aparatos en nuestra
casa. Muchas veces no somos capaces de saber si un aparato eléctrico está roto o, simplemente, sus
pilas se han acabado. Solo podremos comprobar pilas AA, AAA, C y D debido a las limitación de
entrada de 5V en los pines analógicos. Este es uno de esos proyectos Arduino útiles en nuestro día a
día.

Objetivo

Poder detectar cuando una pila tiene suficiente energía o no a través de tres LEDs y Arduino. Cuando
este tipo de pilas están completamente cargadas, suministran un voltaje de 1,5V. Según se van
desgastando el voltaje disminuye. Con este diseño serás capaz de detectar esta situación.

Para avisar utilizaré 3 LEDs, verde, amarillo y rojo. Si la pila está totalmente cargada, se encenderá el
verde, y según se va gastando pasará al amarillo y al rojo.

Componentes

 3 x resistencias 220 Ω
 1 x resistencia 10 KΩ
 1 x LED verde
 1 x LED amarillo
 1 x LED rojo

Podemos cambiar la resolución de las entradas con analogReference para conseguir más resolución.
Medir más de 5V por alguna entrada analógica puede dañar la placa.

Cuidado con invertir las polaridades es decir, el positivo con negativo o viceversa.

Sensor aparca coches


Este es el típico sensor que tienen los coches modernos. Su función es avisar de lo cerca o lejos que
estamos de otro vehículo u objeto a la hora de aparcar. Nos avisa con un sonido y con unas luces que te
indican lo cerca o lejos que estás de colisionar. Dentro de los diferentes proyectos Arduino, este nos
muestra un caso de la vida real.

Objetivo

Simular el sistema que utilizan los coches más modernos a la hora de aparcar. Nos sirve para no
colisionar con los otros vehículos u objetos. Según nos acercamos a un objeto el pitido va subiendo
en frecuencia. Los LEDs también nos ayudan a saber lo cerca o lejos que estamos del objeto en
cuestión.
Si estamos lejos, el sonido se emite con una frecuencia baja y se enciende el LED verde. Si estamos
en una posición intermedia, el pitido aumenta la frecuencia y se encenderá el LED amarillo. Por
último, si estamos demasiado cerca el pitido será muy agudo, una frecuencia alta, y se encenderá el
LED rojo.

Componentes

 3 x resistencias 220 Ω
 1 x LED rojo
 1 x LED amarillo
 1 x LED verde
 1 x piezoeléctrico
 1 x sensor de ultrasonidos

Utilizar varios sensores de ultrasonidos para poder detectar en un mayor rango.


Se puede sustituir el sensor de ultrasonidos por un sensor de infrarrojos.

Semáforo inteligente
Uno de los proyectos Arduino más típicos es el semáforo es uno de los típicos. En este caso le
daré una vuelta de tuerca y lo haremos “inteligente“. Este diseño con Arduino nos permitirá controlar
dos semáforos dependiendo de si hay algún coche esperando o no.

Puede ser muy útil para las personas aficionadas a las maquetas de tren o de otro tipo. Si tu eres uno de
ellos ya conocerás Miniatur Wunderland (Maravillas en Miniatura) que es la maqueta más grande
del mundo con más de 6.000 m². Mira el siguiente vídeo y verás lo impresionante que es.

Objetivo

El objetivo es poder simular un cruce con semáforos donde se detecte la presencia de los coches
para activar o desactivar los semáforos. Para esta simulación utilizaremos unos pulsadores que nos
indicará que ha llegado un coche al cruce.

En un estado inicial habrá un semáforo en verde. Mientras no haya coches en el otro semáforo se
mantendrá en verde. Cuando llegue un nuevo coche al semáforo en rojo dejará pasar un tiempo y se
pondrá en verde cerrando el otro semáforo. Así se irán alternando uno y otro.

Componentes

 6 x resistencias 220 Ω
 2 x LEDs
 2 x LEDs
 2 x LEDs
 2 x pulsadores
 2 x resistencia 10 k (pull down)

Este proyecto es muy interesante para utilizar interrupciones.


Cuidado con utilizar retardos y tiempos con las interrupciones, no funcionan.

Theremín con LDR


El Theremín es un instrumento musical que fue inventado en el año 1919 por el ruso Lev Termen.
Fue el primer instrumento musical electrónico de la historia y el precursor de lo que se conoce hoy
como música electrónica. Los instrumentos han avanzado mucho desde entonces, pero en aquella
época fue toda una revolución.
Lo que diferencia a este instrumento de otros es que, no es necesario el contacto físico para que
suene. Aplica la física y teoría de antenas para producir el sonido. Utiliza la capacitancia de los seres
humanos para aumentar o disminuir el sonido y cambiar la frecuencia de éste.

Objetivo

En este proyecto con Arduino, el objetivo es simular un Theremín en cuanto al cambio de frecuencia.
La filosofía va a ser la misma lo único que en vez de utilizar la iluminación, vamos a utilizar un sensor
de luz un LDR o fotoresistencia. Cuando acercamos la mano al sensor, el sonido aumentará de
frecuencia (más agudo) y cuando la separamos, la frecuencia disminuye (más grave).

Debemos de ser capaces de discretizar el espectro audible entre 20 Hz y 20 KHz en muestras para
que, dependiendo de donde se encuentre la mano suene de una manera o de otra.

Componentes

 1 x piezoeléctrico
 1 x LDR fotoresistencia

Podemos utilizar un sensor de ultasonidos en vez de un LDR.

Dado eléctrico
Seguro que has jugado al parchís o a algún otro juego donde es necesario utilizar un dado para jugar.
Los proyectos Arduino donde tocamos el lado lúdico, tienen más éxito debido a su carácter divertido.
En este caso vamos a simular un dado de 6 caras, un cubo. Existen otro tipo de dados que tienen más
caras y se utilizan en otro tipo de juegos. Se podría llegar a simular y solo deberíamos cambiar parte de
nuestro código.

Objetivo

El objetivo es conseguir un número aleatorio del 1 al 6 cuando se pulse un pulsador. Este número
saldrá representado en un display de 7 segmentos. Hay que llevar mucho ojo con los números
aleatorios con Arduino ya que si no se hace bien, siempre obtendrás el mismo o la misma secuencia.

Componentes

 1 x pulsador
 1 x display 7 segmentos
 1 x resistencia 10 k(pull down)
 1 x resistencia 220 Ω

En este proyecto también se pueden utilizar interrupciones. Te animo a que lo hagas.

Proyecto Halloween con Arduino


Como extra os dejo un proyecto que propone la marca BQ donde podemos hacer una calavera para que
los niños se diviertan en día de Halloween. Podemos descargar el material para imprimir en su página
web.

Objetivo

Dentro de los proyectos Arduino este es muy interesante para crear con nuestros hijos o alumnos el día
de Halloween. Consiste en una calavera de cartón que se articula con un servomotor. Dentro tiene un
sensor de infrarrojos y cuando detecta que alguien mete la mano para coger las chuches, la calavera se
cierra y suena un sonido. Muy divertido y temático para este día tan especial para los pequeños.

Componentes

1. 1 x servomotor
2. 1 x piezoeléctrico
3. 1 x sensor infrarrojos

Arduino para dummies, una guía básica para principiantes

Copiado de: https://descubrearduino.com/


Cómo funciona Arduino, Una guía de Arduino básica para principiantes Esta es una guía de Arduino
básica para aquel que comienza, al final del articulo os añadiré unos enlaces interesantes para
principiantes también de nuestra web. Si aún no sabes lo que es Arduino pásate por este enlace antes.
¿Que es Arduino? Contenidos 1 Cómo funciona Arduino, Una guía de Arduino básica para
principiantes 2 Introducción, definición de Arduino 2.1 Microcontrolador 2.2 Entradas o Inputs 2.3
Salidas o Outputs 3 Tipos de placas 4 El bootloader o la vida de tu programa 5 Software, programar
Arduino, el IDE 6 Cable USB 7 Programación de Arduino 8 Bibliotecas Arduino 9 Pasos para
configurar la placa 10 Shields o módulos 11 Componentes y Accesorios 12 Enlaces de interes
Introducción, definición de Arduino Como hemos dicho en artículos anteriores y ya muchos sabéis,
Arduino es un hardware basado en el código abierto, es un microcontrolador que se puede utilizar para
muchas aplicaciones diferentes. En resumidas cuentas Arduino es una plataforma de prototipado
electrónico de código abierto basada en hardware y software flexible y fácil de usar. Está dirigido a
artistas, diseñadores, aficionados y cualquier persona interesada en crear objetos o entornos
interactivos. Arduino es una computadora pequeña que se puede programar para leer y controlar
componentes eléctricos conectados a ella. Podría decirse que es la opción más fácil, con más
comunidad detrás y menos costosa entre los microcontroladores para aficionados, estudiantes y
profesionales para desarrollar proyectos basados en microcontroladores. Si aún no te está decidido por
Arduino échale un vistazo a estas razones que tienes para decidirte por esta plataforma. Las placas
Arduino utilizan chips Atmel AVR o Atmel ARM , y algunas versiones tienen una interfaz USB.
También tienen seis o más pines de entrada analógicas y catorce o más entradas digitales / salidas (I /
O) pines que se utilizan para conectar sensores, módulos o shields y otros circuitos periféricos al
microcontrolador. Además una placa de este tipo no es muy cara, si la original te parece cara siempre
tienes clones. Microcontrolador Arduino es un microcontrolador en una tarjeta de circuito que facilita
la recepción de entradas y salidas de accionamiento. Un microcontrolador es una computadora
integrada en un chip. Entradas o Inputs Algunos ejemplos de entradas serían un sensor de temperatura,
un sensor de movimiento, un sensor de distancia, un interruptor, etc. Salidas o Outputs Algunos
ejemplos de salidas serían una luz, una pantalla, un motor, etcétera. Tipos de placas
ArduinoUno_R3_y_usb Hay muchos tipos diferentes de placas disponibles, como se muestra en la
siguiente lista, cada uno con su propio conjunto de características. Se diferencian en cuanto a la
velocidad de procesamiento, memoria, puertos I / O, y la conectividad, pero su funcionalidad básica es
la misma. Las siguientes son algunas de ellas. Arduino Uno Arduino MKR1000 Arduino Leonardo
Arduino Due Arduino Yun Arduino Tre Arduino Micro Arduino Robot Arduino Esplora Arduino
Mega Arduino Mini Arduino LilyPad Arduino Nano Arduino Fio Arduino Pro Tienes un resumen de
las placas más importantes y usadas en el siguiente artículo de nuestra web, elegir la placa Arduino
adecuada para tu proyecto. El bootloader o la vida de tu programa La memoria del microcontrolador
que llevan estas placas es del tipo Flash, es decir que persiste aunque se le desconecte de la fuente
dealimentación. Para cambiar el programa dentro de la placa, se necesita otro programa, que reside en
la parte protegida de la placa. Ese programa se llama bootloader. El bootloader es un programa que ya
está precargado en la placa y que permite volver a programarlo desde un ordenador. Una vez se carga
un programa nuevo en la placa, el programa permanece ahí hasta que se cargue uno nuevo o una nueva
versión. Software, programar Arduino, el IDE El software utilizado para programar la placa se
denomina “entorno de desarrollo integrado” (IDE). El IDE es una aplicación Java que se ejecuta en
muchas plataformas diferentes, incluyendo PC, Mac y Linux. Está desarrollado para los principiantes
que no están familiarizados con la programación. Incluye un editor de código, un compilador y un
cargador. idearduino También se incluyen las bibliotecas de código para el uso de periféricos, tales
como puertos serial y varios tipos de pantallas. Los programas realizados para Arduino son llamados
“sketches” o “bocetos”, y están escritos en un lenguaje muy similar a C o C ++. El software es libre y
gratuito. Cable USB USBCable La mayoría de placas se pueden conectar a un equipo host a través de
un cable USB. Esta conexión permite subir programas a la placa, así como proporcionar alimentación
a la placa. Programación de Arduino La programación de un Arduino es fácil: como he dicho un poco
más arriba, se utiliza el editor de código IDE para escribir el programa y luego compilarlo y cargarlo
con un solo clic. Un programa incluye dos funciones principales: 1. setup() 2. loop() La función setup
() se utiliza para inicializar la configuración de la placa. Esta función se ejecuta sólo una vez, cuando el
tablero se enciende. La función loop () se ejecuta después de la setup () completa, y a diferencia de la
función setup (), se ejecuta continuamente. Funciones de programación. Estas son algunas de las
funciones más utilizadas en la programación de Arduino: pinMode – establece el modo de pin de
entrada o salida. analogRead – lee un voltaje analógico de un pin de entrada analógica. analogWrite –
escribe un voltaje analógico a un pin de salida analógica. digitalRead – lee el valor de un pin de
entrada digital. digitalWrite – establece el valor de un pin de salida digital para alta o baja. Serial.print
– datos grabados en el puerto serie como texto ASCII legible. Si se te hace dificil programar a través
del IDE de Arduino hay también alternativas gráficas para poder hacerlo, tienes las más interesantes en
este artículo de nuestra web, donde vemos 5 alternativas gráficas para programar nuestro Arduino.
Bibliotecas Arduino Las bibliotecas son colecciones de funciones que permiten controlar distintos
dispositivos. Estas son algunas de las bibliotecas más utilizados: Biblioteca GPS Biblioteca LCD
Biblioteca Servo Biblioteca SD Biblioteca Robot_control Biblioteca Robot_motor Biblioteca de
Ethernet Biblioteca de Wi-Fi Biblioteca Stepper Biblioteca SPI Biblioteca EEPROM Software Serial
biblioteca Biblioteca de GSM Pasos para configurar la placa En primer lugar, se instala el software
IDE. Se puede descargar el IDE desde el sitio web oficial. Instalar el software en su PC. Ahora ejecutar
el archivo .exe IDE Arduino. Tiene un siguiente distribución: Crear el programa usando el editor de
código y cargarlo en la placa. Para ello, es necesario conectar la placa al ordenador mediante un cable
USB. En el IDE, hay que seleccionar el tipo de placa que estás utilizando de las Herramientas -> menú
de placas. Ahora comprueba el código haciendo clic en el icono de comprobación en la parte superior
de la ventana del IDE, a continuación, haz clic en el botón de compilar y carga el código en la placa.
selecciona-arduino Eso sí quizás tengas que instalar los controladores si el sistema no detecta nuestra
placa. Shields o módulos Los shield o módulos son tableros o módulos que se conectan a la placa y
que permiten conectar dispositivos periféricos, sensores y otros dispositivos nuestro proyecto. A
continuación os listamos los mas populares: shield GSM shield Ethernet shield WiFi shield Motor
Proto shield Joystick shield Bluetooth shield Xbee Componentes y Accesorios A continuación os
mostramos una lista de todos los componentes y accesorios de uso general para usar estas placas a la
hora de desarrollar proyectos: Breadboard Cable USB Batería de 9V LEDs Pulsadores o botones
Condensadores Reguladores de voltaje Sensores (IR, de temperatura, etc.) Puentes Resistencias
Potenciómetros Motors (DC, Servo, BLDC) LCD Teclado Hex Modulos o shields Enlaces de interes
Arduino Qué es, cómo empezar y dar los primeros pasos Elegir la placa Arduino adecuada para tu
proyecto. Una introducción. 5 consejos a la hora de comprar y empezar con Arduino Análisis del
Arduino Starter Kit tick arduino-uno Todo lo necesario para empezar con Arduino Si estás empezando
y no te atreves a meterte a programar con el código te recomendamos que empieces usando una
alternativa gráfica para la programación, en este artículo te enseñamos unas cuantas. Aquí os dejamos
un podcast donde nos dan brevemente una introducción a Arduino. Unos cuantos proyectos para
empezar: 10 proyectos arduino sencillos para principiantes 5 proyectos para empezar con Arduino este
verano 2 divertidos proyectos arduino funcionando con energía solar 2 proyectos de Arduino para
ayudarnos en la cocina 5 proyectos divertidos para hacer con Arduino y LEGO Si te has quedado con
más ganas de proyectos realizados con Arduino pásate por la sección de proyectos con Arduino de
nuestra web.

Copiado de: https://descubrearduino.com/