Introducción

Arduino es una plataforma de desarrollo abierta, concebida para la creación de prototipos y aplicaciones
Hardware. Arduino fue creado inicialmente para estudiantes, ya que antes de esto las placas que existían eran
caras y tenían una arquitectura cerrada, lo que no las hacía atractivas ni a la comunidad de estudiantes, ni a los
aficionados a la electrónica en general.

Con la creación de Arduino como un sistema de desarrollo abierto (no necesita licencias) y la constitución de
un lenguaje de programación propio, en el que prima la sencillez en la programación, dio como resultado un
entorno de desarrollo muy cercano a la gente, que facilita el uso de la electrónica en proyectos de todo tipo,
haciendo esta plataforma muy atractiva y constituyendo entorno a ella una de las comunidades más grandes de
desarrollo que existen en internet actualmente.

El Hardware de Arduino, consiste en una placa con un microcontrolador Atmel AVR, en función del modelo de
placa llevará un microcontrolador u otro, los más usados son el Atmega168, Atmega328, Atmega1280 y el
ATmega8. En los últimos años también se han empezado a implementar microcontroladores ARM de 32bits.
Una de las características que hacen que Arduino sea un sistema muy extendido y muy valorado, es su alta
conectividad, y es que saca al exterior todas las salidas del microcontrolador mediante pines de conexionado
rápido (tan solo tendremos que "pinchar" cables como lo hacemos con las protoboards). Además se ha creado
un estándar en cuanto a la distancia y situación de estos pines, esto es así para la implementación de todo tipo
de "shields" los cuales son otra gran baza a la hora de elegir Arduino frente a otras plataformas de desarrollo.

Modelos de Arduino
En la actualidad Arduino ha lanzado al mercado, placas, shields y sensores casi para cualquier cosa, las
diferencias fundamentales entre una placa u otra suelen ser, el numero de pines que sacan al exterior y la
tipología de estos (si son pines digitales, analógicos o de PWM...), la memoria de programa de la que
disponemos y la frecuencia de reloj del microcontrolador, o lo que es lo mismo, la velocidad a la que podemos
trabajar. En función de estos tres parámetros, deberemos escoger una placa u otra para nuestros proyectos
(dependiendo de nuestras necesidades), ya que puede que tan solo necesitemos unas pocas entradas/salidas y
que la velocidad en nuestra aplicación no sea importante o quizás tengamos que gestionar 20 o 30 procesos
diferentes y hacerlo de manera casi instantánea, según lo que queramos hacer, podemos ajustarnos a una placa
u otra, ya que como es lógico una placa con mayor número de entradas/salidas, mayor memoria de programa y
mayor velocidad será más cara y puede que nuestros proyectos no necesiten estos recursos.
En la imagen superior, podemos ver varios de los Arduinos más comunes, aunque el catalogo es más extenso y
dentro de los mismo modelos podemos encontrar variantes. Si quieres ver una lista completa de los productos
de Arduino

A continuación a modo de resumen y para conocer las características más importantes de cada Arduino,
muestro una tabla donde se pueden ver el número de entrada/salidas de cada tipo, la memoria y la frecuencia de
reloj a la que trabaja el microcontrolador. Esta tabla nos será muy útil para determinar que Arduino es el que
mejor se puede adaptar a nuestro proyecto.

Shield's y sensores
Como mencioné anteriormente, una gran parte del éxito de la plataforma Arduino reside en la gran variedad de
shields y sensores que podemos encontrar en el mercado, estos dan realmente la funcionalidad a Arduino y
hacen mucho más sencilla la creación de cualquier proyecto electrónico, pero...¿ que es realmente un "shield"?.
Para explicarlo de forma sencilla, podríamos decir que si Arduino es el cerebro del sistema, un shield puede
llegar a ser desde el musculo hasta los sentidos del sistema. La placa Arduino tan solo puede trabajar con
pequeñas señales, además esta placa no tiene demasiada conectividad aparte de la conexión USB que posee y
algún puerto serie interno del propio microcontrolador, por ello y a modo de que cada cual adapte Arduino a
sus necesidades, surgen los shields, hay desde shield para controlar motores o elementos de potencia, hasta
shields que dan conectividad, wifi, GSM o incluso bluetooth, esto hace que Arduino sea un sistema modular el
cual podemos adaptar según las necesidades del proyecto. Una particularidad de la mayoría de los shields es
que tan solo hay que pincharlos en la placa Arduino y cargar la librería para que sean totalmente funcionales.
Esto hace que sea muy rápido añadir módulos al sistema. En cuanto a los sensores, decir que también hay una
gran variedad ya creada y adaptada para funcionar con Arduino, podemos encontrar desde sensores de presión,
humedad, temperatura, acelerómetros, sensores de distancia.... En futuros tutoriales, según vaya utilizando
tanto los shields como los sensores, iré poniendo sus características más destacadas y su forma de uso.
Conociendo Arduino (instalación y entorno)

