Conteúdo


Explore o MQTT e o serviço de Internet of Things no IBM Bluemix

Use um aplicativo Java de amostra ou o editor do Node-RED para saber como funciona

Comments

O serviço IBM Bluemix Internet of Things (IoT) oferece a capacidade simples, mas eficiente, de interconectar diferentes tipos de dispositivos e aplicativos no mundo todo. O que torna isso possível? O segredo por trás do serviço Bluemix IoT é o MQTT, Message Queue Telemetry Transport. Neste tutorial, você verá como o MQTT funciona e como é possível facilmente desenvolver aplicativos usando o serviço IoT.

O que será necessário para desenvolver o aplicativo

  • Uma conta do Bluemix
  • Familiaridade com a linguagem de programação Java
  • Familiaridade com MQTT
  • Opcionalmente, familiaridade com Node-RED

Execute o aplicativoObtenha o código

MQTT, um protocolo de mensagem de publicar/assinar simples e leve sobre o protocolo TCP/IP, é o protocolo ideal para o mundo de IoT emergente.

Em termos gerais, o serviço Bluemix IoT atua como um broker do MQTT, sendo responsável por distribuir mensagens para clientes conectados (dispositivos e aplicativos). Dispositivos incluem máquinas que publicam informações que elas detectam e aplicativos são os programas que consomem as informações recebidas desses dispositivos. Dispositivos e aplicativos comunicam-se com o broker do MQTT usando o protocolo MQTT, como mostrado:

Diagram showing how the MQTT broker relates to the MQTT clients
Diagram showing how the MQTT broker relates to the MQTT clients


Um aplicativo usando o serviço Bluemix IoT costuma consistir em três partes:

  • Configuração do serviço Bluemix IoT (registro do dispositivo e do aplicativo)
  • Programação no lado do dispositivo
  • Programação no lado do aplicativo

Pronto para experimentar?

Etapa 1. Configurar o serviço Bluemix IoT

Nesta etapa, você registrará dispositivos e aplicativos com o serviço Bluemix IoT.

Criar um aplicativo no painel

  1. Efetue login no Bluemix usando sua conta do Bluemix.
  2. Clique em Catalog no menu superior.
  3. Na seção Boilerplates, clique em Internet of Things Foundation Starter.
  4. No campo Name, especifique um nome exclusivo para o aplicativo. Para este tutorial, usamos bluemixmqtt.
  5. Clique em CREATE. Espere o aplicativo iniciar.

Adicionar o serviço IoT

  1. Clique em ADD A SERVICE.
  2. Escolha Internet of Things service na seção Internet of Things.
  3. Clique em CREATE. Clique em Restage se solicitado.

Um aplicativo com o serviço IoT agora é criado de modo similar a este:

Screen capture showing the app in Bluemix
Screen capture showing the app in Bluemix

Ative o console de serviço de IoT

  1. Navegue para a página Overview do aplicativo e clique em Internet of Things.
  2. Clique em Launch dashboard para abrir o console do serviço IoT.

Registre o dispositivo

  1. Clique em Add Device na guia Devices. Screen capture showing Add Device
    Screen capture showing Add Device
  2. Escolha Create a device type para a opção Device Type.
  3. Preencha Device Type como MQTTDevice. Usaremos esse valor mais tarde.
  4. Preencha Device ID com um ID exclusivo, por exemplo, aabbccddee12. Você pode inserir seu próprio identificador.
  5. Clique em Continue. Screen capture showing device registration
    Screen capture showing device registration
  6. Copie as informações do dispositivo; elas serão usadas mais tarde. Screen capture showing device connections
    Screen capture showing device connections
  7. Clique em Done.

Repita as etapas acima para registrar mais dispositivos, se desejar.

Registre o aplicativo

  1. Na guia API Keys, clique em New API Key. Screen capture showing New API Key
    Screen capture showing New API Key
  2. Copie as informações no diálogo New API Key; elas serão usadas mais tarde. Screen capture showing New API Key data
    Screen capture showing New API Key data
  3. Clique em OK.

