¿QUÉ ES EL ENC28J60?

El ENC28J60 es un controlador de Ethernet diseñado para sistemas embebidos

fabricado por Microchip Technology Inc. Podemos usar el ENC28J60 junto a un
procesador como Arduino para conectar nuestros proyectos de electrónica y robótica con
Internet.

El ENC28J60 se controla a través de bus SPI, por lo que la conexión con Arduino es
muy sencilla. El ENC28J60 opera a 3.3, pero es tolerante a señales de 5V, por lo que su
integración es aún más sencilla.

El ENC28J60 soporta velocidades de 10Mbits/s y los modos Dúplex (Full-Duplex)

y Semi-dúplex (Half-Duplex) con detección y corrección automática de la polaridad. El
ENC28J60 cumple con las especificaciones IEEE 802.3 10BASE-T.

El ENC28J60 incorpora filtrado de paquetes para limitar el número de paquetes

entrantes, un módulo DMA interno para facilitar el flujo de datos y hardware especifico
para el cálculo de las sumas de control (IP checksums).

Anuncio:

El ENC28J60 es uno de los procesadores más baratos para dotar conectividad a

nuestros proyectos, y es más barato que otras alternativas como el W5100.

Sin embargo, el ENC28J60 carece de una pila de TCP/IP por hardware como sí que
incluye el W5100. Por tanto, su uso es más complejo y requiere una mayor carga del
procesador.

PRECIO
El ENC28J60 es un módulo muy barato, siendo precisamente una de sus principales
ventajas. Podemos encontrarlo por unos 2.10€, buscando en vendedores internacionales
de eBay o AliExpress.
ESQUEMA DE MONTAJE
La conexión de un módulo de Ethernet ENC28J60 es muy sencilla ya que la
comunicación se realiza a través del SPI como vimos en esta entrada.

La conexión en este caso, vista desde Arduino, sería la siguiente.

EJEMPLOS DE CÓDIGO
Para controlar los módulos de Ethernet ENC28J60 usaremos la librería Ethercard.h
disponible en este enlace.

La librería proporciona varios ejemplos de uso del ENC28J60 que resulta

aconsejable revisar. Los siguientes ejemplos son modificaciones a partir de los
disponibles en la librería.

CLIENTE ETHERNET – LEER PÁGINAS WEB

En este ejemplo Arduino actúa como cliente, es decir, se conecta a una página web
para leerla. Leer una página completa y volcarla por el puerto serie es muy lento, y es una
de las muestras de las limitaciones de Arduino frente a un ordenador.
 Sin embargo, puede ser útil para Arduino capture información desde un servidor.
Por ejemplo, podemos hacer que sincronice la hora, que lea una serie de parámetros de
un fichero de texto, que realice una determinada acción si existe un fichero, etc.

Para mostrar en este ejemplo esta capacidad de lectura de datos desde un servidor en
Internet vamos a usar www.pasted.co, una de muchas páginas web que nos permiten
añadir un texto para compartirlo con más gente.

En la página www.pasted.co/2434bc64 he pegado el texto ~1.2.3.4.5~. Los ‘~’ los

usaremos como separadores para encontrar el texto deseado ‘1.2.3.4.5’, que simula una
serie de parámetros que queremos capturar de un servidor.

El siguiente ejemplo se conecta con esta dirección y realiza la búsqueda del texto
1.2.3.4.5, que muestra por puerto serie. En un ejemplo real emplearíamos estos valores,
por ejemplo, para controlar un robot, cambiar los parámetros de medición de una estación,
encender o apagar un dispositivo, etc.

Arduino no tiene potencia suficiente para gestionar la encriptación necesaria en páginas https, por lo que
sólo podremos leer páginas http.

1 #include <EtherCard.h>
2
3 static byte mymac[] = { 0xDD, 0xDD, 0xDD, 0x00, 0x01, 0x05 };
4 static byte myip[] = { 192, 168, 1, 177 };
5
6 byte Ethernet::buffer[700];
7 static uint32_t timer;
8
9 const char website[] PROGMEM = "www.pasted.co";
10 const char dataLocationC[] = "/2434bc64";
11
12 // called when the client request is complete
13 static void my_callback (byte status, word off, word len) {
14 Serial.println(">>>");
15 Ethernet::buffer[off+300] = 0;
16 Serial.print((const char*) Ethernet::buffer + off);
17 Serial.println("...");
18 }
19
20 void setup () {
21 Serial.begin(57600);
22 Serial.println(F("\n[webClient]"));
23
24 if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)
25 Serial.println(F("Failed to access Ethernet controller"));
26 if (!ether.dhcpSetup())
27 Serial.println(F("DHCP failed"));
28
29 ether.printIp("IP: ", ether.myip);
30 ether.printIp("GW: ", ether.gwip);
31 ether.printIp("DNS: ", ether.dnsip);
32
33 if (!ether.dnsLookup(website))
34 Serial.println("DNS failed");
35
36 ether.printIp("SRV: ", ether.hisip);
37 }
38
39 void loop () {
40 ether.packetLoop(ether.packetReceive());
41
42 if (millis() > timer) {
43 timer = millis() + 5000;
44 Serial.println();
45 Serial.print("<<< REQ ");
46
47 // ether.browseUrl(PSTR(dataLocationC), "", website, my_callback); // No funciona en IDE
48 Standard
49 ether.browseUrl(PSTR("/2434bc64"), "", website, my_callback); // En entorno IDE
50 }
}

