6.

PROGRAMAÇÃO ORIENTADA A OBJETOS NO ARDUINO

6.1 Apresentação da Proposta do Trabalho

A proposta deste trabalho é desenvolver uma arquitetura de software para o

desenvolvimento de um sistema embarcado utilizando a plataforma de prototipação
Arduino, aplicando para isso a programação orientada a objetos com Java, com o
desafio de integrar estas tecnologias de forma a proporcionar a programação de
dispositivos embarcados em alto nível de abstração oferecido pela metodologia da
orientação a objetos.

A plataforma Arduino reúne as características para aplicação no desenvolvimento de

protótipos de dispositivos embarcados utilizando uma linguagem de programação
própria que possui as bases conceituais da linguagem C10. A linguagem da plataforma
Arduino tem um modelo de programação baseada na metodologia estruturada, focada
principalmente na utilização de bibliotecas de funções existentes para desempenhar as
diversas ações ou procedimentos necessários aos programas, em um formato de
código que especifica as estruturas de dados a serem manipuladas, juntamente com a
sequência de comandos em estruturas de controle de fluxo (sequencial, condicional e
repetição), utilizando as funções sempre que possível. Este é o modelo de
programação estruturada definido na década de 1970.

Com o surgimento das técnicas e padrões de programação usando a metodologia

orientada a objetos, conforme apresentado no capítulo 3 (Programação Orientada a
Objetos e Padrões de Projeto), o desenvolvimento de programas passa a adotar um
modelo de programação com um nível de abstração maior para criação de soluções,
que aproxima a forma como as pessoas vêm o mundo real, ou seja, através de objetos
10
C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa, procedural,
padronizada pela ISO, criada em 1972 por Dennis Ritchie no AT&T Bell Labs para desenvolver o sistema
operacional Unix.
Fonte: https://pt.wikipedia.org/wiki/C_(linguagem_de_programação), acessado em 05/04/2016.

66
que as cercam. Cada objeto traz consigo um conjunto de características que o fazem
existir, com um conjunto de informações a seu respeito e um conjunto de operações ou
funcionalidades que eles desempenham, formando um comportamento claro e bem
definido de suas ações no meio que se aplicam.

Esta definição de objeto no mundo da programação proporciona um conjunto de

vantagens e capacidades que implicam em uma abordagem carregada de
oportunidades de evolução e criação. Trazendo este conceito para o mundo das
tecnologias embarcadas, a proposta de arquitetura apresentada neste trabalho permite
adotar um modelo de objetos com estado e comportamento bem definidos, aplicando a
metodologia orientada a objetos desde seu projeto de hardware até sua programação
em software, a ser aplicada numa plataforma de prototipação existente (Arduino).

Este estudo remete ainda a idéia da aplicação do termo "Internet das Coisas" (ou,
em inglês, Internet of Things - IoT), que significa a existência de objetos ao nosso
redor, os quais possuem capacidade de interação através de componentes sensores e
atuadores, oferecendo desta forma alguns serviços pela interação na forma de trocas
de mensagens. Segundo Correia, Internet das coisas é a capacidade de conectar
objetos da vida real que lhes permitam alcançar um maior valor e serviço através do
intercâmbio de dados e informações. Hoje em dia, plataformas como Arduino, placas
Intel Edison, BeagleBone ou o Raspberry Pi estão oferecendo aos programadores da
Internet das Coisas um grande ecossistema de hardware que pode ser usado
facilmente para fazer um protótipo e até mesmo ir para produção

Assim, têm-se a possibilidade de criação de componentes de hardware associados a

um componente de software que comandará a comunicação destes objetos com o
meio externo, através das portas de comunicação para realização de operações úteis.
O contexto da Internet das Coisas, através da aplicação de dispositivos que
representam objetos inteligentes tem recebido atenção tanto de pesquisadores de
desenvolvimento, seja de hardware ou de software, como também da indústria de
sistemas embarcados em dispositivos (objetos) espalhados por todo o mundo, os quais

67
passam a ser utilizados pelas pessoas no dia a dia através de um mundo formado de
dispositivos e aplicações conectados.

Diante do cenário da IoT, a aplicação da Orientação a Objetos pode ajudar na

concepção e desenvolvimento de objetos que possuem interação implementada no
mundo físico, aplicando para isso uma plataforma de hardware composta de
componentes eletrônicos formando os objetos ou coisas reais, e uma linguagem de
programação que permita aplicar de forma nativa os conceitos e princípios da
metodologia orientada a objetos. Embora fora do escopo deste trabalho o detalhamento
dos conceitos da Internet das Coisas, não obstante vislumbra-se sua utilização para
propor o desenvolvimento de objetos inteligentes que possam aplicar de certa forma a
abordagem deste estudo em evolução, afetando diretamente na vida das pessoas e na
forma como atuamos em um ambiente altamente conectado.

6.2 Proposta de Arquitetura

Foi diante do contexto de aplicar a integração do conceito de sistemas embarcados

com a plataforma Arduino, e sua capacidade de prototipação de dispositivos de
hardware composto de um microcontrolador programável de forma simples e fácil, que
o presente projeto teve sua ideia concebida para aplicação da programação orientada a
objetos, a qual aproxima a visão de mundo de objetos das pessoas, no caso específico
os desenvolvedores de soluções, pois possui um modelo bem apropriado para
abstração no desenvolvimento de projetos orientados a objetos. Para que isto fosse
possível, inicialmente foi pensado na linguagem que seria utilizada para implementação
do modelo de objetos, e tal linguagem deveria ter a sua concepção de núcleo baseada
na metodologia de programação orientada a objetos, essencialmente.

A linguagem de programação Java, atendendo as condições esperadas no modelo

de objetos, em conjunto com um conjunto de características que a fazem uma
linguagem moderna e atualizada aos padrões de mercado atualmente, como
apresentado no capítulo 5 (Linguagem de Programação Java), foi escolhida como base

68
para o desenvolvimento da programação de objetos criados na plataforma Arduino, de
tal forma que o conceito de abstração deste objeto fosse levado ao nível de
desenvolvimento esperado, bem como que fossem passíveis da aplicação das técnicas
mais recentes de programação orientada a objetos e padrões de projeto, conforme
descrito no capítulo 3 (Programação Orientada a Objetos e Padrões de Projeto).

Desta forma, o projeto foi batizado como Java.ino (Java com Arduino), tendo como
objetivo principal propor uma arquitetura de desenvolvimento em alto nível de
abstração, utilizando os conceitos e princípios da programação orientada a objetos em
Java, composta de uma solução de Software implementada com as linguagens C
(linguagem do Arduino) e Java, baseado na aplicação real de dispositivos criados na
plataforma Arduino. Alguns termos utilizados na proposta arquitetural deste trabalho
foram utilizados em inglês, por escolha do autor.

Como objetivo específico da arquitetura proposta, é desenvolver componentes de