Repita as etapas acima para registrar mais aplicativos, se desejar.

Etapa 2. Criar um programa no lado do dispositivo

Programação do lado do dispositivo consiste em três partes:

  • Conectar-se ao serviço IoT (broker do MQTT)
  • Publicar eventos em aplicativos
  • Assinar comandos de aplicativos

Nesta seção, você desenvolverá um programa simples do lado do dispositivo em Java com Eclipse Paho Java. Para obter mais informações, veja o código-fonte.

Conectar-se ao serviço de IoT

O ponto de acesso para o serviço IoT (broker MQTT) é <orgid>.messaging.internetofthings.ibmcloud.com, em que <orgid> é criado automaticamente quando o serviço IoT é configurado. É possível usar TCP ou TLS (Segurança da Camada de Transporte).

tcp://<org-id>.messaging.internetofthings.ibmcloud.com:1883
ssl://<org-id>.messaging.internetofthings.ibmcloud.com:8883

Para conectar-se ao serviço IoT como um cliente do dispositivo, é preciso definir as opções de conexão do MQTT.

  • A propriedade client-id deve estar na forma d:<orgid>:<type-id>:<divice-id>.


    <orgid> é o mesmo que o acima, enquanto <type-id> e <divice-id> foram inseridos anteriormente durante o registro dos dispositivos.

  • A propriedade authmethod deve ser definida para use-token-auth.
  • A propriedade authtoken deve ser definida para o campo auth-token a partir das informações do dispositivo copiadas anteriormente.

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.MqttHandler.java. Você pode escolher usar TCP ou TLS. Se estiver usando TLS, deverá definir property com.ibm.ssl.protocol para TLSv1.2; caso contrário, a conexão poderá falhar.

	public void connect(String serverHost, String clientId, String authmethod,
			String authtoken, boolean isSSL) {
		// check if client is already connected
		if (!isMqttConnected()) {
			String connectionUri = null;
			
			//tcp://<org-id>.messaging.internetofthings.ibmcloud.com:1883
			//ssl://<org-id>.messaging.internetofthings.ibmcloud.com:8883
			if (isSSL) {
				connectionUri = "ssl://" + serverHost + ":" + DEFAULT_SSL_PORT;
			} else {
				connectionUri = "tcp://" + serverHost + ":" + DEFAULT_TCP_PORT;
			}
                       
			if (client != null) {
				try {
					client.disconnect();
				} catch (MqttException e) {
					e.printStackTrace();
				}
				client = null;
			}
                       
			try {
				client = new MqttClient(connectionUri, clientId);
			} catch (MqttException e) {
				e.printStackTrace();
			}
                       
			client.setCallback(this);
                       
			// create MqttConnectOptions and set the clean session flag
			MqttConnectOptions options = new MqttConnectOptions();
			options.setCleanSession(true);
                      
			options.setUserName(authmethod);
			options.setPassword(authtoken.toCharArray());
                      
			//If SSL is used, do not forget to use TLSv1.2
			if (isSSL) {
				java.util.Properties sslClientProps = new java.util.Properties();
				sslClientProps.setProperty("com.ibm.ssl.protocol", "TLSv1.2");
				options.setSSLProperties(sslClientProps);
			}
                      
			try {
				// connect
				client.connect(options);
				System.out.println("Connected to " + connectionUri);
			} catch (MqttException e) {
				e.printStackTrace();
			}
		}
	}

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.DeviceTest.java. Esse código lê o arquivo de configuração e define as opções de conexão MQTT com os valores do arquivo de configuração nos formatos corretos.

               //Read properties from the conf file
		Properties props = MqttUtil.readProperties("device.conf");
               
		String org = props.getProperty("org");
		String id = props.getProperty("deviceid");
		String authmethod = "use-token-auth";
		String authtoken = props.getProperty("token");
		//isSSL property
		String sslStr = props.getProperty("isSSL");
		boolean isSSL = false;
		if (sslStr.equals("T")) {
			isSSL = true;
		}
               
		System.out.println("org: " + org);
		System.out.println("id: " + id);
		System.out.println("authmethod: " + authmethod);
		System.out.println("authtoken: " + authtoken);
		System.out.println("isSSL: " + isSSL);
               
		String serverHost = org + MqttUtil.SERVER_SUFFIX;
               
		//Format: d:<orgid>:<type-id>:<divice-id>
		String clientId = "d:" + org + ":" + MqttUtil.DEFAULT_DEVICE_TYPE + ":"
				+ id;
		handler = new DeviceMqttHandler();
		handler.connect(serverHost, clientId, authmethod, authtoken, isSSL);

