Metti in pausa Chromcast con un telecomando: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Ho un telecomando Harmony Logitech ed eseguo Home Assistant su un Raspberry Pi.

Volevo essere in grado di mettere in pausa Chromecast dal mio telecomando, ma ho un vecchio televisore che non lo supporta tramite hdmi. La mia idea era quindi quella di utilizzare un NodeMcu per catturare il segnale ir e mettere in pausa.

Se non riesci a farlo funzionare o hai domande, commenta qui sotto

Passaggio 1: attrezzatura

Attrezzature necessarie:

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

Ricevitore Ir (come ad esempio questo:

fili dupont

Cavo micro usb (alimentazione nodemcu)

Uso Logitech Harmony -hub

Per il mio approccio, hai bisogno di un Raspberry pi con hass.io installato e Nodered. Se usi qualcosa di diverso dall'assistente domestico, devi adattare le cose da solo.

Devi essere in grado di usare Nodemcu su Arduino IDE perché non lo approfondirò qui

Passaggio 2: segnale remoto

Il modo in cui l'ho fatto è stato copiare un segnale da un telecomando che non uso nel telecomando Harmony.

Ho usato un telecomando per la tv panasonic modello TXL32C3E in quanto non interferisce con la mia attrezzatura al primo piano. Quella è una tv che ho al piano di sopra.

Se non usi l'armonia puoi saltare questo.

Quindi per trovare il segnale ho usato questo scetch:

/* * IRremoteESP8266: IRrecvDumpV2 - dump dettagli dei codici IR con IRrecv * All'ingresso RECV_PIN deve essere collegato un rilevatore/demodulatore IR. * * Copyright 2009 Ken Shirriff, https://arcfn.com * Copyright 2017 David Conran * * Schema elettrico di esempio: * https://arcfn.com * * Modifiche: * Versione 0.3 novembre 2017 * - Supporto per A/C decodifica per alcuni protocolli. * Versione 0.2 aprile 2017 * - Decodifica da una copia dei dati in modo da poter iniziare a catturare più velocemente in modo * ridurre la probabilità di catture errate. * Basato su IrsendDemo versione 0.1 luglio 2009, di Ken Shirriff, */

#ifndef UNIT_TEST

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

// ===================== inizio PARAMETRI TUNEABLE ====================

// Un rilevatore/demodulatore IR è collegato al pin 14 GPIO // ad es. D5 su una scheda NodeMCU. #define RECV_PIN 14

// La velocità di trasmissione della connessione seriale.

// vale a dire che il messaggio di stato verrà inviato al PC a questa velocità di trasmissione. // Cerca di evitare velocità lente come 9600, poiché perderai messaggi e // causerai altri problemi. Si consiglia 115200 (o più veloce). // NOTA: assicurati di impostare il monitor seriale alla stessa velocità. #define BAUD_RATE 115200

// Poiché questo programma è un cattura/decodificatore per scopi speciali, usiamo un più grande

// rispetto al normale buffer in modo da poter gestire i codici remoti del condizionatore d'aria. #define CAPTURE_BUFFER_SIZE 1024

// TIMEOUT è il nr. di millisecondi di non più dati prima di considerare a

// messaggio terminato. // Questo parametro è un interessante compromesso. Più lungo è il timeout, più // complesso è il messaggio che può catturare. per esempio. Alcuni protocolli del dispositivo invieranno // più pacchetti di messaggi in rapida successione, come i telecomandi dei condizionatori d'aria. // I protocolli Air Conditioner hanno spesso un gap considerevole (20-40+ms) tra // i pacchetti. // Lo svantaggio di un grande valore di timeout è che molti protocolli meno complessi // inviano più messaggi quando si tiene premuto il pulsante del telecomando. Il divario tra // di essi è spesso anche di circa 20+ms. Ciò può comportare che i dati grezzi siano 2-3+ // volte più grandi del necessario poiché ha catturato 2-3+ messaggi in un'unica // cattura. L'impostazione di un valore di timeout basso può risolvere questo problema. // Quindi, la scelta del miglior valore di TIMEOUT per il tuo caso particolare è // piuttosto sfumata. Buona fortuna e buona caccia. // NOTA: non superare MAX_TIMEOUT_MS. In genere 130 ms. #if DECODE_AC #define TIMEOUT 50U // Alcune unità A/C hanno lacune nei loro protocolli di ~40ms. // per esempio. Kelvinator // Un valore così grande può inghiottire le ripetizioni di alcuni protocolli #else // DECODE_AC #define TIMEOUT 15U // Si adatta alla maggior parte dei messaggi, pur non ingoiando molte ripetizioni. #endif // DECODE_AC // Alternative: // #define TIMEOUT 90U // Si adatta a messaggi con grandi spazi vuoti come XMP-1 e alcune unità di aria condizionata //, ma può accidentalmente ingoiare messaggi ripetuti // nell'output rawData. // #define TIMEOUT MAX_TIMEOUT_MS // Questo lo imposterà al nostro // massimo attualmente consentito. Valori così alti sono problematici // perché è all'incirca il limite tipico // dove si ripete la maggior parte dei messaggi. // per esempio. Smetterà di decodificare un messaggio e // inizierà a inviarlo a seriale esattamente // all'ora in cui è probabile che // venga trasmesso il messaggio successivo, e potrebbe non vederlo.

// Imposta i pacchetti di messaggi "SCONOSCIUTI" di dimensioni più piccole che ci interessano effettivamente.

// Questo valore aiuta a ridurre il tasso di rilevamento di falsi positivi del rumore di fondo IR // come messaggi reali. Le possibilità che venga rilevato rumore IR di sottofondo // come messaggio aumenta con la lunghezza del valore TIMEOUT. (Vedi sopra) // Lo svantaggio di impostare questo messaggio troppo grande è che puoi perdere alcuni // messaggi brevi validi per i protocolli che questa libreria non decodifica ancora. // // Imposta più alto se ricevi molti brevi messaggi SCONOSCIUTI casuali quando nulla // dovrebbe inviare un messaggio. // Imposta più basso se sei sicuro che la tua configurazione funzioni, ma non vede i messaggi // dal tuo dispositivo. (ad es. Altri telecomandi IR funzionano.) // NOTA: impostare questo valore molto alto per disattivare efficacemente il rilevamento SCONOSCIUTO. #define MIN_UNKNOWN_SIZE 12 // ==================== fine dei PARAMETRI TUNEABLE ====================

// Utilizza la funzione di attivazione del buffer di salvataggio per una copertura di acquisizione più completa.

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

decode_results risultati; // Da qualche parte per memorizzare i risultati

// Visualizza lo stato leggibile dall'uomo di un messaggio A/C, se possibile.

void dumpACInfo(decode_results *results) { Descrizione stringa = ""; #if DECODE_DAIKIN if (risultati->decode_type == DAIKIN) { IRDaikinESP ac(0); ac.setRaw(risultati->stato); descrizione = ac.toString(); } #endif // DECODE_DAIKIN #if DECODE_FUJITSU_AC if (risultati->decode_type == FUJITSU_AC) { IRFujitsuAC ac(0); ac.setRaw(risultati->stato, risultati->bit / 8); descrizione = ac.toString(); } #endif // DECODE_FUJITSU_AC #if DECODE_KELVINATOR if (risultati->decode_type == KELVINATOR) { IRKelvinatorAC ac(0); ac.setRaw(risultati->stato); descrizione = ac.toString(); } #endif // DECODE_KELVINATOR #if DECODE_TOSHIBA_AC if (risultati->decode_type == TOSHIBA_AC) { IRToshibaAC ac(0); ac.setRaw(risultati->stato); descrizione = ac.toString(); } #endif // DECODE_TOSHIBA_AC #if DECODE_MIDEA if (risultati->decode_type == MIDEA) { IRMideaAC ac(0); ac.setRaw(risultati->valore); // Midea usa value invece di state. descrizione = ac.toString(); } #endif // DECODE_MIDEA // Se abbiamo una descrizione leggibile del messaggio, mostrala. if (descrizione != "") Serial.println("Mesg Desc.: " + descrizione); }

// La sezione di codice viene eseguita solo una volta all'avvio.

void setup() { Serial.begin(BAUD_RATE, SERIAL_8N1, SERIAL_TX_ONLY); ritardo (500); // Attendi un po' che venga stabilita la connessione seriale.

#if DECODE_HASH

// Ignora i messaggi con impulsi di attivazione o disattivazione inferiori al minimo. irrecv.setUnknownThreshold(MIN_UNKNOWN_SIZE); #endif // DECODE_HASH irrecv.enableIRIn(); // Avvia il ricevitore }

// La sezione ripetuta del codice

// void loop() { // Controlla se il codice IR è stato ricevuto. if (irrecv.decode(&results)) { // Visualizza un timestamp grezzo. uint32_t ora = millis(); Serial.printf("Timestamp: %06u.%03u\n", ora / 1000, ora % 1000); if (results.overflow) Serial.printf("ATTENZIONE: il codice IR è troppo grande per il buffer (>= %d). " "Questo risultato non dovrebbe essere considerato attendibile finché non viene risolto. " "Modifica e aumenta CAPTURE_BUFFER_SIZE.\n ", CAPTURE_BUFFER_SIZE); // Visualizza l'output di base di ciò che abbiamo trovato. Serial.print(resultToHumanReadableBasic(&results)); dumpACInfo(&results); // Mostra qualsiasi informazione aggiuntiva sull'aria condizionata se ce l'abbiamo. prodotto(); // Alimenta il WDT poiché l'output di testo può richiedere del tempo per la stampa.

// Visualizza la versione della libreria con cui è stato acquisito il messaggio.

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

// Emette informazioni sui tempi RAW del risultato.

Serial.println(resultToTimingInfo(&results)); prodotto(); // Alimenta il WDT (di nuovo)

// Visualizza i risultati come codice sorgente

Serial.println(resultToSourceCode(&results)); Serial.println(""); // Riga vuota tra le voci yield(); // Alimenta il WDT (di nuovo) } }

Quando questo scetch viene caricato e in esecuzione con il monitor seriale aperto, verrà visualizzato il codice per la pressione del pulsante (vedi immagine)

Annotare i codici che si desidera utilizzare per un uso successivo. Ho usato excel per annotare ciò che ho ottenuto per i pulsanti che volevo usare (vedi foto)

Ho modificato i pulsanti nella mia attività Netflix per inviare segnale di pausa dal telecomando panasonic.. (vedi foto)

Passaggio 3: scrittura del codice per l'invio a Nodered

#ifndef UNIT_TEST#include #endif #include

#includere

#includere

#includere

#includere

#includere

const char* ssid = ""; // Inserisci SSID quiconst char* password = ""; //Inserisci qui la password const char *host = ""; //Indirizzo IP #define USE_SERIAL Seriale ESP8266WiFiMulti WiFiMulti; uint16_t RECV_PIN = 14; IRrecv irrecv(RECV_PIN); decode_results risultati; void setup() { irrecv.enableIRIn(); // Avvia il ricevitore USE_SERIAL.begin(115200); // USE_SERIAL.setDebugOutput(true); USE_SERIAL.println(); USE_SERIAL.println(); USE_SERIAL.println();

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

USE_SERIAL.printf("[SETUP] WAIT %d…\n", t); USE_SERIAL.flush(); ritardo(1000); } WiFi.mode(WIFI_STA); WiFiMulti.addAP(ssid, password); } void loop() { if (irrecv.decode(&results)) {

// Cambia questo valore di segnale per quello che hai

if (results.value == 0x40040D00606D){ USE_SERIAL.println("Pausa Segnale ricevuto"); wifisend(pausa); ritardo(1000);

} if (risultati.valore == 0x400401007273){

USE_SERIAL.println("precedente");

wifisend("precedente"); ritardo(1000); } if (results.value == 0x40040100F2F3){ USE_SERIAL.println("successivo"); wifisend("successivo"); ritardo(1000); }

irrecv.resume(); // Riceve il valore successivo } delay(100); } void wifisend(String data){ if((WiFiMulti.run() == WL_CONNECTED)) { HTTPClient http; USE_SERIAL.print("[HTTP] inizia…\n"); // configura il server traged e l'URL http.begin("https://[user]:[pass]@[ip]:[port]/chromecastpause?data=" + data); USE_SERIAL.print("[HTTP] GET…\n"); // avvia la connessione e invia l'intestazione HTTP int httpCode = http. GET(); // httpCode sarà negativo in caso di errore if(httpCode > 0) { // L'intestazione HTTP è stata inviata e l'intestazione della risposta del server è stata gestita USE_SERIAL.printf("[HTTP] GET… code: %d\n", // file trovato sul server

if(httpCode == HTTP_CODE_OK) { Stringa payload = http.getString(); USE_SERIAL.println(carico utile); } } else { USE_SERIAL.printf("[HTTP] GET… fallito, errore: %s\n", http.errorToString(httpCode).c_str()); } http.end(); ritardo(100); } }

