Arduino Plataforma Eletrônica Microcontroladora

UNIVERSIDADE FEDERAL DO MARANHÃO

CENTRO DE CIÊNCIAS EXATAS E TECNOLOGIA

DEPARTAMENTO DE ENGENHARIA DE ELETRICIDADE

ANTONIO DIEGO SANTOS ABREU

ARDUINO – PLATAFORMA ELETRÔNICA MICROCONTROLADORA

São Luís

2012

ANTONIO DIEGO SANTOS ABREU

ARDUINO – PLATAFORMA ELETRÔNICA MICROCONTROLADORA

São Luís

2012

Monografia apresentada ao Curso de Engenharia Elétrica da Universidade Federal do Maranhão, para obtenção do grau de Bacharel em Engenharia Elétrica. Orientadores:

Prof. Dr. Areolino de Almeida Neto Prof. MSc. Marcos Tadeu Rezende

A Deus pelo dom da vida e sabedoria de todos os dias. À minha linda família companheira.

Aos meus grandes amigos.

AGRADECIMENTOS

Aos meus pais, Dilva Abreu e Raimundo Abreu, por me dar a

possibilidade e todo o suporte para conseguir alcançar os meus objetivos ensinando-

me as diretrizes das disciplinas do meu comportamento para eu poder seguir minha

vida.

Ao meu querido irmão Antonio Marcos, que além de um grande irmão é

um amigo de caráter precioso e único.

A minha namorada, Aurydiana França, por estar sempre perto de mim nos

últimos anos compreendendo e vivenciando vários momentos comigo sejam bons ou

ruins.

Aos meus familiares, principalmente minhas avós, por sempre

entenderem minha ausência quando precisava estudar.

Em especial ao meu grande amigo Engenheiro Lucas Angelo por estar

sempre dando forças e compartilhando bons momentos e projetos ao longo desses

anos.

Ao meu grande amigo Erick Santana, amigo que compartilhei algumas

horas da madrugada nesse desafio dos estudos e provas.

Ao amigo Marcos Ferreira pelo grande coração e o apoio de sempre.

Ao amigo Enio Leal por ajudar-me na mudança de engajamento

profissional.

A todos os meus amigos da Universidade, Anderson Machado, James

Pinheiro, Danilo Vale, Felipe Carvalho, Isac Lauda, Hugo Rossa, Gerdson Cunha,

Marcos Lima, Renato Carvalho, Joselilson Silva, Diego Aurélio e todos aqueles que

de alguma forma participaram da minha formação.

Ao grande Professor Marcos Tadeu, do qual sou admirador pela sua

capacidade de visualizar o que poucos conseguem ver e pelos seus preciosos

ensinamentos e paciência durante todas as etapas deste e de outros projetos.

Ao Professor Areolino Neto por me proporcionar oportunidades e abrir

portas para o mundo da Mecatrônica.

A todos os professores com quem tive o prazer de compartilhar

informações ao longo destes anos no curso.

A Paulo Henrique e Carlos César, da NetCom, pela oportunidade que me

ofereceram em sua Escola Técnica e incentivo para o desenvolvimento de sistemas

mecatrônicos.

A todos que de forma direta ou indireta, me ajudaram a chegar nessa

etapa da vida.

“Não conheço a chave para o sucesso, mas a chave para o fracasso é tentar agradar a todo mundo.”

Bill Cosby

RESUMO

Neste trabalho é apresentada uma plataforma eletrônica microcontroladora

denominada Arduino, incluindo as suas diversas aplicações. A plataforma Arduino é

um sistema embarcado que foi desenvolvido para os projetistas mudarem o foco

para a concepção final do projeto e não a montagem dos circuitos integrados em si.

Dentre as diversas aplicações, destacam-se a sua importância em sistemas

robóticos, sistemas de conexão com internet, sensoriamento, comunicação remota e

sistemas eletrônicos desenvolvidos para uso educacional. Todas essas aplicações

foram desenvolvidas utilizando-se uma estrutura baseada em Microcontrolador.

Palavras-chave: Arduino, Sistema Embarcado, Microcontrolador.

ABSTRACT

This work presents a microcontroller eletronic project called Arduino, includind its

many applications. Arduino´s platform is an embarked system that was developed for

changing the designer´s focus from the assembly of the integrated circuits to the final

conception of the project. Among several applicabilities of Arduino, some stand out,

like applications in robotic systems, systems of connection with internet, sensing,

remote communication and electronic systems designed for educational use. All

these applications were developed using a microcontroller based structure.

Keywords: Arduino, Embarked Systems, Microcontroller.

LISTA DE FIGURAS

Figura 2.1 – Diagrama esquemático de um microcontrolador típico .................... ...22

Figura 2.2 – Evolução do projeto Arduino ............................................................ ...24

Figura 2.3 – Arduino Interface Serial .................................................................... ...27

Figura 2.4 – Arduinos – evolução da comunicação USB....................................... ..28

Figura 2.5 – Arduino Duemilanove ........................................................................ ..28

Figura 2.6 – Arduino UNO ..................................................................................... ..29

Figura 2.7 – Arduino MEGA 2560 ......................................................................... ..30

Figura 2.8 – Arduino Mini ...................................................................................... ..30

Figura 2.9 – Arduino Nano .................................................................................... ..31

Figura 2.10 – Arduino Bluetooth .............................................................................. ..32

Figura 2.11 – Arduino Fio e Lily Pad ....................................................................... ..32

Figura 2.12 – Arduino sensorshields – módulos Zigbee e Inputshield .................... ..34

Figura 2.13 – Arduino Mega GSM, GPRS e GPS ................................................... ..35

Figura 3.1 – Software Arduino ............................................................................... ..38

Figura 3.2 – Design da placa Arduino UNO .......................................................... ..39

Figura 4.1 – Conexão do LED na placa Arduino ................................................... ..43

Figura 4.2 – Interruptor na placa Arduino .............................................................. ..45

Figura 4.3 – Acionamento sequencial ................................................................... ..48

Figura 4.4 – Acionamento de um motor de corrente contínua ............................... ..49

Figura 4.5 – Transistor MOSFET .......................................................................... ..50

Figura 4.6 – Receptor infravermelho ..................................................................... ..51

Figura 4.7 – Pulsos NEC ....................................................................................... ..52

Figura 4.8 – Endereço $59 comando 16 no NEC .................................................. ..52

Figura 4.9 – Repetição de sinal NEC .................................................................... ..53

Figura 4.10 – Montagem do Arduino com o display de cristal líquido ..................... ..54

Figura 4.11 – Conexão do receptor infravermelho com o Arduino .......................... ..54

Figura 4.12 – Controle infravermelho utilizado no projeto ....................................... ..55

Figura 5.1 – Modelos ISO/OSI .............................................................................. ..60

Figura 5.2 – Arduino Ethernet Shield..................................................................... ..64

Figura 5.3 – Hardware de acionamento ................................................................ ..66

Figura 5.4 – Configuração do roteador .................................................................. ..67

Figura 5.5 – Página web Arduino .......................................................................... ..67

LISTA DE TABELAS

Tabela 3.1 – Comparativo com as principais características relativas ao ATMEGA .36

Tabela 5.1 – Funções das camadas do protocolo internet ...................................... ..61

Tabela 5.2 – Características da comunicação TCP/IP ............................................ ..63

LISTA DE QUADROS

Quadro 4.1 – Código do acionamento dos pinos de saída ...................................... ..43

Quadro 4.2 – Código pisca LED .............................................................................. ..44

Quadro 4.3 – Código do acionamento de um pino .................................................. ..46

Quadro 4.4 – Código do filtro de ruído de uma chave ............................................. ..47

Quadro 4.5 – Código do acionamento sequencial ................................................... ..48

Quadro 4.6 – Código do acionamento ..................................................................... ..50

Quadro 4.7 – Códigos e endereços de VCR com NEC ........................................... ..53

Quadro 4.8 – Código do acionamento do controle IR ............................................. ..56

Quadro 5.1 – Código fonte para o WebServer ........................................................ ..68

LISTA DE SIGLAS

ADSL – Asymmetric Digital Subscriber Line

AGC – Automatic Gain Control

ATM – Asynnchronous Transfer Mode

CI – Circuito Integrado

DIP – Dual In-line Package

DC – Direct Current

DNS – Domain Name System

EEPROM – Electrically Erasable Programmable Read-Only Memory

FDDI – Fiber Distributed Data Interface

FTP – File Transfer Protocol

FPGA – Field Programmable Gate Array

FTDI – Future Technology Devices International

HTML – Hyper Text Multi Language

HTTP – Hypertext Transfer Protocol

I2C – Inter Integrated Circuit

IDE – Integrated Development Environment

IP – Internet Protocol

IR – Infrared

ISO – International Organization for Standardization

ICSP – In Circuit Serial Programming

LAN – Local Area Network

LCD – Display de Cristal Líquido

MOSFET – Metal Oxide Semiconductor Field Effect Transistor

NEC – Numerical Eletromagnetics Code

OSI – Open Systems Interconnect

PC – Personal Computer

PLD – Programmable Logic Device

PWM – Pulse-Width Modulation

SMD – Surface Mounting Devices

SPI – Serial Peripheral Interface

SRAM – Static Random Access Memory

SMTP – Simple Mail Transfer Protocol

TCP – Transmission Control Protocol

TTL – Transistor-Transistor Logic

UART – Universal Asynchronous Receiver Transmitter

UDP – User Datagram Protocol

UMR – Unidade Móvel Robótica

USB – Universal Serial Bus

VCR – Video Cassette Recorder

SUMÁRIO

1 INTRODUÇÃO ............................................................................................. 17

1.1 Objetivos ..................................................................................................... 18

1.2 Motivação .................................................................................................... 19

1.3 Organização do Trabalho ........................................................................... 19

2 PLATAFORMA ELETRÔNICA MICROCONTROLADA ARDUINO ............ 21

2.1 Microcontroladores e Sistemas Embarcados .......................................... 21

2.1.1 Sistemas Embarcados .................................................................................. 22

2.2 Histórico do Projeto Arduino ..................................................................... 23

2.3 Conceitos Básicos ...................................................................................... 24

2.4 Os Principais Modelos da Plataforma Arduino ........................................ 26

2.4.1 Versão Arduino – Interface Serial ................................................................. 27

2.4.2 Arduino – evolução USB ............................................................................... 27

2.4.3 Versões Arduino Duemilanove e Diecimila ................................................... 28

2.4.4 Versão Arduino UNO .................................................................................... 29

2.4.5 Versão Arduino MEGA ................................................................................. 29

2.4.6 Versão Arduino Mini ..................................................................................... 30

2.4.7 Versão Arduino Nano ................................................................................... 31

2.4.8 Versão Arduino Bluetooth ............................................................................. 31

2.4.9 Versões Arduino Fio e Lilypad ...................................................................... 32

2.4.10 Principais Diferenças .................................................................................... 33

2.5 Arduino SensorShield ................................................................................ 34

3 CARACTERÍSTICAS TÉCNICAS ................................................................ 36

3.1 Arduino e a Conexão com o Computador ................................................ 37

3.1.1 Software Arduino IDE ................................................................................... 37

3.2 A Placa Arduino UNO ................................................................................. 39

4 PROJETOS E IMPLEMENTAÇÕES COM O ARDUINO ............................. 42

4.1 Projetos Elementares ................................................................................. 42

4.1.1 Acionamento de Dispositivos de Saída ........................................................ 42

4.1.2 Acionamento do Arduino via Dispositivo de Entrada .................................... 45

4.1.3 Acionamentos Sequencial ............................................................................ 48

4.1.4 Acionamento de um motor dc via PWM do Arduino ..................................... 49

4.2 Projeto do Controle Remoto IR ................................................................. 51

4.2.1 Teoria do Controle Infra Vermelho................................................................ 51

4.2.2 Protocolo NEC – Características Técnicas ................................................... 52

4.2.3 Projeto com acionamento de display de cristal via controle remoto ............. 53

5 ARDUINO E A CONEXÃO COM A INTERNET ........................................... 58

5.1 Protocolo TCP/IP e Ethernet ...................................................................... 59

5.2 Camadas do Protocolo ............................................................................... 60

5.2.1 Modelo ISO/OSI x Internet ............................................................................ 60

5.2.2 Funções das Camadas Internet .................................................................... 61

5.2.3 Camada de Transporte TCP/IP .................................................................... 63

5.3 Arduino Ethernet Shield ............................................................................. 64

5.4 Projeto Arduino Ethernet ........................................................................... 65

6 CONCLUSÕES ............................................................................................ 72

REFERÊNCIAS ........................................................................................... 74

ANEXOS ...................................................................................................... 76

17

1 INTRODUÇÃO

A crescente evolução da tecnologia aliada ao grande investimento em

microprocessadores originou uma nova concepção de desenvolvimento de projetos

de sistemas embarcados na área de eletrônica com novas ferramentas

computacionais inclusive aplicadas a área de mecatrônica. Esse novo conceito

permite a uma ampla gama de profissionais (não somente engenheiros) a

possibilidade de desenvolver projetos na área. Rosa 2011 classifica o Arduino como

o Lego do futuro, onde uma criança poderia montar o seu robô com esta ferramenta.

A crescente oferta de Tablets, Smartphones e Netbooks vem possibilitando o

advento de inovações que afetam o dia-dia de milhões de pessoas em todo o mundo

e que estão diretamente relacionados a essa tecnologia.

O surgimento dos microcontroladores e a otimização dos sistemas

embarcados aumentaram as possibilidades de desenvolvimento de projetos de

automação, dado o baixo custo e a alta velocidade de processamento desses

dispositivos.

O trabalho com os microcontroladores transformou-se em uma ferramenta

fundamental para desenvolvimento de projetos eletrônicos de alto desempenho, pois

tornou-se possível programar uma pastilha de circuito integrado para efetuar

controle, monitoramento e acionamento das mais variadas aplicações dentro da

informática.

O aprendizado dos microcontroladores também tornou-se um desafio,

pois são tantos os modelos, configurações e fabricantes que confundem os

iniciantes nos estudos dessa ferramenta, não somente os estudantes, mas qualquer

profissional que deseje implementar os seus projetos com os microcontroladores

embarcados. A definição de qual microcontrolador utilizar em um projeto vai muito

além do que saber programar. Muitos fatores estão envolvidos, tais como: linguagem

de programação, capacidade de processamento e disponibilidade no mercado local.

Assim, existem diversas questões a serem levantadas quando se decide utilizar um

microcontrolador.

Desta forma, surge a necessidade de criar um novo conceito em

aprendizagem de programação em eletrônica, de tal forma que exista uma interação

bem definida dos elementos eletrônicos e da utilização de suas potencialidades sem,

contudo precisar conhecer profundamente os mecanismos. Conforme Rosa 2011, o

18

Arduino traz esse conceito de plataforma, pois em uma mesma placa pode-se

perceber a existência de um microcontrolador e facilmente se pode acessar os seus

pinos de entrada e saída já pré-definidos.

1.1 Objetivos

O presente trabalho visa apresentar uma plataforma eletrônica

microcontroladora tendo por base a tecnologia do Arduino. Este sistema é uma

ferramenta flexível e de baixo custo, uma vez que surge como um novo conceito de

hardware livre. Também é uma ferramenta de fácil utilização, seja por alunos ou

profissionais da área, ou até mesmo usuários com necessidade de desenvolver um

projeto eletrônico e que possuem conhecimentos elementares na área. Margolis

2011 fala sobre o a proposta de criação:

O Arduino é usado em muitos programas educacionais em todo o mundo, especialmente por desenvolvedores que querem criar seus protótipos com facilidade, mas não precisam de uma profunda compreensão dos detalhes técnicos por trás de suas criações. O Arduino também foi projetado para ser usado por pessoas sem formação técnica, o software inclui uma abundância de código de exemplo para demonstrar como usar as mais variadas aplicações da placa Arduino. (MARGOLIS, 2011, p.1)

Neste contexto, nota-se a relevância do Arduino na aplicação de projetos

educacionais em vários níveis do conhecimento, uma vez que para o seu uso em

aplicações elementares, o projetista não deve necessariamente conhecer

profundamente o dispositivo.

Como objetivos secundários, neste trabalho foram projetados, construídos

e testados vários experimentos básicos e complexos, que podem ser utilizados para

o ensino dessa plataforma. Além disso, foram criadas guias de laboratório para

estes experimentos, que podem ser aplicados em treinamentos e minicursos dentro

da própria Universidade.

19

1.2 Motivação

A principal motivação desse trabalho foi apresentar para a comunidade

universitária da UFMA a plataforma Arduino, devido esta ser uma ferramenta de boa

acessibilidade, possuir baixo preço e não ser do conhecimento geral do corpo

discente da Universidade Federal do Maranhão, em termos de desenvolvimento de

trabalhos acadêmicos.

Uma segunda motivação consistiu em poder contribuir para disseminar o

conhecimento de plataformas microcontroladoras voltadas para o projeto como um

todo e não somente para a arquitetura do microcontrolador, dando ênfase à sua

funcionalidade, indo portanto além do estudo sobre a disposição dos elementos

dentro do microcontrolador utilizado.

Desta forma, os resultados dos projetos elaborados nesse trabalho

podem ser utilizados em vários níveis do saber tecnológico, bastando apenas

determinar o objetivo do projeto e conhecer o circuito eletrônico no qual a plataforma

Arduino estará inserida.

1.3 Organização do Trabalho

Este trabalho está dividido em seis capítulos e referências bibliográficas:

• Capítulo 2: neste capítulo são abordados alguns conceitos sobre

Microcontroladores, Sistemas Embarcados e do Projeto Arduino. Neste último

será descrita a evolução de todas as placas bem como da placa mãe dos

