Conteúdo


Desenvolva sensores mais inteligentes com os serviços do Bluemix Business Rules, Watson IoT Platform e Insights for Weather

Comments

Com o Watson Internet of Things (IoT) Platform no IBM Bluemix, seus aplicativos podem usar informações de dispositivos conectados. Por exemplo, é possível projetar aplicativos para verificar a temperatura dos sensores e disparar uma ação com base na temperatura. Com o gerenciamento de decisão flexível do serviço Business Rules no Bluemix, é possível capturar decisões na forma de regras de negócios que são externas aos seus aplicativos.

Este tutorial mostra como usar o serviço Business Rules para gerar avisos com base nos dados da temperatura recuperados por meio do serviço Watson IoT Platform. Ele também mostra como modificar facilmente as decisões sobre quando os avisos são gerados, sem precisar introduzir mudanças de código no aplicativo IoT. O Cliente também aprende como comparar informações do sensor em tempo real e o clima com o serviço Insights for Weather.

Após concluir este tutorial, será possível usar o poder das regras de negócios em uma solução IoT com serviços do Bluemix. Use o código de amostra como um projeto iniciador para uma solução de gerenciamento de energia de casa inteligente.

O que é necessário para construir seu aplicativo

Etapa 1. Crie um app iniciador do Watson IoT Platform

Inicie explorando como o app iniciador do IoT Platform existente usa dados do sensor simulados e regras simples que são definidas no editor de fluxo Node-RED para gerar avisos de alta temperatura.

  1. Crie um app iniciador do IoT Platform seguindo as instruções em Criando apps com o aplicativo iniciador do Internet of Things em Uso. Em seguida, abra o editor de fluxo Node-RED, conforme mostrado na captura de tela a seguir. Node-RED                     flow editor for the IoT Platform starter                     app
    Node-RED flow editor for the IoT Platform starter app
  2. Siga as instruções para configurar o sensor simulado no Node-RED e os nós a seguir: o nó IBM Iot App In se conecta ao dispositivo simulado e o nó device data exibe o conteúdo do objeto de mensagem proveniente do dispositivo simulado na área de janela de depuração.
  3. Implemente o fluxo e consulte as mensagens de status Temperatura na área de janela de depuração à direita.
  4. Use o simulador do sensor para aumentar o valor da temperatura e veja a saída do nó device data na área de janela de depuração à direita. Observe o elemento payload da mensagem, que contém um elemento d , que possui os atributos name, temp, humidity, objectTemp , conforme mostrado na captura de tela a seguir. O sensor simulado contém dados neste formato. Debug pane after sensor simulator temperature                     change
    Debug pane after sensor simulator temperature change
  5. Explore o nó temp thresh para ver as regras que determinam se a temperatura está dentro dos limites seguros, conforme mostrado na captura de tela a seguir. Rules for temperature threshold
    Rules for temperature threshold
  6. Use o simulador do sensor para aumentar o valor da temperatura e veja a mudança de mensagens na área de janela de depuração à direita, conforme visto na captura de tela a seguir. Para ver como as regras geram uma mensagem diferente com um aviso de alta temperatura, aumente a temperatura, deixando-a acima de 40 graus Celsius.Debug pane after sensor simulator temperature                     change
    Debug pane after sensor simulator temperature change

O restante do tutorial explora como usar o serviço Business Rules para incorporar regras complexas no app IoT Platform que foi criado, também chamado de app IoT. Estas regras calculam a sensação térmica usando dados de temperatura e de umidade do sensor e geram avisos de acordo com a sensação térmica e o tipo do sensor (interno ou externo).

Etapa 2. Crie uma instância de serviço Business Rules

Agora que você explorou o app IoT, é possível criar uma instância de serviço Business Rules que o app usa para executar regras de negócios complexas. Estas regras de negócios não estão definidas no editor de fluxo Node-RED do app IoT. Em vez disso, elas são designadas e executadas com o serviço Business Rules.

  1. Efetue login no Bluemix e crie um espaço com um nome como dev.
  2. Crie uma instância de serviço Business Rules, conforme descrito na documentação Criando uma instância de serviço Business Rules do Bluemix. No catálogo do Bluemix, em Web and Application Services, selecione o serviço Business Rules.
  3. Em Incluir Serviço, digite dev para o espaço e MyApp para o nome de seu app IoT para ligar a instância de serviço Business Rules. Clique em CRIAR. Deve-se remontar o app IoT.
  4. Explore a guia Configurações de Conexão para a instância de serviço Business, conforme mostrado na captura de tela a seguir. É possível ver o ID da instância de serviço (iniciando com brsv2-) na URL. Também é possível ver o nome de usuário e a senha para usar a instância de serviço, que você usa na Etapa 4 para implementar regras para a instância de serviço e na Etapa 6 para configurar o fluxo de Node-RED do app IoT para executar regras com a instância de serviço. Connection Settings of the Business Rules service                     instance
    Connection Settings of the Business Rules service instance

