Te imaginas, poder comunicarte desde tu ordenador con tu Furby?
Sí, es posible. Pero aquí conviene tener en cuenta que se pretende controlar un elemento Bluetooth:
Para controlar un Furby, al ser inalámbrico no usaría librerías habituales como PyUSB, porque PyUSB es solo para conexiones de tipo USB. Para un Furby Connect lo correcto es Bluetooth Low Energy —BLE— con Python y la librería bleak.
La propuesta sería:
Windows 10/11
↓
Adaptador Bluetooth 4.0 o superior
↓
Bluetooth Low Energy / GATT
↓
Python 3.11+
↓
bleak
↓
Furby Connect
1. Primero: tenemos que descubrir qué Furby queremos controlar
No todos los Furby se comunican igual. Según la documentación técnica recopilada por la comunidad Furby, las generaciones usan sistemas incompatibles: los Furby de 1998 usan infrarrojos, los de 2012/Boom usan ultrasonidos mediante ComAir, los Furby Connect 2016-2017 usan Bluetooth, y los modelos más recientes usan señales sonoras o infrarrojos según generación. (official-furby.fandom.com)
Por tanto, para Windows + Python + comunicación inalámbrica, la opción más razonable es:
Furby Connect, no Furby 2012 ni Furby Boom.
El proyecto bluefluff documenta que Furby Connect usa Bluetooth Low Energy y que se pueden controlar acciones, color de antena, retroiluminación LCD, estados de ánimo y sensores. (GitHub)
2. Librería recomendada: bleak
Para Windows, la librería adecuada es Bleak, no PyUSB. Bleak es un cliente GATT para dispositivos Bluetooth Low Energy y permite escanear, conectar, leer, escribir características y suscribirse a notificaciones. Además, soporta Windows 10 versión 16299 o superior. (Bleak)
Instalación en PowerShell:
py -m venv .venv
.\.venv\Scripts\activate
python -m pip install --upgrade pip
pip install bleak
Comprueba la versión:
python --version
pip show bleak
3. Entorno físico recomendado
Necesitas:
PC con Windows 10/11
Bluetooth 4.0 o superior
Python 3.11 o superior
Furby Connect con pilas nuevas
Furby despierto y no conectado a la app oficial
Recomendaciones prácticas:
- Usa pilas nuevas. El Furby Connect consume bastante.
- Apaga Bluetooth en móviles cercanos que hayan usado la app oficial.
- Despierta el Furby antes de escanear.
- Acércalo al PC durante las primeras pruebas.
- No empieces subiendo DLC ni modificando memoria interna; primero solo escaneo, conexión y color de antena.
4. UUID importantes del Furby Connect
El servicio interesante se suele llamar Fluff Service:
dab91435-b5a1-e29c-b041-bcd562613bde
Características relevantes:
GeneralPlusListen:
dab91382-b5a1-e29c-b041-bcd562613bde
GeneralPlusWrite:
dab91383-b5a1-e29c-b041-bcd562613bde
NordicListen:
dab90756-b5a1-e29c-b041-bcd562613bde
NordicWrite:
dab90757-b5a1-e29c-b041-bcd562613bde
FileWrite:
dab90758-b5a1-e29c-b041-bcd562613bde
La documentación de PyFluff/bluefluff indica que GeneralPlusWrite se usa para enviar comandos al Furby, y que esos comandos son arrays de bytes de hasta 20 bytes, donde el primer byte define el tipo de comando. (GitHub)
5. Estructura de proyecto propuesta
furby-connect-control/
│
├── scan_furby.py
├── furby_ble.py
├── demo_antenna.py
└── requirements.txt
requirements.txt:
bleak
6. Script 1: escanear dispositivos BLE
Guarda esto como scan_furby.py:
import asyncio
from bleak import BleakScanner
FURBY_SERVICE = "dab91435-b5a1-e29c-b041-bcd562613bde"
async def main():
print("Escaneando dispositivos BLE durante 10 segundos...\n")
devices = await BleakScanner.discover(
timeout=10.0,
return_adv=True
)
for address, (device, adv) in devices.items():
name = device.name or adv.local_name or "Sin nombre"
services = adv.service_uuids or []
print(f"Nombre: {name}")
print(f"Dirección: {device.address}")
print(f"RSSI: {adv.rssi}")
print(f"Servicios: {services}")
print("-" * 60)
if FURBY_SERVICE.lower() in [s.lower() for s in services]:
print(">>> Posible Furby Connect encontrado")
print(f">>> Dirección: {device.address}")
print("-" * 60)
if __name__ == "__main__":
asyncio.run(main())
Ejecución:
python scan_furby.py
Resultado esperado aproximado:
Nombre: Furby
Dirección: XX:XX:XX:XX:XX:XX
Servicios: ['dab91435-b5a1-e29c-b041-bcd562613bde']
>>> Posible Furby Connect encontrado
Bleak permite usar BleakScanner para escuchar anuncios BLE y obtener dispositivos detectados, datos de advertising y UUIDs de servicio. (Bleak)
7. Script 2: clase mínima para controlar el Furby
Guarda esto como furby_ble.py:
import asyncio
from bleak import BleakScanner, BleakClient
FURBY_SERVICE = "dab91435-b5a1-e29c-b041-bcd562613bde"
GENERAL_PLUS_LISTEN = "dab91382-b5a1-e29c-b041-bcd562613bde"
GENERAL_PLUS_WRITE = "dab91383-b5a1-e29c-b041-bcd562613bde"
NORDIC_LISTEN = "dab90756-b5a1-e29c-b041-bcd562613bde"
NORDIC_WRITE = "dab90757-b5a1-e29c-b041-bcd562613bde"
class FurbyConnect:
def __init__(self):
self.device = None
self.client = None
async def find(self, timeout=10.0):
print("Buscando Furby Connect...")
def is_furby(device, adv):
services = adv.service_uuids or []
return FURBY_SERVICE.lower() in [s.lower() for s in services]
self.device = await BleakScanner.find_device_by_filter(
is_furby,
timeout=timeout
)
if self.device is None:
raise RuntimeError(
"No se ha encontrado ningún Furby Connect. "
"Comprueba que esté despierto, cerca y con pilas nuevas."
)
print(f"Furby encontrado: {self.device.name} / {self.device.address}")
return self.device
async def connect(self):
if self.device is None:
await self.find()
self.client = BleakClient(self.device)
await self.client.connect()
if not self.client.is_connected:
raise RuntimeError("No se ha podido conectar al Furby.")
print("Conectado al Furby Connect.")
await self.client.start_notify(
GENERAL_PLUS_LISTEN,
self._on_generalplus_notify
)
async def disconnect(self):
if self.client and self.client.is_connected:
try:
await self.client.stop_notify(GENERAL_PLUS_LISTEN)
except Exception:
pass
await self.client.disconnect()
print("Desconectado.")
def _on_generalplus_notify(self, sender, data):
hex_data = " ".join(f"{b:02X}" for b in data)
print(f"[GeneralPlus] {hex_data}")
async def write_generalplus(self, data: bytes):
if not self.client or not self.client.is_connected:
raise RuntimeError("El Furby no está conectado.")
await self.client.write_gatt_char(
GENERAL_PLUS_WRITE,
data,
response=True
)
async def set_antenna_color(self, red: int, green: int, blue: int):
"""
Controla el LED RGB de la antena.
Comando GeneralPlus 0x14 + RGB.
"""
red = max(0, min(255, red))
green = max(0, min(255, green))
blue = max(0, min(255, blue))
command = bytes([0x14, red, green, blue])
await self.write_generalplus(command)
async def trigger_action_specific(
self,
input_id: int,
index: int,
subindex: int,
specific: int
):
"""
Lanza una acción específica.
Basado en el comando 0x13:
0x13 0x00 input index subindex specific
"""
command = bytes([
0x13,
0x00,
input_id & 0xFF,
index & 0xFF,
subindex & 0xFF,
specific & 0xFF
])
await self.write_generalplus(command)
8. Script 3: demo segura de color de antena
Guarda esto como demo_antenna.py:
import asyncio
from furby_ble import FurbyConnect
async def main():
furby = FurbyConnect()
try:
await furby.find()
await furby.connect()
print("Rojo")
await furby.set_antenna_color(255, 0, 0)
await asyncio.sleep(2)
print("Verde")
await furby.set_antenna_color(0, 255, 0)
await asyncio.sleep(2)
print("Azul")
await furby.set_antenna_color(0, 0, 255)
await asyncio.sleep(2)
print("Blanco")
await furby.set_antenna_color(255, 255, 255)
await asyncio.sleep(2)
print("Apagado")
await furby.set_antenna_color(0, 0, 0)
finally:
await furby.disconnect()
if __name__ == "__main__":
asyncio.run(main())
Ejecución:
python demo_antenna.py
9. Qué comandos podemos enviar
La documentación técnica indica que el comando 0x14 sirve para establecer el color RGB de la antena, 0x13 para disparar una acción específica, 0x24 para modificar estados como excitación, cansancio, hambre o bienestar, y otros comandos permiten gestionar DLC o acceder a estados internos. (GitHub)
Para una primera fase, yo limitaría el proyecto a:
Fase 1: escaneo BLE
Fase 2: conexión
Fase 3: lectura de servicios
Fase 4: color de antena
Fase 5: recepción de notificaciones
Fase 6: acciones preprogramadas
Fase 7: sensores
Fase 8: integración con una aplicación propia
No tocaría todavía:
Subida de DLC
Borrado de slots
Modificación persistente
Actualizaciones
Manipulación de firmware
10. Diagnóstico de problemas típicos en Windows
| Problema | Causa probable | Solución |
|---|---|---|
| No aparece el Furby | Está dormido | Despertarlo y repetir escaneo |
| Aparece pero no conecta | Conectado al móvil o app oficial | Apagar Bluetooth del móvil |
| Se desconecta | Pilas bajas | Cambiar pilas |
| No aparecen servicios | Caché BLE de Windows | Quitar dispositivo en Bluetooth y volver a escanear |
BleakError | Bluetooth inestable | Reiniciar adaptador o PC |
| No responde a comandos | No es Furby Connect | Verificar modelo |
La demo FurBLE también recomienda cambiar pilas si hay desconexiones o comportamientos extraños, y reiniciar el Furby si rechaza conexiones. (pdjstone.github.io)
11. Propuesta de aplicación docente
Podrías montar una práctica muy interesante:
Práctica: Control inalámbrico de un juguete interactivo mediante BLE
Objetivos:
1. Escanear dispositivos BLE.
2. Identificar servicios y características GATT.
3. Conectarse a un periférico.
4. Enviar comandos binarios.
5. Recibir notificaciones.
6. Relacionar protocolo, actuadores y comportamiento físico.
Aplicaciones:
Indicador físico de estado de una clase
Notificador de compilaciones
Mascota robótica controlada desde Python
Interfaz tangible para videojuegos
Ejemplo de ingeniería inversa responsable
Práctica de BLE + GATT + Python
12. Conclusión técnica
La propuesta equivalente al control del i-Buddy sería:
i-Buddy:
Windows + Python + PyUSB + USB HID
Furby Connect:
Windows + Python + Bleak + Bluetooth Low Energy / GATT
Para empezar de forma segura, yo prepararía el entorno con Python 3.11+, Bleak, escaneo BLE y control del LED de antena. Una vez validado eso, ya pasaría a acciones, sensores y automatizaciones.
MOTIVACIÓN, llamada a la acción
Propuesta docente: “Haz que un Furby cobre vida con tu app”
Título de la actividad
FURBY HACK LAB
Programa una mascota interactiva real con Python, Bluetooth y diseño de videojuegos
Mensaje para los alumnos
Imaginad que no estáis programando una práctica más.
Imaginad que vuestra aplicación no se queda dentro de la pantalla, sino que controla un juguete real, con luces, movimientos, reacciones, estados de ánimo y comportamiento físico.
Ese es el reto: crear una aplicación capaz de comunicarse inalámbricamente con un Furby Connect mediante Bluetooth Low Energy.
No se trata solo de “hacer que algo funcione”. Se trata de diseñar una experiencia interactiva donde el Furby se convierta en:
- una mascota virtual-física,
- un personaje no jugable del mundo real,
- un indicador emocional,
- un periférico alternativo,
- una interfaz tangible,
- o incluso un actor dentro de un videojuego.
La pregunta no es solo:
“¿Podemos controlar un Furby?”
La pregunta interesante es:
“¿Qué experiencia podemos diseñar cuando un personaje físico responde a nuestra aplicación?”
El reto
Vais a crear una aplicación que se comunique con un Furby de forma inalámbrica. Para ello usaréis conceptos reales de ingeniería y desarrollo:
Python
Bluetooth Low Energy
GATT
Servicios y características BLE
Comandos binarios
Eventos
Sensores
Interacción física
Diseño de experiencia de usuario
El Furby dejará de ser un juguete cerrado y pasará a ser un dispositivo interactivo programable.
¿Qué se espera que podáis hacer?
Como mínimo, vuestra aplicación debería ser capaz de:
1. Detectar el Furby
La app deberá escanear dispositivos Bluetooth cercanos y encontrar el Furby Connect.
Resultado visual esperado:
Buscando dispositivos BLE...
Furby encontrado.
Conectando...
Conexión establecida.
Esto ya introduce una idea clave: la aplicación descubre dispositivos del mundo físico.
2. Conectarse inalámbricamente
Una vez detectado, la app debe establecer conexión con el Furby mediante Bluetooth Low Energy.
Aquí ya no hablamos de enchufar un cable USB. Hablamos de comunicación inalámbrica real, como la que usan pulseras deportivas, sensores médicos, dispositivos domóticos o mandos modernos.
3. Controlar elementos visuales
La primera función espectacular será controlar la antena RGB del Furby.
Por ejemplo:
| Estado de la app | Color del Furby |
|---|---|
| Conectando | Azul intermitente |
| Todo correcto | Verde |
| Error | Rojo |
| Modo juego | Morado |
| Alerta | Rojo + parpadeo |
| Evento especial | Arcoíris |
Aquí aparece una idea potente para videojuegos:
El Furby puede convertirse en una luz ambiental física que representa el estado del juego.
4. Ejecutar acciones
El siguiente nivel será lanzar comportamientos o acciones del Furby: movimientos, reacciones o respuestas preprogramadas.
La app podría hacer que el Furby reaccione cuando:
- el jugador gana,
- el jugador pierde,
- ocurre un evento importante,
- se recibe una notificación,
- se supera un reto,
- el usuario pulsa un botón,
- cambia el estado emocional de la aplicación.
En vez de mostrar solo un mensaje en pantalla, la aplicación puede hacer que un personaje físico reaccione.
5. Leer respuestas o notificaciones
La comunicación no tiene por qué ser solo de la app al Furby. También puede haber información que vuelva desde el dispositivo.
Eso permite pensar en el Furby no solo como “muñeco controlado”, sino como periférico interactivo.
Ideas de aplicaciones espectaculares
Aquí está la parte importante: no queremos una demo técnica aburrida. Queremos que el resultado parezca una aplicación real, atractiva y con personalidad.
1. Furby como mascota de escritorio inteligente
Una app donde el Furby reacciona al estado del usuario o del ordenador.
Ejemplos:
Tienes clase → Furby se pone azul.
Hay una tarea pendiente → Furby se pone amarillo.
Has terminado una actividad → Furby celebra.
Hay un error → Furby se enfada.
Modo concentración → Furby se queda tranquilo.
Resultado espectacular: el Furby se convierte en una mascota física de productividad.
2. Furby como personaje no jugable físico
La aplicación puede ser un pequeño videojuego donde el Furby representa a un personaje externo al ordenador.
Por ejemplo:
“El Furby es el guardián del laboratorio. El jugador tiene que resolver pruebas y, según lo que ocurra, el Furby cambia de color, reacciona o celebra.”
Resultado espectacular: un videojuego donde uno de los personajes existe fuera de la pantalla.
3. Furby como jefe final
La app podría plantearse como un minijuego:
El Furby está dormido.
El jugador debe superar pruebas.
Cada acierto cambia su estado.
Cada fallo lo enfada.
Al final, el Furby despierta o se calma.
Puede haber niveles, puntuación, sonidos, luces y eventos.
Resultado espectacular: una experiencia híbrida entre videojuego, escape room y juguete interactivo.
4. Furby como indicador emocional de una IA
La app puede conectarse a una lógica conversacional sencilla o a un sistema de estados:
| Estado emocional | Reacción |
|---|---|
| Contento | Verde |
| Enfadado | Rojo |
| Triste | Azul |
| Nervioso | Amarillo intermitente |
| Sorprendido | Blanco |
| Modo fiesta | Secuencia RGB |
Resultado espectacular: el Furby funciona como avatar físico emocional.
Esto conecta muy bien con diseño de personajes, narrativa interactiva y experiencia de usuario.
5. Furby como periférico alternativo de videojuegos
El Furby puede actuar como salida física del juego.
Ejemplos:
Vida baja → antena roja.
Energía cargada → antena verde.
Peligro cercano → parpadeo rápido.
Misión completada → celebración.
Modo sigilo → luz azul tenue.
Resultado espectacular: el alumno diseña un sistema de feedback háptico/visual externo al videojuego.
Esto es especialmente interesante para diseño de videojuegos porque obliga a pensar más allá de la pantalla.
6. Furby como “streamer companion”
Una aplicación tipo compañero de directo:
Nuevo seguidor → Furby se ilumina.
Donación → Furby celebra.
Mensaje importante → Furby reacciona.
Alerta técnica → Furby cambia a rojo.
Resultado espectacular: el Furby se convierte en un dispositivo de notificaciones físicas para streaming.
7. Furby como escape room físico-digital
La aplicación puede plantear una historia:
“El Furby guarda un secreto. Para desbloquearlo, hay que resolver pruebas desde la app. Cada prueba modifica su comportamiento.”
Ejemplo de fases:
Fase 1: detectar al Furby.
Fase 2: activar color correcto.
Fase 3: resolver secuencia.
Fase 4: desbloquear reacción.
Fase 5: final narrativo.
Resultado espectacular: mezcla de programación, narrativa, interacción física y juego.
Qué hace que este proyecto sea atractivo
Este proyecto tiene algo que muchas prácticas no tienen:
Se ve. Se toca. Reacciona.
No es solo código en consola.
Cuando el código funciona, ocurre algo en el mundo real:
La antena cambia de color.
El Furby responde.
El personaje parece vivo.
La app controla un objeto físico.
Eso produce una recompensa inmediata. El alumno ve que su programa tiene consecuencias físicas.
Y eso engancha.
Versión tipo “pitch” para clase
Podrías presentarlo así:
En esta práctica no vais a programar una calculadora, ni una pantalla de login, ni una app que solo muestra datos.
Vais a programar una aplicación capaz de comunicarse con un personaje físico real.
Vuestro reto será convertir un Furby Connect en una mascota interactiva controlada por software. Tendréis que descubrirlo por Bluetooth, conectaros a él, enviarle comandos, controlar sus luces y diseñar una experiencia que tenga sentido.
No gana el proyecto que solo consiga encender una luz. Gana el proyecto que consiga que el Furby parezca formar parte de una experiencia: un juego, una historia, una alerta, una mascota, un asistente o un personaje.
La parte técnica es importante, pero la parte creativa lo es todavía más: ¿qué haréis con un personaje físico que podéis controlar desde vuestra aplicación?
Qué deberían entregar los alumnos
Entrega mínima
Una aplicación que:
1. Escanee dispositivos BLE.
2. Detecte el Furby.
3. Se conecte correctamente.
4. Cambie el color de la antena.
5. Ejecute al menos una secuencia de comportamiento.
6. Tenga una interfaz mínima o menú de control.
Entrega buena
Una aplicación que:
1. Tenga interfaz gráfica.
2. Permita seleccionar estados.
3. Incluya varios modos de comportamiento.
4. Gestione errores de conexión.
5. Documente el protocolo usado.
6. Incluya vídeo demostrativo.
Entrega excelente
Una aplicación que:
1. Proponga una experiencia completa.
2. Integre narrativa, juego o utilidad real.
3. Use estados emocionales.
4. Reaccione a eventos externos.
5. Cuide la interfaz de usuario.
6. Presente una demo espectacular y comprensible.
Ejemplo de aplicación tipo ideal
Nombre
Furby Mood Controller
Idea
Una aplicación que convierte al Furby en una mascota emocional conectada al ordenador.
Funciones
Modo feliz → antena verde + reacción positiva.
Modo enfadado → antena roja + reacción intensa.
Modo sueño → antena azul tenue.
Modo fiesta → secuencia RGB.
Modo alerta → parpadeo rojo.
Modo juego → colores según puntuación.
Pantalla principal
[Conectar Furby]
Estado: Conectado
[ Feliz ] [ Triste ] [ Alerta ] [ Fiesta ] [ Dormir ]
Color personalizado:
R: ___ G: ___ B: ___
[Enviar color]
[Ejecutar secuencia]
[Desconectar]
Resultado visual
El profesor pulsa “Fiesta” y el Furby cambia de colores.
El alumno activa “Alerta” y el Furby se ilumina en rojo.
El juego detecta que el jugador ha ganado y el Furby celebra.
Eso es mucho más memorable que imprimir:
Victoria
en una consola.
Lo que aprenderán sin darse cuenta
Aunque parezca una actividad divertida, en realidad toca muchos contenidos serios:
| Área | Aprendizaje |
|---|---|
| Programación | Python, funciones, clases, asincronía |
| Comunicaciones | Bluetooth Low Energy, GATT, UUID |
| Ingeniería | protocolo, comandos, pruebas, errores |
| Videojuegos | feedback, estados, narrativa, eventos |
| UX | diseño de interacción física |
| Robótica ligera | actuadores, respuesta externa |
| Creatividad | convertir tecnología en experiencia |
La gracia es que el alumno no estudia BLE como teoría aislada. Lo aprende porque quiere que el Furby responda.
Enfoque de Aprendizaje Basado en Proyectos
La actividad puede formularse así:
Problema inicial
Tenemos un dispositivo interactivo real, pero no queremos usar su app oficial. Queremos diseñar nuestra propia aplicación para comunicarnos con él y crear una experiencia nueva.
Producto final
Una aplicación funcional que controle un Furby Connect de forma inalámbrica y lo integre en una experiencia interactiva.
Pregunta guía
¿Cómo podemos transformar un juguete comercial en un personaje interactivo programable?
Criterios para que el proyecto sea espectacular
Para que una demo destaque, no basta con decir “hemos cambiado el color”.
Debe haber intención.
Demo normal
Pulso un botón.
El Furby se pone rojo.
Demos interesantes
El jugador falla una prueba.
La app detecta el fallo.
El Furby se pone rojo.
El Furby reacciona.
La interfaz muestra que está enfadado.
El jugador debe calmarlo.
La diferencia está en el diseño de la experiencia de usuario.
Ideas de nombres para proyectos de alumnos
Furby Mood Lab
Furby Game Master
Furby Quest
Furby Companion
Furby Alert
Furby Boss Fight
Furby Escape Room
Furby Stream Buddy
Furby Classroom Guardian
Furby Emotional Engine
Frase de cierre:
Este proyecto no consiste en controlar un Furby.
Consiste en demostrar que sabéis conectar software, hardware, comunicación inalámbrica, diseño de interacción y creatividad para construir una experiencia que sorprenda.
Cuando vuestro código haga que un objeto físico reaccione, habréis cruzado una frontera importante: la frontera entre programar una pantalla y programar el mundo real.