projetos que fazem parte deste trabalho;

• Capítulo 3: neste capítulo, são apresentados conceitos sobre alguns

componentes eletrônicos usados no projeto, suas funções e especificações,

bem como as mais variadas placas de sensores (sensorshields) utilizadas

atualmente;

• Capítulo 4: neste capítulo, são mostrados vários exemplos de experimentos

desenvolvidos para o laboratório, demonstrando a funcionalidade do Arduino,

bem como dos seus sensorshields e a descrição dos experimentos que foram

construídos para posterior utilização em treinamentos, tanto em Instituições de

Ensino Técnico e Tecnológico como em centros de treinamentos de empresas do

setor;

20

• Capítulo 5: neste capítulo, é apresentado um importante sensorshield da

plataforma Arduino que interage na comunicação com a Internet bem como as

especificações para projetos futuros;

• Capítulo 6: são apresentadas as conclusões, onde são comentadas todas as

potencialidades da plataforma Arduino que foram validadas com testes em

laboratório.

21

2 PLATAFORMA ELETRÔNICA MICROCONTROLADORA- ARDUINO

O presente capítulo descreve a teoria básica dos microcontroladores e

dos sistemas embarcados bem como as suas principais funcionalidades. Em

seguida é descrita a trajetória do projeto Arduino desde o surgimento até a criação

do Arduino UNO. Vários conceitos básicos da plataforma foram contemplados e

todos os modelos das placas foram descritos durante o capítulo, culminando com a

análise das principais diferenças entre as placas. O texto também traz a descrição

sobre os sensorshields, que são elementos importantes para um bom desempenho

dos projetos com o Arduino.

2.1 Microcontroladores e Sistemas Embarcados

Os microcontroladores destacam-se por possuírem várias funcionalidades

em único chip. Lima 2010 apresenta a seguinte definição:

Um microcontrolador é um sistema microprocessado com várias funcionalidades (periféricos) disponíveis em um único chip. Basicamente, um microcontrolador é um microprocessador com memórias de programa, de dados e RAM, temporizadores e circuito de clock embutidos. O único componente externo que pode ser necessário é um cristal para determinar a frequência de trabalho (LIMA, 2010, p. 24).

Microcontroladores são dispositivos capazes de efetuar o controle de

equipamentos eletrônicos ou mesmo de máquinas de pequeno e grande porte,

através de programação realizada em diferentes tipos de linguagem. É um

componente muito versátil, pois ele é programável e pode ser empregado em

diversas aplicações. Atualmente várias empresas como Atmel, Microchip, Intel,

Motorola, Texas, entre outros fabricantes possuem microcontroladores cada vez

mais velozes, robustos, com maior capacidade de processamento, baixo consumo

de energia, entre outras vantagens, as quais foram atingidas devido o alto

investimento nas áreas de pesquisa e desenvolvimento.

Lima 2010 mostra que o desenvolvimento dos microcontroladores está

associado ao grande numero de funções que ele pode executar a partir de um

programa desenvolvido para uma determinada tarefa.

22

O desenvolvimento dos microcontroladores se deve ao grande número de funcionalidades disponíveis em um único circuito integrado. Como o seu funcionamento é ditado por um programa, a flexibilidade de projeto e de formas de trabalho com um hardware específico são inúmeras, permitindo aplicação nas mais diversas áreas (LIMA, 2010, p.18).

Sistemas comandados por microcontroladores estão cada vez mais

presentes no cotidiano das pessoas, onde suas aplicações vão desde sistemas

muitos simples (uma máquina de lavar roupas) até os sistemas mais complexos

como processamento digital de sinais, controle de trajetória de robôs dentre outros.

Com base nos conceitos acima nota-se que a grande vantagem de se

colocar várias funcionalidades em um único circuito integrado é a possibilidade de

desenvolvimento rápido de sistemas eletrônicos com o emprego de um número

pequeno de componentes externos como mostrado no diagrama esquemático da

Figura 2.1.

Figura 2.1 – Diagrama esquemático de um microcontrolador típico

Fonte: LIMA, 2010

2.1.1 Sistemas Embarcados

A nossa sociedade está cercada por incontáveis sistemas embarcados,

encontrados em diversos equipamentos dentre os quais destacamos: aparelhos de

comunicação móvel, TV digital, som, modens, brinquedos, câmeras digitais, fornos

de micro-ondas e outros aparelhos eletrodomésticos inclusive com controle remoto.

Até mesmo em alguns carros são usados vários deles, em diferentes partes como,

23

por exemplo, no sistema de injeção eletrônica, freio ABS, airbag, computador de

bordo, etc.

Em Morimoto 2007 afirma-se que, ao contrário de um PC, que pode

executar os mais diversos programas simultaneamente e com diferentes funções, os

sistemas embarcados são dispositivos "invisíveis", que estão cada vez mais

presentes em nosso cotidiano, de forma que muitas vezes sequer percebemos que

eles estão lá.

Um sistema embarcado pode ser, desde uma pequena placa de algum

brinquedo moderno, até uma máquina com centenas de processadores, destinada a

criar desde previsões sobre mercados de capitais, ou até controlar o tráfego aéreo.

Sistemas embarcados são geralmente desenvolvidos para uma tarefa

específica. Por questões de segurança e aplicabilidade alguns ainda possuem

restrições para computação em tempo real. O software desenvolvido para sistemas

embarcados é muitas vezes chamado firmware e é armazenado em uma memória

ROM ou memória flash, em vez de um disco rígido. Por vezes o sistema também é

executado com recursos computacionais limitados: sem teclado, sem tela e com

pouca memória.

Todos estes fatores também podem ser traduzidos em custo reduzido.

Processadores utilizados em alguns sistemas embarcados geralmente têm preços

bem menores que processadores convencionais.

2.2 Histórico do Projeto Arduino

O projeto Arduino foi iniciado na cidade de Ivrea, na Itália em 2005, tendo

por objetivo tornar os projetos de sistemas microcontrolados mais simples. Ele foi

desenvolvido numa escola de engenharia e com orçamento menor em relação aos

custos na época. Em 2006 o projeto recebeu menção honrosa na categoria

Comunidades Digitais em 2006, pela Prix ArsEletronics. Também alcançou a marca

de 50.000 placas vendidas até outubro de 2008. Até julho de 2011 foram vendidas

mais de 120.000 placas do projeto, de acordo com o site oficial do Arduino1.

A Figura 2.2, mostra os principais marcos históricos do Arduino desde a

criação.

1http://www.arduino.cc

24

Figura 2.2 – Evolução do projeto Arduino

Em 2005, um grupo acadêmico com a proposta de reduzir os custos com

projetos microcontrolados ganhou notória evolução e reconhecimento a nível

mundial em um curto intervalo de tempo. A plataforma ainda era elementar e

contava apenas com a comunicação tipo serial RS232. Em 2007, o Arduino

Diecimilia ganhou a comunicação USB o que tornou o projeto mais flexível e

alavancou as vendas. Em 2009, com o lançamento do Arduino Duemilanove foi

corrigido uma série de erros de operação da placa anterior. Em 2010 foi lançado o

Arduino UNO, que é a placa base mais moderna atualmente e que segue com o

mesmo sucesso, tendo em vista que essa placa conta com mais memória do

microcontrolador e com mais velocidade no envio e recebimento de dados.

2.3 Conceitos Básicos

O Arduino não é um microcontrolador e sim uma plataforma eletrônica

que possui uma série de dispositivos eletrônicos agregados a um microcontrolador

em uma placa de circuito integrado. A placa foi adaptada para conectar-se

facilmente com outros dispositivos, pois possui a descrição bem detalhada de suas

portas de entrada e saída bem como o acesso facilitado para sua comunicação com

outros dispositivos e até mesmo a placas de expansão que também são

confeccionadas para adaptar-se à placa principal.

Embora o Arduino seja uma plataforma que pode ser desenvolvida com

base em qualquer microcontrolador, o modelo mais utilizado nas versões comerciais

é o ATMEL. No presente trabalho, utilizamos duas placas que, assim como no

restante do mundo, utiliza os microcontroladores ATMEGA 328. No Brasil, existem

25

diversas cópias modificadas que foram desenvolvidas e adaptadas, tais como o

Freeduino, Tatuino dentre outras versões.

O Arduino também possui uma linguagem própria, os desenvolvedores a

nomearam de linguagem Arduino. Trata-se de uma linguagem C++ que foi adaptada

à disposição dos pinos das diversas placas do projeto.

Os desenvolvedores do projeto disponibilizam todos os códigos e

diagramas de montagem para qualquer usuário interessado em confeccionar o seu

próprio protótipo, da mesma forma que vendem as placas montadas para todo o

mundo.

Em reportagem à revista INFO2, em março de 2009, David Mellis, da

Arduino, contou como um hardware de código aberto (livre) pode se espalhar pelo

mundo, Mellis falou que a empresa queria que outras pessoas estendessem a

plataforma para adequá-la às suas necessidades. Para isso, elas deveriam ter

acesso ao código-fonte do software e ao projeto do hardware. Além disso, como era

uma plataforma nova e de código aberto deu confiança às pessoas. Elas sabiam que

poderiam continuar expandindo a plataforma mesmo que o desenvolvedor original

desistisse dela.

Segundo David Mellis 2009 “o código aberto traz algumas vantagens ao

hardware que é a possibilidade de adaptar o modelo de negócios e o fornecimento a

diferentes situações. Outras empresas podem vender kits para a montagem de

dispositivos compatíveis com Arduino, por exemplo. Também podem redesenhar os

produtos para trabalhar com componentes que são mais baratos e fáceis de

conseguir em seus países. Um exemplo de produto derivado das placas Arduino que

atende a um uso específico é a ArduPilot, placa de código aberto para navegação

autônoma em aeronaves.” (Revista INFO, 2009, p. 30)

O Arduino é uma plataforma open-source projetada com um microcontrolador simples de 8 bits da família AVR da fabricante ATMEL e que utiliza uma linguagem baseada em C/C++, mas que também pode ter o seu projeto adaptado para qualquer outro microcontrolador que suporte a linguagem. (ROSA, 2011, p.3)

O projeto Arduino tem como uma de suas vantagens, ser uma ferramenta

de baixo custo, flexível e, principalmente, de fácil utilização, seja por alunos

2http://info.abril.com.br/professional/tendencias/hardware-livre-leve-e-solto.shtml

26

profissionais da área, ou até mesmo usuários que tem necessidade de desenvolver

um projeto eletrônico.

Além disso, os requisitos mínimos para utilização de uma das placas da

plataforma Arduino é um computador com entrada USB e o software de compilação

encontrado na página dos desenvolvedores do projeto3.

As placas Arduino possuem algumas portas de entrada e saída,

analógicas e digitais, além de uma ou mais portas de comunicação serial, que são

característicos do microcontrolador utilizado na placa.

As placas Arduino contam com um sistema de boot incorporado ao

microcontrolador, que tem por objetivo interpretar a linguagem Arduino e traduzi-la

para linguagem de instrução do microcontrolador.

Através dos diversos recursos apresentados pela plataforma, o Arduino

pode interagir em diversos níveis de projetos, como em projetos mais simples que

dispõe de LED, botões, CIs, LCD, entre outros, comunicando com um PC através de

porta USB, ou outros dispositivos controláveis como PLDs, FPGAs, ou outros

microcontroladores e ferramentas mais sofisticadas, tais como comunicação ethernet

e sem fio.

2.4 Os Principais Modelos da Plataforma Arduino

Desde o princípio, as placas Arduino contavam com um microcontrolador

ATMEGA, portas de entrada e saída, analógicas e digitais à nível TTL - Transistor-

Transistor Logic (5 V), e porta de comunicação serial. Hoje existem placas cada vez

mais sofisticadas com configurações que atendem cada vez mais as necessidades

do público.

As placas Arduino podem ser encontradas para venda em sites de

representantes comerciais ou montadas pelo próprio usuário, já que os

desenvolvedores disponibilizam em seu site os arquivos do esquemático e do layout

da placa. Além disto, os componentes utilizados para fabricação das placas são de

fácil acesso e encontradas em qualquer loja de componentes eletrônicos.

A seguir são apresentadas as placas disponíveis desde o primeiro modelo

até o mais atual e ainda outros modelos mais específicos.

3http://www.arduino.cc/

27

2.4.1 Versão Arduino – Interface Serial

A plataforma Arduino Interface Serial foi a primeira placa desenvolvida em

2005. Possui um microcontrolador ATMEGA8, que possui 8 KB de memória de

programa do tipo flash, componentes discretos e uma porta serial do tipo RS232,

conforme Figura 2.3. É a placa mais simples de montar, pois os componentes

utilizados são do tipo convencional.

É considerada hoje uma placa obsoleta, por causa de sua porta de

comunicação estar caindo em desuso, os componentes são de encapsulamento tipo

DIP e não conta com componentes do tipo SMD, considerados ideais pelo mercado.

Figura 2.3 – Arduino Interface Serial

Fonte: Arduino, 2011.

2.4.2 Arduino – evolução USB

O Arduino USB foi a primeira placa fabricada com conexão USB, sendo

vendida principalmente como um kit que deveria ser montado pelo usuário. Esta

primeira placa tinha um problema de layout nas ligações com conector USB e teve

uma segunda versão lançada.

Seguida desta, foi lançada a placa Arduino Extreme, que contava com

componentes SMD em substituição aos convencionais, sendo lançada a seguir uma

segunda versão em que o layout possuía plano de terra. Além disso, possuía um

ATMEGA8 e uma FTDI para conversão RS232 - USB.

A terceira geração de Arduino com porta USB foi Arduino NG (Nuova

Generazione), que continha um novo FTDI para conversão RS232 – USB e um novo

28

microcontrolador ATMEGA 168. O Arduino Extreme e o NG são apresentados na

Figura 2.4.

Figura 2.4 – Arduinos – evolução da comunicação USB


2.4.3 Versões Arduino Duemilanove e Diecimila

O Arduino Duemilanove e Diecimilia são os modelos 2009 e 2007 das

placas padrão da plataforma. Conta com 12 portas de I/O digitais, 6 portas de I/O

analógicas, conversor A/D de 10 bits, comunicação via USB, SPI, I2C, Canais PWM,

alimentação via USB ou externa através de fonte de alimentação, entre outras

características. Além disso o modelo 2007 contava com um microcontrolador

ATMEGA 168 com 16 KB, enquanto o modelo 2009 contava com um ATMEGA 328

com 32 KB (Flash). O modelo do Duemilanove é apresentado na Figura 2.5.

Figura 2.5 – Arduino Duemilanove


29

2.4.4 Versão Arduino UNO

O Arduino UNO é a última versão das placas Arduino, como apresentado

na Figura 2.6. Lançada no final de 2010 possui um microcontrolador ATMEGA328 e

a novidade está no conversor RS232 – USB que conta com um ATMEGA8

substituindo o FTDI. Com isto o arquivo de carregamento do sistema diminuiu de

tamanho, o que economizou na memória flash do ATMEGA328 e acelerou o

processo.

O UNO foi utilizado para marcar o lançamento do Arduino 1.0 e junto a

este serão obtidas as versões de referência.

Figura 2.6 – Arduino UNO


2.4.5 Versão Arduino MEGA

O Arduino MEGA é uma placa que possui como características principais

um microcontrolador que possibilita principalmente uma quantidade maior de portas

de I/O, outros recursos como portas seriais extras, PWMs, entre outros recursos

conforme mostrado na Figura 2.7.

Essa placa foi desenvolvida originalmente com o ATMEGA 1280, um

microcontrolador com 128 KB de memória flash e um FTDI, que foram substituídos

posteriormente por um ATMEGA 2560, que possui 256 KB de memória flash e assim

como o UNO possui um ATMEGA 8 como conversor RS232 – USB.

30

Figura 2.7 – Arduino MEGA 2560


2.4.6 Versão Arduino Mini

O Arduino Mini é a menor placa de todas as placas, como mostra a Figura

2.8. Ela é baseada em um ATMEGA168, pode ser considerada a miniaturização da

Diecimila por possuir grande parte dos recursos desta, mas não possui conexão

USB.

Esta placa é ideal quando se deseja otimizar espaço e projetar mais de

um protótipo, pois neste caso é necessário apenas um adaptador no qual pode

gravar quantas placas mini se desejar.

Pode-se utilizá-la diretamente em um protoboard ou então soldá-la ao

hardware do protótipo em desenvolvimento.

Figura 2.8 – Arduino Mini


31

2.4.7 Versão Arduino Nano

Esta placa pode então ser considerada a miniaturização da Arduino

Duemilanove completo, pois possui praticamente todos os recursos que o

Duemilanove dispõe inclusive conexão USB, conforme a Figura 2.9.

Para alimentá-lo por uma fonte externa, é necessário que a alimentação

ocorra diretamente nos pinos de alimentação disponíveis, diferente do que ocorre no

Duemilanove, mas em relação ao tamanho, esta placa é semelhante à Mini, porém

um pouco mais alongada.

Figura 2.9 – Arduino Nano


2.4.8 Versão Arduino Bluetooth

O Arduino Bluetooth é uma placa que se difere em vários aspectos as

Arduinos tradicionais. Como o próprio nome sugere, o Arduino Bluetooth possui

conexão sem fio via Bluetooth incorporado na placa, conforme Figura 2.10.

Devido a sua complexidade, esta é a placa Arduino com o orçamento

mais alto e também a mais sensível. Sua alimentação é de no máximo 5,5 V que

serve para carregar a bateria presente no módulo.

Possui algumas outras peculiaridades, como por exemplo, o módulo de

Bluetooth, que deve ser configurado conforme exige o fabricante.

32

Figura 2.10 – Arduino Bluetooth