SERVIDOR ETHERNET – VISUALIZAR ENTRADAS

En el siguiente código Arduino actúa como servidor, es decir, devuelve una página
web cuando un cliente (un PC, un móvil, otro Arduino…) se conecta a él.

En este caso, vamos a mostrar una página web con el estado de las entradas digitales
y analógicas de Arduino. Para ello, simplemente servimos una cadena de texto en html,
en la que incluimos los valores de las entradas.
 ar conectado en la
misma red local que el Arduino. Si queremos conectar desde internet deberemos definir una conexión
bridge en el router que direcciones la IP externa a la IP local del Arduino.

1 #include <EtherCard.h>
2
3 static byte mymac[] = { 0xDD, 0xDD, 0xDD, 0x00, 0x01, 0x05 };
4 static byte myip[] = { 192, 168, 1, 177 };
5 byte Ethernet::buffer[700];
6
7 void setup() {
8
 9 Serial.begin(9600);
10
11 if (!ether.begin(sizeof Ethernet::buffer, mymac, 10))
12 Serial.println("No se ha podido acceder a la controlador Ethernet");
13 else
14 Serial.println("Controlador Ethernet inicializado");
15
16 if (!ether.staticSetup(myip))
17 Serial.println("No se pudo establecer la dirección IP");
18 Serial.println();
19 }
20
21 static word mainPage()
22 {
23 BufferFiller bfill = ether.tcpOffset();
24 bfill.emit_p(PSTR("HTTP/1.0 200 OKrn"
25 "Content-Type: text/htmlrnPragma: no-cachernRefresh: 5rnrn"
26 "<html><head><title>Luis Llamas</title></head>"
27 "<body>"
28 "<div style='text-align:center;'>"
29 "<h1>Entradas digitales</h1>"
30 "Tiempo transcurrido : $L s"
31 "<br /><br />D00: $D"
32 "<br /><br />D01: $D"
33 "<br /><br />D02: $D"
34 "<br /><br />D03: $D"
35 "<br /><br />D04: $D"
36 "<br /><br />D05: $D"
37 "<br /><br />D06: $D"
38 "<br /><br />D07: $D"
39 "<br /><br />D08: $D"
40 "<br /><br />D09: $D"
41 "<br /><br />D10: $D"
42 "<br /><br />D11: $D"
43 "<br /><br />D12: $D"
44 "<br /><br />D13: $D"
45
46 "<h1>Entradas analogicas</h1>"
47 "<br /><br />AN0: $D"
48 "<br /><br />AN1: $D"
49 "<br /><br />AN2: $D"
50 "<br /><br />AN3: $D"
51 "<br /><br />AN4: $D"
52 "<br /><br />AN5: $D"
53 "<br /><br />AN6: $D"
54 "<br /><br />"
55 "</body></html>"),
56 millis() / 1000,
57 digitalRead(0),
58 digitalRead(1),
59 digitalRead(2),
60 digitalRead(3),
61 digitalRead(4),
62 digitalRead(5),
63 digitalRead(6),
64 digitalRead(7),
65 digitalRead(8),
66 digitalRead(9),
67 digitalRead(10),
68 digitalRead(11),
69 digitalRead(12),
70 digitalRead(13),
71 analogRead(0),
72 analogRead(1),
73 analogRead(2),
74 analogRead(3),
75 analogRead(4),
76 analogRead(5),
77 analogRead(6));
78
79 return bfill.position();
80 }
81
82 void loop()
83 {
84 // wait for an incoming TCP packet, but ignore its contents
85 if (ether.packetLoop(ether.packetReceive()))
86 {
87 ether.httpServerReply(mainPage());
88 }
89 }

SERVIDOR ETHERNET – CONTROLAR SALIDAS

El este ejemplo Arduino actúa también como servidor, pero esta vez queremos que
el usuario pueda realizar acciones sobre Arduino a través de la página web que servimos.

