UNIVERSIDADE FEDERAL DE CAMPINA GRANDE

CENTRO DE ENGENHARIA ELÉTRICA E INFORMÁTICA

DEPARTAMENTO DE ENGENHARIA ELÉTRICA
INSTRUMENTAÇÃO ELETRÔNICA

ARDUINO E LINGUAGEM DE PROGRAMAçÃO

PROCESSING EM INSTRUMENTAÇÃO

Alunos: Filipe Soares Donato

Lindinaldo Maurício da Cunha Filho
Vivianne Silva Torres

Campina Grande, fevereiro de 2023

 2

SUMÁRIO

1 Introdução 4
2 Arduíno 4
2.1 Firmata 5
Por que usar Arduino (Padrão) Firmata? A necessidade de comunicação. 5
3 Processing 6
4 O Projeto 8
4.1 Montagem 9
4.2 Programação do Projeto 12
4.3 Interface 14
5 Resultados Obtidos 15
5.1 Problemas encontrados 17
6 Conclusões 18
Referências 19
 3

Lista de Ilustrações

Figura 1 - Esquemático do Arduino UNO.

Figura 2 - Biblioteca Firmata.
Figura 3 - Montagem com vista do relé e potenciômetros.
Figura 4 - Funcionamento.
Figura 5 - LEDs indicam visualmente o nível de tensão do potenciômetro.
Figura 6 - Montagem vista de cima.
Figura 7 - O carregador possui uma saída máxima de 2A a 5V.
Figura 8 - Já a bateria possui tensão nominal de 3.86V e típica de 4.43V.
Figura 9 - Programa Descompactado.
Figura 10 - Tela Inicial.
Figura 11 - Função de Abas.
Figura 12 - Interface.
Figura 13 - Condição Inicial.
Figura 14 - Coleta de dados.
Figura 15 - Tempo de carregamento x Percentual da bateria.
Figura 16 - Tempo de carregamento x Tensão da bateria.
Figura 17 - Tempo de carregamento x Corrente elétrica.
Figura 18 - Tempo de carregamento x Temperatura LM35.
Figura 19 - Corrente elétrica x Tensão da bateria.
Figura 20 - Corrente elétrica x Tensão da bateria x Temperatura LM35.
 4

1 Introdução
Para solucionar problemas de engenharia, são desenvolvidas técnicas que
complementam a teoria e a experimentação. Nesse contexto, faz-se necessário o
conhecimento das técnicas de medição, dos instrumentos e da forma adequada em que estes
serão aplicados e também das técnicas de processamento de dados. Esses aspectos são
estudados na instrumentação eletrônica.
Sensores são dispositivos que detectam e respondem com eficiência a algumas
entradas provenientes de um ambiente físico, como por exemplo: luz, calor, movimento,
umidade, pressão ou qualquer variável detectável em um ambiente.
Atuadores são dispositivos que realizam a conversão de energia elétrica, hidráulica ou
pneumática, em energia mecânica. A potência mecânica gerada pelos atuadores é então
enviada para os dispositivos conectados aos atuadores, através dos sistemas de transmissão,
para que os mesmos realizem algum movimento.
Além disso, este trabalho visa apresentar uma interação da linguagem Processing com
o Arduino, dessa forma, quando um sensor recebe uma entrada específica proveniente do
ambiente, ele emite uma saída, que geralmente é um sinal capaz de ser convertido e
interpretado pelo processador.
Diante disso, exemplos e aplicações desses instrumentos, serão estudados com
maiores detalhes nos tópicos seguintes.

2 Arduíno
Arduino é uma plataforma eletrônica de código aberto baseada em hardware e software fáceis
de usar. As placas Arduino são capazes de ler entradas - luz em um sensor, um dedo em um
botão ou uma mensagem no Twitter - e transformá-las em uma saída - ativando um motor,
ligando um LED, publicando algo online. Você pode dizer à sua placa o que fazer enviando
um conjunto de instruções para o microcontrolador na placa. Para isso utiliza-se a linguagem
de programação Arduino (baseada em Wiring ), e o Software Arduino (IDE) , baseado em
Processing .
 5

A principal característica dessa plataforma é que seus projetos compiladores têm a

