Interruptor USB con Alexa – Control Inteligente para Dispositivos USB

Selecciona la opción MQTT by Joel Gaehwiler.

El archivo secrets.h debe rellenarse con tus ajustes de WiFi y MQTT de Tinamous; no he incluido el mío por razones obvias.

#define SECRET_SSID "Tu SSID"
#define SECRET_PASS "Contraseña de tu SSID"
/************************* Configuración MQTT Tinamous *********************************/
#define MQTT_SERVER "<nombre_cuenta_tinamous>.tinamous.com"
#define MQTT_SERVERPORT 8883
#define MQTT_USERNAME "UsbSwitch.<nombre_cuenta_tinamous>"
#define MQTT_PASSWORD "Tu contraseña aquí."
#define MQTT_CLIENT_ID "UsbSwitch"
#define DEVICE_USERNAME "UsbSwitch"

Si aún no te has registrado en Tinamous, puedes crear tu cuenta gratuita aquí. Al registrarte se te pide un nombre de Cuenta/Organización, que se convierte en tu área privada en Tinamous; puedes invitar a otros miembros (incluyendo Alexa) y compartir tus dispositivos con tu grupo.

En mi caso llamo a mi cuenta «AlexaExample», que es lo que incluiré en la configuración MQTT, y mi cuenta está en https://AlexaExample.Tinamous.com

Paso 5

Ahora añadimos nuestro Dispositivo. En la página Dispositivos de Tinamous, haz clic en Añadir.

Así, los ajustes MQTT de mi dispositivo quedan así:

/************************* Configuración MQTT Tinamous *********************************/
#define MQTT_SERVER "AlexaExample.tinamous.com"
#define MQTT_SERVERPORT 8883
#define MQTT_USERNAME "UsbSwitch.AlexaExample"
#define MQTT_PASSWORD "Mi contraseña súper secreta que totalmente no es Passw0rd...."
#define MQTT_CLIENT_ID "UsbSwitch"
#define DEVICE_USERNAME "UsbSwitch"

Ya tenemos nuestra cuenta y dispositivo Tinamous habilitados. Puedes añadir más dispositivos aquí si lo deseas, actualizando los ajustes MQTT para DEVICE_USERNAME y MQTT_USERNAME (MQTT no envía información de cabecera como HTTP, así que Tinamous no sabe qué subdominio usas, por eso hay que especificar la cuenta en el nombre de usuario).

Paso 6

Sube el código adjunto a tus dispositivos (con tu secrets.h actualizado). Tómate un momento para revisar TinamousMQTTClient.ino, que maneja nuestras interacciones MQTT y, con ellas, los comandos de Alexa que se envían a nuestro dispositivo.

Debemos usar WiFiSSLClient para SSL. Si deseas usar un servidor MQTT local sin SSL, puedes usar el cliente WiFi normal y bajar al puerto 1883, pero para cualquier cosa basada en internet, usa el cliente SSL.

También necesitamos reservar un poco más que el búfer por defecto para el cliente MQTT; aquí reservamos 4096 bytes.

WiFiSSLClient networkClient;
MQTTClient mqttClient(4096);

Usamos mqttClient.begin para configurar el cliente y especificar un manejador en onMessage que se llama cuando se recibe un mensaje del servidor MQTT.

mqttClient.begin(MQTT_SERVER, MQTT_SERVERPORT, networkClient);
mqttClient.onMessage(messageReceived);

Y luego nos conectamos y suscribimos a los temas que nos interesan. Aquí ves que nos suscribimos a «/Tinamous/V1/Status.To/UsbSwitch»; recibiremos mensajes enviados a @UsbSwitch desde la línea de tiempo de Tinamous. Así recibiremos mensajes de Alexa.

