Hue Magic: 4 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Bem-vindos, assistentes!

Há alguns meses, criei uma pequena caixa mágica com varinha para meu filho de 3 anos. Quando ele toca a caixa com a varinha, uma luz colorida que muda começa a ser emitida da caixa. Quando ele vê uma cor de que gosta particularmente, ele pode apontar a varinha para o abajur (com uma lâmpada Philips Hue dentro), lançar um feitiço e a cor da caixa irá magicamente saltar para a lâmpada! A lâmpada e a luz da caixa de repente têm a mesma cor …

Após alguns segundos, a cor desaparece e o abajur volta ao estado anterior ao feitiço. Até que um novo feitiço seja lançado …

Etapa 1: O que você precisa para criar este projeto

Para criar este projeto, você precisará dos seguintes materiais:

• 1 (ou mais) lâmpada Philips Hue e uma Hue Bridge
• 1 microcontrolador Wemos D1 mini ou similar baseado em esp8266
• 1 (Arduino) sensor de toque (por exemplo, TTP223R)
• 1 botão momentâneo (Arduino)
• 1 capacitor 10uF
• 1 led RGB (tipo de ânodo comum)
• 5 resistores (10, 22 e 47 Ohm, 2x 10K Ohm)
• 2 PCBs de prototipagem pequenos (2x3 polegadas ou cerca de 5x7 cm devem ser grandes o suficiente)
• alguns fios (jumpers)
• um ferro de solda
• uma varinha mágica (pode ser comprada pronta em uma loja de brinquedos ou você mesmo pode fazer)
• uma pequena caixa feita de papelão ou madeira (pode ser uma caixa existente, mas você também pode construir uma caixa do zero, é claro)
• alguma fita
• alguma cola e / ou porcas e parafusos para montar os PCBs na caixa.
• opcional: papel de embrulho para a caixa

NB: Um pouco de experiência na leitura de diagramas de circuitos é útil ao passar por este instrutível. Meu diagrama não é muito complexo: se você puder diferenciar um capacitor de um resistor, provavelmente estará bem.

Alguma experiência com a programação do Arduino usando o IDE do Arduino também é útil. Em vez disso, a experiência básica deve ser suficiente, pois irei fornecer o código completo para você copiar / colar. Você precisará adaptar algumas coisas, para fazê-lo funcionar em sua configuração específica (por exemplo, suas configurações de rede e alguns detalhes de sua configuração Hue). Se isso parece um pouco intimidador, não se preocupe, vou ajudá-lo a recuperar todas as informações de que você precisa.

Etapa 2: a caixa e a varinha

Os primeiros passos são normalmente os mais difíceis, mas não neste instrutível! Para um começo fácil, você pode simplesmente comprar uma varinha mágica em uma loja de brinquedos e, para a caixa, você pode simplesmente reutilizar uma pequena caixa existente que você já está por aí. Apenas certifique-se de que a caixa não é de metal, pois isso bloqueará os sinais de wi-fi e precisamos deles para a mágica;-).

Quando você reaproveita uma caixa existente, a única coisa que você precisa fazer é fazer dois furos na parte superior da caixa: 1 pequeno orifício (tamanho 5 mm = 0,2 ") para o led RGB e um orifício maior (cerca de 12- 14 mm ou cerca de 0,5 ") para o sensor de toque.

A localização exata dos orifícios não é crítica, apenas coloque-os de acordo com seu senso estético, mas tenha algumas coisas em mente:

• Mantenha alguma distância entre os dois orifícios para garantir que os componentes que serão montados sob os orifícios (o led RGB e o sensor de toque) ocupem espaço suficiente para montagem e fiação.
• O maior orifício é para o sensor de toque. Este sensor será montado logo abaixo do orifício, de forma que possa ser tocado (e até mesmo pressionado levemente) pelo bastão. Portanto, certifique-se de que a varinha que você compra não é muito grossa!

Opcionalmente, você pode usar tinta (spray) ou papel de embrulho e plástico de cobertura para deixar sua caixa um pouco mais bonita e protegê-la de respingos de comida e mãos sujas.

Se este primeiro passo for um pouco pouco ambicioso para o seu gosto, vá em frente e crie uma caixa e uma varinha totalmente do zero! Existem vários instrumentos por aí que irão ajudá-lo a criar uma linda varinha

Seja qual for o caminho que você escolher, agora é hora de explorar o interior da caixa.