opção de ser stand-alone, ou seja, apresenta um código já complicado em seu chip, ou pode se
comunicar com algum software que esteja funcionando por um computador.

Além das características citadas, o Arduino possui uma forma padrão de como os
conectores são distribuídos na placa, isso permite ligações de outros módulos expansivos,
chamados de Shields. Esses módulos se acoplam sobre as placas principais. Existem vários
módulos disponíveis no mercado atualmente, sendo eles: sensores, relés, display LCD, entre
outros.

Figura 1: Esquemático do Arduino UNO.

Fonte: arduino.

2.1 Firmata
Firmata é um protocolo para comunicação com microcontroladores de software em um
computador host. O protocolo pode ser implementado em firmware em qualquer arquitetura
de microcontrolador, bem como em software em qualquer pacote de software de computador
host.
Por que usar Arduino (Padrão) Firmata? A necessidade de comunicação.
 6

No Arduino, a Firmata é uma biblioteca que implementa o protocolo de comunicação

denominado Firmata. Na prática, a Firmata torna possível controlar totalmente o arduíno por
um software no computador. E ainda, permite criar uma integração entre processing e arduino.

O Sketch abaixo é um dos exemplos da biblioteca Firmata que é nativa da IDE do

Arduino. Com a IDE aberta: Arquivos > Exemplos > Firmata > StandardFirmata.

Figura 2: Biblioteca Firmata.

Fonte: Autoria Própria.

3 Processing

Processing é uma linguagem de programação flexível e uma linguagem para aprender

a programar. Desde 2001, a Processing promove a alfabetização de software nas artes visuais
e a alfabetização visual na tecnologia. Existem dezenas de milhares de estudantes, artistas,
designers, pesquisadores e amadores que usam o Processing para aprendizado e prototipagem.
O software Processing sempre foi gratuito e de código aberto e sempre foi executado em Mac
OS, Windows e Linux.
 7

O Processing continua a ser uma alternativa às ferramentas de software proprietárias

com licenças restritivas e caras, tornando-o acessível a escolas e alunos individuais. Seu status
de código aberto, livre e gratuito incentiva a participação e a colaboração da comunidade que
são vitais para seu crescimento. Os colaboradores compartilham programas, contribuem com
códigos e criam bibliotecas, ferramentas e modos para ampliar as possibilidades do software.
A comunidade Processing escreveu mais de cem bibliotecas para visão computacional,
visualização de dados, composição musical, rede, exportação de arquivos 3D e programação
eletrônica.

Desde o início, o Processing foi projetado para ser o mais simples possível para
iniciantes, sabendo que sua simplicidade também beneficiaria usuários mais experientes. Foi
inspirado no imediatismo de linguagens anteriores como BASIC e Logo, bem como em
nossas experiências aprendendo a codificar e ensinando codificação para uma ampla
variedade de origens. Os mesmos elementos ensinados em uma aula de ciência da
computação do ensino médio ou universitário são ensinados através do Processing, mas com
uma ênfase diferente. Com foco na criação de mídia visual e interativa, os alunos iniciantes
em programação acham satisfatório fazer algo aparecer em sua tela logo após o uso do
software. Este currículo motivador provou ser um sucesso para liderança em design, arte, e
estudantes de arquitetura em programação e para envolver o corpo estudantil em geral nas
aulas gerais de ciência da computação.

O Processing é usado em salas de aula em todo o mundo, geralmente em escolas de

arte e programas de artes visuais em universidades, mas também é encontrado com frequência
em escolas de ensino médio, programas de ciência da computação e currículos de
humanidades. Em uma pesquisa patrocinada pela National Science Foundation, os alunos de
um curso introdutório de computação de nível universitário ministrado com Processing no
Bryn Mawr College disseram que teriam duas vezes mais chances de fazer outra aula de
ciência da computação do que os alunos de uma classe com um currículo mais tradicional. A
abordagem de Processamento também foi aplicada à eletrônica por meio do Wiring e Arduino
e projetos. Esses projetos usam uma versão modificada do ambiente de programação
Processing para tornar mais fácil para os alunos aprender a programar robôs e inúmeros
outros projetos eletrônicos.
 8

O software Processing é usado por milhares de designers visuais, artistas e arquitetos

