Un Arduino sin WiFi que igual llega a internet

¿Te imaginas un Arduino Uno, una placa que por sí sola no tiene ni WiFi ni Bluetooth, publicando un mensaje en internet con solo enchufarle un cable de red? Esa es exactamente la gracia de este proyecto: usar el módulo Ethernet ENC28J60 para que tu Arduino abra una conexión TCP y dispare un tweet hacia tu cuenta.

Es uno de esos tutoriales clásicos de la era maker, y aunque el servicio puntual que usaba para autenticarse con Twitter ya quedó en el pasado (más abajo te explico el estado real al 2026 y qué alternativas usar hoy), el valor educativo sigue intacto. Al terminar vas a entender cómo un microcontrolador de 8 bits se conecta a una red por SPI, pide una IP por DHCP, resuelve un dominio por DNS y arma a mano una petición HTTP POST. Esa base te sirve para cualquier proyecto IoT: una planta que avisa cuando le falta agua, una alarma que manda un aviso al activarse, o un sensor que sube datos a un servidor propio.

Este artículo es una versión chilena, reescrita y ampliada, del tutorial original de Alberto Cárdenas publicado en ElectroCrea.com. La atribución completa está al final.

Qué necesitas

El hardware es mínimo y barato. Lo central es el módulo Ethernet:

  • Módulo Ethernet ENC28J60: el corazón del proyecto. Es un controlador Ethernet 10 Mbps que se comunica con el Arduino por bus SPI. Ojo con un detalle clave: este módulo se alimenta a 3.3V, no a 5V. Si lo conectas a 5V lo puedes dañar.
  • Placa Arduino (en este tutorial usamos un Arduino Uno R3): hace de cerebro y arma la petición HTTP.
  • Cables jumper macho hembra: para puentear los pines hembra del Arduino con los pines macho del módulo.

Cómo se conecta al Arduino

El ENC28J60 habla SPI, así que va conectado a los pines SPI del Arduino más un par de líneas de control. La distribución es esta:

Módulo Ethernet Arduino Uno
VCC 3.3V
GND GND
CS 8
SI 11
SO 12
SCK 13

¿Por qué estos pines? En el Arduino Uno, los pines 11 (MOSI), 12 (MISO) y 13 (SCK) son las líneas de hardware del bus SPI. El pin 8 se usa como Chip Select (CS): es la señal que le dice al módulo "ahora te toca escuchar". Por eso es importante respetar este cableado y no improvisar: si mueves SCK o MOSI a otro pin sin reconfigurar la librería, la comunicación no funciona.

Diagrama de conexión del módulo Ethernet ENC28J60 al Arduino Uno por bus SPI

Conecta primero la alimentación (VCC al 3.3V y GND al GND) y recién después las líneas de datos. Trabajar siempre con el Arduino desconectado del USB mientras cableas es una buena costumbre para no quemar nada por un cruce accidental.

La librería: EtherCard

El ENC28J60 no se maneja con la librería Ethernet oficial de Arduino (esa es para el chip W5100/W5500). Para este módulo se usa EtherCard, una librería liviana pensada justamente para el ENC28J60. El código de ejemplo se apoya en ella para todo: levantar la interfaz, pedir IP por DHCP y abrir el socket TCP.

Para instalarla, descarga el .zip de EtherCard y agrégalo desde el IDE de Arduino con Programa → Incluir Librería → Añadir biblioteca .ZIP (o copia la carpeta descomprimida en tu directorio libraries). El enlace al archivo original está en la sección de recursos al final.

El servicio de token (y por qué hoy es distinto)

En la versión de 2015, para que el Arduino pudiera escribir en tu cuenta sin manejar todo el flujo OAuth de Twitter (algo imposible de hacer cómodo en un chip de 8 bits), se usaba un servicio intermediario: arduino tweet.appspot.com, creado por el desarrollador NeoCat. Tú autorizabas esa aplicación una sola vez desde tu cuenta y el servicio te entregaba un token. Ese token iba en el código y el Arduino solo tenía que mandarle el texto al servicio, que reenviaba el tweet por ti.

Pantalla de autorización del servicio Arduino Twitter Library pidiendo permiso a tu cuenta

Tras autorizar, el servicio te mostraba tu token, que copiabas y pegabas en la línea #define TOKEN del código.

El servicio entregando el token para pegar en el código de Arduino

Estado real al 2026 (lo que el tutorial original no podía anticipar): ese servicio intermediario ya no está operativo y, además, Twitter pasó a llamarse X y cerró el acceso gratuito a su API de publicación. Es decir, este flujo puntual ya no funciona tal cual. No te frustres: el aprendizaje de fondo (Ethernet + SPI + DHCP + HTTP POST desde Arduino) es exactamente el mismo, y en la sección de variantes te dejo alternativas modernas que sí publican mensajes hoy.

El código

Este es el sketch del ejemplo, tal cual. Fíjate en tres cosas: la tabla de pines en el comentario inicial, la línea #define TOKEN donde iría tu token, y la función sendToTwitter() que arma a mano la petición HTTP POST con Stash::prepare. Ese armado manual del POST es la parte más instructiva: te muestra qué hay realmente "por debajo" cuando un dispositivo habla con un servidor web.

C++ 
/*ElectroCrea.com

Módulo Ethernet    Arduino
----------------------------
 VCC               3.3V
 GND               GND
 CS                8
 SI                11
 SO                12
 SCK               13

1. Obten tu token aquí:http://arduino-tweet.appspot.com/oauth/twitter/login
2. Escribe tu TOKEN en la sección "#define TOKEN"
3. Carga el código y ve a tu cuenta Twitter! 
*/