Una vez introducido Arduino y habiendo elegido una de las múltiples plataformas Arduino que existen en el
mercado, es hora de conectar nuestra placa al ordenador y empezar a desarrollar nuestra aplicación, pero para
ello primero será necesario que nuestro ordenador reconozca nuestra placa Arduino y conocer el entorno de
programación que vamos a utilizar.

Descarga del entorno de desarrollo y drivers

Para empezar hay que ir a la página oficial de Arduino donde podemos descargar las últimas versiones del
software. Según nuestro sistema operativo, tendremos que descargar una versión u otra, y dentro de la opción
de Windows, podemos hacer la descarga como un archivo ejecutable o como un archivo ZIP.

Dentro del archivo ejecutable, se encuentra tanto el entorno de desarrollo para Arduino, como los driver
necesarios para que el dispositivo sea reconocido por nuestro ordenador.

Instalación de los drivers

Para que nuestro ordenador reconozca correctamente la placa Arduino, es necesario instalar los drivers para el
procesador FTDI, estos drivers se encuentran dentro de los archivos que hemos descargado, si hemos realizado
la descarga en formato ZIP, tendremos que descomprimir la carpeta para acceder a los drivers.

Para instalar los drivers, conectaremos Arduino a nuestro equipo, normalmente esta conexión se hace a través
de USB, aunque hay modelos de Arduino que no poseen esta conexión y deben de conectarse al PC con una
conexión serie, si este es el caso, tendremos que alimentar la placa de manera externa.

Al conectar Arduino mediante USB al PC, veremos cómo se enciende un LED verde, esto nos indica que la
placa está siendo alimentada correctamente. Al momento de conectar nuestra placa al ordenador, Windows
mostrará el mensaje de que hemos conectado un nuevo dispositivo y ejecutara automáticamente el instalador.