para criar seus trabalhos. Museus como o Exploratorium em São Francisco usam o Processing
para desenvolver suas exposições. Projetos criados com o Processing foram apresentados no
Museu de Arte Moderna de Nova York, no Victoria and Albert Museum em Londres, no
Centre Georges Pompidou em Paris e em muitos outros locais importantes. O processamento
é usado para criar designs de palco projetados para apresentações de dança e música; para
gerar imagens para videoclipes e filmes; exportar imagens para cartazes, revistas e livros; e
criar instalações interativas em galerias, museus e na rua.

4 O Projeto
Visa atender as especificidades exigidas na disciplina de Instrumentação Eletrônica:
Deverá ser realizado um projeto de instrumentação, com o objetivo de medir uma grandeza ou
grandezas (mensurados), de forma a especificar os sensores/dispositivos utilizados, como
também os circuitos de condicionamento. Os resultados deverão ser mostrados, por exemplo,
em um LCD, ou que os dados obtidos possam ser plotados em gráficos com as grandezas
monitoradas.
Neste projeto, teremos dois circuitos principais. Primeiro, vamos mostrar o
acionamento de um cooler – ligando-o e desligando-o por meio de sinais vindos do Arduino.
E o segundo, o sensor LM35 irá medir a temperatura da fonte do carregador de um aparelho
celular.
Lista de materiais:
● Arduino UNO;
● 3 Resistores;
● 2 Potenciômetros;
● Relé de 5V;
● 3 LEDS;
● Cooler (DC 5V);
● Sensor de temperatura (LM35);
● Jumpers;
● Carregador de celular;
● Fonte de alimentação 5V;
● Bateria de celular.
 9

4.1 Montagem
Na primeira parte, vamos usar um relé, ao qual por sua vez conectamos o motor DC
que iremos controlar. O Módulo Relé é ideal para acionar uma lâmpada ou outra carga que
exija até no máximo 10A utilizando o Arduino ou qualquer outro microcontrolador.
Ele funciona exatamente como uma chave (interruptor). No borne cinza há 3
conexões: NA (Normalmente Aberto), C (Comum) e NF (Normalmente Fechado). Ou seja,
quando o Módulo Relé estiver "desligado", C estará conectado à NF. Quando estiver ligado, C
estará conectado à NA.
O arduino recebe os valores de tensão do pino do meio do potenciômetro 1, de acordo
com esses valores o código irá indicar quantos LEDs irão acender (simulando um volume).

Figura 3: Montagem com vista do relé e potenciômetros.

Fonte: Autoria Própria.

Quando chega num determinado volume, o código vai acionar o arduino e esse ativará
a porta que o relé está conectado. Como indicado anteriormente, o relé vai chavear e permitir
a passagem de corrente da fonte externa de 5V para o ventilador para ligá-lo.
 10

Figura 4: Funcionamento.

Fonte: Autoria Própria.

Os LEDs servem apenas para indicar visualmente o nível de tensão do potenciômetro.

O código ativa o nível alto da porta em determinada condição: Quando a tensão está em 2v
liga o LED 1. Quando a tensão está em 3V liga o LED 2. Quando a tensão está em 4V liga o
LED 3 e também a porta que ativa o relé que permite o funcionamento do cooler.

Na segunda parte do nosso circuito, nós temos o sensor de temperatura LM35. O

LM35 é uma família de sensores de temperatura de precisão que apresentam em sua saída um
valor de tensão linearmente proporcional à temperatura em graus Celsius medida. Sua
precisão em temperatura ambiente é de cerca de ± ¼°C, e pode ser empregado para medir
temperaturas na faixa de -55°C a 150°C (neste caso, com uma precisão de ±¾°C). Esse sensor
funciona com tensões entre 4V e 30V, consumindo menos de 60μA de corrente.

Figura 5: LEDs indicam visualmente o nível de tensão do potenciômetro.

 11

Fonte: Autoria Própria.

O sensor capta a temperatura do carregador de celular, e traduz para um sinal de

tensão, que vai para arduino, e passa para o código, que converte em Celsius (ºC).

Figura 6: Montagem vista de cima.

Fonte: Autoria Própria.

Abaixo temos o carregador e a bateria do celular que foram utilizados no teste.

 12

Figura 7: O carregador possui uma saída máxima de 2A a 5V.