En este caso, vamos a controlar dos salidas digitales, a las que podemos conectar un
Led para visualizar la respuesta.

Para ello, en primer lugar servimos la página web de forma similar al ejemplo
anterior, pero en esta incluimos dos botones para cada salida.
 Al pulsar en cada botón se realiza una nueva solicitud a Arduino, con diferente URL
a la original. Arduino captura la nueva solicitud, y emplea la URL recibida para realizar
las acciones oportunas.

1 #include <EtherCard.h>
2
3 static byte mymac[] = { 0xDD, 0xDD, 0xDD, 0x00, 0x01, 0x05 };
4 static byte myip[] = { 192, 168, 1, 177 };
5 byte Ethernet::buffer[700];
6
7 const int pinLed1 = 13;
8 const int pinLed2 = A0;
9 char* statusLed1 = "OFF";
10 char* statusLed2 = "OFF";
11
12 void setup() {
13
14 Serial.begin(9600);
15
16 if (!ether.begin(sizeof Ethernet::buffer, mymac, 10))
17 Serial.println("No se ha podido acceder a la controlador Ethernet");
18 else
19 Serial.println("Controlador Ethernet inicializado");
20
21 if (!ether.staticSetup(myip))
22 Serial.println("No se pudo establecer la dirección IP");
23 Serial.println();
24
25 pinMode(pinLed1, OUTPUT);
26 pinMode(pinLed2, OUTPUT);
27 digitalWrite(pinLed1, LOW);
28 digitalWrite(pinLed2, LOW);
29 }
30
31 static word mainPage()
32 {
33 BufferFiller bfill = ether.tcpOffset();
34 bfill.emit_p(PSTR("HTTP/1.0 200 OKrn"
35 "Content-Type: text/htmlrnPragma: no-cachernRefresh: 5rnrn"
36 "<html><head><title>Luis Llamas</title></head>"
37 "<body>"
38 "<div style='text-align:center;'>"
39 "<h1>Salidas digitales</h1>"
40 "<br /><br />Estado LED 1 = $S<br />"
41 "<a href='./?data1=0'><input type='button' value='OFF'></a>"
42 "<a href='./?data1=1'><input type='button' value='ON'></a>"
43 "<br /><br />Estado LED 2 = $S<br />"
44 "<a href='./?data2=0'><input type='button' value='OFF'></a>"
45 "<a href='./?data2=1'><input type='button' value='ON'></a>"
46 "<br /></div>\n</body></html>"), statusLed1, statusLed2);
47
48 return bfill.position();
49 }
50
51 void loop()
52 {
53 word len = ether.packetReceive();
54 word pos = ether.packetLoop(len);
55
56 if (pos)
57 {
58 if (strstr((char *)Ethernet::buffer + pos, "GET /?data1=0") != 0) {
59 Serial.println("Led1 OFF");
60 digitalWrite(pinLed1, LOW);
61 statusLed1 = "OFF";
62 }
63
64 if (strstr((char *)Ethernet::buffer + pos, "GET /?data1=1") != 0) {
65 Serial.println("Led1 ON");
66 digitalWrite(pinLed1, HIGH);
67 statusLed1 = "ON";
68 }
69
70 if (strstr((char *)Ethernet::buffer + pos, "GET /?data2=0") != 0) {
71 Serial.println("Led2 OFF recieved");
72 digitalWrite(pinLed2, LOW);
73 statusLed2 = "OFF";
74 }
75
76 if (strstr((char *)Ethernet::buffer + pos, "GET /?data2=1") != 0) {
77 Serial.println("Led2 ON");
78 digitalWrite(pinLed2, HIGH);
79 statusLed2 = "ON";
80 }
81
82
83 ether.httpServerReply(mainPage());
84 }
85 }

Conexión Ethernet para Arduino con

ENC28J60
En este artículo usamos una tarjeta conectada a Arduino para habilitar una puerta
ethernet e implementar un pequeño servidor web.

La primera opción que tenemos es la Ethernet Shield oficial, pero si tenemos

una limitación en el costo o en el espacio a ocupar, tenemos que buscar alternativas.

Una alternativa para implementar una conexión Ethernet es la tarjeta ENC28J60 que
posee interfaz SPI y se aprecia en la figura.

Mas información tras el salto

Materiales
 Tarjeta Ethernet ENC28J60 (que puedes adquirir en nuestra tienda)

 Arduino Uno
 IDE Arduino instalado
 Notebook con Windows 7
 Acceso a Internet
 Cable de Red
 Cables con conectores macho hembra
Instalando Biblioteca

Debemos obtener la biblioteca para instalar y usar. los pasos son los siguientes