software em computadores (pcs ou smartphones) conectados com a plataforma
Arduino através de um meio de comunicação estabelecido (Serial, Ethernet, Wifi,
Bluetooth), de tal forma que estes computadores possa comandar instruções para o
controle das portas de comunicação externas digitais e analógicas do Arduino, as quais
estariam conectadas a circuitos que controlam a utilização de sensores para captação
de estímulos, bem como de atuadores para execução de alguma ação dentro do
sistema, seja de natureza lógica (software) ou física (hardware), conforme apresentado
no esquema abaixo.

69
 Figura 16 - Esquema de componentes envolvidos na arquitetura proposta
Fonte: Produzida pelo autor

6.3 Escopo do Desenvolvimento Realizado

Para o escopo do trabalho desenvolvido, por não apresentar o tempo necessário

para o desenvolvimento de todas as possibilidades que a proposta pode oferecer
através das ideias apresentadas, foi utilizado como Prova de Conceito (PoC, sigla do
inglês, Proof of Concept) a implementação utilizando uma única forma de comunicação
(Serial), conectando um computador pessoal (PC) a uma placa Arduino Uno, aplicando
a arquitetura proposta com as devidas tecnologias que serão detalhadas nas seções
seguintes.

Ainda como parte da PoC, foi criado de um protótipo de semáforo de trânsito com as
fases de "Pare", "Atenção" e "Siga". A criação do protótipo foi implementada em
hardware na plataforma Arduino através de LEDs indicadores dos estados do
semáforo, e a implementação de software foi feita utilizando o Java com os devidos
componentes da arquitetura proposta, de tal forma que fique totalmente transparente
para o desenvolvedor do programa a estrutura de hardware montada no Arduino e sua
linguagem de programação especifica. A interação do código criado em Java com a
placa será realizada através de protocolo de comunicação chamado JIP (Java.ino
Protocol), criado especificamente para estabelecer o nível de comandos de aplicação
necessários para atuação no microcontrolador, que estará executando um Sketch
especializado para tratar os comandos nas portas de comunicação do Arduino, de

70
forma totalmente transparente, tudo isso estabelecido pelo meio de comunicação
utilizado (comunicação Serial).

Vale destacar que nenhum controle de comportamento do objeto em execução é

realizado diretamente no software do Arduino, pois tudo é implementado utilizando um
alto nível de abstração com a programação orientada a objetos na linguagem Java, e
uma camada de componente de comunicação será responsável em transmitir os
comandos necessário ao Sketch que implementa o protocolo de controle das portas de
comunicação (analógicas e digitais) do Arduino.

6.4 Implementação dos Componentes Básicos

Na PoC aplicada ao projeto, foram implementados dois componentes básicos da

arquitetura proposta, conforme apresentado na figura 17.

Figura 17 - Modelo de componentes da arquitetura do Projeto Java.ino

Fonte: Produzida pelo autor

• Componente Java.ino: composto das classes que implementam as

funcionalidades e componentes das diversas configurações das placas da

71
 plataforma Arduino (Uno, Mega, Due, etc.), conforme apresentado no capítulo
8 (Plataforma de Programação Java no Arduino), bem como as classes que
implementam o protocolo de comunicação em Java, e também os respectivos
meios de comunicação com o Arduino (Serial, Bluetooth, Ethernet, Wifi, etc.),
conforme detalhes de projeto e implementação apresentados no capítulo 7
(Solução de Comunicação com Arduino).

• Componente Sketch Protocol: composto basicamente de um código de

Sketch (programa do Arduino) que implementa a comunicação do Arduino
através de um meio de comunicação específico com o protocolo JIP para
tratamento e execução dos comandos recebidos do componente Java.ino.
Este componente é implementado conforme o meio de comunicação utilizado,
recebendo a identificação como SKPn (SKetch Protocol "n"), como exemplo a
implementação da comunicação Serial identificada como SKP0 (0-Serial, 1-
Bluetooth, 2-Ethernet, 3-Wifi, etc.). Diante dos limites de tempo disponível, foi
construído apenas parte do SKP0, citado anteriormente, como uma camada
de software executável no Arduino (Sketch), cujo código é apresentado no
Apêndice A, como também uma camada de comunicação Java utilizando
apenas o formato de comunicação Serial, descrita no capítulo 7 (Solução de
Comunicação com Arduino).

72
7. SOLUÇÃO DE COMUNICAÇÃO COM ARDUINO

7.1 Protocolo de Comunicação

Diante dos desafios postos para a integração das tecnologias Java e Arduino,
inicialmente foi elaborado o projeto de comunicação entre elas, o que levou à
concepção de um protocolo de comunicação bilateral, o qual permite que o
componente Java, do projeto Java.ino como descrito no capítulo anterior, envie
comandos reconhecidos no Sketch Arduino para execução de controles nas portas de
comunicação da placa (hardware). Esta forma de comunicação é essencial para que se
estabeleça uma interface comum, que permita as duas partes envolvidas se
comunicarem e sejam reconhecidas, uma pela outra.

A solução implementada utiliza um protocolo de comunicação, que permite as

operações básicas serem realizadas no microcontrolador da plataforma Arduino, de tal
forma que sejam realizadas as operações básicas de controle, ativação, recuperação e
operação nas diversas portas de comunicação da placa (analógicas e digitais), sendo
para leitura e/ou escrita.

O protocolo implementado foi denominado JIP (Java.ino Protocol - Protocolo do

Projeto Java.ino), que possui um padrão de comandos definidos por um analisador
léxico que divide uma estrutura de comando para um formato genérico de
comunicação, possível de ser implementado através de comunicação Serial,
comunicação de Ethernet, comunicação Bluetooth ou comunicação Wifi, sem prejuízo
algum ao reconhecimento da semântica aplicada. Como situado no capítulo anterior, foi
considerada na Prova de Conceito (PoC) apenas a implementação da comunicação
Serial desta solução, ficando possível sua implementação nos demais formatos de
comunicação em trabalhos futuros.

73
 No lado da plataforma Arduino, está a implementação do Sketch executado pelo
microcontrolador da placa, tratando as mensagens ou comandos recebidos,
executando as operações enviadas, e gerando um retorno para o componente
solicitante da operação. Como exemplo, um comando de saída para uma porta
específica acionada para operação, sendo escrita realizada pelo microcontrolador na
porta acionada. Exemplos de aplicação como este e outros serão apresentados no
capítulo 8 (Plataforma de Programação Java no Arduino). Conforme citado no capítulo
anterior, este componente recebe a identificação SKPn (SKetch Protocol "n"),
implementado conforme o meio de comunicação utilizado. Abaixo uma lista dos SKPs
projetados para implementação.

SKP (Sketch Protocol) - Sketch com implementação do JIP (Java.Ino Protocol)

• SKP0 - Comunicação Serial RxTx
• SKP1 - Comunicação Bluetooth
• SKP2 - Comunicação Ethernet
• SKP3 - Comunicação Wifi

No lado do cliente Java (ou outra plataforma de desenvolvimento que pretenda

comunicar via protocolo JIP com o Arduino), está a implementação do componente de
comunicação Java.ino, responsável pela geração de comandos a serem executados na
plataforma Arduino, e encaminhadas através do protocolo de comunicação JIP. Este
componente foi implementado através de uma modelagem de classes, aplicando a
metodologia orientada a objetos, com seus conceitos e princípios, conforma já
apresentados, a qual será mais detalhada adiantes neste capítulo.