Observação: para conectar-se ao serviço Bluemix IoT, é preciso usar MQTT pelo menos no nível da Versão 3.1; MQTT 3.1.1 é recomendado para funcionalidade mais avançada.

Publicar eventos

Tópicos de evento devem ser publicados nesta forma: iot-2/evt/<event-id>/fmt/<format>. A anotação <event-id> é definida para classificar diferentes tipos de eventos; você pode escolher seu próprio valor. O <format> é definido para json. A mensagem deve ser codificada em JSON e conter uma única propriedade de nível superior chamada "d".

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.DeviceTest.java. Ele codifica a mensagem no formato JSON e a publica para o tópico correto.

                      //Format the Json String
			JSONObject contObj = new JSONObject();
			JSONObject jsonObj = new JSONObject();
			try {
				contObj.put("count", count);
				contObj.put("time", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
						.format(new Date()));
				jsonObj.put("d", contObj);
			} catch (JSONException e1) {
				e1.printStackTrace();
			}
                       
			System.out.println("Send count as " + count);
                      
			//Publish device events to the app
			//iot-2/evt/<event-id>/fmt/<format>
			handler.publish("iot-2/evt/" + MqttUtil.DEFAULT_EVENT_ID
					+ "/fmt/json", jsonObj.toString(), false, 0);

No programa de dispositivo de amostra, publicamos eventos com o valor de contagem incrementando a partir de 0 a cada 15 segundos. A seguir está uma mensagem de amostra. Observe que a propriedade "d" de nível superior é exibida na mensagem JSON do evento.

{
    "d": {
        "count": 3,
        "time": "2014-12-30 16:14:59"
    }
}

Assinar comandos

O tópico de assinar comandos deve estar na forma: iot-2/cmd/<cmd-type>/fmt/<format-id>. O <cmd-type> é definido para categorizar diferentes tipos de comando; você pode escolher seu próprio valor. <cmd-type> pode ser definido usando o símbolo de mais ("+") como curinga, de modo que ele possa assinar vários tipos de comandos. O <format-id> é definido para json.

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.DeviceTest.java. Demonstra como assinar a mensagem do comando.

               //Subscribe the Command events
		//iot-2/cmd/<cmd-type>/fmt/<format-id>
		handler.subscribe("iot-2/cmd/" + MqttUtil.DEFAULT_CMD_ID + "/fmt/json",
				0);

Depois do recebimento de um evento de comando, a função de retorno de chamada messageArrived é executada. O fragmento de código abaixo é de com.ibm.bluemixmqtt.DeviceTest.java. No nosso aplicativo de amostra, quando o comando é recebido do lado do aplicativo, a contagem é redefinida para o valor extraído do comando.

               public void messageArrived(String topic, MqttMessage mqttMessage)
				throws Exception {
			super.messageArrived(topic, mqttMessage);
			
			//Check whether the event is a command event from app
			if (topic.equals("iot-2/cmd/" + MqttUtil.DEFAULT_CMD_ID
					+ "/fmt/json")) {
				String payload = new String(mqttMessage.getPayload());
				JSONObject jsonObject = new JSONObject(payload);
				String cmd = jsonObject.getString("cmd");
				//Reset the count
				if (cmd != null && cmd.equals("reset")) {
					int resetcount = jsonObject.getInt("count");
					count = resetcount;
					System.out.println("Count is reset to " + resetcount);
				}
			}
		}