1. Bajar la biblioteca a tu computador, se obtiene desde la siguiente dirección

2. Se descomprime y se renombra la carpeta cómo “EtherCard”
3. Mover esta carpeta “EtherCard” bajo la carpeta libraries, donde esta el
ejecutable de Arduino.
4. Si estaba abierta, reiniciar la aplicación de Arduino, para asegurarnos que se
apliquen los cambios realizados.

Cuando abrimos el arduino IDE podemos ver la librería instalada y sus ejemplos,
eso se muestra en la siguiente figura.

Conexión Física

La conexión física se basa en el uso de los pines para interfaz SPI. Se necesitan seis
pines.

La siguiente tabla muestra los pines necesarios,

ENC Arduino
VCC 3.3v
GND GND
SCK Pin 13
SO Pin 12
SI Pin 11
CS Pin 8

La conexión física de los pines se ve en las siguientes figuras

Pruebas

Como prueba usamos la página “Back Soon”

// Present a "Will be back soon web page", as stand-in webserver.

// 2011-01-30 <[email protected]> http://opensource.org/licenses/mit-license.php

#include <EtherCard.h>

#define STATIC 0 // set to 1 to disable DHCP (adjust myip/gwip values below)

#if STATIC
// ethernet interface ip address
static byte myip[] = { 192,168,1,200 };
// gateway ip address
static byte gwip[] = { 192,168,1,1 };
#endif

// ethernet mac address - must be unique on your network

static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };

byte Ethernet::buffer[500]; // tcp/ip send and receive buffer

char page[] PROGMEM =
"HTTP/1.0 503 Service Unavailable\r\n"
"Content-Type: text/html\r\n"
"Retry-After: 600\r\n"
"\r\n"
"<html>"
"<head><title>"
"Service Temporarily Unavailable"
"</title></head>"
"<body>"
"<h3>This service is currently unavailable</h3>"
"<p><em>"
"The main server is currently off-line.<br />"
"Please try again later."
"</em></p>"
"</body>"
"</html>"
;

void setup(){
Serial.begin(57600);
Serial.println("\n[backSoon]");

if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)

Serial.println( "Failed to access Ethernet controller");
#if STATIC
ether.staticSetup(myip, gwip);
#else
if (!ether.dhcpSetup())
Serial.println("DHCP failed");
#endif

ether.printIp("IP: ", ether.myip);

ether.printIp("GW: ", ether.gwip);
ether.printIp("DNS: ", ether.dnsip);
}

void loop(){
// wait for an incoming TCP packet, but ignore its contents
if (ether.packetLoop(ether.packetReceive())) {
memcpy_P(ether.tcpOffset(), page, sizeof page);
ether.httpServerReply(sizeof page - 1);
}
}

El resultado de este sketch se aprecia tanto en la página web donde aparece el

mensaje esperado, como via serial donde aparecen los parámetros de red. Esto se
aprecia en la siguiente figura,
Uso del módulo ethernet ENC28J60 con Arduino : Parte 1
Hola, en esta ocación quiero compartir un tutorial para utilizar un módulo ENC28J60 que
proporciona conectividad ethernet a cualquier microcontrolador, en este caso lo usaremos
mediante un Arduino o sea un Atmega328

En el mercado encontraremos diferentes presentaciones de este módulo, algunas vienen

en formato de Shield, yo consegui una tarjeta mas pequeña pero que se cablea facilmente
al Arduino

El módulo que se uso para este tutorial es el siguiente:

Tambíen existe la version "shield":

En las bibliotecas de Arduino ya encontramos una librería ethernet, el problema es que
esta librería esta diseñada para operar con un módulo diferente, el WIZnet W5100, por lo
que no es compatible, despues de probar varias opciones al fin encontre una que funcionó
sin problemas y que se puede descargar desde la sig. liga:

* Actualización al 26/11/2016

La versión actualizada de la librería la encuentran en la siguiente liga:

https://github.com/jcw/ethercard/archive/master.zip

Bueno empezaremos cableando el módulo ethernet al Arduino, para esto usamos el

siguiente diagrama:

Cabe mencionar que la comunicacion entre el módulo ethernet y el arduino se lleva acabo
utilizando un protocolo que se llama SPI o Serial Peripheral Interface

SPI es un protocolo serial sincrono que se utiliza para comunicar un

microcontrolador con otro y con periféricos a distancias cortas.

Para hacer una conexion SPI siempre habrá un dispositivo maestro

(usualmente un microcontrolador) que controlará uno o varios
periféricos (esclavos), se utilizan por lo generar 3 lineas de conexión y
una de selección que son:

* SO o MISO (Master In Slave Out). La linea que utiliza el esclavo para

