UCAM – UNIVERSIDADE CÂNDIDO MENDES

JOSÉ CÍCERO GOMES MAIA

COMUNICAÇÃO SERIAL COM MICROCONTROLADOR USANDO VBA

FORTALEZA - CE
2017
 UCAM – UNIVERSIDADE CÂNDIDO MENDES
JOSÉ CICERO GOMES MAIA

COMUNICAÇÃO SERIAL COM MICROCONTROLADOR USANDO VBA

Monografia apresentada à Universidade Cândido

Mendes - UCAM, como requisito parcial para a
obtenção do título de Especialista em Automação
Industrial.

FORTALEZA - CE
2017
 UCAM – UNIVERSIDADE CANDIDO MENDES

UCAMPROMINAS

Relatório de avaliação do Trabalho de Conclusão de Curso - TCC

Matrícula: 26853
Aluno: JOSE CICERO GOMES MAIA
Curso: AUTOMAÇÃO INDUSTRIAL
Título: COMUNICAÇÃO SERIAL COM MICROCONTROLADOR USANDO VBA

Critérios de avaliação Nota – de 0 a 10

Tema e Título: 9,5
Rigor Científico: 9,5
Nível de Textualidade: 9,5
Conteúdo: 9,5
Formatação e Estrutura: 9,5

Com base na avaliação acima, o trabalho:

_x_ Foi Aprovado com a nota: 9,5

___Exige Reformulação.

___Foi Reprovado.

Profª Luciene Patrícia Vieira Silva

Data: 02/11/2017
COMUNICAÇÃO SERIAL COM MICROCONTROLADOR USANDO VBA

José Cícero Gomes Maia1

RESUMO

Este trabalho tem por objetivo demonstrar, de forma fácil, como ler os dados de um
microcontrolador adquiridos por meio de uma aplicação desenvolvida no MsExcel,
usando a linguagem VBA. Estes dados lidos podem ser úteis para monitoramento
remoto. Esta mesma aplicação pode acionar vários tipos de atuadores, tais como:
Leds, servomotores, motores DC e muito mais.

A ideia principal é criar um sistema supervisório de forma simples e que possa

controlar à distância um dispositivo microcontrolado. Esta aplicação desenvolvida
em VBA dentro do Excel pode ser útil para o controle e monitoramento destes
dados.

Palavras-chave: Robótica, Arduino, Excel, VBA, Porta Serial, Sistema Supervisório,

Aquisição de dados, Monitoramento e Controle, Microcontrolador.

1
Graduado em Análise e Desenvolvimento de Sistemas pela FATENE Fortaleza-Ce. Atualmente, atua como
programador de VBA (Access/Excel) no Banco do Nordeste/IVIA em Fortaleza-Ce e Professor de cursos
profissionalizantes na área de linguagem de programação no Instituto Evolução em Fortaleza-Ce. Interessa-se
por Computação, Automação, Desenho técnico e Ensino técnico.
 ABSTRACT

The objective of this work is to demonstrate how to read the data of a microcontroller
acquired through an application developed in MsExcel using the VBA language. This
data read can be useful for remote monitoring. This same application can trigger
several types of Actuators, such as: Leds, servo motors, DC motors and more.
The main idea is to create a supervisory system in a simple way and that can control
the distance a microcontrolled device. This application developed in VBA within Excel
can be useful for the control and monitoring of this data

Keywords: Robotics, Arduino, Excel, VBA, Serial Port, Supervisory System, Data
Acquisition, Monitoring and Control, Microcontroller.
Sumário
1. Introdução .................................................................................................................................................... 10
2. Fundamentos de Instrumentação............................................................................................................. 11
2.1. Classificação dos instrumentos....................................................................................................... 12
3. Os primórdios do controle industrial ........................................................................................................ 13
3.1. Controle Lógico Programável – CLP .............................................................................................. 14
3.1.1. O CLP moderno ............................................................................................................................ 16
3.1.2. A arquitetura básica...................................................................................................................... 16
3.1.3. A linguagem de programação ..................................................................................................... 18
3.2. A sala de controle.............................................................................................................................. 20
3.3. Os supervisórios ................................................................................................................................ 21
3.4. Prós e Contras ................................................................................................................................... 23
4. Breve introdução aos microcontroladores .............................................................................................. 25
4.1. Diferenças entre MCU e CPU ......................................................................................................... 25
4.2. Arduino – Breve Histórico ................................................................................................................ 27
5. Linguagem VBA .......................................................................................................................................... 29
5.1. Justificativa ......................................................................................................................................... 33
6. O projeto modelo ........................................................................................................................................ 34
6.1. Hardware de controle ....................................................................................................................... 34
6.1.1. Considerações iniciais ................................................................................................................. 34
6.1.2. Descrição do hardware do projeto ............................................................................................. 34
6.1.2.1. Microcontrolador usado ........................................................................................................... 36
6.1.3. Descrição dos componentes ....................................................................................................... 38
6.2. Montagem do projeto ........................................................................................................................ 41
6.2.1. Conectando o Arduino na Protoboard ....................................................................................... 42
6.2.2. Conectando o Potenciômetro no Arduino ................................................................................. 43
6.2.3. Conectando o Sensor de temperatura LM35 no Arduino ....................................................... 44
6.2.4. Conectando o Led no Arduino .................................................................................................... 45
6.2.5. Conectando o Servomotor no Arduino ...................................................................................... 46
6.3. Software de Controle ........................................................................................................................ 47
6.3.1. Considerações iniciais ................................................................................................................. 47
6.3.1.1. O que é um sinal PWM ................................................................................................................ 50
6.3.1.2. Modos de comunicação ............................................................................................................... 51
6.3.1.3. Protocolos de comunicação ........................................................................................................ 52
6.3.2. Como se comunicar...................................................................................................................... 53
6.3.2.1. Drivers de terceiros....................................................................................................................... 53
6.3.2.2. Comunicação nativa ..................................................................................................................... 55
6.3.3. Comunicação usando o VBA e o MsDOS................................................................................. 57
6.3.3.1. Ler os dados do Arduino com VBA ............................................................................................ 59
6.3.3.2. Acionando um atuador com VBA ............................................................................................... 65
6.3.4. Programando o Arduino ............................................................................................................... 67
6.3.4.1. Arquitetura do projeto ................................................................................................................... 67
6.3.4.2. O que é um Firmware................................................................................................................... 69
6.3.4.3. Qual é a melhor IDE para programar......................................................................................... 69
6.3.4.3.1. Programar para Arduino sem Arduino................................................................................... 73
6.3.4.4. Iniciando um novo Sketch ........................................................................................................... 74
6.3.4.5. Entendendo o Firmware do projeto ............................................................................................ 75
6.3.4.5.1. Acionando um Servomotor...................................................................................................... 77
6.3.4.5.2. Acionando um Led ................................................................................................................... 78
6.3.4.5.3. Lendo os sinais das portas analógicas ................................................................................. 79
6.3.4.6. Vamos embarcar ........................................................................................................................... 79
6.3.4.6.1. Entendendo a compilação ....................................................................................................... 82
6.3.5. Conhecendo a interface do usuário ........................................................................................... 83
6.3.5.1. Entrada A ....................................................................................................................................... 84
6.3.5.2. Entrada AST .................................................................................................................................. 85
6.3.5.3. Saída DS ........................................................................................................................................ 87
 6.3.5.4. Saída DL ........................................................................................................................................ 88
Conclusão ............................................................................................................................................................ 89
Bibliografia ........................................................................................................................................................... 91
Anexos.................................................................................................................................................................. 93
Índice de ilustrações
FIGURA 1: QUADRO DE COMANDOS ELÉTRICOS INDUSTRIAL ................................................................................................ 14
FIGURA 2: ESQUEMA ELÉTRICO ..................................................................................................................................... 14
FIGURA 3: MODICON-84 .......................................................................................................................................... 15
FIGURA 4: DA ESQUERDA PARA DIREITA, DICK MORLEY, TOM BOSSEVAIN, GEORGE SCHWENK E JONAS LANDAU .......................... 16
FIGURA 5: FLUXO BÁSICO DE UM CLP............................................................................................................................. 17
FIGURA 6: DIAGRAMA EM BLOCOS DE UM CLP ................................................................................................................ 17
FIGURA 7: DIAGRAMA EM BLOCOS DE UM CLP E SEUS MÓDULOS......................................................................................... 18
FIGURA 8: ESQUEMA ELÉTRICO E A LINGUAGEM LADDER. ................................................................................................... 19
FIGURA 9: TELA DO RSLOGIX 5000, MOSTRANDO AS 4 LINGUAGENS. .................................................................................. 19
FIGURA 10: TDC-2000. ............................................................................................................................................. 20
FIGURA 11: SISTEMA SCADA-AUTOMAÇÃO DO SISTEMA DE TRATAMENTO DE ÁGUA. ............................................................. 22
FIGURA 12: DIAGRAMA EM BLOCOS DE UM COMPUTADOR MODERNO. ................................................................................. 26
FIGURA 13: DIAGRAMA EM BLOCOS DE UM MICROCONTROLADOR PIC FAMÍLIA 18F. ............................................................... 26
FIGURA 14: TIME ARDUINO. ........................................................................................................................................ 28
FIGURA 15: PRIMEIRA PLACA ARDUINO-RS232 FABRICADA NA ITÁLIA.................................................................................. 28
FIGURA 16: TELA DO VISUAL BASIC VERSÃO 1.0. ............................................................................................................. 30
FIGURA 17: LOGOMARCA DO VBA( INTERNET) ................................................................................................................ 31
FIGURA 18: GERENTE DE MARKETING DA MICROSOFT FALA SOBRE O VBA. ........................................................................... 32
FIGURA 19: PLACA BLACKBOARD COM O ATMEGA328. ..................................................................................................... 35
FIGURA 20: DESCRIÇÃO DA BLACKBOARD V1.0. .............................................................................................................. 35
FIGURA 21: DESCRIÇÃO DOS COMPONENTES. .................................................................................................................. 36
FIGURA 22: DIAGRAMA EM BLOCOS SIMPLIFICADO DO ATMEGA328P. ................................................................................ 37
FIGURA 23: PINOS DO ATMEGA328P. ........................................................................................................................... 38
FIGURA 24: POTENCIÔMETRO. ..................................................................................................................................... 39
FIGURA 25: DIODO EMISSOR DE LUZ - LED. .................................................................................................................... 39
FIGURA 26: SENSOR DE TEMPERATURA LM35. ............................................................................................................... 39
FIGURA 27: RESISTOR DE 330R DE 1/8W. ..................................................................................................................... 39
FIGURA 28: SERVOMOTOR SG90. ................................................................................................................................. 39
FIGURA 29: PROTOBOARD DE 840 FUROS. ...................................................................................................................... 40
FIGURA 30: PLACA BLACKBOARD - ARDUINO. .................................................................................................................. 40
FIGURA 31: RASCUNHO DO ESQUEMA DE MONTAGEM. ..................................................................................................... 41
FIGURA 32: TELA DO FRITZING...................................................................................................................................... 42
FIGURA 33: BLACKBOARD - ARDUINO UNO R3 ............................................................................................................... 42
FIGURA 34: MONTAGEM 01 - LIGANDO O POSITIVO E O TERRA. .......................................................................................... 43
FIGURA 35: MONTAGEM 02 - LIGANDO O POTENCIÔMETRO. .............................................................................................. 43
FIGURA 36: PINAGEM DO LM35. (FONTE: DATASHEET) .................................................................................................... 44
FIGURA 37: MONTAGEM 03 – LIGANDO O LM35 ............................................................................................................ 44
FIGURA 38: MONTAGEM 04 – LIGANDO O LED. ............................................................................................................... 45
FIGURA 39: IDENTIFICAÇÃO DOS FIOS (FONTE: DATASHEET) ............................................................................................... 46
FIGURA 40: MONTAGEM 05 - LIGAÇÃO DO SERVO ........................................................................................................... 46
FIGURA 41: MONTAGEM COMPLETA .............................................................................................................................. 47
FIGURA 42: REPRESENTAÇÃO DE UM SINAL ANALÓGICO. .................................................................................................... 48
FIGURA 43: REPRESENTAÇÃO DE UM SINAL DIGITAL. ......................................................................................................... 49
FIGURA 44: DIAGRAMA DO SINAL PWM. ....................................................................................................................... 51
FIGURA 45: VARIAÇÃO DO SINAL PWM. ........................................................................................................................ 51
FIGURA 46: ESQUEMA DE LIGAÇÃO RX/TX. .................................................................................................................... 53
FIGURA 47: FRAGMENTO DO CÓDIGO PARA CONTROLAR A PORTA SERIAL. ............................................................................. 54
FIGURA 48: TELA DO SHELL CMD. .................................................................................................................................. 56
FIGURA 49: PARÂMETROS DE CONFIGURAÇÃO DA FUNÇÃO MODE. ...................................................................................... 56
FIGURA 50: TELA DA IDE E A CALCULADORA. .................................................................................................................. 57
FIGURA 51: FRAGMENTO DA FUNÇÃO ABRIR PORTA. ......................................................................................................... 58
FIGURA 52: FRAGMENTO DA ROTINA DO BOTÃO ON (BTNINICIAR). ..................................................................................... 59
FIGURA 53: FUNCAO TEMPERATURA (BTNINICIAR). ........................................................................................................... 64
FIGURA 54: FRAGMENTO DA ROTINA DO BOTÃO ON (BTNINICIAR), FIM DA ROTINA. ............................................................... 65
FIGURA 55: SINTAXE DO COMANDO DE ENVIO.................................................................................................................. 66
FIGURA 56: DIAGRAMA DA ARQUITETURA DA APLICAÇÃO. .................................................................................................. 68
FIGURA 57: TELA DA IDE PROCESSING. .......................................................................................................................... 70
FIGURA 58: TELA DA IDE WIRING. ................................................................................................................................ 70
FIGURA 59: IDE DO ARDUINO - VERSÃO 1.8.3 ................................................................................................................ 71
FIGURA 60: VISUAL STUDIO COM O ADDIN VISUAL MICRO. ................................................................................................ 72
FIGURA 61: PROGRAMA ESCRITO EM C PARA O MICROCONTROLADOR PIC18F4550. ............................................................. 73
FIGURA 62: CÓDIGO PISCA-PISCA EM C PARA O ATMEGA328P. .......................................................................................... 74
FIGURA 63: IDE DO ARDUINO COM NOVO SKETCH. .......................................................................................................... 75
FIGURA 64: BARRA DE FERRAMENTAS IDE DO ARDUINO. ................................................................................................... 80
FIGURA 65: PROCESSO DE COMPILAÇÃO DO ARDUINO. ...................................................................................................... 80
FIGURA 66: PROCESSO DE UPLOAD. .............................................................................................................................. 81
FIGURA 67: MONITOR SERIAL DA IDE. ........................................................................................................................... 81
FIGURA 68: MONITOR SERIAL, RECEBENDO OS DADOS. ...................................................................................................... 81
FIGURA 69: FLUXO BÁSICO DA COMPILAÇÃO. ................................................................................................................... 82
FIGURA 70: INTERFACE DO SUPERVISÓRIO. ...................................................................................................................... 83
FIGURA 71: BLOCO DE AJUSTE E CHAVE ON/OFF. ............................................................................................................ 84
FIGURA 72: GIRO DO POTENCIÔMETRO (ESQUERDA E DIREITA). ........................................................................................... 85
FIGURA 73: ENTRADA ANALÓGICA-RECEBENDO O VALOR. .................................................................................................. 85
FIGURA 74: MONITORAMENTO DE TEMPERATURA. .......................................................................................................... 86
FIGURA 75: CONFIGURAÇÃO DO ALARME E DEMONSTRAÇÃO. ............................................................................................. 87
FIGURA 76: MOVIMENTANDO O SERVOMOTOR. .............................................................................................................. 87
FIGURA 77: MOVIMENTAR SERVO COM VÁRIOS ÂNGULOS. ................................................................................................. 88
FIGURA 78: ACIONANDO E DESACIONANDO UM LED. ........................................................................................................ 89
1. Introdução

O presente trabalho tem como objetivo apresentar, de forma clara e objetiva,

como é fácil controlar um microcontrolador por meio do MsExcel.
Na indústria em geral, seja ela qual for, há uma necessidade de controlar os
processos produtivos. Em todos eles, há algumas variáveis que têm devem ser
controladas, tais como: pressão, PH, tempo, temperatura, umidade etc.
Nas indústrias do início do século XIX, tudo era muito manual. Imagine uma
tecelagem que, com certeza, já usava máquinas primitivas e extremamente manuais,
tipo algumas máquinas de tear e caldeiras de vapor para gerar água quente, vapor
d´agua para o tingimento dos tecidos. Era necessário ter muitos funcionários nesta
empresa: operários da tecelagem, do controle de operações responsáveis pelo
controle da produção, temperatura das caldeiras, temperatura dos motores, etc.
Tudo isso para manter o bom funcionamento da empresa. Assim, com esta pequena
visão, é possível perceber que há necessidade da indústria em controlar suas
variáveis dentro do seu processo produtivo, pois se uma dessas variáveis sofre
qualquer tipo de alteração o resultado do produto poderá ser alterado. Um exemplo
disso é o processo de produção de uma cerveja em uma microcervejaria: nele, há
muitas variáveis para serem observadas, desde a temperatura da caldeira onde o
mosto é fervido, passando pela temperatura de resfriamento até o seu envase, tem
muita coisa para ficar de olho. Outra realidade é fazer uma cerveja caseira: seria
necessário que o controle das temperaturas, pressão, envase e tudo que pertence a
este processo seria responsabilidade de apenas uma única pessoa, tornando este
processo uma tarefa bem complexa mesmo se for apenas um hobby. Quando
qualquer uma dessas variáveis da produção de cerveja (temperatura, pressão etc.)
fica fora do padrão, o resultado é a perda do produto final e isto, em uma pequena
empresa, o prejuízo pode ser algumas dezenas de reais e, em uma indústria grande,
esta perda pode representar milhões de reais.
Então, como se faz para não perder dinheiro desta forma?
Simples: automatizando o seu processo produtivo. Seria necessário à
empresa adquirir equipamentos com capacidade de controlar todo o seu processo
produtivo.
O processo de automação – além dos sensores, atuadores e controladores –
deve ter uma sala de controle que faça este interfaceamento entre todos estes
componentes e um operador treinado que pode (ou não) interferir no processo
produtivo quando houver alguma necessidade. Este controle é chamado de sistema
SUPERVISÓRIO, pois é isto que ele faz: ele supervisiona todo o processo produtivo
de uma empresa.
Agora, eis o objetivo deste trabalho: entender como funciona os supervisórios,
sensores, controle e atuadores e ver quais as alternativas de se ter um software
supervisório que seja economicamente mais viável para empresas de pequeno e
médio porte.
Neste trabalho, será demonstrado como criar supervisórios simples, mas
eficientes usando o Microsoft Excel. Será construído um pequeno supervisório
modelo para controlar um Arduino.

2. Fundamentos de Instrumentação

A cerveja é basicamente um fermentado de cereais com água e levedura que,