7.2 Implementação da Estrutura do Protocolo

A estrutura do protocolo inclui um formato específico para cada tipo de mensagem

enviada para as partes da comunicação, definido um padrão de comunicação que
estabelece a forma com que cada mensagem é gerada e tratada pelos agentes

74
envolvidos no processo de execução no projeto Java.ino. Estes formatos são
especificados a seguir.

Mensagens de ENVIO (Comando): mensagens de solicitação de serviço/operação,

enviadas do componente Java.ino ao componente SKPn.

Formato da mensagem no protocolo (ENVIO):

@CMD&REF&OPR&VAL&.&.&.&...#

• CMD: comando (mnemônico)

• REF: referência (valor/atributo)
• OPR: operação (código)
• VAL: valores (opcional)

Inicialmente a mensagem possui em seu formato o caractere '@' para indicar a

abertura do tratamento de mensagem do tipo "ENVIO", em seguida o mnemônico que
identifica a ação ou requisição, identificada conforme a tabela adiante. Os
componentes seguintes são separados sintaticamente pelo caractere '&', tendo a
possibilidade de um número indefinido de valores adicionais colocados após a estrutura
obrigatória de elementos especificados. Seguindo a sigla identificação da mensagem,
um parâmetro de referência é definido para identificar a base de execução do comando
enviado, obedecendo o tipo de valor numérico inteiro para este dado. Na sequência
vem a identificação da operação específica a s ser realizada conforme a mensagem
identificada, conforme operação definida para cada identificador de mensagem definido
no protocolo. Como conteúdo completar, uma lista de valores separados pelo caractere
'&' define possíveis parâmetros adicionais necessários ou para a execução da
operação comandada, como forma de flexibilizar a estrutura, aumentando assim sua
escalabilidade, conforme seja evoluído para tratamento de comandos mais avançados
e específicos de aplicação do protocolo. E ao final o caractere '#' indicará o fim da
mensagem enviada, seguindo a partir de então para o tratamento específico da análise
semântica dos itens léxicos identificados.

75
 TABELA INICAL DE COMANDOS, REFERÊNCIAS, OPERAÇÔES E PARÂMETROS
IMPLEMENTADA NA POC DO PROJETO Java.ino
PD N (inteiro) H/1 - Escrita de tensão alta na porta digital (5V)
PD N (inteiro) L/0 - Escrita de tensão baixa na porta digital (0V)
PD N (inteiro) I - Configura porta digital para Input (Entrada/Leitura)
PD N (inteiro) O - Configura porta digital para Output (Saída/Escrita)
PD N (inteiro) R - Leitura do valor de tensão na porta digital
PA N (inteiro) R - Leitura do nível de tensão na porta analógica
SR X BG - Inicia Comunicação Serial (Begin)
SR X BG N (int) Inicia Comunicação Serial (Begin) com velocidade
SR R AV - Verifica se há dado disponível para leitura na
comunicação serial (Available)
SR R RD - Leitura de dado da comunicação serial (Read)
SR W PR - Saída de dados caracteres (String) através da rotina
print da comunicação serial
SR W PL - Saída de dados caracteres (String) através da rotina
println da comunicação serial

Alguns exemplos de mensagens de comando, com descrição:

@PD&1&H# (porta digital 1 será acionada para escrita de tensão alta - 5V)
@PD&0&L# (porta digital 0 será acionada para escrita de tensão baixa - 0V)
@PD&0&R# (porta digital 0 será acionada para leitura de seu estado)
@PA&1&R# (porta analógica 1 será acionada para leitura de seu valor de tensão)
@SR&R&AV# (Serial.available())
@SR&R&RD# (Serial.read())
@SR&W&PR&Arduino Uno# (Serial.print("Arduino Uno"))

Mensagens de ERRO (Retorno): mensagens geradas pelo SKPn e devolvidas

através da comunicação estabelecida com o cliente (componente Java.ino), indicando
uma situação de erro ou exceção ocorrida no tratamento do comando recebido,
impossibilitando muitas vezes a sua execução, por algum motivo identificado na
descrição de retorno, conforme segue formato definido pelo protocolo:

76
 Formato da mensagem no protocolo (ERRO):
!ERR&.MSG.#
• ERR: identificador de erro gerado (mnemônico fixo)
• MSG: mensagem de texto referente à descrição do erro

Seu formato inicia-se com o caractere '!' para identificação da mensagem do tipo
"ERRO", seguido do mnemônico fixo 'ERR' e o caractere '&' separando o texto de
descrição da situação de erro ocorrida. Ao final o caractere '#' indicará o fim da
mensagem enviada, seguindo a partir de então para o tratamento pela componente
Java.ino.

Mensagens de RESPOSTA (Retorno): mensagens geradas pelo SKPn e

devolvidas através da comunicação estabelecida com o cliente (componente Java.ino),
indicando a resposta da recepção e execução do comando solicitado, com a
possibilidade de tratamento das situações de sucesso ou insucesso da operação,
conforme código de retorno identificado. Segue formato da mensagem, abaixo.

Formato da mensagem no protocolo (RESPOSTA):

!RSP&SUC&COD&VAL&.&.&.&...#

• RSP: identificador de resposta (mnemônico fixo)

• SUC: valor identificando o tipo de resposta (sucesso-1 falhar-1)
• COD: código de falha para tratamento pelo cliente (zero se for sucesso)
• VAL: valores (opcional)

Seguindo o código de retorno, como mostrado, ocorre uma lista opcional de dados
separados pelo caractere '&' definindo possíveis valores adicionais de retorno que
poderão ser encaminhados na resposta ao cliente, permitindo desta forma uma maior
flexibilidade de retorno, aumentando a escalabilidade da comunicação. Ao final o

77
caractere '#' indicará o fim da mensagem enviada, seguindo a padrão das mensagens
anteriores.

Conforme já citado anteriormente, vale destacar a implementação apenas parcial do

SKP0 (Sketch Protocol - comunicação Serial), devido as restrições de tempo, como
resultado prático da PoC construída para esta pesquisa, cujo código fonte consta no
APÊNDICE A.

7.3 Implementação dos Componentes de Comunicação

O componente Java.ino é divido em dois pacotes de classes implementados

essencialmente na linguagem Java aplicando os conceitos e princípios da programação
orientada a objetos e padrões de projeto, descritos no capítulo 3 (Programação
Orientada a Objetos e Padrões de Projeto). Um dos pacotes diz respeito ao
componente de comunicação que irá implementar o protocolo JIP para a troca de
mensagens com o SKP implementado no Arduino, o qual será descrito na sequência
do texto. O outro pacote componente do Java.ino contempla a implementação da
abstração de alto nível, em classes de objetos reutilizáveis para a criação de estruturas
mais complexas de objetos construídos na plataforma Arduino, permitindo uma
programação orientada a objetos para criação das características e comportamento
destes objetos implementados. O segundo componente citado será descrito no capítulo
8 (Plataforma de Programação Java no Arduino).

