Universidade Federal de Uberlândia

Faculdade de Engenharia Mecânica

Graduação em Engenharia Mecatrônica

Rafael Batista Cardoso (11321EMT026)

Rubens Rodrigues Teixeira Filho(11021EMT012)
Tiago Martins Paris (11421EMT005)

Laboratório I
COMUNICAÇÃO ENTRE DISPOSITIVOS

Uberlândia
8 de novembro de 2018
 Rafael Batista Cardoso (11321EMT026)
Rubens Rodrigues Teixeira Filho(11021EMT012)
Tiago Martins Paris (11421EMT005)

Laboratório I
COMUNICAÇÃO ENTRE DISPOSITIVOS

Relatório apresentado a disciplina de Redes

Industriais (FEMEC 42082) do Curso de Gra-
duaçõ em Engeharia Mecatrônica para obten-
ção de nota parcial da disciplina

Professor José Jean Paul Z. de S. Tavares

Universidade Federal de Uberlândia

Faculdade de Engenharia Mecânica
Graduação em Engenharia Mecatrônica

Uberlândia
8 de novembro de 2018
 Sumário

Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1 OBJETIVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 MATERIAIS E MÉTODOS . . . . . . . . . . . . . . . . . . . . . . . 5
2.1 Materiais Utilizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Comunicação Serial (Exercício 1) . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Comunicação I2C do tipo Mestre-Escravo (Exercício 2) . . . . . . . . . . . 10
2.2.3 Comunicação Ethernet (Exercício 3) . . . . . . . . . . . . . . . . . . . . . 12
2.2.4 Comunicação Wireless (Exercício 4) . . . . . . . . . . . . . . . . . . . . . 14

3 RESULTADOS ENCONTRADOS . . . . . . . . . . . . . . . . . . . 17
3.1 Comunicação Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Comunicação I2C do tipo Mestre-Escravo . . . . . . . . . . . . . . . 17
3.3 Comunicação Ethernet . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.4 Comunicação Wireless . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4 CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

APÊNDICE A – EXERCICIO 1 . . . . . . . . . . . . . . . . . . . . 23

APÊNDICE B – EXERCICIO 2 . . . . . . . . . . . . . . . . . . . . 26

APÊNDICE C – EXERCICIO 3 . . . . . . . . . . . . . . . . . . . . 30

APÊNDICE D – EXERCICIO 4 . . . . . . . . . . . . . . . . . . . . 34
 3

Introdução

Nos dias atuais o ambiente industrial vem cada vez mais se automatizando, através
de sistemas que para realizar suas funções, utilizam se de eletrônica, informatica, mecânica
e controle. Esses sistemas dependem de uma comunicação entre diferentes dispositivos que
compõe o sistema e realizam atividades distintas por sua vez. Essa comunicação deve ser
veloz e confiável para garantir que o sistema funcione como projetado.
O cenário industrial atual envolve um sistema centralizado e com uma solução para
essa comunicação um tanto conservadora, mas com o desenvolvimento cada vez maior
de microprocessadores e com a redução no custo desse dispositivo, o próximo passo seria
implementar um sistema descentralizado com o uso desse dispositivos.
No relatório a seguir foi implementados diversos tipos de comunicação com o uso
de Arduinos, para desenvolver o conhecimento básico necessário para implementação de
uma rede a partir dessa nova perspectiva
 4

1 Objetivo

O objetivo deste módulo foi desenvolver o conhecimento necessário para estabelecer

uma comunicação entre dois dispositivos. Esse objetivo foi alcançado através de diferentes
atividades, onde cada uma era necessário a implementação de um programa de comunicação
diferente entre os dispositivos. As comunicações abordadas foram:

• Comunicação serial entre Arduino e um monitor serial em um PC

• Comunicação com protocolo I2C entre dois Arduinos

• Comunicação entre Arduinos equipados com shield Ethernet, utilizando o protocolo

UDP

• Comunicação entre Arduinos no padrão Wireless equipados com shield XBee

 5

2 Materiais e Métodos

2.1 Materiais Utilizados

Os materiais utilizados nas atividades foram:

• Válvula pneumática 5/2 vias, acionada eletricamente (solenoide);

• Pistão pneumático;

• Sensor de início e fim de curso, representados por A0 e A1, respectivamente;

• Botão de acionamento (Manual);

• Arduino Uno;

• Shield Ethernet para Arduino;

• Shield XBee para Arduino;

• Módulo XBee;

• Computador;

• Cabos para conexão serial;

• Jumpers;

• Protoboard.
Capítulo 2. Materiais e Métodos 6

2.2 Métodos
Este modulo consistiu em 4 atividades, onde o objetivo era a operação de um
atuador pneumático utilizando diferentes tipos de comunicação entre os dispositivos. As
comunicações abordadas foram:

• Comunicação Serial

