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 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 a rchivo 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 ca rgaremos 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, tutoriales, por ahora, podemos fijarnos en como enciende y apaga el led para comenzar 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í 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 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 problema al compilar. Comentarios: Es muy recomendable usar comentario desde el principio para hacer anotaciones sobre el funcionamiento del programa, programa, esto nos va a ahorrar muchos problemas si nuestro programa se hace muy grande y va a permitir per mitir 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 valor 10
Asignaciones compuestas: Combinan 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
/* OPER OPERAD ADORE ORES S DE COMPAR COMPARACI ACI 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 e xpresiones
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 5
ejecuta instrucciones }
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 15
ejecuta instrucciones }
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 7
ejecuta instrucciones }
8 9
/* El bucle while se ejecutará siempre que se cumpla la condición*/
10
while (x!=0)
11
{
12 13
ejecuta instrucciones }
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 nor malmente 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 //establece el pin 13 como salida salida
3 4
int led=10;
5
pinMode led,OUTPUT); //establece //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 2
/* ENTRADAS/SALIDAS DIGITALES */
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. ? 1 2 3 4 5 6 7
/* ENTRADAS/SALIDAS ANALÓGICAS */ //analogRead (pin) entrada = analogRead (1); //hace que la variable "entrada" sea igual al valor del pin 1 //alnalogWrite (pin,valor) analogWrite (12, 128); //saca por el pin 12 el valor de tensión correspondiente a 128 (mas o menos 2,5 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 e xiste 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). ? 1 2 3 4 5 6 7 8 9 10
/* FUNCIONES SERIAL */ //Serial.begin(rate) Serial.begin(9600); //abre el puerto seríe y establece la velocidad de comunicación en 9600bps (esta funcion debe de ponerse en el SetUp) //Serial.println(data) Serial.println(digitalRead(12); Serial.println(digitalRead(12); //manda por el puerto serial el valor que tenga el pin 12 //Serial.read() 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 P rogramació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. Arduino.