Para modelar a estrutura de comunicação do Java.ino, um modelo de abstração de

comunicação foi definido através de uma interface chamada Communication, a qual
deverá ser implementada conforme o meio de comunicação a ser adotado Serial,
Bluetooth, Ethernet, Wifi, etc.), de forma compatível com a versão do SKPn utilizado
para estabelecer a comunicação com a plataforma Arduino.

78
 Figura 18 - Diagrama de Classes para implementação da Comunicação do Projeto
Fonte: Produzida pelo autor

Conforme o diagrama apresentado acima, para implementação desta interface foi

escrita uma classe abstrata Communication, a qual deverá ser herdada pelo princípio
de Herança da POO pelas classes de comunicação como o Sketch correspondente
disponível na plataforma Arduino, conforme foi realizado na implementação da classe
CommSerial utilizada na PoC construída para este trabalho, a qual implementa a
comunicação Serial com o SKP0, para estabelecer uma conexão entre as partes
através deste meio de comunicação. E a classe CommSerialPort faz parte da solução
de implementação da comunicação Serial com Java.

7.4 Implementação da Comunicação Serial para Prova de Conceito

Para finalizar a descrição da solução de comunicação da PoC, foi utilizada para

implementação da comunicação Serial do Java (classe CommSerial) uma biblioteca de

79
classes chamada API RXTXcomm, como principal API utilizada na comunicação Serial
do Java com a plataforma Arduino. Esta biblioteca (API) RXTXcomm é responsável
pela leitura e escrita da porta serial, sendo a solução aplicada para tornar possível o
envio de mensagens de comando através da comunicação serial para o Arduino, bem
como capturar as informações enviadas através das mensagens pelo Arduino, que são
enviadas/recebidas pela porta Serial onde o Arduino estará conectado ao computador.
Através desta biblioteca e com o tratamento específico das mensagens enviadas
de/para o Arduino, as classes Java demonstradas no diagrama anterior fazem a
comunicação Serial com o Arduino, permitindo assim a implementação do protocolo no
componente do projeto Java.ino (Java.ino Protocol - JIP) descrito anteriormente.

Além dos conceitos e princípios básicos da programação orientada a objetos de

classe, objetos, instância, atributos, métodos, encapsulamento, herança, polimorfismo,
composição, agregação e abstração, também foram aplicados os padrões de projeto
para permitir uma implementação mais flexível e escalável na evolução das estruturas
que compõem a idéia central do projeto desenvolvido.

80
8. PLATAFORMA DE PROGRAMAÇÃO JAVA NO ARDUINO

Para a programação orientada a objetos na plataforma Arduino utilizando a

linguagem Java, além da comunicação implementada para viabilizar integração das
tecnologias adotadas, foi criado um modelo de classes em alto nível de abstração, que
define os componentes necessários para o desenvolvimento de programas para o
controle e comando de ações realizadas no microcontrolador da placa Arduino. Tal
modelo se integra ao componente de comunicação do projeto Java.ino (descrito no
capítulo anterior), formando a proposta de plataforma construída para este estudo.

8.1 Apresentação Geral da Plataforma de Software Proposta

Como base da abstração da plataforma Arduino no modelo de objetos, foi criada

uma classe abstrata chamada Arduino (ver diagrama abaixo), contendo a interface
necessária para a comunicação com a operações disponíveis na plataforma,
especialmente o controle das portas analógicas e digitais, e ainda o encapsulamento
do componente de comunicação do projeto Java.ino, incorporando as funcionalidades
necessárias para a comunicação abstrata pelo meio de comunicação disponível na
construção do projeto considerado alvo no uso da estrutura proposta neste trabalho.

81
 Figura 19 - Diagrama de Classes para implementação de placas Arduino
Fonte: Produzida pelo autor

Para representação das portas de comunicação existentes na plataforma Arduino

(digitais, analógicas e de alimentação), foi utilizada uma agregação na classe Arduino
de um modelo de herança criado na abstração destes elementos, que são utilizados no
hardware da placa. Tais classes são apresentadas no diagrama abaixo.

82
 Figura 20 - Diagrama de Classes das portas de comunicação da placa Arduino
Fonte: Produzida pelo autor

A classe abstrata Arduino representa a estrutura da plataforma Arduino através do

modelo orientado a objetos, qual deverá utilizada para a criação de classes concretas
que representem de forma mais especializada, uma determinada configuração
específica como o Arduino Uno, Arduino Mega, ou qualquer outra configuração
necessária ao projeto alvo. Nesta classe concreta, será implementada a configuração
própria da plataforma específica, definindo a estrutura dos barramentos analógico,
digital e de alimentação do Arduino. Nesta modelagem, também poderão ser
acrescidas novas capacidade e funcionalidades específicas para cada modelo de
Arduino, proporcionando a capacidade de ampliação das aplicações possíveis de tal
modelo

83
 Figura 21 - Diagrama de Classes de abstrações de placas Arduino
Fonte: Produzida pelo autor

8.2 Modelo de Abstração de Componentes Eletrônicos na Plataforma

Além da base de construção dos objetos para representar a estrutura da plataforma

Arduino, o projeto inclui ainda uma abstração de componentes que serão acoplados
aos sistemas embarcados, para a representação de funcionalidades práticas de
aplicação através da ativação de tais componentes. Estes componentes representados
como exemplo no modelo abaixo, criam a forma básica de criar objetos nos programas,
capazes de refletir de forma aproximada do mundo real, suas características,
capacidades e funcionalidades que se aproximam da forma como enxergamos tais
componentes atuado no mundo real, o que preconiza a aplicação da programação
orientada a objetos, apresentada no capítulo 3 (Programação Orientada a Objetos e
Padrões de Projeto).

84
 Figura 22 - Diagrama de Classes de componentes conectáveis às placas Arduino
Fonte: Produzida pelo autor

Para o diagrama acima, estão representados dois componentes básicos que foram
implementados na PoC desenvolvida para esta pesquisa, conforme apresentada em
detalhes na sequência. Os componentes representados abaixo são o LED (Light
Emitting Diode), que pode ser usado para a emissão de luz em locais específicos, onde
se torna conveniente a sua utilização no lugar de uma lâmpada (muito utilizado em
produtos de microeletrônica como sinalizador de avisos, de forma visual), também pode
ser encontrado em tamanho maior, como em alguns modelos de semáforos. Também
foi utilizado no modelo, uma chave comutadora (Switch), também conhecida como
interruptor, que é um dispositivo simples usado para abrir ou fechar circuitos elétricos.
São utilizados na abertura de aparelhos eletrônicos, basicamente na maioria das
situações que envolvem o ligamento ou desligamento para passagem de corrente
elétrica, e que poderá ser controlada por uma porta digital na placa Arduino.

8.3 Utilizando Padrões de Projeto na Implementação da Solução

Como parte da arquitetura proposta e evidenciando os resultados na aplicação de

padrões de projeto para solucionar ou melhorar a utilização prática desta modelagem