• Comunicaçao I2C do tipo mestre escravo

• Comunicação Ethernet

• Comunicação Wireless

O sistema a ser operado foi o mesmo em todas as atividades e o seu esquema pode ser
visto a seguir.

Figura 1 – Esquema Eletropneumático

O atuador é acionado através do solenoide A+, onde a saída do nosso sistema

é conectado, os sensores A0 e A1 são entradas do sistema, e em todas atividades foi
Capítulo 2. Materiais e Métodos 7

implementado um botão para acionamento manual do sistema. Em algumas das atividades

foi implementado um botão de emergência.
Em todas as atividades foi adotada uma padronização dos pinos a serem utilizadas,
que foi a seguinte.

• Botão de acionamento manual pino 2

• Sensor A0 inicio de curso pino 3

• Sensor A1 fim de curso pino 4

• Botão de emergência pino 5

• Saída para a solenoide da válvula pino 8

O microcontrolador ATmega na maioria das placas Arduino possui resistores pull-up

internos (resistores conectados a alimentação internamente) que você pode acessar.
Em todas as entradas foi usado esses resistores utilizando o argumento INPUT_PULLUP
na função pinMode(). esse argumento faz com que o o pino de entrada esteja em HIGH
quando o botão estiver aberto e LOW quando o btoão estiver pressionado.
Todas as atividade foram desenvolvidas em duas etapas, sendo a primeira uma
implementação na mesa utilizando Arduinos, botões, LEDs, protoboards e jumpers dis-
ponibilizados pelo professor, e a segunda etapa consistia em implementar o código na
bancada eletropneumática.
Nos esquemas que serão vistos a seguir o led representa o solenoide da valvula.
Capítulo 2. Materiais e Métodos 8

2.2.1 Comunicação Serial (Exercício 1)

As placas Arduino possuem pelo menos uma porta serial (também conhecida como
UART ou USART), chamada Serial. Ela comunica-se nos pinos digitais RX e TX como
também com um computador via USB. Logo, se você usar essas funções, você não pode
usar ao mesmo tempo os pinos RX e TX como entradas ou saídas digitais.
Você pode usar o monitor serial presente na IDE do Arduino para se comunicar
com uma placa Arduino. Comunicação serial nos pinos TX/RX usa níveis lógicos TTL
(5V ou 3.3V dependendo da placa).
O Arduino Uno em especifico é capaz de se comunicar serialmente pelas portas RX
e TX. Outros modelos de Arduino possuem mais portas de comunicação serial. Esse tipo
de comunicação envia dados sequencialmente pela porta TX e recebe dados sequenciais
pela porta RX. É possível configurar a velocidade de comunicação
Neste exercício foi proposto implementar um programa onde uma saída digital do
Arduino é acionada dado o comando ‘1’ enviado pelo monitor serial ou do acionamento do
botão. O cilindro deve recuar após o recebimento do comando ‘0’ (onde significa desligar
a válvula para o recuo do cilindro) ou após 4s. O programa também deverá escrever o
status do sensor fim de curso do cilindro, sendo A0 e A1, no Serial Monitor em intervalos
de tempos definidos de 3 em 3 segundos, independente se a saída digital estiver sendo
acionada. Caso o botão de avanço seja acionado antes do fim da contagem dos 4s o sistema
deve reiniciar a contagem.
O esquema da montagem pode ser visto a seguir.
Capítulo 2. Materiais e Métodos 9

Figura 2 – Comunicação Serial

Capítulo 2. Materiais e Métodos 10

2.2.2 Comunicação I2C do tipo Mestre-Escravo (Exercício 2)

I2C é a sigla de Inter-Integrated Circuit, e basicamente é um protocolo de co-
municação entre dispositivos que utilizam I2C. O I2C trabalha no modelo master-slave,
com pelo menos um dispositivo atuando como master, e os demais dispositivos atuando
como slave. A função do master é coordenar a comunicação, sendo que é ele quem envia
informações a determinado slave ou consulta informações.
O Arduino vem com pinos próprios para a conexão I2C, no caso do Uno e derivados
os pinos são o SDA e SCL. SDA significa Serial Data e SCL significa Serial Clock. SDA é
o pino que efetivamente transfere os dados, e SCL serve para temporização entre os
dispositivos, de modo que a comunicação pela SDA possa ter confiabilidade Como podemos
observar, tanto o envio quanto a recepção de dados são realizadas utilizando a linha SDA,
ou seja, é uma linha bidirecional de comunicação, ora estamos enviando dados por este
pino, ora estamos recebendo dados. Todo o trabalho com dispositivos I2C se resume a
uma operação de leitura ou uma operação de escrita.
O Exercício 2 possui o mesmo funcionamento do primeiro, acrescentando apenas a
funcionalidade de um botão de emergência que possui prioridade sobre o sistema, o que
significa que quando ele for pressionado o cilindro deve recuar imediatamente.
Nesse exercício um Arduino deve ser o mestre responsável pelo acionamento da
válvula enquanto que o outro deve ser o escravo que verificar o status dos sensores fim de
curso, botão de acionamento e botão de emergência e alerta o mestre quando solicitado
pelo mesmo.
O esquema da montagem pode ser visto a seguir.
Capítulo 2. Materiais e Métodos 11