2.4.9 Versões Arduino Fio e Lilypad

Estas duas placas Arduino são de uso mais específico. O Arduino Lilypad

foi desenvolvido em um formato circular o que viabiliza a sua aplicação, que é ser

incorporado a roupas e tecidos dentre outras aplicações.

Já o Arduino Fio é uma placa desenvolvida para com o Funnel, que é uma

linguagem de programação baseada em redes funcionais. Possui um ponto de

Wireless contendo inclusive um conector para ser acoplado um dispositivo sem fio.

A Figura 2.11 mostra o formato dessas placas.

Figura 2.11 – Arduino Fio e Lilypad


33

2.4.10 Principais Diferenças

Cada Arduino tem sua particularidade, sendo que o melhor é buscar o

custo/benefício mais interessante. O mercado proporciona opções de alto e baixo

custo, que fazem toda a diferença na montagem final do projeto, dependendo do

propósito do mesmo.

Projetos mais simples que não exigem otimização de espaços, podem

utilizar um Arduino UNO ou Duemilanove, dependendo se é necessário uma boa

velocidade do microcontrolador ou não. Aplicações em que velocidade não é

extremamente essencial, o Arduino Duemilanove é suficiente. Caso contrário, um

Arduino UNO é mais interessante, já que o carregamento do arquivo de inicialização

para a memória de programa do microcontrolador principal é executado por um

microcontrolador a parte.

De acordo com a publicação científica Programar 2008, “o bootloader é

uma ferramenta que quando ligada possibilita que o Arduino receba os comandos

diretamente da porta USB”. Em outras palavras, o carregador do arquivo de

inicialização (bootloader) permite um canal direto de carregamento da placa com o

computador, o que dá uma velocidade muito grande na execução do projeto, pois a

própria placa funciona como gravadora do microcontrolador.

Quando são necessárias muitas portas de I/O, digitais ou analógicas, o

Arduino Mega é a melhor opção. Projetar um hardware e ainda ter de multiplexar as

portas I/O para aumentar a variabilidade do Arduino UNO ou Duemilanove muitas

vezes se torna mais dispendioso do que adquirir um Arduino Mega.

Quando se fala em otimização de espaços, os Arduinos Mini e Nano são

as opções mais adequadas, já que se assemelham praticamente a CIs de 40 pinos

DIP. O layout dessas placas foi feito pensando nesta premissa.

O Arduino Bluetooth é uma opção bastante onerosa, mas que

dependendo da situação é mais simples de aplicar do que adquirir um sistema sem

fio e acoplar externamente a outro tipo de Arduino. No mercado é possível adquirir

placas baseadas no Arduino, como o Freeduino, o Chinduino, Seeduino, Iluminato e

até mesmo a versão brasileira com uma estampa da bandeira do Brasil na parte de

baixo da placa. Todas estas placas são os chamados clones e podem apresentar

peculiaridades em relação ao original, inclusive melhorias como uso de um

microcontrolador mais eficiente, maior número de portas, entre outros.

34

A escolha da placa fica por conta da relação custo benefício do projeto,

que deve fazê-lo da melhor forma possível e pensando em todas as possibilidades

futuras, mas se necessário mudar o tipo de placa Arduino depois de iniciado o

projeto, não há problema algum, já que todas as placas tem a linguagem compatível

entre si.

2.5 Placas Arduino SensorShield

O Arduino possui uma séria de adaptadores, que otimizam as suas

funcionalidades, conforme as Figuras 2.12 e 2.13, denominados Arduinos

sensorshields. Os sensorshields são placas plug and play que garantem ao Arduino

uma peculiaridade no desenvolvimento de projetos.

Possuem funções pré-definidas, tais como zigbee (comunicação sem fio),

controle remoto, adaptador ethernet, interface com motores e adaptação para vários

tipos de sensores. São facilmente adaptáveis ao Arduino e servem para aplicações

específicas.

Figura 2.12 – Arduino Sensorshields – Módulos Zigbee e InputShield

Fonte: Arduino,2011

35

Figura 2.13 – Arduino Mega GSM GPRS GPS

Fonte: Arduino, 2011

36

3 CARACTERÍSTICAS TÉCNICAS

Os microcontroladores ATMEGA são bastante flexíveis e os programas

desenvolvidos para um microcontrolador desta família necessitam de poucos

ajustes, às vezes até nenhum, para serem utilizados em outros microcontroladores

do mesmo gênero, diferentemente de outros modelos.

Os microchips utilizados nas placas Arduino são: ATMEGA8,

ATMEGA168, ATMEGA328, ATMEGA1280 e ATMEGA2560. Cada qual possui

peculiaridades, como disposição dos pinos, mas a programação é a mesma e vale

para qualquer um deles.

No Arduino ainda é utilizado um cristal ressonador de 16 MHz como

gerador do sinal de "clock" externo dos microcontroladores. Isto possibilita que o

microcontrolador execute cerca de 16 milhões de instruções por segundo.

Em relação aos recursos de cada um dos microcontroladores, é

apresentado na Tabela 3.1 um comparativo com as principais características

relativas ao ATMEGA.

Tabela 3.1 – Comparativo com as principais características relativas ao ATMEGA

ATMEGA PortasI/O Flash(Kb) EEPROM(Kb) SRAM(Kb) CanaisA/D UART

8 23 8 0,5 1 6 1

168 23 16 0,5 1 8 1

328 23 32 1 2 8 1

1280 86 128 4 8 16 4

2560 86 256 4 8 16 4

Fonte: Rosa, 2011

Alguns conceitos básicos sobre as características destes

microcontroladores são:

• Portas de I/O são as portas de entrada e saída de dados, analógicos ou

digitais, e que servem para comunicar externamente o microcontrolador e

hardware.

• A memória flash delimita o tamanho máximo do programa que será executado

pelo Arduino. O bootloader do Arduino ainda utiliza uma pequena parcela desta

memória.

37

• A memória EEPROM é uma memória utilizada para armazenar dados, os

quais só serão excluídos quando o programa sobrescrevê-los.

• A memória SRAM é uma memória utilizada para armazenar dados

temporários.

• Canais A/D são canais que convertem dados analógicos em digitais. No

ATMEGA a conversão A/D tem precisão de 10 bits.

• UART é um periférico responsável pela comunicação serial entre o

microcontrolador e o mundo externo, como por exemplo a comunicação serial

entre Arduino e PC.

No presente trabalho foi adotada como placa padrão o Arduino UNO e o

Duemilanove para execução dos projetos desenvolvidos e demonstração dos

exemplos de programação. Entretanto, os resultados obtidos podem ser adaptados

para quaisquer outros modelos.

3.1 Arduino e a Conexão com o Computador

O software utilizado para desenvolver os projetos da plataforma Arduino

denominado Arduino IDE (Integrated Development Environment ou Ambiente de

Desenvolvimento Integrado), pode ser utilizado em qualquer uma das placas da

família Arduino.

Nesta seção são apresentados alguns aspectos desse software bem

como da conexão da placa com o computador e algumas inconsistências que podem

interferir na comunicação. Em seguida é descrita a placa Arduino UNO por completo,

todos os pinos externos e componentes que fazem parte do projeto da placa

explicitando as suas funções e os recursos disponíveis.

3.1.1 Software Arduino IDE

O Arduino IDE é um programa multitarefa desenvolvido em JAVA,

utilizado para criar, salvar, editar e compilar os programas e carregá-los na placa

Arduino, além de apresentar outros recursos como gravação do bootloader em um

microcontrolador ATMEGA e um monitor serial simples.

38

O programa possui uma interface simples e rápida, que inclui um editor de

códigos-fonte com recursos de realce e identificação automática de determinados

códigos digitados no programa.

O programa ainda possui uma série códigos-fonte exemplos, uma

ferramenta que auxilia o programador a aprender a linguagem Arduino ou relembrar

códigos necessários durante o projeto que está sendo desenvolvido.

A Figura 3.1 mostra a tela do software Arduino em execução.

Figura 3.1 – Software Arduino


Na página oficial do Arduino é realizado o download de um arquivo

compactado, no qual está uma pasta que contém uma quantidade razoável de

arquivos, drivers para instalação do CI FTDI, exemplos, bibliotecas, referências,

entres outros.

No Anexo I desse trabalho é apresentado todo o passo a passo da

utilização do programa com todos os módulos e características da linguagem.

39

3.2 A Placa Arduino UNO

A placa Arduino UNO é a mais recente e pode-se considerá-la atualmente

como referencia dessa plataforma. Ela é derivada da placa Arduino Duemilanove

que possui um CI de conversão RS232 – USB. A grande novidade desta placa está

na redução do bootloader do sistema que foi incorporado a um ATMEGA8. A Figura

3.2 mostra em detalhes, os diversos componentes da Arduino UNO.

Figura 3.2 – Design da placa Arduino UNO


Para detalhar a funcionalidade dos pinos, observa-se na Figura 3.2, a

partir do primeiro pino no canto superior direito da placa, o pino digital 0 e seguindo

no sentido anti-horário, temos os seguintes componentes e funções:

• Pinos 0 e 1: São portas de I/O digitais quando o modo serial não for utilizado

no código fonte. No caso de necessitar de porta serial para comunicar durante o

programa, estas duas portas não serviram de I/O digitais, apenas para

comunicação (são os pinos Tx e Rx).

• Pinos 2 à 13: São as portas de I/O digitais. São portas onde o sinal de saída

será 0 V ou 5 V, conforme o código fonte executar. Nas portas 11, 10, 9, 6, 5 e 3

estão disponíveis os 6 canais PWMs da placa. Ainda nestes pinos tem-se

40

algumas outras funções especiais, como as ligações SPI e 2 interrupções

externas (pinos 2 e 3).

• Pino GND: Porta referente a um terra digital. Utilizado como terra referencial

do hardware externo.

• Pino AREF: Porta de entrada, responsável por receber um sinal de referência

externa para o conversor A/D do Arduino. Se este pino ficar flutuando, o Arduino

considerará como referência 0 V.

• Pinos Analog in: São as 6 portas analógicas da placa e possuem conversão

A/D com 10 bits de precisão, ou seja, é possível obter 1024 níveis de tensão

diferentes com estes 10 bits (2 bits). Estes pinos podem ser utilizados como

portas de entrada e saída e ainda nestes, está disponível a comunicação I2 C.

• Pinos de alimentação (Power): Podem ser utilizados como fonte de tensão

para o hardware externo, entrada de energia no pino Vin e um pino de reset

externo. São 2 níveis de tensão para alimentação externa (5 V e 3,3 V) e GND.

• Pinos ICSP: Estão disponíveis para o caso de se desejar gravar algum

programa ou o bootloader da placa Arduino e significa In-System Programmer. Se

observado corretamente, pode-se utilizar esses pinos para comunicação SPI da

placa, pois os pinos MISO, MOSI e SCK estão conectados nestes pinos.

O Arduino também possui uma série de outros elementos que são

integrantes básicos das estruturas das placas. São eles:

• Botão de Reset: Este botão é o reset e está ligado diretamente ao reset do

microcontrolador e tem por função facilitar ao usuário a reinicialização da placa.

• Cristal Oscilador: É um componente extremamente importante na placa

Arduino, pois trata-se do gerador de clock com precisão do microcontrolador.

• Conversor RS232 – USB: No caso do Arduino UNO, este componente é um

outro microcontrolador (ATMEGA 8).

• Adaptador de entrada para fonte: É a entrada jack para uma fonte de

alimentação externa do tipo fonte CA/CC com tensão máxima de 15 V, sendo

que o ideal é a utilização de fonte de alimentação com tensão entre 7,5 V e 10 V.

É possível se utilizar uma bateria de 9 V com um adaptador para este tipo de

entrada.

41

• Regulador de tensão: Regulador de tensão do tipo 7805M para regular e

estabilizar em 5 V uma alimentação de uma fonte de tensão externa.

• Entrada USB: Utilizada para comunicação e programação da placa Arduino.

Esta entrada pode ser utilizada como fonte de alimentação, já que a USB do PC

fornece uma alimentação de 5 V estável.

• Microcontrolador ATMEGA328: Responsável por praticamente todas as

funções e que no caso da placa UNO, trata-se de um ATMEGA328.

• LED de sinalização: São quatro os LED de sinalização presentes na placa,

sendo:

o LED de Potência: Indica que a placa está alimentada;

o LED Serial Tx e Rx: Sinalizam que está ocorrendo transmissão

de dados e recepção de dados de e para a placa.

o Pino 13 LED: É o único LED presente na placa para utilização

via código. É ligado ao pino 13 de I/O digital e pode ser utilizado

como teste de verificação de defeito da placa.

42

4 PROJETOS E IMPLEMENTAÇÕES COM O ARDUINO

Neste capítulo são abordadas várias potencialidades e funcionalidades da

placa Arduino bem como a descrição completa de alguns projetos que utilizam essa

placa como principal elemento de controle.

Os projetos também podem ser implementados com os shields, que são

placas adicionais que podem ser agregadas ao Arduino original para aumentar as

suas capacidades de processamento, expansão de pinos e funcionalidades. Dentre

essas funcionalidades podemos destacar os shields de ethernet, TCP/IP sem fio,

motorshield etc.

Os shields seguem a mesma filosofia que o conjunto de ferramentas

originais: são fáceis de montar e baratos de produzir e foram desenvolvidos tendo

como o principal foco a funcionalidade do projeto e não na arquitetura do

microcontrolador que está sendo utilizado. Os shields são acompanhados de

códigos para servir como interface com o código principal de tal forma que devemos

incluir as bibliotecas referentes à sua função para o devido reconhecimento da placa

principal do projeto.

4.1 Projetos Elementares

Os projetos, com implementações práticas apresentados nesta seção

envolveram acionamentos de dispositivos de saída, leitura das entradas do Arduino,

acionamento sequencial e o acionamento de um motor via PWM do Arduino.

4.1.1 Acionamento de Dispositivos de Saída

O projeto em questão é desenvolvido com o intuito de descrever as

ferramentas necessárias para implementar um acionamento de dispositivos de saída

pelos pinos da placa Arduino. No presente experimento foi demonstrado o simples

acionamento de um LED (Light Emitter Diode), conforme mostrado na Figura 4.1.

As placas Arduino são projetadas de forma a facilitar o piscar de um LED

com o uso do pino digital 13, como apresentado na Figura 3.2. As novas placas já

são fabricadas com o LED instalado e também placas existe um resistor de 1 kΩ no

43

pino 13, o que lhe permite conectar o LED diretamente a ele. Para conexão a outro

pino digital, deve-se usar um resistor externo.

Figura 4.1 – Conexão do LED na placa Arduino

No Quadro 4.1, temos o código para ser compilado e executado na placa

Arduino. O código de exemplo é muito simples, pois demonstra o acionamento dos

pinos de saída da placa em nível alto e baixo para respectivamente ligar e desligar.

Quadro 4.1 – Código de acionamento dos pinos de saída

Existem situações em que é necessário que o dispositivo seja acionado

em intervalos periódicos ao mesmo tempo em que outra função é executada (tal

como observar o estado de um interruptor). Para tanto não se deve usar a função

delay ( ), senão todo o restante do programa fica paralisado enquanto o LED pisca.

Para demonstrar esse exemplo segue um código que demonstra como é

possível acionar um dispositivo periodicamente (nesse caso um LED) sem o uso da

função delay ( ). O que o programa faz é observar quando foi a última vez que o LED

foi ligado ou desligado e assim, a cada ciclo de loop ( ), verificar se passou o tempo

/*LED pisca-pisca: liga e desliga um LED conectado a um pino digital em intervalos de 2 segundos. */ void setup( ) pinMode(13, OUTPUT); void loop( ) digitalWrite(13, HIGH); // liga o LED delay(1000); // aguarda 1 segundo digitalWrite(13, LOW); // desliga o LED delay(1000); // aguarda mais um segundo

44

determinado, se esse tempo tiver passado, o LED é ligado caso esteja desligado e

vice-versa.

O código do Quadro 4.2 deve ser o padrão frente à função delay ( ), pois

o delay significa que o microcontrolador irá aguardar um determinado intervalo de

tempo não executando nenhuma outra atividade, um estado de inércia que nem

sempre é interessante para o projeto.

Quadro 4.2 – Código pisca LED

constintLEDPin = 13; //LED conectado ao pino digital 13 intLEDtate = LOW; // ultimo valor do LED longpreviousMillis = 0; // ultimo momento que LED foi atualizado longinterval = 1000; // tempo de transição entre estados (milisegundos) void setup() pinMode(LEDPin, OUTPUT); // configura o pino digital como saída void loop() // verifica se é o melhor momento para atualizar o LED, ou seja, se a diferença entre o tempo atual e o último tempo que piscamos o LED é maior que o tempo de transição entre estados? unsigned long currentMillis = millis(); if(currentMillis - previousMillis> interval) // ultimo tempo em que o LED piscou previousMillis = currentMillis; // se o LED está apagado acenda-o ou vice-versa: if (LEDtate == LOW) LEDtate = HIGH; else LEDtate = LOW; digitalWrite(LEDPin, LEDtate);

45

4.1.2 Acionamento do Arduino via Dispositivo de Entrada

O interruptor instantâneo é um componente que conecta dois pontos de

um circuito ao pressioná-lo. O exemplo a seguir, liga um LED quando é pressionado

um interruptor.

Conforme mostrado na Figura 4.2, verifica-se que foram conectados dois

fios à placa Arduino. O primeiro vai de um dos terminais do interruptor ao GND. O

segundo vai do outro terminal do interruptor até o pino digital 2 do Arduino. Foi

