Embed Size (px)
Citation preview
UNIVERSIDADE FEDERAL DA BAHIA
ESCOLA POLITÉCNICA
CURSO DE GRADUAÇÃO EM ENGENHARIA DE
COMPUTAÇÃO
Sistema Microprocessado para Interface entre um
Robô Lego e um Sistema Supervisório C++
PAULO HENRIQUE ALVES FERREIRA
Salvador – Bahia
2016
ii
PAULO HENRIQUE ALVES FERREIRA
Trabalho de Conclusão de Curso
Sistema Microprocessado para Interface entre um
Robô Lego e um Sistema Supervisório C++
Monografia elaborada pelo acadêmico
Paulo Henrique Alves Ferreira como parte
das exigências para obtenção do título de
Engenheiro de Computação pela
Universidade Federal da Bahia, sob
orientação do Professor Dr. André
Gustavo Scolari Conceição.
Salvador – Bahia
2016
iii
PAULO HENRIQUE ALVES FERREIRA
Sistema Microprocessado para Interface entre um
Robô Lego e um Sistema Supervisório C++
Este Trabalho de Conclusão de Curso foi julgado adequado para obtenção do
título de Engenheiro de Computação e Aprovado em sua forma final pela
Comissão Examinadora e pelo Colegiado do Curso de Engenharia de
Computação da Universidade Federal da Bahia.
__________________________________ Prof. Dr. Eduardo Furtado de Simas Filho
Coordenador do Colegiado do Curso de Engenharia de Computação
__________________________________ Prof. Dr. André Gustavo Scolari Conceição
Orientador – DEE/UFBA
__________________________________ Prof. Dr. Bernardo Ordoñez
Avaliador Interno – DEE/UFBA
__________________________________ Prof. Dr. Eduardo Furtado de Simas Filho
Avaliador Interno – DEE/UFBA
iv
Dedicatória
A todos aqueles qυе dе alguma forma
estiveram е estão próximos dе mim,
fazendo está vida valer cada vеz mais
а pena.
v
Agradecimentos
vi
Resumo
O robô LEGO EV3 adota os conceitos de robôs modulares, capazes de
modificar sua estrutura física e adicionar a eles novos componentes, como por
exemplo motores e sensores. Porém, o robô EV3 tem limitações em termo de
comunicação com dispositivos que não fazem parte da família LEGO. Dessa
forma, não é possível conecta-lo diretamente a um sistema supervisório que
não seja o do LEGO ou licenciados pelo, como por exemplo o Matlab, tendo
que buscar outras alternativas. Este trabalho tem por objetivo o
desenvolvimento de um sistema microprocessado para realizar o
interfaceamento entre o robô EV3 a um sistema supervisório, utilizando um
microcontrolador Arduino UNO. Para esse interfaceamento o barramento I2C
foi utilizado para realizar a comunicação entre o robô EV3 e o Arduino e a serial
entre o Arduino e o computador. Resultados do desenvolvimento e testes
experimentais serão apresentados, mostrando o desempenho do sistema
desenvolvido.
Palavras-chave: Robô Modular, LEGO MINDSTORMS EV3, Comunicação
I2C, Arduino UNO, Controlador de Velocidade PID
vii
Abstract
The robot LEGO EV3 adopts the modular concepts of robots able to modify
their physical structure and to add new components such as motors and
sensors. However, EV3 has limitations in communication with other
components that are not part of LEGO family. Thus, you cannot connect it
directly to a supervisory system C ++ that do not be of the LEGO, having to
seek other alternatives. This study aims to develop a microprocessor system to
perform the interface between the robots LEGO EV3 to a supervisory system
using an Arduino UNO microcontroller. To this interface, the I2C bus was used
for communication between the EV3 and the Arduino. Development results and
experimental tests will be presented, showing the performance of the developed
system.
Keywords: Modular Robot, LEGO MINDSTORMS EV3, I2C communication,
Arduino UNO, PID Speed Control
viii
Lista de Figuras
Figura 1. Diagrama de Blocos do Barramento I2C ............................................................... 4
Figura 2. Ilustração dos sinais que ativam as condições de START e STOP .................. 5
Figura 3. Diagrama da escrita de dados ................................................................................. 7
Figura 4. Diagrama da leitura de dados .................................................................................. 8
Figura 5. Fotografia do Robô LEGO MINDSTORMS EV3 ................................................... 9
Figura 6. Fotografia do Bloco Programável .......................................................................... 10
Figura 7. Fotografia das portas de entradas e saídas do Bloco Programável ................ 10
Figura 8. Fotografia do motor Grande (dir.) e Motor Médio (esq.).................................... 11
Figura 9. Diagrama de Blocos ................................................................................................ 13
Figura 10. Esquemático da comunicação entre o EV3 e o Arduino UNO ....................... 14
Figura 11. Diagrama de Blocos representando o fluxo do Módulo de Controle de
Velocidade ................................................................................................................................. 15
Figura 12. Diagrama de Blocos representando o fluxo do Módulo de Leitura/Escrita de
Dados ......................................................................................................................................... 17
Figura 13. Imagem do Bloco I2C modo leitura de 8 bytes ................................................. 18
Figura 14. Diagrama de Blocos que representa a lógica do firmware ............................. 22
Figura 15. Gráficos dos resultados obtidos .......................................................................... 25
Figura 16. Gráfico de velocidade da roda direita................................................................. 26
Figura 17. Gráfico de velocidade da roda esquerda ........................................................... 26
ix
Lista de Tabelas
Tabela 1. Comparativo entre as gerações de robôs da família LEGO ............................ 12
x
Lista de Siglas
LaR: Laboratório de Robótica
SCADA: Supervisory Control & Data Acquisition Systems
I2C: Inter-Integrated Circuit
SDA: Serial Data
SCL: Serial Clock
ACK : Acknowledgement
LSB: Least Significant Bit
MSB: Most Significant Bit
RPM: Rotações por minuto
Ncm: Newton Centímetro
GND: Terra
PI: Proporcional Integral
IDE: Ambiente de Desenvolvimento Integrado
ROS: Robot Operating System
xi
Sumário
Dedicatória ................................................................................................................................. iv
Resumo ....................................................................................................................................... vi
Abstract ...................................................................................................................................... vii
Lista de Figuras ...................................................................................................................... viii
Lista de Tabelas ........................................................................................................................ ix
Lista de Siglas ............................................................................................................................x
1. Introdução .......................................................................................................................... 1
1.1. Objetivo Geral............................................................................................................ 2
1.2. Objetivos Específicos ............................................................................................. 2
1.3. Justificativa ................................................................................................................ 2
1.4. Estrutura do Texto ................................................................................................... 3
2. Fundamentação Teórica ................................................................................................. 3
2.1. Comunicação I2C ..................................................................................................... 3
2.1.1. Barramento I2C ................................................................................................. 4
2.1.2. Condições de Start e Stop ............................................................................. 4
2.1.3. Formato e Reconhecimento dos Dados ..................................................... 5
2.1.4. Formato de Transmissão ............................................................................... 6
2.1.4.1. Escrita .......................................................................................................... 6
2.1.4.2. Leitura .......................................................................................................... 7
3. Robô LEGO MINDSTORMS EV3 ................................................................................... 8
3.1. Blocos do EV3 ........................................................................................................... 9
3.1.1. Bloco Programável .......................................................................................... 9
3.2. Motores ..................................................................................................................... 10
3.3. Sensores ................................................................................................................... 11
3.4. Software .................................................................................................................... 11
3.5. Comparação com as versões anteriores ......................................................... 12
xii
4. Desenvolvimento ............................................................................................................ 13
4.1. Preparativo para a Comunicação I2C ............................................................... 13
4.2. Programação do LEGO EV3 ................................................................................ 14
4.2.1. Módulo de Controle de Velocidade ........................................................... 15
4.2.1.1. Cálculo do Erro ....................................................................................... 16
4.2.1.2. Controlador de Velocidade PI ............................................................. 16
4.2.2. Módulo de Leitura/Escrita de Dados ......................................................... 17
4.2.2.1. Bloco I2C .................................................................................................. 18
4.2.2.2. Recebimento ............................................................................................ 19
4.2.2.3. Envio .......................................................................................................... 19
4.3. Programação do Arduino ..................................................................................... 21
4.3.1. Barramento I2C ............................................................................................... 21
4.3.2. Estrutura do firmware ................................................................................... 22
5. Resultados ....................................................................................................................... 24
6. CONCLUSÃO ................................................................................................................... 27
Referências .............................................................................................................................. 28
Anexo A ..................................................................................................................................... 29
Anexo B ..................................................................................................................................... 30
Anexo C ..................................................................................................................................... 31
Anexo D ..................................................................................................................................... 32
Anexo E ..................................................................................................................................... 33
Anexo F ..................................................................................................................................... 34
Anexo G .................................................................................................................................... 35
Anexo H ..................................................................................................................................... 36
1
1. Introdução
Nas últimas décadas houve um grande aumento na presença dos computadores na
vida das pessoas, tanto para o auxílio em atividades simples do dia a dia, exemplos
como eletrodomésticos inteligentes e pequenos robôs domésticos, como em
atividades complexas em diversas áreas de atuação (áreas industriais, de saúde,
etc.). Essas aplicações impulsionam o desenvolvimento tecnológico em todas as
áreas de conhecimento humano. Os sistemas microprocessados estão presentes na
grande maioria dessas aplicações, sendo definidos como uma combinação de
hardware e software para executar uma função específica. Um sistema
microprocessado na maioria das vezes está dentro de um sistema maior onde
contém outros sistemas microprocessados, no qual podemos tomar como exemplo
um automóvel, onde se encontra um sistema para o controle do ABS, para exibição
de informações no painel, entre outros (MICHAEL BARR, 2006).
Hoje, a grande quantidade de processos automatizados, existentes nos mais
diversos meios, motiva a utilização de sistemas supervisórios chamados SCADA
(Supervisory Control & Data Acquisition Systems), o qual permitem o monitoramento
do processo em tempo real. O uso de sistemas SCADA, interligados a outras
ferramentas, tende a facilitar o processo de desenvolvimento, sendo que as
informações fornecidas pelo modelo de análise podem ser reaproveitadas no
sistema de supervisão. Hoje é possível a implementação desses sistemas
supervisórios em diversos segmentos, desde sistemas de alarmes, robótica,
hospitais e muitos processos industriais (LUÍS AUGUSTO JURIZATO, 2003)
Devido à restrições de algumas plataformas não é possível realizar a implementação
de um sistema supervisório, podendo mencionar como um exemplo o robô LEGO
MINDSTORMS EV3. Hoje, no Laboratório de Robótica (LaR), somente é possível
realizar a comunicação direta entre o computador e o LEGO EV3 utilizando o
MATLAB ou o LEGO MINDSTORMS EV3 Software, dessa forma trazendo limitações
em aplicações de tempo real. Contando com a importância de um sistema
2
supervisório desenvolvido em outras plataformas como, por exemplo, o ROS (Robot
Operating System), torna-se motivador o desenvolvimento de uma interface visando
estabelecer uma comunicação entre o LEGO EV3 e este sistema.
1.1. Objetivo Geral
Este projeto tem por objetivo o desenvolvimento de um sistema microprocessado
com base no Arduino, a fim de realizar a conexão entre um robô LEGO EV3 e um
computador, assim possibilitando conectá-lo a um sistema supervisório e de controle
de propósito geral C++.
1.2. Objetivos Específicos
Para alcançar o objetivo geral desse projeto deve-se focar nos seguintes pontos:
Adaptar componentes e desenvolver uma rotina para estabelecer a
comunicação I2C entre o robô e o Arduino
Estabelecer a estrutura dos pacotes de dados que serão enviados e
recebidos entre o robô, o Arduino e o computador
Programar o robô LEGO EV3, importando um bloco I2C na IDE da LEGO,
para a comunicação
Implementar o firmware do Arduino para a conexão entre as partes
Realizar testes de validação para checar a confiabilidade da comunicação
1.3. Justificativa
O Laboratório de Robótica (LaR) da Universidade Federal da Bahia (UFBA) possui
uma variedade de robôs à disposição para projetos de pesquisas, onde alguns
destes robôs contém limitações e dessa forma dificultando a fase de
desenvolvimento dos projetos. Sendo assim, se tornou interessante expandir as
3
funcionalidades e romper as limitações do robô LEGO EV3 servindo como uma
plataforma alternativa de desenvolvimento para aplicações no qual estão restritos às
limitações de suas plataformas. A limitação que se deseja romper, para esse projeto,
é da comunicação do LEGO EV3 com um sistema supervisório, utilizando um
Arduino UNO.
1.4. Estrutura do Texto
Na seção 2, será apresentada a teoria do protocolo utilizado neste trabalho para o
estabelecimento da comunicação entre o Arduino e o Robô LEGO EV3. Na seção 3
será apresentado brevemente o robô LEGO MINDSTORMS EV3. Neste caso, o robô
e sua estrutura modular, motores, sensores, etc. Na seção 4 será mostrado a etapa
de desenvolvimento, as implementações e a sua lógica. Na seção 5 serão discutidos
os principais resultados obtidos. Por fim, na seção 6, se encontra as conclusões
alcançadas durante o desenvolvimento do trabalho.
2. Fundamentação Teórica
2.1. Comunicação I2C
Essa comunicação foi desenvolvida pela Philips e se chama Inter-Integrated Circuit,
ou I2C, e possibilita a utilização de uma grande quantidade de dispositivos, os quais
juntos podem realizar diversas funções, além da troca de informações entre eles. O
objetivo do I2C é facilitar a integração de circuitos, como sensores, com um sistema
de controle de modo que eles possam trabalhar com os dados de maneira direta.
O I2C trabalha seguindo o modelo master-slave, com pelo menos um dispositivo
atuando como master e os demais dispositivos atuando como slave. Nesse modelo
a função do master é coordenar a comunicação, assim sendo o master quem envia
informações a um determinado slave ou quem requisita uma informação de um
4
determinado slave. Se pode ter mais de um master em uma comunicação I2C e até
127 dispositivos slave.
2.1.1. Barramento I2C
Uma característica importante do barramento I2C, mostrado na Figura 1, é a
possibilidade de usar componentes de tecnologias diferentes em um mesmo
sistema, sem que ocorra incompatibilidade. No I2C a transmissão dos dados entre
os dispositivos é feita através de dois fios, Serial Data (SDA) e Serial Clock (SCL).
Cada um dos dispositivos conectados no barramento recebe um endereço
específico fixo. O barramento é do tipo multi-master, no qual mais de um dispositivo
de controle pode ser conectado ao barramento, porém durante a comunicação
somente um dos mestres pode estar ativo, ao contrário ocorrerá uma colisão de
dados.
Figura 1. Diagrama de Blocos do Barramento I2C
Os fios SDA e SCL são bidirecionais e devem ser ligadas ao positivo da alimentação
através de uma fonte de corrente ou de um resistor pull-up, para a garantia de que
ambos os fios permaneçam em nível alto quando o barramento estiver livre. Outra
característica do I2C é que a frequência de transmissão não é fixa, ela é
determinada pelo master do barramento pelo fio SCL. Logo o SDA é o responsável
pela transferência de dados e o SCL é o responsável pela temporização.
2.1.2. Condições de Start e Stop
5
A comunicação entre os dispositivos master e slaves é iniciada pela condição de
START e finalizada pela condição de STOP. Uma transição de nível alto para baixo
no fio SDA, enquanto o fio SCL está no nível alto, é um indicativo da condição de
START. Já uma transição do nível baixo para o nível alto da linha SDA enquanto a
linha SCL se mantém no nível alto, define uma condição de STOP, ambas as
transições estão representadas na Figura 2. Sempre o master é responsável por
essas condições. Após a condição de START o barramento fica no status de
ocupado, e apenas volta a ficar livre um tempo depois da condição de STOP.
Figura 2. Ilustração dos sinais que ativam as condições de START e STOP
2.1.3. Formato e Reconhecimento dos Dados
Os dados enviados pelo fio SDA devem ter comprimento de um byte. O número de
bytes que pode ser transferido em cada operação de transferência é limitado,
enviando primeiramente o bit mais significativo. Caso o dispositivo de destino não
puder receber os dados ele altera o fio SCL, colocando no nível baixo, dessa forma
força o master a entrar no estado de espera e somente quando o fio estiver
novamente livre a transferência dos dados poderá continuar.
Após a escrita / leitura de um byte no barramento, o dispositivo receptor irá gerar um
bit de reconhecimento. Esse bit de reconhecimento irá permitir a continuidade da
transferência dos dados. O reconhecimento dos dados transferidos é obrigatório. O
6
fio SDA do receptor é colocado em nível baixo durante o pulso de clock de modo
que ele permaneça estável no nível baixo durante o período alto do pulso de clock.
2.1.4. Formato de Transmissão
O transmissor master envia os sinais para um receptor slave, de acordo com as
seguintes etapas:
I. A transmissão é iniciada pelo master através de um bit de START.
II. É enviado o endereço físico do slave que está conectado ao barramento I2C.
O bit LSB desse endereço (R/W) informa se a operação é de leitura ou escrita
da memória.
III. Logo após a recepção do endereço o slave envia um bit de reconhecimento
(ACK) na linha SDA, informando para o master que está pronto para receber
os dados.
IV. O master envia os dados para o slave. A confirmação de recebimento de
cada byte é fornecida pelo bit ACK enviado pelo escravo.
V. O master envia a condição de STOP ao finalizar a comunicação.
2.1.4.1. Escrita
O processo de escrita, demonstrado na figura 3, segue as etapas de transmissão,
mas é adicionado o envio do endereço do registrador do slave no qual será gravado
o dado. Os bits de reconhecimento de dados ACK são gerados pelo slave (receptor).
Assim sendo:
I. Envio do bit de início da comunicação (START).
II. Envio do byte com o endereço físico do slave, sendo o bit LSB nível BAIXO
(esse bit representa a condição de escrita/leitura, e o nível baixo determina a
condição de escrita).
III. Envio do endereço do registrador do slave no qual o dado será gravado.
IV. Envio dos dados (bytes).
7
V. Envio do bit de finalização da comunicação (STOP).
Figura 3. Diagrama da escrita de dados
Nesse processo os bits de reconhecimento de dados ACK são gerados pelo slave
(receptor).
2.1.4.2. Leitura
Nesse processo de leitura, demonstrado na Figura 4, os bits de reconhecimento de
dados são gerados pelo master (receptor). Assim sendo:
I. Envio do bit de início da comunicação (START).
II. Envio do byte com o endereço físico do slave, sendo o bit LSB nível BAIXO
(escrita).
III. Envio do endereço do registrador do slave no qual o dado será lido.
IV. Novamente é enviado o bit de início da comunicação (START).
V. Novamente é enviado o byte com o endereço físico do slave, sendo o bit LSB
nível ALTO (leitura).
VI. É realizado a leitura dos dados do registrador da etapa 3. A cada byte lido o
master envia uma confirmação de recebimento de dado ACK.
VII. O master informa o fim da comunicação após ler os dados através do bit
NOACK e finaliza com o bit STOP.
8
Figura 4. Diagrama da leitura de dados
Maiores detalhes sobre o padrão I2C podem ser vistos na referência (BUS).
3. Robô LEGO MINDSTORMS EV3
Nessa seção será brevemente apresentado o robô LEGO MINDSTORMS EV3 e
seus principais componentes. Em 1998, a LEGO inaugurou a linha de brinquedos
inteligentes com o modelo LEGO MINDSTORMS. Os kits contêm peças tradicionais
de blocos de construção da marca adaptadas para o encaixe de engrenagens,
sensores e motores que podem ser controlados por um processador programável,
transformado o brinquedo em uma espécie de robô. O EV3 é a 3ª geração da linha
de brinquedos inteligentes LEGO MINDSTORMS e é possível monta-lo de forma
que atenda as especificações físicas de uma determinada aplicação, se tornando
bastante versátil. Para esse projeto, o robô EV3 foi montado utilizando somente o
Bloco Programável e os dois motores grandes, como mostrado na Figura 5. Como
informativo, nessa seção serão mencionados brevemente outros componentes da
família LEGO.
9
Figura 5. Fotografia do Robô LEGO MINDSTORMS EV3
3.1. Blocos do EV3
Seguindo o conceito dos Robôs Modulares, o EV3 é constituído por blocos
classificados em motores e sensores. Esses blocos são conectados a um Bloco
Programável, onde são processadas as informações captadas pelos sensores e, de
acordo com as necessidades, são enviados comandos para os motores. A
comunicação entre o Bloco Programável e seus motores e sensores é feita através
do protocolo I2C.
3.1.1. Bloco Programável
O Bloco Programável EV3, mostrado na Figura 6, funciona como uma central de
controle e estação de energia para os motores e sensores do robô. É possível
programar tanto conectando-o ao computador como pelo display e botões do próprio
bloco, utilizando uma interface construída em cima do Sistema Operacional Linux.
Possui um processador ARM9 de 300MHz, tendo 16 MB de memória flash para
armazenamento e 64 MB de memória RAM. O display é de LCD monocromático de
178x128 pixel.
10
Figura 6. Fotografia do Bloco Programável
O Bloco Programável contém oito portas, sendo quatro de entradas e quatro de
saídas. As portas de entradas identificadas por números de 1 a 4 são destinadas
aos sensores, enquanto as quatro portas de saídas identificadas por ledas de “A” a
“D” são destinadas aos motores, como mostrado na Figura 7.
Figura 7. Fotografia das portas de entradas e saídas do Bloco Programável
3.2. Motores
O EV3 contém dois motores, como mostra a Figura 10, onde são classificados por
grande e médio.
O Motor Grande, como o nome já diz, é maior e mais forte que o Motor Médio.
É utilizado como para ser a base motriz do robô. Funciona entre 160 a 170
rpm, com torque de funcionamento de 20Ncm e um torque neutro de 40Ncm.
O Motor Médio por ser mais leve e menor que o Motor Grande tem um tempo
de resposta menor. Funciona entre 240 a 250 rpm, com um torque de
funcionamento de 8Ncm e um toque neutro de 12Ncm.
11
Dessa forma podemos observar que o Motor Grande é mais lento que o Motor
Médio, porém mais forte. Ambos contêm um sensor de rotação embutido, com
resolução de 1 grau. Para esse projeto foi utilizado somente dois Motores Grandes.
Figura 8. Fotografia do motor Grande (dir.) e Motor Médio (esq.)
3.3. Sensores
Os sensores disponíveis para uso são:
Sensor de Toque: Pressionado / Não pressionado.
Sensor de Cor: Detecta 7 cores (preto, azul, verde, amarelo, vermelho, branco
e marrom), além da ausência de cor.
Sensor Ultrassom: É capaz de medir distâncias entre 3 e 250cm, com
exatidão de +/- 1 cm.
Giroscópio: Mede ângulos com exatidão de +/- 3° a cada giro de 90°.
3.4. Software
O software utilizado para programar o robô EV3 é o LEGO MINDSTORMS EV3
Software, que contém uma interface os, onde são ordenados por:
Blocos de Ação: categoria no qual tem os controles dos motores, da emissão
de sons e das luzes de estado do bloco programável.
Blocos de Fluxo: categoria no qual estão disponíveis blocos que tem função
de controlar o fluxo do programa, determinando o ponto de início do fluxo ou
loops, assim como suas condições de parada.
12
Blocos de Sensores: categoria no qual estão disponíveis blocos para leitura
dos sensores, estando disponível também a leitura dos motores.
Blocos de Dados: categoria no qual contém os blocos para tratamento dos
dados, como instanciar variáveis, ou determinar constantes, para realizar
operações aritméticas ou comparar valores, etc.
Blocos Avançados: categoria no qual contém blocos para manipulação de
arquivos, envios de mensagens, controle da conexão Bluetooth, interrupção
do programa, etc.
Blocos Personalizados: categoria no qual é possível criar um bloco contendo
outros blocos visando evitar assim repetições de um determinado grupo de
blocos.
O programa é construído a partir das ligações entre os blocos das categorias já
citadas.
3.5. Comparação com as versões anteriores
Desde que foi criado em 1998 o LEGO MINDSTORMS evoluiu ao longo dos anos,
tanto em hardware quanto em software. Abaixo segue um quadro comparativo entre
as gerações:
Tabela 1. Comparativo entre as gerações de robôs da família LEGO
EV3 NXT RCX
Lançamento Setembro de 2013 Julho de 2006 1998
Display 178x128 pixel
LCD Monocromático
100x64 pixel
LCD Monocromático
Segmentado
LCD Monocromático
Processador TI Sitara
AM1808
(ARM926EJ-S core)
300 MHz
Atmel
AT91SAM7S256
(ARM7TDMI core)
48 MHz
Hitachi
H8/300
16 MHz
Memória 64 MB RAM
16 MB Flash
64 KB RAM
256 KB Flash
32 KB RAM
16 KB ROM
Maiores detalhes sobre o robô LEGO MINDSTORMS EV3 e seus componentes
podem ser vistos na referência (LEGO).
13
4. Desenvolvimento
Observando a Figura 9, para que seja possível realizar o interfaceamento entre um
robô EV3 com um sistema supervisório é necessário primeiro implementar a
comunicação entre as duas partes. Nesse projeto foi utilizado um Arduino UNO para
este interfaceamento, estabelecendo uma comunicação I2C com o robô e uma
comunicação serial com o computador.
Figura 9. Diagrama de Blocos
4.1. Preparativo para a Comunicação I2C
Para estabelecer a comunicação entre o robô EV3 e o Arduino UNO foi necessário
adaptar um cabo do próprio kit do EV3, que conecta os componentes (sensores e
motores) ao seu Bloco Programável. Seguindo o esquemático da Figura 10, foi
necessário adicionar dois resistores pull-up de 47k ohms, um destinado ao SDA e
outro ao SCL, para garantir a integridade das informações transmitidas. Após a
adaptação do cabo foi conectado aos pinos A4 (SDA), A5 (SCL), VIN e GND do
Arduino cada um dos fios correspondentes.
14
Figura 10. Esquemático da comunicação entre o EV3 e o Arduino UNO
Ainda seguindo o esquemático da Figura 10, caso for optado conectar o Arduino a
uma porta USB do computador ou por uma fonte externa, não é necessário conectar
o fio verde (green) ao pino VIN do Arduino, porém o terminal GND deve estar
sempre conectado. Os fios preto (black) e branco (white) podem ser
desconsiderados como mostrado no esquemático da Figura 10. A outra extremidade
do cabo foi conectada em uma das portas de entrada dos sensores do Bloco
Programável. O robô EV3 sempre será o master na comunicação I2C, sendo ele que
controlar as requisições e envios de dados no barramento.
4.2. Programação do LEGO EV3
Para o EV3 foi implementado um código o qual tem como finalidade controlar as
velocidades dos motores do robô, recebendo valores de referência do Arduino e
aplicando aos motores uma tensão correspondente. Nessa etapa de implementação
foi utilizada a IDE da família LEGO, o software LEGO MINDSTORMS EV3. Como
mencionado na seção 3.4, essa IDE utiliza blocos como forma de programação,
onde cada bloco contém suas funcionalidades e parâmetros.
15
O programa é dividido da seguinte forma:
Módulo de Controle de Velocidade, onde cada motor tendo seu próprio
módulo (este módulo está dividido entre o Anexo B e C, páginas 30 e 31).
Módulo de Leitura/Escrita de Dados (Anexo D, página 32).
Antes da execução dos módulos são declaradas as variáveis e as constantes
(Anexo A, página 29) que servirão para a troca de informações entre os módulos.
São utilizados também flags para a sincronização.
4.2.1. Módulo de Controle de Velocidade
V
F
V
F
O Módulo de Controle de Velocidade foi implementado em conjunto com o aluno de
mestrado Ramon Fernandes, do Departamento de Engenharia Elétrica da UFBA.
Nessa subseção será mostrada duas etapas, sendo a primeira o cálculo do erro e a
segunda o controlador de velocidade PI, como mostrado na Figura 11. Como a
lógica dos módulos do controlador dos motores são idênticos será analisado
somente o do motor direito.
Cálculo do Erro Flag_PI = V Flag_In
Cálculo do Controle de Velocidade
Flag_PI = F Flag_envio = V
Flag_PI
Figura 11. Diagrama de Blocos representando o fluxo do Módulo de Controle de Velocidade
16
4.2.1.1. Cálculo do Erro
Analisando o primeiro diagrama da Figura 11 e o Anexo B, página 30, a variável
Flag_In, localizada no início do processo, tem por função habilitar o loop do cálculo
do erro somente quando as variáveis e constantes estiverem instanciadas. Logo
após, é realizado o cálculo da velocidade do motor a partir da equação:
𝑣𝑑 =𝜋
180∗
∆𝜃
𝑇 (𝑟𝑎𝑑/𝑠)
(1)
no qual ∆𝜃 é a variação da rotação do motor, em graus, em um determinado tempo
𝑇. O erro é nada mais que a diferença entre a velocidade de referência (Refd) e a
velocidade atual do motor direito (vd). Após o cálculo, a variável Flag_PI é alterado
para true, no qual a função desta variável é habilitar a etapa do controlador de
velocidade PI, como será visto a seguir.
4.2.1.2. Controlador de Velocidade PI
Analisando o segundo diagrama da Figura 11 e o Anexo C, página 31, a variável
Flag_PI, localizada no início do processo, tem por função habilitar o loop do
controlador de velocidade PI após o cálculo do erro. O cálculo aplica a seguinte
equação discreta:
𝑢[𝑛] = 𝑢[𝑛 − 1] + 𝐾𝑝 ∗ 𝑒[𝑛] + 𝐾𝑖 ∗ 𝑇
2(𝑒[𝑛] − 𝑒[𝑛 − 1]) +
𝐾𝑑
𝑇(𝑒[𝑛] − 𝑒[𝑛 − 1])
(2)
onde:
Kp: coeficiente da ação proporcional
Ki: coeficiente da ação integral
Kd: coeficiente da ação derivativa
n: amostragem
u[n]: sinal de saída do sinal de controle do sistema na interação n
e[n]: sinal de erro na entrada do controlador na interação n
T: constante de tempo
17
Porém, como o objetivo é implementar um controlador de velocidade PI, o
coeficiente derivativo Kd é igualado a zero. Após a conclusão do cálculo, o sinal de
saída é enviado ao motor direito, a Flag_PI é setada para false e a Flag_Envio é
setada para true, e assim seguindo para a próxima interação. A Flag_Envio tem
como função habilitar o envio dos sinais de controle e das velocidades atuais dos
motores para o Arduino, como será visto a seguir.
4.2.2. Módulo de Leitura/Escrita de Dados
V
F
Este módulo é responsável pelo recebimento e envio de dados entre o robô e o
Arduino, onde são utilizados dois blocos I2C. Este módulo contém um loop para o
recebimento dos dados e outro loop para o envio, sendo que o loop de recebimento
contém o loop de envio, como pode ser observado no diagrama da Figura 12 e no
Anexo D, página 32. Essa estrutura é necessária para que, após o recebimento dos
dados, o módulo do controle de velocidade possa realizar seus cálculos antes do
envio para o Arduino. Esse controle de sincronização é realizado pela variável
Flag_Envio, como mencionado no fim da subseção 4.2.1.2, junto a uma condicional,
onde caso o seu valor seja true os dados serão enviados ao Arduino.
Envio Flag_Envio = F
Flag_Envio
Leitura
Figura 12. Diagrama de Blocos representando o fluxo do Módulo de Leitura/Escrita de Dados
18
4.2.2.1. Bloco I2C
Com fim de estabelecer a comunicação entre o robô EV3 e o Arduino foi importado o
Bloco I2C à IDE da LEGO (LEGO MINDSTORMS EV3 Sofware), pois esse bloco não faz
parte dos blocos padrão da IDE. Este bloco, mostrado na Figura 12, tem como função
estabelecer a conexão entre o robô e o Arduino, assim podendo ocorrer o envio e
recepção dos pacotes de dados.
Figura 13. Imagem do Bloco I2C modo leitura de 8 bytes
No canto inferior direito da Figura 13 pode-se observar que o bloco I2C se encontra
no modo Read 8 bytes, que é o modo de leitura utilizando 8 bytes. O campo que se
localiza na parte superior esquerdo do bloco, no qual na Figura 13 exibe “1”, indica
em qual das portas de entrada dos sensores do Bloco Programável do LEGO EV3 o
cabo está conectado, cabo no qual deve estar conectado também ao Arduino. Este
bloco contém alguns modos de escrita e leitura dos dados:
Read 1 byte / Write 1 byte
Read 8 bytes / Write 8 bytes
Read 8 bytes ASCII
Analog Read
Digital Write
Nesse projeto foi utilizado somente os modos de leitura e escrita de 8 bytes do bloco
I2C.
19
4.2.2.2. Recebimento
Nessa etapa ocorre a atualização dos valores de referência dos motores a partir do
recebimento dos dados enviados pelo Arduino. Para o modo de leitura do bloco I2C
foram utilizados 4 bytes dos 8 disponíveis, assim sendo:
Byte 8: o módulo do valor de referência do motor direito
Byte 7: o sinal do valor de referência do motor direito
Byte 6: o módulo do valor de referência do motor esquerdo
Byte 5: o sinal do valor de referência do motor esquerdo
Os bytes de sinais representam se os valores dos quais pertencem são negativos ou
positivos. Analisando o Anexo E, página 33 (alteração do código representado no
Anexo D para representar em detalhe o tratamento dos dados do motor direito), o
valor contido no byte 8 é transformado a um valor correspondente a outra escala e
atribuído a variável Refd. A transformação do valor é necessária porque o tamanho
do valor enviado pelo Arduino ultrapassa o tamanho da palavra suportada por um
byte, assim seguindo a fórmula:
𝑅𝑒𝑓𝑑 = (𝑊𝑚𝑎𝑥 ∗ 𝑏𝑦𝑡𝑒)
127
(3)
no qual Wmax é uma constante de valor 17.3398, sendo a Velocidade Angular
Máxima. Logo após, é analisado o seu respectivo sinal, contido no byte 7, sendo que
caso o valor seja igual a zero o valor Refd é atualizado para -Refd, e assim seguindo
para o loop de envio. O mesmo processo ocorre com os valores referentes ao motor
esquerdo.
4.2.2.3. Envio
Nessa etapa ocorre o envio dos valores de controle e das velocidades dos motores
ao Arduino. Após a atualização das variáveis de referência entra-se no loop de
20
envio, onde o controle de envio é realizado pela variável Flag_Envio. Essa flag é
setada para true no momento em que os Módulos de Controle de Velocidade
atualizam os sinais de controle e atribuem aos motores. Caso contrário, o processo
fica em um loop infinito aguardando a confirmação da atualização. Após a
confirmação, o processo entra na condicional onde contém o tratamento dos dados
para o envio ao Arduino.
Analisando o Anexo F, página 34 (alteração do código representado no Anexo D
para representar em detalhe o tratamento dos dados do motor direito), é observada
que a velocidade do motor direito (vd) sofre uma correção seguindo a formula:
𝑏𝑦𝑡𝑒 = (𝑣𝑑 ∗ 127)
𝑊𝑚𝑎𝑥
(4)
onde o módulo da transformado é atribuído ao byte 1 do bloco I2C. Em seguida é
verificado se o valor da correção é menor que zero. Caso a condição seja
verdadeira, a variável do sinal de velocidade do motor direito (svd) recebe o valor 1,
caso contrário 0, e assim sendo atribuída ao byte 2 do bloco I2C.
O processo de tratamento do valor do sinal de controle (Ud) é semelhante ao da
variável vd, excluindo somente a etapa do cálculo da correção, pois seu valor se
encontra dentro de um intervalo [-100, +100]. Assim, o módulo do seu valor é
atribuído ao byte 5 e seu sinal ao byte 7. Os dados referentes ao motor esquerdo
sofrem o mesmo processo. Assim, para o modo de escrita do bloco I2C, foram
utilizados os oito bytes disponíveis, sendo:
Byte 8: o sinal do valor de controle do motor esquerdo
Byte 7: o sinal do valor de controle do motor direito
Byte 6: o módulo do valor de controle do motor esquerdo
Byte 5: o módulo do valor de controle do motor direito
Byte 4: o sinal do valor da velocidade do motor esquerdo
Byte 3: o módulo do valor da velocidade do motor esquerdo
Byte 2: o sinal do valor da velocidade do motor direito
Byte 1: o módulo do valor da velocidade do motor direito
21
Após o envido, a variável Flag_Envio é setado para false e o loop de envio é
interrompido, assim caindo novamente no loop de recebimento e recebendo um
novo pacote de dados do Arduino.
4.3. Programação do Arduino
Nessa subseção será apresentado as funções necessárias para iniciar o Arduino em
um barramento I2C e o firmware utilizado neste projeto.
4.3.1. Barramento I2C
Para iniciar o Arduino no barramento I2C é necessária uma biblioteca chamada
Wire, no qual se encarrega de toda a complexidade da geração dos pulsos SDA e
SCL no tempo adequado, tornando possível enviar e receber facilmente os bytes de
dados. Para utilização dessa biblioteca é necessário usar o comando “#include
<Wire.h>”.
O comando Wire.Begin() é chamado dentro da função setup(). Caso o Arduino fosse
o master do barramento não seria necessário informar um endereço. Porém, como
nesse projeto o LEGO EV3 é quem assume esse papel, é necessário especificar um
enderenço em hexadecimal entre 0 e 127 (número total de slave em um barramento
I2C) como parâmetro para que ele seja identificado. Também deverá ser chamado
no setup() os comandos Wire.onReceive() e Wire.onRequest(), sendo:
onReceive(): destinada a interrupções causadas pelo recebimento de dados,
no qual chama uma função que é declarada como parâmetro para realizar o
atendimento da interrupção.
onRequest(): destinada a interrupções causadas quando um master requer
um envio de dados por parte do slave, no qual também é chamada uma
função declarada como parâmetro.
22
4.3.2. Estrutura do firmware
O firmware do Arduino é responsável por realizar a conexão entre o computador e o
robô LEGO EV3, assim sendo necessário a utilização de duas formas de
comunicação. A comunicação I2C é utilizada para estabelecer a troca de dados
entre o robô e o Arduino, onde este envia os dados ao computador utilizando a
comunicação serial. O firmware é formado pelas funções abaixo:
Setup()
RecebeComputador()
Envia_Lego()
Recebe_Lego()
EnviaComputador()
Loop()
Aguarda Requisição do Robô
Loop() F
V
EnviaComputador()
Flag_Lego = 3
RecebeComputador() Envia_Lego()
Recebe_Lego()
Flag_Lego = 0
Figura 14. Diagrama de Blocos que representa a lógica do firmware
23
Na função Setup() ocorre a inicialização das comunicações serial e I2C, essa ultima
seguindo a orientação da subseção 4.3.1.. O diagrama de blocos mostrado na
Figura 14 representa a lógica por trás do firmware. As funções Envia_Lego() e
Recebe_Lego() aguardam a requisição do master para serem executadas, enquanto
as demais estão contidas na função Loop(), esperando que a condição de controle
seja verdadeira para que sejam executadas.
A função RecebeComputador() é responsável pelo recebimento do pacote originado
pelo computador, pelo tratamento das informações do pacote recebido e pela
montagem do pacote que será enviado ao robô. O pacote enviado pelo computador
é um vetor de cinco posições do tipo char, o qual após o seu recebimento é
armazenado na variável val do tipo string. Logo após ocorre a interpretação dos
valores dos sinais e a conversão dos valores das velocidades, sendo atribuído a
variáveis que serão utilizadas para a montagem do vetor U_lego[], que será enviado
ao robô. Este vetor possui quatro posições do tipo byte, onde as posições 0 e 1
recebem a velocidade de referência e o sinal do motor esquerdo e as posições 2 e 3
recebem a velocidade de referência e o sinal do motor direito.
A função Envia_Lego() envia ao robô o vetor U_lego[], utilizando a função
Wire.write(), passando como parâmetro o vetor e o seu tamanho. A função
Recebe_Lego() é responsável por receber o pacote enviado pelo robô, tratar e
atribuir as suas informações a variáveis, no qual serão utilizadas pela função
EnviaComputador(). Ao final atualiza a flag flag_lego, incrementando +1 ao seu
valor. Logo, a função EnviaComputador() monta um pacote a partir das variáveis
atualizadas pela função Recebe_Lego() e envia ao computador pela porta serial,
seguindo a estrutura:
Na função loop() ocorre o controle de envio e recebimento dos pacotes referente ao
computador, onde caso a condição de controle flag_lego for igual a 3 o Arduino
envia um pacote e recebe um novo, e assim setando a flag_lego para 0. Isso indica
que o Arduino só irá enviar e receber pacote do computador quando as variáveis
24
referentes ao estado do robô, tratadas na função Recebe_Lego(), forem atualizadas
3 vezes, ou seja, o Arduino receber 3 vezes um pacote do robô. Essa taxa de
atualização é determinada pelo usuário.
O código completo do firmware pode ser visto no Anexo H, página 36.
5. Resultados
Para o processo de análise, foram obtidas amostragens dos valores enviados aos
motores em um período de tempo. Estes valores estão dentro de um intervalo [-100,
+100], no qual são os valores mínimo e máximo para que os motores operem
adequadamente. Para obter os gráficos dos resultados foi utilizado o software
MATLAB.
A Figura 15 mostra os gráficos dos valores das velocidades de referência, originados
no supervisório e enviados ao robô através do Arduino, os valores dos dados obtidos
sobre o estado dos motores do robô durante o experimento e os sinais de controle
gerados pelo módulo do controlador de velocidade PI.
25
Figura 15. Gráficos dos resultados obtidos
Nas Figuras 16 e 17, apresentam-se testes experimentais com todo o sistema. O
supervisório envia valores de referência para o LEGO, que possui um controlador PI
implementado para o controle de velocidade dos motores. Verifica-se nas figuras
que as referências são seguidas corretamente.
26
Figura 16. Gráfico de velocidade da roda direita
Figura 17. Gráfico de velocidade da roda esquerda
O erro entre o valor de referência e o obtido, no momento que o de referência é
alterado, é causado pelo processo do Módulo do Controle de Velocidade. Os sinais
de controle dos motores tendem a acompanhar o valor de referência a partir deste
erro, no qual a cada interação o processo deste módulo tende a minimiza-lo e assim
normalizando os sinais de controle com o passar do tempo.
27
6. CONCLUSÃO
O objetivo proposto nesse trabalho de desenvolver uma conexão, utilizando um
Arduino UNO, entre um robô LEGO EV3 e o sistema supervisório C++ implementado
pelo aluno de mestrado Ramon Fernandes foi alcançado. A sua veracidade foi
comprovada no decorrer dos experimentos, utilizado em projetos e testes realizados
no Departamento de Engenharia Elétrica da UFBA, no Laboratório de Robótica.
Esse projeto também contribuiu para a expansão das funcionalidades do robô LEGO
EV3, passando a ser uma opção como plataforma de desenvolvimento para projetos
no qual tem-se a necessidade de um sistema supervisório de controle ou algum
outro componente externo no qual possa ser conectado a um Arduino. A imagem do
robô conectado ao Arduino pode ser vista no Anexo G, página 35.
Deve-se ressaltar, como um contratempo, que a ideia inicial para o projeto foi a
utilização da plataforma Galileo da primeira geração da Intel, disponível no LaR,
porém houve a necessidade de descartá-lo do projeto devido à sua restrição em
relação à comunicação I2C. O master, em uma comunicação I2C onde se tenha um
Galileo conectado ao barramento, deve ser obrigatoriamente o próprio Galileo, isso
devido a uma restrição onde ele não atua como slave. Por causa desse fato foi
adotado o Arduino UNO.
28
Referências
BUS, I. I2C Bus - Everything About I2C. Disponivel em: <http://i2c.info/i2c-bus-
specification>. Acesso em: Setembro 2016.
INDUSTRIES, D. Disponivel em: <http://www.dexterindustries.com/howto/connecting-ev3-
arduino/>. Acesso em: junho 2016.
LEGO. LEGO Education. Disponivel em: <https://education.lego.com/en-
us/support/mindstorms-ev3/user-guides>. Acesso em: Setembro 2016.
LUÍS AUGUSTO JURIZATO, P. S. R. P. Sistemas Supervisórios. Network Technologies,
Nova Odessa, v. 1/2, p. 105-114, 2003. ISSN 1677-7778.
MICHAEL BARR, A. M. Programming Embedded Systems. 2. ed. [S.l.]: O'Reilly Media,
2006.
MICROCONTROLANDOS. Projetos e tutoriais sobre programação de PIC, AVR e Arduino.
Disponivel em: <http://microcontrolandos.blogspot.com.br/2012/12/comunicacao-i2c.html>.
Acesso em: Setembro 2016.
MONK, S. Programação com Arduino II: Passos avançados com sketches. Porto Alegre:
Bookman , 2015.
REIS, V. R. D. ArduinoB - Explorando o mundo com Arduino, 2014. Disponivel em:
<http://www.arduinobr.com/arduino/i2c-protocolo-de-comunicacao/>. Acesso em: Setembro
2016.
SOUZA, F. Embarcados, 2013. Disponivel em: <http://www.embarcados.com.br/arduino-
uno/>. Acesso em: Setembro 2016.
29
Anexo A
30
Anexo B
31
Anexo C
32
Anexo D
33
Anexo E
34
Anexo F
35
Anexo G
36
Anexo H
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
#include <Wire.h> #include<MsTimer2.h> #define SLAVE_ADDRESS 0x04 // Variáveis de comunicação int val; char data[10]; byte dados[8] = {0, 0, 0, 0, 0, 0, 0, 0}; byte buf[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; byte U_lego[8] = {0, 0, 0, 0, 0, 0, 0, 0}; // Velocidades Lidas double Vd, Ve; // Sinais das velocidades double sVd, sVe; // Velocidades desejadas double Ref_Vd, Ref_Ve; double vDref, vEref; double VDref, VEref; double sVDref, sVEref; // Sinais de controle aplicados double Ud, Ue, sUe, sUd; // Contador para indicar que houve 3 iteraçãoes com o lego int flag_lego; long double tt = 1; // Contador para debug long double ttt = 0; // Contador para debug double Wmax = 17.3398; /* ------------------------- Funções ------------------------- */ // Envio de dados pela conexao serial void EnviaComputador() { // Carrega o buffer de envio buf[0] = (byte)'@'; buf[1] = (byte)(sVd); buf[2] = (byte)(abs(Vd)); buf[3] = (byte)(abs(Ud)); buf[4] = (byte)(sVe); buf[5] = (byte)(abs(Ve)); buf[6] = (byte)(abs(Ue)); buf[7] = (byte)(tt); buf[8] = (byte)(ttt); buf[9] = (byte)(sUd); buf[10] = (byte)(sUe); // Envia Serial.write(buf, 11); tt = tt + 1; // Atualiza contador } // Para receber os dados da conexão Serial void RecebeComputador(){ int i,t,k; String val; while (Serial.available()>0) { //checa se tem dados pra ler char recieved = Serial.read(); val +=recieved; } // Verifica a ordem dos dados no pacote e rearranja caso seja necessário for(i=0;i<=4;i++){ if(val[i]='#'){ for(k=0;k<=4;k++){ t=k+i; if(t<=4){ val[k]=val[t];
37
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
} else{ val[k]=val[t-5]; } } break; } } // Velocidade desejada da roda direita Ref_Vd = (int)val[1]; if(val[2]=='f'){ sVDref = 0; } else if(val[2]=='b'){ sVDref = 1; } // Velocidade desejada da roda esquerda Ref_Ve = (int)val[3]; if(val[4]=='f'){ sVEref = 0; } else if(val[4]=='b'){ sVEref = 1; } VDref = (Ref_Vd); VEref = (Ref_Ve); // Cria o vetor a ser enviado ao lego U_lego[0] = (byte)(VEref); U_lego[1] = (byte)(sVEref); U_lego[2] = (byte)(VDref); U_lego[3] = (byte)(sVDref); } void Tempo(){ ttt = ttt + 1; } /* Setup */ void setup() { // Inicialização da porta serial Serial.begin(57600); // Comunicação I2C com o Lego EV3 Wire.begin(SLAVE_ADDRESS); Wire.onReceive(Recebe_Lego); Wire.onRequest(Envia_Lego); // Inicialização das velocidades desejadas vEref = 0; vDref = 0; // Interrupção de envio MsTimer2::set(500, Tempo); MsTimer2::start(); } void loop() { if(flag_lego == 3) { RecebeComputador(); EnviaComputador();
38
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
flag_lego = 0; } } // Recebe os sinais do Lego via I2C e salva nas variáveis void Recebe_Lego(int byteCount) { // Contador que sincroniza a leitura int i = 0; while(Wire.available()>0) { val = Wire.read(); dados[i] = val; i = i + 1; } // Salva os dados nas variáveis Ve = dados[0]; sVe = dados[1]; if (sVe==1){ sVe = -1; } Vd = dados[2]; sVd = dados[3]; if (sVd==1){ sVd = -1; } Ue = dados[4]; Ud = dados[5]; sUe = dados[6]; if (sUe==1){ sUe = -1; } sUd = dados[7]; if (sUd==1){ sUd = -1; } // Atualiza o contador flag_lego = flag_lego + 1; } // Envia sinais para o Lego via I2C void Envia_Lego() { Wire.write(U_lego,8); }