Figura 3 – Comunicação I2C Mestre Escravo

Capítulo 2. Materiais e Métodos 12

2.2.3 Comunicação Ethernet (Exercício 3)

A Ethernet é uma tecnologia de rede capaz de agregar novas tecnologias em uma
comunicação compartilhada por um único cabo para todos os dispositivos da rede. Isso
permite que a rede se expanda para acomodar novos dispositivos sem ter de modificar os
dispositivos antigos.
O User Datagram Protocol (UDP) é um protocolo simples da camada de transporte.
Ele é descrito na RFC 768 e permite que a aplicação envie um datagrama encapsulado
num pacote IPv4 ou IPv6 a um destino, porém sem qualquer tipo de garantia que o
pacote chegue corretamente. O UDP também fornece os serviços de broadcast e multicast,
permitindo que um único cliente envie pacotes para vários outros na rede.
O funcionamento do sistema é o mesmo dos anteriores. O sistema consiste em fazer
uma montagem de uma rede no qual esta será utilizado dois Arduinos para o processo, em
que estes estarão equipados com shield Ethernet. Um dos Arduinos ficará responsável por
controlar a válvula enquanto o outro coletará os dados dos sensores do fim de curso e dos
botões de emergência e acionamento, e enviará a informações coletadas pela comunicação
Ethernet através do protocolo UDP.
O esquema da montagem pode ser visto a seguir.
Capítulo 2. Materiais e Métodos 13

Figura 4 – Comunicação Ethernet

Capítulo 2. Materiais e Métodos 14

2.2.4 Comunicação Wireless (Exercício 4)

ZigBee é um padrão que foi criado devido inexistência de uma solução normalizada
de como se operar com redes sem fios para fins como controle e telemetria, principalmente
nas áreas de automação industrial e residencial. O mesmo foi concebido com o enfoque de
se ter alta confiabilidade na transmissão de dados juntamente com baixo consumo, o que
justifica o fato deste não possuir largura de banda elevada. A base do padrão Wireless
Hart é o padrão ZigBee em redes industriais de campo. Existem três tipos pré-definidos
de módulos operacionais do ZigBee:

• Coordenadores (Coordinators): Estes são responsáveis por armazenar as informações

principais que caracterizam a rede, como endereço da rede, chaves de segurança e
outros aspectos. É importante ressaltar que existe apenas um coordenador para cada
rede.

• Roteadores (Routers): Estes são responsáveis por intermediar as informações entre

dispositivos, são comumente utilizados para estender a rede.

• Dispositivos de Fim (End Devices): Estes são os dispositivos utilizados no fim de

malha da rede, são conectados usualmente aos sensores e enviam suas informações
para os roteadores e coordenador da rede.

Os módulos XBee, são módulos RF (Rádio Frequência) que fazem comunicações

no padrão ZigBee IEEE 802.15.4. O Protocolo ZigBee permite comunicações robustas e
opera na freqüência ISM (Industrial, Scientific and Medical), sendo aqui no Brasil 2,4 GHz
(16 canais) e em outras partes do mundo, e não requerem licença para funcionamento.
As Redes ZigBee oferecem uma excelente imunidade contra interferências, e a
capacidade de hospedar milhares de dispositivos numa Rede (mais que 65.000), com
taxas de transferências de dados variando entre 20Kbps a 250Kbps. O Protocolo ZigBee
é destinado a aplicações industriais, portanto, o fator velocidade não é crítico numa
implementação ZigBee.
Os módulos RF padrão ZigBee foram criados para economizar o máximo de
energia possível. Com isso, é possível criar aplicações onde é possível ler sensores em
campo remotamente, apenas utilizando pilhas ou baterias comuns, que durarão meses ou
mesmo anos sem precisarem ser substituídas. Isso porque, os módulos ZigBee quando não
estão transmitindo/recebendo dados, entram num estado de dormência ou em "Sleep",
consumindo o mínimo de energia.
Para configurar o XBee, utilizou-se um cabo Cabo USB (Tipo A para Mini B) e o
software X-CTU. O X-CTU é um software criado pelo própio fabricante do XBee para
enviar comandos de configuração, fazer atualizações e outra diversas ferramentas para
Capítulo 2. Materiais e Métodos 15