85
apresentada, algumas classes foram criadas de tal forma a trazer os benefícios
apresentados pelas soluções de padrões de projeto na construção de software, sendo
estas classes representadas abaixo, como segue:

Para o componente de comunicação do projeto Java.ino:

Para o componente de abstração do Arduino, em sua camada de construção:

Figura 23 - Estruturas das classes aplicando Padrões de Projeto GOF

Fonte: Produzida pelo autor

8.4 Implementação da Prova de Conceito Utilizando a Plataforma

Para validar a arquitetura proposta foi implementada uma prova de conceito (PoC,
(sigla do inglês, Proof of Concept) utilizando todas as classes apresentadas na
modelagem descrita neste capítulo, de tal forma a comprovar os resultados obtidos
com a programação orientada a objetos para a plataforma Arduino, aplicando os
princípios de orientação a objetos (OO) e a abstração em alto nível dos objetos criados.

86
 A PoC contempla dois projetos implementados no hardware da plataforma Arduino,
conforme ilustração mostrada, representando a ligação da placa Arduino aos
componentes controlados pelo programa em Java, através de suas portas de
comunicação.

O primeiro projeto implementado na PoC, é bem simples e serve somente para

demonstrar a utilização do modelo de abstração do Arduino criado em Java e
demonstrado neste capítulo, composto de um LED ligado na placa Arduino por meio da
porta digital de numero 7, o qual poderá ser acionado através da mudança de estado
da porta, sendo aceso quando a porta receber um sinal de tensão alto (5 volts), e
apagado quando receber o sinal de tensão baixo (0 volts). Toda a implementação de
porta, sinais digitais e controles do microcontrolador fica abstraída e encapsulada
dentro da plataforma proposta, ficando a cargo do programa Java, simplesmente enviar
mensagens ao objeto criado no programa as instruções em alto nível de abstração para
a mudança de estado deste componente. Isso é demonstrado através das linhas de
códigos apresentados a seguir.

Figura 24 - Esquema de ligação física dos componentes utilizados na placa Arduino

Fonte: Google (Imagens)

O código a seguir, representa o Sketch construído na linguagem da plataforma

Arduino, que seria necessário para implementado o controle deste circuito, fazendo

87
com que o LED acenda e apague em intervalos fixos de 1 segundo, de forma contínua
(um LED piscante).

// Projeto de LED Piscante

int led = 7;
void setup()
{
pinMode(led, OUTPUT);
}
void loop()
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}

O código abaixo representa o principal resultado da PoC para o presente trabalho,

contendo um código na linguagem Java realizando a mesma funcionalidade realizada
pelo Sketch anterior, utilizando toda tal abstração de Arduino do projeto Java.ino, e a
plataforma de comunicação abstraída conforme descrito no capítulo 7 (Solução de
Comunicação com Arduino). Neste código aplica-se o princípio da abstração de objetos
do mundo real definida na POO (Programação Orientada a Objetos), e foi escrito
essencialmente numa linguagem orientada a objetos, como o Java.

public class LedPiscante {

public static void main(String... args) {
Arduino arduino = FabricaArduino.criarArduino(
EModeloArduino.UNO,"Projeto Led","teste_led");
arduino.setPortaSerial("COM4");
arduino.openComunicacao(CommunicationType.SERIAL);

Led led1 = new Led("led1",arduino,7);

While (true) {
Led1.ligar();

88
 try { Thread.sleep(1000); }
catch (InterruptedException e) { }
led1.desligar();
try { Thread.sleep(1000); }
catch (InterruptedException e) { }
}
}
}

A classe LedPiscante do código acima é uma abstração de toda a plataforma

Arduino e a criação do esquema apresentado anteriormente, bem toda a comunicação
necessária para o programa Java comandar o microcontrolador com suas portas, está
encapsulada na interface da classe abstrata Arduino, implementada pela classe
concreta ArduinoUno e criada no programa acima pela "fábrica" de objetos definida
pela classe FabricaArduino, através de seu método estático criarArduino(). O
objeto LED está implementado pela classe Led usada para instanciar o objeto
referenciado pela variável led1, que passa a se comportar no programa pelo seu
comportamento encapsulado, definido pelos métodos ligar() e desligar().

Desta forma, toda a visão de programação orientada a objetos aplicada neste

projeto, torna o código mais legível, com alto nível de abstração, possuindo ainda a
capacidade de ser executado em qualquer ambiente que possa estabelecer uma
comunicação Serial com o Arduino e execute uma máquina virtual Java.

Para o segundo projeto implementado na PoC, foi definido um objeto representando

a abstração de um Semáforo de Trânsito, com as fases de "Pare", "Atenção" e "Siga".
A implementação física do protótipo está na figura 25, criada no hardware da
plataforma Arduino através de LEDs indicadores dos estados do semáforo, e a
implementação de software foi feita utilizando o Java com os devidos componentes,
baseados na arquitetura apresentada nas seções 6 e 7 deste trabalho.

89
 Figura 25 - Esquema de ligação física dos componentes para um semáforo
Fonte: Google (Imagens)

No código de implementação deste projeto pela PoC da arquitetura proposta, cria-se

uma Thread em Java para fazer a execução do Semáforo, e na classe
SemaforoThread as instâncias da classe Arduino, através da sua classe concreta
ArduinoUno, e da classe Led para representar cada estado do semáforo, em três
instâncias representadas pelas cores de sua configuração. O led vermelho está
conectado à porta digital de número 5, o led verde na porta de número 4 e o led
amarelo na porta de número 6, que são facilmente programadas dentro da classe em
Java pelas variáveis membro (atributos) em SemaforoThread. Os tempos de cada
estado são programados também em atributos da classe SemaforThread, e as
mudanças de estado são aplicadas pelos implementados chamados
semaforFechado(), semaforoAtencao() e semaforoAberto(). O código completo
da classe implementada está apresentado no APÊNDICE B.

8.5 Resultados da Aplicação da Prova de Conceito

Foi possível perceber que com a implementação da arquitetura proposta, a aplicação

apresenta ganhos em escalabilidade, facilidade de manutenção, a reutilização de
classes (através de instâncias - objetos) e o principal fator apresentado foi
proporcionado pelo alto nível de abstração dos objetos utilizados para programar a

90
plataforma Arduino, obtido pela aplicação da metodologia de programação orientada a
objetos, tornando uma forma totalmente transparente ao programador de dispositivos
embarcados, que estejam desenvolvendo projetos com prototipação através da
plataforma Arduino, considerando a plataforma física do hardware e a linguagem
específica utilizada por esta plataforma para controle das operações nas portas de
comunicação e na programação do microcontrolador.

Como resultado final, a arquitetura proposta viabiliza integrar plataformas Java e

Arduino, de tal forma que os resultados proporcionam a possibilidade de
implementação que poderá ser aplicada a quaisquer placas de Arduino implementando
qualquer projeto de circuito de dispositivo embarcado, com a programação orientada a
objetos como centro da metodologia de desenvolvimento do software de controle, e a
plataforma Arduino, utilizada para base da conexão de dispositivos e componentes
eletrônicos em suas postas de comunicação, compondo o hardware do sistema no
projeto.