Observação: para mais informações sobre programação no lado do dispositivo, veja https://developer.ibm.com/iot/recipes/improvise-connect-quickstart/.

Etapa 3. Criar um programa no lado do aplicativo

Como acontece com programação no lado do dispositivo, a programação no lado do aplicativo consiste em três partes:

  • Conectar-se ao serviço IoT (broker do MQTT)
  • Assinar eventos de dispositivo ou do broker do MQTT
  • Publicar comandos para dispositivos

Nesta seção, você desenvolverá um programa simples do lado do aplicativo em Java com Eclipse Paho Java. Para obter mais informações, veja o código-fonte.

Conectar-se ao serviço IoT

O ponto de acesso para o serviço IoT é o mesmo que o do lado do dispositivo, embora haja algumas diferenças entre os formatos da opção de conexão do MQTT:

  • A propriedade client-id deve estar na forma a:<orgid>:<app-id>. <orgid> é o mesmo que no lado do dispositivo e <app-id> é o conjunto de IDs exclusivo para o seu aplicativo; você pode escolher o seu próprio.
  • As propriedades authmethod e authtoken devem ser definidas para campos relevantes (Key e Auth Token) a partir das informações do aplicativo copiadas anteriormente.

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.APPTest.java. Ele lê do arquivo de configuração e define as propriedades de conexão do MQTT com os valores do arquivo de configuração nos formatos corretos.

               //Read properties from the conf file
		Properties props = MqttUtil.readProperties("app.conf");
               
		String org = props.getProperty("org");
		String id = props.getProperty("appid");
		String authmethod = props.getProperty("key");
		String authtoken = props.getProperty("token");
		//isSSL property
		String sslStr = props.getProperty("isSSL");
		boolean isSSL = false;
		if (sslStr.equals("T")) {
			isSSL = true;
		}
		
		System.out.println("org: " + org);
		System.out.println("id: " + id);
		System.out.println("authmethod: " + authmethod);
		System.out.println("authtoken" + authtoken);
		System.out.println("isSSL: " + isSSL);
               
		//Format: a:<orgid>:<app-id>
		String clientId = "a:" + org + ":" + id;
		String serverHost = org + MqttUtil.SERVER_SUFFIX;
               
		handler = new AppMqttHandler();
		handler.connect(serverHost, clientId, authmethod, authtoken, isSSL);

Assinar eventos

O lado do aplicativo pode assinar dois tipos de eventos: (1) mensagens de status do lado do dispositivo e (2) mensagens do monitor de conexão geradas pelo sistema.

  • O tópico para assinar eventos do lado do dispositivo deve estar na forma: iot-2/type/<type-id>/id/<device-id>/evt/<event-id>/fmt/<format-id>. Deve ser consistente com a forma do evento no lado do dispositivo. Um símbolo de mais ("+") pode ser usado como curinga, o que corresponderia a exatamente um nível na árvore de tópicos.
  • O tópico para assinar eventos do sistema deve estar nesta forma: iot-2/type/<type-id>/id/<device-id>/mon. Neste caso, também é possível usar um símbolo de mais ("+") como curinga. Ao assinar eventos do sistema, é possível receber as mensagens sempre que um dispositivo se conectar ou desconectar do serviço IoT.

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.APPTest.java. Os eventos do sistema e do dispositivo são inscritos.

               handler.subscribe("iot-2/type/" + MqttUtil.DEFAULT_DEVICE_TYPE
				+ "/id/+/mon", 0);
		
		//Subscribe Device Events
		//iot-2/type/<type-id>/id/<device-id>/evt/<event-id>/fmt/<format-id>
		handler.subscribe("iot-2/type/" + MqttUtil.DEFAULT_DEVICE_TYPE
				+ "/id/+/evt/" + MqttUtil.DEFAULT_EVENT_ID + "/fmt/json", 0);