Etapa 3: o hardware interno

Use um ferro de soldar para conectar os componentes eletrônicos de acordo com o diagrama de circuito acima. Existem algumas coisas a que prestar atenção especial:

• Os fios entre o Wemos D1 Mini e o led RGB devem ser longos o suficiente para que o led RGB possa ser montado no orifício que você fez na tampa da caixa.
• A mesma conta para os fios conectados à chave momentânea e ao sensor de toque, pois eles devem ser acessíveis através do outro orifício na tampa.
• O botão do interruptor momentâneo deve ser colado na parte inferior (o lado não sensível) do sensor de toque, de forma que você possa colocar o botão de volta no interruptor momentâneo com o sensor de toque colado por cima (ver imagem). O sensor de toque é montado na parte superior do interruptor momentâneo para detectar pressionamentos de botão feitos com o dedo, caso em que o pressionamento de botão será ignorado. Somente quando o botão é pressionado pela varinha mágica (que deve ser não condutiva, então plásticos e madeira são bons), o ciclo mágico começará.
• Monte o botão momentâneo com sensor de toque na parte superior, não muito abaixo do orifício na tampa, porque ele precisa ser acessado pela varinha mágica para colocar a mágica em movimento.
• Certifique-se de observar a polaridade do capacitor ao soldá-lo. Se você inverter os terminais positivo e negativo, o capacitor provavelmente emitirá um pouco de fumaça mágica e colocará seu circuito em um sono eterno.
• Cole, prenda com fita adesiva e / ou aparafuse o suporte da bateria e o (s) PCB (s) no lugar. Não precisa ser limpo, pois não estará à vista. Deve ser apenas à prova de queda.

Para o software!

Etapa 4: o software

Certifique-se de ter o editor de software Arduino mais recente (gratuito), que pode ser baixado em https://www.arduino.cc/en/Main/Software. Para adicionar suporte para o Wemos D1 mini e outras placas baseadas em ESP8266, execute as seguintes etapas:

