Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Chave de alimentação USB habilitada para Alexa

Componentes e suprimentos

Arduino MKR1000
× 1
0,1uF 0805 Capacitor
× 8
LED (genérico)
× 4
Pressione o botão (Long)
× 4
INA219 (soic 8)
× 1
LM3526M
× 2
Soquete USB (vertical)
× 4
resistor 1k 0805
× 4
Resistor de detecção de corrente de 0,1 Ohm
× 1
Capacitor 1uF 0805
× 1

Ferramentas e máquinas necessárias

Impressora 3D (genérica)
Ferro de soldar (genérico)

Aplicativos e serviços online

Amazon Alexa Skills Kit
Tinamous
Amazon Web Services AWS Lambda

Sobre este projeto


Alexa, ligue o ThingyStick ...





Antecedentes


Cada vez mais dispositivos são alimentados por USB, muitos deles tendem a ser dispositivos "burros" sem conectividade com a Internet ou opções de automação residencial (por exemplo, luzes LED), como podemos automatizar ou controlá-los remotamente? Talvez uma fonte USB conectada a um interruptor principal, isso é um pouco exagero, especialmente se quisermos 4 dispositivos controlados individualmente!

Este projeto permite que você controle o fornecimento de energia para dispositivos alimentados por USB através da internet e, usando o Tinamous SmartHome Skill para Alexa, você pode habilitar o controle de voz para seus dispositivos USB burros.

Atualmente são poucos os dispositivos no mercado para controlar remotamente a alimentação USB, quando comecei este projeto não encontrei nenhum (no Reino Unido), mas alguns surgiram recentemente como parte de pontos de venda multigangue (sim, a ideia começou há muito tempo, em uma galáxia muito distante), estes não são de fabricantes de automação residencial bem conhecidos, em vez de fabricantes sem marca (ou seja, ZLD-34UK), então temos o problema de qual dispositivo em nuvem eles usam, se os dados vão para China e vice-versa, o que acontecerá se esse fabricante não existir mais, quão seguro é, quão utilizável é o software, estará na caixa de reciclagem na próxima semana e muitas das outras preocupações normais dos dispositivos conectados à Internet, para não mencionar não podendo ser hackeado da mesma forma que um dispositivo de código aberto com o Arduino pode ser.





Casos de uso


Exemplos de dispositivos alimentados por USB que podemos desejar controlar:
  • Luzes alimentadas por USB
  • Kindle Fire / Chrome cast sticks (especialmente em quartos de crianças para impedi-los de assistir TV)
  • umidificadores USB
  • Echo Dot (fazer o Alexa desligar-se durante a noite? ou apenas reiniciar o dispositivo)
  • Placas de desenvolvimento. Precisa reiniciar esse projeto porque seus códigos entraram em um loop infinito?
  • Dispositivos que são difíceis de acessar, mas precisam ser reiniciados ocasionalmente (ou seja, sensores no loft).
  • Dispositivos instalados nas instalações do cliente onde queremos garantir que está alimentado (medindo o consumo de corrente e a tensão de entrada)

Controle de energia simples: Comutação de energia habilitada para Internet, seja via controle de voz Alexa ou outros comandos via Tinamous. Ligado e desligado.

Controle de energia inteligente: Muitas lâmpadas USB têm controles de toque para acender a lâmpada, o que significa que não podemos acender a luz remotamente, mas podemos desligá-la e muitas vezes é tudo o que queremos (tentando dormir, deixamos uma lâmpada acesa ? Saindo, quer todas as luzes desligadas?).

No entanto, uma vez que usamos Alexa para desligar a lâmpada USB, temos que pedir a Alexa para ligar a lâmpada antes de podermos ligá-la, isso é bobagem. Com o smart power ativado, o comando off desligará a lâmpada por alguns segundos antes de restaurar a energia para o dispositivo. O suficiente para desligar a lâmpada, mas também permitindo o funcionamento normal depois.

Automação do temporizador: Faça com que seus dispositivos desliguem automaticamente em horários definidos. Crianças assistindo Amazon TV no fogo ficam até tarde? Desligue a alimentação USB automaticamente às 20h.

Monitoramento de energia: Se você estiver desenvolvendo um hardware alimentado por USB, convém saber a quantidade de corrente que seu dispositivo está consumindo, principalmente quando ele é ligado pela primeira vez, ou talvez você queira analisar o carregamento da bateria. Com o INA219 on-board você pode monitorar o consumo de corrente (consegui cerca de 1kHz de amostragem com pouco esforço). A queda de tensão nos cabos USB em alta corrente também pode ser um problema, o INA219 monitora a alimentação do dispositivo para que possamos alertar sobre baixa tensão. Um bloco de terminais também é fornecido para permitir que correntes mais altas e cabos maiores sejam usados.

Falha de energia: Usando a opção de bateria no MKR 1000, podemos monitorar a tensão de alimentação USB e enviar notificações se houver falha na alimentação de entrada. Isso pode ser útil para soluções remotas (fora do local) que usam energia USB, mas precisam de um pouco de monitoramento extra, ou apenas como uma simples detecção de falha de energia para sua casa.





Hardware


Este projeto é bastante simples, um Arduino MKR1000 no coração, comutação de alimentação USB usando dois LM3526M para fornecer comutação de lado alto e detecção de falha (baixa tensão, sobrecorrente), junto com monitoramento de energia (tensão e corrente) usando um INA219 e, finalmente LEDs e interruptores para opções de controle local.

Eu fiz um PCB em DirtyPCBs.com, você também pode enviar o arquivo .brd para OSHPark.com para que seja feito também. O soquete Arduino tem pads pcb em cada lado de cada pino para permitir hacking. por exemplo. você pode adicionar facilmente alguns sensores para as condições ambientais ou um pequeno display OLED para mostrar a tensão e a corrente.