enviar datos al maestro
* SI o MOSI (Master Out Slave In). Datos del maestro al esclavo.
* SCK (Serial clock). Pulsos de reloj para sincronizar la comunicación
* CS o Select. Se usa por el master para habilitar o deshabilitar un
determinado periférico

Los microcontroladores atmel incluyen las 4 lineas para usar protocolo

SPI las cuales obviamente están presentes en los pines del arduino,
para el arduino uno se deben usar: Pin digital 10 para CS, Pin digital 11
para SI, Pin digital 12 para SO y Pin digital 13 para SCK, en el caso del
arduino mega se usaría los sig. pines: 50 (MISO), 51 (MOSI), 52 (SCK),
and 53 (CS).

La alimentación del módulo puede ser a 3.3 o 5V, yo usé ambos para las
pruebas y no encontré ninguna diferencia así que lo deje puesto a 3.3V.

Así queda nuestro módulo cableado:

Después de cablear el módulo lo que sigue es instalar la librería, como
estoy usando la versión de Windows, las rutas serán en ese formato,
primero busco el archivo que descargué, el mio quedó guardado con el
mismo nombre EtherCard.zip
A continuación descomprimo el archivo y envío la carpeta descomprimida al directorio de
Arduino/libraries (o la ruta donde esté instalado el ide de arduino)

Después de este paso abrimos el IDE de arduino y en el menu de Ejemplos ya deben

aparecer los ejemplos de la libreria EtherCard
Seleccionamos el ejemplo pingsStaticIP
En las variables myip y gwip colocamos primero la ip que querramos asignar al arduino
(en mi caso 192.168.1.188) y después la ip de nuestra puerta de enlace o gateway, en
méxico para las redes de infinitum y una gran mayoría de las redes domésticas este valor
es el que se muestra (192.168.1.254), una vez hecho este pequeño cambio descargamos
el script al arduino y abrimos el monitor serial donde vemos el arranque del script:
Si analizamos el script vemos que hay una rutina que obtiene via dns la direccion ip del
dominio www.google.com y se queda enviándole pings, en el monitor vemos los tiempos
de respuesta del servidor de google (Esta parte solo funcionará si estamos conectados a
internet).

Si nosotros abrimos una ventana de comandos y hacemos ping a la dirección ip del

arduino debemos ver una respuesta como la de abajo, en la pantalla del monitor serial
tambíen podemos ver las solicitudes de ping enviadas por la pc y recibidas por el arduino
Si lograron llevar acabo con éxito todos los pasos felicidades! oficialmente acaban de
darle conectividad de red a su arduino.

En la segunda parte del tutorial aprenderemos como convertir nuestro arduino en un

servidor web para poder monitorear y controlar las salidas y entradas de la placa, hasta la
próxima!

Con información tomada de:

http://www.geeetech.com/arduino-enc28j60-ethernet-module-p-263.html
http://www.open-electronics.org/low-cost-ethernet-shield-with-enc28j60/

DE Arduino y Configuración
1 respuesta

Entorno de programación

El entorno de desarrollo integrado también llamado IDE (sigla en inglés de Integrated Development
Environment), es un programa informático compuesto por un conjunto de herramientas de
programación. Puede dedicarse en exclusiva a un solo lenguaje de programación o bien puede utilizarse
para varios lenguajes.

Un IDE es un entorno de programación que ha sido empaquetado como un programa de aplicación; es

decir, que consiste en un editor de código, un compilador, un depurador y un constructor de interfaz
gráfica (GUI). Además en el caso de Arduino incorpora las herramientas para cargar el programa ya
compilado en la memoria flash del hardware.

El IDE de Arduino va a ser la herramienta de trabajo durante el curso y habrá que conocer su
funcionamiento.

Los programas de arduino están compuestos por un solo fichero con extensión “ino”, aunque es posible
organizarlo en varios ficheros. El fichero principal siempre debe estar en una carpeta con el mismo
nombre que el fichero.

Anteriormente a la versión 1.x de Arduino se usaba la extensión “pde”. Cuando se pasó a la versión 1.x
hubo grandes cambios, que deben tenerse en cuenta si se usa el código antiguo. Guía de como migrar de
versiones anteriores a la 1.0: http://www.engblaze.com/changes-in-the-arduino-1-0-release/

La última versión del IDE de Arduino es la 1.8.5. Los grandes cambios en el IDE Arduino se han
producido desde la actualización de la versión 0.22 a la 1.0 y posteriormente la actualización de la
versión 1.0.6 a la 1.6.0 que han supuesto importantes mejoras en el IDE de Arduino.

También está disponible la versión 1.9.0 en beta para probar las novedades del IDE.