configuração do XBee como definir um Router, End Device, nome da rede, entre outras
configurações.
O funcionamento continua igual aos anteriores, exceto por não ter o comando via
serial, nem a vizualização dos status dos sensores, pois o XBee faz uso dessa comunicação
com o Arduino. O exercício consiste em montar uma rede utilizando dois Arduinos,
equipados com shield XBee. Deve-se utilizar o modo API para comunicação entre os
mesmos.
O primeiro Arduino é responsável por ler o status dos fins de curso e dos botões e
implementar a lógica do funcionamento, enviando apenas o comando para o segundo se
ele deve ou não acionar a válvula.
O esquema da montagem pode ser visto a seguir.
Capítulo 2. Materiais e Métodos 16

Figura 5 – Comunicação Wireless

 17

3 Resultados Encontrados

Todos os códigos foram desenvolvidos no software Arduino IDE e se encontram no

Apêndice

3.1 Comunicação Serial

As principais funções usados em uma comunicação serial são:

• Serial.begin(taxa): define a taxa de transferência em bits por segundo.

• Serial.println(): imprime dados na porta serial como texto ASCII e pula uma linha.

• Serial.available(): pega o número de bytes (caracteres) disponíveis para leitura na

porta serial.

• Serial.read(): lê os dados que chegam na porta serial.

• Serial.write(): escreve dados binários na porta serial.

• Serial.flush(): espera a transmissão de dados acabar e limpa o buffer

O codigo utilizado pode ser visto no Apêndice A com comentarios sobre a utilização
de cada função que foi usada
O codigo desnvolvido conseguiu cumprir os requisitos requeridos pelo sistema.

3.2 Comunicação I2C do tipo Mestre-Escravo

O código foi dividido em duas partes, uma para o mestre e a outra para o escravo.
Abaixo encontra-se algumas funções da comunicação I2C que foram implementadas:

• Wire.requestFrom(endereço, 1): Este comando informa o dispositivo identificado por

endereço que queremos ler uma posição de memória (ou byte, ou registrador), a
partir da posição de memória especificada anteriormente. Esta informação é posta
imediatamente na linha SDA, e o dispositivo então responde informando também na
SDA o valor contido no registrador. Neste exemplo estamos pedindo apenas o valor
de um registrador, mas poderíamos pedir tantos quanto forem necessários. Neste
caso o dispositivo iria informar sequencialmente, a partir da posição informada pelo
write anterior.
Capítulo 3. Resultados Encontrados 18

• Wire.available(): Este comando verifica se há informação disponível para leitura. O

hardware do Arduino armazena em buffer as informações recebidas, e atualmente
este buffer tem o tamanho de 32 bytes com isso podemos fazer tranquilamente a
leitura de 32 bytes sequenciais.

• Wire.read(): Esta é bem simples, similar ao Serial.read. Basicamente este comando

lê um byte de cada vez. Alguns comandos para a escrita:

• Wire.beginTransmission(endereço): envia o endereço do dispositivo pela linha SDA,

sinalizando o dispositivo correspondente que haverá uma comunicação. Todos os
dispositivos “escutam” essa informação, mas apenas o dispositivo que possui o
endereço informado estará apto a se comunicar.

• Wire.write(memória): A maioria possui diversos registradores que podem ser gravados,

e precisamos informar em qual registrador queremos informação.

• Wire.write(valor): envia o valor (sempre 1 byte) pela SDA para o dispositivo infor-
mado anteriormente. O dispositivo possui um registrador (ou memória) aguardando
pela informação, e os outros dispositivos ignoram esta comunicação. O comum é
enviarmos uma informação (um byte) em cada operação.

• Wire.endTransmission(): Após enviarmos a informação, devemos finalizar a operação

com essa linha, liberando o dispositivo e o barramento I2C para novas operações.

A utilização dessas funções podem ser vistas no Apêndice B. Com o presente

codigo o sistema se comportou como o esperado. Entretanto foi feito um codigo com uma
abordagem diferente, onde os dados só seriam transmitidos se ocorresse uma interrupção,
para que o processador não fosse desperdiçado requisitando sempre os mesmos dados. O
processador ficava livre até que a primeira interrupção fosse causada, mas após isso não se
foi capaz de cessar a transmissão de dados, recaindo na abordagem usual, então essa nova
abordagem foi abandonada.

3.3 Comunicação Ethernet

Neste exercício o codigo foi dividido em duas partes novamente, uma para o emissor
e uma para o receptor. Encontrou se dificuldades na comunicação entre os dispositivos, o
protocolo UDP envia apenas informações do tipo char, a primeira tentativa de comunicação
foi enviar uma string com 4 caracteres, referentes as entradas do sistema, mas não se obteve
sucesso. Em uma segunda abordagem implementou se a lógica no dispositivo que capturava
as entradas e tentou se enviar uma variavel do tipo char com apenas um caractere mas
não se obteve sucesso tambem, então o codigo foi desenvolvido com a logica no emissor e
enviou se um caractere especifico e não uma variavel, que no caso foi ’1’ para avanço e ’0’
Capítulo 3. Resultados Encontrados 19