Portanto, a plataforma proposta tem como objetivo aproveitar o melhor de cada uma
das metodologias e tecnologias adotadas. Como resultado adicional, nota-se a
facilidade de divisão de tarefas de projeto, uma vez que torna as plataformas de
software e hardware praticamente independentes, permitindo alocar equipes
especializadas em diferentes tarefas, em cada uma destas plataformas.

91
9. CONCLUSÃO

A programação aplicada com a metodologia orientada a objetos no desenvolvimento

do projeto desta pesquisa demonstrou a flexibilidade, escalabilidade e manutenibilidade
oferecida pelo código gerado, em comparação ao modelo estruturado utilizado pela
linguagem nativa da plataforma Arduino, mostrando ainda o nível de abstração que
pode ser aplicado quando utilizado a perspectiva de objetos na modelagem de
soluções na programação de sistemas embarcados.

9.1 Conclusão e Resultados

O principal resultado demonstrado no desenvolvimento da prova de conceito (PoC)

criada durante o desenvolvimento deste trabalho, mostrou o poder da abstração
quando aplicamos os conceitos e princípios da orientação a objetos na programação de
soluções de componentes de software. A arquitetura proposta viabilizou integrar as
plataformas estudadas utilizando a abstração de objetos através da metodologia OO.

Definiu ainda, para o desenvolvimento de programas para a plataforma Arduino, uma

nova alternativa para desenvolver projetos de dispositivos embarcados que sejam
prototipados através do uso desta plataforma, utilizando uma linguagem de
programação de grande penetração no mercado, e bastante difundida nos meios
empresarial e acadêmico (linguagem Java).

Esta alternativa de programação orientada a objetos para o Arduino demonstrou a

possibilidade de programar através de uma abstração completa da estrutura de
hardware existente na plataforma, utilizando um modelo de classes e componentes.
Esta nova forma de programar o Arduino com a perspectiva de objetos, permitiu criar
operações do microcontrolador e o controle das portas de comunicação utilizadas para

92
a conexão de sensores e/ou atuadores, através de objetos instanciados com
comportamento definindo pelos conceitos da orientação a objetos.

O resultado da PoC demonstrou ainda a possibilidade de programar dispositivos

construídos com a plataforma Arduino utilizando uma perspectiva de objetos
componentizados através da arquitetura proposta. Outro fator importante é a
independência do desenvolvimento e a divisão de responsabilidades proporcionada
pela abstração do hardware através de um modelo de classes, otimizando a divisão de
tarefas e a alocação dos recursos em um projeto de sistema embarcado no Arduino.
No entanto, este trabalho limitou-se à codificação parcial da proposta de componentes
possíveis de implementação, deixando uma margem de evolução bastante extensa e
aberta para novos trabalhos futuros com base na estrutura arquitetural definida.

9.2 Trabalhos Futuros

Como sugestão para trabalhos futuros, existem muitas implementações a serem

realizadas que ficaram fora do escopo deste trabalho, como por exemplo os novos
meios de comunicação que precisam ser implementados, para permitir o uso do
protocolo JIP utilizando os meios Bluetooth (SKP1), Ethernet (SKP2) e Wifi (SKP3). E
ainda, o incremento de funcionalidades no Sketch Arduino para receber novas
funcionalidades previstas pela plataforma, bem como novos controles de portas, como
as denominadas PWM, as quais não foram tratadas no escopo deste trabalho. Desta
forma, seguindo o padrão definido pelo protocolo JIP, fica facilitada a implementação
de novos recursos adicionais ao Sketch.

A base de componentes deve ser acrescida de novas implementações, para permitir

que novas abstrações de componentes possam ser construídos e novos circuitos com
capacidades mais complexas possam ser implementados em projetos utilizando o
Arduino com Java através da arquitetura do projeto Java.ino.

93
 Finalmente como sugestão para avanços e evolução do projeto Java.ino, a
realização de testes funcionais e de desempenho com análise quantitativa, com o fim
de garantir sua aplicação em projetos que tenham maior grau de complexidade, dada a
simplicidade adotada na PoC realizada devido as restrições do tempo de
desenvolvimento.

94
REFERÊNCIAS BIBLIOGRÁFICAS

ARDUINO. Site oficial da plataforma Arduino. Disponível em:

<http://www.arduino.cc>. Acesso em: 03/04/2016.

BANZI, Massimo. Getting Started with Arduino - 2 ed. Sebastopol, CA: O'Reilly,
2011.

BENTES, Leandro Maurício A. Sistema de Segurança Veicular com uso de GPS

baseado em Arduino. Trabalho de Conclusão de Curso (Graduação em Engenharia
de Computação). Manaus: Universidade do Estado do Amazonas, 2013.

BORATTI, Isaias Camilo. Programação Orientada a Objetos em Java. Florianópolis:

Visual Books, 2007.

CORREIA, Nuno. Internet das Coisas com SAP HANA. Lisboa: Ui5 Community
Network.

DEITEL, Paul J.; DEITEL, Harvey M. Java como programar – 8 ed. São Paulo:
Pearson Prentice Hall, 2010.

GAMMA, Erich; HELM, Richard; JOHNSON, Ralph; VLISSIDES, John. Padrões de

Projeto: Soluções reutilizáveis de software orientado a objetos. Porto Alegre:
Bookman, 2000.

JANDL Jr., Peter. Java Guia do Programador - 2 ed. São Paulo: Novatec Editora,
2013.

LEITE, Mario; RAHAL Jr., Nelson Abu Sanra. Programação Orientada ao Objeto:
uma abordagem didática. Agosto, 2002. Disponível em:
<http://www.ccuec.unicamp.br/revista/navegacao/infotec.html>. Acesso em:
04/02/2016.

McROBERTS, Michael. Arduino Básico. São Paulo: Novatec, 2011.

MONK, Simon. 30 Arduino Projects for the Evil Genius. New York: McGraw-Hill,
2010.

PRESSMAN, Roger S. Engenharia de Software: Uma abordagem profissional. 7

ed. Porto Alegre: McGraw-Hill (Bookman), 2011.

SCHILDT, Herbert. Java: A Referência Completa - 8 ed. Rio de Janeiro: Alta Books,
2014.

95
SILVEIRA, Paulo; SILVEIRA, Guilherme; LOPES, Sérgio; MOREIRA, Guilherme;
STEPPAT, Nico; KUNG, Fabio. Introdução à Arquitetura e Design de Software:
Uma visão sobre a plataforma Java. Rio de Janeiro: Elsevier, 2012.

SOMMERVILLE, Ian. Engenharia de Software. 9 ed. São Paulo: Pearson Prentice

Hall, 2011.

96
 APÊNDICE A
Código de implementação do SKP0
(SKetch Protocol 0 - implementação do protocolo JIP na comunicação Serial)

// constantes globais do Sketch

const char CMD_START = '@';