if (!mqttClient.connect(MQTT_CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) {
  if (mqttClient.lastError() == LWMQTT_CONNECTION_DENIED) {
    // Error: usuario o contraseña incorrectos
  }
  if (mqttClient.lastError() == -6) {
    // Probablemente no añadiste el certificado SSL
  }
  delay(10000);
  return false;
}
mqttClient.subscribe("/Tinamous/V1/Status.To/" DEVICE_USERNAME);

Puedes pensar en la línea de tiempo de Tinamous como una versión privada de Twitter para ti y tus dispositivos; pueden usar MQTT o la API REST (o uno de los bots) para ver los mensajes enviados a ellos y actuar en consecuencia, así como publicar mensajes de vuelta.

Tenemos un poco más de trabajo en Tinamous para habilitar la integración con Alexa, pero por ahora podemos probar nuestro dispositivo y firmware usando la línea de tiempo y enviando mensajes.

Si usas la Skill Tinamous SmartHome, ¡todo el código necesario está hecho!

La Skill Tinamous Smart Home para Alexa

La Skill Tinamous Smart Home está pendiente de aprobación para publicarse (en el momento de escribir esto, cruzo los dedos para que ya esté en la tienda). Para hacer tu propio conmutador USB, solo necesitas usar esta Skill cuando esté disponible.

La skill es muy genérica: no sabe nada de los dispositivos ni cómo hablar con ellos. Aplicamos etiquetas a los dispositivos en Tinamous y la skill crea un dispositivo apropiado en la cuenta de Alexa; así, podrías usar esta skill y Tinamous para dar control por voz a uno de tus propios proyectos con solo unas líneas de código en el dispositivo.

Sin embargo, puede que quieras modificar cosas o escribir tu propia skill, así que compartiré los detalles de mi desarrollo.

Escribí la skill en C# para .Net Core 2.0; se desarrolló originalmente para mi proyecto de ventilador inteligente BOFF, pero para este proyecto la extendí para permitir que un dispositivo tenga muchas salidas (puertos) y que cada una sea un ciudadano de primera clase en los dispositivos Smart Home de Alexa.

Todo el código (¡incluyendo tests!) está en el repositorio Tinamous SmartHome; clónalo, descárgalo o míralo como quieras. Usé Visual Studio 2017 con las herramientas de AWS instaladas para subir la skill a Lambda.

El framework deserializa el mensaje de directiva entrante de Alexa en objetos accesibles desde el código; se toman acciones apropiadas basadas en el namespace y nombre de la directiva del encabezado, y se devuelve una respuesta apropiada.

Los mensajes principales de interés son:

• Vinculación de cuenta (Account Linking)
• Descubrimiento (Discovery)
• Informe de estado (State Report)
• Control de energía (Power Control)

Vinculación de cuenta

Alexa lo gestiona por nosotros: tras añadir la skill a nuestra cuenta, Alexa solicita autenticación y nos lleva a la página de autorización de Tinamous para permitir que el dispositivo acceda a nuestra cuenta. Aquí debes introducir tu nombre de cuenta (AlexaExample en este caso), nombre de usuario (Steve) y contraseña (¡no, no la diré!).

Descubrimiento

Una vez vinculada la cuenta, Alexa pide realizar el descubrimiento; la skill consulta Tinamous por dispositivos etiquetados con «Alexa.SmartDevice». Los dispositivos sin esta etiqueta se ignoran.

Estas etiquetas se aplican editando el dispositivo desde la página Dispositivos en Tinamous.

Si el dispositivo también tiene la etiqueta «MultiPort», cada puerto se enumera y se añade un dispositivo para cada uno. También aplicamos etiquetas basadas en las directivas de Alexa que nuestro dispositivo soporta; aquí solo «Alexa.PowerController» y una etiqueta para indicar la categoría en la app, usando «SmartPlug».

Otras interfaces están disponibles, como Alexa.BrightnessController, pero no son tan útiles aquí. Ver el README del repositorio para más detalles.

Para que nuestro dispositivo MultiPort exponga puertos individuales a Alexa, necesitamos configurar las Variables de Estado, también en la página de edición del dispositivo.

PortCount indica el número de puertos; luego «Port-1»..«Port-n» dan los nombres que Alexa usará. Cualquier puerto sin nombre se ignora. Puedes cambiar fácilmente el nombre del puerto aquí y volver a ejecutar el descubrimiento para actualizar Alexa.

Durante el descubrimiento, la skill también busca un campo etiquetado, nombrado o etiquetado «powerState», o «powerState-port-n» según corresponda. Si se encuentra, se asigna como capacidad soportada para el dispositivo (más en Informe de Estado).

Informe de estado

Durante la fase de descubrimiento le dijimos a Alexa qué capacidades tiene nuestro dispositivo; la skill por defecto le dice a Alexa que pueden solicitarse, así que Alexa enviará una petición StateReport para obtener los valores.

Nos queda un último conjunto de etiquetas para aplicar, esta vez a los campos del dispositivo. Una vez que tu dispositivo envía datos (ese mensaje senml que se empuja por MQTT en el código de Arduino), Tinamous crea campos para el dispositivo. Podemos usar la opción Avanzada desde la lista de campos para editar esto. Usar la opción de etiqueta es lo más versátil, ya que no necesitamos acertar con el nombre del campo en el firmware ni quedarnos atascados si queremos renombrarlo.

Si no se encuentran los campos específicos de puerto, Alexa recurrirá al campo no específico (aquí llamado powerState).

Control de energía

Nuestro dispositivo no serviría en Alexa sin esto. Alexa enviará dos directivas a nuestra Skill: «TurnOn» y «TurnOff». El punto de entrada principal de la skill busca primero el namespace (Alexa.PowerController) y luego pasa el trabajo a la clase controladora apropiada (PowerController.cs).

La skill simplemente publica un mensaje de Estado en la línea de tiempo de Tinamous.

Por ejemplo:

@UsbSwitch Turn On

o

@UsbSwitch Turn On port-1

Las otras interfaces soportadas se manejan de forma casi idéntica. Luego depende de nuestro dispositivo vigilar ese mensaje de estado y realizar una acción. Alexa puede leer el estado usando StateReport.

Así funciona la skill. Ahora solo queda subirla a AWS Lambda y crear una entrada de Skill en la consola de Alexa para dar acceso a Alexa.

Crear la función AWS Lambda

Usé las herramientas de AWS dentro de Visual Studio para subir la skill compilada a Lambda. Pero primero necesitamos crear la Lambda.

Consejo pro: Crea la Lambda en la región AWS apropiada para el idioma que soportas. Inglés (UK) necesita eu-west (Irlanda).

Crea una nueva función Lambda desde cero. Los blueprints existentes son limitados y obsoletos (solo soportan V2 de la interfaz SmartHome, muy diferente y deprecada; usamos V3).

Necesitarás crear un nuevo rol que permita a la Lambda acceder a los recursos que necesita. Aquí seleccionamos Simple Microservices como predeterminado (en realidad da mucho más de lo que necesitamos). Si ves que no llegan logs a CloudWatch, puede que también necesites dar permisos para eso en la sección IAM.

Luego publicamos los binarios desde Visual Studio. Con las herramientas AWS instaladas, clic derecho en el proyecto y selecciona «Publicar en AWS Lambda...»

Rellena los detalles de la expresión Lambda y pulsa Subir...

Una vez subida, podemos ejecutar tests en la Lambda para asegurar que funciona. Luego «Publicar nueva versión» desde el desplegable Acciones.

Una vez publicada, necesitamos dar a nuestra Skill permisos para acceder a ella. Clic en el disparador «Alexa Smart Home» e introduce el skill id (aún no lo tenemos...).

Crear la Skill en la consola de Alexa

Con nuestra Lambda casi lista, vamos a la consola de desarrollador de skills y creamos una entrada. Abre https://developer.amazon.com, selecciona Alexa Skills Kit y añade una nueva Skill.

Selecciona Smart Home Skill API, el idioma (p.ej. English (UK) para UK) y versión de payload V3 (preferida).

En la página de Configuración entramos en detalles. Introduce el ARN de Lambda de nuestra versión (arriba a la derecha). Debe terminar en :1, :2 o :5246 (si has tenido muchos intentos).

En Lambda también pegamos el «Application ID» o «Skill ID» de la skill; algo como amzn1.ask.skill.2_______________50. Asegúrate de guardar tras añadir el Application ID.

Para habilitar la vinculación de cuenta necesitamos una aplicación OAuth creada en Tinamous, usando el Bot Alexa. Ve a la página Bots de tu cuenta Tinamous y añade un Alexa Bot. Una vez creado, el diálogo te dará todos los detalles para configurar la vinculación de cuenta.

Nota: Si usas la (próximamente publicada) Skill Tinamous SmartHome, no necesitas un Alexa Bot.

La aplicación creada por el bot permitirá a cualquier titular de cuenta Tinamous usar tu skill y vincular su cuenta. Naturalmente no tienes que publicar tu skill y puedes mantenerla privada; no podrán ver nada en tu cuenta Tinamous.

Si usas otra nube de dispositivos (¿en serio, por qué lo harías? ;-) ), tendrás que introducir sus detalles de aplicación OAuth.