ligado um resistor pull-up de 10 kΩ nesse último terminal (um terminal do resistor vai

ao terminal do interruptor; o outro vai ao pino de fornecimento de 5 V do Arduino).

Quando o interruptor está livre (não pressionado), não há conexão entre

seus dois terminais, de forma que o pino do Arduino está conectado aos 5 V (via o

resistor pull-up) e ao ler o pino, obtém-se um nível alto. Quando o interruptor é

fechado (pressionado), ocorre à conexão entre seus terminais, de forma que o pino

do Arduino é ligado ao terra do circuito e obtém-se um nível baixo. Nesse caso,

observa-se que o pino ainda se mantém conectado aos 5 V, mas o resistor de pull-

down com que o pino esteja mais próximo ao terra. O circuito também pode ser

ligado na lógica reversa com o resistor de pull-up mantendo o pino 2 em nível baixo.

Se por acaso o pino digital for desconectado da montagem, o LED poderá

piscar de forma irregular, porque no pino o nível de tensão está flutuando com

valores aleatórios, entre níveis alto e baixo. Por isso se utiliza um resistor de pull-up

ou pull-down no circuito. O código referente à aplicação prática está presente no

Quadro 4.3.

Figura 4.2 – Interruptor na placa Arduino


46

Quadro 4.3 – Código do acionamento de um pino

Em situações mais críticas, necessita-se de um filtro para evitar ruídos do

interruptor toda vez que ele é acionado, pois trepidações causam reconhecimento

semelhante a múltiplos toques. O código apresentado no Quadro 4.4 realiza esse

filtro através da função milis ( ) para acompanhar o momento em que o interruptor é

pressionado. Esta função também permite o ajuste do tempo de filtragem, em

diversos projetos esse tipo de função é interessante, por parametrizar o ajuste de

tempo em que função atuará no sistema a fim de evitar a trepidação.

intLEDPin = 13; // escolha o pino para o LED intinPin = 2; // escolha o pino de entrada (para o interruptor) intval = 0; // variável para ler o estado do interruptor void setup() pinMode(LEDPin, OUTPUT); // declara-se o LED como saída pinMode(inPin, INPUT); // declara-se o interruptor como entrada void loop() val = digitalRead(inPin); // ler o valor de entrada if (val == HIGH) // verificar se a entrada é HIGH (interruptor livre) digitalWrite(LEDPin, LOW); // desligar LED else digitalWrite(LEDPin, HIGH); // ligar LED

47

Quadro 4.4 – Código do filtro de ruído de uma chave

intinPin = 7; // o número do pino de entrada intoutPin = 13; // número do pino de saída intstate = HIGH; // estado atual do pino de saída intreading; // estado atual do pino de entrada intprevious = LOW; // estado anterior do pino de entrada // as seguintes variáveis são do tipo ''long'' porque o tempo, // medido em milissegundos, // transformar-se-á logo em um valor grande demais para um ''int'' long time = 0; // último momento em que o pino de saída foi atualizado longdebounce = 200; // tempo do filtro, aumente se ocorrer irregularidades void setup() pinMode(inPin, INPUT); pinMode(outPin, OUTPUT); void loop() reading = digitalRead(inPin); // se acabamos de pressionar o interruptor (isto é, se a entrada // foi de LOW para HIGH), e esperamos o bastante desde o // último toque de forma a ignorar o ruído... if (reading == HIGH &&previous == LOW &&millis() - time >debounce) // inverta a saída if (state == HIGH) state = LOW; else state = HIGH; // ...e lembre-se do momento do último toque time = millis(); digitalWrite(outPin, state); previous = reading;

48

4.1.3 Acionamentos Sequenciais

Neste experimento são utilizados seis LED para apresentar um modo

sequencial de acionamento dos dispositivos de saída do Arduino, conforme

mostrado na Figura 4.3. Os LED estão conectados do pino 2 ao 7 da placa, com o

uso de resistores de 330 Ω.

O código de acionamento sequencial é apresentado no Quadro 4.5 e

através dele é produzido piscar dos LED em sequência, um por um, utilizando para

tal duas funções: uma para acionar a saída e outra para gerar um retardo.

Figura 4.3 – Acionamento sequencial

Quadro 4.5 – Código acionamento sequencial

int timer = 100; // Quanto maior, mais devagar. int pins[] = 2, 3, 4, 5, 6, 7 ; // vetor com o número dos pinos intnum_pins = 6; // quantidade de LED (tamanho do vetor) void setup() int i; for (i = 0; i <num_pins; i++) // elementos do vetor vão de 0 a num_pins - 1 pinMode(pins[i], OUTPUT); // configurar cada pino como saída void loop() int i; for (i = 0; i <num_pins; i++) // varrer cada pino... digitalWrite(pins[i], HIGH); // ligando-o, delay(timer); // pausando-o, digitalWrite(pins[i], LOW); // e desligando-o. for (i = num_pins - 1; i >= 0; i--) digitalWrite(pins[i], HIGH); delay(timer); digitalWrite(pins[i], LOW);

49

4.1.4 Acionamento de um motor dc via PWM do Arduino

Neste experimento é desenvolvido o acionamento de um motor dc de

12 V via PWM de uma placa Arduino, conforme mostrado na Figura 4.4. O controle

do motor é feito a partir da leitura de um potenciômetro, cujo valor de tensão é usado

como referência para o ajuste do ciclo de trabalho do PWM. Com base no valor de

tensão do potenciômetro, o Arduino ajusta o tempo dos níveis alto e baixo do PWM,

de modo a controlar o motor dc.

Para o desenvolvimento do experimento, foram utilizados os seguintes

componentes:

1 placa Arduino Duemilanove

1 MOSFET IRF540

2 Resistores: 1 de 1 kΩ e outro de 10 kΩ

1 Motor DC de 12 V

O código utilizado no acionamento do motor dc é apresentado no

Quadro 4.6.

Figura 4.4 – Acionamento de um motor de corrente contínua

50

Figura 4.5 – Transistor MOSFET

Quadro 4.6 – Código do acionamento

O experimento desenvolvido demonstrou a potencialidade do Arduino ao

controlar um motor de corrente contínua via modulação PWM, que é um tipo de

acionamento muito comum em automação e controle.

O Arduino UNO possui no total 12 pinos de I/O digitais, cujos valores de

tensão são 0 V ou 5 V. As portas PWM estão disponíveis em seis canais, que são as

portas 3, 5, 6, 9, 10 e 11. Para o experimento em questão, foi utilizado o pino 9 para

gatilhar o MOSFET que comuta para o funcionamento do motor dc.

intsensorPin = A0;

intsensorValue = 0;

void setup()

pinMode(9, OUTPUT);

Serial.begin(9600);

void loop()

sensorValue = analogRead(sensorPin);

analogWrite(9,sensorValue/4);

Serial.println(sensorValue/4);

delay(10);

51

4.2 Projeto do Controle Remoto IR

O projeto do controle remoto IR precisou de um sensor receptor

infravermelho. O receptor utilizado foi o IRM3638, apresentado na Figura 4.6, que foi

conectado à placa Arduino como forma de receber o sinal infravermelho. A ideia

básica do projeto é enviar comandos de um controle remoto para o Arduino através

do receptor IR com os valores dos acionamentos sendo apresentados em um

display de LCD 16 x 2.

4.2.1 Teoria do Controle Infra Vermelho

A comunicação por um sinal infra-vermelho foi desenvolvida ao longo dos

anos, sendo hoje a forma mais barata para controlar remotamente um dispositivo.

Quase todos os equipamentos de áudio e vídeo podem ser controlados dessa

maneira.

O uso dos componentes que são utilizados para implementar sistemas de

controle infra-vermelho ficou generalizado, de modo que o preço desses

dispositivos cada vez mais acessível ao desenvolvedor.

A seguir é apresentado o modelo de comunicação infravermelha bem

como exposição do protocolo de comunicação que foi utilizado para estabelecer as

regras de comunicação do controle IR com o Arduino. Não é objeto desse trabalho

discutir sobre os protocolos de comunicação via sinal infra-vermelho, mas a próxima

subseção destina-se exclusivamente ao tratamento do protocolo NEC, que viabiliza

a comunicação desses dispositivos.

Figura 4.6 – Receptor infravermelho

52

4.2.2 Protocolo NEC – Características Técnicas

O protocolo NEC é um formato de protocolo japonês utilizado em

produtos como os da Sanyo mais antigos. Tem como característica um sinal de 16

bits, sendo 8 bits de endereço e 8 bits de comando. Para diminuição de erros, são

transmitidos duas vezes na mensagem, com uma portadora de 38 kHz. Além disso,

existe diferenciação de tempo para a interpretação dos níveis lógicos positivo e

negativo, sendo 1,12 ms para o nível “0” e 2,25 ms para o nível “1”. A indicação de

um bit, 0 ou 1, é sempre com o envio de um trem de pulsos de duração de 560 µs

como mostrados na Figura 4.7:

Figura 4.7 – Pulsos NEC

Fonte: SB-PROJECTS, 2006

Como exemplo de uma mensagem gerada por esse protocolo tem-se a

Figura 4.8 com o endereço $59 e comando $16 iniciando por um bit de 9 ms AGC

(Controle de Ganho Automático), seguido por um espaço de 4,5 ms.

Figura 4.8 – Endereço $59 comando 16 no NEC


O grande diferencial desse protocolo é a utilização de um bit específico

para repetições de 9 ms AGC, espaçado por 2,25 ms e novo nível de tensão por 560

µs e repetido a cada 110 ms, como mostrado na Figura 4.9:

53

Figura 4.9 – Repetição de sinal NEC


No Quadro 4.7, são apresentados os códigos de VCR Fisher 530.

Quadro 4.7 – Códigos e endereços de VCR com NEC


4.2.3 Projeto com acionamento de display de cristal via controle remoto

O projeto desenvolvido com a placa Arduino para receber sinais IR, foi

concebido com a itenção de demonstrar a chegada dos dados ao arduino via

controle remoto e o receptor IRM3638. Para tanto foi utilizado:

1 Controle IR

1 Receptor IR

1 Display LCD 16 x 2

1 Arduino Duemilanove

1 LED

1 Resistor de 10 kΩ

NEC Message Key Function $68-$00 Play $68-$01 Rec $68-$02 AudioDub $68-$03 Frame $68-$04 Slow $68-$05 Quick $68-$06 Cue $68-$07 Review $68-$08 FF $68-$09 Rew $68-$0A Stop $68-$0B Pause/Still $68-$0C Upkey $68-$0E Down key

54

Figura 4.10 – Montagem do Arduino com o display de cristal líquido

Figura 4.11 – Conexão do receptor infravermelho com o Arduino.

55

Figura 4.12 – Controle infravermelho utilizado no projeto


O presente projeto tem a finalidade de apresentar como acontece o envio

de dados do controle IR para a placa Arduino passando pelo receptor IR. Os valores

numéricos são apresentados na tela do display de LCD, conforme mostrado nas

Figuras 4.10, 4.11 e 4.12.

O que é percebido com esse projeto é a relativa facilidade para

implementação de envio de dados via infravermelho, pois pode-se enviar e receber

comandos para fazer qualquer tipo de acionamento e que possibilita uma gama

muito grande de possibilidades para a mecatrônica, com o acionamento a distancia

de diversos equipamentos, bastando apenas adaptar o código à realidade do projeto

a ser desenvolvido.

O código para acionamento do controle IR é apresentado no Quadro 4.8.

56

Quadro 4.8 – Código de acionamento do controle IR

#include <LiquidCrystal.h> #define IR_IN 8 LiquidCrystallcd(12, 11, 5, 4, 3, 2); intPulse_Width=0; intir_code=0x00; charadrL_code=0x00; charadrH_code=0x00; void timer1_init(void) TCCR1A = 0X00; TCCR1B = 0X05; TCCR1C = 0X00; TCNT1 = 0X00; TIMSK1 = 0X00; voidremote_deal(void) lcd.clear(); delay(1); lcd.setCursor(0,0); lcd.print(ir_code,HEX); lcd.setCursor(0,1); lcd.print(adrL_code,HEX); charlogic_value() TCNT1 = 0X00; while(!(digitalRead(8))); Pulse_Width=TCNT1; TCNT1=0; if(Pulse_Width>=7&&Pulse_Width<=10)//560us while(digitalRead(8)); Pulse_Width=TCNT1; TCNT1=0; if(Pulse_Width>=7&&Pulse_Width<=10)// 560us return 0; else if(Pulse_Width>=25&&Pulse_Width<=27) // 1.7ms return 1; return -1; voidpulse_deal() int i; int j; ir_code=0x00; adrL_code=0x00; adrH_code=0x00; for(i = 0 ; i < 16; i++) if(logic_value() == 1) ir_code |= (1<<i); for(i = 0 ; i < 8; i++) if(logic_value() == 1) adrL_code |= (1<<i);

57

for(j = 0 ; j < 8; j++) if(logic_value() == 1) adrH_code |= (1<<j); voidremote_decode(void) TCNT1=0X00; while(digitalRead(8)) if(TCNT1>=1563) ir_code=0x00ff; adrL_code=0x00; adrH_code=0x00; return; TCNT1=0X00; while(!(digitalRead(8))); Pulse_Width=TCNT1; TCNT1=0; if(Pulse_Width>=140&&Pulse_Width<=141)//9ms while(digitalRead(8)); Pulse_Width=TCNT1; TCNT1=0; if(Pulse_Width>=68&&Pulse_Width<=72)//4.5ms pulse_deal(); return; else if(Pulse_Width>=34&&Pulse_Width<=36)//2.25ms while(!(digitalRead(8))) Pulse_Width=TCNT1; TCNT1=0; if(Pulse_Width>=7&&Pulse_Width<=10)//560us return; void setup() unsigned char i; pinMode(IR_IN,INPUT); lcd.begin(16, 2); void loop() timer1_init(); while(1)

58

5 ARDUINO E A CONEXÃO COM A INTERNET

Os sistemas de comunicação digital de dados, em especial a Internet, vem se

tornando um meio cada vez mais essencial para o homem moderno, aumentando

significativamente a eficiência daqueles que utilizam seus recursos. Com acessos

dedicados e com a possibilidade de distribuição desse recurso em grande escala por

um baixo custo, a utilização da internet difundiu-se nos meios residenciais,

industriais e consequentemente no meio empresarial.

Atualmente a Internet tem seu emprego em larga escala nos computadores pessoais que dispõem de sistemas operacionais com todo o protocolo embutido em seu kernel, cabendo aos usuários e programadores apenas utilizar esses recursos. Esse sistema é e ainda será por muitos anos o carro-chefe das aplicações da grande rede. Porém, com a evolução dos microcontroladores, uma nova geração de aplicações está se formando, são as aplicações embedded (embarcadas) para a Internet. (MOKARZEL, 2004, p.11)

Essa nova tecnologia possibilita a construção de hardware clientes e

servidores de Internet a um custo muito baixo. É possível imaginar uma gama de

produtos que pode ser criada ou aprimorada com o emprego dessa nova ferramenta.

Desde brinquedos e aplicações domésticas até o monitoramento e controle de

equipamentos na indústria, uma nova geração de telefonia IP de baixo custo e

equipamentos interativos monitorados pelo celular.

Hoje não só computadores, como outros dispositivos baseados em

microprocessadores podem compartilhar uma rede local. Se antes um computador

compartilhava uma impressora na rede local, hoje a própria impressora é uma parte

da rede com uma interface e um endereço de IP próprio. Além do mais, temos PDAs

(computadores de mão), celulares, netbooks e várias outras criações embarcadas

com tecnologia baseada em microcontroladores de uso geral compartilhando

informações na rede. O futuro dos eletrodomésticos está na evolução e integração

de todos esses sistemas na rede.

O Arduino oferece uma grande facilidade de colocar os dispositivos nessa

rede de comunicação uma vez que existe um sensorshield que funciona unica e

exclusivamente para conectar a plataforma Arduino com a Internet.

59

5.1 Protocolo de rede TCP/IP e Ethernet

O TCP/IP é um conjunto de protocolos usado em redes na Internet. Um

protocolo é um conjunto de normas que dois ou mais computadores devem usar

para estabelecerem uma comunicação entre si. Fala-se em conjunto de protocolos

para o TCP/IP, pois várias especificações estão envolvidas. Tecnicamente, ele é

tratado como uma pilha de protocolos de comunicação.

De acordo com Kurose 2006, a Ethernet praticamente tomou conta do

mercado de redes com fio. Na década de 80 e início da década de 90, ela enfrentou

muitos desafios de outras tecnologias LAN, incluindo tokeng ring, FDDI e ATM.

Algumas dessas outras tecnologias conseguiram conquistar uma parte do mercado

de LANs durante alguns anos. Mas, desde sua invenção, em meados da década de

1970, a Ethernet continuou a se desenvolver e crescer e conservou a sua posição

dominante no mercado. Hoje, ela tem predominado como tecnologia de LAN com fio

e é provável que continue assim no futuro próximo. Kurose 2006 compara a Ethernet

que está sendo usada para a rede local com o que a Internet tem sido para a rede

global.

A Ethernet é a camada de sinalização de baixo nível básico que fornece a capacidade de transmissão de mensagens físicas. Endereços de origem e de destino para estas mensagens são identificadas por um Media Access Control (MAC). Seu esboço Arduino define um valor de endereço MAC, que deve ser exclusivo em sua rede. (MARGOLIS, 2011, p. 451)

Com base nessa potencialidade da Ethernet, é possível colocar sistemas

embarcados funcionando como webserver robustos que podem trabalhar em tempo

real em aplicações que exigem um nível de criticidade elevado.

60

5.2 Camadas do Protocolo

Nesta seção serão descritos os modelos de referências de camadas

ISO/OSI, as funções das camadas internet e as camadas de transporte TCP/IP.