• Após a instalação, inicie o software Arduino e abra a janela Preferências.
• Digite https://arduino.esp8266.com/stable/package_esp8266com_index.json no campo "URLs adicionais do gerenciador de placa". Você pode adicionar vários URLs, separando-os com vírgulas.
• Abra o gerenciador de placas em Ferramentas> menu Placa e instale a plataforma esp8266 (e não se esqueça de selecionar sua placa ESP8266 em Ferramentas> menu Placa após a instalação. "LOLIN (WEMOS) D1 R2 e mini" funciona melhor para Wemos D1 mini v2 e v3 Pranchas.

Se precisar de mais ajuda para instalar o Arduino e configurar os drivers, você pode dar uma olhada em

No editor do Arduino, abra um novo arquivo (Arquivo> Novo) e copie / cole o código abaixo na janela que acabou de abrir. Basta substituir as linhas que já estão presentes na nova janela (configuração do void e loop do void).

Agora você está quase pronto, mas terá que adaptar algumas partes do código para sua configuração específica.

A primeira coisa a fazer é alterar o endereço IP na linha 34 (no editor Arduino, as linhas de código são numeradas) para o endereço IP de sua ponte Hue. Se você não souber seu endereço IP do Hue Bridge, visite https://discovery.meethue.com/ e o endereço IP correto aparecerá imediatamente no seu navegador. O endereço IP é o número pontilhado precedido por "internalipaddress".

Para se comunicar com as luzes Hue, você terá que criar um usuário Hue API para o Wemos D1 mini, para que o Wemos possa se comunicar com a luz Hue por meio da API Hue. Para fazer isso, siga as instruções em https://developers.meethue.com/develop/get-started-2/ e copie / cole o nome de usuário gerado (bastante longo) na janela de código do Arduino. Basta substituir cada "SEU NOME DE USUÁRIO DA HUE API" pelo nome de usuário da API gerado.

Então você precisa selecionar a luz matiz certa para mudar de cor. Na API Hue, cada luz tem um número, então você precisa descobrir o número que corresponde à luz que deseja usar para este projeto. Uma das maneiras mais fáceis de descobrir o número de uma luz em particular é fazer o download do aplicativo Hue Viewer para Android ou iOS. Substitua o texto "SEU NÚMERO DE LUZ" pelo número correto em qualquer lugar na janela de código do Arduino.

A última coisa a fazer é configurar o Wemos para se conectar à sua rede wi-fi. Isso é feito carregando o código para o Wemos e em seu laptop mude para outra rede wi-fi: para "AutoConnectAP". Seu navegador exibirá uma página onde você pode adicionar o SSID (nome) e a senha de sua rede wi-fi que o controlador Wemos usará para se conectar à sua rede wi-fi (e à ponte Hue).

Nota: Se o upload do código para o nosso Wemos D1 mini via USB não funcionar, pode ser necessário fazer o download de um driver para o chip USB no Wemos. Um driver para sua plataforma (Windows, Mac) pode ser baixado em

Agora você está pronto para testar sua criação!

// ESP8266 Hue Magic Wand // Richard van Kampen - 2018 // Este código foi testado em um Wemos D1 mini, mas provavelmente também funcionará em outras placas de desenvolvimento baseadas em ESP8266 // Para adicionar suporte para Wemos D1 mini e outras placas ESP8266 para o editor Arduino, siga os seguintes passos: // - Inicie o Arduino e abra a janela Preferências. // - Digite https://arduino.esp8266.com/stable/package_esp8266com_index.json no campo URLs adicionais do gerenciador de placa. Você pode adicionar vários URLs, separando-os com vírgulas. // - Abra o gerenciador de placas em Ferramentas> menu Placa e instale a plataforma esp8266 (e não se esqueça de selecionar sua placa ESP8266 em Ferramentas> menu Placa após a instalação). // bibliotecas usadas: #include "ESP8266WiFi.h" // Biblioteca WiFi principal ESP8266 #include "DNSServer.h" // Servidor DNS local usado para redirecionar todas as solicitações para o portal de configuração WiFiManager se nenhuma configuração WIFI (SSID, senha) tiver ainda não foi definido. #include "ESP8266WebServer.h" // Local WebServer usado para servir o portal de configuração WiFiManager #include "WiFiManager.h" // Biblioteca de configuração WiFi Magic, se ainda não estiver instalada, consulte https://github.com/tzapu/WiFiManager # install-through-library-manager #include "RestClient.h" // https://github.com/fabianofranca/ESP8266RestClient, necessário para usar a API Philips Hue (consulte https://developers.meethue.com/develop/ hue-api /). #include "ArduinoJson.h" // https://github.com/bblanchon/ArduinoJson, necessário para analisar a resposta da API do Hue, instale a versão 5.x por meio do gerenciador de biblioteca no Arduino (Menu "Sketch"> Incluir biblioteca> Gerenciar Bibliotecas> procure ArduinoJson e altere a versão para a versão 5.x mais recente). A versão 6 (atualmente em beta) gera um erro. // variáveis e init: String response; const int redPin = 13; // no Wemos é d7 const int greenPin = 12; // no Wemos é d6 const int bluePin = 14; // no Wemos é d5 const int touchSensor = 5; // no Wemos isso é d1 const int activationPin = 4; // no Wemos, isso é d2 bool activation = HIGH; toque bool = BAIXO; const char * aan_restore; int bri_restore; double x_restore; double y_restore; double x_magic; double y_magic; bool primeiro = verdadeiro; unsigned long startMillis; unsigned long currentMillis; long durationMillis sem sinal; Cliente RestClient = RestClient ("192.168.178.23"); // "seu endereço IP Hue Bridge" // Se você não souber seu endereço IP Hue Bridge, visite https://discovery.meethue.com e ele aparecerá imediatamente em seu navegador. O endereço IP é o número pontilhado precedido por "internalipaddress" void setup () {analogWriteRange (255); Serial.begin (9600); // Comece com o LED apagado. pinMode (activationPin, INPUT_PULLUP); pinMode (touchSensor, INPUT); startMillis = millis (); checkWand (); } void loop () {// nada a fazer aqui, deixe em branco…} void checkWand () {int rgbColour [3]; // Código de cores RGB de James Harton, https://gist.github.com/jamesotron/766994 // Comece com vermelho. rgbColour [0] = 255; rgbColour [1] = 0; rgbColour [2] = 0; ativação = digitalRead (activationPin); // LOW significa que a varinha está sendo usada. touch = digitalRead (touchSensor); // HIGH significa que o dedo é usado em vez da varinha, o que não deveria ser o caso. while (ativação == LOW && touch == LOW) {// Escolha as cores para aumentar e diminuir. for (int decColor = 0; decColor <3; decColour + = 1) {int incColor = decColour == 2? 0: decColor + 1; // = operador ternário, significa: int incColour; if (decColour == 2) {incColour = 0;} else {incColour = decColour +1;} // esmaecimento das duas cores. para (int i = 0; i <255; i + = 1) {rgbColor [decColor] - = 1; rgbColour [incColour] + = 1; // como nosso LED RGB tem um ânodo comum em vez de cátodo (então precisamos conectar a + 3,3 V em vez de terra), precisamos de valores inversos para RGB: int red = 255 - rgbColour [0]; verde int = 255 - rgbColour [1]; int blue = 255 - rgbColour [2]; analogWrite (redPin, vermelho); analogWrite (greenPin, verde); analogWrite (bluePin, azul); atraso (8); ativação = digitalRead (activationPin); if (ativação == HIGH) {// HIGH significa que a varinha está levantada. goto stopColorCycling; }}}} stopColorCycling: currentMillis = millis (); durationMillis = (currentMillis - startMillis); if (durationMillis> 1000) {RGBtoxy (rgbColour [0], rgbColour [1], rgbColour [2]); } else {// coloca o Wemos no modo de hibernação: ESP.deepSleep (0); }} void RGBtoxy (int red, int green, int blue) {// veja https://developers.meethue.com/documentation/color-conversions-rgb-xy double R = map (red, 0, 255, 0, 1000); R / = 1000; duplo G = mapa (verde, 0, 255, 0, 1000); G / = 1000; duplo B = mapa (azul, 0, 255, 0, 1000); B / = 1000; R = (R> 0,04045f)? pow ((R + 0,055f) / (1,0f + 0,055f), 2,4f): (R / 12,92f); G = (G> 0,04045f)? pow ((G + 0,055f) / (1,0f + 0,055f), 2,4f): (G / 12,92f); B = (B> 0,04045f)? pow ((B + 0,055f) / (1,0f + 0,055f), 2,4f): (B / 12,92f); duplo X = R * 0,649926f + G * 0,103455f + B * 0,197109f; duplo Y = R * 0,234327f + G * 0,743075f + B * 0,022598f; duplo Z = R * 0,0000000f + G * 0,053077f + B * 1,035763f; duplo x = X / (X + Y + Z); duplo y = Y / (X + Y + Z); // conversão não totalmente concluída, mas provavelmente boa o suficiente para o que queremos alcançar, então deixe assim e envie os valores XY para lamp: sendtoHue (x, y); } void sendtoHue (double a, double b) {// mudança de cor real da mágica da varinha if (first) {// primeira passagem: obtém o estado atual da lâmpada getCurrentValues (); } // então envie as cores da varinha mágica: // espera pelo feitiço: espera longa; x_magic = a; y_magic = b; // lâmpada acesa na cor da varinha mágica: response = ""; temp int = aleatório (2, 9); const char * state = "true"; for (int i = 1; i <= temp; i ++) {// criar matriz de caracteres para enviar à ponte: String temp_body1 = "{" on / ":" + String (estado) + ", \" bri / ": 220, / "xy \": ["+ String (x_magic) +", "+ String (y_magic) +"], / "tempo de transição \": 1} "; int str_len1 = temp_body1.length () + 1; char post_body1 [str_len1]; temp_body1.toCharArray (post_body1, str_len1); // agora temos post_body1 como array de caracteres; // fazer chamada de descanso: int statusCodePut1 = client.put ("/ api / SEU NOME DE USUÁRIO DA API DE MATIZ / lights / SEU NÚMERO DE LUZ / estado", post_body1, & resposta); esperar = aleatório (100, 600); atrasar (esperar); if (estado == "verdadeiro") {estado = "falso"; } else {state = "true"; }} // reduz o brilho…: response = ""; temp = aleatório (4, 17); // cria um array de char para enviar para a ponte: String temp_body2 = "{" on / ": true, \" bri / ": 154, \" transactiontime / ":" + String (temp) + "}"; int str_len2 = temp_body2.length () + 1; char post_body2 [str_len2]; temp_body2.toCharArray (post_body2, str_len2); // agora temos post_body2 como array de caracteres; // faça a chamada de descanso: int statusCodePut2 = client.put ("/ api / SEU NOME DE USUÁRIO DA API DE MATIZ / lights / SEU NÚMERO DE LUZ / estado", post_body2, & resposta); esperar = aleatório (1000, 2500); atrasar (esperar); //..e tornar mais claro novamente: response = ""; temp = aleatório (4, 17); // cria um array de char para enviar para a ponte: String temp_body3 = "{" bri_inc / ": 100, \" tempo de transição / ":}"; int str_len3 = temp_body3.length () + 1; char post_body3 [str_len3]; temp_body3.toCharArray (post_body3, str_len3); // agora temos post_body3 como array de caracteres; // fazer chamada de descanso: int statusCodePut3 = client.put ("/ api / SEU NOME DE USUÁRIO DA API DE MATIZ / lights / SEU NÚMERO DE LUZ / estado", post_body3, & resposta); esperar = aleatório (2500, 5000); // espera 2-5 segundos delay (wait); // e volta ao valor antigo: response = ""; // criar matriz de caracteres para enviar para a ponte: String temp_body4 = "{" on / ":" + String (aan_restore) + ", \" bri / ":" + String (bri_restore) + ", \" xy / ": ["+ String (x_restore) +", "+ String (y_restore) +"], / "tempo de transição \": "+ String (20) +"} "; int str_len4 = temp_body4.length () + 1; char post_body4 [str_len4]; temp_body4.toCharArray (post_body4, str_len4); // agora temos post_body4 como array de caracteres; // fazer chamada de descanso: int statusCodePut4 = client.put ("/ api / SEU NOME DE USUÁRIO DA API DE MATIZ / lights / SEU NÚMERO DE LUZ / estado", post_body4, & resposta); ESP.deepSleep (0); // vou dormir de novo…. } unsigned int getCurrentValues () {connectWifi (); // primeiro conectar ao Wifi response = ""; // fazer chamada de descanso: int statusCodeGet = client.get ("/ api / SEU NOME DE USUÁRIO DA API DE MATIZ / lights / SEU NÚMERO DE LUZ", & resposta); Serial.print ("Código de status do servidor após GET:"); Serial.println (statusCodeGet); Serial.print ("Corpo de resposta do servidor:"); Serial.println (resposta); StaticJsonBuffer jsonBuffer; // Analisando a resposta Json // Raiz da árvore de objetos. // // É uma referência ao JsonObject, os bytes reais estão dentro do // jsonBuffer com todos os outros nós da árvore de objetos. // A memória é liberada quando jsonBuffer sai do escopo. JsonObject & root = jsonBuffer.parseObject (resposta); JsonObject & state = root ["state"]; // Testa se a análise foi bem-sucedida. if (! root.success ()) {Serial.println ("parseObject () falhou"); } // Buscar valores. aan_restore = estado ["ligado"]; Serial.println (aan_restore); bri_restore = estado ["bri"]; x_restore = estado ["xy"] [0]; y_restore = estado ["xy"] [1]; primeiro = falso;} void connectWifi () {// Inicialização local. Depois de concluído o processo, não há necessidade de mantê-lo em torno do WiFiManager wifiManager; // redefinir as configurações - para teste: //wifiManager.resetSettings (); // define o retorno de chamada que é chamado ao conectar-se ao WiFi anterior falha e entra no modo Ponto de Acesso wifiManager.setAPCallback (configModeCallback); // busca ssid e passa e tenta conectar // se não conectar, inicia um ponto de acesso com o nome especificado // aqui "AutoConnectAP" // e entra em um loop de bloqueio aguardando configuração if (! wifiManager.autoConnect ()) {Serial.println ("falha ao conectar e atingir o tempo limite"); // reinicie e tente novamente, ou talvez coloque-o em hibernação ESP.reset (); atraso (1000); } // se você chegar aqui, você se conectou ao WiFi Serial.println ("conectado… yeey:)"); Serial.print ("Conectado a:"); Serial.println (WiFi. SSID ()); Serial.print ("endereço IP:"); Serial.println (WiFi.localIP ()); // Endereço IP atribuído ao seu ESP (Wemos) // imprime a intensidade do sinal recebido: long rssi = WiFi. RSSI (); Serial.print ("intensidade do sinal (RSSI):"); Serial.println (rssi); } void configModeCallback (WiFiManager * myWiFiManager) {Serial.println ("Modo de configuração inserido"); Serial.println (WiFi.softAPIP ()); // se você usou o SSID gerado automaticamente, imprima-o Serial.println (myWiFiManager-> getConfigPortalSSID ()); }