para recuo. O codigo pode ser observado no Apêndice C. Após as modificações o sistema
se comportou como o esperado.

3.4 Comunicação Wireless

Novamente o codigo foi dividido em emissor e receptor, semelhante as abordagens
anteriores, apesar do codigo ter sido revisto e não ter sido encontrado nenhuma incon-
sistência na programação não foi possível a implementação desse exercicio na bancada
eletropneumática. O erro não foi encontrado, mas podemos supor que tenha sido uma
configuração errada no setup dos dispositivos ou até algum erro de hardware que não foi
detectado. O codigo desenvolvido encontra se no Apêndice D.
 20

4 Conclusão

A comunicação serial é uma forma bastante utilizada devida a sua simplicidade,

tanto na construção que necessita apenas de um meio de comunicação e na sua transmissão
de dados pois ela envia um bit de cada vez, sequencialmente numm canal de comunicação
ou barramento, sendo bastante indicada para relés, válvulas e chaves. Uma desvantagem
dessa comunicação é ter uma menor velocidade de transmissão.
O barramento I2C permite a integração de circuitos com sensores e conversores
com um sistema de controle, de modo que eles possam trabalhar com seus sinais de
maneira direta. Ele possibilita comunicar com vários dispositivos utilizando poucos fios,
além de possibilitar que mais de um mestre controle os escravos e a a ligação com o
microcontrolador utilizando somente 2 fios, possibilitando a comunicação bidirecional.
A comunicação Ethernet é barata e de facil utilização, devido a sua grande difusão
na sociedade, ela funciona baseada em envio de pacotes, é necessário um controle para
gerenciar estas informações na Rede Ethernet, essa função é desempenhada pelo Switch.
Além de um baixo custo essa comunicação possui uma alta velocidade, e uma grande
confiabilidade e possui uma comunicação relativamente simples.
O ZigBee é um protocolo de rede sem fio, classificado como WPAN (redes pessoais
sem fio), possui uma infraestrutura de rede simples e baixo consumo de energia. Diferentes
dos demais padrões de redes sem fio, protocolos Wi-Fi e ao seu principal concorrente
o Bluetooth, ele possui baixas taxas de transmissão, o que possibilita a utilização de
baterias como fonte de alimentação.Além do baixíssimo consumo de energia, o ZigBee
possui também outras características peculiares a ele como o baixo custo, o uso de baterias
do tipo AA que podem durar até por 6 meses por conta do Duty circle que possibilita
esse baixo consumo de energia.A utilização de topologias de rede (mista, malha e arvore),
torna mais flexível com a possibilidade de ter 65000 nós, o modo de operação sleep que
o deixa em espera economizando energia e o uso do DSSS que o faz entrar em espera
sem perder a sincronização.Além de possuir um pequeno tempo de ligação e um rápida
transição para o modo de funcionamento, isso faz com que o ZigBee apresente um baixo
tempo de latência.Uma desvantagem do ZigBee são baixas taxas de transferência o que
mesmo para aplicações simplórias o inviabiliza em certas ações que precisam de um taxa
de transferência maiores aos que ele possui.
Esse módulo trouxe aos alunos o conhecimento basico necessário para a implemen-
tação de uma rede industrial fazendo uso de Arduinos, e uma maior familiarização com a
utilização e a programação de um Arduino. Como cada vez mais o custo de microprocessa-
dores abaixa, poderemos ver em um futuro próximo esse tipo de dispositivo, e os padrões
Capítulo 4. Conclusão 21

de comunicação abordados implementados em industrias, assim os alunos já estarão mais

bem preparados.
 22

Referências

[1] TAVARES JOSE JEAN-PAUL, Z. D. S. Laboratório I COMUNICAÇÃO ENTRE

DISPOSITIVOS. Uberlândia, MG, 2018.

[2] Disponível em: <https://www.arduino.cc/>.

 23

APÊNDICE A – Exercicio 1

1 const int bt1 = 2; // definindo o pino do botao

2 const int led = 8; // definindo a saida do led q representa
o acionamento do atuador
3 const int a0 = 3; // definindo o sensor do cilindro recuado
4 const int a1 = 4; // definindo o sensor do cliindro
avancado
5 int acionador = 0; // acionador que define se o botao foi
pressionado para o avanco ou para o recuo do atuador
6 int estadobt1 =1; //estado atual do botao utilizado como
auxilio na logica do acionador
7 int ultimoestadobt1 = 1 ; //ultimo estado do botao utilizado
na logica do acionador
8 char c; // Variavel do tipo char lida pelo monitor
Serial
9 unsigned long tempobaseretorno=0; //tempo base para o retorno
do atuador
10 const long retorno=4000; //tempo para o retorno do
atuador
11 unsigned long tempobasesensor=0; //tempo base para os
sensores
12 const long printsensor=3000; // tempo para informacao dos
sensores
13
14 void setup() {
15 // Definindo as entradas do botao e dos sensores como
INPUT_PULLUP
16 pinMode(bt1, INPUT_PULLUP);
17 pinMode(a0, INPUT_PULLUP);
18 pinMode(a1, INPUT_PULLUP);
19 pinMode(led,OUTPUT); //definindo o led como saida
20 digitalWrite (led, LOW); // Inicializando o led Apagado
21 Serial.begin(9600); //Iniciando a comunicacao Serial
22 }
23
 APÊNDICE A. Exercicio 1 24