após um tempo de maturação (fermentação) e de ser resfriada, ganha o seu teor
alcoólico por conta das leveduras que se alimentam dos açúcares e tem a liberação
do álcool. Estando gelada, é uma das bebidas mais consumida no mundo.
Agora, observe que uma das principais variáveis neste processo de
fabricação de uma cerveja, caseira ou industrial, é a "Temperatura". Tem-se o
controle da temperatura com um grande "X". Se a temperatura não estiver no ponto
desejado, é possível perder todo o mosto (mosto é o nome da cerveja antes de virar
cerveja própria para o consumo). Em consequência, para quem faz cerveja em casa,
a perda pode ser de alguns reais (em torno de uns R$ 600,00 para 20 L de cerveja).
Já para a grandes indústrias, um erro na temperatura em qualquer uma das fases de
produção da cerveja é uma perda de alguns mil reais.
Pense só: se este é um ponto muito crucial dentro do processo, então é um
ponto onde deve que haver pessoas sempre prestando muita atenção para a
temperatura permanecer no ponto. O controle é total, sempre regulando a
temperatura para mantê-la no ponto ideal, baixando ou aumentado até ficar sempre
dentro da especificação.
Se isto é feito em casa, o produtor vai estar sempre perto da "panela de
cozimento" e ficar sempre controlando a "temperatura” e o tempo de cozimento.
Opa! Outra variável muito importante foi referida: o "Tempo". Este é outro ponto
muito importante, pois em algum momento a TEMPERATURA está correta mas ficou
muito TEMPO e isto ocasionou um problema de aumento da “pressão” dentro da
panela.
Veja, outra variável apareceu: tem-se agora a PRESSÃO. Sim, há muitas
variáveis para prestar atenção e, caso seja perdida qualquer uma delas, o produtor
vai ter problemas na produção. O grande objetivo de qualquer empresa é ganhar
dinheiro e ter lucro e, para que isto aconteça de forma correta e sem perdas, a
indústria recorre a AUTOMAÇÃO INDUSTRIAL.
A AUTOMAÇÃO INDUSTRIAL serve para criar padrões e controla grandezas
existentes por meio de hardware e software projetados especificamente para este
fim.
Assim, é possível garantir que um processo seja executado quantas vezes for
necessário sem qualquer tipo de erro, pois uma vez criado os parâmetros dentro da
PLANTA INDUSTRIAL todos são executados com perfeição.
Em qualquer processo industrial, é extremamente importante controlar e
manter as principais variáveis, tais como: pressão, nível, temperatura, PH, tempo,
umidade, etc. Todos devem estar sempre de acordo com o seu padrão.
Para isto, a indústria tem os INSTRUMENTOS DE MEDIÇÃO E CONTROLE
ou SISTEMAS DE MEDIÇÃO.
Os sistemas de medição usam sensores para receber do mundo externo as
percepções que estão a sua volta e os envia para o sistema de controle que tem a
função de converter este sinal analógico em um valor mensurável.
Os sistemas de controle recebem estes valores e têm que os manter sempre
dentro do valor padrão ou valor definido (set point) e a automação faz o resto, ele
mesmo faz os ajustes que achar necessário (offset).

2.1. Classificação dos instrumentos

Nas indústrias em geral, há sempre alguns elementos que ajudam nos

processos de fabricação, sejam eles alarmes, sensores, aturadores, etc. Serão
vistas agora as definições de alguns desses instrumentos:
 Instrumento Descrição
São os dispositivos que não tem nenhuma medida em si próprio apenas sentem
Cegos o valor da medida para o seu acionamento, nesta classificação temos os
ALARMES e os PRESSOSTATOS e os TERMOSTATOS
São dispositivos que tem alguma forma de leitura dos valores obtidos, seja por
Indicadores
uma escala graduada ou na forma digital.
São dispositivos que registram e armazenam os dados lidos e controlados e
Registradores
mostram em forma numérica ou em gráficos.
São os dispositivos que estão realmente em contato com o objeto a ser medido
Primários
ou controlado ou são os sensores propriamente ditos
Os transmissores recebem a variação na medição a partir dos elementos
Transmissores primários. Sensores estes que podem ou não este no mesmo encapsulamento do
transmissão.
São dispositivos que recebe um sinal de uma determinada forma e o converte
Conversores
para uma forma padrão, também chamado de TRANSDUTOR
São dispositivos que recebem os sinais dos sensores e comparam os valores
Controladores recebidos com os valores de controle, se houve algum erro o próprio dispositivo
consegue regularizar este erro.

Estes são os principais instrumentos de medição e, por meio deles, o controle

em uma indústria é feito, pois tem como medir temperaturas, saber nível de água, e
controlar pressão. Sempre com precisão e controle.

3. Os primórdios do controle industrial

No início da Era industrial moderna, a partir dos anos de 1960, a indústria

tinha o controle dos seus processos produtivos por meio do que se chama hoje de
“Quadro de comandos elétricos”, que nada mais era do um arranjo lógico feito com
relés e atuadores (ver figura 1).
Estes quadros de comandos eram usados para tudo dentro das indústrias
(ainda hoje são usados, mas para alguns casos gerais), desde acionar uma esteira,
acionamento de motor, controle de luz e etc.
 Figura 1: Quadro de comandos elétricos Figura 2: Esquema elétrico
industrial
(Fonte: Site: (Fonte: Franchi, 2007, p. 222)
http://eletricasilveira.com/manutencao-quadro-
de-comando-kimadeiras,2017)

Os eletricistas sabem muito bem o quanto é complicado montar, manter e

fazer qualquer tipo de alteração em um quadro de comandos elétricos. Veja um
esquema elétrico que os eletricistas têm que conhecer para trabalhar (ver figura 2).
Pois bem. Esta era a rotina de muitos eletricistas que trabalhavam nas indústrias em
meados dos anos 1960 e 1970.
Qualquer alteração na planta para acrescentar qualquer dispositivo novo ou
remover um componente com defeito era bem trabalhoso.

3.1. Controle Lógico Programável – CLP

Um sistema de controle programável foi desenvolvido por volta de 1968 pelos

engenheiros Dick Morley e George Schwenk, proprietários da Bedford Associates.
Este sistema tinha a capacidade de controlar uma linha de produção de qualquer
tipo de indústria produtiva. Em 1971, este sistema foi implantado como o principal
sistema da empresa Hidra-Matic.
Esta empresa é uma das empresas da GM. Ela desenvolve transmissões
automotivas; e eles estavam com problemas para controlar as suas linhas de
produção na configuração antiga: a empresa levava em torno de 15 dias para
reconfigurar seus controladores para uma nova planta industrial, isto era feito
usando PDP-14 da DEC e esta situação sempre foi um problema.
 O controlador chamado MODICON-84 (Modular Digital Controler-84) – que
tinha uma maior capacidade de processamento, maior poder de controle, mais
entradas e saídas de controle – foi a nova aquisição, e o melhor: a Hidra-Matic
poderia fazer a alteração em suas linhas de produção em um tempo bem menor,
pois toda a reconfiguração da planta industrial era feita em até 6 dias. Outro ponto
que deve ser falado é que o MODICON era programado usando uma linguagem que
já era conhecida pelos eletricistas na época, é uma linguagem que simulava a
montagem de um painel de comandos elétricos que se parece com uma “escada”.
Por isto, o nome da linguagem é LADDER.

Figura 3: MODICON-84
(Fonte: http://repositorio.uniceub.br/bitstream/235/8690/1/21016990.pdf, 2017)

O protótipo desenvolvido pela MODICON (Dick Morley - Bedford) era

chamado de 084 porque seu protótipo era o de número 84 na lista das empresas
fornecedoras de soluções para a GM. Allen Bradley, que adquiriu a 3-i no final de
1969, registrou o nome "PROGRAMMABLE LOGIC CONTROLLER" - CLP assim
que comprou a empresa. Mas, como nunca aplicou o uso exclusivo do nome, este é
usado livremente para designar estes tipos de equipamentos.
 Figura 4: Da esquerda para direita, Dick Morley, Tom Bossevain, George Schwenk e Jonas Landau
(Fonte: https://www.automation.com/automation-news/article/the-dawn-of-the-programmable-logic-
controller-plc, 2015)

Em meados dos anos 1970, a empresa Square D adquiriu as licenças de

distribuição junto a MODICON PLC e a Schneider Eletric é dona da Square D.

3.1.1. O CLP moderno

Os CLPs atuais têm muito mais funções que seus antecessores. Hoje em dia,
eles controlam diretamente os sensores; ou seja, pode-se ligar um sensor de
temperatura diretamente em um CLP, controlar a variação de temperatura e fazer as
correções para um equilíbrio do processo, e controlar atuadores à distância. Hoje,
ele pode se conectar a uma rede industrial com protocolos específicos para a
transmissão dos dados e sinais analógicos e digitais; enfim, superam e muito os
primeiros modelos e ainda usam a linguagem Ladder para facilitar sua programação.
Estes CLPs mais modernos têm uma variação entre R$ 300,00 até valores
acima de R$ 5.000,00, isto depende muito da marca, modelo, quantidade de portas
e recursos adicionais.

3.1.2. A arquitetura básica

O princípio básico de funcionamento de um CLP é apenas um fluxo simples

de entrada controle e saída, conforme a figura 5:
 Figura 5: Fluxo básico de um CLP.

Este fluxo ocorre sempre desta maneira: o CLP faz uma varredura em todas
as entradas (Input), tanto as digitais como as analógicas, e as carregam para a
memória, depois o programa carregado executa as tarefas de acordo com a
programação feita e depois gera os retornos para as devidas portas de saída
(outputs).
O CLP é construído usando uma CPU que processa os dados recebidos da
memória e os envia para as saídas, mas para que tudo isto funcione tem-se uma
fonte de alimentação que varia entre 110 e 220V. Veja a figura 6.

Figura 6: Diagrama em blocos de um CLP

Para as operações de acionamento de atuadores, os CLPs têm um atrativo,

que são os módulos de INPUT/OUTPUT que podem ser incorporados e quanto mais
módulos mais portas e mais funções são adicionados no CLP. É claro que estes
modelos com mais Slots são os mais caros, existem também os chamados mini PLC
que tem somente algumas entradas e saídas fixas, mas assim mesmo têm custos
elevados. Estas composições podem ser vistas melhor na imagem abaixo:

Figura 7: Diagrama em blocos de um CLP e seus módulos.

3.1.3. A linguagem de programação

Como foi dito antes, a grande motivação para a GM desenvolver uma

tecnologia para otimizar os controles dentro das suas fábricas foi realmente a
dificuldade de se trocar as plantas (estruturas mecânicas e elétricas do chão de
fábrica) quando era necessário a mudança da linha de produção para um novo
produto.
Os eletricistas tinham uma dificuldade muito grande para fazer qualquer tipo
de mudança nos quadros de comandos elétricos, pois as plantas eram grandes e o
tempo para esta tarefa era bem pequeno, sempre dava algum problema, pois a
empresa não poderia ficar muito tempo parada, um dia fechada para estas
alterações era na verdade uma grande perda em dinheiro.
Os eletricistas já estavam acostumados a um esquema que, ao ser
desenhado muito se assemelhava a uma escada, e mostrava realmente como ficava
dentro dos armários de comandos elétricos, onde para um olho treinado entenderia
toda a lógica com os fios, cabos, reles e contatores.
 A linguagem de programação dos primeiros CLPs foi chamada de
“Histograma de Contatos” ou, como foi mais conhecida, “Diagrama de Escada”, isto
porque o esquema era muito parecido com os esquemas elétricos dentro dos
armários.
Assim, a linguagem LADDER foi melhorada e aperfeiçoada para ser usada
para programar a lógica e gravar no CLP

Figura 8: Esquema elétrico e a linguagem Ladder.

(Fonte: Bega, 2006, p. 521)

Como pode ser observado, esta programação facilitava bastante que

qualquer eletricista com experiência teria êxito em criar uma lógica de programação
e gravar em um CLP, mas a linguagem Ladder não é a única que pode ser usada
para programar um CLP. Existem outras pelo menos umas três muito conhecidas.

Figura 9: Tela do RSLogix 5000, mostrando as 4 linguagens.

(Fonte: Tergolina, 2014, p. 22)
3.2. A sala de controle

Com toda a evolução da indústria deste os anos 1900, uma coisa era sempre
almejada: o “controle remoto”. Imagine em uma indústria de tecidos onde se tem
muitos vasos de pressão; sempre existiu a necessidade de ter um funcionário para
controlar a temperatura da caldeira, um outro para controlar a quantidade de água,
outro para controlar o fogo, e ainda mais um para controlar tudo isto.
Um controle que, à distância, poderia receber os sinais analógicos, controlar e
executar atuadores para controlar alguma situação sem haver a necessidade de ter
um funcionário perto o bastante de alguma caldeira ou forno. Isto sempre pensando
na melhoria do trabalho. Assim, tem-se o SDCD - Sistema Digital de Controle
Distribuído: um sistema de controle microprocessado que foi concebido de início
para controlar as variáveis analógicas.
Este sistema está apoiado em três pilares, assim: 1) A interface com o
processo (usando controladores locais e sistemas de aquisição de dados), 2) IHM
(a Interface-Home-Máquina), e 3) Data Highway (a via dos dados).
Deve-se perceber que o SDCD é um sistema que tem uma inteligência
computadorizada que pode tomar algumas decisões de acordo com as informações
recebidas. Enquanto o homem está em uma sala de controle a alguns metros de
distância do chão de fábrica, ele pode controlar remotamente algum atuador tipo
válvula de pressão, fluxo de ar, de agua etc., isto tudo à distância.

(Fonte:
https://www.automation.com/libra
ry/articles-white-papers/articles-
by-bill-lydon/do-plcs-eliminate-
Figura 10: TDC-2000. need-for-a-dcs, 2008)
 No Brasil, o primeiro sistema tinha o controle da planta e interagia com o
processo. Foi importado da empresa americana Honeywell era o TDC-2000 (Total
Distribuited Control) (ver a figura 10). Este equipamento, lançado em 1975 pela
empresa Honeywell, era um dos primeiros a ter uma CPU de computador de uso
geral, uma tela de CRT (Tubo de Raios Catódicos) e um teclado que facilitava a
operação do sistema por parte do operador.
Este foi considerado um dos primeiros sistemas que recebia a leitura de um
sensor por meio de placas adaptadoras (existiam várias) e na tela do TDC-2000 era
possível, em tempo real, a temperatura de uma caldeira, por exemplo.

Assim, este equipamento, e outros que vieram em sua época, foram os

pioneiros nos sistemas que hoje conhecemos como SUPERVISÓRIOS

3.3. Os supervisórios

Os supervisórios, hoje em dia, são os SDCD com esteroide, pois ele tem hoje
muito mais recursos que os primeiros SDCD.
Em princípio, estes novos sistemas têm um poder de não só receber os dados
em tempo real, mas ter um banco de dados com histórico de tudo o que aconteceu e
também ter recurso de interfaceamento que é possível acionar sirenes, válvulas e
qualquer tipo de atuador usando somente um comando que está sempre visível na
tela do sistema.
Estes sistemas hoje são chamados de Controle Supervisório e Aquisição
de Dados ou, em inglês, SCADA (Supervisory Control and Data Aquisition).
Para que estes sistemas funcionem de maneira correta, faz-se necessário ter
seus periféricos já instalados e configurados dentro da planta industrial; ou seja, um
sistema SCADA é um software que tem o desenho da planta industrial, mas se
conecta a qualquer controlador externo, pode ser um CLP, Controler ou até mesmo
ser ligado a um sensor com controler embutido (vide tópico 2.1).
Tudo isto é facilmente conectado ao SCADA por meio de comunicação serial
que todo o computador (PC comum) tem. Uma porta de comunicação serial que
normalmente é conhecida no meio técnico como RS-232, mas qualquer
comunicação serial pode ser usada, RS-485, Ethernet e USB.
 Basicamente, as principais funções dos sistemas SCADA são as seguintes:

a) Aquisição de dados: É a recepção da informação que vem de algum

controlador do processo que, na maioria dos casos, é um CLP, mas pode
vir diretamente de um Controler também.
b) Gerenciamento dos dados: Simplesmente a exibição das informações
geradas com os dados obtidos. Estas informações vêm do processamento
dos dados brutos vindos do CLP, que pode ser uma simples informação de
temperatura até mesmo o acompanhamento em tempo real na forma de
vídeo sobre a execução de alguma parte do processo; e isto é exibido por
meio de uma tela que normalmente tem o desenho da planta industrial,
com relatórios e armazenamento destas informações em banco de dados.

O uso da interface gráfica, que ficou muito forte nos anos 1990, é um grande
atrativo para termos telas mais bonitas com muitos detalhes e muito mais eficientes.

Figura 11: Sistema SCADA-Automação do sistema de tratamento de água.