Etapa 3. Defina regras de negócios com o Rule Designer

Agora é necessário definir as regras de negócios executadas pelo app IoT usando a instância de serviço. As regras são designadas no Rule Designer baseado no Eclipse.

  1. Instale o Rule Designer para o serviço Business Rules em seu Eclipse Juno 4.2.2 IDE, conforme descrito na documentação Desenvolvimento para o serviço Business Rules.
  2. Faça o download dos projetos sensor-xom e sensor-rules a partir do link da documentação. Importe-os em sua área de trabalho do Eclipse e, em seguida, alterne para a perspectiva Regra para abrir o Rule Explorer.
  3. Explore o modelo de objeto de execução (XOM), que é o modelo de tempo de execução no qual as regras são executadas. O XOM é definido no projeto Java sensor-xom , mas ele também pode ser baseado em XML. Explore a classe Sensor , a qual representa as informações que são recebidas de um sensor e é definida com os atributos a seguir. Observe como os quatro primeiros atributos na lista a seguir correspondem aos dados de carga útil da mensagem na Etapa 1: Crie um app iniciador do Watson IoT Platform.

    name (Nome do Sensor)

    temp (Temperatura do sensor em Centígrados)

    humidity (Porcentagem de umidade, intervalo de 0 a 100)

    objectTemp (Temperatura do objeto em Centígrados)

    type (Tipo de sensor, por exemplo, "indoor" ou "outdoor")

    feelsLikeTemp (A sensação térmica em Centígrados, a ser calculada a partir de temp e humidity)

    warning (Aviso de temperatura, a ser gerado com base em feelsLikeTemp)

    Ele também contém um método computeFeelsLikeTemperature() que calcula a sensação térmica com base na umidade e na temperatura.

  4. Explore o projeto sensor-rules e a entrada do modelo de objeto de negócios (BOM) sensors , a qual é criada a partir do XOM no Rule Designer. Esta entrada da BOM já está criada no código de amostra para você usar neste tutorial. Ela contém uma classe Sensor que corresponde à classe Sensor que está definida em Java, mostrada na captura de tela a seguir.Connection Settings of the Business Rules service                     instance
    Connection Settings of the Business Rules service instance
  5. Explore a pasta rules no projeto de regra sensor-rules . Ela contém a tabela de decisão generateWarning e o fluxo de regra principal, conforme mostrado na captura de tela a seguir. A tabela de decisão generateWarning gera o aviso de temperatura, que depende do tipo do sensor e do valor da sensação térmica.Generate warnings based on the feels like                     temperature
    Generate warnings based on the feels like temperature

    A ação inicial do mainRuleflow calcula a sensação térmica, a partir da temperatura e da umidade especificadas nos dados de entrada, conforme visto na captura de tela a seguir.

    Ruleflow with the initial actions
    Ruleflow with the initial actions

    Sendo assim, o fluxo de regra executa a tabela de decisão generateWarning na tabela no pacote sensor . Quando o conjunto de regras é executado, o fluxo de regra executa as regras na ordem especificada.

  6. Defina o contrato entre a lógica de negócios e seu aplicativo cliente com parâmetros de conjunto de regras. É possível ver os parâmetros de conjunto de regras definidos clicando com o botão direito no projeto sensor-rules e selecionando Propriedades. O nome do parâmetro de entrada/saída é sensor e possui um tipo Sensor , conforme mostrado na captura de tela a seguir. Use este nome do parâmetro na Etapa 6: Inclua novos nós no fluxo do Node-RED ao configurar o fluxo do Node-RED para fornecer dados de entrada às regras no app IoT.Ruleset parameter
    Ruleset parameter

Etapa 4. Implemente suas regras e teste a carga útil