No repositório github, há uma opção de 2 portas e 4 portas. Tenha cuidado com o PCB de 2 portas, pois eu errei e obteve o layout do soquete USB errado (eles estão de trás para a frente - polaridade errada !).

Vitória das garras da derrota:

Acontece que montar o USB inserido na parte de trás da placa é na verdade uma boa solução e significa que as conexões de pinos estavam corretas (no entanto, para a placa de 2 portas também significa que o silk screen está do lado errado!). O Arduino com cabeçalhos em um soquete foi um pouco pressionado para obter espaço com a altura necessária para tirar os soquetes USB do gabinete, então funcionou melhor, decidi refazer a placa com soquetes, interruptores e LEDs no reverso lado e para adicionar duas portas extras, portanto, a versão de quatro portas foi criada (também, eu tinha os LEDs horrivelmente alinhados no 2 porteiro, então isso também foi consertado!).

Eles impedem que isso seja estendido para um switcher de 6 ou 8 portas, embora os LEDs e switches possam precisar ser eliminados ou melhorados.

O esquema parece muito mais complexo de construir do que é. Muitos dos resistores são opcionais. Os resistores R23, 19, 27 e 26 são todos pull-ups para os interruptores, da mesma forma que R20-22, R14 e R15 são pull-ups para o controle USB e detecção de falha. Tudo isso pode ser feito por meio do modo de pino INPUT_PULLUP no Arduino, no entanto, se você quiser colocar o Arduino em hibernação e usar interrupções para ativá-lo, convém preenchê-los para que não flutuem (e saltem) .

Eu também adicionei resistores opcionais em torno das linhas USB D + / D-. Eles podem ser ajustados para informar ao dispositivo quanta energia ele pode usar, mas para muitos dispositivos burros, eles são ignorados de qualquer maneira. Abaixo, apenas R24 para a limitação de corrente do LED é realmente necessário. R2-5 e R28 são deixados vazios.

Os LEDs e interruptores também são totalmente opcionais. Se você deseja apenas uma caixa autônoma que controle USB remotamente, não adicione essas peças.

Entrada de energia

Este controlador pode ser alimentado por meio de três opções.

A primeira é a opção "Interna" (JP6 pinos 1 e 2 conectados), a alimentação USB é retirada do pino 5V do Arduino (e, portanto, do conector USB do Arduino). No entanto, isso só deve ser usado para cargas de baixa potência.

As outras opções são para alimentação externa (JP6 pinos 2 e 3 conectados), você pode conectar 5V via J2 (o micro conector USB integrado) ou JP8 (um bloco de terminais). Você não deve usar as duas opções ao mesmo tempo. A alimentação externa também é direcionada ao pino VIn do Arduino, portanto, ele não precisará de sua própria opção de alimentação também.

Para pontos de bônus, encaixar resistores 0R em R10 e R11, bem como J2 dá passagem USB para USB 3 para que possamos reiniciar um dispositivo conectado por USB, muito útil ao desenvolver hardware e você não quer gastar seus soquetes USB o PC!





Gabinete


Um gabinete para impressão 3D está incluído neste projeto. Ele usa inserções de ajuste térmico M3 para conexões de PCB e tampa, embora as tolerâncias na tampa sejam boas o suficiente para um encaixe por fricção.

A tampa inclui algumas opções.
  • Com ou sem compartimento de bateria.
  • Com ou sem pés (também conhecido como orifícios de montagem para permitir que a caixa seja fixada a uma superfície).

Da mesma forma, a caixa base pode ser configurada (usando OpenSCAD) para incluir aberturas para cada uma das três fontes de energia.

Demorou algumas tentativas para obter o recinto certo. Como você modifica suas impressões? Minhas amostras do fã-clube Rigid.Ink foram muito úteis.






Conectando-se ao Tinamous


Estamos usando o Arduino MKR1000 para controlar as tomadas, então temos conectividade wi-fi. Se você for novo nesta placa, precisará adicionar a opção de placa ao seu Arduino IDE.

Vamos usar o servidor MQTT Tinamous para nos conectar, principalmente porque ele é incrível, mas também, talvez porque eu seja o fundador / desenvolvedor / fabricante de chá! Vamos assinar o tópico de postagem de status para mensagens enviadas para o dispositivo. (ou seja, o tópico "Status.To").

Antes de iniciar a codificação, precisamos garantir que o Arduino tenha o firmware mais recente, bem como os certificados SSL necessários para obter uma conexão segura com o Tinamous. Obviamente, se você preferir, poderá adaptá-lo ao seu próprio servidor MQTT local e não se preocupar tanto com a segurança.





Etapa 1


Abra o IDE do Arduino e carregue o FirmwareUpdater esboço do menu de exemplos WiFi101. Faça upload para o seu dispositivo.





Etapa 2


Após o upload, selecione WiFi101 Firmware Updater nas Ferramentas cardápio.





Etapa 3


Teste sua conexão e em seguida Atualize o firmware . Depois de fazer isso, use Adicionar domínio botão e adicione tinamous.com para garantir que o Arduino tenha os certificados SSL corretos. Pressione Carregar certificados para o módulo WiFi botão para fazer o upload dos certificados.





Etapa 4


Agora podemos escrever nosso próprio firmware. Você encontrará os arquivos anexados a este projeto e também no repositório GitHub (o GitHub terá a versão mais recente).

Usaremos o WiFi101 e o MQTT Client para o seu esboço do Arduino.

Selecione a opção MQTT de Joel Gaehwiler.