5.2.1 Modelo ISO/OSI x Internet

O Modelo OSI é uma referência de camadas para o funcionamento da

rede. Nele a rede é dividida em sete camadas bem definidas, cada uma com sua

função própria, para facilitar o desenvolvimento da rede, conforme apresentado na

Figura 5.1.

Cada camada é um grupo de funções similares que fornece serviços à

camada superior e recebe serviços da camada inferior.

As sete camadas desse modelo são: Camada de Aplicação,

Apresentação, Seção, Transporte, Rede, Link de Dados e Física. Existe uma

simplificação para o Modelo de camadas Internet, no qual as camadas de aplicação,

tradução e seção são agrupadas apenas em aplicação e as camadas link dados e

física agrupadas na camada de rede.

Figura 5.1 – Modelos ISO/OSI

Fonte: MOKARZEL, 2004

É comum descrever a pilha de um protocolo como um conjunto de

camadas, onde cada uma possui sua própria função. Cada camada depende da

61

camada inferior e é fornecedora para a camada superior, conforme a Figura 5.1.

Mokarzel 2004 aponta como vantagem desse sistema a possibilidade de redesenhar

uma das camadas mantendo-se as demais intactas. Por exemplo, ao trocar uma

placa de rede que utiliza cabo UTP por um sistema sem fio, não é necessário

nenhuma adaptação no navegador de página web. A Internet é baseada em uma

simplificação de quatro camadas da arquitetura ISO/OSI de sete camadas.

5.2.2 Funções das Camadas Internet

As camadas do protocolo Internet possuem as seguintes funções,

relacionadas na Tabela 5.1:

Tabela 5.1 – Funções das camadas do protocolo internet

Camada Função Exemplo

Camada de Aplicação

Contém um conjunto de protocolos distintos que provêem os diversos serviços da Internet.

HTTP, FTP e Email (SMTP/POP)

Camada Transporte Possibilita a comunicação entre os pontos da rede. TCP e UDP

Camada Internet Roteia e entrega os datagramas entre os nós da rede.

IP, ICMP e ARP

Camada Rede Implementa a transmissão de pacotes. Ethernet (802.3), PPP e X-25

Fonte: MOKARZEL, 2004

A camada de aplicação é onde residem aplicações de rede e seus

protocolos. Ela inclui muitos protocolos, tais como o protocolo HTTP (que provê

requisição e transferência de documentos pela Web), o SMTP (que provê

transferência de mensagens de correio eletrônico) e o FTP (que provê a

transferência de arquivos entre dois sistemas finais). Verifica-se que certas funções

de rede, como a tradução de nomes fáceis de entender dados a sistemas finais da

Internet (por exemplo, ufma.br) para um endereço de rede de 32 bits, também são

executadas com a ajuda de um protocolo de camada de aplicação, no caso, o

sistema de nomes de domínio (domainname system - DNS).

A camada de transporte da Internet transporta mensagens da camada

de aplicação entre os lados do cliente e servidor de uma aplicação. Há dois

protocolos de transporte na Internet: TCP e UDP, e qualquer um deles pode levar

62

mensagens de camada de aplicação. O TCP provê serviços orientados para

conexão para suas aplicações. Alguns desses serviços são a entrega garantida de

mensagens da camada de aplicação ao destino e controle de fluxo (isto é,

compatibilização das velocidades remetente/receptor). O TCP também fragmenta

mensagens longas em segmentos mais curtos e provê mecanismo de controle de

congestionamento, de modo que uma origem regula sua velocidade de transmissão

quando a rede está congestionada. O protocolo UDP provê serviço não orientado

para conexão a suas aplicações.

A camada de Internet é responsável pela movimentação, de uma

máquina para outra, de pacotes de camada de rede conhecidos como datagramas.

O protocolo de camada de transporte da Internet (TCP ou UDP) em uma máquina de

origem passa um segmento de camada de transporte e um endereço de destino à

camada de rede, exatamente como você passaria ao serviço de correios uma carta

como um endereço de destinatário. A camada de rede então provê o serviço de

entrega do segmento à camada de transporte na máquina destinatária.

A camada de rede da Internet tem dois componentes principais: IP

(Internet Protocol – Protocolo Internet) e protocolo de roteamento. O IP define os

campos no datagrama e o modo como os sistemas finais e os roteadores agem

nesses campos. Existe um único protocolo IP e todos os componentes da Internet

que têm uma camada de rede devem executar esse protocolo. O protocolo de

roteamento determina as rotas que os datagramas seguem da origem ao destino. A

Internet tem muitos protocolos de roteamento.

A Internet é uma rede de redes e, dentro de uma delas, o administrador pode executar qualquer protocolo de roteamento que queira. Embora a camada de rede contenha o protocolo IP e também numerosos protocolos de roteamento, ela quase sempre é denominada simplesmente camada IP, refletindo o fato de que ela é o elemento fundamental que mantém a integridade da Internet. (KUROSE, 2006, p.37)

A camada de Interface de rede é a responsável por lidar diretamente

com o meio físico de envio dos dados, como cabos (de cobre ou fibras ópticas) ou

ondas de rádio. Desse modo, essa camada trata diretamente das características

elétricas e mecânicas, interfaces e switches, enfim, trata do meio por onde os dados

passam.

63

Ela é responsável por receber os datagramas que vêm da camada de

Internet e prepará-los para serem enviados para o meio de transmissão. É

interessante constatar que o meio de transmissão é diverso, existindo vários: pode

ser por sinais elétricos (em redes que utilizam cabos do tipo par trançado), sinais

luminosos (no caso de redes que utilizam fibras ópticas) ou até ondas de rádio

(redes wireless), só para citar como exemplos.

Além disso, a interface de rede é responsável por receber os dados pela

rede (ou seja, enviados pelo meio de transmissão) e garantir que eles cheguem via

Internet.

Os tipos de protocolos usados para garantir o envio dos dados no meio de

transmissão dependem da tecnologia de interconexão utilizada na rede. No

momento, a mais usada e conhecida são as redes Ethernet.

5.2.3 Camada de Transporte TCP/IP

A principal função da camada de transporte TCP é dar robustez ao

sistema, garantindo que mensagens enviadas sejam recebidas. Para isso o TCP

possui as características descritas na Tabela 5.2.

Tabela 5.2 – Características da comunicação TCP/IP

Características Descrição

Transferência básica de dados

Para a camada de aplicação, o TCP é capaz de transferir um fluxo contínuo de octetos de uma estação a outra, empacotando esses octetos em grupos que são transportados pela camada internet. O TCP decide quando e como enviar, se deve separar em blocos ou retransmitir algum pacote.

Robustez

O TCP cuida de recuperar dados que foram danificados, perdidos, duplicados ou recebidos fora de ordem, conferindo robustez ao meio de comunicação. Isso é conseguido pelo sequenciamento dos pacotes e envio de confirmação de recebimento (ACK).

Controle de Fluxo

O TCP provê os meios para que o receptor possa controlar o fluxo de envio. Esse controle é feito através do retorno de uma janela em cada mensagem de ACK, indicando o número de octetos que ainda podem receber além do último aceito.

64

Multiplexação

Para permitir que uma única estação use diversas comunicações TCP simultâneas, o protocolo fornece uma numeração de porta, que combinada com a rede e com o endereço IP, forma um socket. Cada socket é único, desta forma múltiplas conexões simultâneas podem ser geradas.

Conexão Lógica

Os mecanismos de robustez e controle de fluxo descritos anteriormente obrigam o TCP a inicializar e manter certas informações sobre cada fluxo de dados. A combinação dessas informações, que inclui o socket, o número da sequência e o tamanho da janela, chama-se conexão lógica.

Segurança O usuário do TCP deve indicar a segurança e a precedência da sua comunicação.

Fonte: Mokarzel, 2004

5.3 Arduino Ethernet Shield

Trata-se de um módulo capaz de abrir ligações com outros servidores da

Internet ou então, funcionar ele próprio como um mini servidor destinado a páginas

web, não exigindo mais nenhum equipamento para fazer este tipo de atividade.

O Arduino Ethernet Shield, baseia-se num chip w 5100 que é capaz de

fornecer 4 sockets independentes e simultâneo.

Figura 5.2 – Arduino Ethernet Shield


Neste momento do trabalho, será apresentado a maneira como o Arduino

conecta-se com os dados a serem compartilhados em rede, seja ela local ou mesmo

a internet.

65

Existe a possibilidade de desenvolvimento de vários aplicativos que

demonstram como construir e utilizar clientes e servidores web bem como a

interação de protocolos de comunicação mais comuns da Internet com o Arduino.

A Internet permite que um cliente (navegador web, por exemplo) solicite

informações de um servidor (um servidor web ou outro prestador de serviço

Internet). Dentre as diversas possibilidades, o Arduino pode funcionar como servidor

que fornece informações aos clientes utilizando protocolos de Internet podendo agir

como um webserver criando páginas para exibição em navegadores web.

O Arduino Ethernet suporta uma grande variedade de métodos

(protocolos) que permitem a sua adaptação para funcionar como um cliente ou

servidor de Internet. A biblioteca Ethernet usa o conjunto de protocolos padrão da

Internet onde a maior parte da linguagem de baixo nível está oculta.

5.4 Projeto Arduino Ethernet

O Ethernet Shield tem uma entrada para o cabo RJ 45 (cabo de rede),

possibilitando ao Arduino interagir em uma rede pessoal ou até mesmo com a

internet, dessa forma cria-se uma vasta gama de atividades, tais como interagir com

o Arduino remotamente.

A proposta de trabalho é de desenvolver um projeto onde o Arduino

emula um servidor web, onde através de uma página HTML (uma página internet

simples) é enviado o comando, para os LED serem ligados ou desligados e assim

enviar diretamente para o servidor as informações de quando é ligado ou desligado.

Os materiais utilizados para o projeto foram:

1 placa Arduino

1 Ethernet Shield

1 protoboard

1 roteador Linksys WRT545

No presente experimento, o Arduino vai emular um servidor web e depois

receber algum comando para ligar ou desligar os LED que estão conectados na

placa.

66

O Ethernet Shield foi conectado à placa Arduino e para conectar os LED

no Arduino foram utilizados os pinos 4, 5, 6 e7. Os botões foram conectados aos

pinos 8 e 9, conforme a Figura 5.3.

Figura 5.3 – Hardware de acionamento

Em seguida foi conectado o cabo RJ45 do Ethernet Shield no roteador.

Outra peça importante no funcionamento do projeto é o roteador, neste

trabalho um Linksys WRT54G, um roteador wireless com 4 portas LAN. Precisou-se

para esse caso utilizarmos a porta 8246 e IP local. A preferência por usar essa

porta, dá-se pelo fato de a porta 80 ou 8080 bloquear com facilidade.

O programa Arduino é baseado no exemplo webserver.pde com algumas

modificações.

O código HTML é armazenado na memória do programa, de modo a se

obter RAM suficiente para armazenar outros dados.

Para colocar o Arduino em rede, foi atribuído o endereço de IP local

192.168.1.134. Dessa forma, os testes para obtenção de respostas via ethernet ficou

mais canalizado. Esta configuração foi feita no próprio roteador conforme mostrado

na Figura 5.4.

67

Figura 5.4 – Configuração do roteador

Observando a Figura 5.5, pode ser percebida a proposta do trabalho de

forma mais compreensiva, pois na mesma é encontrado o navegador com o script

HTML que está na memória de programa do microcontrolador utilizado no Arduino.

O script apresentado no Quadro 5.1, quando é executado, mostra no navegador web

os comandos que devem ser enviados para o Arduino conforme ordem de

acionamento dos mesmos dentro da respectiva sequência sugerida.

Figura 5.5 – Página Web Arduino

68

Quadro 5.1 – Código fonte para o WebServer

#include <LED.h> #include <Ethernet.h> #include <SPI.h> #include <avr/pgmspace.h> prog_char string_0[] PROGMEM = "<html><body><h2>Controle de LED pela Internet</h2><font size= 4><form method=GET>"; prog_char string_1[] PROGMEM = "<br><input type=submit name=b1 value=LED1>"; prog_char string_2[] PROGMEM = "<br><input type=submit name=b2 value=LED2>"; prog_char string_3[] PROGMEM = "<br><input type=submit name=b3 value=LED3>"; prog_char string_4[] PROGMEM = "<br><input type=submit name=b4 value=LED4>"; prog_char string_5[] PROGMEM = "<br>Insert your name here:"; prog_char string_6[] PROGMEM = "<input name=msg value=no_name MAXLENGTH=20>"; prog_char string_7[] PROGMEM = "</form></body></html>"; prog_char string_8[] PROGMEM = "Ligada (ON)"; prog_char string_9[] PROGMEM = "Desligada (OFF)"; prog_char string_10[] PROGMEM = "<meta http-equiv=refresh content=30 > "; //for auto refresh PROGMEM const char *string_table[] = // change "string_table" name to suit string_0, string_1, string_2, string_3, string_4, string_5, string_6, string_7, string_8, string_9, string_10 ; char buffer[85]; // make sure this is large enough for the largest string it must hold byte mac[] = 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; byteip[] = 192, 168, 1, 134 ; byte gateway[] = 192, 168, 1, 1 ; byte subnet[] = 255, 255, 255, 0 ; String inString = String(35); Server server(8246); LEDLED1 = LED(7); LEDLED2 = LED(6); LEDLED3 = LED(5); LEDLED4 = LED(4); String msg=""; int tam=0; int st1=9,st2=9,st3=9,st4=9; void setup() Serial.begin(9600);

69

Ethernet.begin(mac, ip,gateway,subnet); server.begin(); Serial.println("Serial READY"); Serial.println("Ethernet READY"); Serial.println("Server READY"); pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT); pinMode(7,OUTPUT); pinMode(8,INPUT); pinMode(9,INPUT); void loop() Client client = server.available(); intLED=0; if (client) booleancurrent_line_is_blank = true; while (client.connected()) if (client.available()) char c = client.read(); if (inString.length() < 35) inString.concat(c); if (c == '\n' &&current_line_is_blank) if(inString.indexOf("b1")>0) LED1.toggle(); if(LED1.getState()) st1=8; else st1=9; LED=1; if(inString.indexOf("b2")>0) LED2.toggle(); if(LED2.getState()) st2=8; else st2=9; LED=2; if(inString.indexOf("b3")>0) LED3.toggle(); if(LED3.getState()) st3=8; else st3=9; LED=3; if(inString.indexOf("b4")>0) LED4.toggle(); if(LED4.getState()) st4=8; else st4=9;

70

LED=4; client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); strcpy_P(buffer, (char*)pgm_read_word(&(string_table[0]))); // Necessary casts and dereferencing, just copy. client.println( buffer ); for (int i = 1; i < 8; i++) strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Necessary casts and dereferencing, just copy. client.println( buffer ); switch(i) case 1: strcpy_P(buffer, (char*)pgm_read_word(&(string_table[st1]))); client.println( buffer ); break; case 2: strcpy_P(buffer, (char*)pgm_read_word(&(string_table[st2]))); client.println( buffer ); break; case 3: strcpy_P(buffer, (char*)pgm_read_word(&(string_table[st3]))); client.println( buffer ); break; case 4: strcpy_P(buffer, (char*)pgm_read_word(&(string_table[st4]))); client.println( buffer ); break; delay(30); if(digitalRead(8)==HIGH) client.println("<br>Botao 1, ON"); else client.println("<br>Botao 1, OFF"); if(digitalRead(9)==HIGH) client.println("<br>Botao 2, ON"); else client.println("<br>Botao 2, OFF"); //strcpy_P(buffer, (char*)pgm_read_word(&(string_table[10]))); client.println( buffer ); break; if (c == '\n') // we're starting a new line current_line_is_blank = true; else if (c != '\r') // we've gotten a character on the current line current_line_is_blank = false;

// give the web browser time to receive the data

delay(1);

inString = "";

client.stop();

71

Este experimento funciona com o envio de dados para o webserver

Arduino. Para a utilização da aplicação, é necessário o acesso à placa via IP de rede

que foi atribuído ao dispositivo. Este acesso é realizado através do navegador de

internet que logo retornará as mensagens da página web conforme a Figura 5.5.

A partir desse método, percebemos a potencialidade de aplicação do

Arduino, podendo expandir para projetos mais complexos bem como monitoramento

de sensores a distância e acionamento de dispositivos via web.

//strcpy_P(buffer, (char*)pgm_read_word(&(string_table[10]))); client.println( buffer ); break; if (c == '\n') // we're starting a new line current_line_is_blank = true; else if (c != '\r') // we've gotten a character on the current line current_line_is_blank = false; // give the web browser time to receive the data delay(1); inString = ""; client.stop();

72

6 CONCLUSÕES

A motivação deste trabalho foi provocada pela grande aplicabilidade da

placa Arduino e pela pouca literatura existente dentro do âmbito acadêmico sobre

esse tema. A tecnologia é relativamente nova e desde o seu lançamento está em

franco desenvolvimento e a cada dia ganha mais adeptos tendo em vista a facilidade

e o grande apelo mercadológico que traz. Trata-se de um novo conceito de

hardware aberto possibilitando aos usuários de todo mundo aumentarem as

funcionalidades e potencialidades da plataforma bem como agregar inúmeras

possibilidades de funcionamento de maneira bem rápida.

Por isso, este trabalho apresentou uma proposta de servir como material

didático de suporte a projetistas entre o que atualmente tem-se de bibliografia sobre

o Arduino e o que pode-se fazer em termos práticos para otimizar as potencialidades

deste sistema. Vários experimentos foram realizados em laboratório com o intuito de

testar e/ou adaptar as funcionalidades das placas e otimizar processos que antes,