Quando um evento é recebido, a função de retorno de chamada messageArrived é executada. No nosso aplicativo de amostra, verificamos o valor de contagem na mensagem. Se o valor de contagem atingir 4, começamos um novo encadeamento para publicar um comando para o dispositivo correspondente para redefinir o valor de contagem para 0. Para obter mais informações, veja o arquivo com.ibm.bluemixmqtt.APPTest.java da classe.

             public void messageArrived(String topic, MqttMessage mqttMessage)
				throws Exception {
			super.messageArrived(topic, mqttMessage);
                       
			Matcher matcher = pattern.matcher(topic);
			if (matcher.matches()) {
				String deviceid = matcher.group(1);
				String payload = new String(mqttMessage.getPayload());
				
				//Parse the payload in Json Format
				JSONObject jsonObject = new JSONObject(payload);
				JSONObject contObj = jsonObject.getJSONObject("d");
				int count = contObj.getInt("count");
				System.out.println("Receive count " + count + " from device "
						+ deviceid);
                         
				//If count >=4, start a new thread to reset the count
				if (count >= 4) {
					new ResetCountThread(deviceid, 0).start();
				}
			}
		}

Publicar comandos

O tópico para publicar comandos deve estar nesta forma: iot-2/cmd/<cmd-type>/fmt/<format-id>. Ele deve ser consistente com a forma de comando no lado do dispositivo.

O fragmento de código a seguir é da classe com.ibm.bluemixmqtt.APPTest.java. Ele publica o comando reset para o dispositivo correspondente quando o valor de contagem atinge 4. Esse comando obviamente é codificado em formato JSON também.

                      JSONObject jsonObj = new JSONObject();
			try {
				jsonObj.put("cmd", "reset");
				jsonObj.put("count", count);
				jsonObj.put("time", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
						.format(new Date()));
			} catch (JSONException e) {
				e.printStackTrace();
			}
			System.out.println("Reset count for device " + deviceid);
			
			//Publish command to one specific device
			//iot-2/type/<type-id>/id/<device-id>/cmd/<cmd-id>/fmt/<format-id>
			handler.publish("iot-2/type/" + MqttUtil.DEFAULT_DEVICE_TYPE
					+ "/id/" + deviceid + "/cmd/" + MqttUtil.DEFAULT_CMD_ID
					+ "/fmt/json", jsonObj.toString(), false, 0);

Observação: para obter mais informações sobre programação no lado do aplicativo, veja https://developer.ibm.com/iot/recipes/improvise-application-development/.

Etapa 4. Executar o aplicativo

Desenvolver o projeto

  1. Bifurque o código do código-fonte.
  2. Desenvolva o projeto usando Eclipse localmente e exporte-o como um archive jar, por exemplo, "bluemixmqtt.jar". É possível localizar um exemplo compilado e outras bibliotecas de referência na pasta MyData, caso você não deseje compilar por si mesmo.

Observação: o projeto requer Java SDK 7.0 ou posterior.

Atualizar o arquivo de configuração do lado do aplicativo

O arquivo de configuração do lado do aplicativo está em MyData/app.conf. Atualize-o de acordo com as propriedades copiadas ao registrar o aplicativo anteriormente.

#Configuration files for App Side Applications

#The org field is the same org field as the Device side
org=<org>

# A unique id you choose it by yourself, maybe, abcdefg123456
appid=<appid>

# The key field from App Keys info you copied previously
key=<Key>

# The Auth Token field from App Keys info you copied previously
token=<Auth_Token>

#T or F, T means using SSL, while F means not
isSSL=F

Executar o programa no lado do aplicativo