24 void loop() {
25 //Iniico logica da ativacao pelo botao
26 estadobt1= digitalRead(bt1); //le o estado do botao
27 // Compara o estado atual do botao com o ultimo estado
28 if (estadobt1!= ultimoestadobt1){
29 // Verifica se o botao foi pressionado
30 if (estadobt1==LOW){
31 // Acrescenta o acionador
32 if(acionador==0){
33 acionador++;
34 tempobaseretorno=millis();
35 //decrementa o acionador
36 }else{
37 acionador--;
38 }
39 }
40 }
41 ultimoestadobt1=estadobt1;
42 // Fim da logica de ativacao pelo botao
43
44 //Inicia logica de ativacao pelo Monitor Serial
45 if (Serial.available()>0) { // Se receber algum valor pelo
serial monitor
46 c = Serial.read() - ’0’; // Le o numero e converte para
decimal
47 Serial.flush(); // espera completar a transmissao
dos dados e limpa o buffer
48 if(c==1) { // Se o valor lido for igual a 1
49 acionador=1; // Avanca o atuador
50 tempobaseretorno=millis(); // Se o atuador for acionado seta
o tempo para o retorno automatico
51 }
52 if(c==0) { //Se o valor lido for 0
53 acionador=0; //Recua o Atuador
54 }
55 }
56 // Fim da logica de ativacao pelo Monitor Serial
57
58 //Retorno apos 4s
 APÊNDICE A. Exercicio 1 25

59 if (millis()-tempobaseretorno>=retorno){
60 acionador=0;
61 }
62 //Acionamento do atuador
63 if (acionador==1){
64 digitalWrite(led,HIGH);
65 }
66 if (acionador==0){
67 digitalWrite(led,LOW);
68 }
69
70 //Print dos Sensores
71 if (millis()-tempobasesensor>=printsensor){
72 Serial.print("Sensor A0: ");
73 Serial.println(digitalRead(a0));
74 Serial.print("Sensor A1: ");
75 Serial.println(digitalRead(a1));
76 tempobasesensor=millis();
77 }
78 }
 26

APÊNDICE B – Exercicio 2

Codigo do escravo
1 #include<Wire.h>
2 #define bte 5 //definindo o pino do botao de emergencia
3 #define bt 2 //definindo o pino do botao
4 #define a0 3 //definindo o sensor do cilindro recuado
5 #define a1 4 //definindo o sensor do cilindro
avancado
6
7
8 void setup() {
9 Wire.begin(2); //Inica a biblioteca wire e define o endereco
do escravo
10 Wire.onRequest(com); //Registre uma funcao a ser chamada
quando um mestre solicitar dados deste dispositivo escravo.
11 pinMode( a0, INPUT_PULLUP);
12 pinMode( a1, INPUT_PULLUP);
13 pinMode( bt, INPUT_PULLUP);
14 pinMode( bte, INPUT_PULLUP);
15 }
16
17 void loop(){
18 }
19
20 void com(){ //funcao a ser chamada
21 char buf[4];
22 buf[0] = digitalRead(bte); // le o botao
23 buf[1] = digitalRead(bt); // le o sensor A0
24 buf[2] = digitalRead(a0); // le o sensor A1
25 buf[3] = digitalRead(a1); // le o botao de emergencia
26 Wire.write (buf, 4); // Envia o estados dos
sensores e do botao para o mestre
27 }
 APÊNDICE B. Exercicio 2 27