com os microcontroladores e placas convencionais, despendiam muita energia e

tempo dos projetistas.

Os experimentos desenvolvidos nesse trabalho foram testados e

validados no laboratório. Dentre as diversas possibilidades de projeto com o

Arduino, foi destacado ao longo do trabalho alguns exemplos que foram

implementados utilizando-se pouco hardware, mas que trazem resultados voltados

para aplicações do dia a dia na área de automação de sistemas, tais como

acionamento infravermelho e envio de dados pela ethernet utilizando a placa como

um webserver, etc.

Dentre os diversos experimentos realizados no laboratório o trabalho

apresentou o acionamento de portas, que mostrou como é feita a configuração das

portas do Arduino bem como o seu ajuste para recebimento e envio de dados. Em

seguida, foi demonstrado o funcionamento do sistema de temporização. Os

experimentos mais complexos foram os acionamentos via controle infravermelho e o

webserver. O primeiro mostrou como acionar dispositivos sem fio e o segundo

apresentou como colocar o Arduino na Internet, fato que consolida essa tecnologia

como objetiva e prática, tendo em vista que precisará de apenas uma placa adicional

para servir de interface com a placa principal para o Arduino comunicar-se com a

rede mundial de computadores.

73

O estudo da tecnologia Arduino é muito abrangente e também possui

inúmeras possibilidades de projetos técnico e científicos. Este trabalho mostrou

várias oportunidades de utilizar as funcionalidades do Arduino da maneira mais

prática possível, mostrando também o que existe de tecnologia já desenvolvida e

implementada para o Arduino.

Para trabalhos futuros fica a sugestão de desenvolvimento de

monitoramento e controles de processos através da web com o uso de placas

Arduino, de tal forma que pode-se destacar necessidades de controle e

monitoramento de variáveis importantes de um sistema. Outra importante corrente

de trabalho está no desenvolvimento de aplicações que coloquem o Arduino nas

redes sociais. Nesse trabalho sugerimos o envio de dados pelo Twitter.

Também foram confeccionados vários guias de experimentos que servem

para orientar futuros trabalhos acadêmicos e treinamentos sobre a tecnologia

Arduino.

Tendo em vista a grande quantidade de possibilidades que o Arduino traz

para o mundo da eletrônica, destacam-se a partir dos resultados obtidos nesse

trabalho, a gama de aplicações na área da mecatrônica e da automação, uma vez

que o Arduino oferece rapidez e versatilidade na construção de inúmeras aplicações,

dentre as quais merecem destaque os acionamentos a distância e a comunicação

via Internet.

74

REFERÊNCIAS ARDUINO. Disponível em: <http://www.arduino.cc>. Acesso em: 12/10/2011. Associação Brasileira de Normas Técnicas (ABNT) – NBR14724. 3. ed. Rio de Janeiro: ABNT, 2011 ATMEL Technology. Data Sheet ATMEL328. USA, 2010. EDSON Roberto de Pieri. Curso de Robótica Móvel, Santa Catarina, Florianópolis 2002. EVANS, Brian W. Arduino Program Notebook. 1 ed. San Francisco: EUA, 2008. Introdução ao Arduino. PROGRAMAR: A Revista Portuguesa de Programação, Lisboa, 2008, n. 17, p. 40 dez./2008 JONES, Joseph L.; Flynn, ANITA M. Mobile Robots – Inspiration to Implementation. Wellesley, Massachusetts: A. K. Peters Ltd., 1993, 345 p. KUROSE, James F. / KEITH, W. Ross. Redes de computadores e a internet: uma abordagem top-down. 3. ed. São Paulo: Pearson Addison Wesley, 2006. LIMA, Charles Borges de. Técnicas de projetos eletrônicos com os microcontroladores AVR. 1. ed. Florianópolis, Ed. do Autor, 2010. LTO – DMS, Data Sheet: Power MOSFET IRF540. USA, 2003. MARGOLIS, Michael. Arduino cookbook. United States of America: O’Relly, 2011. MCCOMB, Gordon. Constructing Robot Bases. New York. McGraw-Hill. 2004. p. 350 MELLIS, David. REVISTA INFO. O sucesso do arduino. Rio de Janeiro, ed. Abril, n. 217, p.21 mar./2009 MICROCHIP Technology. Data Sheet PIC16F977A. USA, 2001. MOKARZEL, Marcos Perez / CARNEIRO, Karina Perez Mokarzel. Internet Embedded: TCP/IP para microcontroladores. 1. ed. São Paulo: Érica, 2004. MORIMOTO, Carlos E. Hardware, o guia definitivo. 1 ed. São Paulo: GDH Press, 2007. PEREIRA, Fábio. Microcontrolador PIC18 Detalhado: Hardware e Software. 1. ed. São Paulo: Ed. Érica, 2010. ROBÓTICA EDUCACIONAL: INICIANDO EM MICROCRONTROLADORES, 2011. Disponível em: <http://www..robotic.com.br/novo_umr.pdf>. Acesso em: 10/11/2011.

75

ROSA, Felipe dos Santos. Plataforma de protótipos eletrônicos arduino: teoria, projetos e aplicação. 1. ed. Florianópolis: Clube de Autores, 2011. SANDI, Franz A. Sistema de Navegação e Guiagem de Robôs Móveis Autônomos. SBA Controle e Automação, 1998. SB-PROJECTS. Holanda. 2001. Disponível em: <http://www.sbprojects.com/knowLEDge/ir/nec.php>. Acesso em: 12/10/2011.

76

ANEXOS

77

ANEXO A – Experimento 1: ACIONAMENTO DE LED DE FORMA SEQUENCIAL

1. Objetivos:

O experimento em questão tem como objetivo descrever as ferramentas

necessárias para implementar um projeto básico de acionamento de dispositivos de

saída pelos pinos da placa Arduino, no presente experimento será demonstrado o

simples acionamento de um LED (Light Emitter Diode – Diodo Emissor de Luz).

As placas Arduino são projetadas de forma a facilitar o piscar de um LED

com o uso do pino digital 13. As placas atuais são fabricadas com o LED já

instalado. Em outras placas existe um resistor de 1 kΩ no pino 13, o que lhe permite

conectar o LED diretamente a ela. Para conexão a outro pino digital, deve-se usar

um resistor externo.

Os experimentos apresentados são desenvolvidos a partir do Arduino

Duemilanove, dispositivos discretos (LED, displays, etc) e um protoboard.

2. Introdução:

A placa Arduino é uma plataforma de computação física composta por

sistemas digitais ligados a sensores e atuadores, permitindo o desenvolvimento de

outros sistemas que percebam a realidade e respondam com ações físicas, baseada

em uma simples placa de Entrada/Saída microcontrolada e desenvolvida sobre uma

biblioteca que simplifica a escrita da programação em C/C++.

3. Programação em Arduino

Um microcontrolador (também denominado MCU) é um computador em

um chip, que contém processador, memória e periféricos de entrada/saída. É um

microprocessador que pode ser programado para funções específicas, em contraste

com outros microprocessadores de propósito geral. Ele pode ser embarcado no

interior de algum outro dispositivo, em nosso caso a placa Arduino, para que possam

controlar suas funções ou ações, conforme mostrado na Figura A.1.

78

Figura A.1 – Diagrama básico

4. Software Arduino

O Arduino IDE (Ambiente Integrado de Desenvolvimento) é um programa

multitarefa desenvolvido em JAVA, utilizado para criar, salvar, editar e compilar os

programas e carregá-los na placa Arduino, além de apresentar outros recursos como

gravação do bootloader (arquivo de inicialização rápida) em um microcontrolador

ATMEGA, um monitor simples, entre outros, cujo código básico é apresentado na

tela da Figura A.2.

Figura A.2 – Arduino software

5. Atividades Práticas

5.1 Experimento Sequencial de LED

Este experimento apresenta a utilização de seis LED para representar de

modo sequencial o acionamento dos dispositivos de saída do Arduino.

Os LED estão conectados aos pinos de 2 à 11 da placa, com o uso de

resistores de 150 Ω, conforme mostrado na Figura A.3.

79

O objetivo do código desenvolvido é o piscar dos LED em sequência, um

por um, utilizando para tanto duas funções: uma para acionar a saída e outra para

gerar um retardo.

Figura A.3 – Experimento sequencial

6. Relatório

O relatório deve conter:

• Introdução Teórica da placa Arduino;

• Desenvolvimento do Projeto com as devidas inferências a respeito dos

códigos criados;

• Conclusões sobre o experimento realizado;

• Referências.

O programa deve ser entregue ao professor. Com comentários ao longo

do algoritmo.

80

ANEXO B – Experimento 2: ACIONAMENTO DE UM DISPLAY DE 7 SEGMENTOS

1. Objetivos:

O experimento em questão tem como objetivo descrever as ferramentas

necessárias para implementar um projeto básico de acionamento de dispositivos de

saída pelos pinos da placa Arduino, demonstrar o acionamento do display de 7

segmentos.

O experimento apresentado pode ser desenvolvido a partir do Arduino

Duemilanove, dispositivos discretos (LED, displays, etc) e um protoboard.

2. Introdução:

a. Contagem com Display 7 Segmentos

O programa do display de 7 (sete) segmentos tem por objetivo utilizar o

display ligado do pino 5 ao 12 para fazer uma contagem de 0 a 9, com cada número

sendo exibido durante 1 segundo e reiniciando a contagem até que seja gerada uma

interrupção externa.

O código do Quadro B.1 tem por objetivo realizar um teste de um display

de 7 segmentos com um ponto decimal ligado ao Arduino desde o pino 5 ao 12,

conforme a Figura B.1. Neste caso, todos os segmentos são ligados e após um

segundo, todos desligam-se um de cada vez.

Como os segmentos são LED, então precisamos limitar a corrente, para

isso devemos usar uma resistência em cada segmento. A corrente utilizada,

depende do brilho que queremos do display, normalmente utilizam-se resistências

entre 220 e 560 Ω para uma fonte de 5 V, o que equivale a uma corrente entre 9 mA

e 20 mA. Não devemos usar valores de resistência muito baixa, pois estaremos

reduzindo a vida útil do display, podendo queimar o segmento. Se for usar um

display, teste antes cada segmento, para ter a certeza que não está a usar um

display com algum segmento queimado.

Programa para testar o display 7 segmentos.

81

Quadro B.1 – Testando o display via Arduino

Figura B.1 – Montagem com o display de 7 segmentos

3. Materiais

1 Display 7 segmentos

8 Resistores de 330Ω

int b=5, a=6, f=7, g=8, dp=9, c=10, d=11, e=12; int pins[8] = b, a, f, g, dp, c, d, e; void setup() Serial.begin(9600); for (int i = 0; i == 7; i++) pinMode(pins[i], OUTPUT); void loop() for(int i = 0; i <8 7; i++) digitalWrite(pins[i], HIGH); delay(250); delay(1000); for(int i = 0; i <8 7; i++) digitalWrite(pins[i], LOW); delay(250);

82

1 Display LCD 16x2


1 LED

4. Relatório

O relatório deverá conter:


códigos criados;

• Conclusão do Trabalho;

• Referências.

O programa deverá ser entregue ao professor, o mesmo precisará de

comentários ao longo do algoritmo.

83

ANEXO C – Experimento 3: ACIONAMENTO DE UM DISPLAY LCD 16 X 2 VIA

CONTROLE REMOTO

1. Objetivos:

O projeto tem objetivo de validar o acionamento de um display LCD 16 x 2

via controle remoto enviando dados de comandos alfanuméricos a serem

apresentados no display.

Os experimentos apresentados podem ser desenvolvidos a partir do

Arduino Duemilanove, dispositivos discretos (LED, displays, etc) e um protoboard.

2. Introdução

Esse projeto precisou de um simples sensor receptor infravermelho, o

receptor utilizado foi o IRM3638 que foi conectado à placa Arduino como forma de

receber o sinal infravermelho.

3. Materiais

1 Controle IR

1 Receptor IR

1 Display LCD 16x2


1 LED

1 Resistor de 10kΩ

4. Relatório



códigos criados;


• Referências.

84



85

ANEXO D – Experimento 4: UNIDADE MÓVEL ROBÓTICA

1. Objetivos

Esse projeto tem o objetivo de integrar sistemas de comunicação e

acionamento através da robótica móvel. A UMR (Unidade Móvel Robótica) possui:

• Sensor Ultrassônica;

• Sensor Infravermelho;

• Sensor de Trilha;

• Placa de interface para acionamento de motores.

O objetivo dessa prática é de:

• Integrar os diversos sistemas da UMR;

• Projetar diversas possibilidades de trilhas para otimização de rotas;

• Montar diversos cenários para a UMR poder desviar de obstáculos com o

sensor ultrassônico;

• Controlar a UMR com o controle infravermelho.

2. Introdução

A UMR (Unidade Móvel Robótica) foi um projeto desenvolvido para

otimizar o estudo da robótica móvel educacional. Dentre as suas funcionalidades

destacamos o uso de sensores para versatilizar o ambiente de aprendizado em sala

de aula com sensores ultrassônicos e infra vermelhos com os quais podemos fazer o

robô desviar obstáculos, seguir trilha e obedecer comandos via controle remoto.

A UMR foi desenvolvida com o Arduino Duemilanove juntamente com o

Arduino SensorShield para acoplar os sensores utilizados bem como os servo

motores utilizados nas rodas e no ultrassom.

86

Figura D.1 – Unidade Móvel Robótica

Fonte:Robotic, 2011

3. Materiais

1 UMR

1 Controle Remoto SONY ou similar

1 Fonte 9V/1A

1 Cabo de dados USB

4. Relatório



códigos criados;


• Referências.



87

ANEXO E – Experimento 5: PWM DO ARDUINO

Experimento 5: PWM DO ARDUINO

1. Objetivos:

Nesse experimento será testada a saída PWM do Arduino para controlar

a velocidade de um motor dc de 12 V. O código desse experimento está descrito no

Quadro E.1.

Figura E.1 – Diagrama de Montagem do Projeto

2. Lista de Materiais


1 MOSFET IRF540

2 Resistores: 1 de 1 kΩ e outro de 10 kΩ

1 Motor DC de 12 V

88

Quadro E.1 – Código do acionamento do motor dc

O Arduino UNO possui dos pinos 13 ao 2, ao todo 12 pinos de I/O digitais,

são portas cujo sinal de saída é de 0 V ou 5 V. As portas PWM estão disponíveis em

6 canais, correspondentes às portas 11, 10, 9, 6, 5 e 3. Para o experimento em

questão, foi utilizado o pino 9 para gatilhar o MOSFET que comuta para o

funcionamento do motor DC.

3. Relatório



códigos criados;


• Referências.



intsensorPin = A0; intsensorValue = 0; void setup() pinMode(9, OUTPUT); Serial.begin(9600); void loop() sensorValue = analogRead(sensorPin); analogWrite(9,sensorValue/4); Serial.println(sensorValue/4); delay(10);

89

ANEXO F – Software Arduino

Conectando o Arduino ao computador

As placas Arduino foram desenvolvidas inicialmente com o CI FTDI

(FT232-RL), um conversor RS 232 – USB que usando a UART do microcontrolador

possibilita a comunicação entre Arduino e computador. Os novos modelos UNO e

Mega2560, dispõe de um ATMEGA8 desempenhando o papel deste conversor.

É por causa deste conversor FTDI que as placas são do tipo plug and

play, ou seja, ao conectar placa no computador via USB, o sistema operacional

instala automaticamente os drivers para comunicação com a placa. Mas com as

novas placas Arduino UNO e MEGA2560, a instalação deve ser manual.

Quando devidamente instalada, é possível visualizar que a placa foi

reconhecida no gerenciador de dispositivos do Windows. Para tal, é aberto o

gerenciador de dispositivos do Windows e verificado se está disponível uma porta

COM nomeada como Porta COM: ESB Serial Port (COM xx). No caso da Figura F.1,

a porta está instalada na COM16.

Figura F.1 – Verificando instalação

90

É possível que o sistema operacional não reconheça a placa Arduino

automaticamente, mais precisamente, o driver do FTDI ou o ATMEGA8. Isto ocorre

principalmente quando o sistema operacional é de 64 bits. Nestes casos a placa não

é reconhecida, podendo-se observar no gerenciador de dispositivos que o hardware

FT232R ou placa Arduino UNO/MEGA2560 não está instalado.

Nestes casos a solução é fazer a instalação manual. Na pasta do

programa Arduino IDE existe uma pasta específica de drivers, permitindo instalar os

drivers das placas mais recentes. Contudo, se o sistema operacional for 64 bits e a

placa Arduino for anterior à Arduino UNO e MEGA25860 é necessário fazer o

download do driver da FTDI para sistemas 64 bits. Este drive encontra-se:

http://www.ftdichip.com/Drivers/VCP.htm

Nestes dois casos é executada a instalação manual clicando-se no ícone

do FT232R ou placa UNO no gerenciador de dispositivos, atualizando o driver

substituindo-o pelo novo que foi descarregado do site.

É possível ainda haver problemas de hardware que acarretam o não

reconhecimento da placa. Cabo USB defeituoso ou placa com defeito de fabricação

também promovem este tipo de problema.

Software e a Placa Arduino

O aplicativo Arduino IDE, é utilizado principalmente para desenvolver o

código fonte e carregá-lo na placa do usuário.

Nesse momento, são destacados os pontos mais relevantes quando se

conecta a placa e deseja-se que a mesma realize suas funções corretamente.

Caso o trabalho seja realizado com mais de uma placa Arduino, é

importante observar em que porta serial a placa foi instalada no computador na

primeira vez em que foi utilizada. Também recomenda-se que o usuário utilize