En el asistente de la instalación le diremos que no se conecte a internet para buscar los drivers y en la siguiente
pantalla, que los instalaremos desde una localización especifica, que se encontrará dentro de la carpeta que
hemos descargado anteriormente, en nuestro caso será la carpeta "drivers" que se encuentra dentro de la carpeta
arduino-1.0.5 (la que hemos descargado).
Si el asistente de instalación no se ejecutase, tendríamos que hacer la instalación de manera manual, para ello,
clicamos con el botón derecho sobre el icono de nuestro equipo (o abrimos la ruta "Panel de control\Sistema y
seguridad\Sistema"), entramos en "administrador de dispositivos" y veremos que hay un dispositivo que
aparece como desconocido, damos botón derecho sobre él , y de entre las opciones que aparecen, le damos a
"actualizar software del controlador". Los siguientes pasos son los mismo que instalando con el asistente.
Una vez hecho esto, podemos ver en el administrador de dispositivos como nuestro Arduino aparece totalmente
identificado. Ya podremos usarlo y cargar nuestros programas en él.
El entorno de trabajo

Ahora que nuestro ordenador reconoce perfectamente nuestra placa, es hora de abrir el entorno de trabajo
donde programaremos nuestras aplicaciones. El entorno de programación de Arduino no necesita instalación,
tan solo tendremos que ir a la carpeta que descargamos y hacer doble clic sobre el icono que pone
"arduino".(Recomiendo guardar la carpeta de Arduino en algún lugar de nuestro disco donde creamos que este
segura y crear un acceso directo en el escritorio.)

Al hacer esto nos aparecerá la pantalla principal el Sketch, donde podemos diferenciar las siguientes partes:

 Área de trabajo: Esta será el área donde vamos a escribir el programa que queremos ejecutar en Arduino.

 Verificación: Cuando redactemos nuestro programa, podemos verificar que la sintaxis del mismo es
correcta y que no hemos cometido ningún error pulsando sobre este icono, si hay algún error, no podremos
cargar el programa en Arduino.
 Carga de programa: Cuando tengamos listo nuestro programa y no tenga ningún error, lo cargaremos en
Arduino pulsando sobre este botón.
 Archivo nuevo: Abrirá una nueva área de trabajo.
 Abrir un programa: Al pulsar sobre este botón, tendremos la opción de abrir un archivo desde una
ubicación especifica o cargar en nuestra área de trabajo una serie de programas o librerías ya creadas y que
tiene Arduino por defecto.
 Guardar programa: Guardara en una ubicación especificada por el usuario el contenido del área de trabajo.
Antes de ponernos a programar, deberemos de seleccionar en el Sketch con que placa Arduino estamos
trabajando y a que puerto USB de nuestro ordenador está conectado nuestro Arduino, para ello iremos a la
pestaña "Herramientas" y dentro de esta pestaña podemos ver el apartado "Tarjeta" y "Puerto Serial", donde
seleccionaremos el modelo de nuestro Arduino y el puerto USB al que está conectado. Normalmente el puerto
USB es detectado automáticamente, pero si tenemos varios Arduinos conectado a nuestro PC, tendremos que
seleccionar el puerto.

Cargando nuestro primer programa

Si ya hemos instalado los drives de nuestro Arduino, abierto el Sketch y configurado tanto la placa que vamos a
usar como el puerto de nuestro ordenador al que está conectado, ya tenemos todo listo para poder cargar
nuestro primer programa!!

Como ejemplo y a modo de verificar que nuestra placa funciona correctamente, vamos a cargar un programa
que trae por defecto el software de Arduino y que se llama "blink" (en español "parpadeo"), este es un sencillo
programa que lo único que va a hacer es poner a parpadear un led que está asociado a la patilla 13 de nuestro
Arduino.

Para cargar este programa en nuestra área de trabajo, vamos a pulsar sobre el icono "abrir" y se nos mostrará
una lista con varios programas que trae nuestro Arduino por defecto. Vamos a cargar, el programa "Blink" que
se encuentra dentro de "Basics".
Una vez cargado podemos ver la estructura básica del programa en la que entraremos con más detalle en
posteriores tutoriales, por ahora, podemos fijarnos en como enciende y apaga el led para comenzar a entender el
código, para encender el led, usa la instrucción "digitalWrite(led, HIGH);", espera 1000 milisegundos (1
segundo) "delay(1000);" y lo apaga "digitalWrite(led, LOW);" esperando otros 1000 milisegundos apagado.

Con el programa en el área de trabajo, daremos a "cargar" para pasar el código del programa a nuestro Arduino,
viendo como parpadean rápidamente los leds "TX" y "RX" de la placa que indican que se está llevando a cabo
la comunicación entre el ordenador y Arduino. Una vez cargado el programa, veremos como el led asociado a
la patilla 13, empieza a parpadear a intervalos de 1 segundo.

A modo de prueba y para ir cogiendo soltura, podemos cambiar el tiempo que el led permanece encendido o
apagado modificando valor que hay encerrado entre paréntesis en la función "delay".
Conociendo Arduino (Funciones)

Ahora que tenemos nuestra placa correctamente instalada y conocemos el entorno de programación para
nuestro Arduino, llega el momento de aprender a programar!!. He de decir que esta es la parte difícil y quizás
aburrida para muchos, pero del conocimiento del lenguaje de programación va a depender que nuestros
programas puedan hacer cosas increíbles.

Arduino, como muchos otros lenguajes de programación, tiene infinidad de funciones, operadores, variables....
si tuviera que enunciarlos y explicarlos todos en este capítulo sería larguísimo y no creo que nadie llegara hasta
el final sin aburrirse, por ello lo que voy a hacer es una introducción al lenguaje para que conozcáis que
podemos encontrarnos y de que recursos disponemos a la hora de programar. Iremos aprendiendo el uso de las
funciones poco a poco usándolas en pequeñas aplicaciones.

Para aquellos que queráis avanzar algo mas rápido os recomiendo que uséis alguno de los muchos libros o
manuales que hay para iniciarse en Arduino, muchos de los cuales son gratuitos. Yo he confeccionado un
manual a partir de la información que se puede encontrar en la página oficial de Arduino, este manual explica
todos los conceptos básicos y está muy bien para aprender, el manual lo podéis descargar de aquí.

Estructura
Al empezar a trabajar con Arduino, tenemos que tener muy claro la estructura de trabajo básica, esta estructura
es muy simple y debe aparecer en TODOS los programas, se trata de dos funciones, la función "setup" y la
funcion "loop".
?

1 void setup() //Funciópn SetUp (configuración)

2 {
3 pinMode(13, OUTPUT);
4 }
5 void loop() //Función Loop (se ejecutará cíclicamente)
6 {
7 digitalWrite(13, HIGH);
8 delay(1000);
9 digitalWrite(13, LOW);
10 delay(1000);
11 }

Arriba podemos ver estas dos funciones en un ejemplo que ya conocemos el "blink", como se aprecia, la
función "Setup" declara el Pin 13 como salida, ya que es por este Pin por donde pretendemos sacar
información, o en nuestro caso el estado del Led. La función "Setup" solo se invoca una vez al inicio del
programa, y se usa para configurar los pines, configurar la comunicación serie o establecer un estado inicial o
de partida para algún dispositivo.

La función "Loop" será la función donde se encuentre el grueso de nuestro programa, esta función se repetirá
una y otra vez ejecutando lo que se encuentre en su interior, esta repetición es la que posibilita que el programa
este actualizándose y respondiendo a los eventos que ocurran.
Las funciones "Loop" y "Setup" son necesarias en todos los programas que hagamos, pero no tienen por qué ser
únicas, podemos crear tantas funciones como queramos para organizar el contenido de nuestro programa ó para
hacer tareas repetitivas dentro de nuestro programa principal. Las funciones están acotadas por las llaves{},
estas llaves definirán el bloque de la función.

Instrucciones y operadores
Delimitadores: son elementos que acotan o detienen el alcance de una función o instrucción
{} Llaves: definen el principio y el final de un bloque de instrucciones o función, podemos encontrarlas en
estructuras de control definiendo el bloque al cual afecta la función. Podemos anidar tantos bloques como
queramos.

; Punto y coma: Se utiliza para separar instrucciones, es común olvidar colocarlo al final de línea. Si no lo
ponemos no reconocerá el fin de la función y el programa dará un problema al compilar.

Comentarios: Es muy recomendable usar comentario desde el principio para hacer anotaciones sobre el
funcionamiento del programa, esto nos va a ahorrar muchos problemas si nuestro programa se hace muy grande
y va a permitir que otras personas entiendan como hemos hecho el programa.

/*….*/ Bloque de comentario: Son áreas de texto que pueden abarcar más de una línea, lo que escribamos
entre esos símbolos será ignorado por el programa.

// Línea de Comentario: Funciona como el bloque de comentario, con la diferencia que solo será ignorado
el texto que este a su derecha, al cambiar de línea perderá el efecto.
Operadores: Los operadores son los elementos con los que vamos transformar variables, hacer comparaciones,
contar un número determinado de eventos… en definitiva, los operadores se pueden considerar los elementos
más importantes del programa junto con las estructuras de control. Dentro de los operadores, podemos
encontrarlos de varios tipos

Aritméticos: Son operadores básicos como la suma, resta, multiplicación y división, también podríamos
incluir aquí la operación de asignación “=”

1 /* OPERADORES ARITMÉTICOS */
2 x = x + 5; //suma x+5 y guarda el valor en x
3 y = y - 8; //resta 8 a el valor "y" almacena el resultado en "y"
4 z = z * 2; //multiplica z*2 y guarda el valor en z
5 k = k / 3; //divide k entre 3 y guarda el valor en k
6 p = 10; // asigna a p el valor 10

Asignaciones compuestas: Combinan una operación aritmética con una variable ya asignada. Se usan
comúnmente en bucles.
?

1 /* OPERADORES DE ASIGNACIÓN COMPUESTA */

2 x ++; //equivale a x = x + 1 (incrementa x en 1)
3 x --; //equivale a x = x - 1 (decrementa x en 1)
4 x += y; //equivale a x = x + y
5 x -= y; //equivale a x = x - y
6 x *= y; //equivale a x = x * y
7 x /= y; //equivale a x = x / y

De comparación: Este tipo de operadores se usan para comprobar variables o constantes con otras verificar
así si una condición es verdadera o no. Suelen utilizarse en conjunto con estructuras de control.

1 /* OPERADORES DE COMPARACIÓN */
2 x == y; //x es igual a y
3 x != y; //x es distinto de y
4 x < y; //x es menor que y
5 x > y; //x es mayor que y
6 x <= y; //x es menor o igual que y
7 x >=y; // x es mayor o igual que y

Booleanos: Son operadores lógicos que se usan para comparar 2 o más expresiones y que no devuelven un
valor, sino que dan un estado de “verdadero” (si se cumple la expresión) o “falso” (si no se cumple).
?

1 /* OPERADORES BOLEANOS */
2 if (x<3 && x>0) //Cierto si se cumplen las dos expresiones
3 if (x<7 || x=20) //Cierto si se cumple alguna de las dos expresiones
4 if (!x=3) //Cierto si x es distinto de 3

Estructuras de control: En las estructuras de control se engloban todos los estamentos que sirven para guiar al
programa en una u en otra dirección en función de si se cumplen las condiciones que le marquemos. Dentro de
estas estructuras podemos encontrar condicionales, bucles o elementos de salto.
Condicionales: Los condicionales chequean un estado o condición y si esta condición se cumple se pasa a
ejecutar las sentencias englobadas dentro de la condición.
?

1 /* CONDICIONALES */
2 if (x==10) //Si x es igual a 10 ejecuta la instrucción
3 {
4 ejecuta instrucciones
5 }
6
7
8 if (y != 10) // Si y es distinto de 10 ejecuta la instrucción
9 {
10 ejecuta instrucciones
11 }
12 else //si no, ejecuta esta instrucción
13 {
14 ejecuta instrucciones
15 }

Bucles: Los bucles son unos estamentos los cuales harán que el programa entre en un ciclo de repetición
mientras se cumplan las condiciones del bucle.

1 /* BUCLES */
2
3 /*Entra en el bucle "for" y se repetirá mientras se cumpla la condición*/
4 for(int x=0; x<20; x++) //asigna a x el valor 0; condición ; incrementa x en 1
5 {
6 ejecuta instrucciones
7 }
8
9 /* El bucle while se ejecutará siempre que se cumpla la condición*/
10 while (x!=0)
11 {
12 ejecuta instrucciones
13 }
14
15 /* El bucle "do...while" se ejecuta almenos 1 vez, luego dependerá de si se cumple la condición */
16 do
17 {
18 instrucciones
19 }while (x!=0);
 Sentencias especiales: Estas sentencias se usan en programas avanzados y normalmente se utilizan cuando
trabajamos con varias funciones. Si estás empezando a programar con Arduino no tengas demasiado en
cuenta estas instrucciones.
Break: Esta es una sentencia que debemos evitar a la hora de programar, tan solo se usará cuando sea
totalmente inevitable. Lo que hace la sentencia es "romper" la iteración del bucle saliéndose del
mismo sin tener en cuenta que se cumplan las condiciones marcadas para salir.

Goto: Esta sentencia marcará un lugar del código al cual realizaremos un salto. La posición desde la
que saltemos quedará almacenada en la pila del programa para que podamos regresar. Esta sentencia
se usa para hacer saltos a funciones que puedan hacer tareas repetitivas o que tengamos que chequear
constantemente y una vez ejecutada continuar con el programa normalmente.

Return: Es la sentencia que se utiliza para volver de un salto (goto)

Funciones Básicas: Para los que tengáis nociones de programación las instrucciones vistas hasta ahora os
sonarán, ya que son comunes a varios lenguajes de programación como por ejemplo #C, pero no debemos de
olvidar que lo que estamos programando es un dispositivo físico dotado con pines de entrada/salida que
comunican nuestra placa con diversos elementos, por ello existen instrucciones adicionales a las que podemos
encontrar en otros lenguajes de programación similares y que en Arduino son BASICAS, ya que en
prácticamente la totalidad de las aplicaciones que creemos tendremos que leer el estado de pulsadores,
sensores, niveles de tensión.... y normalmente tendremos que actuar sobre relés, leds, motores...
Pin mode: Esta instrucción se usa para configurar los pines de nuestro Arduino como entrada o como
salida. Se declarará dentro de la función "SetUp", por lo que la configuración de pines solo se hará una
vez antes de empezar a ejecutar el programa principal. Los pines de Arduino están configurados como
entrada por defecto, por lo que no es necesario definirlos en caso de usarlos como entrada

1 /* PIN MODE */
2 pinMode (13,OUTPUT); //establece el pin 13 como salida
3
4 int led=10;
5 pinMode led,OUTPUT); //establece "led" (que esta asociado al 10) como salida