(http://www.infoeng.com.br/conteudo/ambev-automacao-de-sistema-de-tratamento-de-agua.html,2017)

Pode ser observado na figura 11 que existe um sistema SCADA feito para a
empresa AMBEV para o tratamento de água. Vê-se que o sistema tem uma tela
muito bem produzida, isto para facilitar os operadores do sistema que, diga-se de
passagem, não precisa ser mais um operário com extremo conhecimento dentro da
empresa, basta que este operador faça um treinamento para aprender como operar
o sistema e pronto: menos custo para a empresa.
3.4. Prós e Contras

Qual a empresa que não quer reduzir seus custos operacionais, se o principal
objetivo de uma empresa é ter lucro?
Tudo o que foi apresentado até o momento foi para embasar que tivemos
uma evolução muito grande e, por vezes, até muito rápida com toda a tecnologia
que temos dentro da indústria.
Mas nem tudo são flores. Deve-se ter em mente que, para as indústrias terem
uma redução de custo usando a tecnologia, pode ser demorado. Veja quando uma
indústria automobilística substitui vários operários (mecânicos, eletricistas,
soldadores, pintores etc...) por robôs. Eles têm em mente só uma coisa: a redução
de custos. Mas alguém pode se questionar como reduzir custos fazendo altos
investimentos em tecnologia. Tentar-se-á tratar desta questão brevemente.
Ao substituir os operários por robôs, principalmente em funções que exigem
muita repetição de movimento e, principalmente, podem trazer riscos ao homem, é
somente se proteger contra os processos de doenças do trabalho, o resultado é
melhor. Quanto mais rápido a indústria constrói, mais ela vende e mais ela tem lucro
e o seu setor de RH não tem problemas com acidentes ou DORT (Doenças
Osteoarticulares Relacionadas ao Trabalho) para lidar. Mas, e os trabalhadores que
foram dispensados de suas funções? Bom, este é um problema que pode levar por
outros caminhos; portanto, não será discutido neste trabalho já que está fora do
tema. Mas, de forma geral, acredita-se que os trabalhadores dispensados podem
assumir atividades mais humanas, como as de planejamento, desenvolvimento e as
de manutenção técnica.
Não ter um profissional extremamente especialista em sistemas SCADA pode
ser mais um ponto para os sistemas SCADA, pois um operário com apenas um
treinamento de operação do sistema poder operar sem muitas dificuldades. É claro
que a empresa deve ter um ou dois profissionais de infraestrutura (técnicos
especializados em rede industrial) para sempre manter a infra dos sistemas sempre
em ordem (computadores, CLPs, PACs e etc.).
Agora, ver-se-á que nem tudo são flores. Imagine que foi comprada uma
licença para um sistema supervisório (sim, a maioria dos sistemas SCADA são
vendidos por meio de licenças), foi chamada outra empresa para montar o seu
supervisório e, após um certo tempo, precisou-se adicionar um novo controlador
(que pode ser um controlador de temperatura, pressão etc.), faz-se esta aquisição e
chama-se um técnico e é solicitado que ele faça a integração deste novo
equipamento; e tem-se uma surpresa: o seu sistema SCADA, que custou muito caro,
não aceita novos DRIVERS. Isto é muito comum. É chamado de sistema FECHADO.
Ponto negativo.
Como foi mencionado antes, os sistemas SCADAs são vendidos por meio de
licenças. Estas licenças normalmente são baseadas no número de terminais (tags)
que sua planta tem, ou seja, o sistema é montado de acordo com todos os seus
terminais de controle. Estes sistemas SCADA são verdadeiramente uma tela em
branco onde o artista (o técnico especialista) desenha o fluxo do processo a ser
controlado. Neste desenho, ele tem que configurar todas as tags (terminais de
controle físico), e um sistema de tamanho razoável pode chegar a algumas centenas
de reais. Ponto negativo.
Não se pode deixar de comentar que algumas empresas disponibilizam uma
versão DEMO do seu software para que se estude e se tenha uma ideia de como
fazer o projeto; mas assim mesmo os DEMOS não são completos ou têm limitações.
Outra característica é a flexibilidade de poder criar novas funções. Alguns no
mercado permitem que você possa criar novas funções e adicionar como se fosse
um Plugin no sistema, até mesmo usando linguagens de programação de uso geral
como C/C++, VISUAL BASIC e etc. A National Instruments oferece este recurso no
seu sistema LabView. Ponto positivo.
Outro recurso que pode ser observado é ter a possibilidade de programar o
seu CLP e seu sistema SCADA dentro de uma única ferramenta. Isto é bem
interessante, mas isto pode ser uma faca de dois gumes pois aí pode-se estar
comprando um sistema FECHADO, e o valor será mais salgado. Ponto negativo.
Enfim, são os pontos mais comuns que devem ser observados.
Ainda nesta questão, é muito lógico que um sistema de grande porte com
todos estes recursos é uma excelente aquisição para a empresa, mas sempre se
tem alternativas. Uma delas é desenvolver seu próprio sistema supervisório (a
empresa vai ter custo com o funcionário, equipamentos de testes etc.), pode também
usar sistemas do tipo free, que são limitados (isto serve para que se compre a
versão completa do seu sistema), e é claro que pode contratar uma empresa para
desenvolver o sistema. Estas são somente as alternativas mais comuns.
4. Breve introdução aos microcontroladores

Muito se fala em placas de prototipação rápida hoje em dia. Entretanto, há

alguns anos, dentro da indústria, era bem complicado se construir alguma coisa que
tivesse uma inteligência (artificial) dentro de um circuito para que ele tomasse as
decisões cabíveis em algum momento, ou simplesmente fizesse alguma coisa.
Em anos anteriores, só se tinha as CPUs como o Z80 (microprocessador da
empresa ZILOG), Motorola 6800, entre outros. Não existia projetos que fossem
executados em alguns dias: eles duravam meses, pois a construção tinha que usar
muitos componentes.
A linguagem mais comum para a programação destas CPUs é a linguagem
Assembly que é considerada por muitos extremamente complexa e de baixo nível.
A linguagem Assembly, que nasceu nos anos 1950, veio como uma
alternativa para os engenheiros (ainda na época dos grandes computadores
valvulados e os primeiros computadores transistorizados) que sofriam bastante para
programar um computador daquela época, e para tentar melhorar um pouco esta
atividade, foi criada uma linguagem simbólica que substitui as instruções em binário
ou em hexadecimal por letras que são semanticamente mais fáceis de lembrar que
uma sequência de zeros e uns.
Assim, esta linguagem monta as instruções de forma correta para que o
processador possa executar as operações solicitadas; ou seja, a linguagem é
somente um tradutor de símbolos mnemônicos para a linguagem de máquina.
Com a evolução tecnológica e da nova era da microeletrônica, na década de
80, apareceram os primeiros Microcontroladores ou MCU (Micro Controler Unit –
Unidade de Microcontrolador).

4.1. Diferenças entre MCU e CPU

Os processadores (CPUs) e os Microcontroladores (MCUs) são primos com

algumas diferenças.
Em princípio, a diferenciação é bem simples, enquanto as CPUs precisam de
outros circuitos para que ele funcione, tais como um circuito de memória RAM, para
o armazenamento dos programas em execução, uma memória ROM para o
programa principal que vai controlar tudo (o programa do BIOS da placa mãe é um
exemplo), um controlador de I/O, um oscilador e muito mais, enfim uma CPU precisa
de todos estes componentes para que você possa construir um projeto com ele. Ver
a figura 12.

Figura 12: Diagrama em blocos de um computador moderno.

Já as MCUs não precisam de nada disto. Mas como assim não precisam?
Todos estes componentes que uma CPU precisa para funcionar um
microcontrolador já têm tudo isto, só que encapsulado em um único chip de circuito
integrado (C.I).

Figura 13: Diagrama em blocos de um microcontrolador Pic família 18F.

(Fonte: http://www.microchip.com/design-centers/8-bit/architecture,2017)

Como todos os microcontroladores têm tudo o que precisam para operar,

qualquer projeto fica bem fácil e mais barato para se desenvolver. Os
microcontroladores raramente necessitam de algum chip externo. Sempre vai existir
esta situação, mas são para projetos mais especializados. Caso contrário, não existe
esta necessidade.
Assim, pode-se ver que os microcontroladores são uma ótima alternativa para
o desenvolvimento de novos projetos. Seus recursos são bem menores em relação
aos computadores atuais. Como exemplo, tem-se microcontroladores com memória
entre 1 e 3 MB de RAM, tem-se um clock bem pequeno entorno de 40Mhz, e isto é
sem comparação com as CPUs mais modernas que operam com clocks acima dos
2GHz (2000MHz).
E tem mais coisa boa: para programar um microcontrolador, pode-se usar o
bom e velho Assembly. Mas se não quiser, sem problema. Pode-se programar
facilmente usando a linguagem C/C++, as IDE de desenvolvimento geralmente
disponibilizam vários recursos como Debug (Procedimento de depuração do código
em tempo de execução), verificador de memória e etc.
Até 2016, existiam duas grandes empresas que eram líderes de mercado no
que tange a fabricação de microcontroladores. Basicamente, tinha-se a Microchip
(ela fabrica os PIC), uma das grandes fabricantes, e, do outro lado, a sua grande
concorrente a Atmel (fabricante do Atmega e AVR). Mas, em janeiro de 2017, foi
confirmada a aquisição da Atmel pela sua concorrente, a Microchip. Assim, a partir
de agora, todos os microcontroladores para Arduino e seus clones serão de uma
mesma empresa, com a exceção dos Arduinos produzidos em parceria com a Intel,
que usa um microcontrolador proprietário.

4.2. Arduino – Breve Histórico

As primeiras placas de Arduino foram fabricadas em 2005 usando um

microcontrolador Atmega8.
Ainda hoje existe muita controvérsia com relação a quem é creditado como o
criador do Arduino. Na pesquisa, foi encontrada a seguinte informação. Duas
pessoas trabalhavam em paralelo com a mesma ideia, uma delas era Massimo
Banzi, professor de design de interação na Interaction Design Institute na cidade de
Ivrea na Itália. Ele desenvolveu um projeto para ensinar seus alunos a criar projetos
usando a eletrônica e a programação de computadores, este projeto se chamava
programma2003 e usava um ambiente de desenvolvimento chamado JAL (Just
Another Language – Apenas uma outra linguagem) este propiciava a programação
em C puro. Um dos alunos de mestrado de Massimo era Hernado Barragan, que
teve em 2003 uma ideia parecida e foi usada em sua tese de mestrado. A sua ideia
era bem parecida com a de Massimo, porém bem mais simples. Ele usou um
microcontrolador Atmega mais barato e desenvolveu um framework baseado em
processing que lhe permitiu a utilização da linguagem C para programar o Atmega.
Este protótipo foi chamado de wiring.
Enfim, ainda existem muitos problemas jurídicos nesta questão. O fato é que
o Hernado Barragan teve a melhor ideia e Massimo Banzi foi o cara de visão que
mostrou para o mundo o Arduino (a figura 14 mostra o time do projeto Arduino)
como sendo uma plataforma de prototipação rápida com o melhor resultado unindo
hardware de baixo custo e software compatível e de livre acesso.

(Atrás)
Dave Mellis,
Tom Igoe;
(Frente)
Gianluca Martino,
David Cuartielles,
Massimo Banzi

Figura 14: Time Arduino.

(Fonte: https://blog.arduino.cc/2008/03/,2008)

A primeira placa em formato beta teve como conexão uma porta DB9, usando
o protocolo de comunicação RS232. Logo foi substituída pela versão 2.0.

Figura 15: Primeira placa Arduino-RS232 fabricada na Itália.

(Foto: Nicholas Zambetti, Fonte: https://www.arduino.cc/en/Main/ArduinoBoardSerial,2005)

A próxima placa já foi uma grande evolução. Eles conseguiram um conversor

da porta USB (Serial Universal Bus) para a uma porta serial comum, como se fosse
uma porta tipo RS232. Isto só é possível usando o chip FTDI-FT232Bm que no caso
era o componente mais difícil de ser soldado, pois era o único componente tipo
SMD.
 O projeto Arduino sempre foi disponibilizado de forma livre. Muitas outras
pessoas e empresas criaram versões clones do Arduino, já que a licença do Arduino
permite isto. Neste projeto, será usado um clone Arduino, chamado de Blackboard,
que é um clone da placa Arduino UNO R3. Mas lembrando que se tudo é distribuído
gratuitamente porque é um clone?
Simples, já é um entendimento que as únicas originais são as fabricadas na
Itália direto da Arduino-SRL (Empresa Smart Project srl do co-fundador Gianluca
Martino) com a licença da Arduino-LLC (de Massimo Banzi), todos os outros têm por
base as mesmas especificações e até o mesmo microcontrolador. Mas se não forem
fabricados pela Smart Project Srl, são clones.

5. Linguagem VBA

Pensando um pouco sobre as linguagens de programação, tentou-se

conhecer quais outras linguagens (de fácil aprendizagem) poderiam ser usadas para
se comunicar com um microcontrolador.
Então, fez-se a seguinte analogia, nos primórdios da Era da eletrônica e
computação e nos primórdios da automação industrial, os primeiros dispositivos de
controle eram os próprios computadores (modificados para tal tarefa), sendo assim
como era feita a comunicação entre os dispositivos. Usando uma simples porta
serial.
A maioria dos dispositivos daquela época se conectava por meio da porta
serial e o sistema operacional mais comum eram os sistemas operacionais de disco
o mais comum deles era o MsDOS.
Este S.O. tinha em seus comandos nativos a comunicação com as portas do
computador, tanto as portas paralelas como as portas seriais. Pensando um pouco
mais, ainda se tem o MsDOS (ou uma versão emulada, dentro dos S.O. modernos)
no nosso Windows de hoje em dia e, assim sendo, quais eram as linguagens na
época dos primeiros SDCD; sim, eram o C/C++, Assembly, Pascal e o Basic.
A linguagem de programação BASIC (Beginner’s All-purpose Symbolic
Instruction Code – Código de instruções simbólicas de uso geral para iniciantes),
que nasceu em 1964, era uma linguagem até bem versátil para a época e foi a
influenciadora para as outras linguagens que derivaram diretamente dela, como o
VBScript, DarkBASIC, Visual Basic e VBA.
A linguagem chamada de Visual Basic foi lançada em 1991 pela Microsoft,
com o advento muito forte do ambiente gráfico para MsDOS o Windows

Figura 16: Tela do Visual Basic Versão 1.0.

(https://winworldpc.com/product/microsoft-visual-bas/10, 2003)

A Microsoft (fundada em 1975), nesta época, já havia implantado uma versão

minimalista do seu principal programa de desenvolvimento que era o QBASIC. Esta
versão era suficiente para criar de forma rápida e prática novas rotinas e
funcionalidades a seus programas de escritório (suíte de escritório conhecida como
Office). Assim, caso se precisasse de contar quantas palavras em inglês tem o texto,
o Word não tem esta funcionalidade (até hoje não tem, ele conta o total de palavras
no documento inteiro), mas seria possível criar esta funcionalidade usando esta
versão do QBASIC que na época era chamado de WORD BASIC. Este era um
dialeto um pouco menor que seu primo rico, mas era suficiente para criar este tipo
de funcionalidade. Os engenheiros, quando usavam o Excel, usavam bastante esta
forma de criar funções e rotinas para automatizar as suas tarefas. Mas poucos
chamavam de Excel Basic e era mesmo conhecido como MACRO.
Somente em 1995, a Microsoft reuniu todos os programas de escritório em
um único pacote chamado, assim, de Office. E, em 1997, veio uma das versões
mais interessantes, pois foi a evolução deste dialeto BASIC que a partir de agora
ganha uma nova roupagem, novos recursos e, mais que isto, uma identidade
própria. Agora esta nova linguagem é incorporada diretamente ao pacote, ou seja,
qualquer nova função pode ser automaticamente usada sem qualquer tipo de
restrição. Esta nova linguagem agora é chamada de VISUAL BASIC FOR
APPLICATIONS ou simplesmente de VBA.
 A linguagem VBA tem uma IDE (Integrated Development Enviroment –
Ambiente de desenvolvimento integrado) que possibilita o desenvolvimento de
qualquer coisa: funções, procedimentos e inclusive formulários (as telas). Entretanto,
deve-se lembrar que tudo o que for criado em VBA só pode ser executado dentro do
seu HOST, ou seja, dentro do seu aplicativo maior, seja ele o Excel, Access e todos
os outros.

Figura 17: Logomarca do VBA( Internet)

Ele, na verdade, nasceu para que pessoas comuns sem conhecimento de

programação pudessem criar funções para facilitar o seu dia a dia, automatizando
assim as tarefas mais repetitivas.
Mas a aceitação foi tão boa no mercado que a Microsoft ganhou muito
dinheiro licenciando a linguagem VBA para outros fabricantes de software, tais
como: a Autodesk para usar no Autocad, a Mathcad, a Wordperfect, entre outras.
O VBA expandiu exponencialmente a capacidade de “plug-in” nos programas
que tinham o VBA como linguagem de automação. Um contador que tem um
escritório de contabilidade precisa de uma função para usar no Excel que é muito
especifica e ficaria muito complexa se ele tivesse que criar esta formula através das
formulas do próprio Excel, e se ele conseguir criar esta formula maluca, e a sua
repetição em outras planilhas. Complicado, não é?
O VBA está aí para exatamente isto. Veja que ele só tem que conhecer o
básico da lógica de programação (conhecer os tipos de dados, as lógicas de
condições e loops), conhecer os comandos e instruções específicas da linguagem e
conhecer os objetos do Excel. Em poucos dias de estudo, ele já consegue criar a
sua função especializada: cria um suplemento para o Excel e agora ele pode usar a
sua função em qualquer arquivo do Excel.
Entre as suas principais aplicações, estão os seguintes pontos.

A) A manipulação da interface da aplicação;

B) Criar novas barras de menus, ou Ribbons;
C) Criar novas telas usando os formulários;
 D) Interligação com os outros aplicativos do pacote Office;
E) Extração de dados dos principais bancos de dados e sistemas
comerciais do mercado e muito mais.

O negócio ia tão bem que, em 16/03/1998, houve um evento que a Microsoft

compareceu: o National Manufacturing Week, na cidade de Chicago-EUA. Neste
evento, a Microsoft apresentou em uma palestra mais de 12 empresas que havia
licenciado a sua linguagem VBA.
Um executivo de uma destas empresas (ver figura 18) afirma que no seu dia a
dia de trabalho é muito comum no meio da instalação dos sistemas SCADA e PLCs
que o cliente sempre solicite alguma tela a mais que não estava no projeto, são
coisas assim que tornam o VBA muito customizável. Isto é muito interessante.

Figura 18: Gerente de Marketing da Microsoft fala sobre o VBA.