Para executar suas regras de negócios recém-definidas a partir da instância de serviço Business Rules, deve-se implementá-las na instância criada na Etapa 2: Crie uma instância de serviço Business Rules. As regras são implementadas em archives que são chamados de RuleApps, do Rule Designer para o Rule Execution Server que está associado à instância de serviço. Conclua as etapas a seguir.

  1. No Rule Designer, crie um projeto de configuração do Rule Execution Server seguindo as etapas em Criando uma configuração do Rule Execution Server. Para a URL, o Login e a Senha na janela Configuração do Servidor, recupere as informações a partir da guia Configurações de Conexão da instância de serviço Business Rules que você criou na Etapa 2 e clique em Testar Conexão.
  2. No Rule Designer, crie um Projeto do RuleApp chamado SensorRuleApp e inclua o projeto de regra sensor-rules . No Mapa do Projeto de Regra, clique em Criar projeto do RuleApp. (Siga a Etapa 3: Crie o RuleApp na documentação Criando regras e criando um RuleApp do Bluemix.)
  3. Para implementar o RuleApp, clique com o botão direito no projeto SensorRuleApp e selecione RuleApp > Implementar. Em seguida, selecione o tipo de implementação Incrementar versão principal do RuleApp , conforme descrito na documentação Implementando o RuleApp na instância de serviço Business Rules do Bluemix. Na janela Implementar um RuleApp para Rule Execution Server, selecione a configuração do Rule Execution Server para sua instância de serviço Business Rules e certifique-se de que Implementar XOM dos projetos de regra e archives contidos no RuleApp esteja selecionado, conforme mostrado na captura de tela a seguir. Clique em Concluir.
  4. Acesse sua instância de serviço Business Rules no painel do Bluemix e selecione a guia Serviços de Decisão para ver seus RuleApps e conjuntos de regras implementados. Se necessário, clique em Atualizar , conforme mostrado na captura de tela a seguir.Decision Services tab of Business Rules                 service
    Decision Services tab of Business Rules service
  5. Clique no nome do conjunto de regras (sensorrules 1.0 neste exemplo) para abrir a página Detalhes para o conjunto de regras. Clique na guia JSON e, em seguida, clique no botão WADL (conforme mostrado no canto inferior direito da captura de tela a seguir) para assegurar que a linguagem da descrição seja gerada corretamente para o conjunto de regras. Se você vir erros, revise a Etapa 3. Defina regras de negócios com o Rule Designer para configurar o XOM adequadamente.

    Anote a URL para o conjunto de regras, a qual especifica as versões do RuleApp e do conjunto de regras configuradas ao implementar o RuleApp, com base no tipo de implementação selecionado. Use esta URL na Etapa 6: Inclua novos nós no fluxo do Node-RED ao configurar o fluxo do Node-RED do app IoT para executar o conjunto de regras.

    Ruleset Details page of Business Rules                     service
    Ruleset Details page of Business Rules service
  6. Teste a carga útil de seu conjunto de regras a partir do console do Bluemix concluindo as ações a seguir.
    • Na página Detalhes do conjunto de regras, clique em Voltar aos Serviços de Decisão para acessar a página Serviços de Decisão. Para testar o conjunto de regras, clique na seta próxima a ele. A página Teste é carregada com as áreas de janela Solicitação de Decisão e Resposta de Decisão. A área de janela Solicitação de Decisão é preenchida com uma carga útil de amostra e a área de janela Resposta de Decisão está vazia.
    • Após gerar a carga útil JSON de amostra, preencha-a com dados de teste conforme mostrado na captura de tela a seguir e clique em Executar Teste. O conjunto de regras é executado com os dados de teste e a resposta da execução de conjunto de regras é exibida em Resposta de Decisão. A resposta contém os valores para a sensação térmica e um aviso que é calculado pelas regras que foram executadas. Para obter detalhes, consulte a documentação Testando um conjunto de regras do Bluemix.Testing the Business Rules service payload
      Testing the Business Rules service payload

Etapa 5. Entenda o novo fluxo do Node-RED

Agora você estende o fluxo do Node-RED do app IoT para executar as regras que são implementadas na instância de serviço Business Rules. Estas regras calculam a sensação térmica e geram os avisos necessários.

No painel do Bluemix, acesse seu app IoT e abra o editor de fluxo Node-RED. A captura de tela a seguir mostra a aparência do fluxo concluído.

Node-RED flow with Business rules                 invocation
Node-RED flow with Business rules invocation