En la página Test, asegúrate de que tu skill esté en «Sí» para «Mostrar esta skill en la Alexa App».

Guarda y ve a alexa.amazon.co.uk (o la de tu región), o aparentemente hay una app también...

Clic en «Skills», arriba a la derecha «Tus Skills», luego «DEV SKILLS»; deberías ver tu skill con un marcador verde indicando que es una skill de desarrollo.

El «Alexa, apaga la luz USB» y la información adicional al seleccionarla se configura en la página «Información de publicación»; puedes introducir la info durante el desarrollo sin publicar totalmente.

Si necesitas actualizar el código de la skill, sube la nueva función Lambda, crea una nueva versión, vuelve a añadir el disparador SmartHome y Skill ID, luego pega el ARN de la Lambda versionada en la consola de la skill (podrías usar una Lambda no versionada, pero no funcionó cuando lo intenté, aunque en ese momento tenía muchas otras cosas mal).

¡Éxito!

Con nuestro código de skill corriendo en Lambda y la Skill instalada en nuestra cuenta Alexa, podemos ejecutar el descubrimiento y empezar a controlar los dispositivos.

Puedes ir a los logs de CloudWatch para ver la información escrita por tu skill.

Depuración de la Skill y consejos

Alexa proporciona casi ninguna retroalimentación al desarrollador cuando fallan las cosas; puedes pasar edades adivinando por qué Alexa no hace lo que esperabas.

