Pausar Chromcast con un control remoto: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Tengo un control remoto Logitech Harmony y ejecuto Home Assistant en una frambuesa pi.

Quería poder pausar Chromecast desde mi control remoto, pero tengo un televisor antiguo que no admite esto a través de hdmi. Entonces, mi idea fue utilizar un NodeMcu para captar la señal de infrarrojos y hacer una pausa.

Si no puede hacer que funcione o tiene preguntas, por favor comente a continuación.

Paso 1: equipamiento

Equipo necesario:

Nodemcu (https://www.ebay.com/sch/i.html?_from=R40&_trksid=…

Receptor de infrarrojos (como este:

alambres dupont

Cable micro usb (alimentación nodemcu)

Yo uso Logitech Harmony -hub

Para mi enfoque, necesita una Raspberry pi con hass.io instalado y Nodered. No entraré en la configuración del asistente de hogar aquí. Si usa algo que no sea un asistente de hogar, debe adaptar las cosas usted mismo.

Debe poder usar Nodemcu en Arduino IDE, ya que no entraré en eso aquí

Paso 2: señal remota

La forma en que lo hice fue copiar una señal de un control remoto que no uso en un control remoto de armonía.

Utilicé un control remoto para panasonic tv modelo TXL32C3E ya que no interfiere con mi equipo en mi primer piso. Esa es una televisión que tengo arriba.

Si no usa la armonía, puede omitir esto.

Entonces, para encontrar la señal, utilicé este scetch:

/ * * IRremoteESP8266: IRrecvDumpV2 - detalles de volcado de códigos IR con IRrecv * Debe conectarse un detector / demodulador IR a la entrada RECV_PIN. * * Copyright 2009 Ken Shirriff, https://arcfn.com * Copyright 2017 David Conran * * Ejemplo de diagrama de circuito: * https://arcfn.com * * Cambios: * Versión 0.3 de noviembre de 2017 * - Soporte para A / C decodificación para algunos protocolos. * Versión 0.2 de abril de 2017 *: decodifique a partir de una copia de los datos para que podamos comenzar a capturar más rápido y así * reducir la probabilidad de capturas erróneas. * Basado en IrsendDemo Version 0.1 de Ken Shirriff, julio de 2009, * /

#ifndef UNIT_TEST

#include #endif #include #include #include #if DECODE_AC #include #include #include #include #include #endif // DECODE_AC

// ==================== inicio de PARÁMETROS SINTONIZABLES ====================

// Un detector / demodulador de infrarrojos está conectado al pin GPIO 14 // p. Ej. D5 en una placa NodeMCU. #define RECV_PIN 14

// La velocidad en baudios de la conexión serial.

// es decir, el mensaje de estado se enviará a la PC a esta velocidad en baudios. // Trate de evitar velocidades lentas como 9600, ya que perderá mensajes y // causará otros problemas. Se recomienda 115200 (o más rápido). // NOTA: asegúrese de configurar su monitor serial a la misma velocidad. #define BAUD_RATE 115200

// Como este programa es un decodificador / capturador de propósito especial, usemos un

// que el búfer normal para que podamos manejar los códigos remotos del aire acondicionado. #define CAPTURE_BUFFER_SIZE 1024

// TIMEOUT es el Nr. de milisegundos de no-más-datos antes de que consideremos un

// mensaje terminado. // Este parámetro es una compensación interesante. Cuanto mayor sea el tiempo de espera, más // complejo será el mensaje que pueda capturar. p.ej. Algunos protocolos de dispositivo enviarán // varios paquetes de mensajes en rápida sucesión, como los controles remotos de aire acondicionado. // Los protocolos de Air Coniditioner suelen tener una brecha considerable (20-40 + ms) entre // paquetes. // La desventaja de un valor de tiempo de espera grande es que muchos protocolos menos complejos // envían varios mensajes cuando se mantiene presionado el botón del control remoto. La brecha entre // ellos también suele ser de alrededor de 20 + ms. Esto puede resultar en que los datos sin procesar sean 2-3 + // veces más grandes de lo necesario, ya que han capturado 2-3 + mensajes en una sola // captura. Establecer un valor de tiempo de espera bajo puede resolver esto. // Entonces, elegir el mejor valor de TIMEOUT para su caso particular de uso // es bastante matizado. Buena suerte y feliz caza. // NOTA: No exceda MAX_TIMEOUT_MS. Normalmente 130 ms. #if DECODE_AC #define TIMEOUT 50U // Algunas unidades de A / C tienen brechas en sus protocolos de ~ 40ms. // p.ej. Kelvinator // Un valor tan grande puede absorber las repeticiones de algunos protocolos #else // DECODE_AC #define TIMEOUT 15U // Se adapta a la mayoría de los mensajes, aunque no se traga muchas repeticiones. #endif // DECODE_AC // Alternativas: // #define TIMEOUT 90U // Se adapta a mensajes con grandes espacios como XMP-1 y algunas unidades // de aire acondicionado, pero puede tragarse accidentalmente mensajes repetidos // en la salida rawData . // #define TIMEOUT MAX_TIMEOUT_MS // Esto lo establecerá en nuestro // máximo permitido actualmente. Valores tan altos son problemáticos // porque es aproximadamente el límite típico // donde se repiten la mayoría de los mensajes. // p.ej. Dejará de decodificar un mensaje y // comenzará a enviarlo en serie exactamente // en el momento en que es probable // que se transmita el siguiente mensaje, y es posible que lo pierda.

// Establecer los paquetes de mensajes "DESCONOCIDOS" de menor tamaño que realmente nos interesan.

// Este valor ayuda a reducir la tasa de detección de falsos positivos del ruido de fondo // IR como mensajes reales. Las posibilidades de que se detecte el ruido IR de fondo // como mensaje aumentan con la duración del valor de TIMEOUT. (Ver arriba) // La desventaja de configurar este mensaje demasiado grande es que puede perder algunos mensajes // cortos válidos para protocolos que esta biblioteca aún no decodifica. // // Establezca un valor más alto si recibe muchos mensajes DESCONOCIDOS cortos aleatorios cuando nada // debería enviar un mensaje. // Establezca un valor más bajo si está seguro de que su configuración está funcionando, pero no ve mensajes // de su dispositivo. (Por ejemplo, funcionan otros mandos a distancia por infrarrojos). // NOTA: Establezca este valor en un valor muy alto para desactivar la detección DESCONOCIDO de forma eficaz. #define MIN_UNKNOWN_SIZE 12 // ==================== fin de PARÁMETROS SINTONIZABLES ====================

// Active la función de almacenamiento en búfer para obtener una cobertura de captura más completa.

IRrecv irrecv (RECV_PIN, CAPTURE_BUFFER_SIZE, TIMEOUT, verdadero);

decode_results resultados; // En algún lugar para almacenar los resultados

// Mostrar el estado legible por humanos de un mensaje de A / C si podemos.

void dumpACInfo (decode_results * resultados) {String description = ""; #if DECODE_DAIKIN if (resultados-> decode_type == DAIKIN) {IRDaikinESP ac (0); ac.setRaw (resultados-> estado); descripción = ac.toString (); } #endif // DECODE_DAIKIN #if DECODE_FUJITSU_AC if (resultados-> decode_type == FUJITSU_AC) {IRFujitsuAC ac (0); ac.setRaw (resultados-> estado, resultados-> bits / 8); descripción = ac.toString (); } #endif // DECODE_FUJITSU_AC #if DECODE_KELVINATOR if (resultados-> decode_type == KELVINATOR) {IRKelvinatorAC ac (0); ac.setRaw (resultados-> estado); descripción = ac.toString (); } #endif // DECODE_KELVINATOR #if DECODE_TOSHIBA_AC if (resultados-> decode_type == TOSHIBA_AC) {IRToshibaAC ac (0); ac.setRaw (resultados-> estado); descripción = ac.toString (); } #endif // DECODE_TOSHIBA_AC #if DECODE_MIDEA if (resultados-> decode_type == MIDEA) {IRMideaAC ac (0); ac.setRaw (resultados-> valor); // Midea usa valor en lugar de estado. descripción = ac.toString (); } #endif // DECODE_MIDEA // Si obtuvimos una descripción del mensaje legible por humanos, muéstrela. if (descripción! = "") Serial.println ("Mesg Desc.:" + descripción); }

// La sección de código se ejecuta solo una vez al inicio.

configuración vacía () {Serial.begin (BAUD_RATE, SERIAL_8N1, SERIAL_TX_ONLY); retraso (500); // Espere un momento a que se establezca la conexión en serie.

#if DECODE_HASH

// Ignora los mensajes con menos del mínimo de pulsos de encendido o apagado. irrecv.setUnknownThreshold (MIN_UNKNOWN_SIZE); #endif // DECODE_HASH irrecv.enableIRIn (); // Iniciar el receptor}

// La sección repetida del código

// bucle void () {// Compruebe si se ha recibido el código IR. if (irrecv.decode (& results)) {// Muestra una marca de tiempo cruda. uint32_t ahora = millis (); Serial.printf ("Marca de tiempo:% 06u.% 03u / n", ahora / 1000, ahora% 1000); if (results.overflow) Serial.printf ("ADVERTENCIA: El código IR es demasiado grande para el búfer (> =% d)." "No se debe confiar en este resultado hasta que se resuelva." "Edite y aumente CAPTURE_BUFFER_SIZE. / n ", CAPTURE_BUFFER_SIZE); // Muestra la salida básica de lo que encontramos. Serial.print (resultToHumanReadableBasic (& results)); dumpACInfo (& resultados); // Mostrar cualquier información adicional de A / C si la tenemos. producir(); // Alimente el WDT ya que la salida de texto puede tardar un poco en imprimirse.

// Muestra la versión de la biblioteca con la que se capturó el mensaje.

Serial.print ("Biblioteca: v"); Serial.println (_IRREMOTEESP8266_VERSION_); Serial.println ();

// Salida de información de tiempo RAW del resultado.

Serial.println (resultToTimingInfo (y resultados)); producir(); // Alimenta al WDT (de nuevo)

// Muestra los resultados como código fuente

Serial.println (resultToSourceCode (y resultados)); Serial.println (""); // Línea en blanco entre entradas yield (); // Alimenta el WDT (de nuevo)}}

Cuando este scetch se carga y se ejecuta con el monitor en serie abierto, generará el código para presionar el botón (ver imagen)

Anote los códigos que desea utilizar para su uso posterior. Usé Excel para anotar lo que obtuve por los botones que quería usar (ver imagen)

Edité los botones en mi actividad de Netflix para enviar la señal de pausa desde el control remoto de Panasonic. (Ver imagen)

Paso 3: escribir el código para enviar a Nodered

#ifndef UNIT_TEST # include #endif #include

#incluir

#incluir

#incluir

#incluir

#incluir

const char * ssid = ""; // Ingrese SSID aquíconst char * contraseña = ""; // Ingrese la contraseña aquí const char * host = ""; // Dirección IP #define USE_SERIAL Serial ESP8266WiFiMulti WiFiMulti; uint16_t RECV_PIN = 14; IRrecv irrecv (RECV_PIN); decode_results resultados; configuración vacía () {irrecv.enableIRIn (); // Inicie el receptor USE_SERIAL.begin (115200); // USE_SERIAL.setDebugOutput (verdadero); USE_SERIAL.println (); USE_SERIAL.println (); USE_SERIAL.println ();

para (uint8_t t = 4; t> 0; t--) {

USE_SERIAL.printf ("[CONFIGURACIÓN] ESPERE% d… / n", t); USE_SERIAL.flush (); retraso (1000); } Modo WiFi (WIFI_STA); WiFiMulti.addAP (ssid, contraseña); } void loop () {if (irrecv.decode (y resultados)) {

// Cambia este valor de señal por el que tienes

if (results.value == 0x40040D00606D) {USE_SERIAL.println ("señal de pausa recibida"); wifisend (pausa); retraso (1000);

} if (results.value == 0x400401007273) {

USE_SERIAL.println ("anterior");

wifisend ("anterior"); retraso (1000); } if (results.value == 0x40040100F2F3) {USE_SERIAL.println ("siguiente"); wifisend ("siguiente"); retraso (1000); }

irrecv.resume (); // Recibe el siguiente valor} delay (100); } void wifisend (datos de cadena) {if ((WiFiMulti.run () == WL_CONNECTED)) {HTTPClient http; USE_SERIAL.print ("[HTTP] comienza … / n"); // configurar el servidor traged y la URL http.begin ("https:// [usuario]: [contraseña] @ [ip]: [puerto] / chromecastpause? data =" + data); USE_SERIAL.print ("[HTTP] OBTENER… / n"); // iniciar la conexión y enviar el encabezado HTTP int httpCode = http. GET (); // httpCode será negativo en caso de error si (httpCode> 0) {// Se ha enviado el encabezado HTTP y se ha manejado el encabezado de respuesta del servidor USE_SERIAL.printf ("[HTTP] GET… código:% d / n", // archivo encontrado en el servidor

if (httpCode == HTTP_CODE_OK) {String payload = http.getString (); USE_SERIAL.println (carga útil); }} else {USE_SERIAL.printf ("[HTTP] GET … falló, error:% s / n", http.errorToString (httpCode).c_str ()); } http.end (); retraso (100); }}

Este es el código que utilicé en mi nodemcu. Deberá tener instaladas esas bibliotecas.

Puede probar usando el monitor en serie y presionar los botones remotos que agregó en el código para ver la respuesta.

En la linea:

http.begin ("https:// [usuario]: [contraseña] @ [ip]: [puerto] / chromecastpause? data =" + data);

Necesita cambiar [usuario] a su usuario y así sucesivamente. SIN soportes. los corchetes están ahí para mostrar los campos de brujas para cambiar.

Esa línea tampoco funcionará hasta que configuremos nuestro flujo en nodado.

Paso 4: crear un flujo en Nodered

Como se mencionó al principio, uso hass.io con nodered. Si ejecuta una configuración diferente, tendrá que hacer esto diferente. Puedes ver en la imagen que cuando se presiona un botón se muestra en la ventana de depuración …

El nodo de carga útil de cambio probablemente podría haberse omitido si hubiera elegido algo diferente a data = en el paso anterior. El nodo de conmutación que uso es mucho más grande que simplemente pausar, pero eso es solo para poder agregar más señales de infrarrojos para usar Chromecast para estaciones de radio, etc.

Para simplemente reproducir pausa, puede usar el flujo en la otra imagen.

[{"id": "e6440c30.4a35a", "type": "http in", "z": "869ceb74.0275c8", "name": "", "url": "chromecastpause", "method": "get", "upload": false, "swaggerDoc": "", "x": 133, "y": 98, "cables":

Eliminé el nombre de usuario y la URL de esto, por lo que es posible que deba editarlo.

agregue un nodo de conmutación si desea reaccionar a algo más que una simple pausa (vea la imagen, por ejemplo)

En el nodo del asistente de inicio para el uso de pausa:

name: play pause chromecastdomain: media_playerService: media_play_pausedata: {"entity_id": "media_player. [tu chromecast aquí]"}

para la siguiente pista, simplemente copie ese nodo y edite el servicio en: media_next_track y el nombre en: siguiente chromecast

Paso 5: Alexa Pause Chromecast opcional

Opcional agregar comando alexa para pausar Chromecast:

Hay varias opciones aquí … Puedes hacer un nodo de alexa llamado pause chromecast que pausa chromecast, o puede hacer uno llamado pause tv que verifica la actividad armónica actual y pausa dependiendo de eso.

Agregaré esto aquí más tarde …