Me encantan las newsletters. El problema es que me encantan demasiado: me suscribo a todas las que parecen interesantes y, al final de la semana, tengo una pila de correos sin leer que me genera más culpa que conocimiento. Así que decidí automatizar el problema: un pequeño sistema que cada lunes recoge las newsletters de la semana, las resume y me las envía convertidas en un audio de pocos minutos que escucho mientras desayuno o voy al trabajo.
En este post te cuento cómo funciona y cómo puedes montarlo tú también.
La idea
El flujo es muy simple y tiene cuatro pasos:
Recoger: un script lee los correos de la semana que tengo etiquetados como «Newsletters» en Gmail.
Resumir: le pasa todo ese contenido a Claude, el modelo de IA de Anthropic, con una instrucción clara: escribe un guion para ser escuchado, agrupado por temas y no por newsletter.
Convertir en voz: el guion se transforma en un MP3 con una voz neuronal en español que suena sorprendentemente natural.
Enviar: me llega un correo con el audio adjunto y, en el cuerpo, unos pocos enlaces que merece la pena leer con calma.
Todo esto se ejecuta solo, cada lunes a primera hora, sin que mi ordenador tenga que estar encendido.
Las piezas
Gmail y un filtro. Lo primero es separar las newsletters del resto del correo. En Gmail creé una etiqueta llamada «Newsletters» y filtros que la aplican automáticamente.
Un script en Python. El script se conecta a Gmail por IMAP (en modo solo lectura, así que no borra ni marca nada), extrae el texto de cada newsletter y limpia el HTML. Para conectarse usa una contraseña de aplicación de Google, que es una contraseña específica para este uso y que se puede revocar en cualquier momento sin tocar la principal.
Claude para resumir. La parte más interesante es el prompt. No le pido «un resumen» sin más, sino un guion pensado para el oído: texto corrido sin listas ni URLs, un saludo con un adelanto de los temas, transiciones naturales y una despedida. También le pido que combine las noticias que se repiten entre varias fuentes y que diga de qué newsletter sale cada cosa. El resultado se parece más a un pódcast que a un resumen automático.
Una voz en español. Para convertir el texto en audio uso edge-tts, una librería que aprovecha las voces neuronales de Microsoft. Es gratuita, no necesita clave y tiene voces de España, México, Argentina y otros países. Como no es un servicio oficial, si algún día deja de funcionar se puede cambiar fácilmente por alternativas de pago como OpenAI o ElevenLabs.
GitHub Actions como reloj. Para que todo se ejecute solo, el script vive en un repositorio privado de GitHub con un workflow programado. GitHub lo lanza cada lunes en sus servidores, gratis, y las credenciales se guardan como secrets cifrados que nadie puede leer, ni siquiera yo una vez guardados.
Lo que aprendí por el camino
Repositorio privado, mejor. En los repositorios públicos, GitHub desactiva los workflows programados tras 60 días sin actividad. En un proyecto que no tocas nunca, eso significa que dejaría de funcionar a los dos meses sin avisar.
Las contraseñas de aplicación van sin espacios. Google las muestra en bloques de cuatro para que sean legibles, pero hay que pegarlas seguidas.
La API de Claude es independiente de la suscripción. Aunque pagues Claude Pro, la API se paga aparte con créditos prepagados. La buena noticia es que cada resumen semanal cuesta unos céntimos.
Escribir para el oído es distinto. Los primeros resúmenes eran correctos pero aburridos de escuchar. Pedir explícitamente un guion hablado, con números escritos para ser leídos y sin URLs, marcó la diferencia.
El resultado
Ahora los lunes empiezan con un pequeño pódcast hecho a medida: lo más importante de la semana, organizado por temas, con la voz que he elegido y a la velocidad que prefiero. Las newsletters siguen llegando, pero ya no se acumulan. Y si algo me interesa de verdad, tengo el enlace en el correo para profundizar.
Si quieres montarlo tú, solo necesitas una cuenta de Gmail, una de GitHub y una clave de la API de Claude. El montaje lleva una tarde, y a partir de ahí funciona solo.
Quake (1996) es uno de esos juegos que se te quedan grabados, y su logo también: un anillo abierto por arriba atravesado por un clavo. Un día pensé que me gustaría ver ese logo cada vez que escribo una Q en el editor. Solo esa letra; el resto del código tenía que seguir igual.
Parecía tan fácil como cambiar una fuente, pero no lo era.
El problema: VS Code no deja cambiar la fuente de una sola letra
En VS Code, editor.fontFamily se aplica a todo el editor, y la API de extensiones no tiene nada parecido a «esta letra, con esta fuente».
Lo que sí ofrece son las decoraciones (createTextEditorDecorationType). Son las mismas que usan los linters para subrayar errores o GitLens para anotar líneas. Con ellas puedes cambiar el color, el fondo o el borde de un trozo de texto, y añadir contenido antes o después de él (before y after), incluida una imagen.
Con eso había dos caminos:
Inyectar CSS. El valor de la propiedad textDecoration acaba tal cual en el CSS del editor. Por eso, si escribes none; font-family: 'DpQuake', se cuela una regla font-family. Funciona, pero es un truco no documentado y solo sirve si tienes una fuente de Quake instalada. Lo dejé como modo opcional (quakeQ.fontFamily).
Dibujar encima. Hacer la letra transparente y pintar una imagen en su sitio. No depende de ninguna fuente instalada, así que es el modo por defecto.
Cómo funciona por dentro
1. Una decoración que esconde la letra
El primer paso es una decoración que vuelve transparente la letra:
Cada glifo tiene además un ascent: el número de filas que quedan por encima de la línea base. Las demás cuelgan por debajo, como el rabito de la q, y aquí ese rabito es la punta del clavo.
La función buildSvg convierte la cuadrícula en un SVG:
Junta los píxeles seguidos de cada fila en un solo rectángulo, para que el SVG sea pequeño.
Lo rellena con un degradado vertical de bronce, de #d8b070 a #7a4a20, los dos colores configurables.
Usa shape-rendering="crispEdges" para que los bordes salgan nítidos, como en un juego de los 90.
4. Medir sin poder medir
La API no da las medidas reales de la fuente del editor, así que las estimo a partir de la configuración:
Ancho de un carácter: unos 0,6 × fontSize + letterSpacing. Casi todas las fuentes monoespaciadas rondan las 0,6 em de ancho.
Alto de línea: si editor.lineHeight vale 0, VS Code usa 1,35 × fontSize (1,5 en macOS). Los valores menores que 8 son multiplicadores del tamaño de letra.
Línea base: más o menos a mitad de la línea más 0,33 × fontSize.
Como la imagen se superpone a la letra en lugar de sustituirla, un error de un píxel en estas cuentas no descoloca nada. Y si con tu fuente la letra queda un poco alta o baja, se corrige con quakeQ.verticalOffset.
5. El tamaño del píxel
El tamaño de cada «píxel» del dibujo es el menor de tres límites:
const pixel = Math.min(
width / (COLUMNS + 1), // que quepa a lo ancho
baseline / glyph.ascent, // que no se salga por arriba
(lineHeight - baseline) / descent // ni por abajo
);
El ancho es el de un carácter multiplicado por quakeQ.scale, que por defecto vale 1,5. Así el logo es algo más grande que una letra y se mete un poco en las vecinas, pero nunca se sale de la línea.
6. Archivos SVG con nombre de hash
contentIconPath necesita la URI de un archivo. Por eso cada SVG se guarda en la carpeta de almacenamiento de la extensión (globalStorageUri), con un nombre sacado de su contenido: los primeros 12 caracteres de su hash SHA-1.
Si el SVG no cambia, el archivo tampoco, y un mapa en memoria evita volver a escribirlo.
7. Solo lo que se ve
La extensión solo busca la Q con una expresión regular en las líneas visibles, más 20 de margen por arriba y por abajo para que al hacer scroll rápido no aparezcan letras sin decorar.
El recálculo se hace con un retraso (debounce) de 50 ms cada vez que:
cambian los editores visibles,
haces scroll,
editas el documento.
Así un archivo de 10.000 líneas cuesta lo mismo que uno de 50.
Cuando cambias cualquier ajuste de la extensión (quakeQ.*) o del editor (editor.*), como el tamaño de letra, todo se reconstruye desde cero.
El diseño de la letra
La letra fue lo que más vueltas dio:
Una q de consola. La primera versión era una q gruesa inspirada en la fuente de consola de Quake.
El logo vectorial. Probé a usar el logo oficial en SVG. Al final preferí volver al pixel art, que encaja mejor con el estilo retro (además, el logo es una marca registrada de id Software).
El logo en píxeles. Redibujé la letra con la forma del logo: un anillo y un clavo con cruceta.
Más grande. A tamaño de editor se veía demasiado fina, así que añadí el ajuste quakeQ.scale para que ocupe algo más que una letra.
Sin cruz. Quité la cruceta del clavo, que a ese tamaño ensuciaba el dibujo.
Anillo redondo. Curvé las puntas hacia dentro y ensanché la base para que pareciera un anillo y no un tridente.
Por último añadí el ajuste quakeQ.letters, para elegir si se sustituye la Q mayúscula (por defecto), la q minúscula o las dos.
Ajustes
Ajuste
Por defecto
Para qué sirve
quakeQ.enabled
true
Activa o desactiva el efecto
quakeQ.letters
uppercase
uppercase, lowercase o both
quakeQ.scale
1.5
Tamaño del logo respecto a una letra
quakeQ.color / quakeQ.shadowColor
#d8b070 / #7a4a20
Colores del degradado
quakeQ.verticalOffset
0
Ajuste vertical en píxeles
quakeQ.fontFamily
""
Usar una fuente de Quake instalada en lugar del dibujo
También hay un comando, Quake Q: Toggle, para activarla y desactivarla.
Herramientas
JavaScript sin compilar: sin paso de build, sin TypeScript y sin dependencias. Son dos archivos: extension.js, con las decoraciones y los ajustes, y glyph.js, con los dibujos.
Icono y captura generados con código: se crean con Playwright a partir de la misma función buildSvg que usa la extensión, así que siempre coinciden con lo que se ve en el editor.
Empaquetado: con vsce.
Claude Code: desarrollé la extensión con Claude Code. Yo le explicaba en español lo que quería ver, revisaba las capturas y le pedía ajustes. En el repositorio hay un CLAUDE.md con las convenciones del proyecto: commits en formato Conventional Commits y todo el código y la documentación en inglés.
Limitaciones
Medidas estimadas: no son las reales de la fuente, así que con algunas fuentes hay que retocar verticalOffset.
Colores fijos: no cambian con el tema de VS Code, aunque el bronce se ve bien tanto en temas claros como oscuros.
Solapamiento: con scale por encima de 1, el logo se monta un poco sobre las letras de al lado.
Modo fuente: depende de un truco de CSS que una futura versión de VS Code podría romper.
Consiste en una aplicación web que conecta a clientes con productores de proximidad. Sólo hace falta buscar en el mapa productores y ponerse en contacto con ellos. Si eres productor de proximidad, TaulellDigital te permite promocionarte y automatizar muchos aspectos relacionados con el marketing tradicional.
En esta entrada explicaré como reproducir MP3 con arduino y la placa YX5300 de Catalex:
Este módulo utiliza una tarjeta SD para almacenar las canciones en formato MP3 o WAV. La tarjeta debe estar formateada a FAT32 o FAT16.
Se recomienda guardar los audios en carpetas numeradas, aunque solo se tenga una carpeta, la manera más cómoda (por ejemplo si se quiere reproducir todas las canciones de una carpeta en loop) es seguir la siguiente estructura:
Para la conexión del cableado si utilizamos Arduino Uno o Nano será la siguiente: Serial MP3 Player -> ARDUINO
VCC -> 5V o 3.3V
GND -> GND
TX-> D5
RX -> D6
Si utilizamos Arduino Mega se debe utilizar la siguiente conexión que utiliza el Serial3 (en el código también se tendrán que comentar/descomentar un par de líneas): Serial MP3 Player -> ARDUINO
VCC -> 5V o 3.3V
GND -> GND
TX-> 15 RX3
RX -> 14 TX3
También deberemos conectar a la salida del Jack 3.5 unos altavoces/auriculares.
/***********************************************************/
// Demo for the Serial MP3 Player Catalex (YX5300 chip)
// Hardware: Serial MP3 Player *1
// Board: Arduino UNO
// http://www.dx.com/p/uart-control-serial-mp3-music-player-module-for-arduino-avr-arm-pic-blue-silver-342439#.VfHyobPh5z0
//
//
//
// Uncomment SoftwareSerial for Arduino Uno or Nano.
#include <SoftwareSerial.h>
#define ARDUINO_RX 5 //should connect to TX of the Serial MP3 Player module
#define ARDUINO_TX 6 //connect to RX of the module
SoftwareSerial mp3(ARDUINO_RX, ARDUINO_TX);
//#define mp3 Serial3 // Connect the MP3 Serial Player to the Arduino MEGA Serial3 (14 TX3 -> RX, 15 RX3 -> TX)
static int8_t Send_buf[8] = {0}; // Buffer for Send commands. // BETTER LOCALLY
static uint8_t ansbuf[10] = {0}; // Buffer for the answers. // BETTER LOCALLY
String mp3Answer; // Answer from the MP3.
boolean autoResume = true;
/************ Command byte **************************/
#define CMD_NEXT_SONG 0X01 // Play next song.
#define CMD_PREV_SONG 0X02 // Play previous song.
#define CMD_PLAY_W_INDEX 0X03
#define CMD_VOLUME_UP 0X04
#define CMD_VOLUME_DOWN 0X05
#define CMD_SET_VOLUME 0X06
#define CMD_SNG_CYCL_PLAY 0X08 // Single Cycle Play.
#define CMD_SEL_DEV 0X09
#define CMD_SLEEP_MODE 0X0A
#define CMD_WAKE_UP 0X0B
#define CMD_RESET 0X0C
#define CMD_PLAY 0X0D
#define CMD_PAUSE 0X0E
#define CMD_PLAY_FOLDER_FILE 0X0F
#define CMD_STOP_PLAY 0X16
#define CMD_FOLDER_CYCLE 0X17
#define CMD_SHUFFLE_PLAY 0x18 //
#define CMD_SET_SNGL_CYCL 0X19 // Set single cycle.
#define CMD_SET_DAC 0X1A
#define DAC_ON 0X00
#define DAC_OFF 0X01
#define CMD_PLAY_W_VOL 0X22
#define CMD_PLAYING_N 0x4C
#define CMD_QUERY_STATUS 0x42
#define CMD_QUERY_VOLUME 0x43
#define CMD_QUERY_FLDR_TRACKS 0x4e
#define CMD_QUERY_TOT_TRACKS 0x48
#define CMD_QUERY_FLDR_COUNT 0x4f
/************ Opitons **************************/
#define DEV_TF 0X02
/*********************************************************************/
void setup()
{
Serial.begin(9600);
mp3.begin(9600);
delay(500);
sendCommand(CMD_SEL_DEV, DEV_TF);
delay(500);
}
void loop()
{
char c = ' ';
// If there a char on Serial call sendMP3Command to sendCommand
if ( Serial.available() )
{
c = Serial.read();
sendMP3Command(c);
}
// Check for the answer.
if (mp3.available())
{
Serial.println(decodeMP3Answer());
}
delay(100);
}
/********************************************************************************/
/*Function sendMP3Command: seek for a 'c' command and send it to MP3 */
/*Parameter: c. Code for the MP3 Command, 'h' for help. */
/*Return: void */
void sendMP3Command(char c) {
switch (c) {
case '?':
case 'h':
Serial.println("HELP ");
Serial.println(" p = Play");
Serial.println(" P = Pause");
Serial.println(" > = Next");
Serial.println(" < = Previous");
Serial.println(" + = Volume UP");
Serial.println(" - = Volume DOWN");
Serial.println(" c = Query current file");
Serial.println(" q = Query status");
Serial.println(" v = Query volume");
Serial.println(" x = Query folder count");
Serial.println(" t = Query total file count");
Serial.println(" 1 = Play folder 1");
Serial.println(" 2 = Play folder 2");
Serial.println(" 3 = Play folder 3");
Serial.println(" 4 = Play folder 4");
Serial.println(" 5 = Play folder 5");
Serial.println(" S = Sleep");
Serial.println(" W = Wake up");
Serial.println(" r = Reset");
break;
case 'p':
Serial.println("Play ");
sendCommand(CMD_PLAY, 0);
break;
case 'P':
Serial.println("Pause");
sendCommand(CMD_PAUSE, 0);
break;
case '>':
Serial.println("Next");
sendCommand(CMD_NEXT_SONG, 0);
sendCommand(CMD_PLAYING_N, 0x0000); // ask for the number of file is playing
break;
case '<':
Serial.println("Previous");
sendCommand(CMD_PREV_SONG, 0);
sendCommand(CMD_PLAYING_N, 0x0000); // ask for the number of file is playing
break;
case '+':
Serial.println("Volume Up");
sendCommand(CMD_VOLUME_UP, 0);
break;
case '-':
Serial.println("Volume Down");
sendCommand(CMD_VOLUME_DOWN, 0);
break;
case 'c':
Serial.println("Query current file");
sendCommand(CMD_PLAYING_N, 0);
break;
case 'q':
Serial.println("Query status");
sendCommand(CMD_QUERY_STATUS, 0);
break;
case 'v':
Serial.println("Query volume");
sendCommand(CMD_QUERY_VOLUME, 0);
break;
case 'x':
Serial.println("Query folder count");
sendCommand(CMD_QUERY_FLDR_COUNT, 0);
break;
case 't':
Serial.println("Query total file count");
sendCommand(CMD_QUERY_TOT_TRACKS, 0);
break;
case '1':
Serial.println("Play folder 1");
sendCommand(CMD_FOLDER_CYCLE, 0x0101);
break;
case '2':
Serial.println("Play folder 2");
sendCommand(CMD_FOLDER_CYCLE, 0x0201);
break;
case '3':
Serial.println("Play folder 3");
sendCommand(CMD_FOLDER_CYCLE, 0x0301);
break;
case '4':
Serial.println("Play folder 4");
sendCommand(CMD_FOLDER_CYCLE, 0x0401);
break;
case '5':
Serial.println("Play folder 5");
sendCommand(CMD_FOLDER_CYCLE, 0x0501);
break;
case 'S':
Serial.println("Sleep");
sendCommand(CMD_SLEEP_MODE, 0x00);
break;
case 'W':
Serial.println("Wake up");
sendCommand(CMD_WAKE_UP, 0x00);
break;
case 'r':
Serial.println("Reset");
sendCommand(CMD_RESET, 0x00);
break;
}
}
/********************************************************************************/
/*Function decodeMP3Answer: Decode MP3 answer. */
/*Parameter:-void */
/*Return: The */
String decodeMP3Answer() {
String decodedMP3Answer = "";
decodedMP3Answer += sanswer();
switch (ansbuf[3]) {
case 0x3A:
decodedMP3Answer += " -> Memory card inserted.";
break;
case 0x3D:
decodedMP3Answer += " -> Completed play num " + String(ansbuf[6], DEC);
break;
case 0x40:
decodedMP3Answer += " -> Error";
break;
case 0x41:
decodedMP3Answer += " -> Data recived correctly. ";
break;
case 0x42:
decodedMP3Answer += " -> Status playing: " + String(ansbuf[6], DEC);
break;
case 0x48:
decodedMP3Answer += " -> File count: " + String(ansbuf[6], DEC);
break;
case 0x4C:
decodedMP3Answer += " -> Playing: " + String(ansbuf[6], DEC);
break;
case 0x4E:
decodedMP3Answer += " -> Folder file count: " + String(ansbuf[6], DEC);
break;
case 0x4F:
decodedMP3Answer += " -> Folder count: " + String(ansbuf[6], DEC);
break;
}
return decodedMP3Answer;
}
/********************************************************************************/
/*Function: Send command to the MP3 */
/*Parameter:-int8_t command */
/*Parameter:-int16_ dat parameter for the command */
void sendCommand(int8_t command, int16_t dat)
{
delay(20);
Send_buf[0] = 0x7e; //
Send_buf[1] = 0xff; //
Send_buf[2] = 0x06; // Len
Send_buf[3] = command;//
Send_buf[4] = 0x01; // 0x00 NO, 0x01 feedback
Send_buf[5] = (int8_t)(dat >> 8); //datah
Send_buf[6] = (int8_t)(dat); //datal
Send_buf[7] = 0xef; //
Serial.print("Sending: ");
for (uint8_t i = 0; i < 8; i++)
{
mp3.write(Send_buf[i]) ;
Serial.print(sbyte2hex(Send_buf[i]));
}
Serial.println();
}
/********************************************************************************/
/*Function: sbyte2hex. Returns a byte data in HEX format. */
/*Parameter:- uint8_t b. Byte to convert to HEX. */
/*Return: String */
String sbyte2hex(uint8_t b)
{
String shex;
shex = "0X";
if (b < 16) shex += "0";
shex += String(b, HEX);
shex += " ";
return shex;
}
/********************************************************************************/
/*Function: sanswer. Returns a String answer from mp3 UART module. */
/*Parameter:- uint8_t b. void. */
/*Return: String. If the answer is well formated answer. */
String sanswer(void)
{
uint8_t i = 0;
String mp3answer = "";
// Get only 10 Bytes
while (mp3.available() && (i < 10))
{
uint8_t b = mp3.read();
ansbuf[i] = b;
i++;
mp3answer += sbyte2hex(b);
}
// if the answer format is correct.
if ((ansbuf[0] == 0x7E) && (ansbuf[9] == 0xEF))
{
return mp3answer;
}
return "???: " + mp3answer;
}
Si estamos trabajando con Arduino Mega se deberá comentar la línea 13
#include <SoftwareSerial.h>
Comentar la línea 18 y descomentar la 19
SoftwareSerial mp3(ARDUINO_RX, ARDUINO_TX);
//#define mp3 Serial3 // Connect the MP3 Serial Player to the Arduino MEGA Serial3 (14 TX3 -> RX, 15 RX3 -> TX)
Ahora podremos manipular el reproductor a través del monitor serie del propio IDE de Arduino. Una vez subido el código al Arduino abrimos el monitor serie:
Si todo está correcto nos mostrará el texto:
Si introducimos la letra «h» nos mostrará el menu de ayuda con las diferentes opciones disponibles:
Si introducimos la letra «p» se ejecutará un audio y si introducimos «1» ejecutará todas las canciones de la carpeta 01.
Para hacer un archivo ejecutable que abra el navegador Chrome en modo kiosk se debe crear un archivo de texto y guardar en formato .bat con el siguiente contenido:
Podemos crear un archivo phpinfo para ver la información:
sudo nano /var/www/html/info.php
Dentro del archivo escribimos:
<?php
phpinfo();
?>
Ahora podemos comprobar entrando en el navegador web desde la Raspberry la url: http://localhost/info.php
O si nos conectamos de manera remota (en el ejemplo la ip es 192.168.1.100), introducimos la siguiente url en nuestro navegador web: http://192.168.1.100/info.php
Podremos ver algo parecido a esto:
Instalamos MySQL:
sudo apt-get install mysql-server
Ahora podemos instalar phpMyAdmin para gestionar via web la Base de Datos, para ello primero haremos:
Mientras se instala nos pedirá el tipo de servidor instalado, seleccionamos «apache2».
También nos preguntará la contraseña que tiene la base de datos y nos pedirá una contraseña para el phpMyAdmin.
Ahora queda configurar Apache para trabajar con phpMyAdmin:
sudo nano /etc/apache2/apache2.conf
Y añadimos al final del documento (recuerda que puedes avanzar más rápido con Ctrl+V) la siguiente línea:
Include /etc/phpmyadmin/apache.conf
Guardamos el documento y reiniciamos apache:
sudo /etc/init.d/apache2 restart
Ahora si introducimos en el navegador web de la Rapberry:
http://localhost/phpmyadmin
O si lo hacemos desde remoto (en el ejemplo la ip es 192.168.1.100), introducimos en nuestro navegador web: http://192.168.1.100/phpmyadmin
Nos aparecerá la pantalla de login de phpmyadmin:
Ahora ya podemos gestionar por la web la base de datos, bieeen!
Para saber siempre la IP de tu Raspberry Pi lo que debes hacer es asignarle una IP que tú le especifiques, para ello debemos modificar el archivo «interfaces» de la Raspberry.
Primero podemos hacer una copia del archivo por seguridad:
Dentro del documento yo he tenido que comentar la siguiente línea(puede que en vez de la palabra «manual» aparezca otra):
iface eth0 inet manual
Y Añadir:
-La línea con la palabra «static»
-La dirección que queremos asignarle (en el ejemplo 192.168.1.100)
-La Mascara de red (255.255.255.0)
-La dirección del router (192.168.0.1)
La parte anterior sirve para la conexión por cable, si también conectamos la Raspberry por Wifi deberemos hacer lo mismo para la Wifi en el documento, un poquito más abajo:
Hay tres maneras de importar una librerías (library) a Arduino:
-Utilizando el Library Manager
-Importando un .zip
-Manualmente
Utilizando el Library Manager Dentro del menú Programa->Include Library-> Manage Libraries.
Aquí podrás buscar e instalar la librería que quieras.
Importando un .zip
Si tienes un comprimido que te has descargado puedes importar directamente este archivo desde Programa-> Include Library -> Add .zip Library y seleccionar el .zip.
Manualmente Deberás dejar la carpeta con el contenido (archivo .cpp, archivo .h y otros archivos/caretas como ejemplos) dentro de una determinada carpeta dependiendo de tu SO:
En Windows (carpeta Mis Documentos):
Documentos\Arduino\libraries
En Mac:
Documents/Arduino/libraries
En Linux:
Será la carpeta «libraries» en tu sketchbook.
¡Importante!
Los archivos .cpp y .h se deben encontrar en la carpeta inmediata, no funciona si se encuentran en una subcarpeta, es decir, esta disposición és incorrecta:
Arduino\libraries\Librerias_nuevas\MinuevaLib\archivo.cpp
Debe estar en el primer nivel por debajo de «libraries»:
Arduino\libraries\MinuevaLib\archivo.cpp