#define TOKEN   "Escribe tu Token aqui"
#include <EtherCard.h>
byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
const char website[] PROGMEM = "arduino-tweet.appspot.com";
static byte session;
byte Ethernet::buffer[700];
Stash stash;

static void sendToTwitter () {
  Serial.println("Enviando tweet...");
  byte sd = stash.create();
  const char tweet[] = "Tweet escrito desde Arduino! #electrocrea @electrocrea_";
  stash.print("token=");
  stash.print(TOKEN);
  stash.print("&status=");
  stash.println(tweet);
  stash.save();
  int stash_size = stash.size();
  Stash::prepare(PSTR("POST http://$F/update HTTP/1.0" "\r\n"
    "Host: $F" "\r\n"
    "Content-Length: $D" "\r\n"
    "\r\n"
    "$H"),
  website, website, stash_size, sd);
  session = ether.tcpSend();
}
////////////////////////////////////////////////////////////////////VOID SETUP
void setup () {
  Serial.begin(57600);
  Serial.println("\n[Twitter Client]");

  if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) 
  Serial.println(F("Error al accesar al controlador Ethernet"));
  
  if (!ether.dhcpSetup())
  Serial.println(F("Error DHCP"));
  ether.printIp("IP:  ", ether.myip);
  ether.printIp("GW:  ", ether.gwip);  
  ether.printIp("DNS: ", ether.dnsip);  

  if (!ether.dnsLookup(website))
  Serial.println(F("Error DNS"));
  ether.printIp("SRV: ", ether.hisip);
  sendToTwitter();
}
////////////////////////////////////////////////////////////////////VOID LOOP
void loop () {
  ether.packetLoop(ether.packetReceive());
  const char* reply = ether.tcpReply(session);
  
  if (reply != 0) {
    Serial.println("Obtuviste respuesta!");
    Serial.println(reply);
  }
}
//Mas información en ElectroCrea.com

La mymac[] es la dirección MAC que el módulo va a usar en tu red; puede ser cualquiera mientras sea única en tu LAN. El Serial.begin(57600) te deja ver por el monitor serial cada paso: la IP que obtuvo por DHCP, el gateway, el DNS y la respuesta del servidor. Si algo falla, ahí vas a ver el mensaje de error correspondiente (error al acceder al controlador, error DHCP o error DNS), lo que hace muy fácil el diagnóstico.

Pruebas y diagnóstico

Con el módulo conectado y el código cargado, abre el monitor serial a 57600 baudios y reinicia el Arduino. Deberías ver cómo imprime la IP asignada y, segundos después, el aviso de que envió el tweet. Errores comunes y cómo abordarlos:

  • No obtiene IP (error DHCP): revisa que el cable de red esté conectado a un router con DHCP activo y que la alimentación del módulo sea estable a 3.3V.
  • Se queda pegado o se reinicia: suele ser alimentación insuficiente. El ENC28J60 puede pedir picos de corriente; aliméntalo desde el pin 3.3V del Arduino solo si tu placa lo soporta, o usa una fuente externa de 3.3V bien filtrada.
  • Conecta pero no responde el servidor: lógico hoy, porque el servicio intermediario quedó fuera de línea. Para validar tu hardware, prueba el cableado con cualquier ejemplo de EtherCard que haga una petición a un servidor activo (por ejemplo, leer una página simple) antes de culpar al código.

Variantes y mejoras

Acá es donde este proyecto clásico se moderniza. Tres caminos para que publiques mensajes de verdad hoy:

  1. Cámbiate a un ESP32 o ESP8266 con webhook. Estas placas traen WiFi integrado y TLS, así que pueden hablar directo con servicios actuales. La forma más simple de "tuitear" o avisar algo hoy es con un webhook de IFTTT o Make: el ESP32 hace un POST a una URL privada y el servicio reenvía el mensaje a X, Telegram, correo o lo que conectes. Adiós módulo Ethernet y adiós servicio intermediario.
  2. Usa un bot de Telegram en vez de Twitter/X. La API de Telegram es gratuita y sencilla: con un ESP32 y la librería UniversalTelegramBot envías mensajes a tu celular en segundos. Para avisos del tipo "la planta necesita agua" o "se activó la alarma", es más práctico y confiable que la API de X.
  3. Mantén el ENC28J60 pero apúntalo a tu propio servidor. Si lo que te interesa es el hardware Ethernet (porque tu proyecto va cableado, sin WiFi), conserva el módulo y haz que el Arduino haga POST a un servidor tuyo (un Raspberry Pi en tu red, por ejemplo) que registre los datos o reenvíe la notificación. Así reutilizas todo lo que aprendiste del bus SPI y del armado del HTTP POST.

Personalización para Chile

En Chile puedes conseguir todo lo necesario para replicar este proyecto en MechatronicStore, con stock local:

  • Módulo ethernet ENC28j60 red LAN (SKU F-415): $9.990 CLP. Es exactamente el módulo del tutorial.
  • Arduino Uno R3 (SKU X4-8): $9.990 CLP. La placa que hace de cerebro.
  • Cables macho hembra 30cm (SKU C-418): $1.990 CLP. Los jumper para puentear los pines del Arduino al módulo.

Si quieres dar el salto a las variantes modernas con WiFi, en el mismo catálogo encuentras placas ESP32 y ESP8266 que reemplazan al dúo Arduino más módulo Ethernet con conectividad inalámbrica integrada.

Recursos

Versión chilena con componentes en stock local en MechatronicStore, ampliada con el estado real del servicio en 2026 y alternativas modernas.