Codigo do Mestre
1 #include <Wire.h>
2 #define led 8
3 int bt,bte,a0,a1,ultestbt,ultestbte,acionador;
4 char c=0;
5 unsigned long tempobaseretorno=0; //tempo base para o retorno
do atuador
6 const long retorno=4000; //tempo para o retorno do
atuador
7 unsigned long tempobasesensor=0; //tempo base para os
sensores
8 const long printsensor=3000; // tempo para informacao dos
sensores
9
10 void setup() {
11 Wire.begin(); //Inica a biblioteca wire e define o
disposiivo como mestre
12 Serial.begin(9600); //Iniciando a comunicacao Serial
13 pinMode(led, OUTPUT); // define o led como saida
14 }
15
16 void loop() {
17 Wire.requestFrom(2,4); //Requisita 4 bytes do escravo 2
18 while (Wire.available()) { //Leitura dos dados enviados pelo
escravo
19 bte=Wire.read();
20 bt = Wire.read();
21 a0 = Wire.read();
22 a1 = Wire.read();
23 }
24 //Iniico logica da ativacao pelo botao
25 // Compara o estado atual do botaocom o ultimo estado
26 if (bt != ultestbt){
27 // Verifica se o botaofoi pressionado
28 if (bt==0){
29 acionador=1;
30 tempobaseretorno=millis(); // Se o atuador for acionado
seta o tempo para o retorno automatico
31 }
 APÊNDICE B. Exercicio 2 28

32 }
33 ultestbt=bt;
34 // Fim da logica de ativacao pelo botao
35
36 //Iniico logica da ativacao pelo botao de emergencia
37 // Compara o estado atual do botaocom o ultimo estado
38 if (bte != ultestbte){
39 // Verifica se o botao foi pressionado
40 if (bte==0){
41 acionador=0;
42 }
43 }
44 ultestbte=bte;
45 // Fim da logica de ativacao pelo botaode emergencia
46
47 //Inicia logica de ativacao pelo Monitor Serial
48 if (Serial.available()>0) { // Se receber algum valor pelo
serial monitor
49 c = Serial.read() - ’0’; // le o numero e converte para
decimal
50 Serial.flush(); // espera completar a transmissao
dos dados e limpa o buffer
51 if(c==1) { // Se o valor lido for igual a 1
52 acionador=1; // Avanca o atuador
53 tempobaseretorno=millis(); // Se o atuador for acionado seta
o tempo para o retorno automatico
54 }
55 if(c==0) { //Se o valor lido for 0
56 acionador=0; //Recua o Atuador
57 }
58 }
59 // Fim da logica de ativacao pelo Monitor Serial
60
61
62 if (acionador==1){ //Aciona o Atuador
63 digitalWrite(led,HIGH);
64 }
65 if (acionador==0){ // Recua o Atuador
66 digitalWrite(led,LOW);
 APÊNDICE B. Exercicio 2 29

67 }
68 if(millis()-tempobaseretorno>=retorno){ //Recuo automatico do
atuador
69 digitalWrite(led,LOW);
70 }
71 }
 30

APÊNDICE C – Exercicio 3

Codigo do Emissor
1 #include <SPI.h>
2 #include <Ethernet.h>
3 #include <EthernetUdp.h>
4 #define btee 5 //definindo o pino do botao de
emergencia
5 #define btt 2 //definindo o pino do botao
6 #define a00 3 //definindo o sensor do cilindro
recuado
7 #define a11 4 //definindo o sensor do cilindro
avancado
8
9 EthernetUDP Udp;
10 byte mac[]={0x90,0xA2,0xDA,0x00,0x64,0x44};
11 byte ip[]={192,168,1,200};
12 byte remoteip[]={192,168,1,80};
13 char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
14 unsigned int port =8888;
15 int bt=0;
16 int bte=1;
17 int a1=1;
18 int a0=0;
19 int ultestbt,ultestbte,ultesta1;
20 char acionador;
21 unsigned long tempobaseretorno=0; //tempo base para o retorno
do atuador
22 const long retorno=4000; //tempo para o retorno do
atuador
23 bool flag=false;
24 void setup (){
25 Ethernet.begin(mac,ip);
26 Udp.begin(port);
27 Serial.begin(9600);
28 pinMode( a00, INPUT_PULLUP);
29 pinMode( a11, INPUT_PULLUP);
 APÊNDICE C. Exercicio 3 31

30 pinMode( btt, INPUT_PULLUP);

31 pinMode( btee, INPUT_PULLUP);
32 }
33
34 void loop(){
35 bte = digitalRead(btee); // le o botao
36 bt = digitalRead(btt); // le o sensor A0
37 a0 = digitalRead(a00); // le o sensor A1
38 a1 = digitalRead(a11); // le o botao de emergencia
39
40 // Compara o estado atual do botao com o ultimo estado
41 if (bt != ultestbt){
42 // Verifica se o botao foi pressionado
43 if (bt==1){
44 Udp.beginPacket(remoteip, port);
45 Udp.write(’1’);
46 Udp.endPacket();
47 tempobaseretorno=millis();
48 }
49 }
50 ultestbt=bt;
51
52 if (a1 != ultesta1){
53 // Verifica se o botao foi pressionado
54 if (a1==1){
55 tempobaseretorno=millis();
56 flag=true;
57 }
58 }
59 ultesta1=a1;
60
61 if((millis()-tempobaseretorno>retorno)&&(flag)){
62 Udp.beginPacket(remoteip, port);
63 Udp.write(’0’);
64 Udp.endPacket();
65 flag=false;
66 }
67 }
 APÊNDICE C. Exercicio 3 32

