Cada vez mais estamos em um mundo globalizado e cada vez mais conectados. Começamos com a antiga internet discada e hoje possuímos banda larga com mais de 10 MB em nossas casa. A tecnologia chegou a um nível tão avançado que buscamos agora unir todas as coisas à Internet e conectá-las.

Para quem já está acostumado a esse mundo, facilmente percebe a aderência a linguagens como Java, NodeJS e Python, mas e o PHP? O PHP é um linguagem focada para o desenvolvimento web, mas podemos, sim, utilizá-la para o mundo da Internet das coisas. Embora a linguagem não seja construída para isso, ela não deixa a desejar, se comparado às outras.

2015 definitivamente foi o ano da Internet das coisas (em inglês, IoT – Internet of Things). Em conjunto com o mobile, foram milhares de aplicativos desenvolvidos e muitas soluções inteligentes criadas. Dentre as mais famosas estão as automações residenciais, em que é possível acender a luz através de aplicativos e até mesmo controlar a temperatura ambiente da casa. Nas tecnologias mais avançadas, são construídos braços biônicos para pacientes com deficiência. E tudo isso é possível através de uma placa que cabe na palma da nossa mão.

Internet of Things é o termo utilizado para se referir aos objetos conectados, onde é possível trocar dados entre esses objetos e utilizá-los para diversos fins. A palavra Thing (traduzido como “Coisa”, literalmente) é exatamente o que parece, ou seja, conectar toda e qualquer coisa à Internet (sapato, carteira, camiseta, mesa, armário e tudo o que você imaginar).

Tudo isso é possível graças a expansão da banda larga e a evolução dos dispositivos móveis, cada vez mais rápidos e menores, isso contribuiu (e muito!) para que a evolução nos levasse para esse caminho. Hoje temos milhões de dispositivos conectados, trocando dados entre si e armazenando dados para análise.

Todos os campos de trabalho são beneficiados – agricultura, construção, transporte e educação são alguns que podemos citar. Os dispositivos utilizados no famosos mundo IoT são característicos pelo poder de processamento, capacidade de memória e armazenamento reduzido.

E entrar nessa onda, não é nada complicado; basta ter Internet e algum dispositivo para fazer a ponte da “coisa” com a Internet, e é aí nesse ponto que damos atenção ao Arduino.

Além da parte do hardware, temos também algumas linguagens de programação bem específicas para se comunicar com esses dispositivos. Como, por exemplo, o Java que hoje em dia é uma das linguagens de programação mais famosas do mundo, rodando em milhões de dispositivos, sem contar a sua utilização para aplicações de grandes organizações.

Porém, temos também o Javascript, que apesar do seu nome, nada tem a ver com o Java. Javascript, assim como PHP, é uma linguagem totalmente voltada para a web e é executada do lado do cliente, mas que teve uma revira volta muito grande, quando surgiu o NodeJS que permite a execução do Javascript no lado do servidor.

O hardware

Meu primeiro sketch

Para que possamos desenvolver ideias e caminhar para projetos mais complexos, primeiro precisamos entender como utilizar o Arduino de maneira simples e entender seu ciclo de execução.

O sketch (esse é o nome que se dá ao código que escrevemos para o Arduino) clássico que existe pela Internet é o de piscar um LED e para continuar a tradição iremos criar esse exemplo aqui.

Vamos, então, conectar o nosso hardware. Para essa parte, você pode utilizar o https://123d.circuits.io/, que simula a execução do Arduino e seus componentes – isso lhe ajudará a se familiarizar com os componentes e o código fonte escrito em C. O 123d.circuits é muito realista e qualquer ligação que você faça nele é possível replicar em um Arduino real sem alterar uma linha de código.

O nosso projeto final ficará com a seguinte cara:

O código que o Arduino irá executar é bem simples, veja:

Listagem 1. Primeiro sketch para fazer o LED piscar:

int led = 13;

void setup() {
  pinMode(led, OUTPUT);
}

void loop() {		
  digitalWrite(led, HIGH); 
  delay(1000);
  digitalWrite(led, LOW);
  delay(1000); 
}

Java

Quando ficamos familiarizados com o Arduino e entendemos como utilizá-lo, logo queremos mudar de linguagem de programação por uma série de motivos. Querer mudar por conhecer mais uma linguagem de programação, mudar porque precisa de mais recursos entre outros ou pelo simples fato de não se sentir confortável com C.

Através do site oficial do Arduino, conseguimos encontrar uma lista de linguagens de programação que possuem uma interface para trabalhar com o Arduino e, dentre elas, podemos listar Python, Ruby e, se navegarmos um pouquinho mais, encontramos o Java.

Essas de fato são linguagens que podemos utilizar facilmente para a integração com o Arduino. Com Java podemos utilizar a biblioteca RXTX para que seja possível se comunicar com a porta serial e, assim, interagir com o Arduino.