sempre a mesma porta USB, devido à possibilidade de alguns conflitos ocorrerem

futuramente.

Desta forma, não é possível escolher qual a porta que o Arduino será

instalado, quando o método de instalação for o plug and play. Ela será instalada na

primeira porta COM virtual disponível no sistema.

91

Na primeira utilização, é importante configurar alguns parâmetros do

software. Em Tools, deve-se conferir e selecionar a placa utilizada (em Board) e

conferir se a placa está habilitada na porta COM onde foi instalada (em Serial Port),

como mostrado na Figura F.2:

Figura F.2 – Selecionando a placa do projeto

A última opção a seguir nem sempre é necessária a modificação manual,

já que ao plugar a placa o software reconhece automaticamente a porta a qual a

placa pertence e já aparecerá selecionada a porta serial correta. Porém, quando se

utiliza mais de uma placa Arduino ou alguma outra placa serial virtual, esta seleção

deve ser realizada com frequência.

No menu Tools, existem algumas outras ferramentas de auxílio:

• Burn Bootloader: Permite o usuário gravar o bootloader de uma placa Arduino

que possua um microcontrolador que não o possua, utilizando alguns dos tipos

de gravadores mais comuns de microcontroladores ATMEGA.

• Serial Monitor: Selecionando esta opção, irá se abrir uma janela do tipo hyper

terminal, responsável por receber e enviar caracteres ASCII ao Arduino, via

teclado.

92

• Outras opções: Há mais 3 opções no menu tools, respectivamente auto

formatação, arquivar, e consertar código e recarregar, sem muita relevância.

No menu File é possível criar um novo código fonte, abrir um código

existente, buscar exemplos prontos de código fonte, salvar carregar na placa,

configurar página, imprimir e ajustar algumas preferências referentes a diretório do

Arduino, tamanho de fonte, utilização de editor externo, entre outras.

O menu Edit possui exclusivamente opções de edição do arquivo fonte,

como copiar, colar, endentar e dessedentar o código, por exemplo.

O menu Sketch possui as opções verificar e compilar, importar uma

biblioteca do Arduino e adicionar um arquivo.

Por fim, o menu Help é exclusivamente em relação à busca de soluções

para problemas de todos os tipos, desde software e linguagem, à problemas com o

hardware das placas Arduino. É uma boa referência rápida em caso de problemas

simples.

Na visão geral do programa, é possível observar alguns atalhos e uma

janela de mensagens de compilação em formato semelhante ao DOS, onde são

mostradas mensagens do compilador ao usuário. A tela principal do Arduino IDE é

apresentada na Figura F.3.

93

Figura F.3 – Tela principal do Arduino IDE

Uma das ferramentas mais interessantes presentes no Arduino IDE é o

serial monitor, um terminal que recebe e envia dados ao Arduino via porta serial,

neste caso, via USB. Este terminal é um item muito utilizado para estes quando não

se dispõe de um display LCD ou alguma outra ferramenta visual, pois ele facilita

muito no diagnóstico de bugs no código fonte. A tela correspondente ao serial

monitor é apresentado na Figura F.4.

94

Figura F.4 – Monitor Serial Arduino IDE

É possível utilizar outros tipos de terminal serial em conjunto com o

Arduino. Nesse caso, é necessário apenas ajustar o parâmetro de taxa de símbolos

em sincronia com o código do Arduino.

95

ANEXO G – Instruções do Arduino

FUNÇÕES: CONCEITOS E PROPRIEDADES

Abordagem das funções, seus conceitos e propriedades, principalmente

as funções exclusivas da linguagem Arduino.

DIGITAL I/O:

pinMode( )

Configura o pino especificado para se comportar como uma entrada ou

uma saída. Ver a descrição dos pinos digitais para obter mais detalhes.

Sintaxe

pinMode (pino, modo)

Parâmetros

Pino: o número do pino cujo modo que deseja ajustar;

modo: entrada (INPUT)ou saída (OUTPUT).

Retorno

Nenhum

Exemplo

intLEDPin = 13;

void setup ( )

pinMode (LEDPin, OUTPUT); // pino 13 comosaída

void loop ( )

......

*Os pinos de I/O analógicos podem ser utilizados como pinos digitais,

definidos como pinos 14 (porta analógica 0) a 19 (porta analógica 5).

96

digitalWrite( )

Utilizado para definir o estado de um pino digital em estado alto (HIGH) ou

baixo (LOW).

Se o pino foi configurado como uma saída com pinMode( ), a sua tensão

será ajustada para o valor correspondente: 5 V para alto, 0 V (GND) para baixo.