• Evita casi todo lo que no sea alfanumérico en tus endpointIDs (usé * en una etapa y todo se rompió, pero no de forma obvia; sin embargo # funcionó. ¡A ver!).
• Registra todo. Comprueba logs al invocar tu skill. Sin logs probablemente es autenticación, o tu skill no está autorizada para la expresión Lambda.
• Usa cuentas de email AWS y Alexa coincidentes.
• Mantén la Lambda en la misma región que la skill (Irlanda para skills UK).
• Si tu skill se invoca pero Alexa no responde (p.ej. no lista dispositivos), tu formato de respuesta probablemente es incorrecto.
• Si no quieres usar tu cuenta Alexa diaria, puedes usar Amazon Households para añadir una segunda cuenta de adulto. Ojo: parece limitado a 2 adultos y no se puede cambiar sin un retraso épico.
• Puedes decir «Alexa, Cambiar Perfil» para alternar entre tu perfil de desarrollador y el normal.
• Espero que con el rediseño de la consola Alexa haya mejor información de depuración. Ahora solo veo cajas más grandes y un poco mejor validación. Algunos logs están disponibles pero son solo logs de éxito, métricas de bienestar a nivel directivo, y con 36 horas de retraso, ¡no ayuda para depurar!

Una Skill, ¡Cualquier (IoT) Cosa!

Con la Skill Tinamous SmartHome, mientras tu «cosa» (Internet de las Cosas) pueda conectarse al servidor MQTT de Tinamous (o esté conectada vía un bot soportado), añadir control SmartHome de Alexa a tu cosa es simplemente unas líneas de código para manejar mensajes como «Turn On», «Turn Off», «Set brightness 20». Solo añade las etiquetas en Tinamous, y...

«Alexa, descubre dispositivos de Smart Home».

Código

• AlexaUsbSwitcher.ino
• TinamousMQTTClient.ino
• UsbControl.ino
• WiFiClient.ino
• Secrets.h

AlexaUsbSwitcher.ino (principal)

#include <MQTTClient.h>
#include <system.h>
#include <WiFi101.h>
#include <Adafruit_INA219.h>
#include "Secrets.h"

// ================================
// 4 Port board.
#define MAX_USB_PORTS 4
int led_pin[MAX_USB_PORTS][2] = {{14, 14}, {13,13}, {7,7}, {6,6}};
int switch_pin[] = {A0, A1, A2, A3};
int usb_enable_pin[] = {5, 4, 1, 3};
int usb_fault_pin[] = {2, 2, 2, 2};
bool usb_port_state[] = {false, false, false, false};
int usb_power_mode[] = {1, 0, 0, 0};

// Automatización
unsigned long usb_power_switch_on_at[] = {0, 0, 0, 0};
unsigned long usb_power_switch_off_at[] = {1, 1, 1, 1};

Adafruit_INA219 ina219;
bool has_usb_fault = false;
float shunt_voltage = 0, bus_voltage = 0, current_mA = 0, load_voltage = 0, power_mW = 0;
float max_current_mA = 0, max_busvoltage = 0, min_busvoltage = 20;
unsigned long last_measurement_time = 0;
bool power_failed = false, over_current = false;

int update_interval_seconds = 20;
unsigned long next_message_send_at = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  for (int ch=0; ch MAX_USB_PORTS) return;
  SetLeds(stage-1, true, true);
}

