Antonio Diego - Monografia Arduino

Transcript

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 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 São Luís 2012 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 ensinandome 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. 1 http://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 2 http://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 - TransistorTransistor 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. 3 http://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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011. 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 Fonte: Arduino, 2011 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 Fonte: Arduino, 2011 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 /*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 } 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 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; longpreviousMillis = 0; // ultimo valor do LED // 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 pulldown 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 Fonte: Arduino, 2011 46 Quadro 4.3 – Código do acionamento de um pino 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 } } 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. 47 Quadro 4.4 – Código do filtro de ruído de uma chave intinPin = 7; intoutPin = 13; // o número do pino de entrada // 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 = 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 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);} 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. 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 Fonte: SB-PROJECTS, 2006 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 Fonte: SB-PROJECTS, 2006 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 NEC Message $68-$00 $68-$01 $68-$02 $68-$03 $68-$04 $68-$05 $68-$06 $68-$07 $68-$08 $68-$09 $68-$0A $68-$0B $68-$0C $68-$0E Key Function Play Rec AudioDub Frame Slow Quick Cue Review FF Rew Stop Pause/Still Upkey Down key Fonte: SB-PROJECTS, 2006 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Ω 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 Fonte: SB-PROJECTS, 2006 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 #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<=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 Camada de Aplicação Camada Transporte Camada Internet Camada Rede Função Contém um conjunto de protocolos distintos que provêem os diversos serviços da Internet. Possibilita a comunicação entre os pontos da rede. Roteia e entrega os datagramas entre os nós da rede. Implementa a transmissão de pacotes. Exemplo HTTP, FTP e Email (SMTP/POP) TCP e UDP IP, ICMP e ARP 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 Fonte: Arduino, 2011 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 #include #include #include prog_char string_0[] PROGMEM = "

Controle de LED pela Internet

"; prog_char string_1[] PROGMEM = "
"; prog_char string_2[] PROGMEM = "
"; prog_char string_3[] PROGMEM = "
"; prog_char string_4[] PROGMEM = "
"; prog_char string_5[] PROGMEM = "
Insert your name here:"; prog_char string_6[] PROGMEM = ""; prog_char string_7[] PROGMEM = "

"; prog_char string_8[] PROGMEM = "Ligada (ON)"; prog_char string_9[] PROGMEM = "Desligada (OFF)"; prog_char string_10[] PROGMEM = " "; //for auto refresh PROGMEM const char *string_table[] = { 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]; // change "string_table" name to suit // 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' &¤t_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("
Botao 1, ON"); }else{ client.println("
Botao 1, OFF"); } if(digitalRead(9)==HIGH){ client.println("
Botao 2, ON"); }else{ client.println("
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 //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(); } } 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. 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: . 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 microcontroladores AVR. 1. ed. Florianópolis, Ed. do Autor, 2010. com os 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: . 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 . Acesso em: 12/10/2011. em: 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 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); } } Figura B.1 – Montagem com o display de 7 segmentos 3. Materiais 1 Display 7 segmentos 8 Resistores de 330Ω 82 1 Display LCD 16x2 1 Arduino Duemilanove 1 LED 4. Relatório O relatório deverá conter: • Desenvolvimento do Projeto com as devidas inferências a respeito dos 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 Arduino Duemilanove 1 LED 1 Resistor de 10kΩ 4. Relatório O relatório deverá conter: • Desenvolvimento do Projeto com as devidas inferências a respeito dos códigos criados; • Conclusão do Trabalho; • Referências. 84 O programa deverá ser entregue ao professor, o mesmo precisará de comentários ao longo do algoritmo. 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; • 2. Controlar a UMR com o controle infravermelho. 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 O relatório deverá conter: • Desenvolvimento do Projeto com as devidas inferências a respeito dos 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. 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 Arduino Duemilanove 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 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);} 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 O relatório deverá conter: • Desenvolvimento do Projeto com as devidas inferências a respeito dos 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. 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, 07 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; intanalodPin = 3; // LED conectado ao pino 9 //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 dutycicle) 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( ) { Serial.begin (9600); } 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); Serial.println (randNumber); delay (50); }
randomSeed( ): Parâmetros seed, tipo int – número que gera o valor aleatório. Retorno Nenhum. Exemplo longrandNumber; 110 void setup ( ) { Serial.begin (9600); randomSeed (analogRead (0)); } Void loop ( ) [ randNumber = random (300); Serial.println (randNumber); 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 Fonte: Robotic, 2011 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 Fonte: Robotic, 2011 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 Fonte: Robotic, 2011 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 #include //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 Fonte: Robotic, 2011 119 Quadro H.2: Código do Arduino Seguidor de Trilha #include //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); } Fonte:Robotic, 2011 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(); doubleGetKi(); doubleGetKd(); intGetMode(); intGetDirection(); private: void Initialize(); // These functions query the pid for interal values. // they were created mainly for the pid front-end, // where it's important to know what is actually // inside the PID. // 121 doubLEDispKp; doubLEDispKi; doubLEDispKd; doublekp; doubleki; doublekd; // * we'll hold on to the tuning parameters in user-entered // format for display purposes // // * (P)roportional Tuning Parameter // * (I)ntegral Tuning Parameter // * (D)erivative Tuning Parameter intcontrollerDirection; double *myInput; double *myOutput; double *mySetpoint; // * Pointers to the Input, Output, and Setpoint variables // This creates a hard link between the variables and the // 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 Fonte: Arduino, 2011. Quadro I.2: Controle PID – Exemplo Básico #include //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);} Fonte: Arduino, 2011. 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. 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 #if defined(ARDUINO) && ARDUINO > 18 // Arduino 0019 or later #include #endif #include //#include Only needed in Arduino 0022 or earlier #include 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() { } 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. 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