O arquivo secrets.h precisa ser preenchido com suas configurações de WiFi e Tinamous MQTT, não incluí minha cópia por motivos óbvios.

Configurações do servidor WiFi e MQTT:
  #define SECRET_SSID "Seu SSID" #define SECRET_PASS "Sua senha SSIDs" / ************************** Tinamous MQTT Setup *********************************** / # define MQTT_SERVER " .tinamous.com" #define MQTT_SERVERPORT 8883 #define MQTT_USERNAME "UsbSwitch. " # define MQTT_PASSWORD "Sua senha vai aqui." # Define MQTT_CLIENT_ID "UsbSwitch" #define DEVICE_USERNAME "UsbSwitch"  

Se você ainda não se cadastrou no Tinamous, você pode criar sua própria conta gratuita aqui. Quando você se registra, é solicitado um nome de conta / organização, esta se torna sua própria área privada de Tinamous, você pode convidar outros membros para essa área (incluindo Alexa) e compartilhar seus dispositivos com seu grupo.

Abaixo, estou chamando minha conta de "AlexaExample", isso é o que preciso incluir na configuração do MQTT e minha conta Tinamous está em https://AlexaExample.Tinamous.com





Etapa 5


Em seguida, precisamos adicionar nosso dispositivo. Na página Tinamous Devices, clique no botão Add.

Portanto, as configurações de MQTT de Tinamous para meu dispositivo se parecem com isto ...
  / ************************** Configuração do MQTT Tinamous *************** ******************* / # define MQTT_SERVER "AlexaExample.tinamous.com" #define MQTT_SERVERPORT 8883 #define MQTT_USERNAME "UsbSwitch.AlexaExample" #define MQTT_PASSWORD "Minha senha supersecreta que totalmente não é Passw0rd .... "# define MQTT_CLIENT_ID" UsbSwitch "#define DEVICE_USERNAME" UsbSwitch " 

Essa é a nossa conta Tinamous e o dispositivo habilitado. Você pode adicionar mais dispositivos aqui se desejar, apenas atualize as configurações de MQTT para DEVICE_USERNAME e MQTT_USERNAME (MQTT não envia informações de cabeçalho como http, então Tinamous não tem ideia de qual subdomínio você está usando, portanto, precisamos especificar o conta no nome de usuário).





Etapa 6


Faça upload do código anexado aos seus dispositivos (com o arquivo secrets.h atualizado). Reserve um momento para olhar o arquivo TinamousMQTTClient.ino, ele lida com nossas interações MQTT e, com isso, os comandos Alexa que são enviados para nosso dispositivo.

Precisamos usar o WiFiSSLClient para SSL. Se desejar usar um servidor MQTT local sem SSL, você pode usar o cliente WiFi normal e descer para a porta 1883, mas para qualquer coisa baseada na Internet, use o cliente SSL.

Também precisamos reservar um pouco mais do que o buffer padrão para o cliente MQTT, aqui estamos reservando 4096 bytes.
  WiFiSSLClient networkClient; MQTTClient mqttClient (4096);  

Usamos o mqttClient.begin para configurar o cliente e especificar um manipulador de função em onMessage que é chamado quando uma mensagem é recebida do servidor MQTT.
  mqttClient.begin (MQTT_SERVER, MQTT_SERVERPORT, networkClient); // Gerencia as mensagens recebidas. mqttClient.onMessage (messageReceived);  