Os nós data changed? e data changed asseguram que as regras sejam executadas somente se a temperatura do sensor ou a umidade mudarem em uma quantidade especificada, não a cada intervalo que os dados do sensor são recebidos. O nó create rules input converte a carga útil da mensagem para o formato esperado pelas regras e o nó rules input a exibe. O nó Sensor rules inicia o conjunto de regras que é implementado na instância de serviço Business Rules e o nó rules output exibe a saída de execução de regras. Os nós get warning, new warning e show warning recuperam e exibem o aviso que é gerado pelas regras se os dados mudaram.

Etapa 6. Inclua novos nós no fluxo do Node-RED

Inclua novos nós no fluxo do Node-RED do app IoT.

Como um atalho, copie o fluxo JSON a seguir em sua área de transferência e, em seguida, importe no Node-RED, clique em Importar > Área de Transferência (ou Ctrl-I).

[{"id":"1f968581.e0697a","type":"http request","z":"fb2728c1.04d8d8","name":"Sensor rules","method":"POST","ret":"obj","url":"ruleset_url","x":654.5555801391602,"y":405.00000762939453,"wires":[["3afab48f.c5054c","e07eb510.1f8148"]]},{"id":"3afab48f.c5054c","type":"debug","z":"fb2728c1.04d8d8","name":"rules output","active":true,"console":"false","complete":"payload.sensor","x":830.5283584594727,"y":360.50000762939453,"wires":[]},{"id":"e07eb510.1f8148","type":"function","z":"fb2728c1.04d8d8","name":"get warning","func":"context.global.set(\"sensorFeelsLikeTemp\",msg.payload.sensor.feelsLikeTemp);\ncontext.global.set(\"sensorWarning\",msg.payload.sensor.warning);\n\nmsg.payload = msg.payload.sensor.warning;\nreturn msg;\n","outputs":1,"noerr":0,"x":825.5279312133789,"y":403.9722366333008,"wires":[["c55fc999.8f0318"]]},{"id":"6be8839.f94177c","type":"debug","z":"fb2728c1.04d8d8","name":"show warning","active":true,"console":"false","complete":"payload","x":1213.363624572754,"y":403.0833206176758,"wires":[]},{"id":"71fc0d5e.8bf2d4","type":"function","z":"fb2728c1.04d8d8","name":"create rules input","func":"msg.payload.sensor = msg.payload.d;\nmsg.payload.sensor.type=\"outdoor\";\nmsg.payload.sensor.warning=\"\";\ndelete msg.payload.d;\ndelete msg.payload.dataChanged;\nreturn msg;","outputs":1,"noerr":0,"x":449.74060821533203,"y":404.12271881103516,"wires":[["1f968581.e0697a","f1266aa4.b81db8"]]},{"id":"2f97466f.dc436a","type":"function","z":"fb2728c1.04d8d8","name":"data changed?","func":"var dataChanged = false;\nif ((msg.payload.d.temp >= context.global.get(\"currentTemp\") + 2) \n    ||(msg.payload.d.temp <= context.global.get(\"currentTemp\") - 2)){\n    dataChanged = true;\n} else if ((msg.payload.d.humidity >= context.global.get(\"currentHumidity\") + 5) \n    ||(msg.payload.d.humidity <= context.global.get(\"currentHumidity\") - 5)){\n    dataChanged = true;\n}\nif (dataChanged){\n    context.global.set(\"currentTemp\",msg.payload.d.temp);\n    context.global.set(\"currentHumidity\",msg.payload.d.humidity);\n    msg.payload.dataChanged = \"true\";\n} else {\n    msg.payload.dataChanged = \"false\";\n}\nmsg.headers = { \"Content-type\" : \"application/json\"};\nreturn msg;","outputs":1,"noerr":0,"x":449.5148162841797,"y":311.5407180786133,"wires":[["a7d743f4.3e8fa"]]},{"id":"f1266aa4.b81db8","type":"debug","z":"fb2728c1.04d8d8","name":"rules input","active":true,"console":"false","complete":"payload.sensor","x":651.3995132446289,"y":361.2501907348633,"wires":[]},{"id":"a7d743f4.3e8fa","type":"switch","z":"fb2728c1.04d8d8","name":"data changed","property":"payload.dataChanged","propertyType":"msg","rules":[{"t":"eq","v":"true","vt":"str"}],"checkall":"true","outputs":1,"x":448.17554473876953,"y":358.5407485961914,"wires":[["71fc0d5e.8bf2d4"]]},{"id":"c55fc999.8f0318","type":"rbe","z":"fb2728c1.04d8d8","name":"new warning","func":"rbe","gap":"","start":"","x":995.4109878540039,"y":403.5502395629883,"wires":[["6be8839.f94177c","86eba0fb.3365"]]}]