Depois da atualização do arquivo de configuração, abra uma linha de comando, vá para a pasta MyData e execute o seguinte comando para executar o programa no lado do aplicativo:
java -cp .;org.eclipse.paho.client.mqttv3.jar;json4j-apache-1.1.0.jar;bluemixmqtt.jar com.ibm.bluemixmqtt.AppTest

Quando o programa no lado do aplicativo tiver sido conectado com sucesso ao serviço IoT, você deve receber uma mensagem de confirmação similar a esta:

Screen capture showing confirmation message
Screen capture showing confirmation message

Atualizar o arquivo de configuração no lado do dispositivo

O arquivo de configuração no lado do dispositivo está em MyData/device.conf. Atualize-o conforme as propriedades copiadas ao registrar o dispositivo anteriormente.

#Configuration files for Device Side Applications
           
#The org field from Device info you copied previously
org=<org>
           
#The id field from Device info you copied previously
deviceid=<id>
           
#The auth-token field from Device info you copied previously
token=<auth-token>
           
#T or F, T means using SSL, while F means not
isSSL=F

Executar o programa no lado do servidor

Depois da atualização do arquivo de configuração, abra uma linha de comando, vá para a pasta MyData e execute o seguinte comando para executar o programa do lado do dispositivo.
java -cp .;org.eclipse.paho.client.mqttv3.jar;json4j-apache-1.1.0.jar;bluemixmqtt.jar com.ibm.bluemixmqtt.DeviceTest

Quando o programa do lado do dispositivo tiver sido conectado com sucesso ao serviço IoT, você deverá receber uma mensagem de confirmação similar a esta:

Screen capture showing connection confirmation
Screen capture showing connection confirmation

Verificar aplicativos em execução

Programas no lado do dispositivo publicam mensagens de evento de status (com o valor de contagem incrementando a partir de 0 a cada 15 segundos). É possível localizar logs relevantes (incluindo detalhes de mensagens de evento e comando) na linha de comando.

Além disso, é possível seguir as etapas abaixo para visualizar os detalhes do evento no console de serviço de IoT.

  1. Navegue para o console de serviço IoT.
  2. Na guia Devices, observe o que acontece aos dispositivos relevantes. Neste caso, o ID do dispositivo é aabbccddee12. Screen capture showing running applications
    Screen capture showing running applications
  3. Clique em um evento para visualizar os detalhes da mensagem.

    Preste atenção ao campo de contagem. Como mencionado anteriormente, o valor do campo de contagem está incrementando a partir de 0. Depois de atingir 4, o programa do lado do aplicativo publica um comando para o dispositivo correspondente para redefinir o valor para 0. Assim, o valor de contagem será sempre de 0 a 4, mas nunca fora do domínio.

    Screen capture showing count
    Screen capture showing count

Saiba mais

Ao seguir as etapas abaixo, é possível desenvolver um aplicativo usando o serviço Bluemix IoT por meio do protocolo MQTT. Se você estiver familiarizado com cada programação do cliente do MQTT, poderá considerar que não há diferenças significativas, exceto que, ao usar o serviço Bluemix IoT, é preciso criar propriedades — como as opções de conexão do MQTT, o formulário de assuntos de assinatura e publicação e assim por diante, — conforme o formato correto.

É mais fácil desenvolver soluções usando o serviço Bluemix IoT quando elas são baseadas em uma biblioteca do cliente do MQTT existente. A boa notícia é que há muitas bibliotecas de software livre para diferentes plataformas, como C, C++, Java, JavaScript, Ruby, Go, entre outras.

Os serviços Bluemix IoT têm suporte para uma variedade de dispositivos inteligentes conectados, como Arduino Uno, Raspberry Pi e assim por diante. Veja a documentação do Bluemix para obter informações detalhadas. Se o seu dispositivo estiver na lista, estude o código de amostra primeiro. O mecanismo de MQTT discutido anteriormente deverá ajudá-lo a entender e a modificar o código-fonte. Se o dispositivo não estiver na lista, não se preocupe. Assim como eu implementei o programa do lado do dispositivo em Java no meu aplicativo de amostra, você pode facilmente desenvolver seu próprio programa usando uma biblioteca do cliente do MQTT.