Es destacable desde la aparición de la versión 1.6.2 la incorporación de la gestión de libreríasy

la gestión de placas muy mejoradas respecto a la versión anterior y los avisos de actualización de
versiones de librerías y cores.

Todos los cambios en la versiones pueden verse en: https://www.arduino.cc/en/Main/ReleaseNotes

Código fuente del IDE de Arduino está disponible en: https://github.com/arduino/Arduino/ y las
instrucciones para construir el IDE desde código fuente pueden verse
en: https://github.com/arduino/Arduino/wiki/Building-Arduino

Podemos también ver los problemas/bugs detectados de la versión actual y hacer un seguimiento de
ellos: https://github.com/arduino/Arduino/issues y en http://forum.arduino.cc/index.php?board=2.0

Conozcamos el IDE, nuestro entorno de trabajo:

IMPORTANTE: Para conocer el entorno de programación a fondo

ver: http://arduino.cc/en/Guide/Environment

Es importante conocer cada uno de los menús y opciones que tiene, pero los más importantes por ahora
son:

 Botones de Verificar y Subir

 Botón Monitor Serie
 Consola de Error
 Menú herramientas Placa y Puerto
  Menú de pestañas
 Puerto y placa seleccionada
 Menú preferencias
 Proyecto/Sketch

Configuración inicial del IDE

Después de la instalación, lo primero es configurar el IDE para facilitar la edición de nuestros

programas, que nos muestre toda la información de compilación y subida de programas a Arduino y que
nos muestre por pantalla todos los warnings del compilador. Cuanta más información tengamos, más
fácil será localizar un problema.

Para ello, entrar en el menú Archivo → preferencias y activar:

 Números de Línea
 Mostrar salida detallada en la compilación y al subir un sketch
 Configurar la ruta de nuestro workspace
 Advertencia del compilador: Todos
 Asociar extensión .ino a nuestro IDE
 Habilitar plegado de código
 Verificar el código después de subir
Desde esta pantalla configuramos donde se guardan las preferencias, sketches y librerías, de forma que
al instalar una actualización mantenemos todos los datos o si instalamos varios IDEs van a compartir
estos datos.

 Los sketches y librerías se guardan en C:\Users\nombre_usuario\Documentos\Arduino

 Las preferencias se guardan en el directorio:
C:\Users\nombre_usuario\AppData\Local\Arduino15\, aquí también está el listado de librerías
y placas disponibles desde el gestor de librerías y tarjetas.

NOTA: Guardar en el directorio de “Localización de Proyecto” la carpeta con las prácticas, de esta
manera estarán disponibles directamente desde el IDE de Arduino.

Cargar un Programa en Arduino

El IDE de Arduino contiene un editor de texto para escribir nuestro sketch, una consola de error y un
área con los menús y los botones que realizan las funciones más comunes como son abrir sketch, guardar
sketch, compilar y cargar programa.
A la hora de cargar un programa en Arduino, debemos seleccionar siempre el modelo de la placa
conectada y el puerto al que está conectado.

Una vez seleccionada la placa y el puerto ya podemos pulsar sobre el botón subir y comenzará el
proceso de compilación y carga del programa a la placa Arduino.

Cuando cargamos un programa en Arduino, estamos usando el bootloader de Arduino, que es un

pequeño programa cargado en el microcontrolador que permite subir el código sin usar hardware
adicional. El bootloader está activo unos segundos cuando se resetea la placa, después comienza el
programa que tenga cargado el Arduino en su memoria Flash. El led integrado en la placa (pin 13)
parpadea cuando el bootloader se ejecuta.
Práctica: Probar a cargar el programa blink en Arduino y comprobar que parpadea el led integrado en la
placa. De esta forma comprobamos que hemos instalado todo correctamente.

Gestor de Tarjetas

El gestor de tarjetas está disponible desde el menú herramientas → Placa → Gestor de tarjetas, nos
muestra el soporte a qué tipo de placas tenemos y permite instalar otro tipo de placas. Estas placas se
refieren a la familia de tarjetas no a los modelos de Arduino soportados, eso se debe configurar desde
otro fichero.

Por defecto tenemos instalado el soporte a las placas Arduino AVR que son la mayoría, pero nos permite
instalar el soporte para los Arduino con MCU ARM de 32 bits como el Arduino MKR1000 o las Intel
como el Arduino 101.

En este enlace explica como instalar nuevos cores: https://www.arduino.cc/en/Guide/Cores

Cuando tengamos algún problema, la primera opción es recurrir a la guía de

Troubleshooting: http://arduino.cc/en/Guide/Troubleshooting

Gestor de Librerías