Conecte a saída IBM IoT App In à entrada data changed? . Clique duas vezes no nó Sensor rules e substitua ruleset_url pela URL da página Detalhes do conjunto de regras que você implementou na instância de serviço Business Rules na Etapa 4. Selecione Usar autenticação básica e configure o nome de usuário e a senha com as informações da guia Configurações de Conexão na Etapa 2. A janela Editar nó de solicitação de HTTP para seu nó Sensor rules deve ser semelhante ao exemplo na captura de tela a seguir:

Sensor rules node
Sensor rules node

Como alternativa, é possível criar os nós com as etapas a seguir:

  1. No editor de fluxo Node-RED, inclua um nó function (listado nos nós de filtro function na área de janela esquerda) chamado data changed?. Inclua o código a seguir para atualizar os valores da temperatura e umidade atuais no contexto global de Node-RED, se eles mudarem em uma determinada quantia e configure msg.payload.dataChanged como true.
    	var dataChanged = false;
    if ((msg.payload.d.temp >= context.global.get("currentTemp") + 2) 
     ||(msg.payload.d.temp <= context.global.get("currentTemp") - 2)){
     dataChanged = true;
    } else if ((msg.payload.d.humidity >= context.global.get("currentHumidity") + 5) 
     ||(msg.payload.d.humidity <= context.global.get("currentHumidity") - 5)){
     dataChanged = true;
    }
    if (dataChanged){
     context.global.set("currentTemp",msg.payload.d.temp);
     context.global.set("currentHumidity",msg.payload.d.humidity);
     msg.payload.dataChanged = "true";
    } else {
     msg.payload.dataChanged = "false";
    }
    msg.headers = { "Content-type" : "application/json"};
    return msg;

    Os valores que são salvos no contexto global podem ser acessados por todos os nós no fluxo. Além disso, configure os cabeçalhos da mensagem para especificar se os dados estão no formato JSON.

    Conecte a saída IBM IoT App In à entrada data changed? .

  2. Em seguida, inclua um nó switch (listado nos nós de filtro function na área de janela esquerda) chamado data changedpara verificar se msg.payload.dataChanged é true. Configure-o conforme mostrado na captura de tela a seguir. Conecte a saída data changed? à entrada data changed .Data changed node
    Data changed node
  3. Inclua um nó function chamado create rules input. Esta função inicializa o parâmetro de entrada do conjunto de regras sensor criado na Etapa 3: Defina regras de negócios com o Rule Designer com os dados recebidos do sensor. Use o código a seguir para inicializar o elemento de carga útil sensor ao elemento de carga útil d . Também é possível inicializar o atributo sensor.type para "outdoor" e o atributo sensor.warning para uma sequência de caracteres vazia.
    	msg.payload.sensor = msg.payload.d;
    msg.payload.sensor.type="outdoor";
    msg.payload.sensor.warning="";
    delete msg.payload.d;
    delete msg.payload.dataChanged;
    return msg;

    Para executar as regras apenas se a temperatura ou umidade do sensor mudar em uma quantidade específica, conecte a saída data changed à entrada create rules input .

  4. Inclua um nó debug (listado nos nós de filtro output na área de janela esquerda), chamado rules input. Configure a saída como msg.payload.sensor para imprimir os valores dos dados de regras de entrada, conforme mostrado na captura de tela a seguir. Conecte a saída create rules input à entrada rules input , conforme mostrado na captura de tela a seguir.Rules input debug node
    Rules input debug node
  5. Inclua um nó http request (listado nos nós de filtro function na área de janela esquerda), chamado Sensor rules. Use este nó para executar as regras que são implementadas na instância de serviço Business Rules como um serviço da web que usa a API REST. Recupere o valor para a URL a partir da página Detalhes do conjunto de regras que você implementou na instância de serviço Business Rules na Etapa 4: Implemente suas regras e teste a carga útil e o nome de usuário e a senha da guia Configurações de Conexão na Etapa 2: Crie uma instância de serviço Business Rules. Conecte a saída do nó create rules input à entrada do nó Sensor rules .
  6. Inclua um nó debug chamado rules output. Configure a saída como msg.payload.sensor para imprimir os valores dos dados do sensor após os cálculos das regras. Conecte a saída do nó Sensor rules à entrada do nó rules output .
  7. Inclua um nó function chamado get warning. Use o código a seguir para salvar a sensação térmica e o aviso gerado pelas regras no contexto global, para uso futuro. Retorne o aviso como a carga útil da mensagem. Conecte a saída Sensor rules à entrada get warning .
    	context.global.set("sensorFeelsLikeTemp",msg.payload.sensor.feelsLikeTemp);
    context.global.set("sensorWarning",msg.payload.sensor.warning);
    msg.payload = msg.payload.sensor.warning;
    return msg;
  8. Inclua um nó rbe (listado nos nós de filtro function na página à esquerda), chamado new warning. Para o Modo, selecione block unless value changes. Conecte a saída get warning à entrada new warning .
  9. Inclua um nó debug chamado show warning. Configure a saída como msg.payload para imprimir o aviso. Conecte a saída new warning à entrada show warning .