Eu implementei meu programa do lado do aplicativo em Java, mas você pode escolher outra linguagem de programação, como Node.js ou Ruby. para facilitar a programação no lado do aplicativo, é possível usar o editor de fluxo baseado em navegador Node-RED em vez de codificá-lo localmente. Esteja você desenvolvendo sozinho ou usando Node-RED, o fluxo MQTT sob o serviço Bluemix IoT funciona da mesma maneira.

Programação do lado do aplicativo via Node-RED (opcional)

Se você estiver interessado em usar a ferramenta Node-RED para desenvolver seu programa do lado do aplicativo, siga estas etapas.

O Node-RED é baseado no tempo de execução do Node.js, e está incluído no texto padrão do Internet of Things Foundation Starter criado anteriormente.

  1. Navegue para a URL do aplicativo, que normalmente é http://<app_name>.mybluemix.net. Nesse caso, é http://bluemixmqtt.mybluemix.net.
  2. Clique no botão Go to your Node-RED flow editor . Pode ser necessário rolar um pouco para baixo para ver o botão.
  3. Clique no símbolo de menu na seção superior direita. Com o ponteiro do mouse sobre Workspaces, clique em Add para incluir uma nova área de trabalho. Screen capture showing adding workspaces
    Screen capture showing adding workspaces
  4. Clique no símbolo de menu na seção superior direita. Com o ponteiro do mouse sobre Import..., clique em Clipboard para importar o fluxo. Screen capture showing importing to clipboard
    Screen capture showing importing to clipboard
  5. Copie o conteúdo de MyData/redsample.txt no código-fonte para o campo de texto Nodes, depois clique em OK.Screen capture showing importing nodes
    Screen capture showing importing nodes
  6. Uma confirmação indica que o fluxo foi importando.Screen capture showing flow
    Screen capture showing flow
  7. Clique duas vezes em cada bloco de fluxo. Você verá o diálogo de configuração. Esses parâmetros podem parecer familiares assim como eram familiares àqueles usados no desenvolvimento do programa do lado do aplicativo em Java. Screen capture showing configuration dialogue
    Screen capture showing configuration dialogue
  8. Clique no botão Deploy na seção superior direita para implementar um programa do lado do aplicativo.
  9. É possível executar o programa do lado do dispositivo novamente, e você obterá resultados similares. No painel direito do editor, é possível visualizar as mensagens do lado do dispositivo também.

É mais fácil e simples desenvolver seu próprio programa do lado do aplicativo usando o editor de GUI do Node-RED. O Node-RED fornece muitos blocos de fluxo integrados para que seja possível conectá-los de modo fácil e implementá-los imediatamente. Para obter mais informações sobre o uso de Node-RED em IoT, veja a documentação do Bluemix.

Observação: não é necessário registrar o aplicativo no console do serviço IoT manualmente, uma vez que ele será registrado automaticamente ao usar o editor Node-RED. Escolha a opção Bluemix Service for Authentication quando avisado.

Conclusão

É simples e interessante desenvolver aplicativos com o serviço Bluemix Internet of Things (IoT). Neste tutorial, exploramos o mundo do MQTT por trás do serviço IoT e explicamos como ele funciona. Um tutorial passo a passo mostrou como desenvolver uma solução de amostra usando MQTT com Java ou o editor de Node-RED. Uma vez que o conceito de IoT pode ser usado em muitos cenários diferentes, é possível usar o aplicativo de amostra como referência e compor suas próprias soluções usando o serviço Bluemix IoT para ajudar a interconectar o mundo todo.


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, Tecnologia Java, Internet of Things
ArticleID=1024952
ArticleTitle=Explore o MQTT e o serviço de Internet of Things no IBM Bluemix
publish-date=12292015