(https://sites.google.com/site/vbabernardes/vba/vba,1998)

Mas, em julho de 2007, a Microsoft deixou de licenciar e distribuir o core do

VBA para novos clientes. Os clientes atendidos continuarão a ter o suporte
garantido. Não foi muito divulgado, mas acredita-se aqui que a Microsoft está
fazendo isto - não atualizando mais nenhuma versão do VBA – porque esta
linguagem estava quase tomando o carro chefe da Microsoft (isto pelo uso dos
clientes).
Cria-se uma aplicação desenvolvida em VBA, no Access ou Excel, e pronto: é
só entregar ao cliente ou até mesmo vender a aplicação que, no fim das contas, é
apenas um arquivo de dados que pode ser executado pelo aplicativo Host.
Lembrando que qualquer aplicativo escrito em VBA não gera um Executável ou
como é conhecido dentro da plataforma Windows.
Mas, enfim, se muitas empresas da área industrial como a Rockwell,
Interllution, entre outras, usavam e usam até hoje em seus sistemas para facilitar a
vida dos programadores, porque não são simples mortais.
5.1. Justificativa

Basicamente, a grande justificativa em se usar o VBA (seja no Excel, Access

ou outro) é ter uma saída para os altos valores em um investimento na implantação
de qualquer sistema de automação, seja ele na indústria, em casa no comércio ou
qualquer lugar. Os custos para este tipo de investimento normalmente não são
baixos.
Mas existe uma saída: da mesma forma que se tem o ARDUINO como um
recurso eletrônico para a prototipação de forma rápida, tem-se a linguagem VBA
para se construir os próprios projetos com a certeza que o projeto não terá
surpresas.
Na indústria, tem-se a mesma coisa. Veja que se pode usar o Microsoft Excel
com recursos nativos (sem uso de DLLs ou programas feitos por terceiros) para
controlar as portas de comunicação de um desktop ou laptop (Conhecido como
notebook, computador portátil).
De forma fácil, pode-se ler e gravar, ou seja, é possível controlar um
microcontrolador usando apenas a linguagem VBA e uma interface muito amigável.
Quando o protótipo estiver pronto, vai-se construir a sua PCB (Printed Circuit
Board – Placa de circuito impresso) com os componentes que compõem o projeto e,
quanto ao software, agora é possível construir a aplicação usando IDE com mais
recursos, pode até mesmo criar uma aplicação de desktop usando a linguagem
VB.Net (a sucessora da linguagem VB da Microsoft) dentro da IDE Visual Studio.
Enfim, o controle com os custos é bem resumido, pois tem-se uma placa de
prototipação rápida de baixo custo e uma linguagem de programação completa e de
fácil acesso. Além disso, caso se tenha uma versão do Microsoft Office instalada no
computador de forma completa, já se tem a linguagem VBA instalada. Agora é só
usar.
E pode-se ter certeza que muitos dos projetos vão acabar sendo melhorados
e podendo até mesmo este ser o seu projeto final, sem haver a necessidade de se
converter seus códigos de VBA para outra linguagem como VB.NET, C#, entre
outras.

6. O projeto modelo

6.1. Hardware de controle

6.1.1. Considerações iniciais

Este trabalho tem o propósito de demonstrar que é possível desenvolver

projetos dos mais variados tipos e com os mais variados recursos usando placas de
prototipagem rápida. Quem sabe um estudante ou um engenheiro queira
desenvolver algum sistema que faça alguma coisa em muito especifica que não tem
no mercado comercial, ele pode sim desenvolver usando as chamadas placas de
prototipagem rápida. Tem-se aí as placas de Arduino, RaspbarryPy, Beaglebone só
para citar as mais conhecidas. Fora as versões e clones melhorados com mais
recursos que o próprio Arduino.
Assim com uma placa tipo Arduino, é possível desenvolver o protótipo de
forma rápida e segura e depois de pronto. Aí se cria a sua PCB de forma correta,
solda os seus componentes e com o software pronto e testado.
O objetivo aqui é demonstrar que, usando uma placa tipo Arduino (um clone)
alguns componentes eletrônicos, sensores e usando a linguagem VBA do Microsoft
Excel, é possível criar um sistema supervisório, sem usar DLLs de terceiros e nem
recursos pagos

6.1.2. Descrição do hardware do projeto

A placa de teste aqui é fabricada no Brasil pela Robocore, que fabrica uma
placa compatível com o Arduino. Sim, todas que são compatíveis suportam todas as
placas de acessórios chamadas de Shield.
 Figura 19: Placa Blackboard com o Atmega328.
(Fonte: https://www.robocore.net/loja/produtos/arduino-blackboard.html,2017)

Conhecer-se-á um pouco melhor esta placa, pois é com ela que se vai
construir o sistema embarcado que vai fornecer os dados necessários.
Veja a descrição básica deste modelo na figura 20, mencionando seu
microcontrolador e suas principais características.
Esta é uma placa de prototipação rápida e como tal ela tem que ter os
principais componentes necessários a esta tarefa como, por exemplo, portas para a
conexão com os pinos analógicos, digitais, fonte de alimentação e muito mais. Não
se vai estender muito, pois como esta placa é bem documentada na internet e no
site do fabricante. Ater-se-á somente a explicar os componentes que serão usados,
mas tem uma visão com os principais componentes desta placa na figura 21.

Figura 20: Descrição da Blackboard V1.0.

(Fonte: https://www.robocore.net/loja/produtos/arduino-blackboard.html)
 Figura 21: Descrição dos componentes.

6.1.2.1. Microcontrolador usado

Como já foi dito antes, os microcontroladores são dispositivos bem completos,

tem todos os circuitos e periféricos que são úteis para o seu funcionamento
completo.
Conforme a figura 22, pode-se observar todos os componentes (de forma
bem simplificada, pois não é objeto deste trabalho aprofundar os conhecimentos da
eletrônica deste microcontrolador), no diagrama em blocos (forma simplificada).
Veja que a CPU tem um total de 131 instruções e as suas memórias são
divididas em SRAM, FLASHRAM (RAM) e a EEPROM. Tem-se ainda as portas que
são divididas em B, C e D. Tem-se os TIMERS (são 3 tipos). Tem-se também as
portas seriais de comunicação contando com os seguintes protocolos:

A. UART: Universal Assincronus Receiver and Transmiter - Receptor e

Transmissor assíncrono universal;
B. SPI: Serial Peripheral Interface – Interface de comunicação serial para
periféricos, protocolo criado pela Motorola com comunicação “Full-Duplex”;
C. TWI: É um protocolo criado nos anos 80 - pela Philips, neste protocolo, é
usado apenas dois fios para a comunicação, um transmite os dados e o
outro transmite o sinal de clock. O nome deste protocolo é conhecido
como I2C, mas para a Atmel não pagar royalties pelo uso da marca. Eles o
chamaram simplesmente de Interface de Fio Duplo (Two Wire Interface).
 Tem-se ainda os Comparadores e Conversores A/D (Analógicos – Digitais), e
uma coisa bem inteligente nesta arquitetura é que o WathDog Time (Cão de Guarda
– WDT) tem um oscilador gerador de clock específico para ele, ou seja, este
oscilador é sincronizado como o gerador de clock principal, mas em qualquer
momento que o WDT precisar entrar em ação ele não vai afetar o restante da
aplicação.
O microcontrolador que será usado, pertence à família AVR (Advanced Virtual
RISC), fabricado pela Microchip, todos os modelos desta família têm a mesma
arquitetura e conjunto de instruções. Este modelo é o Atmega328P, é um
microcontrolador de 8 bits e tem uma memória Flash de 32Kb.

Figura 22: Diagrama em Blocos simplificado do Atmega328P.

Para se desenvolver qualquer tipo de projeto de automação usando

microcontroladores, faz-se necessário ter o chamado DATASHEET, que é o manual
do microcontrolador. Nele, sempre se tem todas as características do
microcontrolador, tem-se todas identificações dos pinos, quais as suas funções,
tensões e tudo mais o que for precisar, pois sempre tem que ter à mão o Datasheet
dos pinos o chamado de PINOUT. Ver a próxima imagem.
 Figura 23: Pinos do Atmega328P.
(Fonte: http://www.pighixxx.com/test/portfolio-items/atmega328/?portfolioID=337,2017)

Para a montagem de qualquer projeto, faz-se necessário ter sempre à vista o

Datasheet para ver os seus pinos/funções e mais durante a etapa de escrever o
programa que vai ficar embarcado dentro do microcontrolador. Tem-se que saber
quais bibliotecas devemos incluir, quais instruções devemos chamadas; enfim, é
extremamente útil.

6.1.3. Descrição dos componentes

Para o projeto, serão usados componentes simples e de fácil aquisição.

Segue a tabela com os componentes e suas características:

Componentes Descrição
 O potenciômetro é um componente analógico que permite alterar o valor da
resistência que passa por ele, ou seja, é muito comum o seu uso em
situações em que necessite de ajuste com muita constância, exemplo,
como o botão do volume usa nos aparelhos de som, em mesas de som ou
Figura 24:
qualquer lugar que seja necessário um ajuste.
Potenciômetro.

O LED ou Light Emmiting Diode é apenas um semicondutor com junção

PN. Quando uma corrente atravessa o semicondutor ocorre uma
recombinação dos portadores de luz, e uma radiação é emitida.
Mas como a sua radiação é muito baixa, por isto que temos uma capa feito
Figura 25: Diodo normalmente de uma resina que amplifica esta radiação, normalmente esta
Emissor de Luz - LED. capa é da mesma cor da radiação.

O LM35 é um dos sensores mais comuns em projetos de eletrônica e

automação em geral.
Ele é fabricado pela Texas Instrument (antigamente era pela National
Semicondutor). Ele tem a característica facilidade na instalação, ter um
Figura 26: Sensor de range entre -55º e 150 ºC, tem baixa impedância e saída linear geralmente
Temperatura LM35. tem um encapsulamento TO-92 de plástico.

Um resistor é um componente eletrônico que tem a finalidade de criar uma

“resistência” a passagem da tensão elétrica.

Figura 27: Resistor de É muito usado para redução da tensão ou da corrente em alguma parte do
330R de 1/8W. circuito elétrico.

Um Servomotor ou simplesmente SERVO é um dispositivo muito parecido

com um motor de giro livre, um motor de passo é um motor de giro livre, ou
seja, ele gira o seu atuador livremente por 360º.

Já um servo é um componente que tem dentro dele um conjunto de

engrenagens que fazem a redução do giro, pois dentro de um servo existe
um motor DC, um sensor de posição, que na verdade é um potenciômetro e
um circuito de controle que tem um circuito PID ele ler o valor da resistência
Figura 28: Servomotor do potenciômetro e determina a sua posição angular, assim todo o
SG90.
movimento é bem suave e controlado. Normalmente o servo tem um ângulo
restrito a 180º máx., mas existem outros que tem giro de 360º.

Equipamento muito usado para mover braços robóticos, e diversos tipos de

atuadores.
 Muito usado em eletrônica e no desenvolvimento de diversos projetos,
tecnicamente é conhecida com placa de ensaios, mas popularmente
conhecida como Protoboard ou em inglês Breadboard.

É uma placa furada na superfície, mas por baixo tem uma malha de
contatos interligados.

Figura 29: Protoboard A sua utilização é bem fácil, conectamos os componentes na Protoboard e
de 840 furos. ligamos os fios necessários aos outros componentes, fazemos todos os
testes do projeto e assim que estiver tudo concluído já poderemos fazer a
PCB definitiva.

A placa usada no nosso projeto é uma placa clone do Arduino, esta é uma
placa fabricada no brasil com o nome de Blackboard, tem o mesmo
microcontrolador de um Arduino UNO
Figura 30: Placa
Blackboard - Arduino.

Foram mostrados quais os componentes que serão usados para a construção

do pequeno projeto de controle de aquisição de dados, conheceu-se os
componentes e será mostrada agora a lista de componentes e uma média do preço
de cada um deles:

Nº Componente Quantidade Valor

1 Potenciômetro linear de 10KB 1 R$ 1,80
2 Led 5 mm comum vermelho 1 R$ 0,20
3 Sensor LM 35 TO-92 1 R$ 7,50
4 Resistor 330R 1/8w 1 R$ 0,15
5 Servomotor SG90 1 R$ 20,00
6 Protoboard 830 furos 1 R$ 60,00
7 Placa Blackboard V1.0 (comp. com o Arduino UNO) 1 R$ 85,00
Totais: 7 R$ 174,65

Vale ressaltar que, em um laboratório de projetos de automação ou de

manutenção, muitos destes componentes podem até mesmo já existir tornando este
projeto muito mais barato.
É importante salientar que, nestes valores, podem haver alterações por
diversos fatores, valor do dólar, região, lojistas e etc.
6.2. Montagem do projeto

Agora que já se conhece os componentes, quantidades e até mesmo valores,

vai-se observar como montar o projeto.
Logo abaixo, tem-se o primeiro esquema da montagem dos componentes.
Veja que foi feita uma pequena legenda para indicar os fios positivo – vermelho,
terra – azul e de controle – preto.

Figura 31: Rascunho do esquema de montagem.

Vai-se ver agora com mais detalhes as conexões.

Primeiro, deve-se ver quais os pinos do microcontrolador devem ser usados.
Para isto, tem-se que olhar o Datasheet do microcontrolador, ou poder-se-á olhar a
figura 23 na qual há a pinagem do nosso Atmega328P.
Para isto, será usado um programa Free, que é bastante usado a montagem
dos projetos, usando Arduino (só lembrando a placa Blackboard é compatível com o
Arduino UNO, portanto pode-se a qualquer momento referenciar a placa como
ARDUINO ou como BLACKBOARD.), está sendo falado do software de montagem
de projetos para Arduino o Fritzing (http://fritzing.org/home/). Com este software,
pode-se montar o projeto. Nesta última versão, pode-se montar o projeto em uma
visão que simula as placas, a Protoboard e os componentes mais comuns para os
Arduino. Também é possível gerar o esquema elétrico da placa com os
componentes e também pode-se escrever o código; e, posteriormente, fazer o
Download para o microcontrolador.
 Figura 32: Tela do Fritzing.

Este software é bem simples de se usar, apenas arrastar e ligar os

componentes, que aparecem na barra lateral.

6.2.1. Conectando o Arduino na Protoboard

Para começar, é necessário ver quais os pinos de energia. Esta placa já vem
nos informando onde ficam os pinos relativos à energia, como é possível observar
na figura 33. Logo abaixo, é possível ver também os pinos 5V (5vcc – positivo) e um
dos pinos de TERRA (GND). Esta placa tem outros pinos a mais para tensão sendo
uma de 3,3V (não será usada). Será usada como referência a figura abaixo e para
os pinos será usada a figura 34

Figura 33: Blackboard - Arduino UNO R3

Agora é bem simples. Usando um fio chamado de Jumper, na cor vermelha,

liga-se uma ponta do fio na Protoboard onde tem a indicação com o sinal de positivo.
A outra ponta é ligada no pino de tensão do Arduino que, no caso, é o pino de 5V.
Esta é a tensão que vai alimentar a Protoboard e todos os componentes que vão
precisar de energia para funcionar. O outro jumper é de cor preto e este fica ligado
uma ponta na Protoboard (indicado pelo sinal negativo) e a outra ponta no pino GND
(Terra) (ver a figura 34).

Figura 34: Montagem 01 - ligando o positivo e o terra.

6.2.2. Conectando o Potenciômetro no Arduino

A inserção do segundo componente (ainda no Fritzing) é muito fácil: escolhe-

se na lista de componentes um potenciômetro, arrasta-se para a Protoboard e, com
o mouse, liga-se cada um dos pinos. A ligação é bem simples. De acordo com a
figura 35, com um fio vermelho, liga-se o terminal da esquerda na Protoboard (na
saída do positivo) e o terminal da direita (fio preto) é ligado na Protoboard também
(na saída do negativo) e o terminal do meio é o sinal de controle, este será ligado na
porta A0 (porta analógica) do Arduino.

Figura 35: Montagem 02 - ligando o potenciômetro.

Agora deve-se saber exatamente o que se quer montar. Se o objetivo for ler
os dados adquiridos pelo Arduino, então tem-se que ter sensores que fazem a leitura
de um meio (do ambiente natural) de forma analógica a cada ciclo que o
microcontrolador estiver sendo executado. Assim, o potenciômetro será um sensor
analógico, e como um sensor analógico é bem óbvio que a ligação do pino do meio
do potenciômetro deve ser feita em alguma porta analógica.

6.2.3. Conectando o Sensor de temperatura LM35 no Arduino

Este componente é um sensor de temperatura LM35, ou seja, ele é usado

para ler a temperatura do ambiente. Assim sendo, tem-se que escolher qualquer
uma das 6 portas analógicas e, como a porta A0 já foi usada com o potenciômetro,
será usada a porta A1, sem problemas.
Agora de acordo com o Datasheet do LM35, deve-se olhar o componente pelo
lado chanfrado onde tem a inscrição LM35. Então tem-se o pino a esquerda é o Vcc
(positivo), o pino do meio é o Vout (saída, controle), e o terceiro pino é o terra
(GND).

Figura 36: Pinagem do LM35. (Fonte: Datasheet)

Agora que se sabe quem são os pinos do LM35, pode-se fazer as ligações de
acordo com figura abaixo:

Figura 37: Montagem 03 – Ligando o LM35

6.2.4. Conectando o Led no Arduino

Agora é a vez do LED e tem-se que ligar um resistor também para fazer a
redução correta da tensão para o led.
Para calcular a resistência correta para o resistor de redução do led, vai-se
seguir a equação logo abaixo:

Onde:
Rst: Resistencia em Ohms do resistor
Valimentação: Tensão de alimentação do circuito
Vled: Tensão padrão de alimentação do led
Iled: Corrente do led em mA

Neste caso, o led que se vai usar é o vermelho que tem uma tensão padrão
entre 1,8 e 2,0V e a sua corrente de operação é 20mA. Sendo assim, fazendo as
devidas substituições, tem-se o resultado de 150 Ohms.

Vendo o resultado, basta termos

um resistor de 150R já é suficiente. Mas
para evitar qualquer tipo de problema,
vou usar um resistor de 330R que é bem
suficiente para o nosso projeto e não vai
haver perdas.

Veja as ligações: primeiro temos

Figura 38: Montagem 04 – Ligando o led.
que ver onde fica o pino negativo
(Catodo) e onde fica o pino positivo
(Anodo).
Muito fácil. Uma maneira de
descobrir é localizando o chanfro em um
dos lados do led. Este chanfro indica o
terminal negativo.
Assim, ligamos o terminal negativo ao
terra (fio azul na Protoboard). O terminal
positivo fica ligado a um furo (como
mostra a figura) na saída do terminal
positivo ligamos o nosso resistor de 330r
e na saída do resistor ligamos o fio de
controle, que será ligado no pino 11 do
Arduino.
6.2.5. Conectando o Servomotor no Arduino

A ligação do Servomotor é bem simples. Tem-se que olhar no datasheet do

fabricante a identificação de cada um dos pinos. Como, neste caso, está sendo
usado um servo modelo SG90, tem-se os seguintes fios: fio marrom é o GND
(Terra), o fio vermelho é o Vcc (alimentação de tensão, valores entre 4.8~5V) e o
ultimo fio é o laranja que é o sinal de PWM (este sinal será explicado mais adiante).
Seguindo a explicação do datasheet, conforme a imagem abaixo:

Figura 39: Identificação dos fios (Fonte: Datasheet)

Conforme o manual, são ligados os fios aos seus devidos pinos, tanto na
Protoboard como o Arduino, lembrando que fio marrom (negativo), fio vermelho
(positivo) e fio laranja são o sinal PWM na porta digital Nº 6.

Figura 40: Montagem 05 - ligação do Servo

Só uma pequena observação em relação à figura 40, que mostra as cores

diferentes: as cores dependem do fabricante, por isto sempre veja o Datasheet. Mas
isto não afeta em nada a ligação.
 Enfim, na próxima figura, pode-se ver como ficou a montagem final, com
todos os componentes.

Figura 41: Montagem completa

6.3. Software de Controle

6.3.1. Considerações iniciais

Este tópico tem como objetivo apresentar alguns conceitos sobre

comunicação de dados e apresentar os softwares usados para construir o projeto
modelo. Além disso, será mostrado como é feita a aquisição dos dados por meio do
MsExcel.
A informação é resultante da compilação dos dados vindos de um emissor.
Assim, é possível dizer que a informação é tudo o que é transmitido entre um
emissor e receptor.
Existem muitas formas de comunicação entre um dispositivo fornecedor de
sinais (emissor) e o ser humano que vai receber estes dados (receptor).
As formas mais comuns de transmissão de dados são, sem dúvida, a
ANALÓGICA e a DIGITAL.
O sinal analógico é um sinal natural como a voz humana. É um sinal onde a
mudança de estado ocorre em função do tempo, mas ela não tem estados finitos.
Ela é como uma onda que ora está por cima e ora está por baixo.
 Esta onda é conhecida como ciclo que se repete várias vezes dentro de um
determinado período de tempo, mas tecnicamente esta onda ou ciclo é conhecida
como SENOIDE.
Esta senoide é representada pela função do seno, que é mostrado logo
abaixo (não vou entrar nestes detalhes trigonométricos pois não faz parte deste
trabalho).

Já o gráfico do seno (que é feito a partir da função acima) demonstra com

perfeição os dois arcos lado a lado em sua fase positiva que vai de 0º passando 90°
e chegando a 180° e na sua fase negativa iniciando em 180° indo até 270° e, por
fim, finalizando um círculo em 360°

Figura 42: Representação de um sinal analógico.

Para as transmissões de sinal analógico, é possível alterar a forma na qual o

sinal é transmitido. Isto é feito para que seja possível enviar um dado do emissor e o
receptor entender o que está sendo enviado.
Isto só é feito por meio da modulação do sinal. Com isto, é possível alterar
todas as características de uma onda: a Amplitude (é a crista de uma onda),
período (é o tempo total para as repetições do ciclo), frequência (é a quantidade de
vezes que o ciclo se repete) e a fase (que é a posição da onda em relação ao marco
zero do tempo).
Alterando qualquer uma destas características, é possível enviar um sinal a
um receptor devidamente preparado pode ler este sinal. A isto é chamado de
PROTOCOLO DE COMUNICAÇÃO.
 Mas a transmissão analógica tem alguns problemas, tais como barreiras,
ruídos no sinal, etc. Para evitar estes problemas com a transmissão ANALÓGICA,
há uma alternativa: é possível usar a transmissão DIGITAL.
A transmissão digital teve muito sucesso com a chegada da microeletrônica e
foi aperfeiçoada e difundida. Todos os equipamentos eletrônicos existentes desde a
invenção dos primeiros circuitos usam um sistema digital, onde é decodificado
quando um sinal passa e outro não passa; ou seja, quando tem a passagem de sinal
elétrico no circuito e quando não tem a passagem do sinal elétrico no circuito.
Como um sinal DIGITAL tem um conjunto finito de estados, somente alguns
destes estados são usados para representar um dado.
Estes estados finitos válidos são chamados de NÍVEL ALTO e NÍVEL BAIXO.
Para entender melhor, recorre-se aqui a um exemplo. Em um circuito
qualquer, quando existe a passagem de 5 volts, temos um NÍVEL ALTO e quando
temos 0 volts há um NÍVEL BAIXO.

Figura 43: Representação de um sinal digital.

Quando um usuário clica no ícone do Excel para carregar o programa, o que

na verdade está ocorrendo é que o Sistema Operacional (S.O) envia uns comandos
para o escalonador de processos para acionar o programa chamado. Este, por sua
vez, solicita ao Kernnel do S.O que localize este programa na unidade de disco
(normalmente é o Disco rígido). Uma vez localizado, o programa é carregado em
memória como um processo (processo é um programa em execução na memória) e,
por fim, o programa é desenhado na tela para que o usuário possa trabalhar com
ele. Todas estas tarefas são, na verdade, solicitações de programas mais baixo nível
que consegue conversar diretamente com o disco rígido, isto é, cada uma destas
solicitações é na verdade conjuntos de bits que o processador recebe, processa e
entrega o resultado (no caso o programa aberto para o usuário). Olhando um pouco
mais a fundo, existem muitos sinais sendo transmitidos da memória para o
processador e vice-versa. Estes sinais são os níveis (alto e baixo) que têm a
passagem de tensão (5 v) ou a ausência de tensão (0 v). Isto é contabilizado como
um conjunto de bits, que o processador interpreta como um conjunto de comandos e
que, por sua vez, o S.O interpreta como um programa, que no fim deste árduo
processo exibe ao usuário o programa que ele solicitou.
Só para ficar bem claro é assim: um bit que é o acrômio de BInary digiT
(digito binário), que é a menor unidade de informação que o computador consegue
entender ou somente os estados LIGADO ou DESLIGADO, ou seja, os níveis alto e
baixo.
Para entender melhor, observa-se a figura 43, que mostra um sinal digital.
Este sinal está enviando um conjunto de 8 bits (portanto, é um Byte ou pode chamar
de CARACTERE) que neste caso é a letra “M” em maiúsculo. A letra M é identificada
na posição 77 (número decimal) da tabela ASCII.
Assim, o emissor envia um conjunto de Zeros e Huns de acordo com o
protocolo usado e o receptor conhecendo o mesmo protocolo ler os bits e faz a
decodificação do valor, achando o valor 77. Agora ele olha na tabela ASCII e vê que
temos a letra M na posição 77. Enfim, esta é a transmissão de dados entre um
emissor e um receptor.

6.3.1.1. O que é um sinal PWM

Na eletrônica, ouve-se muito falar em sinal PWM (Pulse Width Modulation –

Modulacao por largura de pulso). O termo significa “modulação por largura de pulso”
e é o equivalente digital a uma voltagem analógica que é encontrada em um
potenciômetro.
O sinal PWM é um sinal de frequência fixa onde é variado o ciclo ativo
(também conhecido como Duty Cycle, que é a razão entre o período total e o
período de pico da onda) da onda. É muito usado no controle de potência como
fontes chaveadas, controle de velocidades e acionamento de Servomotor.
 Figura 44: Diagrama do sinal PWM.

O Arduino possui seis saídas (PWM) nos pinos digitais 3, 5, 6, 9, 10 e 11. O

Arduino pode facilmente mudar o ciclo de trabalho ou a saída a qualquer momento
no Sketch, usando o comando analogWrite (). Para usar o comando analogWrite
(PWM_pin, speed), deve-se ligar o seu dispositivo em um pino PWM (pinos 3, 5, 6,
9, 10, 11). O ciclo de trabalho PWM varia de 0 a 255.

Figura 45: Variação do sinal PWM.

(Font: https://www.arduino.cc/en/Tutorial/PWM,2017)

6.3.1.2. Modos de comunicação

A comunicação tem por objetivo transmitir dados, dados estes que são
transmitidos na forma de bits, é possível transmitir um bit por vez. Isto é uma
comunicação em serie ou SERIAL. Também pode-se transmitir todos os bits de uma
única vez e assim pode-se transmitir mais bits por vez. Consequentemente, ter-se-á
uma transmissão em PARALELO.
Quanto aos modos de transmissão, há um que é muito conhecido e durante
bastante tempo foi muito usado, desde as primeiras impressoras comerciais
(matriciais) até chegar as novíssimas impressoras de jato de tinta. Todas as
impressoras usavam uma porta PARALELA.
 Outra porta muito conhecida é a porta SERIAL, onde os bits são enviados em
pacotes. Cada pacote tem um conjunto de 10 bits, onde existe um 1 bit de start
(início) e na outra ponta existe um bit de stop (parada) e no meio segue os 8 bits do
dado a ser transmitido. Uma das suas principais características é o seu baixo custo
de fabricação, pois precisa de, no mínimo, uma linha para a transmissão do dado.

6.3.1.3. Protocolos de comunicação

A sua transmissão (em Serial ou em Paralelo) pode ocorrer pelo menos de

duas formas: ASSÍNCRONAS e SÍNCRONAS. Quando se fala de transmissão de
dados, sempre falar-se-á dos famosos TX/RX. Este é o termo usado para
representar a transmissão (TX) e a recepção dos dados (RX), e a sua ligação
sempre é feita de acordo com os seus opositores; ou seja, quando for ligar um
dispositivo de comunicação serial, sempre será ligado do TX do primeiro para ao RX
do segundo e o RX do primeiro ligado ao TX do segundo e não se pode esquecer do
terra (GND), muito importante, a figura 46 mostra isto muito claramente.
Mais uma vez falando sobre os protocolos de comunicação, tem-se alguns
que são os mais conhecidos:

a) UART - Universal Asynchronus Receiver / Transmitter: Receptor /

Transmissor Assíncrono Universal: É muito usado para transmissões a
longa distância, porém tem uma taxa de transmissão muito baixa em
função da sincronização ser feita por software.

b) USRT – Universal Synchronus Receiver / Transmitter: Receptor /

Transmissor Síncrono Universal: É muito usado em sistemas de sincronia
por hardware e transmissões muito pequenas.

c) USART – Universal Synchronus / Asynchronus Receiver / Transmitter:

Receptor / Transmissor Síncrono / Assíncrono Universal: É muito usando,
pois tem uma versatilidade no modo de operação podendo ser síncrono ou
assíncrono.
 Figura 46: Esquema de ligação RX/TX.

Para o projeto-modelo, usar-se-á uma conexão serial e quem vai controlar isto
é o circuito da UART do microcontrolador Atmeg328P.
O protocolo UART é uma forma de transmissão ASSÍNCRONA; ou seja, não
existe sincronia com o que está sendo enviado, pois a cada pacote enviado existe
uma forma de identificação deste pacote. Cada pacote tem sempre um bit de início e
um bit de parada para fechar o pacote. Como não existe sincronia, a sua construção
é bem mais barata pois só precisa de apenas um único fio para o envio dos bits, o
controle é feito por software. Outro fator que é muito importante é a taxa de
transmissão que é conhecida como Baud Rate. Este parâmetro tem que ser
especificado tanto do lado do emissor quanto do lado do receptor.
Como o Atmega328 tem apenas uma unidade de UART, ela tem 2 fios, um
para o TX (transmissor) e o outro para o RX(receptor). Além disso, como a
comunicação é do tipo ponto-a-ponto, a transmissão é feita ao mesmo tempo que
existe a recepção; é o FULL-DUPLEX.

6.3.2. Como se comunicar

6.3.2.1. Drivers de terceiros

Neste momento, já se conhece o que se quer fazer e são conhecidos os

conceitos de transmissão de dados. Já se sabe que o circuito controlador das
transmissões é o UART que está embutido no Arduino (ATmega328P). Agora falta
saber qual o driver vai ser usado para ler o Arduino e transmiti-lo ao PC.
 No mercado, existem inúmeros softwares SCADA e programas de
comunicação serial e muitas DLL´s que fazem este trabalho de ler os dados do
Arduino e enviá-los ao computador.
Uma destas bibliotecas de comunicação mais usada é fornecida pela
empresa americana Paralax. O nome do software é o PLX-DAQ, que é uma
ferramenta escrita em VBA para MsExcel.
O PLX-DAQ tem uma interface bem simples e prática de ser usada. No
entanto, ele só lê os dados do Arduino e os envia para o MsExcel. Com os dados em
mãos, pode-se tratar estes dados, armazenar e fazer o que precisar com eles.
Porém, ele só lê os dados. Se este for o seu objetivo, esta ferramenta vai lhe
atender muito bem.
Encontrou-se também um código escrito em VB (Visual Basic) usando as API
(Application Programming Interface – Interface de Programação de Aplicação) das
bibliotecas de uso comum do sistema operacional Windows. Um pequeno fragmento
pode ser visto na figura logo abaixo.

Figura 47: Fragmento do código para controlar a porta serial.

(Fonte: https://strokescribe.com/en/serial-port-vb-winapi.html,2017)

Esta era sim a melhor solução, pois com este código é possível receber os
dados e enviá-los usando a porta serial. Neste sentido, com algumas modificações,
o código fica completamente usual, porém teria que rever todo o código e poderia ter
alguma incompatibilidade com as versões do Windows (nada preocupante, e até
fácil de se resolver). Entretanto, no fim, acabou não sendo usada esta solução (mas
poderia sim).
6.3.2.2. Comunicação nativa

Ainda pesquisando um pouco mais, não achando nada interessante, foi

lembrado que, nos anos 90, a comunicação entre os periféricos e os PCs eram feitos
por meio da porta serial, compartilhamento em rede ou mesmo só a instalação. Tudo
era feito usando arquivos de configuração, os chamados arquivos “*.INI” que são
usados até hoje para facilitar algum tipo de configuração.
Enfim, foi lembrado que se usava arquivos de programação em lote que são
conhecidos como arquivos “*.BAT”, os BATs. Eram a melhor forma para se
configurar algum periférico. Diante disso, viu-se que havia instruções do MSDOS
que permitiam configurar as portas. Fala-se aqui do comando chamado de MODE.
Este é chamado de comando, mas na verdade é um programa mas compilado com
a extensão “*.COM” de comando.
Agora, sabendo que poderia configurar a porta serial com os parâmetros
necessários, faltava somente saber como ele funcionava, e agora ficou fácil: era só
entrar no Shell do Windows que atualmente é chamado de CMD.EXE, carregou-se o
CMD e chamou-se o comando. Quando se quer saber como o comando ou
programa funciona, basta ir até o prompt de comando, digitar o nome do comando
seguido da barra de parâmetro ( / ) e o símbolo de interrogação (?) e teclar ENTER.
O shell vai mostrar os parâmetros disponíveis para se usar com este comando ou
programa.
 Figura 48: Tela do Shell cmd.

Sabendo que a porta pode ser configurada via MsDOS (emulado), agora falta
saber quais são os valores para cada um destes parâmetros. Depois de muitos
testes, chegou-se aos seguintes valores e quais os parâmetros devem-se usados:

Figura 49: Parâmetros de configuração da função Mode.

Agora tem-se outra questão a ser resolvida. Como será chamado este
comando do MsDOS usando o VBA, muito fácil, para todos os que trabalham
automatizando tarefas no MsExcel ou MsAccess usando o VBA, eles sabem que
tem como chamar um objeto externo ao ambiente de trabalho (no caso o MsExcel).
Para isto, vai ser usada uma instrução muito conhecida dos programadores
em VBA: a instrução Shell. Veja como é a sintaxe e seus parâmetros conforme o
documento de ajuda do próprio Excel.
 Continuando. Já se sabe como configurar a porta serial usando o comando do
MsDOS. Já se sabe como fazer a chamada a partir do MsExcel. Agora, mostrar-se-á
um teste em VBA para chamar a calculadora do Windows.

Figura 50: Tela da IDE e a Calculadora.

A figura 50 é apenas um teste para demonstrar que é possível chamar outros

aplicativos pelo VBA usando os comandos do bom e velho MsDOS.

Sub chamaCalc()
retorno=Shell("C:\Windows\System32\calc.exe",vbNormalFocus)
End Sub

Veja a transcrição do código que foi usado para chamar a calculadora. Tem
uma variável chamada retorno que recebe o resultado da chamada feita pela
instrução Shell. Assim são feitos os envios dos comandos para o Arduino e
recebidos os dados por ele lidos.

6.3.3. Comunicação usando o VBA e o MsDOS

Para que se possa realmente fazer esta comunicação, é necessário

configurar a porta serial. Assim tem-se os seguintes valores:
A. Porta de comunicação: deve-se observar qual foi a porta criada no
momento da instalação da IDE de programação do Arduino. No
computador usado, a porta criada foi a COM3.
 B. Taxa de transmissão: uma taxa muito baixa pode não ser muito legal.
A melhor taxa (resultado obtido em testes) é de 9600 Bouds, que deve
ser configurado no código que vai ficar dentro do Arduino e no código
aplicação principal (que, no caso, é feita no Excel).

Para uma melhor compreensão, veja um fragmento da função fncAbrirPorta()

criada para configurar os parâmetros da porta serial e abrir o arquivo em memória
que será usado para enviar os comandos para o Arduino e recebe as respostas do
Arduino, conforme a figura logo abaixo:

Figura 51: Fragmento da função abrir porta.

Para poder entender um pouco melhor este código, foi transcrito logo abaixo
um trecho deste código. Veja que há a variável retorno, que recebe o retorno da
instrução Shell que configura os parâmetros da porta serial. Logo depois, tem-se que
dar uma pausa na execução da rotina para dar tempo dar porta ser configurada e
ser possível trabalhar com ela. Deu-se uma pausa de 2 segundos e, por fim, tem-se
a instrução Open que lê a porta sCom$ e abre uma comunicação de leitura e escrita
na memória que recebe o número 1. Este é o nome desta porta aberta.
'retorno da função Shell, onde o retorno é um valor numérico
retorno = Shell("mode.com " + sCom$ + " baud=" + sBaud$ + _
" parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")

'tem um atraso na aplicação de 2 segundos

Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)

'abrir um arquivo de E/S para ler e escrever em um arquivo externo

'este arquivo primeiramente fica em memoria e só depois vai para a porta serial
'determinada, todo o arquivo recebe um nome que na verdade é um número.
Open sCom$ For Binary Access Read Write As #1
 Depois que a porta foi configurada e aberta, é só começar a receber os dados
vindos pela porta serial. Ver-se-á alguns aspectos do botão iniciar, que vai ter a
função de iniciar a captura dos dados vindos pela porta serial. Será comentado
somente os principais pontos desta rotina. Ela vai estar completa no final deste
trabalho. Como esta é uma aplicação escrita em VBA, devem-se ser usadas as
sintaxes correspondentes. Assim, para as ações de tela (mais adiante será descrita
a arquitetura da aplicação), vou usar SUBs (são as sub-rotinas) e para as rotinas
que devem fazer alguma coisa e dar um retorno se foi ou não executada. Vão ser
usadas as FUNCTIONs.

6.3.3.1. Ler os dados do Arduino com VBA

Assim, na tela principal, tem um botão que inicia o processo de leitura da

porta serial. Em um primeiro momento, tem que ser declaradas as variáveis
necessárias para trabalhar com as folhas (é conhecida como ABA do Excel, mas
pertencem ao objeto Sheet) do Excel. Veja que se seta o objeto WS para poder ser
mais fácil a manipulação da folha (Aba do Excel ou planilha).

Figura 52: Fragmento da rotina do botão ON (btnIniciar).

Ver-se-á, logo abaixo, um trecho da rotina do botão btnIniciar(). Vai-se

detalhar algumas partes importantes deste código.
'se a função abrir porta retornar VERDADEIRO a rotina
'de leitura do arduino pode iniciar
If fncAbrirPorta = True Then

'controla a exibição do led na interface de tela

Call fncExibeOcultaObjeto("led_off", 2)
Call fncExibeOcultaObjeto("led_on", 1)

'espera 2 segundos
Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2)

'pega a string a ser enviada

MyString$ = ""
MyString$ = "i"
 'envia o caractere pela porta aberta, usa o comando Put e informa qual
'a cadeia de caracteres que será enviada
Put #1, , MyString$
Trecho retirado da rotina btnIniciar()

No trecho do código, retirado da rotina do botão que inicia a aplicação, que no

caso é chamada de btnIniciar(), é possível ver algumas coisas que já se conhece.
Observe.
Logo no início, há uma condicional que vem do retorno da função
fncAbrirPorta() (já foi comentado anteriormente). O retorno desta função é um
retorno booleano, ou seja, só retorna VERDADEIRO ou FALSO. Isto é o que a
instrução IF quer saber: se a fncAbrirPorta() retornou VERDADEIRO, significa que a
porta foi configurada corretamente e está aberta para transmissões e recepções.
Se o retorno for VERDADEIRO (True em inglês), tudo certo. Agora, poder-se-
á enviar algum comando para o Arduino. Tem-se, logo no início, duas chamadas
com a instrução CALL, mas estas instruções não são importantes neste momento.
Por isto, não serão comentadas. Tem-se mais um delay na rotina de 2 segundos e
agora tem-se a variável MyString$ que vai ser usada para a comunicação. Esta
variável vai receber a letra “i” (letra i em minúsculo) de “informação” e, por fim, tem-
se a instrução que escreve na porta serial. É a instrução Put.
Veja que ela “envia” para a porta número 1 o valor que está dentro da variável
MyString$. Esta instrução, na verdade, escreve no arquivo que tem o nome de
número 1 (estes dados são gravados na memória e depois é que são enviados em
definitivo para a sua saída, que no caso é a porta serial, mas poderia ser um arquivo
TXT ou outro tipo de saída) e assim o comando “i” é enviado para o Arduino usando
a porta serial.

'Enquanto a célula A1 estiver vazia a pesquisa continua em loop

While ws.Range("A1") = ""

'DoEvents - entrega o controla do processo desta aplicação para o

'sistema operacional e depois o devolve ao aplicativo chamador.

DoEvents
MyString$ = "" 'limpa a string
Trecho retirado da rotina btnIniciar()

Continuando os comentários do código, observa-se agora uma estrutura de

laço. Esta estrutura, que no caso é o “Enquanto” (While...Wend), trabalha da
seguinte forma. Esta instrução vai verificar se a célula A1 está vazia. Enquanto a
célula A1 é igual a vazio, a instrução entre no looping. Dentro do looping é chamada
uma instrução que entrega o controle para o sistema operacional é o DoEvents.
Depois, a variável de envio e leitura é limpa. É a MyString$.

DoEvents
MyString$ = "" 'limpa a string
Do
DoEvents
char$ = Input(1, #1) 'Pega o caractere da interface
Debug.Print ": " & char$
If (char > Chr(31)) Then 'se o caractere é imprimível
MyString$ = MyString$ + char$ 'adiciona o caractere a minha string
End If

Loop Until (char$ = Chr(44)) 'looping até o caractere ser uma virgula

Trecho retirado da rotina btnIniciar()

Este trecho do código começa a ficar mais complicado, mas é aqui que está a
mágica deste código. É assim. Há uma instrução de looping chamada Do(Faça).
Dentro deste laço, tem-se uma variável chamada char$. Esta variável vai receber o
retorno da instrução Input() (nesta instrução só tem que informar quantos caracteres
serão retornados e qual o nome do arquivo, ficando assim Input(1, #1)). Esta
instrução é responsável por ficar lendo os valores da porta serial. Tudo o que for lido
por ela vai ser gravado na variável char$. A próxima instrução (vou pular a
instrução Debug) é uma condicional que vai checar se o caractere recebido é um
caractere válido, ou seja, imprimível (isto porque os valores imprimíveis começam a
partir do decimal 31 na tabela ASCII). Os valores que estamos querendo são
caracteres numéricos e estes iniciam a partir do decimal 47 (é o zero). Uma vez
encontrado os valores, estes são gravados na variável MyString$ e este laço vai
continuar até que uma virgula (nº 44 em ASCII), seja recebida por este laço. Neste
momento, o laço termina. Segue-se para o próximo bloco de instruções.
Para ser bem claro, estas rotinas têm que ler uma cadeia de caracteres da
forma “765,56”, onde estes são os valores analógicos vindos do Arduino. Portanto,
tem-se que localizar a vírgula para saber que a primeira cadeia de caracteres foi
encontrada e agora vai para a segunda cadeia de caracteres que compreende os
valores após a vírgula.
 Continuando este código, os valores recebidos antes da virgula é o valor do
primeiro sensor (que neste caso é o potenciômetro) e este será gravado na célula
B6 e E7 que são as bases para gerar os gráficos referentes a estes valores.
O próximo bloco de comandos é idêntico ao comentado anteriormente, a
única diferença é que no final do laço não será mais procurada a vírgula (44 na
tabela ASCII). Agora, vai-se procurar o fim do retorno que é um simples ENTER (13
na tabela ASCII), assim a estrutura de laço é a mesma e só a condição no final é
que muda. Assim, vai ter recebido a informação completa. Não se pode esquecer de
gravar estes últimos valores (agora do sensor de temperatura), vai para C6 e F7 que
são as bases para gerar os gráficos da temperatura.
Falando neste bloco de comandos que vai receber os valores do segundo
sensor, tem-se que transformar estes valores em um valor de temperatura legível.
Para isto, foi criada uma função para ler os valores vindos do Arduino e convertê-los
em valor de temperatura em graus célsius.

'***************cálculo da temperatura **********************************

'valor double recebido direto pela porta serial

valor = CDbl(MyString$)
'a temperatura vem calculada a partir da funcao fncTemperatura
temp = fncTemperatura(valor)
'armazena na planilha
ws.Cells(5, 8).Value2 = temp & "ºC"

'*************************************************************************
Trecho retirado da rotina btnIniciar()

Ainda nesta rotina, é interessante ler o valor do LM35 e calcular o valor da

temperatura lida. Para isto, foi criada uma função. Trata-se de uma variável
chamada VALOR que vai receber o valor obtido na variável MyString$ e este
valor será convertido para um valor Double (tipo de dados numérico que representa
números de 64 bits com mais de 12 casas decimais de precisão), este resultado
será armazenado na variável VALOR e será usado na função fncTemperatura()
como parâmetro de entrada. O retorno da função vai ser armazenado na variável
TEMP. Depois o mesmo valor será guardado na célula H5 da planilha. Finalizando
este passo, armazena-se os valores que vão alimentar os gráficos de temperatura (o
gráfico de dispersão e um gráfico de coluna) e alimentar o display analógico de
temperatura.
 Uma coisa muito legal é receber os dados (os caracteres numéricos) de forma
bruta, ou seja, não é preciso preocupar-se em tratar estes dados. Assim fica bem
fácil trata-los da forma que parecer melhor; sem falar que senão se conhecer muito
da linguagem C/C++ para criar as rotinas para o Arduino, não terá problemas, faça
somente o básico e o resto fica por conta do VBA (que provavelmente você domina
mais que o C/C++).
Assim, vai-se comentar um pouco sobre a função de temperatura. Mas, para
se entender como ela funciona, serão dados alguns conceitos importantes.
A grandeza a ser medida é a temperatura, e para que este projeto seja
simples o suficiente optou-se por um sensor de temperatura de baixo custo, mas
com uma ótima qualidade. Por isto, optou-se por usar o LM35 (ver item 6.1.3-
Descrição dos componentes) e agora é só ler este sinal (analógico).
O sensor LM35 está ligado na porta A1 (vide a figura 37), que é uma porta de
entrada analógica, ou seja, é por esta porta que o sinal analógico entra e o Arduino
pode enviar, mas ainda poder-se-á receber estes dados já convertidos. Todos os
pinos de entrada analógica já têm habilitados o ADC (Analogic Digital Conversor ) e
este é o ponto. É sabido que o ADC do Atmega328 tem uma resolução de 10 bits
(210 = 1024 valores). A tensão de referência dos pinos é 5v (VREF) e, sabendo disto
agora, sabe-se que a saída resultante da leitura de uma porta analógica no Arduino
fica entre 0 e 1023.
Veja como ocorre. Se a entrada analógica for 0v (VIN), o resultado do valor
ADC será 0 (zero). Agora, se o valor de entrada for 5v (VIN), o resultado será 1023.
E, se o valor for 2,5v (VIN), o resultado é 512. É assim que o Arduino trabalha com as
portas analógicas.

Onde:
ADC: Leitura do Conversor Analógico Digital
VIN: Tensão de entrada em Volts
210: Resolução máxima do ADC = 1024
VREF: Tensão de referencia = 5 Volts

Agora que é sabido como o Arduino envia os dados, é preciso calcular o valor
da temperatura. Então, pega-se o valor lido pelo ADC (ValorADC). Aqui será chamado
simplesmente de VALOR e será multiplicada pela razão do VREF (5v) por 1023.
 Onde:
temp: Temperatura em graus Celsius
ValorADC: Valor da leitura analógica
VREF: Tensão de referencia = 5 Volts
1023: Limite das leituras

Conforme a fórmula acima, o valor da tensão nominal é dividido por 1023

porque as leituras do Arduino vão de 0 a 1023 e não de 1 a 1024.
Com esta fórmula, é possível transformar o valor recebido em um valor de
temperatura aceitável. Assim, foi criada a função fncTemperatura(), onde ela recebe
com valor de entrada o valor ADC lido anteriormente.

Figura 53: Funcao temperatura (btnIniciar).

Para fechar a rotina do botão iniciar (botão ON), temos que fechar a
comunicação quando o botão parar (botão OFF) for acionado. Veja que sempre no
fim do laço While é verificado se a célula A1 está vazia. Pois bem, quando o botão
Parar for acionado, ele insere um valor nesta célula. Assim, quando for o próximo
looping, será verificado se esta célula está vazia ou não e no caso não vai estar.
Assim, sai do laço (instrução Wend) e limpa as variáveis de transporte, e
envia a última instrução para o Arduino, quando ele ler “f + ENTER” ele vai saber
que não deve mandar mais nenhuma informação para a porta serial. Depois, o
arquivo de comunicação com a porta serial é fechado também por meio da instrução
“Close #1” e a rotina é encerrada (o código completo vai está disponível no final
deste trabalho).
 Figura 54: Fragmento da rotina do botão ON (btnIniciar), fim da rotina.

Esta rotina parece um pouco extensa, mas na verdade não é (parece extensa
porque foi comentado as principais partes). Ver-se-á um pouco do que realmente é o
diferencial do Excel sobre as outras formas de comunicação. É possível enviar
comandos para o Arduino executar.

6.3.3.2. Acionando um atuador com VBA

Esta é a parte mais legal. Comentar-se-á, por exemplo, como é feito para
mover um servo (vide tópico ver item 6.1.3-Descrição dos componentes). A mesma
lógica se aplica quando for acionar um led ou qualquer outro tipo de atuador, a
diferença vai estar no programa que fica rodando no Arduino e isto ainda será visto
neste trabalho. Ver-se-á um pouco da rotina que move o Servomotor.

Function fncMoverServo(ByVal valor As Integer)

Dim ws As Worksheet
Set ws = ActiveWorkbook.Sheets(painel) 'Seta WS como a planilha ativa

'verifica se o retorno da funcao fncAbrirPorta é True (verdadeiro)

If fncAbrirPorta = True Then
MyString$ = "" 'Limpa a variável
MyString$ = "s" 'Variável recebe o comando S de servo
MyString$ = MyString$ & valor 'Variável recebe s + o valor do usuário
MyString$ = MyString$ + Chr(13) 'Variavel recebe s+valor e junto ao ENTER
'Envia os comandos por meio da instrucao Put
Put #1, , MyString$
'Fecha o arquivo de E/S
Close #1
Else
fncMensagem "Ocorreu um problema na recepção dos dados.", 2
End If

End Function
Funcao para mover o Servomotor
 Veja que esta função que foi criada é bem parecida com a estrutura anterior
do btnIniciar(). Sempre se define o objeto da planilha ativa e sempre início a função
fncAbrirPorta() (que já foi descrita) e testo o seu retorno (True/False). Se caso True
(Verdadeiro), enviar-se-á um comando ao Arduino para que ele movimente o
Servomotor. Em princípio, é só isto que esta função faz. A sintaxe de envio fica
assim: a variável que recebe os comandos na seguinte forma, letra do comando
(neste caso a letra s) concatenado (neste caso uso o sinal de +) com o valor (este
valor é a conversão do ângulo para um valor analógico que o servo entende)
concatenado com o ENTER (“CR” é Carriage Return – Retorno do Carro é o ENTER
que é usado na computação, decimal 13 na tabela ASCII). Veja a figura abaixo:

Figura 55: Sintaxe do comando de envio.

Continuando, depois da cadeia de string montada conforme a figura 55, envia-

se o comando pela porta serial. Isto é feito usando a instrução Put, que segue o
número do arquivo aberto #1 e o comando a ser enviado. Depois do envio, a porta
deve ser fechada para que não ocorra problemas. Para isto, uso a instrução Close
#1.
Para se usar a função fncMoverServo(), tem que saber como converter um
ângulo digitado pelo usuário para um valor analógico igual ao valor lido pelo ADC do
Arduino.
A fórmula para converter os graus digitados pelo usuário recebe o valor dos
graus e multiplica pelo FTC. Esta é uma constante que foi criada justamente para
fazer estas conversões. Durante a fase de testes da aplicação, existe a necessidade
de girar o servo em algum grau especifico (exemplo 25,86 graus) e, durante os
testes, é encontrado este Fator de Conversão (FTC) que representa valor inteiro de
quantidade 1300. Assim, os graus são multiplicados por FTC e, no fim, este
resultado vai ser dividido por 180º que é o limite de giro do servo.
 Onde:
graus: Variável inserida pelo usuário
FTC: Fator de Conversão = 1300
180º: Limite de giro máx.

Logo abaixo, tem-se a transcrição do código completo da função

fncConvGrauToValor(), que tem o objetivo de converter o valor do ângulo digitado
pelo usuário em um valor analógico que o servo vai ler.

Function fncConvGrauToValor(ByVal grau As Double) As Double

'O valor em grau recebido é multiplicado pelo FTC e dividido
'por 180 que é o giro em grau max do servo
'FTC = Fator de Conversao = 1300
Dim x As Double
Dim FTC As Long

FTC = 1300
x = (grau * FTC) / 180

fncConvGrauToValor = Int(x)
End Function
Funcao para converter ângulo em valor analógico.

Agora é possível ver que é muito fácil ler as entradas analógicas do Arduino e
acionar Leds, Servomotor, coolers e quaisquer outros dispositivos que possam se
comunicar com a porta serial.

6.3.4. Programando o Arduino

6.3.4.1. Arquitetura do projeto

Para que o projeto modelo funcione, deve-se criar o software que vai
embarcado no microcontrolador (no Arduino). Este é, sem dúvida, um ponto
importante no projeto, pois depende muito do Arduino para que o projeto funcione;
ou seja, ler os dados dos sensores e controlar os atuadores é a principal função do
projeto.
Observe de forma macro como é a arquitetura do projeto. Veja a figura 56.
Nela, é possível ver os seguintes componentes: o dispositivo com o software
embarcado é o Arduino (Placa Blackboard com o Atmega328p), que é o principal
hardware; ligados a ele há um SENSOR (neste caso é o sensor de temperatura
LM35) e um ATUADOR (neste caso é um Servomotor), este dispositivo está
conectado a um computador por meio de uma porta serial (neste caso a porta serial
é somente o protocolo de uso, pois na realidade a porta física é uma porta USB) e
neste computador há o SOFTWARE do supervisório escrito em VBA e usando o
MsExcel como plataforma de desenvolvimento.

Figura 56: Diagrama da arquitetura da aplicação.

Assim, vê-se que este projeto (bem simples) é, na verdade, a montagem

simplificada de qualquer projeto de sistema supervisório. Todos vão funcionar com
as mesmas características. Todos vão ter os sensores, os atuadores e um software
para receber e controlar tudo. Em suma, isto é o que o projeto-modelo faz.
Agora, ver-se-á um pouco do SOFTWARE que vai embarcado no Arduino.
Quando se fala em software EMBARCADO, quer dizer que em um
determinado dispositivo tem um software de controle “embutido” dentro dele. Um
exemplo muito comum hoje em dia são alguns modelos de carros que têm o
chamado “computador de bordo” e que nada mais é que um sistema de controle
EMBARCADO em um microcontrolador que é instalado no carro. Normalmente, ele
tem um display para exibir as informações de controle que, na maioria das vezes,
são informações ligadas ao próprio veículo, como consumo do combustível,
autonomia, pressão do óleo e muito mais.
Mas como isto funciona? É até bem simples (de um ponto de vista macro).
Caso se queira controlar um braço robótico, sabe-se que este braço vai se mover
usando servo motor ou motor de passo, ou seja, tem-se que controlar as posições
do braço que, na verdade, são os movimentos dos motores. Assim, tem-se que
mover os motores para as posições que se quer. Estas posições podem ser
espaciais, ou seja, de ângulos livres onde o operador usa um joystick para controlar
os movimentos do braço, ou estas posições podem ser predefinidas dentro do
software que vai fazer este controle. Este software vai receber os comandos (sinais
elétricos) do joystick e vai comandar o movimento do motor. Enfim, este software,
que recebe os sinais externos e os transforma em algum resultado (seja ligar ou
desligar alguma coisa), fica gravado dentro do microcontrolador e, assim, ele
consegue controlar tudo o que lhe foi programado. Enfim, este software é chamado
de sistema EMBARCADO, e é assim porque ele está dentro do microcontrolador.

6.3.4.2. O que é um Firmware

Quando se desenvolve uma aplicação para automação (seja industrial,

caseira etc.), de fato, é desenvolvido um HARDWARE que é a parte física da sua
solução de automação. Neste HARDWARE, há os dispositivos que fazem parte da
solução. Assim, existem os sensores, os controladores, os atuadores e a MCU que
vai controlar toda esta parte, e também é desenvolvido o software, mas na verdade
são feitos 2 (dois) SOFTWARES. Um é o software que controla o HARDWARE
diretamente, este é o que se chama de software EMBARCADO ou de FIRMWARE, é
a inteligência que vai controlar todos os dispositivos ligados a MCU. O outro
SOFTWARE é uma aplicação de alto nível, ou seja, é uma aplicação feita para um
usuário (mais experiente ou não) ter mais controle sobre a sua parte física,
lembrando que este SOFTWARE do usuário pode (ou não) precisar ser construído,
às vezes somente o FIRMWARE ou SOFTWARE EMBARCADO é todo o software
que a sua solução necessita.

6.3.4.3. Qual é a melhor IDE para programar

Conceitos explicados e entendidos, seguir-se-á ao que interessa: como o

projeto usa um Arduino (já explicado anteriormente neste trabalho), concentrar-se-á
apenas nele. O Arduino é programado diretamente em uma linguagem de alto nível
chamada de linguagem C/C++. No entanto, para que se possa compreender a
grande facilidade de se usar a IDE do Arduino, é preciso entender como funciona
nos bastidores.
Antes de mais nada, deve-se conhecer alguns conceitos sobre a
programação do Arduino.
O Arduino é um Framework que tem uma IDE que facilita o trabalho de
programação. Esta IDE do Arduino é na verdade um fork (na computação é quando
um desenvolvedor ou um grupo de desenvolvedores criam um software inteiro, mas
tomando como base um software já existente) da IDE wiring (ver figura 58). Esta
aplicação foi toda escrita em Processing (figura 57). Voltando ao wiring, neste fork,
ele foi totalmente escrito em C/C++ e foi feito várias adaptações, entre elas foi criado
várias bibliotecas para suportar a sua linguagem padrão que é um mix entre o C
puro e o C++. É isto mesmo: a linguagem do Arduino usa sintaxes variadas como,
por exemplo, as chamadas das principais funções (ler do pino digital (DigitalRead),
ler do pino analógico (AnalogRead) e etc.) foram todos escritas em C, mas outras
funções importantes como a comunicação serial, acesso a registradores, leitura e
escrita diretamente na memória (EEProm) entre outras foram escritas em C++.

Figura 57: Tela da IDE Processing. Figura 58: Tela da IDE Wiring.
A linguagem Processing foi criada em 2001
Criado em 2003 por Hernando Barragán (já
por Ben Fry e Casey Reas enquanto ambos
citado anteriormente como o idealizador do
eram estudantes no MediaLab do MIT, esta
“arduino”)
linguagem foi baseada em Java
http://hackaday.com/2016/03/04/wiring-was-arduino-before-arduino/
 Assim, um usuário avançado em C/C++ fica um pouco perdido no começo,
mas depois de algumas horas estudando ele já consegue dominar bem a linguagem.
Só um detalhe: a sintaxe de escrita em wiring tem algumas diferenças da linguagem
Processing (ela é bem mais parecida com o Java, pois é baseada em Java).
Para algumas pessoas que não têm nenhum conhecimento em programação
de computadores, a curva de aprendizagem é muito baixa, ou seja, um novato sem
conhecimento em eletrônica e nada de programação, em algumas horas, aprende a
fazer o “Hello World” do Arduino (exemplo chamado blink) e com mais alguns dias
ele vai estar desenvolvendo projetos muito interessantes.
A linguagem em si é bem fácil, pois não requer muitos conhecimentos
prévios. Porém, algumas aulas de lógica de programação e os fundamentos básicos
de eletrônica analógica vão tornar este usuário muito mais apto a desenvolver os
projetos para Arduino.
A interface para programação usando a IDE do Arduino é bem simples, porém
ela é suficiente para a atividade de programação. Para um usuário iniciante, esta
IDE é mais que suficiente, mas esta IDE não traz recursos importantes para o
usuário com experiência em programação.

Figura 59: IDE do Arduino - versão 1.8.3

Entretanto, alguns programadores mais experientes sentem falta de alguns

recursos que ajudam bastante na programação. Entre eles, há os recursos de
autocompletar, debug, identificação dos objetos e variáveis declaradas e muitos
outros recursos.
Para este projeto, a IDE do Arduino é perfeitamente aceitável, pois não serão
criadas estruturas muito complexas. Assim, esta IDE é bem-vinda. Mas como gosto
de usar as facilidades que algumas IDEs têm, pesquisou-se bastante para ver outras
IDEs que têm suporte para Arduino e achou-se algumas, mas o que realmente
interessou foi um addin para o Visual Studio. Sim, o bom e velho Visual Studio pode
ser usado para criar os projetos dos programas para o Arduino. Para isto, vá até o
site http://www.visualmicro.com e faça o download da versão de teste. Faça a
instalação, no site tem toda a documentação necessária.

Figura 60: Visual Studio com o Addin Visual Micro.

Usar ou não uma IDE com mais recursos não invalida usar a IDE do próprio
Arduino, pois é perfeitamente possível criar todo um novo firmware em um bloco de
notas e compilar usando ferramentas livres para gerar o arquivo “HEX” para gravar
no microcontrolador. Porém, se a pessoa pode ter uma IDE com mais recursos,
porque não usá-la?
6.3.4.3.1. Programar para Arduino sem Arduino

Agora que se conhece aonde vai ser escrito o programa, conhecer-se-á um

pouco sobre a linguagem do Arduino (que no caso já se sabe que é a linguagem
Wiring). Como foi dito anteriormente, a linguagem do Arduino é na verdade um
Framework (uma plataforma que oculta a complexidade de alguma coisa e exibindo
apenas uma interface de fácil compreensão) que encapsula toda a complexidade de
uma codificação deste porte.
Só para clarear as coisas, quando se programa para um µC
(microcontrolador) do tipo PIC (exemplo 18F4550), os programadores usam a
linguagem C (C puro) junto com as lib do µC específico. Outra coisa interessante é
que este tipo de programação permite ao programador muito mais ações, pois tem
todos os recursos do µC; porém o programador tem que conhecer muito bem estes
recursos.

Figura 61: Programa escrito em C para o microcontrolador PIC18F4550.

Este programa na figura 61 é um programa bem simples. A sua função é ligar

o led quando o botão for pressionado. Quando o botão não for pressionado, o led
fica apagado. Veja que é preciso seguir a lógica normal de um programa em C, ou
seja, tem-se que ter os INCLUDES (uso das bibliotecas) e o procedimento principal
que vai dar o Start na aplicação é o MAIN() e dentro tem-se o loop infinito WHILE
(TRUE). Os µC são programados uma vez e ficam trabalhando (em execução) por
tempo indeterminado e, dentro o loop, tem-se os comandos que dizem ao µC o que
fazer, como fazer e quando fazer alguma coisa. É sempre assim toda a vez que se
for programar para PIC.
Mas antes do Arduino aparecer, não existia os µC? Sim, existiam sim. Só que
os µC eram todos “programados na unha” (jargão de programador); ou seja: a
pessoa teria que conhecer muito bem o seu µC, registradores, flags, clock, fusíveis,
etc. Além disto, o conhecimento em programação na linguagem C tinha que ser
muito bom. Veja a figura 62, mostrando um código para fazer o led (pino 13 do
Arduino) piscar a cada 1 segundo. O código foi escrito em C puro, ou seja, sem o
framework do Arduino. Neste caso, o µC é um Atmega328p.

Figura 62: Código pisca-pisca em C para o Atmega328p.

Viu que é bem simples programar em um µC antigamente? Agora sem piada,

a programação de µC era uma tarefa voltada somente para os engenheiros que
usavam em seus projetos. Mas a grande sacada do Arduino foi justamente essa:
ocultar toda esta complexidade e deixar exposto somente o que fosse necessário.
Assim é o framework do Arduino (usando a linguagem Wiring).

6.3.4.4. Iniciando um novo Sketch

Veja o que o framework do Arduino tem quando se abre a IDE e abre novo
Sketch em branco. Isto mesmo, agora só há duas rotinas para programar um µC.
 Figura 63: IDE do Arduino com novo Sketch.

Tem-se uma rotina chamada de SETUP(), onde é feito as declarações dos

objetos, declarações da configuração do µC como definição dos comportamentos
das portas, velocidade para a comunicação serial, diretivas para habilitar ou
desabilitar os registradores internos e muito mais. Assim, esta rotina configura como
o seu µC vai se comportar. A outra rotina é o LOOP(). Esta é uma rotina que vai
executar assim que o µC for carregado (quando estiver ligado a fonte de
alimentação e o programa embarcado). Esta é a rotina principal, pois nela será
escrito o nosso código. É nela que se diz ao µC o que fazer, como fazer e quando
fazer. Assim. Bem simples.
O Arduino é um framework que esconde toda a complexidade. Uma destas
complexidades é precisar se preocupar em criar uma rotina MAIN(). Ele mesmo a
cria, criando junto as duas rotinas expostas setup() e loop(). Como a complexidade
está oculta, não se pode escrever programas em Assembly, pelo menos não
diretamente a IDE do Arduino não aceita a linguagem Assembly nativamente. Mas
existem formas para a IDE aceitar sim o Assembly.

6.3.4.5. Entendendo o Firmware do projeto

Agora que se conheceu um pouco como funciona o framework do Arduino,

deste ponto em diante, chamar-se-á somente de Arduino. Ver-se-á alguns pontos do
código que foi escrito para este projeto.
 1 #include <Servo.h>
2
3 //criar os objetos para controlar os servos
4 Servo junta01; //garra
5
6 char comando;
7 int valor;
8 int pot;
9 int lm35;
10
Código do Arduino - Declarações

Este código é bem simples. Veja na linha 1: há a declaração da diretiva de

vinculação de arquivo externo. Neste caso, é o #include. Esta diretiva tem que ser
usada toda a vez que vai incluir uma biblioteca de funções (chamada de lib). Na
linha 3, há um comentário. Tudo o que for precedido por “//” é um comentário e não
é interpretado pelo compilador. Na linha 4, tem uma variável do tipo Servo com o
nome de “junta01”, ou seja, referenciar-se-á ao Servomotor com este nome. Da linha
6 até a linha 9, tem-se as declarações das variáveis de armazenamento e controle
da aplicação.

11 void setup()
12 {
13 Serial.begin(9600);
14 junta01.attach(6);
15 }

Código do Arduino - Setup

Nesta segunda parte, far-se-á a configuração do Arduino, que neste caso é

bem simples, dentro da rotina setup(). Na linha 13, usar-se-á a função
Serial.begin(9600), desta forma definimos a velocidade de comunicação da porta
serial e a velocidade escolhida foi a de 9600 bauds (depois de muitos testes). Na
linha 14, há a indicação de qual porta o servo vai estar conectado, neste caso usa-
se o método attach com o número 6. A porta 6 é uma porta digital com PWM,
perfeita para trabalhar com servos.
17 void loop()
18 {
19
20 if (Serial.available()>0)
21 {
22 comando = Serial.read();
23 }

Código do Arduino – loop() – Parte 1.

 Depois do Arduino configurado no procedimento setup(), vai-se a rotina que
ficará rodando o tempo todo, dentro do procedimento loop().
Este código é um pouco grande, por isto serão comentados somente os
principais pontos. Assim tem-se o início do procedimento na linha 17. A primeira
ação é fazer o Arduino ficar constantemente lendo da porta serial, na linha 20, há
uma condicional; se Serial.available (dados trafegados na porta) é maior que zero,
significa que algo foi enviado pela porta serial para o Arduino, em caso positivo
mando o Arduino ler o conteúdo do que foi enviado e gravado na variável comando,
linha 22.

6.3.4.5.1. Acionando um Servomotor

24 if (comando == 's')
25 {
26 //controlar o servo
27 valor = Serial.parseInt();
28 pot = map(valor, 0, 1023, 0, 179);
29 delay(15);
30 junta01.write(pot);
31 comando='j';
32 }

Código do Arduino – loop() – Parte 2.

Continuando na linha 24, existe outra condicional. Agora, testa-se se o

comando é o “s”. Se for, é o comando para mover o servo (mais detalhes no item
6.3.3.2-Acionando um atuador com VBA). Na linha 27, o valor é recebido (é feito
uma conversão de caractere para um número inteiro). Na linha 28, é usado a função
map() (que na verdade mapeia um valor qualquer que esteja dentro de uma
determinada faixa para outro valor equivalente em outra determinada faixa).
Explicando rapidamente, esta função recebe um valor e este valor é identificado
dentro da seguinte faixa de 0 a 1023. Se estiver dentro desta faixa, será feito uma
conversão para um ângulo equivalente entre 0 e 179 (nunca coloco 180 graus por
motivo de segurança) e, por fim, a função map() faz a sua mágica e retorna o ângulo
equivalente ao valor recebido pela porta serial. Este retorno vai para a variável pot.
Há um atraso no código de 15 milissegundos (linha 29), usando o método write()
para mover o servo de acordo com o ângulo recebido. Simples assim (linha 30). E,
para finalizar, esta condicional atribuo “j” à variável comando para que esta
execução seja encerrada.

6.3.4.5.2. Acionando um Led

34 if (comando == 'e')
35 {
36 //controlar a luminisidade do led
37 valor = Serial.parseInt();
38 analogWrite(11,valor);
39 comando='j';
40 }
Código do Arduino – loop() – Parte 3.

Esta rotina é bem simples. Veja a condicional na linha 34. Se o comando

recebido for a letra “e”, então executa o bloco de instruções dentro desta
condicional. Na linha 37, a variável valor recebe um valor numérico pela porta serial.
O responsável por isto é a instrução Serial.parseint(). Esta instrução recebe um valor
na forma de texto e converte para um número inteiro válido. Feito isto, a próxima
instrução é acionar o led.
Na linha 38, a instrução analogWrite(Nº da porta,valor), quando acionada em
um pino com sinal PWM, faz gerar uma simulação de um sinal analógico (6.3.1.1-O
que é o PWM) e isto não tem nada a ver com as entradas analógicas.
Enfim, esta instrução tem uma faixa de operação entre 0 e 255, ou seja, todo
o valor inserido nesta instrução tem que estar dentro desta faixa. Assim, 0 não vai
ligar o led e, quando o valor for 255, o led é ligado. Então, qualquer valor entre 0 e
255 é uma representação de uma variação analógica (em um sinal digital). Assim, é
possível acionar e desacionar o led e poder-se-á alterar a variação da luminosidade
como um Dimmer. E, mais uma vez, finaliza-se tudo com a letra “j” na variável
comando.
6.3.4.5.3. Lendo os sinais das portas analógicas

42 if (comando == 'i')
43 {
44 //ler os dados das portas analogicas
45 //potenciometro 01
46 pot = analogRead(A0);
47 //Sensor de Temperatura lm35
48 lm35 = analogRead(A1);
49 Serial.print(pot);
50 Serial.print(",");
51 Serial.println(lm35);
52 delay(200);
53 }
54 }
55
Código do Arduino – loop() – Parte 4.

O próximo bloco de instruções inicia na linha 42. Há o teste da condição para

ver se na variável comando a letra recebida é a letra “i”. Nesta rotina, lê-se dois
sensores: o primeiro é o Potenciômetro que está na porta A0, e o segundo é o LM35
que está na porta A1.
Sendo assim, na linha 46, é lido o valor da porta A0 e armazenado na variável
pot. Na linha 48, é lido o valor da porta A1 e armazenado na variável lm35. Nas
linhas 49, 50 e 51, é montada a transmissão destes dados coletados, isto de acordo
com a sintaxe na figura 55 (item 6.3.3.2 – Acionando um atuador com VBA).
Para finalizar este bloco, tem um delay de 200 milissegundos para haver
tempo do dado ser transmitido pela porta serial. E, assim, finaliza-se as rotinas que
compõem o software que vai controlar o Arduino que será embarcado no
Atmega328p.
Todo este código tem que ser gravado no µC para que ele tenha a autonomia
de ler os comandos e executar tudo o que foi solicitado. Viu-se, de modo bem
detalhado e simplificado, como executar uma ação (ação de escrever) e uma ação
de receber um sinal (ação de ler).

6.3.4.6. Vamos embarcar

O processo de gravar o software no Arduino é bem simples. Na IDE que usar

para codificar, vai ter um botão para VERIFICAR o código e um botão para
CARREGAR. Neste caso, usou-se a IDE do Visual Studio para programar e por lá
mesmo fez-se o UpLoad para o µC, mas a grande maioria dos estudantes, hobistas
e garagistas vai mesmo é usar a IDE do Arduino. O mesmo será usado aqui.

Figura 64: Barra de ferramentas IDE do Arduino.

A IDE do Arduino é bem simples. Pode-se ver na figura 64 os principais

comandos. O fluxo é assim: abre-se a IDE (ele vem com o ultimo sketch ou um
sketch em branco), escreve-se o código, depois clica-se no botão COMPILAR, a IDE
vai fazer um processo de verificação do código e se não houver erros o código será
compilado veja a figura 65 (parte A). Quando o processo terminar, vai ficar igual à
figura 65 (parte b).

Figura 65: Processo de compilação do Arduino.

Se a compilação ocorreu bem e sem problemas, o próximo passo é fazer o

UPLOAD para o Arduino. O processo é bem semelhante ao de compilar: a IDE vai
compilar novamente o Sketch e depois vai fazer o Upload (na versão em português
fica como CARREGAR) (ver a figura 66). E se tudo ocorrer bem, a conclusão do
processo será indicada na barra de status com o nome de CARREGADO.
 Figura 66: Processo de UpLoad.

Agora que o firmware foi transferido para o Arduino, deve-se testar. Como
este projeto usa a comunicação serial para se comunicar, é possível usar uma
ferramenta da própria IDE do Arduino para ver se está funcionando. Para isto, abre-
se o monitor serial na tela da IDE (ver a figura 64). Para que ele funcione, deve-se
enviar o comando para de leitura, que no caso é a letra “i’ (ver item 6.3.4.5.3).
Assim, digita-se a letra “i” e pressiono o botão ENVIAR (ver figura 67).

Figura 67: Monitor serial da IDE.

Na próxima imagem, são exibidas as leituras das portas analógicas do

Arduino. Observe a velocidade da porta configurada de acordo com o projeto, que é
de 9600. Outros valores podem ser usados, sempre verificando como está no seu
projeto.

Figura 68: Monitor serial, recebendo os dados.

 Como se pode ver, o processo de compilar e carregar o sketch para o Arduino
é bem simples do ponto de vista prático-operacional. Qualquer um, com o mínimo de
conhecimento em programação, consegue escrever um programa em C/C++ para o
Arduino e fazer o seu carregamento.

6.3.4.6.1. Entendendo a compilação

O primeiro passo é a compilação do programa. A compilação é o processo de

análise de um programa escrito em linguagem de alto nível. O programa fonte (ou
código fonte) e sua conversão (ou tradução) em um programa equivalente podem
ser descritos em linguagem binária de máquina, denominada programa-objeto (ou
código-objeto). O programa que realiza esta tarefa é denominado de compilador
(Monteiro, Mario A, 2012) e o fluxo do processo de compilação pode ser visto na
figura 69.
Durante o processo de compilação, o código-fonte é analisado, linha por linha
(ou seja, comando por comando). O programa compilador realiza várias tarefas,
dependendo do tipo de comando que ele esteja analisando. Se, por exemplo, ele
estiver analisando um comando que esteja declarando uma variável, criará a
respectiva entrada em sua tabela de símbolos (usada no processo de montagem)
(Monteiro, Mario A, 2012).

Figura 69: Fluxo básico da compilação.

(Fonte: Monteiro, 2012, p. 496)
 Enfim, este é o fluxo de forma bem simplificada. É claro que detalhes
menores não foram contemplados aqui, como o código é traduzido para linguagem
de máquina e como é linkado a suas bibliotecas. Isto fica fora do objeto deste
trabalho.
Mas, para os mais curiosos, a IDE do Arduino usa o AVR-GCC como
compilador e usa todos os utilitários do AVRDUDE para compilar e gravar o firmware
no microcontrolador.

6.3.5. Conhecendo a interface do usuário

Depois que foi mostrado como funciona a leitura das informações geradas
pelo Arduino, conheceu-se como mandar o Arduino executar uma ação, que no caso
foi controlar o led (ligar e desligar) e acionar o Servomotor.
Agora, vai-se controlar isto à distância. Para isto, usar-se-á uma interface
para o usuário feito no MsExcel e codificado em VBA. Assim, ver-se-á alguns
detalhes do funcionamento desta aplicação.
Como foi visto anteriormente, no tópico sobre supervisório (item 3.3-
Supervisório), o seu principal objetivo é supervisionar e controlar remotamente um
processo de produção. Por isto, o projeto tem somente o necessário para fazer estas
ações, conforme pode ser visto na figura 70. Veja como funciona esta interface.

Figura 70: Interface do supervisório.

 Pode-se ver que, na figura 70, a interface criada no MsExcel e percebe-se
que ela está dividida em 5 blocos. Cada um dos blocos tem uma ou mais
funcionalidades, mas todas elas estão dentro das duas funções principais que é ler e
escrever.
Com a aplicação carregada na tela, deve-se ligá-la para vê-la funcionar. Para
isto, existem dois botões bem intuitivos: ON/OFF, que fica a direita na parte inferior
da tela, ao clicar no botão ON (botão verde, para ligar o programa). A aplicação
começa a funcionar para demonstrar isto. No bloco ajustes, tem um led que fica
vermelho quando o programa está OFF e fica verde quando o programa está ON.
Veja melhor no status A: Desligado e no status B: Ligado da figura 71.

Figura 71: Bloco de ajuste e chave ON/OFF.

Agora que o sistema está ligado, observa-se melhor os blocos existentes.

6.3.5.1. Entrada A

Este bloco da interface representa a leitura vinda do Arduino. Só para

relembrar, esta é uma entrada analógica que, neste caso, o sensor é um simples
potenciômetro (resistor variável). Quando este potenciômetro é movido (girado da
esquerda para direita), a resistência vai baixar ou elevar-se. O que a porta analógica
do Arduino faz é somente ler esta variação, com a sensibilidade do ADC.
Assim, esta parte do programa tem um display digital (indicador 1 na figura
73) que representa os valores de entrada que variam de 0 a 1023. No exemplo da
figura 73, o valor lido é 484. Veja que, logo abaixo, tem uma coluna de leitura
mostrando de forma gráfica o valor de entrada. Ao mesmo tempo, há um gráfico de
tempo que mostra as variações desta entrada, é o indicador 3. Veja que, ao longo do
tempo, ele representa e, até mantém, um certo histórico das variações ocorridas,
pois esta é uma das aplicações que podem ser feitas usando como base esta
ferramenta, criar um banco de dados com estes valores de histórico. As
possibilidades são muitas.
E ainda neste bloco, há um botão chamado GRAVAR (indicador 2, figura 73).
Este botão foi inserido para permitir a gravação dos valores lidos pela porta
analógica. Neste exemplo, estão sendo usados estes valores armazenados para
mover o Servomotor. Assim, este é um exemplo de como pode armazenar os
valores lidos da porta analógica. Isto fica bem observado vendo o giro para esquerda
da figura 72 e o resultado é exibido na figura 73 no valor obtido de 484.
Para entender melhor, imagine por alguns instantes que este potenciômetro é
um sensor de pressão, que está em uma caldeira. De acordo com este sensor, é
possível calcular a pressão e, de acordo com a situação, o operador pode fazer
alguma ação ou aumentar ou diminuir a pressão; ou seja, agora é só um
potenciômetro, mas pode ser qualquer tipo de sensor, inclusive este sinal pode vir
de um CLP, ou direto de um outro sensor ou controlador.

Figura 72: Giro do potenciômetro (esquerda e

direita). Figura 73: Entrada analógica-Recebendo o valor.

6.3.5.2. Entrada AST

Este é o monitoramento de temperatura. Aqui o valor recebido (da porta A1)

é um ranger de 0 a 1023 que é convertido em Graus Celsius. O valor entra puro do
jeito que o Arduino ler, e no MsExcel por meio da codificação em VBA é que estes
valores são convertidos para unidade de temperatura.
Há um display digital que mostra os valores da temperatura (indicador 1,
figura 74). Há também um gráfico de tempo onde é possível ver a variação desta
temperatura (indicador 2, figura 74). Há uma coluna graduada que vai de 15º até 50º
(isto é claro pode ser definido de acordo com seu projeto) que mostra em tempo real
a variação de temperatura (indicador 3, figura 74). E, por fim, mais uma forma de
mostrar a variação, usou-se um Gauge ou manômetro. Este tem um visual que
lembra os manômetros que ficam em caldeiras. Esta aparência traz uma facilidade
na leitura e sem falar que deixa a interface mais bela (ver o indicador 4, da figura
74).

Figura 74: Monitoramento de Temperatura.

Veja que se recebe os valores brutos do Arduino, faz a conversão para

unidade de temperatura, depois de convertidos podem ser exibidos. Então, que tal
ter um alarme que informe quando a temperatura chegar a um determinado valor?
Bom, isto foi feito. Observe. No bloco AJUSTES, tem um botão ABRIR, ao clicar
sobre ele, será exibido uma tela de configurações (ver a figura 75-A).
Nesta tela, tem as principais configurações do sistema. Veja. Indicador 1 é a
porta serial em que a ferramenta vai se comunicar com o Arduino e, neste caso, é a
COM3. Indicador 2 é a velocidade desta porta e, neste caso, é 9600. E, por fim, o
indicador 3 é o parâmetro para definir qual a temperatura do alarme, este alarme
pode ser áudio e visual e, neste caso, foi somente visual com um alerta piscando na
tela. Este foi definido para 30º C; ou seja, quando a temperatura chegar a este valor
um alerta visual será exibido na tela e ficará piscando até a temperatura baixar.
Para exemplificar isto, observa-se a figura 75-A. O alarme está definido para
30º C e a figura 75-B exibe uma leitura acima dos 20º C, mas abaixo dos 30º C. E
veja que está tudo bem. Observe agora a figura 75-C. Veja que existe agora um
alerta visual e o manômetro está indicando um valor de 30º C ou superior. Este
indicador vermelho de alarme só vai parar de piscar quando a temperatura cair e for
menor que 30º C.
 Figura 75: Configuração do Alarme e demonstração.

Esta é uma forma de exibir um monitoramento. Neste caso, é um sensor de

temperatura, mas poderia ser pressão, nível de água, valor de PH e assim por
diante.

6.3.5.3. Saída DS

Este bloco é a área dos atuadores, usa-se um Servomotor. Este bloco é o

controle de uma saída digital. Neste caso, o servo está conectado à porta digital 6
que é uma porta PWM. Este controle é bem simples: pode-se digitar um valor de
ângulo de 0 até 180º e quando o botão OK é acionado o Arduino recebe o comando
e executa a ação de mover o servo.
É possível ver que na figura 76-A tem a posição de ângulo 45º e na figura 76-
B há a posição angular de 0º e, para ficar bem claro, existem as visões dos servos e
da tela da aplicação. Assim é fácil controlar qualquer atuador, desde um motor D.C.,
ventoinhas e outros mais.

Figura 76: Movimentando o Servomotor.

 Ainda nesta Saída Digital, além de controlar o servo por meio dos ângulos, é
possível fazer o servo executar vários movimentos armazenados. Lembre-se que, no
tópico ENTRADA A (item 6.3.5.1), na figura 73 indicador 1 e indicador 2, mostra
claramente que temos um botão. Este botão GRAVAR é usado para armazenar os
valores lidos da porta analógica. Cada vez que clicar no botão GRAVAR um valor é
armazenado e onde serão usados estes valores armazenados. Agora, na figura 77-
B, tem um botão OK, quando se clica neste botão, o servo começa a se movimentar
de acordo com todos os valores armazenados anteriormente. Para este trabalho,
fez-se o teste com até 30 posições e funcionou muito bem.
Imagine que isto pode ser um braço robótico acionado por servos. É possível
receber os valores dos potenciômetros (ou joysticks), armazenar os valores e depois
é só solicitar para que o braço execute os movimentos previamente armazenados.

Figura 77: Movimentar servo com vários ângulos.

6.3.5.4. Saída DL

Continuando com os controles de saída digital, há agora o controle de um led.

Só para demonstrar mais uma vez que controlar um led, um servo ou um conjunto
de luzes, etc. é bem fácil.
Esse controle é bem simples. Para ligar o led, é só clicar no botão LIGAR e
veja que o led no painel fica em vermelho vivo e o led acendeu (figura 78-B). Só
para entender, quando o led está apagado no painel, o led também fica apagado
(figura 78-A). Isto tem que existir, pois quando se controla um atuador, deve-se ter
um retorno no painel para poder saber que o comando funcionou.
Também é possível controlar o led como um Dimmer, usando graduações que
vão do 0 (apagado) até o 255 (aceso). Enfim, controle demonstrado (ver figura 78).
Assim, vê-se que o controle de um led é bem simples e fácil.
 Figura 78: Acionando e desacionando um Led.

Conclusão

Este trabalho foi realizado com o objetivo de demonstrar, de forma fácil, como
desenvolver um sistema de supervisório modelo para aquisição, monitoramento e
controle; ou seja, um projeto pequeno de um sistema SCADA.
Para o desenvolvimento deste trabalho, não houve a aquisição de qualquer
tipo de componente o que facilitou bastante o meu trabalho, sobrando tempo para as
pesquisas.
Em um primeiro momento, procurou-se na internet algum modelo de Sistema
Supervisório desenvolvido inteiramente em Excel e usando VBA. Na verdade, não
foi encontrado nada neste sentido. Achou-se muitas aplicações que apenas tratavam
os dados oriundos de um sistema SCADA. Com um pouco mais de pesquisa, foram
encontrados alguns modelos que já faziam a leitura dos dados de um Arduino. No
entanto, somente faziam a leitura; já em VBA, com a função especifica de ler e
controlar um microcontrolador, não foi achado.
Foi, neste momento, que foi percebida a oportunidade de demonstrar que era
possível fazer esta comunicação com um microcontrolador: no caso, um Arduino,
mas pode ser feito com um PIC também. Então, pesquisou-se como poderia ser feito
esta comunicação e foram encontradas várias formas de se comunicarem. Diante
delas, optou-se pela mais simples, já que o objetivo era ser simples mesmo.
Por este motivo, usou-se o protocolo de comunicação de dados com o padrão
RS-232, ou seja, foi usada a porta serial. Usou-se, para configurar e abrir a porta, as
instruções nativas do VBA (herdadas do seu primo mais velho o Visual Basic) e para
a comunicação. Usou-se o comando nativo MODE.COM do próprio Windows.
Desta forma, foi fácil a comunicação. Como o pesquisador deste trabalho
desenvolve há bastante tempo usando a linguagem VBA, o desenvolvimento do
sistema de supervisório não foi difícil.
Durante o desenvolvimento do projeto, encontrou-se vários problemas, como
incompatibilidade dos comandos do MsDOS (emulado dentro do Windows atual).
Alguns parâmetros que deveriam funcionar, mas simplesmente não funcionaram. Os
dados eram enviados para o notebook pela porta serial, mas a porta não passava
pela porta ou a porta já estava aberta e eu tinha problemas com o tempo em que o
Arduino enviava estes dados e o tempo para o Excel ler estes dados. Foi aí que se
decidiu inserir, em vários pontos do código, algumas instruções de delay para poder
funcionar corretamente. Isso sem falar de quando tudo funcionava, conseguia-se ler
os dados do Arduino, conseguia acender o led, mas quando desligava e ligava o
sistema novamente, nada mais funcionava. Testou-se em um sistema Windows XP
virtualizado e funcionou bem. Mas como o Windows 10 estava sendo usado,
precisou-se fazer algumas adaptações. Todos os tópicos abordados neste trabalho
já estão atualizados e adaptados.
Enfim, desenvolveu-se o sistema supervisório usando o VBA. Criou-se o
firmware embarcado dentro do Arduino. Conseguiu-se ler o sinal do potenciômetro,
monitorar a temperatura da sala aonde se trabalhou usando o LM35 como sensor.
Conseguiu-se também controlar o acionamento de um led, inclusive como Dimmer, e
fez-se mover um Servomotor por meio de ângulos digitados na interface da
aplicação.
Neste sentido, o objetivo deste trabalho foi alcançado: a interface da
aplicação foi bem elaborada, sendo de fácil uso e o sistema embarcado funciona
muito bem.
Bibliografia

MONK, Simon. 30 Projetos com Arduino. Série tekene, Bookman, 2014.

LUIZ, Carlos Eduardo Sandrini. Criação de sistemas supervisórios em Microsoft

Visual C# 2010 Express – Conceitos básico, Érica, 2012.

MIYADAIARA, Alberto Noboru, Microcontroladores PIC18: Aprenda e programe em

linguagem C. Érica, 2013.

MONTEIRO, Mario A. Introdução a Organização de Computadores. LTC, 2012.

LIMA, C. B. Técnicas de Projetos Eletrônicos com os Microcontroladores AVR. 1. ed.

www.clubedeautores.com.br: Clube de Autores, 2010.

FRANCHI, Clairton Moro. Acionamentos elétricos. Erica, 2008

BEGA, Egídio Alberto. Instrumentação Industrial. Interciência, 2006

TERGOLINA, Rogério Lampert. Automação e Controle. Disponível em

<http://www.feng.pucrs.br/professores/tergolina/Automacao_e_Controle/?SUBDIRET
ORIO=Automacao_e_Controle>. Acesso em 05 de Fev. de 2017.

LYDON, Bill. A PLC for process control can appear to be less expensive...
Do PLCs Eliminate Need for a DCS? Disponível em:
<https://www.automation.com/library/articles-white-papers/articles-by-bill-lydon/do-
plcs-eliminate-need-for-a-dcs>. Acesso em 05 de Fev. de 2017.

Cliente AMBEV. Disponivel em: < http://www.infoeng.com.br/conteudo/ambev-

automacao-de-sistema-de-tratamento-de-agua.html>. Acesso em 05 de Fev. de
2017.

Microchip. Disponível em: < http://www.microchip.com/design-centers/8-

bit/architecture>. Acesso em 18 de Mar. De 2017.
Arduino. Disponível em: < https://blog.arduino.cc/2008/03/>. Acesso em 18 de Mar.
De 2017.

Arduino. Disponível em: < https://www.arduino.cc/en/main/credits >. Acesso em 18

de Mar. De 2017.

Arduino. Disponível em: < http://arduinohistory.github.io/ >. Acesso em 18 de Mar. De

2017

Arduino pinagem. Disponível em: < http://www.pighixxx.com/test/portfolio-

items/atmega328/?portfolioID=337 >. Acesso em 18 de Mar. De 2017

Hernando Barragán. Disponível em: <

http://people.interactionivrea.org/h.barragan/thesis/thesis_low_res.pdf >. Acesso em
18 de Mar. De 2017

WILLIAMS, Elliot. Wiring was arduino before arduino. Disponível em: <
http://hackaday.com/2016/03/04/wiring-was-arduino-before-arduino/ >. Acesso em 18
de Mar. De 2017

WIRING. Disponível em: < http://www.wiring.org.co/ >. Acesso em 18 de Mar. De

2017

PROCESSING. Disponível em: < https://www.processing.org/ >. Acesso em 18 de

Mar. De 2017

JAL. Disponível em: < http://justanotherlanguage.org/ >. Acesso em 18 de Mar. De

2017

QUADROS, Daniel. Programação em C no AVR: O avr-gcc ToolChain. Disponível

em: < http://dqsoft.blogspot.com.br/2012/05/programacao-em-c-no-avr-o-avr-
gcc.html >. Acesso em 18 de Mar. De 2017
BALDUCCI, Francesco. Programming Arduino UNO in pure C. Disponível em: <
https://balau82.wordpress.com/2011/03/29/programming-arduino-uno-in-pure-c/ >.
Acesso em 18 de Mar. De 2017

Forum ozgrid. Use Open to connect to serial port. Disponível em: <
http://www.ozgrid.com/forum/showthread.php?t=194802 >. Acesso em 18 de Mar. De
2017

WinWorld. Disponível em: < https://winworldpc.com/product/microsoft-visual-bas/10

>. Acesso em 18 de Mar. De 2017

BERNADES, Andre Luiz. VBA – Visual Basic for Application. Disponível em: <
https://sites.google.com/site/vbabernardes/vba/vba >. Acesso em 18 de Mar. De
2017

MICROSOFT. Fabricantes de software adotam o Visual Basic for Application.

Disponível em: < https://www.microsoft.com/brasil/pr/fabric.htm >. Acesso em 18 de
Mar. De 2017

Comandos do MSDOS. Disponível em: <

http://info.wsisiz.edu.pl/~bse26236/batutil/help/MODECSPS.HTM >. Acesso em 18
de Mar. De 2017

MIKROLINK Enginnering Solutions. Technical Notes: RS-232 Serial Port. Disponível

em: < http://www.microlink.co.uk/rs232.html >. Acesso em 18 de Mar. De 2017

Anexos

Código da aplicação em VBA para Excel.

Sub btnIniciar()
Dim ws As Worksheet
Dim linha, valor As Integer
Dim temp As Double
Set ws = ActiveWorkbook.Sheets(painel)

'abre a recepcao dos dados

ws.Range("A1").Value2 = ""

'limpando os valores do grafico principal

Call fncExibeOcultaObjeto("txtAlarme", 2)
Call fncExibeOcultaObjeto("led_off", 1)
Call fncExibeOcultaObjeto("led_on", 2)

gl_lin = 0
ws.Columns("e:e").ClearContents
ws.Columns("f:f").ClearContents
ws.Columns("d:d").ClearContents

'se a função abrir porta retornar VERDADEIRO a rotina

'de leitura do arduino pode iniciar
If fncAbrirPorta = True Then

'controla a exibição do led na interface de tela

Call fncExibeOcultaObjeto("led_off", 2)
Call fncExibeOcultaObjeto("led_on", 1)

'espera 2 segundos
Application.Wait TimeSerial(Hour(Now()), _
Minute(Now()), Second(Now()) + 2)

'pega a string a ser enviada

MyString$ = ""
MyString$ = "i"

'envia o caractere pela porta aberta,

'usa o comando Put e informa qual
'a cadeia de caracteres que será enviada
Put #1, , MyString$

'Nº da linha inicial dos dados para montar o grafico em tempo real
linha = 7

'Enquanto a celula A1 estiver vazia a pesquisa continua em loop

While ws.Range("A1") = ""

'DoEvents - entrega o controla do processo desta aplicação para o

'sistema operacional e depois o devolve ao aplicativo chamador.

DoEvents
MyString$ = "" 'limpa a string
Do
DoEvents
'Pega o caractere da interface
char$ = Input(1, #1)
Debug.Print ": " & char$
'se o caractere é imprimivel
If (char > Chr(31)) Then
'adiciona o caractere a minha string
MyString$ = MyString$ + char$
End If
 'looping até o caractere ser uma virgula
Loop Until (char$ = Chr(44))

ws.Cells(6, 2) = Int(MyString$) 'b6 - grafico

ws.Cells(linha, 5) = Int(MyString$) 'e7 - grafico de tempo

DoEvents
MyString$ = "" 'limpa a string
Do
DoEvents
char$ = Input(1, #1) 'Pega o caractere da interface
If (char$ > Chr(31)) Then 'se o caractere é imprimível
'adiciona o caractere a minha string
MyString$ = MyString$ + char$
End If

Loop Until (char$ = Chr(13)) 'looping até ser o ENTER

'*************** calculo da temperatura **************************

'valor double recebido direto pela porta serial

valor = CDbl(MyString$)
'a temperatura vem calculada a partir
'da funcao fncTemperatura
temp = fncTemperatura(valor)
'armazena na planilha
ws.Cells(5, 8).Value2 = temp & "ºC"
'*****************************************************************
'Armazena o valor do gráfico da temperatura
'na celula c6 - Grafico em coluna
ws.Cells(6, 3) = temp
'Armazena os valores da temperatura para o grafico de
dispersão, em F7
ws.Cells(linha, 6) = temp
'rotina verifica o limite de temperatura para disparar o alarme
If temp > fncGetTempAlarme Then
Call fncAlarme
End If
'---------------------------------------------------
linha = linha + 1
'se linha maior que 301 entao reinicia a contagem
'301 é o nº limite de linhas do grafico
If linha > 301 Then
linha = 7
End If
'Debug.Print "linha + 1: " & linha

Wend 'finaliza o laço enquanto

'**** Faz o fechamento da porta e encerra a transmissao ********

MyString$ = ""
MyString$ = "f" + Chr(13) 'Pega a string para o envio e junta a
um ENTER
Put #1, , MyString$ 'Envia o comando para a porta serial
Close #1 'Fecha o arquivo

Else
 fncMensagem "Ocorreu um problema na recepção dos dados.", 2
End If

End Sub
Código do btnIniciar (botão ON)

Sub btnFechar()
Dim ws As Worksheet
Set ws = ActiveWorkbook.Sheets(painel)
'fecha a recepcao dos dados
ws.Range("A1").Value2 = 1
Call fncExibeOcultaObjeto("led_off", 1)
Call fncExibeOcultaObjeto("led_on", 2)
End Sub
Código do btnFechar (botão OFF)

Sub moverServo()
Dim lin, valor As Long
lin = 26: col = 4
While Cells(lin, col).Value2 <> ""
valor = Cells(lin, col).Value2
Call fncMoverServo(valor)
lin = lin + 1
Wend
End Sub
Código do botão OK (botão para mover o servo por sequência de ângulos)

Sub moverServoGraus()
'mover o servo de acordo com o valor
'em graus digitado pelo usuario
Dim grau, x As Double
Dim lin, valor As Long

'definir a celula A26

lin = 26: col = 1
'a variavel grau ler a celula A26
grau = Cells(lin, col).Value2
'o grau digitado é convertido em valor inteiro
valor = fncConvGrauToValor(grau)
'é chamada a funcao para mover o servo
Call fncMoverServo(valor)
End Sub
Código do botão OK (botão para mover o servo por ângulos)

Sub enviarDados()

If Range("B1").Value = 0 Then
Call fncExibeOcultaObjeto("led_deslig", 1)
Call fncExibeOcultaObjeto("led_lig", 2)
Call fncEnviarSinal
End If
If Range("B1").Value > 0 Then
Call fncExibeOcultaObjeto("led_deslig", 2)
Call fncExibeOcultaObjeto("led_lig", 1)
 Call fncEnviarSinal
End If

End Sub
Código do controle Dimmer do Led

Sub LedOn()
Range("B1").Value2 = 255
Call fncEnviarSinal
Call fncExibeOcultaObjeto("led_deslig", 2)
Call fncExibeOcultaObjeto("led_lig", 1)
End Sub
Código do botão Ligar Led

Sub LedOff()
Range("B1").Value2 = 0
Call fncEnviarSinal
Call fncExibeOcultaObjeto("led_deslig", 1)
Call fncExibeOcultaObjeto("led_lig", 2)
End Sub
Código do botão Desligar Led

Sub gravar()
'rotina para gravar os valores obtidos da entrada analogica
'no caso os valores vem do potenciometro
Dim valor As Integer
valor = Range("b6")
Call fncGravar(valor)
End Sub
Código do botão Gravar

Sub telaConfig()
frmConfig.Show
End Sub
Código do botão Abrir – Para mostrar a tela de configuração

Global gl_ret As Long

Global gl_lin As Long
Global Const painel = "painel"
Global Const configSistema = "config"
Global Const titulo = "Supervisorio_VBA_ver1.0"

Function fncGetPort() As String

Dim sCom As String
Dim ws As Worksheet

Set ws = ActiveWorkbook.Worksheets(configSistema)
'pega o nome da porta
sCom = UCase(ws.Cells(1, 1))
fncGetPort = sCom
End Function

Function fncGetTempAlarme() As Double

Dim temp As Double
Dim ws As Worksheet
 Set ws = ActiveWorkbook.Worksheets(configSistema)
temp = ws.Cells(3, 1)
fncGetTempAlarme = temp
End Function

Function fncEnviarSinal()
'Função para acionar o Led
Dim ws As Worksheet

Set ws = ActiveWorkbook.Sheets(painel)

If fncAbrirPorta = True Then

MyString$ = ""
MyString$ = "e"
MyString$ = MyString$ & ws.Range("B1").Value
MyString$ = MyString$ + Chr(13)
'Envia o comando
Put #1, , MyString$
'Fecha a porta
Close #1
Else
fncMensagem "Ocorreu algum problema!", 1
End If
End Function

Function fncMoverServo(ByVal valor As Integer)

Dim ws As Worksheet
'Seta WS como a planilha ativa
Set ws = ActiveWorkbook.Sheets(painel)

'verifica se o retorno da funcao fncAbrirPorta

'é True (verdadeiro)
If fncAbrirPorta = True Then

'Limpa a variavel
MyString$ = ""
'Variavel recebe o comando S de servo
MyString$ = "s"
'Variavel recebe s + o valor inserido pelo usuario
MyString$ = MyString$ & valor
'Variavel recebe s+valor e junto ao ENTER
MyString$ = MyString$ + Chr(13)

'Envia os comandos por meio da instrucao Put

Put #1, , MyString$
'Fecha o arquivo de E/S
Close #1
Else
fncMensagem "Ocorreu um problema na recepção dos dados.", 2
End If

End Function

Function fncAbrirPorta() As Boolean

'**************************************************************
' Rotina para Configurar a porta serial e abrir um arquivo
' em memória, o que possibilita a transmissao de dados.
'**************************************************************
Dim ws As Worksheet
Dim ret As Integer

'Define o retorno da função como False

fncAbrirPorta = False

'define WS como uma folha no excel cujo o

'nome é configSistema que é uma constante
Set ws = ActiveWorkbook.Worksheets(configSistema)

'pega o nome da porta - com3

sCom$ = UCase(ws.Cells(1, 1))

'pega a velocidade - 9600

sBaud$ = UCase(ws.Cells(2, 1))

'retorno da função Shell, onde o retorno é um valor numerico

retorno = Shell("mode.com " + sCom$ + " baud=" + sBaud$ + _
" parity=n data=8 stop=2 to=off xon=off dtr=off rts=off")

'tem um atraso na aplicação de 2 segundos

Application.Wait TimeSerial(Hour(Now()), Minute(Now()), _
Second(Now()) + 2)

'abrir um arquivo de E/S para ler e escrever em um arquivo externo

'este arquivo primeiramente fica em memoria e só depois vai para
'a porta serial determinada, todo o arquivo recebe um nome que
'na verdade é um número.
Open sCom$ For Binary Access Read Write As #1

'variavel de retorno
gl_ret = retorno

'verifica se o conteudo da variavel de retorno está vazia

'se nao a função vai retornar VERDADEIRO
If IsNull(retorno) Or retorno = "" Then
fncMensagem "Porta não configurada", 2
fncAbrirPorta = False
Else
fncAbrirPorta = True
End If

End Function

Function fncTemperatura(ByVal valor As Integer) As Double

'*********************************************************
'Proposito: Receber um inteiro (analogico) e converter em uma
' medida de temperatura.
'Resolução do ADC do Atmega328p = 10 bits = 2^10 = 1024
'Tensao Vcc = 5 volts
Dim temp, volt As Double
Dim tempR As String

'volt = entrada_analogica *(Vcc / 10 bits)

volt = valor * (5 / 1023)

temp = volt * 100

'Arrendondamento em 2 casas decimais

 tempR = Round(temp, 2)

'retorno da função
fncTemperatura = tempR
End Function

Function fncGravar(ByVal valor As Integer)

Dim col As Long
Dim ws As Worksheet

Set ws = ThisWorkbook.Sheets(painel)
col = 4

If gl_lin = 0 Then
gl_lin = 26
Else
gl_lin = gl_lin + 1
End If

If ws.Cells(gl_lin, col).Value2 = "" Then

ws.Cells(gl_lin, col).Value2 = valor
End If
End Function

Function fncGetLastLine(nomePlan As String, ByRef coluna As Long) As Long

Dim lin, linv, col, i, id As Long
Dim ws As Worksheet
Dim t As Variant
'define o worksheet padrao
Set ws = ActiveWorkbook.Worksheets(nomePlan)

If coluna <> 1 Then

'pega a ultima linha preenchida
lin = ws.Cells(Rows.Count, coluna).End(xlUp).Row
Else
'pega a ultima linha preenchida
lin = ws.Cells(Rows.Count, 1).End(xlUp).Row
End If

'ultima linha vazia

linv = lin + 1

fncGetLastLine = linv
End Function

Function fncConvGrauToValor(ByVal grau As Double) As Double

'O valor em grau recebido é multiplicado pelo FTC e dividido
'por 180 que é o giro em grau max do servo
'FTC = Fator de Conversao = 1300
Dim x As Double
Dim FTC As Long

FTC = 1300
x = (grau * FTC) / 180

fncConvGrauToValor = Int(x)
End Function

Function fncConvValorToGrau(ByVal valor As Double) As Double

 Dim x As Double
x = (valor * 180) / 1300
fncConvValorToGrau = Round(x, 2)
End Function

Public Function fncDelay(ByVal tempoMili As Long)

Dim varStart
varStart = Timer 'Tempo inicial
Do While Timer < varStart + (tempoMili / 1000)
DoEvents 'Libera outros processos
Loop
End Function

Function fncPiscaPisca(ByVal liga As Boolean)

'funcao usada para piscar o alarme
Dim lin, valor As Long
lin = 5: col = 10
If liga = True Then

Cells(lin, col).Value2 = "ALARME"

Cells(lin, col).Select
With Selection.Font
.Name = "Consolas"
.Size = 20
.ThemeColor = xlThemeColorDark1
End With

With Selection
.HorizontalAlignment = xlCenter
.VerticalAlignment = xlBottom
.Orientation = 0
.IndentLevel = 0
.ReadingOrder = xlContext
End With

Selection.Interior.Color = vbRed
Else
Cells(lin, col).Clear
End If
End Function

Sub chamaCalc()
'primeira funcao de teste
retorno = Shell("C:\Windows\System32\calc.exe", vbNormalFocus)
End Sub

Function fncAlarme()
Dim tempo As Long
tempo = 500
Call fncExibeOcultaObjeto("txtAlarme", 2)
Call fncDelay(tempo)
Call fncExibeOcultaObjeto("txtAlarme", 1)
Call fncDelay(tempo)
Call fncExibeOcultaObjeto("txtAlarme", 2)
End Function

Public Function fncExibeOcultaObjeto(ByVal nome As String, _

ByVal exibe As Integer)
'1 = sim = exibe / 2 = nao = oculta
 If exibe = 1 Then
ActiveSheet.Shapes.Range(Array(nome)).Visible = True
Else
ActiveSheet.Shapes.Range(Array(nome)).Visible = False
End If
End Function

Function fncMensagem(texto As String, _

Optional tipo As Byte)
Select Case tipo
Case 1
MsgBox texto, vbInformation, titulo
Case 2
MsgBox texto, vbExclamation, titulo
Case Else
MsgBox texto, , titulo
End Select
End Function
Códigos do Módulo funções

Código do Firmware em C para Arduino.

#include <Servo.h>

//criar os objetos para controlar os servos

Servo junta01; //garra

char comando;
int valor;
int pot;
int lm35;

void setup()
{
Serial.begin(9600);
junta01.attach(6);
}
void loop()
{

if (Serial.available()>0)
{
comando = Serial.read();
}
if (comando == 's')
{
//controlar o servo
valor = Serial.parseInt();
pot = map(valor, 0, 1023, 0, 179);
delay(15);
junta01.write(pot);
comando='j';
}

if (comando == 'e')
{
//controlar a luminisidade do led
 valor = Serial.parseInt();
analogWrite(11,valor);
comando='j';
}

if (comando == 'i')
{
//ler os dados das portas analogicas
//e envia pela porta serial
//potenciometro 01
pot = analogRead(A0);
//Sensor de Temperatura lm35
lm35 = analogRead(A1);
Serial.print(pot);
Serial.print(",");
Serial.println(lm35);
delay(200);
}
}
Código em C que vai embarcado no Arduino.