Se o pino foi configurado como entrada, ao defini-lo como alto (com

digitalWrite( ) irá habilitar o resistor de pull-up interno 20 kΩ. Ao defini-lo como baixo

irá desativar o pull-up. O resistor de pull-up é o suficiente para limitar a corrente e

mal acender um LED, então se os LED parecem funcionar, mas muito fracos, esta é

uma causa provável. A solução é colocar o pino de uma saída com o pinMode( ).

Sintaxe

digitalWrite(pino, valor)

Parâmetros

pino: o número de pinos

valor: HIGH ou LOW

Retorno

nenhum

Exemplo

intLEDPin = 13;

void setup( )

pinMode (LEDPin, OUTPUT); // pino 13 definidocomo

saida

void loop ( )

digitalWrite (LEDPin, HIGH); //liga LED

delay (1000) //atraso de 1000ms

digitalWrite (LEDPin, LOW); //desliga LED

delay (1000);

97

DigitalRead()

Lê o valor de um determinado pino digital, HIGH (alto) ou LOW (baixo).

Sintaxe

digitalRead(pino)

Parâmetros

pino: o número do pino digital que você quer ler (int)

Retorno

HIGH ou LOW

Exemplo

intLEDPin = 13;

intLEDPin = 7; //pushbutton connectado no pino digital

7.

intval = 0; //variavel para salvar o valor lido.

void setup ( )

pinMode (LEDPin, OUTPUT); //pino 13 como saída.

pinMode (inPin, INPUT); //pino 7 como entrada.

void loop ( )

val = digitalRead (inPin); //lendo o pino de entrada.

digitalWrite (LEDPin, val); //LED com o valor do botão.

Se o pino não é conectado a nada, digitalRead( ) pode retornar alto ou

baixo (e isso pode alternar de forma aleatória).

ANALOG I/O

São os pinos de entrada e saída analógicos, que possuem várias

configurações analógicas como descrito a seguir.

98

analogReference( )

Configura a tensão de referência utilizada para a entrada analógica (ou

seja, o valor usado como fundo de escala de entrada). As opções são:

• Default: o padrão analógico de referência é 5 V ou 3,3 V (depende da placa).

• Interna: uma referência interna igual a 1,1 V no ATMEGA168 ou ATMEGA328

e 2,56 V no ATMEGA8.

• Externa: a tensão aplicada ao pino AREF é usado como referência.

Parâmetros

tipo: o tipo de referência ao uso (default, interna, ou externa).

Retorno

Nenhum.

Se estiver utilizando uma tensão de referência externa (aplicando ao pino

AREF), deve-se definir a referência analógica para externa antes de chamar

analogRead( ). Caso contrário, pode ocorrer um curto-circuito entre a tensão de

referência ativa (gerada internamente) e o pino AREF, podendo danificar o

microcontrolador na placa Arduino.

Alternativamente, pode-se conectar um resistor de uns 5 kΩ entre a

tensão de referência externa e o pino AREF o que lhe permite alternar entre as

tensões de referência externa e interna. Observe que o resistor irá alterar a tensão

que é usada como referência, porque há uma resistência interna de 32 kΩ no pino

AREF.

analogRead( )

Lê um valor de tensão analógico no pino analógico especificado. A placa

Arduino UNO possui 6 pinos analógicos com conversão A/D de 10 bits. Isso significa

que ele irá mapear tensões de entrada entre 0 e 5 V em valores inteiros entre 0 e

1023. Isso produz uma resolução entre as leituras de: 5 V / 1024 unidades, ou seja,

0,0049 volts (4,9 mV) por unidade. O intervalo de entrada e resolução podem ser

alteradas utilizando analogReference( ).

Demora cerca de 100 microssegundos (0,0001s) para ler uma entrada

analógica, portanto, a taxa máxima de leitura é cerca de 10.000Hz.

99

Sintaxe

analogRead(pino)

Parâmetros

Pino: o número de pinos de entrada analógica para ler (0-5 na maioria das placas, 0-

7 sobre o Mini e Nano, 0-15 no Mega)

Retorno

int (0-1023)

Se o pino de entrada analógica não está conectado a nada, o valor

retornado pelo analogRead ( ) irá variar com base em uma série de fatores (por

exemplo, os valores das entradas analógicas de outros pinos).

Exemplo

intanalogPin = 3;

//potenciômetro conectado ao pino 3, 5V e GND.

int Val = 0;

//variável inicializada para armazenar o valor lido.

void setup( )

Serial.begin(9600);

//Porta serial com leitura de 9600bauds/s

void loop( )

val = analogRead(analogPin)

//Leo valor analógico e converte

Serial.println(val);

//Imprime via monitor serial o valor lido

100

analogWrite

Escreve um valor analógico (utilizando os canais PWM). Pode ser usada

para acender um LED de brilhos diferentes ou uma unidade de motor em

velocidades diferentes. Após uma chamada do analogWrite( ), o pino irá gerar uma

onda quadrada constante no ciclo especificado até a próxima chamada para

analogWrite( ) (ou uma chamada para digitalRead( ) ou digitalWrite( ) no mesmo

pino). A frequência do sinal PWM e de aproximadamente 490 Hz. Não é necessário

definir, com pinMode( ), o pino como uma saída antes de chamar analogWrite( ).

A função analogWrite não tem nenhuma ligação com os pinos analógicos

ou função analogRead.

Sintaxe

analogWrite(pino, valor)

Parâmetros

pino: o pino para gravar.

valor: ciclo de trabalho (entre 0 (sempre desligado) e 255 (sempre ligado)).

Retorno

Nenhum

Exemplo

Define a saída para um diodo emissor de luz proporcional ao valor lido do

potenciômetro.

intLEDPin = 9; // LED conectado ao pino 9

intanalodPin = 3; //potenciômetro conectado ao pino 3

intval = 0;

void setup( )

pinMode (LEDPin, OUTPUT);

void loop ( )

val = analogRead (analogPin);

analogWrite(LEDPin, val / 4);

//analogRead valores entre 0 à 1023, analogWrite valores

101

entre 0 à 255

MODOS DE I/O AVANÇADOS

tone( )

Gera uma onda quadrada de freqüência especificada (e 50% de duty-

cicle) em um pino. A duração pode ser especificada, caso contrário, a onda

continuará até que uma chamada para noTone( ). O pino pode ser ligado a uma

campainha piezo ou outro falante para reproduzir sons.

Apenas um tom pode ser gerado de cada vez. Se o tom já está tocando

em um pino diferente, a chamada para o tone( ) não terá nenhum efeito. Se o tom

está enviando ao mesmo pino, a chamada irá definir a sua freqüência.

O uso do tone( ) irá interferir com PWM de saída nos pinos 3 e 11.

Observação: se desejar colocar valores em pinos múltiplos, é necessário

chamar no Tone( ) em um pino antes de chamar o tone( ) no pino seguinte.

Sintaxe

tone (pino, frequência)

tone(pino, frequência, duração)

Parâmetros

pinos: o pino sobre o qual gera o tom.

frequência: a frequência do tom hertz.

Duração: a duração do tom em milissegundos (opcional).

Retorno

Nenhum

noTone( )

Para a geração de uma onda quadrada desencadeada por tone( ). Não

tem nenhum efeito se não houver nenhum tom sendo gerado.

Sintaxe

noTone(pino)

102

Parâmetros

pino: o pino que se deseja parar de gerar o tom

Retorno

nenhum

shiftOut( )

Desloca os bits dos bytes de dados um por vez. Começa a partir do mais

significado (ou seja, o mais à esquerda) ou pelo bit menos significativo. Cada bit é

enviado para o pino de saída, após a mudança de clock.

Isso é conhecido como protocolo serial síncrono e é uma forma comum

de microcontroladores se comunicarem com os sensores e com outros

microncontroladores. Isto ocorre devido aos dois dispositivos ficarem sincronizados e

comunicarem-se perto de velocidades máximas, já que ambos compartilham do

mesmo clock. Isto é frequentemente referido na documentação de hardware como

chip Serial Peripheral Interface (SPI).

Sintaxe

SHIFTOUT (dataPin, clockPin, bitOrder, valor)

Parâmetros

dataPin: o pino de dados

clockPin: o clock

bitOrder: Define a ordem dos bits, ou seja mais significativo primeiro ou menos

significativo primeiro.

valor: valor dos dados para a mudança. (byte)

Retorno

Nenhum

O dataPin e o clock já devem ser configurados como saída por uma

chamada de pinMode ( ).

SHIFTOUT está definido para a saída de 1 byte (8 bits), por isso requer

uma operação de dois passos para uma saída de valores maiores do que 255.

Exemplo 1:

//Ordem: Mais significativo primeiro

int data = 500; // shift out highbyte

shiftOut (dataPin, clock, MSBFIRST, (data >> 8));

103

// shift out lowbyte

shiftOut (data, clock, MSBFIRST, data);

// Ordem menos significativo primeiro

data = 500; //shift out lowbyte

shiftOut (dataPin, clock, LSBFIRST, data);

// shift out highbyte

shiftOut (dataPin, clock, LSBFIRST, (data >> 8));

Exemplo 2

//************************************************************

********//

// Name :shiftOutCode, Hello World

//

// Author :Carlyn Maw, Tom Igoe

//

// Date : 25 Oct, 2006

//

// Version : 1.0

//

// Notes : Code for using a 74HC595 Shift Register

//

// : to count from 0 to 255

//

//************************************************************

********//

//Pino conectado ao ST_CP of 74HC595

intlatchPin = 8;

//Pino concetado ao SH_CP of 74HC595

int clock = 12;

////Pino conectado ao DS of 74HC595

int data Pin = 11;

104

void setup( )

//setar os pinos como saída

pinMode (latchPin, OUTPUT) ;

pinMode (clockPin, OUTPUT) ;

pinMode (dataPin, OUTPUT) ;

void loop ( )

for (int j = 0; j < 256; j++)

digitalWrite (latchPin, LOW) ;

shiftOut (dataPin, clockPin, LSBFIRST, j) ;

digitalWrite (latchPin, HIGH) ;

delay (1000) ;

pulseIn( )

Lê um pulso (alto ou baixo) em um pino. Por exemplo, se o valor for

elevado, pulseIn( ) espera o pino assumir valor alto, inicia a contagem, aguarda o

pino ir para nível baixo e pára a cronometragem. Retorna o comprimento do pulso

em microssegundos. Cancela e retorna 0 se nenhum pulso começar dentro de um

limite de tempo especificado.

A temporização dessa função foi produzida empiricamente e

provavelmente mostrará erros em pulsos mais longos. Funciona em pulsos de 10

microssegundos à 3 minutos de duração.

Sintaxe

pulseIn (pino, valor)

pulseLn (pino, valor, tempo de espera)

Parâmetros

pino: o número do pino no qual se quer ler o pulso.

valor: tipo de pulso para ler: alto ou baixo.

timeout (opcional): o número de microssegundos para aguardar o impulso para

iniciar; padrão é um segundo.

Retorna

105

A duração do pulso (em microssegundos) ou 0 se nenhum pulso começar

antes do tempo limite.

Exemplo

int pin = 7;

unsigned long duration;

void setup ( )

pinMode (pin, INPUT);

void loop( )

Duration = pulseIn (pin, HIGH);

FUNÇÕES DE TEMPO

millis()

Retorna o número de milissegundos desde que a placa Arduino começou

a executar o programa atual. Esse número vai estourar (voltar para zero), após

aproximadamente 50 dias executando.

Parâmetros

Nenhum

Retorno

Número de milissegundos desde o início do programa.

Exemplo

unsigned long time;

void setup ( )

Serial.begin (9600);

void loop ( )

Serial.print (“Time: “);

time = millis ( );

//imprime o tempo desde o inicio do programa

106

Serial.println (time);

delay (1000);

micros( )

Retorna o número de microssegundos desde que a placa Arduino

começou a executar o programa atual. Esse número vai estourar (voltar para zero),

após aproximadamente 70 minutos. Em 16 MHz as placas Arduino têm uma

resolução de quatro microssegundos (ou seja, o valor retornado é sempre um

múltiplo de quatro).

Parâmetros

Nenhum

Retorno

Número de microssegundos desde o início do programa.

Exemplo

unsigned long time;

void setup ( )

Serial.begian (9600);

void loop ( )

Serial.print (“Time: “);

Time = micros ( );

Serial.println (time);

delay (1000);

delay( )

Interrompe o programa por um período de tempo (em milissegundos)

especificado como parâmetro.

Sintaxe

delay(ms)

Parâmetros

ms: o número de milissegundos para fazer uma pausa.

Retorno

Nenhum

107

Embora seja fácil criar um LED piscando com a função delay( ), atrasos

limitam o uso das tarefas como mudança de estados, assim sendo o uso de delay( )

em um projeto tem desvantagens significativas. Nenhuma outra leitura de sensores,

cálculos matemáticos, manipulação dos pinos, etc, podem continuar durante a

função de atraso. Os mais experientes programadores geralmente evitam o uso de

delay( ) para o sincronismo dos eventos com mais de 10 de milissegundos a menos

que o projeto seja muito simples.

delayMicroseconds()

Interrompe o programa para o período de tempo (em microsegundos)

especificado como parâmetro. Há milhares de microsegundos em um milisegundo, e

um milhão de microsegundos em um segundo.

Sintaxe

delayMicroseconds (valor)

Parâmetros

valor: o número de microsegundos para fazer uma pausa

Retorna

Nenhum

Exemplo

intoutPin = 8;

void setup( )

pinMode (outPin, OUTPUT);

void loop ( )

digitalWrite (outPin, HIGH);

delayMicroseconds (50);

digitalWrite (outPin, LOW);

delayMicroseconds (50);

FUNÇÕES MATEMÁTICAS

108

As funções matemáticas utilizadas na linguagem Arduino IDE são as

mesmas utilizadas na linguagem C. São citadas abaixo as funções mais utilizadas e

sugerida a utilização de material complementar referente a linguagem C, afim de

utilizar estas funções.

O menu Help de qualquer compilador C possui todo conceito e

propriedades de cada uma das funções a seguir, ou em material disponível em sites

na internet.

• Função min(x, y): retorna qual o valor mínimo entre x e y.

• Função max(x,y): retorna o valor máximo entre x e y.

• Função abs(x): retorna o valor absoluto de x.

• Função constrain (x, a, b):restringe valor de x entre a e b.

• Função pow (base, expoente): eleva base ao expoente.

• Função sqrt(x): retorna o valor da raiz quadrada de x.

• Funções trigonométricas: retornam o valor do seno, cosseno ou tangente

de determinado ângulo em radianos através das funções sin(x), cós(x) e

tan(x), respectivamente.

NÚMEROS ALEATÓRIOS

A função randomSeed( ) inicializa o gerador de números

pseudoaleatórios, fazendo com que ela comece em um ponto arbitrário na sua

sequência aleatória. Esta sequência, embora muito longa e aleatória é sempre a

mesma.

Se é importante uma sequência de valores aleatórios utilize a função

random( ). Em execuções subsequentes de um projeto, use randomSeed( ) para

inicializar o gerador de números aleatórios com uma entrada bastante aleatória,

como analogRead( ) em um pino desconectado.

Por outro lado, pode ser ocasionalmente útil utilizar números

pseudoaleatórios que se repetem exatamente. Isso pode ser feito chamando

randomSeed( ) com um número fixo, antes de iniciar a sequência aleatória.

A seguir são descritas as funções random( ) e randomSeed( ), com seus

respectivos exemplos:

109

random( )

Sintaxe

random(max)

random(min, max)

Parâmetros

min – limite inferior do valor aleatório (opcional);

max – limite superior do valor aleatório.

Retorno

O valor aleatório entre min e Max.

Exemplo

longrandNumber;

void setup( )


void loop ( )

// print a random number from 0 to 299

randNumber = random (300);

Serial.println (randNumber);

// print a random number from 10 to 19

randNumber = random (10, 20);


delay (50);

randomSeed( ):

Parâmetros

seed, tipo int – número que gera o valor aleatório.

Retorno

Nenhum.

Exemplo

longrandNumber;

110

void setup ( )


randomSeed (analogRead (0));

Void loop ( ) [

randNumber = random (300);


delay (50);

FUNÇÕES PARA TRATAR BITS E BYTES

highByte( )

Extrai o byte de maior ordem (à esquerda) de uma palavra (ou o byte de

menor ordem de um segundo tipo de dados maior).

Sintaxe

highByte (x)

Parâmetros

x: um valor de qualquer tipo

Retorno

byte

lowByte()

Extrai o byte de menor ordem (à direita) de uma variável.

Sintaxe

Lowbyte (x)

Parâmetros

x: um valor de qualquer tipo

Retorno

byte

bitRead()

Lê um bit de um número.

Sintaxe

bitRead (x, n)

Parâmetros

x: o número a partir do qual se faz a leitura.

111

n: o número de bits a ser lido, começando em 0 para o bit menos significativo.

Retorno

O valor do bit (0 ou 1)

bitWrite()

Grava um bit de uma variável numérica.

Sintaxe

bitWrite (x, n, b)

Parâmetros

x: variável numérica na qual se escreve.

n: o número de bits a ser escrito, começando em 0 para o bit menos significativo.

b: o valor a se gravar (bit com valor 0 ou 1)

Retorno

nenhum

bitSet()

Seta 1 em um bit de uma variável numérica.

Sintaxe

bitset (x,n)

Parâmetros

x: variável numérica cujo valor quer se definir.

n: o bit a se definir, a partir de 0 para o bit menos significativo (mais à direita)

Retorno

nenhum

bitClear()

Limpa (escreve 0) em um bit de uma variável numérica.

Sintaxe

bitClear (x, n)

Parâmetros

x: variável numérica cujo bit se quer zerado.

n: qual o bit a ser zerado, a partir de 0 para o bit menos significativo (mais à direita).

Retorno

Nenhum

112

bit()

Calcula o valor do bit especificado (bit 0 é 1, o bit 1 é 2, o bit 2 é 4, etc.)

Sintaxe

bit (n)

Parâmetros

n: o bit, cujo valor se deseja calcular

Retorno

o valor do bit

113

Bibliotecas

O uso de bibliotecas proporciona um horizonte de programação mais

amplo e diverso quando comparado a utilização apenas de estruturas, valores e

funções. Isso é perceptível quando são analisados os assuntos que são abordados

por cada biblioteca em específico.

Lembrando sempre que, para se fazer uso de uma biblioteca está já deve

estar instalada e disponível na sua máquina.

Tem-se as seguintes bibliotecas de referencia:

• EEPROM: leitura e escrita de “armazenamento” permanente.

• Ethernet: para se conectar a uma rede Ethernet usando o Arduino Ethernet

Shield.

• Firmata: para se comunicar com os aplicativos no computador usando o

protocolo Firmata.

• Liquid Crystal: para controlar telas de cristal líquido (LCD).

• Servo: para controlar servo motores.

• SPI: para se comunicar com dispositivos que utilizam barramento Serial

Peripheral Interface(SPI).

• Software Serial: Para a comunicação serial em qualquer um dos pinos

digitais.

• Stepper: para controlar motores de passo.

• Wire: Dois Wire Interface (TWI/I2C) para enviar e receber dados através de

uma rede de dispositivos ou sensores.

Tem-se como referência também, o uso de bibliotecas mais específicas.

O que é de extrema importância quando se faz uso do Arduino com um enfoque em

uma determinada área, como por exemplo:

Comunicação (redes e protocolos)

• Messenger: Para o processamento de mensagens de texto a partir do

computador.

• New Soft Serial: Uma versão melhorada da biblioteca Software Serial.

114

• OneWire: Dispositivos de controle que usam o protocolo OneWire.

• PS2Keyboard: Ler caracteres de um teclado PS2.

• Simple Message System: Enviar mensagens entre Arduino e o computador.

• SSerial2Mobile: Enviar mensagens de texto ou e-mails usando um telefone

celular.

• Webduino: Biblioteca que cria um servidor Web (para uso com o Arduino

Ethernet Shield).

• X10: Envio de sinais nas linhas de energia AC.

• XBee: Para se comunicar via protocolo XBee.

• Serial Control: Controle remoto através de uma conexão serial.

Sensoriamento

• Capacitive Sensing: Transformar dois ou mais pinos em sensores capacitivos.

• Debounce: Leitura de ruídos na entrada digital.

Geração de Frequência e de áudio

• Tone: Gerar ondas quadradas de frequência de áudio em qualquer pino do

microcontrolador.

Temporização

• DateTime: Uma biblioteca para se manter informado da data e hora atuais do

software.

• Metro: Ajuda ao programador a acionar o tempo em intervalos regulares.

• MsTimer2: Utiliza o temporizador de 2 de interrupção para desencadear uma

ação a cada N milissegundos.

Utilidades

• Text String (String): Manipular strings

• PString: uma classe leve para imprimir em buffers.

• Streaming: Um método para simplificar as declarações de impressão.

115

ANEXO H– ROBO MÓVEL EDUCACIONAL

Figura H.1: Unidade Móvel Robótica

Fonte: Robotic, 2011

A UMR (Unidade Móvel Robótica) é uma estrutura de robô móvel

desenvolvida com o Arduino Duemilanove Atmega 328 como placa central de

processamento. O robô possui diversas funcionalidades agregadas, tais como

sensor infravermelho, sensor ultrassônico, Shield Arduino Navigation, além de

agregar sensores digitais de trilha, comunicação remota, detecção de obstáculos

através do infravermelho ou do ultrassom, medição de distancias, labirinto, etc.

Também pode ser agregado outros shields e expandir as funções com Xbee, WiFi,

Ethernet, GPS, bussola e demais outras funções incorporadas.

116

Figura H.2: Arduino Shield Navigation


117

Controlando a UMR por um controle remoto

O código do controle por IR está no Quadro H.1. Na Figura H.3 apresenta-se o

controle remoto e a UMR utilizada no experimento.

Figura H.3: Controle Remoto com a UMR


Robô Seguidor de Trilha

Conecte o sensor de trilha, no conector do shieldNavigation. Ligue cabos

Jumpers do SD ao P7 do Arduino, SC ao P6 e SE ao P5.

SD => Sensor direito

SC => Sensor Central

SE => Sensor Esquerdo

Figura H.4: Arduino Sensor Shield


Faça uma trilha usando fita isolante ou pintada na cor preta, com 20mm

de largura em uma superfície branca. O código do seguidor de trilha está no Quadro

H.2.

118

Figura H.5: Trilha para a UMR

Quadro H.1: Código do Arduino Controle IR


#include <IRremote.h> #include <MegaServo.h> //Inclue a biblioteca MegaServos #define NBR_SERVOS 12 // Numero de Servos ligados. Maximo de 48 arduino MEGA, 12 para outros arduinos #define FIRST_SERVO_PIN8 MegaServo Servos[NBR_SERVOS] ; constint RECV_PIN = 2; //SENSOR DE INFRARED NO PIN 2 IRrecvirrecv(RECV_PIN); decode_results results; void setup() Serial.begin(9600); Servos[1].attach(8,880,2400) ; //SERVO DIREITO NO PIN 8 Servos[2].attach(9,880,2400) ; //SERVO ESQUERDO NO PIN 9 Servos[1].write(70) ; Servos[2].write(70) ; irrecv.enableIRIn(); // Start the receiver irrecv.blink13(true); delay(15); void loop() if (irrecv.decode(&results)) Serial.println(results.value); if (results.value == 144) //Chave CH+ frente Servos[1].write(180) ; Servos[2].write(0) ; delay(15); if (results.value == 2192) //Chave CH- volta Servos[1].write(0) ; Servos[2].write(180) ; delay(15); if (results.value == 1168) //Chave VOL+ direita Servos[1].write(0) ; Servos[2].write(0) ; delay(15); if (results.value == 3216) //Chave VOL+ esquerda Servos[1].write(180) ; Servos[2].write(180) ; delay(15); if (results.value>= 3536) //Chave JUMP PÁRA Servos[1].write(70) ; Servos[2].write(70) ; delay(15); irrecv.resume(); / Recebe proximo valor

119

Quadro H.2: Código do Arduino Seguidor de Trilha

Fonte:Robotic, 2011

#include <MegaServo.h> //Inclue a biblioteca MegaServos #define NBR_SERVOS 12 // Numero de Servos ligados. Maximo de 48 arduino MEGA, 12 para outros arduinos #define FIRST_SERVO_PIN8 MegaServo Servos[NBR_SERVOS] ; intmotor_d = 9; intmotor_e = 10; intir_d = 7; intir_c = 6; intir_e = 5; intst_d; // variavel para quardar o valor no ir receptor direito intst_c; intst_e; void setup() Servos[1].attach(motor_d,880,2400) ; Servos[2].attach(motor_e,880,2400) ; pinMode(ir_d,INPUT); pinMode(ir_c,INPUT); pinMode(ir_e,INPUT); para(); void loop() st_d = digitalRead(ir_d); //verifica cada sensor e guarda seu status st_c =digitalRead(ir_c); st_e = digitalRead(ir_e); if (st_e == HIGH and st_c==LOW and st_d==HIGH)frente(); if (st_e == HIGH and st_c==HIGH and st_d==HIGH)para(); if (st_e == LOW and st_c==HIGH and st_d==HIGH)esquerda(); if (st_e == LOW and st_c==LOW and st_d==HIGH)esquerda(); if (st_d == LOW and st_c==HIGH and st_e==HIGH)direita(); if (st_d == LOW and st_c==LOW and st_e==HIGH)direita(); voidfrente() Servos[1].write(180) ; Servos[2].write(0) ; delay(15); voidpara() Servos[1].write(70) ; Servos[2].write(70) ; delay(300); voiddireita() Servos[1].write(0); Servos[2].write(0); delay(30); void esquerda() Servos[1].write(180); Servos[2].write(180); delay(30);

120

ANEXO I – CONTROLE PID COM ARDUINO

Quadro I.1: Biblioteca PID_v1.h

#ifndef PID_v1_h #define PID_v1_h #define LIBRARY_VERSION 1.0.0 class PID public: //Constants used in some of the functions below #define AUTOMATIC 1 #define MANUAL 0 #define DIRECT 0 #define REVERSE 1 PID(double*, double*, double*, // * constructor. links the PID to the Input, Output, and double, double, double, int); // Setpoint. Initial tuning parameters are also set here voidSetMode(int Mode); // * sets PID to either Manual (0) or Auto (non-0) void Compute(); // * performs the PID calculation. it should be // calLED every time loop() cycles. ON/OFF and // calculation frequency can be set using SetMode // SetSampleTime respectively voidSetOutputLimits(double, double); //clamps the output to a specific range. 0-255 by default, but //it's likely the user will want to change this depending on //the application voidSetTunings(double, double, // * While most users will set the tunings once in the double); // constructor, this function gives the user the option // of changing tunings during runtime for Adaptive control voidSetControllerDirection(int); // * Sets the Direction, or "Action" of the controller. DIRECT // means the output will increase when error is positive. REVERSE // means the opposite. it's very unlikely that this will be needed // once it is set in the constructor. voidSetSampleTime(int); // * sets the frequency, in Milliseconds, with which // the PID calculation is performed. default is 100 doubleGetKp(); // These functions query the pid for interal values. doubleGetKi(); // they were created mainly for the pid front-end, doubleGetKd(); // where it's important to know what is actually intGetMode(); // inside the PID. intGetDirection(); // private: void Initialize();

121


Quadro I.2: Controle PID – Exemplo Básico


No Quadro I.1 tem-se a biblioteca do PID para desenvolvimento de

sistemas de controle baseados nessa tecnologia.

O exemplo do Quadro I.2 apresenta um controle PID para leitura da

entrada analógica A0 e controle da saída PWM através do pino 3.

#include <PID_v1.h> //Define Variables we'll be connecting to doubleSetpoint, Input, Output; //Specify the links and initial tuning parameters PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT); void setup() //initialize the variables we're linked to Input = analogRead(0); Setpoint = 100; //turn the PID on myPID.SetMode(AUTOMATIC); void loop() Input = analogRead(0); myPID.Compute(); analogWrite(3,Output);

doubLEDispKp; // * we'll hold on to the tuning parameters in user-entered doubLEDispKi; // format for display purposes doubLEDispKd; // doublekp; // * (P)roportional Tuning Parameter doubleki; // * (I)ntegral Tuning Parameter doublekd; // * (D)erivative Tuning Parameter intcontrollerDirection; double *myInput; // * Pointers to the Input, Output, and Setpoint variables double *myOutput; // This creates a hard link between the variables and the double *mySetpoint; // PID, freeing the user from having to constantly tell us // what these values are. with pointers we'll just know. unsigned long lastTime; doubleITerm, lastInput; intSampleTime; doubleoutMin, outMax; boolinAuto; ; #endif

122

ANEXO J - ARDUINO TWITTER

O Arduino possui uma biblioteca Twitter que se comunica através do

EthernetShield.

A biblioteca não irá twittar diretamente do Arduino, o dispositivo irá enviar

os tweets para um site que em seguida enviará para o site do twitter através de um

mecanismo que envia o tweet sem necessidade do usuário/senha.

O site do twitter já possui um aplicativo para realizar a interface com o

Arduino, conforme a Figura J.1.

Figura J.1 – Arduino Twitter

123

Quadro J.1 – Código da Aplicação

A biblioteca utiliza este site como um servidor proxy para o material

OAuth. Seu tweet não podem ser aplicadas durante a manutenção deste site.

#if defined(ARDUINO) && ARDUINO > 18 // Arduino 0019 or later #include <SPI.h> #endif #include <Ethernet.h> //#include <EthernetDNS.h> Only needed in Arduino 0022 or earlier #include <Twitter.h> byte mac[] = 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; byte ip[] = 10, 0, 0, 177 ; Twitter twitter("<<< your token here >>>"); char msg[] = "Hello, World! I'm Arduino!"; void setup() delay(1000); Ethernet.begin(mac, ip); Serial.begin(9600); Serial.println("connecting ..."); if (twitter.post(msg)) int status = twitter.wait(); if (status == 200) Serial.println("OK."); else Serial.print("faiLED : code "); Serial.println(status); else Serial.println("connection faiLED."); void loop()

124

Abreu, Antonio Diego Santos Arduino – plataforma eletrônica microcontrolada / Antonio Diego Santos Abreu. – 2011. 123 f. Impresso por computador (Fotocópia). Orientadores: Areolino de Almeida Neto, Marcos Tadeu Rezende. Monografia (Graduação) – Universidade Federal do Maranhão, Curso de Engenharia de Eletricidade, 2011. 1.Controle automático – Engenharia. 2. Arduino. 3. Sistema embarcado. 4. Microcontrolador. I Título

CDU 681.5

Arduino Plataforma Eletrônica Microcontroladora

Documents

Transcript of Arduino Plataforma Eletrônica Microcontroladora