Etapa 7. Implemente e teste o novo fluxo

Certifique-se de que os novos nós estejam conectados conforme mostrado na Etapa 5. Entenda o novo fluxo do Node-RED. Implemente o novo fluxo e mude a temperatura do sensor em pelo menos 2 graus. Você verá que a saída para o nó rules input e o nó rules output é exibida na área de janela de depuração, o que significa que as regras foram disparadas após a mudança de 2 graus na temperatura do sensor.

Em seguida, mude a umidade do sensor para ver como o nó rules output muda na área de janela de depuração. Além disso, observe os avisos exibidos na saída show warning , por exemplo "Below freezing point!", se a sensação térmica muda para abaixo do ponto de congelamento.

A captura de tela a seguir mostra o nó rules output após a temperatura do sensor mudar para 27 graus Celsius, 34 graus Celsius e 20 graus Celsius, com uma umidade de 78%. Observe que a sensação térmica é calculada pelas regras e o aviso gerado é baseado na sensação térmica e no tipo de sensor.

Rule output data for varying sensor                     temperatures
Rule output data for varying sensor temperatures

Agora é possível usar os dados de saída de regra. Por exemplo, para dispositivos móveis, é possível criar um alerta de aviso com o serviço IBM Push Notification no Bluemix. Além disso, é possível usar o serviço Watson Text to Speech para converter o texto do aviso para fala.

Etapa 8. Modifique as regras de negócios

Agora, modifique as regras de negócios e teste se as regras modificadas forem executadas pelo app IoT.

  1. No Rule Designer, modifique suas regras no projeto sensor-rules . Na tabela de decisão generateWarning mude o valor 35 para 30 na linha destacada na captura de tela a seguir, para que o aviso Temperaturas em elevação, horário externo limite no dia seja gerado para sensação térmica maior ou igual a 30 graus Celsius em vez de 35 graus Celsius. Salve as mudanças.Modified generateWarning decision
    Modified generateWarning decision
  2. Implemente o SensorRuleApp para a instância de serviço Business Rules. Na janela Implementar um RuleApp para o Rule Execution Server, selecione o tipo de implementação Substituir versão do RuleApp .
  3. Mude a temperatura no simulador do sensor.

    Para uma sensação térmica entre 30 graus Celsius e 35 graus Celsius, você verá na área de janela de depuração que o aviso foi atualizado para 'Temperaturas em elevação, horário externo limite no dia'.

    Não é necessário mudar o app IoT para que as novas regras entrem em vigor, porque você selecionou o tipo de implementação Substituir versão do RuleApp para o RuleApp.

    Se você selecionar Incrementar a versão principal do RuleApp ou Incrementar a versão secundária do RuleApp para o tipo de implementação do RuleApp, modifique a URL no nó Sensor rules que foi incluído na Etapa 6: Inclua novos nós no fluxo do Node-RED para apontar para a versão do conjunto de regras mais recente. Implemente a mudança mais recente no editor Node-RED para certificar-se de que a nova versão das regras entraram em vigor.

  4. No fluxo do Node-RED, no nó create rules input , configure o valor de msg.payload.sensor.type para "indoor" e veja como a saída de regra e o aviso mudam conforme a temperatura ou a umidade do sensor muda para um sensor interno. Para incorporar regras com base em onde os sensores internos estão localizados na casa, é possível incluir linhas como "living room" e "bedroom" na tabela de decisão generateWarning para os tipos de sensor interno específicos.