void loop() {
  if (!hasPoweredPorts()) digitalWrite(LED_BUILTIN, LOW);
  bool faulted = false;
  for (int ch=0; ch

TinamousMQTTClient.ino (conectividad MQTT)

#include <MQTTClient.h>
#include <system.h>
#include "secrets.h"

WiFiSSLClient networkClient;
MQTTClient mqttClient(4096);
bool was_connected = false;
String senml = "";
unsigned long nextSendMeasurementsAt = 0;

bool setupMqtt() {
  senml.reserve(4096);
  Serial.print("Conectando a Tinamous MQTT en puerto: "); Serial.println(MQTT_SERVERPORT);
  Serial.print("Servidor: "); Serial.println(MQTT_SERVER);
  mqttClient.begin(MQTT_SERVER, MQTT_SERVERPORT, networkClient);
  mqttClient.onMessage(messageReceived);
  connectToMqttServer();
}

bool connectToMqttServer() {
  if (mqttClient.connected()) return true;
  Serial.println("Reconectando..."); Serial.println("Comprobando WiFi...");
  if (WiFi.status() != WL_CONNECTED) {
    Serial.print("WiFi no conectado. Estado: "); Serial.println(WiFi.status(), HEX);
    delay(10000); return false;
  }
  Serial.println("Conectando a servidor MQTT...");
  if (!mqttClient.connect(MQTT_CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) {
    Serial.println("Falló conexión MQTT.");
    Serial.print("Error: "); Serial.print(mqttClient.lastError());
    Serial.print(", Return Code: "); Serial.println(mqttClient.returnCode());
    if (mqttClient.lastError() == LWMQTT_CONNECTION_DENIED)
      Serial.println("Acceso denegado. Comprueba usuario y contraseña. Usuario debe ser 'Dispositivo.Cuenta' p.ej. MiSensor.MiCasa");
    if (mqttClient.lastError() == -6)
      Serial.println("Comprueba que el Arduino tiene el certificado SSL cargado para Tinmaous.com");
    delay(10000); return false;
  }
  Serial.println("¡Conectado a Tinamous MQTT!");
  mqttClient.subscribe("/Tinamous/V1/Status.To/" DEVICE_USERNAME);
  Serial.println("Suscrito a status.to topic.");
  publishTinamousStatus("¡Hola! Interruptor USB conectado. Mencióname con help para ayuda.");
  was_connected = true; return true;
}

void mqttLoop() {
  connectToMqttServer();
  mqttClient.loop();
}

void publishTinamousStatus(String msg) {
  Serial.println("Status: " + msg);
  mqttClient.publish("/Tinamous/V1/Status", msg);
}

void publishTinamousSenMLMeasurements(String senml) {
  Serial.println("SenML Measurement: " + senml);
  mqttClient.publish("/Tinamous/V1/Measurements/SenML", senml);
  if (mqttClient.lastError() != 0) {
    Serial.print("MQTT Error: "); Serial.println(mqttClient.lastError());
  }
  Serial.println("Hecho.");
}

void messageReceived(String &topic, String &payload) {
  Serial.println("Mensaje de Tinamous en topic: " + topic + " - " + payload);
  if (payload.startsWith("@")) {
    payload.toLowerCase();
    if (handleStatusMessage(payload)) {
      Serial.println("@ me status message handled.");
      return;
    }
  }
  publishTinamousStatus("¡Hola! No entendí el mensaje. Mencióname con help para ayuda.");
}

bool handleStatusMessage(String payload) {
  char buffer[25];
  for (int port=0; port 0) {
      Serial.print("Encender puerto "); Serial.println(port);
      setUsb(port, true); return true;
    }
    sprintf(buffer, "turn off port-%d", port+1);
    if (payload.indexOf(buffer) > 0) {
      Serial.print("Apagar puerto "); Serial.println(port);
      setUsb(port, false); return true;
    }
  }
  if (payload.indexOf("turn on") > 0) { allOn(); return true; }
  if (payload.indexOf("turn off") > 0) { allOff(); return true; }
  if (payload.indexOf("help") > 0) {
    Serial.println("Enviando ayuda...");
    publishTinamousStatus("Envía un mensaje a mí (@" DEVICE_USERNAME ") luego: 'Turn on Port-1' para encender puerto 1, 'Turn off Port-1' para apagar puerto 1, 'Turn on' para encender todos, 'Turn off' para apagar todos. * Puerto puede ser 1, 2, 3 o 4.");
    return true;
  }
  Serial.print("Mensaje de estado desconocido: "); Serial.println(payload);
  return false;
}

UsbControl.ino (control de puertos USB)

bool hasPoweredPorts() {
  for (int ch=0; ch

WiFiClient.ino (conexión WiFi)

#include "Secrets.h"
char ssid[] = SECRET_SSID;
char pass[] = SECRET_PASS;
int status = WL_IDLE_STATUS;

void setupWiFi() {
  Serial.println("Conectando a WiFi...");
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("Escudo WiFi no presente"); while(true);
  }
  while (status != WL_CONNECTED) {
    Serial.print("Intentando conectar a WPA SSID: "); Serial.println(ssid);
    status = WiFi.begin(ssid, pass);
    delay(10000);
  }
  Serial.println("Conectado a la red");
  printCurrentNet(); printWiFiData();
}

void printWiFiData() {
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: "); Serial.println(ip);
  byte mac[6]; WiFi.macAddress(mac);
  Serial.print("MAC: ");
  for(int i=5;i>=0;i--) { Serial.print(mac[i],HEX); if(i) Serial.print(":"); }
  Serial.println();
}

void printCurrentNet() {
  Serial.print("SSID: "); Serial.println(WiFi.SSID());
  byte bssid[6]; WiFi.BSSID(bssid);
  Serial.print("BSSID: ");
  for(int i=5;i>=0;i--) { Serial.print(bssid[i],HEX); if(i) Serial.print(":"); }
  Serial.println();
  long rssi = WiFi.RSSI(); Serial.print("RSSI: "); Serial.println(rssi);
  byte enc = WiFi.encryptionType(); Serial.print("Encryption: "); Serial.println(enc,HEX);
}

Secrets.h (configuración personal)

#define SECRET_SSID "<Tu punto de acceso WiFi>"
#define SECRET_PASS "<Tu contraseña WiFi>"
#define MQTT_SERVER "<Tu nombre de cuenta>.tinamous.com"
#define MQTT_SERVERPORT 8883
#define MQTT_USERNAME "<Usuario dispositivo>.<Tu nombre de cuenta>"
#define MQTT_PASSWORD "La contraseña del dispositivo"
#define MQTT_CLIENT_ID "Un ID de cliente aleatorio"
#define DEVICE_USERNAME "<Usuario dispositivo>"

Partes personalizadas y recintos

Esta es la mejor opción si no sabes cómo conectar. Tiene agujeros para el Arduino, bloque de terminales y USB micro adicional. Esta es la versión con todos los conectores, pero no incluye las primeras capas de texto que algunas impresoras pueden tener dificultades. Esta es la versión más simple y rápida de imprimir.

Esquemáticos

Envíalo a OSHPark o DirtyPCBs para fabricar el tuyo.

arduinostandaloneusbswitch-4port_q16AoF01Aq.brd
arduinostandaloneusbswitch-v2_Xd45dtjndI.sch

Repositorio GitHub USB Power Switcher

Busca: carpeta Arduino/StandAlone/ y la versión de 4 puertos.
https://github.com/ThingySticks/USBPowerSwitcher

Jukebox Moderna: Reproductor Musical Raspberry Pi + Arduino con LEDs Reactivos Programación OTA Arduino MKR con Control por Voz y Extras