Figura 8: Já a bateria possui tensão nominal de 3.86V e típica de 4.43V

4.2 Programação do Projeto

 13

Utilizou-se o Processing 4.1, vejamos nas figuras abaixo:

Figura 9: Programa Descompactado.

Fonte: Autoria Própria.

O código do circuito é extremamente simples, consistindo em um sketch que ativa e

desativa o nível lógico no pino do Arduino, o qual por sua vez liga e desliga o relé que
controla o cooler. E ainda converte o sinal de tensão que provém do sensor de temperatura,
convertendo em Celsius (ºC).

Figura 10: Tela Inicial.

 14

Fonte: Autoria Própria.

As abas permitem criar funções e melhorar a organização do código.

Figura 11: Função de Abas.

Fonte: Autoria Própria.

 15

4.3 Interface
Como mostrado na figura abaixo, Através da aplicação é possível visualizar o estado
de sensores e atuadores, assim como gravar os dados de interesse.

Figura 12: Interface.

Fonte: Autoria Própria.

Aqui lista as funcionalidades da interface

● Monitoramento do potenciômetro 1: simula um controle de volume, com indicativos
em led na protoboard e no programa acontece o monitoramento desse volume
artificial, se chegar em um nível alto o programa vai acionar um relé que vai ligar um
cooler para refrigeração de um suposto sistema. Ao ser ligada no programa terá
também um indicativo visual.
● Monitoramento do potenciômetro 2: lê o valor de tensão que está no potenciômetro.
Poderia ser considerado um sensor trabalhando na mesma faixa de valores e o
programa toma as decisões através do código.
● Gravar Dados: cria um arquivo de dados para cada turma, e quando o usuário quiser
gravar uma medição este valor será gravado em um arquivo de texto que pode ser
obtido na pasta data ou enviado para uma nuvem e ser baixado posteriormente.
● Monitoramento de temperatura do sensor LM35.
 16

5 Resultados Obtidos

Fizemos o monitoramento da temperatura de um aparelho celular em carregamento.

Fixamos o sensor com fita adesiva na tela e passamos um pouco de pasta térmica para
melhorar a leitura.

Figura 13: Condição Inicial.

Fonte: Autoria Própria.

O aplicativo utilizado para medir a corrente foi o DevCheck. Embora saibamos que o
aparelho android dispõe de diversos sensores internos , à nossa disposição no momento essa
era a melhor opção para fazer as medições com o lm35. É perceptível e esperado que como
ele estava posicionado na tela do aparelho as medições fossem abaixo do sensor do próprio
aparelho.
 17

A máxima temperatura no LM35 foi de 36.48°C, enquanto que no sensor do aparelho

marcava 40°C(sem casas decimais). Em todas as medições percebemos uma diferença em
torno de 3°C.

Figura 14: Coleta de dados.

Fonte: Autoria Própria.

A corrente no início do carregamento chegou perto de 1.8A e depois ficou na média de

1.7A. Depois que passou de 88% a corrente foi diminuindo para em torno de 1.5A. Após 91%
quando a tensão ficou em 4.399V a corrente foi diminuindo até completar a carga. A tensão
em 100% de carregamento ficou em 4.40 ficando em sintonia com a declarada pelo
fabricante de 4.43V. Abaixo, seguem os gráficos relacionados:
 18

Figura 15: Tempo de carregamento x Percentual da bateria.

Fonte: Autoria Própria.

Figura 16: Tempo de carregamento x Tensão da bateria.

Fonte: Autoria Própria.

 19

Figura 17: Tempo de carregamento x Corrente elétrica.

Fonte: Autoria Própria.

O gerenciamento da carga para aparelhos de 5V é aparentemente simples. Pois em

nosso teste a temperatura da bateria não influenciou na corrente de carga.

Figura 18: Tempo de carregamento x Temperatura LM35.

Fonte: Autoria Própria.

 20

Figura 19: Corrente elétrica x Tensão da bateria.

Fonte: Autoria Própria.

Importante notar que a corrente só diminuiu após 90% de carga.

Figura 20: Corrente elétrica x Tensão da bateria x Temperatura LM35.

Fonte: Autoria Própria.

Sistemas de carregamento turbo podem usar circuitos mais sofisticados, geralmente