El gestor de librerías accesible desde menú > Programa > Incluir Librería > Gestionar Librerías

Este gestor nos permite instalar, desinstalar y actualizar las librerías que tenemos disponibles en el IDE.
Monitor serie

El monitor serie es una de las partes más importantes del IDE de Arduino porque es nuestra ventana para
la comunicación entre Arduino y el ordenador, que se hace a través del cable USB.

Para realizar la conexión mediante puerto serie únicamente es necesario conectar nuestra placa Arduino
empleando el mismo puerto que empleamos para programarlo. A continuación abrimos el IDE Standard
de Arduino y hacemos click en el “Monitor Serial” como se indica en la imagen.
El monitor serie muestra los datos enviados por el Arduino a través del puerto serie también nos permite
mandar datos al Arduino mediante el puerto serie.
El monitor de puerto serie es una pequeña utilidad integrada dentro de IDE Standard que nos permite
enviar y recibir fácilmente información a través del puerto serie. Su uso es muy sencillo, y dispone de
dos zonas, una que muestra los datos recibidos, y otra para enviarlos. Estas zonas se muestran en la
siguiente imagen.
Hay disponibles alternativas al monitor serie que en algunas circunstancias podemos necesitar puesto
que el incluido en el IDE de Arduino es bastante sencillo, pero generalmente suficiente.

Una buena alternativa muy completa es el btaru terminal: https://sites.google.com/site/terminalbpp/

Arduino Serial Plotter. Desde la versión 1.6.6 del IDE de Arduino disponemos de la herramienta
Arduino Serial Plotter que nos permite hacer gráficas de los datos mandados por puerto serie.

Práctica: Cargar el programa “AnalogReadSerial” dentro de los ejemplos, apartado 01.Basics y ver lo
que saca por el monitor serie y por el Serial Plotter.
IDE Online

Arduino.cc ha sacado un IDE on-line llamado Arduino Web Editor que puede usarse en lugar del IDE
que acabamos de ver. Este IDE on-line está dentro del proyecto Arduino Create accesible
desde https://create.arduino.cc/ y incluye varios apartados.

Para usar este IDE es necesario instalar un plugin y mediante este wizard online es posible
instalarlo: https://create.arduino.cc/getting-started/plugin

También es importante señalar que es necesario crearse una cuenta de arduino.cc para poder usar este
IDE on-line.

Getting started con Arduino Web Editor: https://create.arduino.cc/projecthub/Arduino_Genuino/getting-

started-with-the-arduino-web-editor-4b3e4a

En estas publicaciones del blog de arduino.cc habla de Arduino Create:

 https://blog.arduino.cc/2015/05/05/sneak-peak-arduino-create/
 https://blog.arduino.cc/2015/12/02/the-next-steps-of-the-arduino-create-betatesting/#more-
12820
 Video: https://youtu.be/6cRFf4qkcTw

Con Arduino Web Editor es posible escribir y cargar sketchs a cualquier placa Arduino directamente
desde el navegador, guardar todos los sketches en el Arduino Cloud y acceder a ellos desde cualquier
dispositivo.

El nuevo IDE de Arduino Web está siempre actualizado, incluyendo las últimas librerías y cores de las
placas sin tener que instalar nada. Las placas conectadas al ordenador aparecen automáticamente en un
desplegable.

Los ejemplos están disponible con los esquemáticos de conexión y también permite subir tus sketches
con el esquemático y diagrama eléctrico, de forma que está todo en un mismo lugar.

Para poder usarlo es necesario descargar un plug-in en función del sistema operativo
(Windows/Linux/Mac OS). El código fuente y los binarios de este plugin están
en: https://github.com/arduino/arduino-create-agent

Este plugin (agente) detecta automáticamente los puertos USB de nuestro ordenador y detecta cualquier
placa Arduino conectada, si estamos cargando un sketch o si estamos usando el monitor serie.
Este plugin está basado en el serial-port-json-server de johnlauer: https://github.com/johnlauer/serial-
port-json-server que permite comunicarte con el puerto serie de un ordenador desde un navegador. Esto
permite hacer aplicaciones web que se pueden comunicar con el puerto serie local. Más información y
ejemplo en: http://chilipeppr.com/

Esto no es una sustitución del IDE tradicional, sino un complemento para quien no quiera instalarse el
IDE. Arduino.cc ha mostrado su intención de dar siempre a la comunidad un IDE off-line, aunque
actualmente están fomentado el uso del IDE online.

Instalación Software Arduino

3 respuestas

Antes de empezar a usar el hardware de Arduino, vamos a conocer el software de Arduino, dejarlo
instalado y configurado para poder empezar a trabajar.

Desinstalación del Software Arduino y Configuraciones