Entradas/Salidas digitales: Las entradas y salidas digitales solo trabajaran con dos estados "ALTO" o
"BAJO" que irá asociados a un nivel de 5 voltios(alto) ó 0 voltios (bajo) (también podemos encontrarnos
con Arduinos que trabajan a 3.3v).

1 /* ENTRADAS/SALIDAS DIGITALES */
2
3 //digitaRead (pin)
4 entrada = digitalRead(10); //hace que la variable "entrada" sea igual al estado del pin 10
5
6 //digitalWrite (pin, valor)
7 digitalWrite (10, HIGH); //establede el pin 10 como HIGH (saca 5 voltios)

Entradas/Salidas analógicas: Estos pines a diferencia de los pines digitales pueden tomar cualquier valor
entre 0 y 5 voltios. A la hora de leer un valor tendremos una resolución de 10bit's o lo que es lo mismo, el
valor que podemos leer tendrá un rango entre 0 y 1023. Para escribir un valor analógico lo haremos
usando el PWM (modulación por ancho de impulso), para esto la resolución será de 8 bit's teniendo un
rango de 0 a 255.

/* ENTRADAS/SALIDAS ANALÓGICAS */
1
2
//analogRead (pin)
3
entrada = analogRead (1); //hace que la variable "entrada" sea igual al valor del pin 1
4
5
//alnalogWrite (pin,valor)
6
analogWrite (12, 128); //saca por el pin 12 el valor de tensión correspondiente a 128 (mas o menos 2,5
7
voltios)