aumentando a tensão de 5V para 9V ou 12V, mantendo a mesma corrente. Isso aumenta a
potência disponível para carregar a bateria, resultando em um tempo de carregamento mais
rápido.
 21

5.1 Problemas encontrados

Ao utilizar em conjunto para medir as entradas analogicas e digitais temos um

problema na queda de tensão pois foram conectados leds e um relé que consomem energia.
Então para o LM35 ser utilizado sem problemas é preciso não utilizar as outras funções e
manter os potenciômetros zerados. Além disso, o ATmega tem apenas um ADC para fazer a
leitura de todos os pinos analógicos, assim quando mandamos que ele faça a leitura de outra
entrada analógica o circuito do ADC é comutado de uma entrada pra outra para que o ADC
possa tomar uma amostra da tensão presente no pino e fazer a nova conversão.

6 Conclusões

A porcentagem da bateria que o Android exibe parece ser proporcional ao nível de

tensão da bateria, por isso que quando temos uma bateria viciada, ela não consegue manter
sua tensão por muito tempo e decai rapidamente, fazendo com que o aparelho exibe também a
rápida queda de porcentagem.
A interação do arduino com processing trouxe um bom aprendizado, percebe-se que
são inúmeras as formas de aplicação do Processing, a quantidade de material e exemplos para
estudos no próprio site dos criadores é uma das vantagens de utilizar a linguagem. Pode-se
desenhar botões, desenhar gráficos para exibir dados medidos por sensores conectados ao
Arduino, entre outras infinidades de coisas.
 22

Referências
ARDUINO. Firmata Library. Disponível em:
https://docs.arduino.cc/hacking/software/FirmataLibrary. Acesso em 03 de fevereiro de 2023.

PROCESSING. Reference. Disponível em: https://processing.org/reference/. Acesso em 03

de fevereiro de 2023.

DAINF. Processing (Beta). Disponível em:

https://pessoal.dainf.ct.utfpr.edu.br/merkle/processing/reference/ptBR/index_ext.html. Acesso
em 04 de fevereiro de 2023.

RANOYA. O código Processing. Disponível em:

https://www.ranoya.com/books/public/processing/. Acesso em 04 de fevereiro de 2023.

JEKNOWLEDGE. Interface LED com Arduino e Processing. Disponível em:

http://jeknowledge.github.io/academy-articles/interface-led-com-arduino-e-processing.
Acesso em 04 de fevereiro de 2023.

MAKER HERO. Integrando Processing no Arduino. Disponível em:

https://www.filipeflop.com/blog/interface-no-processing-para-o-arduino/. Acesso em 05 de
fevereiro de 2023.

SRITU HOBBY. Processing IDE with LED On and OFF. Disponível em:
https://srituhobby.com/processing-ide-with-led-on-and-off/. Acesso em 05 de fevereiro de
2023.

FAB ACADEMY. Processing reading a potentiometer. Disponível em:

http://archive.fabacademy.org/2016/fablabesan2016/students/328/potentiometer-with-processi
ng.html. Acesso em 05 de fevereiro de 2023.

AUTO CORE ROBOTICA. Como utilizar Processing com Arduino: Parte 3. Disponível
em: https://autocorerobotica.blog.br/como-utilizar-processing-com-arduino-parte-3/. Acesso
em 05 de fevereiro de 2023.
 23

Anexos
Anexo A - Código principal
//DECLARAÇÕES DE BILIOTECAS E VARIAVEIS
import processing.serial.*; // Carrega a biblioteca Serial na pasta Libraries
do Processing
import cc.arduino.*; // Carrega a biblioteca Arduino na pasta desse
projeto
Arduino arduino; //Criou esse objeto para poder utilizar as
funções da biblioteca do arduino
Table tabela;
PImage ufcg_logo, powerON, powerOFF, click, clickON; //serve para as imagens
PFont fonte; //serve para mudar a fonte do programa
PrintWriter output1, output2;