Mão na massa

A primeira parte que vamos alterar será a do Arduino. Veja o nosso novo sketch para controlar nossa LED.

Listagem 2. Skecth interagindo com portal Serial:

int led = 13;
String input = "";

void setup() {
  pinMode(led, OUTPUT);

  Serial.begin(9600);
}

void loop() {

  if (Serial.available() > 0) { 
   
    input = Serial.readString();
    
    if (input == "ON") {
      digitalWrite(led, HIGH);
    } else {
      digitalWrite(led, LOW);
    }

    Serial.println(input);
  }
}

Um ponto interessante a ressaltar aqui é que o 123d.circuits possui uma simulação muito interessante para comunicação via Serial com o Arduino. Antes de tentar rodar o novo sketch no seu Arduino real, tente simular o código no 123d.circuits. É uma maneira de agilizar o seu desenvolvimento, prever alguns erros e também uma maneira de montar uma comunicação mais inteligente.

Após escrever o todo o nosso sketch no 123d.circutis e clicar em “Upload & Run”, veja mais a direita que existe uma aba nomeada “Serial Monitor”. É através dessa aba que podemos simular como o nosso sketch se comportará se enviarmos o texto “ON” ou “OFF” – aqui é onde podemos testar diversos comportamentos sem efetivamente ter um hardware conectado. Imagine o quanto isso irá facilitar o seu trabalho antes de conectar tudo fisicamente.

Entendendo as mudanças no nosso sketch

Após organizar o nosso ambiente, podemos focar, então, no código fonte que iremos utilizar para integrar nosso Arduino com o Java. O código a seguir foi totalmente baseado no código que o site oficial do Arduino nos fornece neste link, porém foram realizadas pequenas alterações no nosso código para que seja possível atingir nosso objetivo de controlar o LED através do Java, veja:

Listagem 3. Primeiro código em Java para integrar com o Arduino:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import gnu.io.CommPortIdentifier; 
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent; 
import gnu.io.SerialPortEventListener; 
import java.util.Enumeration;


public class SerialTest implements SerialPortEventListener {
    SerialPort serialPort;
    
    private static final String PORT_NAMES[] = {
    	"/dev/ttyACM0",
    };
    
    private BufferedReader input;
    
    /** The output stream to the port */
    private OutputStream output;
    
    /** Milliseconds to block while waiting for port open */
    private static final int TIME_OUT = 2000;
    
    /** Default bits per second for COM port. */
    private static final int DATA_RATE = 9600;

public void initialize() {
    CommPortIdentifier portId = null;
    Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
    
    //First, Find an instance of serial port as set in PORT_NAMES.
    while (portEnum.hasMoreElements()) {
        CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();

        for (String portName : PORT_NAMES) {
            if (currPortId.getName().equals(portName)) {
                portId = currPortId;
                break;
            }
        }
    }

    if (portId == null) {
        System.out.println("Could not find COM port.");
        return;
    }
    
    try {
        // open serial port, and use class name for the appName.
        serialPort = (SerialPort) portId.open(this.getClass().getName(),
        TIME_OUT);
        
        // set port parameters
        serialPort.setSerialPortParams(DATA_RATE,
        SerialPort.DATABITS_8,
        SerialPort.STOPBITS_1,
        SerialPort.PARITY_NONE);
        
        // open the streams
        input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
        output = serialPort.getOutputStream();
        
        // add event listeners
        serialPort.addEventListener(this);
        serialPort.notifyOnDataAvailable(true);
    } catch (Exception e) {
        System.err.println(e.toString());
    }
}

/**
 * This should be called when you stop using the port.
 * This will prevent port locking on platforms like Linux.
 */
public synchronized void close() {
	if (serialPort != null) {
		serialPort.removeEventListener();
		serialPort.close();
	}
}


/**
 * Handle an event on the serial port. Read the data and print it.
 */
public synchronized void serialEvent(SerialPortEvent oEvent) {
	if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
		try {
			String inputLine=input.readLine();
			System.out.println(inputLine);
		} catch (Exception e) {
			System.err.println(e.toString());
		}
	}
	// Ignore all the other eventTypes, but you should consider the other ones.
}

public static void main(String[] args) throws Exception {
Arduino main = new Arduino();
	main.initialize();
		
	Thread t = new Thread() {
		public void run() {
			try {
				Thread.sleep(1000000);
			} catch (InterruptedException ie) {
				System.out.println(ie.getMessage());
			}
		}
	};
		
	t.start();
	
	System.out.println("Started");
		
	Scanner in = new Scanner(System.in);
		
	String input = "";
		
	while (!input.equals("exit")) {
		input = in.nextLine();
		
		OutputStream op = main.getOutput();
		
		try {
			op.write(input.getBytes());
		} catch (IOException erro) {
			System.out.println(erro.getMessage());
		}
	}
		
	System.out.println("Ended");
	
	System.exit(0);
	
}
}