Questo è il codice che ho usato sul mio nodemcu. Avrai bisogno di avere quelle librerie installate.

Puoi testare usando il monitor seriale e premere i pulsanti remoti che hai aggiunto nel codice per vedere la risposta..

In linea:

http.begin("https://[utente]:[pass]@[ip]:[porta]/chromecastpause?data=" + dati);

Devi cambiare [utente] con il tuo utente e così via. SENZA parentesi. le parentesi sono lì per mostrare i campi delle streghe da cambiare.

Anche quella linea non funzionerà finché non impostiamo il nostro flusso in nodered.

Passaggio 4: creazione di un flusso in Nodered

Come accennato all'inizio, utilizzo hass.io con nodered. Se esegui una configurazione diversa, dovrai renderla diversa! Puoi vedere nell'immagine che quando viene premuto un pulsante viene mostrato nella finestra di debug …

Il nodo del payload di modifica probabilmente avrebbe potuto essere saltato se avessi scelto qualcosa di diverso da data= nel passaggio precedente. Il nodo di commutazione che utilizzo è molto più grande della semplice pausa, ma è solo per poter aggiungere più segnali ir per utilizzare Chromecast per le stazioni radio ecc.

Per mettere in pausa solo la riproduzione puoi usare il flusso nell'altra immagine.

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

Ho rimosso il nome userpass e l'URL da questo, quindi potrebbe essere necessario modificarlo.

aggiungi un nodo di commutazione se vuoi reagire a qualcosa di più della semplice pausa (vedi l'immagine per esempio)

Nel nodo dell'assistente domestico per l'uso in pausa:

name: play pause chromecastdomain: media_playerService: media_play_pausedata: { "entity_id": "media_player.[il tuo chromecast qui]" }

per la traccia successiva basta copiare quel nodo e modificare il servizio in: media_next_track e nome in: prossimo chromecast

Passaggio 5: Alexa opzionale mette in pausa Chromecast

Comando aggiungi Alexa opzionale per mettere in pausa Chromecast:

Ci sono opzioni qui.. Puoi creare un nnodo di Alexa chiamato pause chromecast che mette in pausa Chromecast, oppure puoi crearne uno chiamato pause tv che controlla l'attuale attività di armonia e mette in pausa a seconda di ciò.

Lo aggiungo qui più tardi..