Instrucciones de tiempo: Son instrucciones que nos sirven para hacer temporizaciones o para comprobar el
tiempo transcurrido desde el inicio del programa.

1 /* FUNCIONES DE TIEMPO */
2
3 //delay (ms)
4 delay (1000); //espera 1000 milisegundos antes de ejecutar la siguiente instrucción
5
6 //millis()
7 tiempo = millis(); //asigna a la variable "tiempo" el tiempo trasncurrido desde el inicio del programa.

Funciones de matemáticas: son funciones que nos ayudaran con el desarrollo de algunos de nuestros
programas, hay que decir que existe una librería llamada "math.h" la cual añade nos da la posibilidad de añadir
operaciones como elevar al cuadrado, hacer senos, cosenos, arcotangente... esto lo veremos con posterioridad,
de momento solo nombraré las funciones básicas de matemáticas.
?

1 /* FUNCIONES MATEMÁTICAS */
2
3 //min (x,y)
4 minimo = min(valor, 100); //asigna el valor mas pequeño (entre "valor" y 100) a la variable minimo
5
6 //max (x,y)
7 maximo = max(valor, 100); //asigna el valor mas grande (entre "valor" y 100) a la variable maximo
8
9 //ramdomSeed(seed)
10 randomSeed(valor); // hace que la variable valor tome un valor aleatorio