No futuro, será possível usar este projeto de regra iniciador e estender o XOM, a BOM e as regras para gerar avisos com base na hora do dia (por exemplo, durante horas do dia e à noite). Você pode diferenciar horas do dia baseado em dias da semana e em finais de semana. Além disso, é possível configurar mais condições para diferentes estações do ano conforme mostrado na captura de tela de exemplo a seguir (não faz parte da amostra de código).

Additional conditions in generateWarning decision                     table
Additional conditions in generateWarning decision table

Etapa 9. Compare a sensação térmica a partir dos dados do sensor com o Insights for Weather

É possível usar a sensação térmica a partir do serviço Insights for Weather para comparar sensação térmica dos dados do sensor com condições de clima em tempo real (se o aviso gerado pelas regras mudou). Se você não tiver um sensor externo, poderá usar a sensação térmica do Insights para comparar com os dados do sensor interno e tomar decisões como abrir as janelas para resfriar uma sala no verão, em vez de usar ar-condicionado.

Inclua o serviço Insights for Weather em seu app IoT seguindo as instruções na seção Incluir o serviço Insights for Weather na documentação Incluindo o Insights for Weather em seu aplicativo do Bluemix. Remonte o app IoT. Acesse a instância de serviço Insights for Weather para ver a URL e as credenciais para o serviço, conforme mostrado na captura de tela a seguir.

Insights for Weather Service credentials
Insights for Weather Service credentials

Acesse o editor de fluxo Node-RED para o app IoT. Inclua nós no fluxo que usam o serviço Insights for Weather para obter a sensação térmica atual e compará-la com a sensação térmica do sensor (calculada pelo serviço Business Rules). Em seguida, exiba o resultado da comparação. A captura de tela a seguir mostra os novos nós.

Flow to compare with Insights feels like                     temperature
Flow to compare with Insights feels like temperature

Como um atalho, copie o fluxo JSON a seguir em sua área de transferência e, em seguida, clique em Importar > Área de Transferência (ou pressione Ctrl-I) para importá-lo no Node-RED.

[{"id":"86eba0fb.3365","type":"http request","z":"fb2728c1.04d8d8","name":"Insights weather","method":"GET","ret":"obj","url":"insights_url","x":658.0973892211914,"y":466.5407180786133,"wires": [["22615c13.055cb4"]]},{"id":"22615c13.055cb4","type":"switch","z":"fb2728c1.04d8d8","name":"compare 'Feels like'","property":"payload.observation.metric.feels_like","propertyType":"msg","rules":[{"t":"lt","v":"sensorFeelsLikeTemp","vt":"global"},{"t":"gte","v":"sensorFeelsLikeTemp","vt":"global"}],"checkall":"true","outputs":2,"x":882.1528091430664,"y":465.7073440551758,"wires":[["1520303b.8b7e1"],["155a17fd.51c268"]]},{"id":"1520303b.8b7e1","type":"function","z":"fb2728c1.04d8d8","name":"sensor warmer","func":"msg.payload=\"The sensor 'Feels like' temperature \" + context.global.get(\"sensorFeelsLikeTemp\") + \" is warmer than the Insights 'Feels like' temperature \" + msg.payload.observation.metric.feels_like;\nreturn msg;","outputs":1,"noerr":0,"x":1079.375099182129,"y":443.23511505126953,"wires":[["1cf07b90.02a7d4"]]},{"id":"155a17fd.51c268","type":"function","z":"fb2728c1.04d8d8","name":"sensor cooler","func":"msg.payload=\"The sensor 'Feels like' temperature \" + context.global.get(\"sensorFeelsLikeTemp\") + \" is cooler than the Insights 'Feels like' temperature \" + msg.payload.observation.metric.feels_like;\nreturn msg; \n","outputs":1,"noerr":0,"x":1077.625099182129,"y":491.48511505126953,"wires":[["1cf07b90.02a7d4"]]},{"id":"1cf07b90.02a7d4","type":"debug","z":"fb2728c1.04d8d8","name":"'Feels like' status","active":true,"console":"false","complete":"payload","x":1279.2741928100586,"y":465.5407772064209,"wires":[]}]

Conecte a saída new warning à entrada Insights weather . Clique duas vezes no nó Insights weather e substitua insights_url por url/api/weather/v2/observations/current?units=m&geocode=latitude%2Clongitude&language=en-US. Recupere a url a partir das credenciais do serviço Insights for Weather. Substitua latitude e longitude por valores para a localização geográfica atual de seu sensor, conforme mostrado na captura de tela a seguir.