v=

O mundo do PHP

Como já citamos anteriormente, o PHP nasceu para suprir necessidades da web e faz isso de uma maneira extraordinária. Em seu último lançamento, o PHP 7 trouxe inúmeras melhorias e a que mais se destacou foi a sua performance, que também aumentou, comparada com a versão 5.6.

Hoje temos mais de 244 milhões de sites rodando em PHP provando que o PHP é uma linguagem popular e muito competitiva no mercado de trabalho, o que atrai novos desenvolvedores e empresas.

Analisando o gráfico fornecido pela Netcraft, podemos deduzir que esse número tende somente a crescer com o passar do tempo. Mas será que PHP só resolve o nosso problema da web? E os desenvolvedores que possuem anos de experiência na linguagem precisam aprender uma nova para mergulhar no IoT?

Há tempos o PHP possui funcionalidades para manipular streams, sockets e arquivos que são utilizados normalmente em web sites, mas que também podemos utilizar para qualquer coisa, como enviar dados para o Arduino. Aplicações feitas para utilizar a linha de comando também são destaques no PHP – geralmente vemos essas aplicações no formato .phar (esse formato tem o mesmo conceito que um .jar do Java).

Listagem 7. Primeira comunicação entre o PHP e o Arduino:

<?php

$resource = fopen('/dev/ttyACM0', 'r+');

if (false === $resource) {
    exit('Não foi possível enviar os dados para o Arduino');
}

fwrite($resource, "ON");

Como estamos utilizando Linux para os exemplos, o nosso Arduino está conectado na porta ttyACM0 (mas poderia ser ttyUSB0) e agora na função fopen, passamos o caminho da porta para que o PHP abstraia isso e nos retorne um resource para manipularmos.

Feito isso, fazemos uma simples checagem para saber se o PHP conseguiu abstrair corretamente a porta que o nosso Arduino está conectado. Se algo der errado, a mensagem “Não foi possível enviar os dados para o Arduino” é exibida e a execução do script PHP é finalizada.

Caso contrário, enviamos ao nosso Arduino o texto “ON” para que a LED seja acesa, pois esse é o texto que o sketch programado está esperando – qualquer outro texto enviado para o Arduino a LED será apagada.

Com isso, a comunicação entre o PHP e o Arduino está pronta e sem ter que utilizar nenhuma biblioteca externa.

Conclusão

Nos dias de hoje, os programadores estão indo além e não apenas desenvolvendo sistemas para controlar estoque, hoje os programadores precisam cada vez mais se atualizar e se manter em dia com as novas tecnologias que vão surgindo. A Internet das coisas abre diversas portas para que possamos sair do mundo digital e unificar o que é real.

A chance que temos com o avanço da tecnologia é fornecer serviços e soluções cada vez mais elegantes. Acender uma luz com o celular, controlar a temperatura da casa com um web site e até mesmo colocar a água para esquentar minutos antes de chegar em casa. Essas são soluções incríveis e ao alcance de todos, e, ainda assim, não é o suficiente.

Independentemente da tecnologia utilizada (seja ela Java, PHP, Python ou Ruby), sempre vamos ter um meio de intercalar essas tecnologias. Nesse artigo, vimos como é a integração do Arduino com o Java criando nossa classe, o nosso primeiro sketch e como resolver pequenos problemas caso ocorram, sem contar dos tipos de placas que podemos utilizar.

Arduino nano, Arduino uno e até mesmo o Intel Edison cairam nessa lista; e não pense você que para por aí! Temos inúmeras placas e inúmeros sensores para por em práticas nossas ideias.

E, finalmente, chegamos a parte do PHP, onde adaptamos o código que criamos em Java para que seja possível utilizar com o PHP. As principais diferenças que podemos citar entre essas duas tecnologias e a sua integração com o Arduino é, principalmente, a utilização de dependências e o número de linhas que utilizamos para chegar a uma integração funcional com o Arduino.

Com o Java fica claro que devemos tomar alguns passos a mais. O primeiro deles é a utilização da biblioteca RXTX e o segundo é o número de linhas de código que precisamos escrever para atingir o mesmo objetivo. Com o PHP, a integração é bem mais fácil, pois nenhuma biblioteca é necessária e precisamos de no máximo 5 linhas de código para isso.

Utilize a tecnologia que achar mais confortável, que faça você ser mais produtivo e que você consiga absorver o máximo de conhecimento. As vezes, nuances da linguagem que não conhecemos acaba atrapalhando para absorver o que queremos, que nesse caso é a integração com o Arduino.