IMPORTANTE: Esto es para el buen desarrollo del curso Arduino, si haces esto en tu ordenador de
casa perderás los sketches que tengas en el espacio de trabajo de Arduino, las librerías instaladas y las
configuraciones personalizadas del IDE. NO LO HAGAS ESTAS OPERACIONES DE
DESINSTALACIÓN SI NO ESTAS SEGURO y sigue con la instalación del software de Arduino en
el siguiente apartado “Instalación Software Arduino”.

Para tener una instalación limpia y que no haya problemas en la realización de las prácticas del curso de
Arduino hacer los siguientes pasos:

 Ver los directorios de configuración del software de Arduino, para ello entrar en el menú
Archivo → preferencias
  Desinstala (si está instalado) el software de Arduino desde el Panel de Control de Windows.
Asegurate que dentro del directorio “C:\Program Files (x86)\Arduino\” no queda nada dentro o
sino borralo.
 Borra (si existe) la carpeta y todo su contenido de Localización de Proyecto que estaba en
propiedades. Generalmente será: “C:\Users\ThinkTIC\Documents\Arduino”. Esto borra los
sketches guardados y las librerías instaladas.
 Borra (si existe) la carpeta y su contenido de preferencias que estaba en propiedades.
Generalmente será: “C:\Users\ThinkTIC\AppData\Local\Arduino15”. Esto borra las
preferencias del software de Arduino y el soporte a placas instalado.

Ahora ya tenemos limpio de datos de la anterior instalación del software de Arduino y podemos empezar
con una instalación limpia desde cero.

Instalación Software Arduino

Vamos a instalar la última versión del IDE de Arduino, conocer el entorno de programación y hacer las
principales configuraciones en el entorno para poder trabajar de forma más eficiente.
Descargar la última versión del IDE de Arduino desde: http://arduino.cc/en/Main/Software.

Elegir la opción de Windows Installer, aunque también es posible descargar la versión comprimida en
zip, que es una versión portable o para aquellos que no tengan privilegios suficientes para instalar
aplicaciones o simplemente quien quiera hacer una instalación manual. En caso de descargar la versión
comprimida en zip, simplemente descomprimirlo en la carpeta deseada y ya podemos usarlo.

Una vez descargado, ejecutar el instalador. Si existe una versión anterior el instalador nos avisa y nos
desinstala la versión actual. En el caso que hayamos hecho modificaciones en el directorio de instalación
las perderemos.

Ya en la instalación aceptamos el acuerdo de licencia.

Marcar todas las opciones y elegir directorio de instalación, generalmente C:\Program Files
(x86)\Arduino\:

Permitir instalar los drivers si lo solicita:

Y ya está instalado:
En este momento ya tenemos instalado el IDE en nuestro ordenador.

Ejecutar la aplicación:

Y este es el aspecto del IDE:

Cambios incluidos en cada versión: https://www.arduino.cc/en/Main/ReleaseNotes

El IDE de Arduino es multiplataforma y en caso de instalar el IDE Arduino en otros sistemas operativos
estas son las instrucciones:

 Windows: https://www.arduino.cc/en/Guide/Windows
 Mac OSX: http://arduino.cc/en/Guide/MacOSX
 Linux: https://www.arduino.cc/en/Guide/Linux y http://playground.arduino.cc/Learning/Linux

NOTA: para usuarios de linux/debian, el IDE Arduino está en los repositorios oficiales, pero instalará
una versión antigua del IDE. Por lo tanto aunque funcione “apt-get install arduino “, es recomendable
hacer la instalación según https://www.arduino.cc/en/Guide/Linux. Para ver qué versión se instalará
desde el repositorio oficial usar el comando “apt-cache showpkg arduino”

Actualizar el IDE de Arduino

Para actualizar una versión anterior del IDE de Arduino, el procedimiento es el mismo que el de una
instalación inicial, puesto que el instalador detecta una versión anterior y la desinstala manteniendo todas
nuestras configuraciones, librerías y sketches anteriores.

En caso que queramos mantener varias versiones del IDE en el mismo ordenador, simplemente hacemos
la instalación manual en directorios diferentes y las configuraciones, librerías y sketches son
compartidas por las diferentes versiones del IDE instaladas.

A la hora de actualizar, el instalador de Arduino lo que hace es borrar toda la ruta completa donde hemos
instalado Arduino e instala la nueva versión. Por lo tanto cualquier modificación o librería instalada en el
directorio de instalación se perderá en la actualización.

Es importante que cualquier sketch que hagamos y cualquier librería que instalemos se haga en la ruta
indicada en las propiedades, de esta forma mantendremos nuestra configuración al actualizar el IDE.