Insights weather node
Insights weather node

Como alternativa, é possível criar os nós adicionais com as etapas a seguir:

  1. Acesse o editor de fluxo Node-RED para o app IoT e inclua um nó http request (listado nos nós de filtro function na área de janela esquerda), chamado Insights weather. Use este nó para executar o serviço Insights for Weather para obter o clima atual. Configure os valores mostrados na captura de tela anterior.
    • Configure a URL com o valor url/api/weather/v2/observations/current?units=m&geocode=latitude%2Clongitude&language=en-US. Recupere a url a partir das credenciais do serviço Insights for Weather. Substitua latitude e longitude por valores para a localização geográfica atual de seu sensor.
    • Leia Obtendo condições atuais na documentação do Bluemix sobre como usar o serviço Insights for Weather para obter o clima atual e como aprender o formato dos dados de resposta. A carga útil de resposta possui o atributo observation.metric.feels_like , o qual contém o valor para a sensação térmica atual.
  2. Conecte a saída new warning à entrada Insights weather .
  3. Inclua um nó switch (listado nos nós de filtro function na área de janela esquerda), chamado compare 'Feels like', para comparar a sensação térmica do Insights com a sensação térmica do sensor no contexto global. Configure-o conforme mostrado na captura de tela a seguir. Se a sensação térmica do Insights for inferior à sensação térmica do sensor, envie a mensagem à primeira saída. Caso contrário, envie a mensagem à segunda saída. Conecte a saída Insights weather à entrada compare 'Feels like' . Compare feels like node
    Compare feels like node
  4. Inclua dois nós function , chamados sensor warmer e sensor cooler.
    • Inclua o código a seguir no sensor warmer para retornar a mensagem apropriada.

      	msg.payload="The sensor 'Feels like' temperature " + context.global.get("sensorFeelsLikeTemp") + " is warmer than the Insights 'Feels like' temperature " + msg.payload.observation.metric.feels_like;
      return msg;
    • Inclua o código a seguir no sensor cooler para retornar a mensagem apropriada.

      	msg.payload="The sensor 'Feels like' temperature " + context.global.get("sensorFeelsLikeTemp") + " is cooler than the Insights 'Feels like' temperature " + msg.payload.observation.metric.feels_like;
      return msg;

      Conecte a primeira saída compare 'Feels like' à entrada sensor warmer . Conecte a segunda saída compare 'Feels like' à entrada sensor cooler .

  5. Inclua um nó debug chamado 'Feels like' status. Para imprimir o resultado da comparação da sensação térmica, configure a saída como msg.payload. Conecte as saídas sensor warmer e sensor cooler à entrada 'Feels like' status .
  6. Implemente o fluxo atualizado e mude a temperatura ou umidade do sensor. A área de janela de depuração mostra a comparação entre o sensor e sensação térmica do Insights, por exemplo: A temperatura 'Feels like' do sensor 30 é mais fria do que a temperatura 'Feels like' do Insights 35.

Conclusão

Neste tutorial, você aprendeu como usar o serviço Business Rules no Bluemix para incorporar regras complexas em um aplicativo Internet of Things. Você usou regras de negócios para introduzir mudanças de decisão sem a necessidade de modificar o aplicativo Internet of Things.

Use o que você aprendeu neste tutorial para que possa gastar menos tempo no registro e teste de seu aplicativo. Em vez disso, a lógica pode ser mudada e testada no serviço Business Rules. Esta abordagem permite maior agilidade de decisão.

Você também aprendeu como usar o serviço Insights for Weather em um aplicativo Internet of Things para incorporar informações sobre o clima em tempo real. A amostra que você criou pode ser usada como um projeto inicial para um sistema de gerenciamento de energia inteligente. Por exemplo, considere um sistema que controla o aquecimento e o resfriamento interno, dependendo das temperaturas interna e externa, o horário do dia e as mudanças sazonais. É possível incorporar e modificar estas decisões sem modificar repetidamente o fluxo de Node-RED do aplicativo IoT.

Agradecimentos

O autor gostaria de agradecer Alain Robert, Valerie Lampkin e Alex Melamed pela revisão deste tutorial.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing, Cognitive computing
ArticleID=1032565
ArticleTitle=Desenvolva sensores mais inteligentes com os serviços do Bluemix Business Rules, Watson IoT Platform e Insights for Weather
publish-date=05312016