Funciones Serial : Las placas de Arduino tienen al menos 1 puerto serial para la comunicación con el ordenador
o con otros dispositivos, esta comunicación se llevará a cabo mediante los pines TX y RX (podemos tener
varios en nuestra placa según el modelo).

/* FUNCIONES SERIAL */
1
2
//Serial.begin(rate)
3
Serial.begin(9600); //abre el puerto seríe y establece la velocidad de comunicación en 9600bps (esta
4
funcion debe de ponerse en el SetUp)
5
6
//Serial.println(data)
7
Serial.println(digitalRead(12); //manda por el puerto serial el valor que tenga el pin 12
8
9
//Serial.read()
10
Valor_leido = Serial.read(); //asigna a "Valor_leido" el valor que lea del puerto serial.

Existen más instrucciones en Arduino, además de todas las que pueden ser añadidas poniendo bibliotecas
adicionales, pero creo que con todas las mencionadas anteriormente, tenemos más que suficiente para empezar
a hacer nuestros proyectos, y no os preocupéis si ahora os suenan a chino, porque iré utilizándolas todas ellas
en pequeños ejemplos donde veréis claramente cómo funcionan y empezareis a ver por vosotros mismo nuevas
formas de combinarlas para conseguir hacer vuestros propios proyectos.

Lenguaje de Programación
Arduino se programará mediante un editor de texto o "sketch" el cual usa un lenguaje propio creado
expresamente para la plataforma Arduino, este lenguaje, está basado en "Processing", que es un lenguaje de
alto nivel. El Sketch es un entorno de programación sencillo el cual no tiene más que las opciones básicas de
programación, verificación del código y carga en la placa Arduino.