const char CMD_END = '#';
const char CMD_SPLIT = '&';
const char ERR_START = '!';
const char RSP_START = '$';
const byte MAX_DIGITAL = 13;
const byte MAX_ANALOG = 5;
const byte MAX_PWM = 6;

// estruturas globais do Sketch

struct TComando {
String CMD;
String REF;
String OPR;
String VAL;
};

// variáveis globais do Sketch

byte byteRead;
String strComando;
String strResposta;
struct TComando vComando;

// Prototipos de funções utilizadas

void piscaPino13();
String lerCMD();
void limparSerial();
String converteBase2(byte);
String converteBase2Invertido(byte);
struct TComando separarCMD(String);
void lerValores(struct TComando, String[], byte&);
void executarCMD(struct TComando);
void execPD(struct TComando);
void execPA(struct TComando);
void execSR(struct TComando);

////////////
void setup()
////////////
{
pinMode(13, OUTPUT);
Serial.begin(9600);
}

97
///////////
void loop()
///////////
{
strComando = lerCMD();
Serial.println("CMD:> "+strComando);
piscaPino13();

if (strComando[0] == ERR_START)
{
strResposta = strComando;
}
else
{
strResposta = String(RSP_START) + "RSP&";
if (strComando[0] == CMD_START)
{
vComando = separarCMD(strComando);
executarCMD(vComando);
}
}

Serial.println("RSP>>> "+strResposta);
}
/////////////////////////////////////
void executarCMD(struct TComando cmd)
{

if(cmd.CMD == "PD")
execPD(cmd);

if(cmd.CMD == "PA")
execPA(cmd);

if(cmd.CMD == "SR")
execSR(cmd);

strResposta += CMD_END;
}
////////////////////////////////
void execPD(struct TComando cmd)
{
byte porta=0;
byte valor=0;
byte coderro=0;

if (cmd.REF.length() == 0 || cmd.OPR.length() == 0)
coderro+=pow(2,0);
if (cmd.REF.length() > 2 || cmd.OPR.length() != 1)
coderro+=pow(2,1);
porta = (byte)cmd.REF.toInt();
if (cmd.REF != String(porta))
coderro+=pow(2,2);
if (porta < 0 || porta > MAX_DIGITAL)
coderro+=pow(2,3);
if (String("IORH1L0").indexOf(cmd.OPR.charAt(0)) < 0)
coderro+=pow(2,4);

98
 if (coderro == 0)
{
switch(cmd.OPR.charAt(0))
{
case 'O':
Serial.println("EXEC> pinMode("+String(porta)+",
OUTPUT);");
pinMode(porta, OUTPUT);
break;
case 'I':
Serial.println("EXEC> pinMode("+String(porta)+",
INPUT);");
pinMode(porta, INPUT);
break;
case 'R':
Serial.println("EXEC>
digitalRead("+String(porta)+");");
valor = digitalRead(porta);
break;
case 'H':
case '1':
Serial.println("EXEC> digitalWrite("+String(porta)+",
HIGH);");
digitalWrite(porta, HIGH);
break;
case 'L':
case '0':
Serial.println("EXEC> digitalWrite("+String(porta)+",
LOW);");
digitalWrite(porta, LOW);
break;
}
}

strResposta += String(coderro)+"&"+converteBase2Invertido(coderro);
if (cmd.OPR.charAt(0) == 'R' && coderro == 0)
strResposta += "&"+String(valor);

}
////////////////////////////////
void execPA(struct TComando cmd)
{
String val[20];
byte valcont=0;
byte porta=0;
int valor=0;
byte coderro=0;

if (cmd.REF.length() == 0 || cmd.OPR.length() == 0)
coderro+=pow(2,0);
if (cmd.REF.length() > 2 || cmd.OPR.length() != 1)
coderro+=pow(2,1);
porta = (byte)cmd.REF.toInt();
if (cmd.REF != String(porta))
coderro+=pow(2,2);
if (porta < 0 || porta > MAX_ANALOG)

99
 coderro+=pow(2,3);
if (String("RW").indexOf(cmd.OPR.charAt(0)) < 0)
coderro+=pow(2,4);
if (cmd.OPR.charAt(0)=='W' && cmd.VAL.length() == 0)
coderro+=pow(2,5);

if (cmd.OPR.charAt(0)=='W')
{
lerValores(cmd,val,valcont);
for (int i=0; i<valcont; i++)
{
Serial.println("VAL["+String(i)+"]="+val[i]);
}
if (valcont != 1 || val[0].length() == 0)
coderro+=pow(2,6);
}

if (coderro == 0)
{
switch(cmd.OPR.charAt(0))
{
case 'R':
Serial.println("EXEC>
analogRead("+String(porta)+");");
valor = analogRead(porta);
break;
case 'W':
valor = val[0].toInt();
if (val[0]!=String(valor) || valor < 0 || valor >
255)
coderro+=pow(2,7);
else
{
Serial.println("EXEC>
analogWrite("+String(porta)+", "+valor+");");
analogWrite(porta, valor);
}
break;
}
}

strResposta += String(coderro)+"&"+converteBase2Invertido(coderro);
if (cmd.OPR.charAt(0) == 'R' && coderro == 0)
strResposta += "&"+String(valor);

}
////////////////////////////////
void execSR(struct TComando cmd)
{
String val[20];
byte valcont=0;
int velocidade=9600;
byte valor;
byte coderro=0;

if (cmd.REF.length() == 0 || cmd.OPR.length() == 0)
coderro+=pow(2,0);

100
 if (cmd.REF.length() != 2 || cmd.OPR.length() > 2)
coderro+=pow(2,1);
if (cmd.REF != "RW")
coderro+=pow(2,2);
if (String("BG|AV|RD|PR|PL").indexOf(cmd.OPR) < 0)
coderro+=pow(2,3);
if (String("PR|PL").indexOf(cmd.OPR) >= 0 && cmd.VAL.length() == 0)
coderro+=pow(2,4);

if (String("BG|PR|PL").indexOf(cmd.OPR) >= 0)
{
lerValores(cmd,val,valcont);
for (int i=0; i<valcont; i++)
{
Serial.println("VAL["+String(i)+"]="+val[i]);
}
}

if (String("PR|PL").indexOf(cmd.OPR) >= 0)
if (valcont < 1 || val[0].length() == 0)
coderro+=pow(2,5);

if (cmd.OPR == "BG")

if (valcont > 0 || val[0].length() == 0)

{
velocidade = val[0].toInt();
if (velocidade!=300 && velocidade!=600 && velocidade!=1200
&& velocidade!=2400 && velocidade!=4800 && velocidade!=9600
&& velocidade!=14400 && velocidade!=19200 &&
velocidade!=28800 && velocidade!=38400 && velocidade!=57600
&& velocidade!=115200)
velocidade = 9600;
}

if (coderro == 0)
{
if (cmd.OPR == "BG")
{
Serial.println("EXEC> Serial.begin("+String(velocidade)
+");");
Serial.begin(velocidade);
}
if (cmd.OPR == "AV")
{
Serial.println("EXEC> Serial.available();");
valor = Serial.available();
}
if (cmd.OPR == "RD")
{
Serial.println("EXEC> Serial.read();");
valor = Serial.read();
}
if (cmd.OPR == "PR")
{
Serial.println("EXEC> Serial.print(\"xxx\");");
Serial.print(val[0]);

101
 }
if (cmd.OPR == "PL")
{
Serial.println("EXEC> Serial.println(\"xxx\");");
Serial.println(val[0]);
}
}

strResposta += String(coderro)+"&"+converteBase2Invertido(coderro);
if (cmd.OPR == "AV" && coderro == 0)
strResposta += "&"+String(valor);
if (cmd.OPR == "RD" && coderro == 0)
strResposta += "&"+(char)valor;

}
//////////////////
void piscaPino13()
{
// pisca pino 13 (LED onboard)
digitalWrite(13, HIGH);
delay(200);
digitalWrite(13, LOW);
delay(100);
}
///////////////////
void limparSerial()
{
char ch;
Serial.print("<lixo>");
while (Serial.available())
{
ch = Serial.read();
Serial.print(ch);
if (ch == CMD_END)
break;
delay(10);
}
}
//////////////////////////////
String converteBase2(byte val)
{
String aux = "";
while (val > 0)
{
aux = (val%2) + aux;
val = val/2;
}
while (aux.length() < 8)
aux = "0"+aux;
return aux;
}
//////////////////////////////
String converteBase2Invertido(byte val)
{
String aux = "";
while (val > 0)
{

102
 aux = aux + (val%2);
val = val/2;
}
while (aux.length() < 8)
aux = aux + "0";
return aux;
}
///////////////
String lerCMD()
{
String strCMD;
byte control = 0;

while (true)
{
if (! Serial.available())
continue;

if (strCMD.length() == 250)
{
strCMD = ERR_START + "ERR&Estouro no comprimento da linha
de comando!#";
limparSerial();
break;
}

byteRead = Serial.read();
Serial.write(byteRead);
delay(10);

if (byteRead == CMD_END)
{
strCMD += (char)byteRead;
break;
}

if (control == 0)
{
if (byteRead == CMD_START)
{
strCMD += (char)byteRead;
control ++;
}
continue;
}

if (control == 1)
{
if (byteRead >= 'A' && byteRead <= 'Z')
strCMD += (char)byteRead; else
if (byteRead == CMD_SPLIT) {
strCMD += (char)byteRead;
control ++;
}
continue;
}

103
 if (control == 2)
{
if (byteRead >= 'A' && byteRead <= 'Z')
strCMD += (char)byteRead; else
if (byteRead >= '0' && byteRead <= '9')
strCMD += (char)byteRead;
else
if (byteRead == CMD_SPLIT) {
strCMD += (char)byteRead;
control ++;
}
continue;
}

if (control == 3)
{
if (byteRead >= 'A' && byteRead <= 'Z')
strCMD += (char)byteRead;
else
if (byteRead >= '0' && byteRead <= '9')
strCMD += (char)byteRead;
else
if (byteRead == CMD_SPLIT) {
strCMD += (char)byteRead;
control ++;
}
continue;
}

if (control == 4)
{
strCMD += (char)byteRead; }

}
Serial.println("/");
Serial.println("strCMD> "+strCMD);

if (control < 3)
strCMD = "!ERR&Comando invalido! Faltando campos obrigatorios.#";
Serial.println("--x--");
return strCMD;
}
//////////////////////////////////////
struct TComando separarCMD(String cmd)
{
struct TComando aux;
String strAux;
byte control = 0;

aux.CMD = aux.REF = aux.OPR = aux.VAL = strAux = "";

if (cmd[0] == CMD_START) // START: @

control++;
else
return aux;
for(int i=1; i <= cmd.length(); i++)
{

104
 if (i < cmd.length())
{
if ((control>3 || cmd[i]!=CMD_SPLIT) && cmd[i]!=CMD_END) {
// SPLIT
strAux = strAux + cmd[i];
continue;
}
}

switch(control)
{
case 1:
aux.CMD = strAux; break;
case 2:
aux.REF = strAux; break;
case 3:
aux.OPR = strAux; break;
case 4:
aux.VAL = strAux; break;
}
strAux = "";
control++;
}
Serial.println("vCMD> "+aux.CMD);
Serial.println("vREF> "+aux.REF);
Serial.println("vOPR> "+aux.OPR);
Serial.println("vVAL> "+aux.VAL);

return aux;

}
//////////////////////////////////////////////////////////////
void lerValores(struct TComando cmd, String val[], byte& cont)
{
String strAux = "";
cont = 0;
Serial.println("VAL="+cmd.VAL);
if (cmd.VAL.length() <= 0)
return;

for(int i=0; i <= cmd.VAL.length(); i++)

{
if (i < cmd.VAL.length())
if (cmd.VAL[i] != CMD_SPLIT && cmd.VAL[i] != CMD_END) {
strAux += cmd.VAL[i];
continue;
}

val[cont++] = strAux;
strAux = "";
}

105
 APÊNDICE B
Código de implementação da PoC referente ao objeto
representando a abstração de um Semáforo de Trânsito,
utilizando o projeto Java.ino

public class SemaforoThread extends Thread

{
private Integer portaFechado = 5;
private Integer portaAberto = 4;
private Integer portaAtencao = 6;
private Integer tempoFechado = 10000; // 5s
private Integer tempoAberto = 5000; // 5s
private Integer tempoAtencao = 3000; // 3s
private Arduino arduino;
private String portaArduino = "COM4";
private Led ledFechado;
private Led ledAberto;
private Led ledAtencao;

private SemaforoJavaino()
{
arduino = FabricaArduino.criarArduino(EModeloArduino.UNO,"Projeto
Semaforo","semaforo");
arduino.setPortaSerial(portaArduino);
arduino.openComunicacao(CommunicationType.SERIAL);
ledAberto = new Led("ledAberto",arduino,portaAberto);
ledFechado = new Led("ledFechado",arduino,portaFechado);
ledAtencao = new Led("ledAtencao",arduino,portaAtencao);
}

public void run()

{
this.resetSemaforo();
while(true)
{
this.semaforoFechado(); System.out.println("Sinal
Fechado");
this.tempoPausa(tempoFechado);
this.semaforoAberto(); System.out.println("Sinal Aberto");
this.tempoPausa(tempoAberto);
this.semaforoAtencao(); System.out.println("Em Atenção!");
this.tempoPausa(tempoAtencao);
}
//arduino.closeComunicacao();
}

public void resetSemaforo()

{
ledFechado.desligar();
ledAberto.desligar();
ledAtencao.desligar();
}

106
 public void semaforoFechado()
{
resetSemaforo();
this.ledFechado.ligar();
}

public void semaforoAberto()

{
resetSemaforo();
this.ledAberto.ligar();
}

public void semaforoAtencao()

{
resetSemaforo();
this.ledAtencao.ligar();
}

public void tempoPausa(Integer t)

{
try {
sleep(t);
} catch(InterruptedException e)
{
e.printStackTrace();
}
}

public static void main(String... args)

{
new SemaforoJavaino().run();
}
}

107