Codigo do Receptor
1 #include <SPI.h>
2 #include <Ethernet.h>
3 #include <EthernetUdp.h>
4 #define led 8
5
6 EthernetUDP Udp;
7 byte mac[]={0x90,0xA2,0xDA,0x00,0x64,0x50};
8 byte ip[] = {192,168,1,80};
9 unsigned int port = 8888;
10 char acionador=0;
11 char c=0;
12 char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
13
14 void setup(){
15 Ethernet.begin(mac,ip);
16 Udp.begin(port);
17 Serial.begin(9600);
18 pinMode( led, OUTPUT);
19 }
20
21 void loop(){
22 int packetSize = Udp.parsePacket();
23 if (packetSize){
24 Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
25 acionador=packetBuffer[0];
26 }
27 if(packetBuffer[0] == ’1’){
28 digitalWrite(led,HIGH);
29 }
30 if(packetBuffer[0] == ’0’){
31 digitalWrite(led,LOW);
32 }
33
34 if (Serial.available()>0) { // Se receber algum valor pelo
serial monitor
35 c = Serial.read() - ’0’; // Le o numero e converte para
decimal
36 Serial.flush(); // espera completar a transmissao dos dados
 APÊNDICE C. Exercicio 3 33

e limpa o buffer
37 if(c==1) { // Se o valor lido for igual a 1
38 digitalWrite(led,HIGH); // Coloca o pino 8 como nivel logico
alto
39 }
40 if(c==0) { // Se o valor lido for igual a 0
41 digitalWrite(led,LOW); // Coloca o pino 8 como nivel logico
baixo
42 }
43 }
44 }
 34

APÊNDICE D – Exercicio 4

Codigo do Emissor
1 #include <XBee.h>
2 XBee xbee = XBee();
3 XBeeAddress64 add64 = XBeeAddress64(0x0013A200, 0x40B8F669);
4 uint8_t payload[1] ;
5 #define btt 2 //definindo o pino do botao
6 #define a00 3 //definindo o sensor do cilindro
recuado
7 #define a11 4 //definindo o sensor do cilindro
avancado
8
9 int bt=0;
10 //int bte=1;
11 int a1=1;
12 int a0=0;
13 int ultestbt,ultestbte,ultesta1;
14 char acionador;
15 unsigned long tempobaseretorno=0; //tempo base para o retorno
do atuador
16 const long retorno=4000; //tempo para o retorno do
atuador
17 bool flag=false;
18
19 void setup (){
20 Serial.begin(9600);
21 xbee.setSerial(Serial);
22
23 pinMode( a00, INPUT_PULLUP);
24 pinMode( a11, INPUT_PULLUP);
25 pinMode( btt, INPUT_PULLUP);
26 //pinMode( btee, INPUT_PULLUP);
27
28 }
29
30 void loop(){
 APÊNDICE D. Exercicio 4 35

31 bt = digitalRead(btt); // le o sensor A0
32 a0 = digitalRead(a00); // le o sensor A1
33 a1 = digitalRead(a11); // le o botao de emergencia
34
35 // Compara o estado atual do botao com o ultimo estado
36 if (bt != ultestbt){
37 // Verifica se o botao foi pressionado
38 if (bt==1){
39 payload[0]=’a’;
40 ZBTxRequest data = ZBTxRequest(add64, payload, sizeof(
payload));
41 xbee.send(data);
42 tempobaseretorno=millis();
43 }
44 }
45 ultestbt=bt;
46
47 if (a1 != ultesta1){
48 // Verifica se o botao foi pressionado
49 if (a1==1){
50 tempobaseretorno=millis();
51 flag=true;
52 }
53 }
54 ultesta1=a1;
55
56 if((millis()-tempobaseretorno>retorno)&&(flag)){
57 payload[0]=’r’;
58 ZBTxRequest data = ZBTxRequest(add64, payload, sizeof(
payload));
59 xbee.send(data);
60 flag=false;
61 }
62 }
 APÊNDICE D. Exercicio 4 36

Codigo do Receptor
1 #include <XBee.h>
2 XBee xbee = XBee();
3 ZBRxResponse rx = ZBRxResponse();
4 #define led 8
5
6 void setup(){
7 xbee.setSerial(Serial);
8 Serial.begin(9600);
9 pinMode( led, OUTPUT);
10 }
11
12 void loop(){
13 uint8_t resposta;
14 xbee.readPacket();
15 if (xbee.getResponse().isAvailable()) {
16 if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) {
17 xbee.getResponse().getZBRxResponse(rx);
18 resposta = rx.getData(0);
19 }
20 }
21
22 if(resposta == ’a’){
23 digitalWrite(led,HIGH);
24 }
25 if(resposta == ’r’){
26 digitalWrite(led,LOW);
27 }
28 }