void setup() {
size(800,600); //Tamanho da Janela
smooth(); // Habilita o anti-aliasing

ufcg_logo = loadImage("ufcg_logo.png"); //Foto da ufcg carregou o arquivo

powerON = loadImage("powerON.png");
powerOFF = loadImage("powerOFF.png");
click = loadImage("click.png");
clickON = loadImage("clickON.png");
fonte = loadFont("Cambria-16.vlw");
output1 = createWriter("data/dados_1.txt");
output2 = createWriter("data/dados_2.txt");

arduino = new Arduino(this, "COM4", 57600); // Comunicacao com Arduino na

velocidade

arduino.pinMode(0, Arduino.INPUT); // Define o pino 0 como entrada

para o potenciometro 1
arduino.pinMode(1, Arduino.INPUT); // Define o pino 1 como entrada
para o potenciometro 2
arduino.pinMode(2, Arduino.INPUT); // Define o pino 2 como entrada
para o LM35
arduino.pinMode(3, Arduino.OUTPUT); // Define o pino 3 como saida
para o led 1 do potenciometro
 24

arduino.pinMode(4, Arduino.OUTPUT); // Define o pino 4 como saida

para o led 2 do potenciometro
arduino.pinMode(5, Arduino.OUTPUT); // Define o pino 5 como saida
para o led 3 do potenciometro
arduino.pinMode(6, Arduino.OUTPUT); // não utilizado
arduino.pinMode(7, Arduino.OUTPUT); // Define o pino 7 como saida
para o RELE
arduino.pinMode(8, Arduino.OUTPUT); // não utilizado
arduino.pinMode(9, Arduino.INPUT); // não utilizado
arduino.pinMode(10, Arduino.INPUT); // não utilizado
arduino.pinMode(11, Arduino.INPUT); // não utilizado
arduino.pinMode(12, Arduino.OUTPUT); // não utilizado
arduino.pinMode(13, Arduino.OUTPUT); // não utilizado

void draw() {
background(250); //Cor do fundo da tela
efeito_do_mouse();
cabecalho();
potenciometro();
menu_potenciometro();
lm_35();
mouse_interacao();
// Foi tudo feito em funções nas abas, daí é só chamar cada uma delas
mantendo a organização
}

Anexo B - Cabeçalho
void cabecalho() {
image(ufcg_logo, 1,30, width/5.5, height/4); //posição a exibir e tamanho
redimensionado
fill(0,0,0); textFont(fonte); textSize(22); //Atributos do texto de cor,
fonte e tamanho da letra

text("Instrumentação Eletrônica - Interação com Arduino e Processing", 130,

50); //texto e sua respectiva posição X Y
 25

text("Grupo: Filipe Soares Donato", 130, 75);

//texto e sua respectiva posição X Y
text("Lindnaldo Maurício da Cunha Filho", 203, 95);
//texto e sua respectiva posição X Y
text("Viviane Silva Torres", 203, 115);
//texto e sua respectiva posição X Y
}

Anexo C - Efeito do Mouse

//Faz o efeito do mouse--------------------------
int num = 15;
float mx[] = new float[num]; // Array
float my[] = new float[num]; // Array

void efeito_do_mouse () {
noStroke(); // Desativar traço
fill(0, 15); // Cor de Preenchimento do que vem abaixo

int which = frameCount % num;

mx[which] = mouseX;
my[which] = mouseY;

for (int i = 0; i < num; i++) {

int index = (which+1 + i) % num;
ellipse(mx[index], my[index], i, i);
}
}

Anexo D - LM35
int pino_lm35 = 2; //Pino que vai estar conectado
float val_leitura = 0; //Valor inicial

void lm_35() {
arduino.pinMode(pino_lm35, Arduino.INPUT); //setup pino na input
(A0=2)
val_leitura = arduino.analogRead(pino_lm35)*(0.48); // Valor da temperatura
convertido ou ajustado
 26

delay(50);

//LM35 MENU---------------------------------------------
fill(0);
text("Sensor LM35", 305,480);
text("Temperatura = ", 305, 510);
fill(0, 0, 255, 20);
rect(300,485,240,40);
fill(0,210,0);
text(val_leitura, 445, 510);
Potenciômetro 2
text("°C", 515, 510);
}
// Cor de Preenchimento preto
//Escreve o texto nessa posição
// Cor do objeto abaixo
// Desenha um retângulo
// Cor do que vem abaixo
// Exibe na tela o valor do
// Texto nessa posição

Anexo E - Menu do Potenciômetro

void menu_potenciometro() {
//Potenciometro 1 MENU----------------------------------------------
textSize(22); // Define o tamanho da fonte
fill(0);
text("Potenciômetro 1", 0,300); //Escreve o texto na cor preta
text("Refrigeração Ligada: ", 0, 317);
fill(0,0,255,20); // Cor do objeto abaixo
circle(215, 310, 25); // Desenha um circulo de raio 25
fill(0, 0, 255, 20); // Cor de Preenchimento do que vem abaixo
rect(0, 302, 196, 20); // Desenha um retângulo

// Potenciometro 1 Indicativo visual de Refrigeração ligada

if (val_pot1 > 4) {
fill(255,0,0,200); // Cor do objeto abaixo
circle(215, 310, 25); // Atualiza o círculo pra ver que foi pressionado
}

//Potenciometro 2 MENU---------------------------------------------
fill(0); // Cor de Preenchimento preto
text("Potenciômetro 2", 0,450); //Escreve o texto nessa posição
 27

text("Tensão = ", 0, 480); //Escreve o texto nessa posição

fill(0, 0, 255, 20); // Cor do objeto abaixo
rect(0,455,220,40); // Desenha um retângulo
fill(0,210,0); // Cor do que vem abaixo
text(val_pot2, 88, 478); // Exibe na tela o valor do Potenciômetro 2
text("Volts", 155, 478); // Texto
}

Anexo F - Mouse Interação

boolean clicado2 = false;
boolean clicado3 = false;

void mouse_interacao() {

// Menu de aquisição de dados--------------------------------------------

image(clicado2? click : clickON, 450,245, width/12, height/9); //posição a
exibir e tamanho redimensionado
textSize(22); // Define o tamanho da fonte
fill(0); // Cor de preenchimento preta
text("Gravar Dados\n Tensão:", 300,270); // Escreve o texto

if (mousePressed && mouseX>450 && mouseX<520 && mouseY>254 && mouseY<292) {

clicado2 = true;
output1.println(val_pot2 + "\n"); //Exemplo que ele vai gravar o valor do
potenciômetro 2 para a turma A
output1.flush();
//output.close();
delay(50);
}
else {
clicado2=false;
image(click, 450,245, width/12, height/9);
}

image(clicado3? click : clickON, 450,350, width/12, height/9); //posição a

exibir e tamanho redimensionado
 28

textSize(22); // Define o tamanho da fonte

fill(0); // Cor de preenchimento preta
text("Gravar Dados\n Temperatura:", 300,380); // Escreve o texto
if (mousePressed && mouseX>450 && mouseX<520 && mouseY>360 && mouseY<400) {
clicado3 = true;
output2.println(val_leitura + "\n"); //Exemplo que ele vai gravar o valor
da temp do lm35 para a turma B
output2.flush();
delay(50);
}
else {
clicado3=false;
image(click, 450,350, width/12, height/9);
}
}

Anexo G - Potenciômetro
int potenciometro1 = 0; //Pino que vai estar conectado
int potenciometro2 = 1; //Pino que vai estar conectado
float val_pot1 = 0; //Valor inicial
float val_pot2 = 0; //Valor inicial

void potenciometro () {
arduino.pinMode(potenciometro1, Arduino.INPUT); //setup pino na
input (A0 =0)
arduino.pinMode(potenciometro2, Arduino.INPUT); //setup pino na
input (A1 =1)
val_pot1 = arduino.analogRead(potenciometro1)*5.2/1023; // Valor do
Potenciômetro 1
delay(5);
val_pot2 = arduino.analogRead(potenciometro2)*5.2/1023; // Em vez de
potenciômetro poderia ser um sensor de temperatura
delay(5);
println(val_pot1, " ", val_pot2);

int i;
for(i=3; i<=5; i++){ // Esse i=3 é pra resolver um bug
que esta ativando outro led sem necessidade
 29

if(i < val_pot1+1) { // Esse +1 serve pra escolher uma

tensão acima de 2v
arduino.digitalWrite(i, Arduino.HIGH);
}
else {
arduino.digitalWrite(i, Arduino.LOW);
}
}
if (val_pot1 > 4) {
arduino.digitalWrite(7, Arduino.HIGH);
}
else if (val_pot1 < 4){
arduino.digitalWrite(7, Arduino.LOW);
}
}