E então podemos nos conectar e assinar o tópico de nosso interesse. Aqui você vê que assinamos "Tinamous / V1 / Status.To / UsbSwitch", receberemos mensagens enviadas para @UsbSwitch a partir da linha do tempo do Tinamous. É assim que vamos receber mensagens de Alexa.
  if (! mqttClient.connect (MQTT_CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) {if (mqttClient.lastError () ==LWMQTT_CONNECTION_DENIED) {// Este erro ocorre porque seu nome de usuário ou senha está errado} if (mqttClient} if. lastError () ==-6) {// Este erro é mais provável porque você não adicionou o certificado SSL. } // Força um atraso antes de tentar novamente o atraso de conexão (10000); return false;} // Conexão bem-sucedida. Agora assine o tópico mqttClient.subscribe ("/ Tinamous / V1 / Status.To /" DEVICE_USERNAME);  

Você pode pensar na linha do tempo do Tinamous como uma versão privada do Twitter para você e seus dispositivos, eles podem usar MQTT ou a API REST (ou um dos bots) para ver as mensagens enviadas a eles e agir sobre eles, bem como postar mensagens de volta.

Temos um pouco mais de trabalho a fazer no Tinamous para permitir a integração do Alexa, mas por enquanto podemos testar nosso dispositivo e firmware usando a linha do tempo e enviando mensagens.

Se você usar a habilidade Tinamous SmartHome, essa é toda a codificação necessária.





A habilidade de casa inteligente Tinamous para Alexa


A Tinamous Smart Home Skill está atualmente com aprovação pendente para ser publicada (no momento da escrita, dedos cruzados está na loja agora ...). Para fazer seu próprio switcher USB, você pode usar esta habilidade quando estiver disponível.

A habilidade é realmente muito genérica, não sabe nada sobre os dispositivos ou como falar com eles. Aplicamos tags aos dispositivos no Tinamous e a habilidade criará um dispositivo apropriado na conta Alexa, portanto, você pode usar essa habilidade e o Tinamous para habilitar por voz um de seus próprios projetos com apenas algumas linhas de código no dispositivo.

No entanto, você pode desejar alterar as coisas ou escrever suas próprias habilidades, portanto, compartilharei os detalhes do meu desenvolvimento.

Eu escrevi a habilidade em C # para .Net Core 2.0, na verdade ela foi desenvolvida para meu projeto de ventilador inteligente BOFF, mas para este projeto eu a estendi para permitir que um dispositivo tenha muitas saídas (portas) e para cada uma ser uma primeira classe cidadão em dispositivos Alexa Smart Home.

Todo o código (incluindo alguns testes!) Está no repositório Tinamous SmartHome, clone, baixe ou apenas veja como quiser. Usei o Visual Studio 2017 com as ferramentas AWS instaladas para ajudar a levar a habilidade para Lambda.

A estrutura desserializa a mensagem de diretiva recebida de Alexa em objetos que podemos acessar por meio do código, as ações apropriadas são tomadas com base no namespace dos cabeçalhos e no nome da diretiva e, em seguida, uma resposta apropriada é retornada.

As principais mensagens de interesse são:
  • Vinculação de contas
  • Descoberta
  • Relatório de estado
  • Controle de energia





Vinculação de conta:


Isso é tratado por Alexa para nós, depois de adicionarmos a habilidade à nossa conta, Alexa solicitará autenticação, somos levados à página de autorização do Tinamous para permitir que o dispositivo acesse nossa conta. Aqui você precisa inserir o nome da sua conta (AlexaExample neste caso), nome de usuário (Steve) e senha (não, não estou dizendo!)





Descoberta:


Uma vez que sua conta está vinculada, Alexa pede para realizar a descoberta, a habilidade então consulta Tinamous para dispositivos que estão marcados com " Alexa.SmartDevice ". Dispositivos sem isso são simplesmente ignorados.

Essas tags são aplicadas editando o dispositivo na página Dispositivos no Tinamous.

Se o dispositivo também estiver marcado com " MultiPort "cada porta é enumerada e um dispositivo também é adicionado para elas. Também aplicamos tags com base nas diretivas Alexa que nosso dispositivo suporta, aqui é apenas" Alexa.PowerController "e também uma tag para indicar em qual categoria o dispositivo deve ser exibido no aplicativo, aqui eu usei" SmartPlug "

Outras interfaces estão disponíveis, como Alexa.BrightnessController, mas isso não é tão útil aqui. Veja o leia-me do repositório para mais detalhes.

Para que nosso dispositivo MultiPort exponha portas individuais para Alexa, precisamos configurar as variáveis ​​de estado, também na página de edição do dispositivo.

PortCount indica o número de portas que o dispositivo possui, então "Port-1" .. "Port-n" fornece os nomes que Alexa usará para as portas. Qualquer porta sem um nome será ignorada. Você pode alterar facilmente o nome da porta aqui e executar a descoberta novamente para atualizar o Alexa.

Durante a descoberta, a habilidade também procurará por um campo marcado, denominado ou rotulado como "powerState" ou "powerState-port-n" conforme apropriado. Se este campo for encontrado, ele é atribuído como um recurso compatível para o dispositivo (mais sobre isso no Relatório de estado).





Relatório de estado


Durante a fase de descoberta, dissemos a Alexa quais são os recursos de nosso dispositivo, o padrão de habilidade é dizer a Alexa que eles podem ser solicitados, portanto, Alexa enviará uma solicitação StateReport para obter os valores para eles.

Temos um último conjunto de tags a serem aplicados para dar suporte a isso, desta vez para os campos de dispositivos. Assim que seu dispositivo estiver enviando dados (essa é a mensagem senml que está sendo enviada por push no MQTT no código do Arduino), o Tinamous criará campos para o dispositivo. Podemos então usar a opção Avançado da lista de campos para editar isso. Usar a opção de tag é a mais versátil, pois significa que não precisamos corrigir o nome do campo no firmware ou travar se quisermos renomeá-lo.

Se os campos específicos da porta não forem encontrados, Alexa voltará para o campo não específico da porta (aqui denominado powerState).





Controle de potência


Nosso dispositivo não vai ter nenhuma utilidade no Alexa sem isso! Alexa enviará duas diretivas para nossa habilidade "TurnOn" e "TurnOff". O principal ponto de entrada da função para a habilidade primeiro procura o namespace (Alexa.PowerController) e, em seguida, passa o trabalho para a classe de controlador apropriada (PowerController.cs).

A habilidade então simplesmente publica uma Mensagem de Status na linha do tempo de Tinamous.

Por exemplo:

@UsbSwitch Ligar

ou

@UsbSwitch Ligue a porta 1

As outras interfaces suportadas são tratadas de maneira quase idêntica. Cabe então ao nosso dispositivo observar essa mensagem de status e executar uma ação. Alexa pode então ler o estado usando um StateReport.

É assim que a habilidade funciona. Agora, só precisamos enviá-lo para o AWS Lambda e criar uma entrada Skill no console do Alexa para dar à Alexa acesso a ele.





Criação da função AWS Lambda:


Usei as ferramentas AWS dentro do Visual Studio para levar a habilidade compilada para Lambda. Mas primeiro precisamos criar o Lambda.

Dica profissional: Crie o Lambda na área AWS apropriada para o idioma que você está oferecendo. Inglês (Reino Unido) deve segmentar eu-oeste (Irlanda).

Crie uma nova função lambda do zero. Os projetos existentes são limitados e desatualizados (suportando apenas V2 da interface SmartHome, que é muito diferente e obsoleta - estamos usando V3).

Você precisará criar uma nova função para permitir que o Lambda acesse os recursos de que precisa. Aqui, selecionamos Microsserviços simples como padrão (na verdade, oferece muito mais do que precisamos). Se você descobrir que não está obtendo registros no Cloud Watch, também pode precisar dar as permissões de papel para isso por meio da seção IAM.

Em seguida, precisamos publicar os binários do Visual Studio. Com as ferramentas AWS instaladas, clique com o botão direito do mouse no projeto e selecione "Publicar no AWS Lambda ..."

Em seguida, preencha os detalhes da expressão Lambda e clique em Carregar ...

Depois de carregado, podemos executar alguns testes no Lambda para garantir que ele seja executado. Em seguida, precisamos "Publicar nova versão" no menu suspenso Ações.

Depois de publicado, precisamos dar às nossas permissões de habilidade para acessar isso,

Clique no gatilho "Alexa Smart Home" e insira a identificação da habilidade (ainda não temos isso ...)





Criando a habilidade no console Alexa:


Com nosso Lambda quase pronto, precisamos ir ao console do desenvolvedor de habilidades e criar uma entrada para ele. Abra https://developer.amazon.com, selecione Alexa Skills Kit e adicione uma nova habilidade.

Selecione Smart Home Skill API, o idioma que você deseja segmentar (por exemplo, inglês (Reino Unido) para nós no Reino Unido) e selecione a versão de carga útil V3 (preferencial).

Na página de configuração, entramos em detalhes mais interessantes. Digite o Lambda ARN de nosso Lambda com versão (canto superior direito da tela). Deve terminar algo como:1 ou:2 ou:5246 (se você já tentou algumas vezes;-)).

Enquanto no Lambda também podemos colar o "Application ID" ou "Skill ID" ou "ID" ou o que quer que seja chamado hoje a partir da habilidade, deve ser algo como amzn1.ask.skill.2 _______________ 50.

Certifique-se de clicar em Salvar depois de adicionar o ID do aplicativo. No console antigo você pode encontrar o id no cabeçalho sob o nome da habilidade, no novo, erm, abra uma nova janela, volte para a lista de habilidades do console e clique no link apropriado. (é como se eles nunca tivessem usado o console para realmente fazer uma habilidade).

Para habilitar a vinculação de contas, precisamos de um aplicativo OAuth criado na Tinamous, isso é feito usando o Alexa Bot. Vá para a página de Bots da sua conta Tinamous e adicione um Alexa Bot. Depois de criar essa caixa de diálogo, você encontrará todos os detalhes necessários para configurar a vinculação de contas.

NB:Se você estiver usando a (em breve ...) habilidade Tinamous SmartHome publicada, você não precisa de um Alexa Bot.

O aplicativo criado pelo bot permitirá que qualquer outro titular de conta do Tinamous use sua habilidade e vincule sua conta. Naturalmente, você não precisa publicar sua habilidade e pode mantê-la privada, e eles não poderão ver nada em sua conta do Tinamous.

Da mesma forma, se você usar uma nuvem de dispositivo diferente (sério, por que faria isso;-)), você precisará inserir os detalhes do aplicativo OAuth.

Na página de teste, certifique-se de que sua habilidade está definida como "Sim" para "Mostrar esta habilidade no aplicativo Alexa".

Salve e vá para alexa.amazon.co.uk (ou aquele apropriado para sua região), ou aparentemente o aplicativo deles também .....

Clique em "Habilidades", no canto superior direito, "Suas Habilidades" e depois em "HABILIDADES DE DEV", você verá sua habilidade listada com um marcador verde para indicar que é uma habilidade de desenvolvimento.

A opção "Alexa, desligue a luz do usb" e as informações de habilidade adicionais quando você selecioná-la são configuradas na página "Publishing Information", você pode inserir as informações durante o desenvolvimento sem ter que ir para a publicação completa.

Se você precisar atualizar o código de habilidade, carregue a nova função do Lambda, crie uma nova versão, adicione novamente o gatilho SmartHome e o ID de habilidade e, em seguida, cole a função Lambda com versão no console de habilidade (você pode usar uma função não lambda versionado, mas não funcionou quando tentei - embora houvesse muitas outras coisas que eu também havia errado naquela época).





Sucesso!


Com nosso código de habilidade em execução no Lambda e a habilidade instalada em nossa conta Alexa, podemos executar a descoberta e, em seguida, começar a controlar os dispositivos.

Você pode clicar nos logs do CloudWatch para ver as informações de log gravadas por sua habilidade.






Depuração de habilidades e dicas


Alexa quase não fornece feedback de desenvolvedor quando as coisas dão errado, você pode passar anos tentando adivinhar por que Alexa não faz o que você esperava.
  • Avoid most things other than alpha-numerics in your endpointID's (I used * at one stage and everything broke, but not in an obvious way, however # was fine. Go figure!).
  • Log everything. Check for logs when you've invoked your skill. No log then it's probably authentication, or your skill isn't authorized for the Lambda expression.
  • Use matching AWS and Alexa email accounts.
  • Keep the Lambda in the same region as the skill (Ireland for UK skills).
  • If your skill is invoked but Alexa isn't responding to it (i.e. not listing devices), your response format is probably wrong.
  • If you don't want to use your day to day Alexa account you can use Amazon households to add a second adult account. Note however this appears to be limited to 2 adults, and you can't change it without an epic delay.
  • You can ask "Alexa, Switch Profiles" to switch between your developer and regular profiles.
  • I hope with the redesign of the Alexa Console some better debugging information will be available. However right now all I see is bigger boxes and a little better validation. Some logs are available but they are just success logs. aka management level feel good metrics, and delayed by 36 hours which isn't helpful for debugging!





One Skill, Any (IoT) Thing!


With the Tinamous SmartHome skill, as long as your (Internet of Things) thing can connect to the Tinamous MQTT server (or is connected via a supported bot) adding Alexa SmartHome control to your thing is simply a few lines of code to handle messages like "Turn On", "Turn Off", "Set brightness 20". Just add the tags in Tinamous, and....

"Alexa, Discover Smart Home Devices".


Código

  • AlexaUsbSwitcher.ino
  • TinamousMQTTClient.ino
  • UsbControl.ino
  • WiFiClient.ino
  • Secrets.h
AlexaUsbSwitcher.inoArduino
This is the main file.
#include #include #include #include // Provide your own Secrets.h with WiFi and Tinamous definitions in it.#include "Secrets.h"// ================================/*#define MAX_USB_PORTS 2// 2 Port board.int led_pin[MAX_USB_PORTS][2] ={{A5, A6},{0,1}};int switch_pin[] ={A0, A1};// Usb switch B channel -> pin 5 ==USB1int usb_enable_pin[] ={2, 5};int usb_fault_pin[] ={3, 4};bool usb_port_state[] ={false, false};bool usb_power_mode[] ={0, 0, 1, 1};*/// ---------------------------------// 4 Port board.#define MAX_USB_PORTS 4// The 2 port board has bi-color LEDs, 4 port doesn't so use same pin......// LEDs:TX, Rx, D7, D6 (1-4)int led_pin[MAX_USB_PORTS][2] ={{14, 14}, {13,13}, {7,7}, {6,6}};int switch_pin[] ={A0, A1, A2, A3};// USB Enable pins, D1, D3, D4, D5 (not in that order)int usb_enable_pin[] ={5, 4, 1, 3};// Single fault pin (D2)int usb_fault_pin[] ={2, 2, 2, 2};bool usb_port_state[] ={false, false, false, false};// Mode:0 - Switch off as requested.// Mode:1 - Switch off, then on after a delay (useful for LED lights that have touch controls).int usb_power_mode[] ={1, 0, 0, 0};// ================================// Automation options.// time (millis) that the USB port should be switched on/off at.// zero indicates ignore.unsigned long usb_power_switch_on_at[] ={0, 0, 0, 0};// Set> 0 to get processed on first loop.// Side effect is switching them off that those in smart power // mode will schedule to come back on again).unsigned long usb_power_switch_off_at[] ={1, 1, 1, 1};// Current monitor INA219Adafruit_INA219 ina219;// Flag to indicate if one or more USB ports has a fault.bool has_usb_fault =false;// Measured power .float shunt_voltage =0;float bus_voltage =0;float current_mA =0;float load_voltage =0;float power_mW =0;// Min/max float max_current_mA =0;float max_busvoltage =0;float min_busvoltage =20;// track power usage.unsigned long last_measurement_time =0;bool power_failed =false;bool over_current =false;// MQTT publishing.// Probably want it quicker when powering devices.// or slower when not!int update_interval_seconds =20;unsigned long next_message_send_at =0;// =================================================// Main setup entry point// =================================================void setup() { pinMode(LED_BUILTIN, OUTPUT); digitalWrite(LED_BUILTIN, HIGH); for (int channel=0; channel MAX_USB_PORTS) { return; } // Light up the LED (1..4) based on the setup progress. SetLeds(stage-1 , true, true);}// ===================================================// Main Loop// ===================================================void loop() { // 4 port device, Debug LED is port 4 LED. // if any port 4 is on, then don't switch off the LED. // with all 4 ports off, the debug LED can blink as it likes... if (!hasPoweredPorts()) { digitalWrite(LED_BUILTIN, LOW); } // Check for a fault. bool faulted =false; for (int channel =0; channel  max_current_mA) { max_current_mA =current_mA; } if (bus_voltage> max_busvoltage) { max_busvoltage =bus_voltage; } if (bus_voltage  4.5) { Serial.print("External power restored. Bus voltage:"); Serial.print(bus_voltage); Serial.println(" V"); publishTinamousStatus("External power has been restored."); power_failed =false; } if (bus_voltage <4.2 &&!power_failed) { Serial.print("External power failed! Bus voltage:"); Serial.print(bus_voltage); Serial.println(" V."); publishTinamousStatus("External power lost!"); power_failed =true; } if (over_current &¤t_mA <1500) { publishTinamousStatus("Current fault cleared!"); over_current =false; } if (current_mA> 2000 &&!over_current) { // Overload! publishTinamousStatus("Over Current!"); over_current =true; } }void printPowerWide() { Serial.print("Bus Voltage:\t"); Serial.print(bus_voltage); Serial.print(" V\t"); Serial.print("Current:\t"); Serial.print(current_mA); Serial.print(" mA\t"); Serial.print("Max Current:\t"); Serial.print(max_current_mA); Serial.print(" mA\t"); Serial.print("Min Voltage:\t"); Serial.print(min_busvoltage); Serial.print(" V\t"); Serial.print("Max Voltage:\t"); Serial.print(max_busvoltage); Serial.print(" V\t"); Serial.println();}void printPowerSkinny() { Serial.print(bus_voltage); Serial.print ("\ t"); Serial.print(current_mA); Serial.print("\t\t"); Serial.print(max_current_mA); Serial.print("\t\t"); Serial.print(min_busvoltage); Serial.print ("\ t"); Serial.print(max_busvoltage); Serial.print ("\ t"); Serial.print("["); for (int channel=0; channel next_message_send_at) { Serial.println("------------------------"); Serial.println("MQTT publish measurements"); if (power_failed) { // reduce how often we send when the power // has failed to preserve battery power. sentNextPublishAt(update_interval_seconds * 10); } else { sentNextPublishAt(update_interval_seconds); } // And do one as senml... String senml ="{'e':["; // Voltage senml =senml + "{'n':'busVoltage'"; senml =senml + ", 'v':"; senml =senml + String(bus_voltage); senml =senml + ", 'u':'V'}"; // Max voltage senml =senml + ",{'n':'maxBusVoltage'"; senml =senml + ", 'v':"; senml =senml + String(max_busvoltage); senml =senml + ", 'u':'V'}"; // Min voltage senml =senml + ",{'n':'minBusVoltage'"; senml =senml + ", 'v':"; senml =senml + String(min_busvoltage); senml =senml + ", 'u':'V'}"; // Current senml =senml + ",{'n':'Current'"; senml =senml + ", 'v':"; senml =senml + String(current_mA); senml =senml + ", 'u':'mA'}"; // Max current senml =senml + ",{'n':'MaxCurrent'"; senml =senml + ", 'v':'"; senml =senml + String(max_current_mA); senml =senml + "', 'u':'mA'}"; // mAh consumed... senml =senml + ",{'n':'mAh'"; senml =senml + ", 'v':"; senml =senml + String(0); // TODO! senml =senml + ", 'u':'mAh'}"; senml =senml + ",{'n':'powerState"; senml =senml + "', 'bv':"; if (isPowered()) { senml =senml + "true"; } else { senml =senml + "false"; } senml =senml + "}"; for (int channel=0; channel 0 &&onAt  0 &&offAt  
TinamousMQTTClient.inoArduino
This file handled the MQTT connectivity (i.e. it's the bit that responds to Alexa commands).
// ======================================// Tinamous connectivity via MQTT// ======================================#include #include #include "secrets.h"// WiFi and MQTT settings in Secrets.h// Be sure to use WiFiSSLClient for an SSL connection.// for a non ssl (port 1883) use regular WiFiClient.//WiFiClient networkClient; WiFiSSLClient networkClient; // https://github.com/256dpi/arduino-mqtt// Specifying 4096 bytes buffer sizeMQTTClient mqttClient(4096); // If we have been connected since powered up bool was_connected =false;String senml ="";unsigned long nextSendMeasurementsAt =0;// =================================================// Setup the MQTT connection information// =================================================bool setupMqtt() { senml.reserve(4096); Serial.print("Connecting to Tinamous MQTT Server on port:"); Serial.println(MQTT_SERVERPORT); Serial.print("Server:"); Serial.println(MQTT_SERVER); mqttClient.begin(MQTT_SERVER, MQTT_SERVERPORT, networkClient); // Handle received messages. mqttClient.onMessage(messageReceived); connectToMqttServer();}// =================================================// Connect to the MQTT server. This can be called // repeatedly and will be ignored if already connected// =================================================bool connectToMqttServer() { if (mqttClient.connected()) { return true; } Serial.println("Reconnecting...."); Serial.println("checking wifi..."); if (WiFi.status() !=WL_CONNECTED) { Serial.print("WiFi Not Connected. Status:"); Serial.print(WiFi.status(), HEX); Serial.println (); atraso (10000); return false; } Serial.println("Connecting to MQTT Server..."); if (!mqttClient.connect(MQTT_CLIENT_ID, MQTT_USERNAME, MQTT_PASSWORD)) { Serial.println("Failed to connect to MQTT Server."); Serial.print("Error:"); Serial.print(mqttClient.lastError()); Serial.print(", Return Code:"); Serial.print(mqttClient.returnCode()); Serial.println (); if (mqttClient.lastError() ==LWMQTT_CONNECTION_DENIED) { Serial.println("Access denied. Check your username and password. Username should be 'DeviceName.AccountName' e.g. MySensor.MyHome"); } if (mqttClient.lastError() ==-6) { Serial.println("Check your Arduino has the SSL Certificate loaded for Tinmaous.com"); // Load the Firmware Updater sketch onto the Arduino. // Use the Tools -> WiFi Firmware Updater utility } // Wait 10s before it gets re-tried. atraso (10000); return false; } Serial.println("Connected to Tinamous MQTT!"); mqttClient.subscribe("/Tinamous/V1/Status.To/" DEVICE_USERNAME); Serial.println("Subscribed to status.to topic."); // Say Hi. publishTinamousStatus("Hello! Usb switch is now connected. @ me with help for help."); was_connected =true; return true;} // =================================================// Loop for mqtt processing.// =================================================void mqttLoop() { // Call anyway, does nothing if already connected. connectToMqttServer(); mqttClient.loop(); }// =================================================// Publish a status message on the Tinamous timeline// =================================================void publishTinamousStatus(String message) { Serial.println("Status:" + message); mqttClient.publish("/Tinamous/V1/Status", message); }// =================================================// Publish measurements using the plain json format// =================================================void publishTinamousJsonMeasurements(String json) { Serial.println("Measurement:" + json); mqttClient.publish("/Tinamous/V1/Measurements/Json", json); }// =================================================// Publish measurements using senml json format// =================================================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.print(mqttClient.lastError()); Serial.println (); } Serial.println("Done.");}// =================================================// Message received from the MQTT server// =================================================void messageReceived(String &topic, String &payload) { Serial.println("Message from Tinamous on topic:" + topic + " - " + payload); // If it starts with @ it's a status message to this device. if (payload.startsWith("@")) { payload.toLowerCase(); if (handleStatusMessage(payload)) { Serial.println("@ me status message handled."); Retorna; } } // Didn't get an expected command, so the message was to us. // Publish a help message. publishTinamousStatus("Hello! Sorry I didn't understand the message. @ me with help for help.");} // =================================================// Message was a Status Post (probably Alexa)// =================================================bool handleStatusMessage(String payload) {char buffer[25]; // for 1..4 (maps to 0..3) for (int port =0; port  0) { Serial.print("Turn on port "); Serial.println(port); setUsb(port, true); return true; } sprintf(buffer, "turn off port-%01d", port + 1); if (payload.indexOf(buffer)> 0) { Serial.print("Turn off port "); Serial.println(port); setUsb(port, false); return true; } } // No port specified, turn on all. 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("Sending help..."); publishTinamousStatus( "Send a message to me (@" DEVICE_USERNAME ") then:" "'Turn on Port-1' to turn on usb port 1," "'Turn off Port-1' to turn off usb port 1," "'Turn on' to turn on all usb ports," "'Turn off' to turn off all usb ports," " \n* Port number can be 1, 2, 3 or 4." ); return true; } Serial.print("Unknown status message:"); Serial.println(payload); return false;}
UsbControl.inoArduino
This file is responsible for the iterations with the USB power switching.
// ======================================// USB Port power control// and indication.// ======================================// Determine if one or more of the ports is poweredbool hasPoweredPorts() { for (int channel =0; channel  
WiFiClient.inoArduino
This file deals with WiFi Connectivity
// ======================================// WiFi handling// ======================================#include "Secrets.h" char ssid[] =SECRET_SSID; char pass[] =SECRET_PASS; int status =WL_IDLE_STATUS; void setupWiFi() { Serial.println("Connecting to WiFi..."); // check for the presence of the shield:if (WiFi.status() ==WL_NO_SHIELD) { Serial.println("WiFi shield not present"); // don't continue:while (true); } // attempt to connect to WiFi network:while ( status !=WL_CONNECTED) { Serial.print("Attempting to connect to WPA SSID:"); Serial.println(ssid); // Connect to WPA/WPA2 network:status =WiFi.begin(ssid, pass); // aguarde 10 segundos pela conexão:delay (10000); } // you're connected now, so print out the data:Serial.println("You're connected to the network"); printCurrentNet(); printWiFiData();}// ---------------------------------------// WiFivoid printWiFiData() { // print your WiFi shield's IP address:IPAddress ip =WiFi.localIP(); Serial.print("IP Address:"); Serial.println(ip); Serial.println(ip); // print your MAC address:byte mac[6]; WiFi.macAddress(mac); Serial.print("MAC address:"); Serial.print(mac[5], HEX); Serial.print(":"); Serial.print(mac[4], HEX); Serial.print(":"); Serial.print(mac[3], HEX); Serial.print(":"); Serial.print(mac[2], HEX); Serial.print(":"); Serial.print(mac[1], HEX); Serial.print(":"); Serial.println(mac[0], HEX);}void printCurrentNet() { // print the SSID of the network you're attached to:Serial.print("SSID:"); Serial.println(WiFi.SSID()); // print the MAC address of the router you're attached to:byte bssid[6]; WiFi.BSSID(bssid); Serial.print("BSSID:"); Serial.print(bssid[5], HEX); Serial.print(":"); Serial.print(bssid[4], HEX); Serial.print(":"); Serial.print(bssid[3], HEX); Serial.print(":"); Serial.print(bssid[2], HEX); Serial.print(":"); Serial.print(bssid[1], HEX); Serial.print(":"); Serial.println(bssid[0], HEX); // print the received signal strength:long rssi =WiFi.RSSI(); Serial.print("signal strength (RSSI):"); Serial.println(rssi); // print the encryption type:byte encryption =WiFi.encryptionType(); Serial.print("Encryption Type:"); Serial.println(encryption, HEX); Serial.println();}String hostName ="www.google.com";void doPing() { Serial.print("Pinging "); Serial.print(hostName); Serial.print(":"); int pingResult =WiFi.ping(hostName); if (pingResult>=0) { Serial.print("SUCCESS! RTT ="); Serial.print(pingResult); Serial.println ("ms"); } else { Serial.print("FAILED! Error code:"); Serial.println(pingResult); }} void reconnectWiFi() { // attempt to reconnect to WiFi network if the connection was lost:while ( status !=WL_CONNECTED) { Serial.print("Attempting to connect to WPA SSID:"); Serial.println(ssid); // Connect to WPA/WPA2 network:status =WiFi.begin(ssid, pass); if (status ==WL_CONNECTED) { Serial.print("You're re-connected to the network"); printCurrentNet(); printWiFiData(); Retorna; } delay(5000); }} 
Secrets.hArduino
You need to update this with your own settings.
#define SECRET_SSID ""#define SECRET_PASS ""/************************* Tinamous MQTT Setup *********************************/#define MQTT_SERVER ".tinamous.com"#define MQTT_SERVERPORT 8883 #define MQTT_USERNAME "."#define MQTT_PASSWORD "The devices password"#define MQTT_CLIENT_ID "A random client id"#define DEVICE_USERNAME ""

Peças personalizadas e gabinetes

This is the best bet if you don't know how you'll connect. It's got holes for the Arduino, terminal block and additional USB micro.This is the all connectors version, but doesn't include the first layers of text which some printers may struggle with.This is the simplest version and quickest to print.

Esquemas

Send this off to OSHPark or DirtyPCBs to get your own one made. arduinostandaloneusbswitch-4port_q16AoF01Aq.brd arduinostandaloneusbswitch-v2_Xd45dtjndI.sch
GitHub USB Power Switcher Repository
You want:Arduino/StandAlone/ folder and the 4 port version.https://github.com/ThingySticks/USBPowerSwitcher

Processo de manufatura

  1. Instrução C# switch
  2. Carregadores de bateria oferecem maior densidade de energia, carregamento mais rápido
  3. Sensor de queda de energia
  4. Raspberry Pi / Hologram SMS interruptor de alimentação CA controlado
  5. Força do vento
  6. Guia para martelos elétricos
  7. O que é uma prensa automática de energia?
  8. O que é um Power Chuck?
  9. Um guia rápido para mandris de potência
  10. Entendendo a energia hidrelétrica