Introducao a Computacao Fisica Com Arduino
-
Upload
thalis-antunes -
Category
Documents
-
view
113 -
download
9
Transcript of Introducao a Computacao Fisica Com Arduino
Introdução à Computação Física com Arduino de Thalis Antunes de Souza é licenciado sob
uma Licença Creative Commons Atribuição-Uso não-comercial-Compartilhamento pela mesma
licença 3.0 Unported.
Sumário
1 Computação .......................................................................................................................... 8
1.2 Computação Física ........................................................................................................... 8
2 Open Source ......................................................................................................................... 9
3 Open Hardware ..................................................................................................................... 9
4 Arduino ................................................................................................................................. 10
4.1 Hardware .......................................................................................................................... 11
4.2 IDE ..................................................................................................................................... 12
5 Arduino UNO ....................................................................................................................... 12
5.1 Características..................................................................................................................... 13
5.2 Alimentação ........................................................................................................................ 14
5.3 Memória ............................................................................................................................. 15
5.4 Entrada e Saída ................................................................................................................... 15
5. 5 Comunicação ..................................................................................................................... 16
5.6 Programação ....................................................................................................................... 16
5.7 Reset automatico por software .......................................................................................... 17
5.8 Proteção contra sobre-corrente na USB ............................................................................ 18
5.9 Características físicas .......................................................................................................... 18
5.10 Shield´s ........................................................................................................................... 19
6 Starter Kit ............................................................................................................................. 19
6.1 Laboratório de Garagem ................................................................................................ 20
6.2 Itens ................................................................................................................................... 20
6.2.1 Cabo USB ..................................................................................................................... 21
6.2.2 Protoboard .................................................................................................................... 22
6.2.3 Jumpers ......................................................................................................................... 22
6.2.4 Display LCD .................................................................................................................. 22
6.2.5 Arduino UNO ................................................................................................................ 23
6.2.6 Resistores ..................................................................................................................... 28
6.2.6.1 Resistor 10 K ............................................................................................................. 28
6.2.6.2 Resistor 330 R .......................................................................................................... 28
6.2.7 LED’s ............................................................................................................................. 29
6.2.7.1 LED Verde ................................................................................................................. 29
6.2.7.2 LED Amarelo ............................................................................................................. 29
6.2.7.3 LED Vermelho ........................................................................................................... 30
6.2.8 Potenciometro Linear 10K .......................................................................................... 30
6.2.9 Sensor de Temperatura LM35 ................................................................................... 31
6.2.10 Buzzer Contínuo ........................................................................................................ 32
6.2.11 Push Button ................................................................................................................ 32
7 Electronic design automation (ECAD) ............................................................................. 33
7.1 Fritzing .............................................................................................................................. 33
8 Práticas ................................................................................................................................ 33
8.1 Analog ............................................................................................................................... 33
8.1.1 Input ............................................................................................................................... 33
8.1.1.1 Potentiometer ............................................................................................................ 33
8.2 Digital ................................................................................................................................ 35
8.2.1 Input ............................................................................................................................... 35
8.2.1.1 Button ......................................................................................................................... 35
8.2.2 Output ............................................................................................................................ 37
8.2.2.1 Blink ............................................................................................................................ 37
8.2.2.2 Loop ............................................................................................................................ 38
8.2.2.3 Traffic Light ................................................................................................................ 40
8.3 Light ................................................................................................................................... 41
8.3.1 Display ........................................................................................................................... 41
8.3.1.1 PrintData .................................................................................................................... 41
8.3.2 Led ................................................................................................................................. 43
8.3.2.1 Analog In / Out (Pot and LED) ................................................................................ 43
8.3.2.2 Color Fader (RGB LED) .......................................................................................... 44
8.4 Sensors ............................................................................................................................. 46
8.4.1 Temperature ................................................................................................................. 46
8.4.1.1 Temperature Sensors .............................................................................................. 46
8.5 Sound ................................................................................................................................ 48
8.5.1 Melody ........................................................................................................................... 48
Figura 1 - Arduino Uno .............................................................................................. 19
Figura 2 - Shield Relay .............................................................................................. 19
Figura 3 - Kit Starter da loja Laboratório de Garagem ............................................... 20
Figura 4 - Itens do kit dentro da caixa ....................................................................... 21
Figura 5 - Itens do kit starter ...................................................................................... 21
Figura 6 - Cabo USB A-B .......................................................................................... 22
Figura 7 - Protoboard ................................................................................................ 22
Figura 8 - Jumpers para protoboard .......................................................................... 22
Figura 9 - LCD 2x16 com backlight ........................................................................... 23
Figura 10 - Fundo do LCD 2x16 ................................................................................ 23
Figura 11 - Datasheet dos pinos ............................................................................... 23
Figura 12 - Arduino Uno ............................................................................................ 24
Figura 13 - Arduino Uno ............................................................................................ 25
Figura 14 - Pinout do Arduino Uno ............................................................................ 25
Figura 15 - Detalhe do pinout do Arduino Uno .......................................................... 26
Figura 16 - Conector USB e de Alimentação............................................................. 26
Figura 17 - Detalhe do botão de reset ....................................................................... 27
Figura 18 - Detalhe do led ON e conector ICSP........................................................ 27
Figura 19 - Detalhe para o conversor USB/Serial e Led´s de TX e RX ..................... 28
Figura 20 - Resistores de 10K ................................................................................... 28
Figura 21 - Resistores de 330R ................................................................................. 29
Figura 22 - Led Verde ............................................................................................... 29
Figura 23 - Led Amarelo ............................................................................................ 30
Figura 24 - Led Vermelho .......................................................................................... 30
Figura 25 - Potenciômetro 10K .................................................................................. 31
Figura 26 - Sensor de Temperatura LM35 ................................................................ 31
Figura 27 - Push Button ............................................................................................ 32
Figura 28 - Terminais do Push Button ....................................................................... 33
Figura 29 - Detalhe do Push Button .......................................................................... 33
Figura 30 - Protoboard .............................................................................................. 34
Figura 31- Esquemático ............................................................................................ 34
Figura 32 - PCB ......................................................................................................... 35
Figura 33 - Protoboard .............................................................................................. 36
Figura 34 - PCB ......................................................................................................... 36
Figura 35 - Esquemático ........................................................................................... 36
Figura 36 - Protoboard .............................................................................................. 37
Figura 37 - Esquemático ........................................................................................... 37
Figura 38 - PCB ......................................................................................................... 38
Figura 39 - Protoboard .............................................................................................. 38
Figura 40 - Esquemático ........................................................................................... 39
Figura 41 - PCB ......................................................................................................... 39
Figura 42 - Protoboard .............................................................................................. 40
Figura 43 - Esquemático ........................................................................................... 40
Figura 44 - PCB ......................................................................................................... 40
Figura 45 - Protoboard .............................................................................................. 42
Figura 46 - Esquemático ........................................................................................... 42
Figura 47 - PCB ......................................................................................................... 42
Figura 48 - Protoboard .............................................................................................. 43
Figura 49 - Esquemático ........................................................................................... 43
Figura 50 - PCB ......................................................................................................... 44
Figura 51 - Protoboard .............................................................................................. 44
Figura 52 - Esquemático ........................................................................................... 45
Figura 53 - PCB ......................................................................................................... 45
Figura 54 - Protoboard .............................................................................................. 46
Figura 55 - Esquemático ........................................................................................... 47
Figura 56 - PCB ......................................................................................................... 47
Figura 57 - Protoboard .............................................................................................. 48
Figura 58 - Esquemático ........................................................................................... 49
Figura 59 - PCB ......................................................................................................... 49
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 8
1 Computação
A computação pode ser definida como a busca de uma solução para um problema a
partir de entradas (inputs) e tem seus resultados (outputs) depois de trabalhada
através de um algoritmo. É com isto que lida a teoria da computação, subcampo da
ciência da computação e da matemática. Durante milhares de anos, a computação
foi executada com caneta e papel, ou com giz e ardósia, ou mentalmente, por vezes
com o auxílio de tabelas ou utensílios artesanais.
A partir da segunda metade do século XX, com o advento dos computadores
eletrônicos, a Computação passou a ter uma presença cada vez mais marcante na
sociedade, influenciando a vida diária de parte da população mundial. A partir da
década de 1950, a Computação ganhou o status de Ciência surgindo então o termo
ciência da computação, uma área do conhecimento humano hoje fortemente ligado
à produção de software.
1.2 Computação Física
O campo da computação física engloba todas as disciplinas que permitem construir
equipamentos digitais de computação que interagem com, e respondem à, realidade
física analógica que os rodeia, usando software e hardware para este fim.
Em sentido mais lato, é a disciplina que estuda e concebe sistemas digitais,
incluindo computadores, controladores e respectivo software que, ligados a sensores
e atuadores, permitem construir sistemas e aparelhos autómatos, que percebem a
realidade e respondem com ações físicas a esta realidade.
Em sentido mais estrito, o termo aplica-se a projetos que envolvem computadores,
sensores e atuadores, capazes de produzir sistemas que de um modo simples, sob
o ponto de vista dos meios, cumpram aquelas premissas de resposta/interação física
ao mundo físico, envolvendo meios específicos da computação e normalmente em
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 9
ambientes não especificamente tecnológicos, como sejam os campos da arte,
design, multimídia, vida quotidiana, e mesmo em automatismos mais elaborados
(museus, centros de interpretação, demonstração, marketing, maquetagem, jogos,
multimedia, domótica, etc) envolvendo interação com utilizadores ou com o meio que
o rodeia.
2 Open Source
O termo código aberto, ou open source em inglês, foi criado pela OSI (Open Source
Initiative) e refere-se a software também conhecido por software livre.
Genericamente trata-se de software que respeita as quatro liberdades definidas pela
Free Software Foundation, compartilhadas também pelo projeto Debian,
nomeadamente em "Debian Free Software Guidelines (DFSG)". Qualquer licença de
software livre é também uma licença de código aberto (Open Source), a diferença
entre as duas nomenclaturas reside essencialmente na sua apresentação. Enquanto
a FSF usa o termo "Software Livre" envolta de um discurso baseado em questões
éticas, direitos e liberdade, a OSI usa o termo "Código Aberto" sob um ponto de vista
puramente técnico, evitando (propositadamente) questões éticas. Esta nomenclatura
e discurso foram cunhados por Eric Raymond e outros fundadores da OSI com o
objetivo de apresentar o software livre a empresas de uma forma mais comercial
evitando o discurso ético.
3 Open Hardware
Hardware livre é um hardware projetado e oferecido da mesma maneira que um
software de código livre, o termo foi primeiramente empregado para refletir o
lançamento irrestrito de informação sobre o projeto de hardware, tal como um
diagrama, estrutura de produtos e dados de layout de uma placa de circuito
impresso.[1]
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 10
Com o crescimento dos dispositivos lógicos reprogramáveis, o compartilhamento dos
esquemas lógicos de forma aberta também se espalhou. Ao invés de compartilhar
as esquemáticas, é o código da linguagem de descrição de hardware que
normalmente se divide. Suas descrições popularmente são usadas para configurar
um system-on-a-chip ou através de FPGA ou diretamente via ASIC. Estes módulos,
quando distribuídos, são chamados de núcleos semicondutores de propriedade
intelectual (Em inglês, Semiconductor intellectual property core - IP cores) ou
Núcleos IP.
4 Arduino
Arduino, palavra por vezes traduzida ao português como Arduíno,[3][5] é uma
plataforma de prototipagem eletrônica de hardware livre, projetada com um
microcontrolador Atmel AVR de placa única, com suporte de entrada/saída
embutido, uma linguagem de programação padrão,[6] na qual tem origem em Wiring,
e é essencialmente C/C++.[7] O objetivo do projeto é criar ferramentas que são
acessíveis, com baixo custo, flexíveis e fáceis de se usar por artistas e amadores.
Principalmente para aqueles que não teriam alcance aos controladores mais
sofisticados e de ferramentas mais complicadas.[8]
Pode ser usado para o desenvolvimento de objetos interativos independentes, ou
ainda para ser conectado a um computador hospedeiro. Uma típica placa Arduino é
composta por um controlador, algumas linhas de E/S digital e analógica, além de
uma interface serial ou USB, para interligar-se ao hospedeiro, que é usado para
programá-la e interagi-la em tempo real. Ela em si não possui qualquer recurso de
rede, porém é comum combinar um ou mais Arduinos deste modo, usando
extensões apropriadas chamadas de shields. A interface do hospedeiro é simples,
podendo ser escrita em várias linguagens. A mais popular é a Processing, mas
outras que podem comunicar-se com a conexão serial são: Max/MSP,[9] Pure
Data,[10] SuperCollider,[11] ActionScript[12] e Java.[13] Em 2010 foi realizado um
documentário sobre a plataforma chamado Arduino: The Documentary.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 11
4.1 Hardware
Sua placa consiste em um microcontrolador Atmel AVR de 8 bits, com componentes
complementares para facilitar a programação e incorporação para outros circuitos.
Um importante aspecto é a maneira padrão que os conectores são expostos,
permitindo o CPU ser interligado a outros módulos expansivos, conhecidos como
shields. Os Arduinos originais utilizam a série de chips megaAVR, especialmente os
ATmega8, ATmega168, ATmega328 e a ATmega1280; porém muitos outros
processadores foram utilizados por clones deles.[18]
A grande maioria de placas inclui um regulador linear de 5 volts e um oscilador de
cristal de 16 MHz (podendo haver variantes com um ressonador cerâmico), embora
alguns esquemas como o LilyPad usam até 8 MHz e dispensam um regulador de
tensão embutido, por ter uma forma específica de restrições de fator. Além de ser
microcontrolador, o componente também é pré-programado com um bootloader que
simplifica o carregamento de programas para o chip de memória flash embutido,
comparado com outros aparelhos que usualmente necessitam de um chip
programador externo.[18]
Conceitualmente, quando seu software é utilizado, ele monta todas as placas sobre
uma programação de conexão serial RS-232, mas a maneira que é implementado
no hardware varia em cada versão. Suas placas serial contém um simples circuito
inversor para converter entre os sinais dos níveis RS-232 e TTL. Atualmente,
existem alguns métodos diferentes para realizar a transmissão dos dados, como por
placas programáveis via USB, adicionadas através de um chip adaptador USB-para-
Serial como o FTDI FT232. Algumas variantes, como o Arduino Mini e o não oficial
Boarduino, usam um módulo, cabo adaptador USB, bluetooth ou outros métodos.
Nestes casos, são usados com ferramentas microcontroladoras ao invés do Arduino
IDE, utilizando assim a programação padrão AVR ISP.[19][20]
A maioria dos pinos de E/S dos microcontroladores são para uso de outros circuitos.
A versão Diecimila, que substituiu a Duemilanove, por exemplo, disponibiliza 14
pinos digitais, 6 das quais podem produzir sinais MLP, além de 6 entradas
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 12
analógicas. Estes estão disponíveis em cima da placa, através de conectores
fêmeas de 0,1 polegadas (ou 0,25 centímetros).[21]
O modelo Nano, Boarduino e placas compatíveis com estas, fornecem conectores
machos na parte de baixo da placa, para serem plugados em protoboards.[18]
4.2 IDE
O Arduino IDE é uma aplicação multiplataforma escrita em Java na qual é derivada
dos projetos Processing e Wiring.[18][22] É esquematizado para introduzir a
programação a artistas e a pessoas não familiarizadas com o desenvolvimento de
software. Inclui um editor de código com recursos de realce de sintaxe, parênteses
correspondentes e identação automática, sendo capaz de compilar e carregar
programas para a placa com um único clique. Com isso não há a necessidade de
editar Makefiles ou rodar programas em ambientes de linha de comando.[8][23]
Tendo uma biblioteca chamada "Wiring", ele possui a capacidade de programar em
C/C++. Isto permite criar com facilidade muitas operações de entrada e saída, tendo
que definir apenas duas funções no pedido para fazer um programa funcional:[18]
setup() – Inserida no inicio, na qual pode ser usada para inicializar configuração, e
loop() – Chamada para repetir um bloco de comandos ou esperar até que seja
desligada.
Habitualmente, o primeiro programa que é executado tem a simples função de piscar
um LED.
5 Arduino UNO
O Arduino Uno é uma placa de microcontrolador baseado no ATmega328
(datasheet). Ele tem 14 pinos de entrada/saída digital (dos quais 6 podem ser
usados como saídas PWM), 6 entradas analógicas, um cristal oscilador de 16MHz,
uma conexão USB, uma entrada de alimentação uma conexão ICSP e um botão de
reset. Ele contém todos os componentes necessários para suportar o
microcontrolador, simplesmente conecte a um computador pela porta USB ou
alimentar com uma fonte ou com uma bateria e tudo pronto para começar.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 13
O Uno difere de todas as placas antecessoras no sentido de não utilizar o chip FTDI
cara conversão do sinal serial. Utiliza no seu lugar um Atmega8U2 programado
como conversor de USB para serial.
Revisão 3 da placa com as novas características:
Pinos SDA e SCL adicionados próximos ao AREF.
Dois outros pinos adicionados próximos ao RESET, o IOREF que permite aos
shields se adaptarem à voltagem fornecida pela placa. No futuro os shields
serão compatíveis tanto com as placas que utilizam o AVR e operam a 5V,
como com o ARduino Due que operará a 3,3V. O segundo pino não está
conectado e é resrvado para propósitos futuros.
Circuíto de RESET mais robusto.
Atmega 16U2 em substituição ao 8U2.
"Uno" quer dizer um em italiano e é utilizado para marcar o lançamento do Arduino
1.0. O Uno e a versão 1.0 serão as versões de referência do Arduino, daqui para
diante. O UNO é o mais recente de uma série de placas Arduino, e o modelo de
referência para a plataforma Arduino. Para uma comparação com as versões prévias
veja o índice de palcas Arduino.
5.1 Características
Microcontrolador ATmega328
Voltagem Operacional 5V
Voltagem de entrada (recomendada) 7-12V
Voltagem de entrada (limites) 6-20V
Pinos E/S digitais 14 (dos quais 6 podems ser saídas PWM)
Pinos de entrada analógica 6
Corrente CC por pino E/S 40 mA
Corrente CC para o pino 3,3V 50 mA
Flash Memory 32 KB (ATmega328
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Velocidade de Clock 16 MHz
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 14
5.2 Alimentação
O arduino Uno pode ser alimentado pela conexão USB ou com uma fonte de
alimentação externa. A alimentação é selecionada automaticamente.
Alimentação externa (não USB) pode ser tanto de um adaptador CA para CC ou
bateria. Há um conector para alimentação de 2,1mm com o positivo no centro.
Cabos vindos de uma bateria podem ser inseridos diretamente nos pinos Gnd e Vin
do conector de alimentação.
Esta placa pode funcionar com uma fonte de alimentação externa de 6 a 20 volts. No
entanto se a alimentação for inferior a 7V, o pino 5V pode fornecer menos de cinco
volts e a placa pode se mostrar instável. E se a aliemtação for maior do que 12V o
regulador de voltagem pode superaquecer e danificar a placa. A faixa recomendada
é de 7 a 12 volts.
Os pinos de alimentação são os seguintes:
VIN. A entrada de alimentação para a placa Arduino quando se está utilizando uma
fonte de alimentação externa. (em oposição à conexão USB ou outra fonte de
aliemteção regulada). Você pode fornecer alimentação através deste pino, ou se
estiver utilizando o conector de alimentação acessar esta voltagem aqui.
5V. A fonte de alimentação regulada usada para o microcontrolador e para outros
componentes na placa. Pode vir tanto do VIN através do regulador embarcado ou da
conexão USB ou outra fonte regulada em 5V.
3V3. Uma fonte de 3,3V gerada pelo regulador embarcado. A corrente máxima
suportada é de 50mA.
GND. Pinos terra.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 15
5.3 Memória
O ATmega328 têm 32KB (dos quais 0,5 são utilizados pelo bootloader). Também
tem 2KB de SRAM e 1KB de EEPROM (que pode ser lido ou gravado com a
biblioteca EEPROM).
5.4 Entrada e Saída
Cada um dos 14 pinos digitais do Uno podem ser utilizados como uma entrada ou
uma saída utilizando-se as funções pinMode(), digitalWrite(), e digitalRead(). Eles
operam a 5V. Cada pino pode fornecer ou receber um máximo de 40mA e tem um
resistor pull-up interno (desconectado por padrão) de 20-50kΩ. Além disso alguns
pinos tem funções especializadas:
Serial: 0 (RX) e 1 (TX). Usados para receber (RX) e transmitir (TX) dados
seriais TTL. Estes pinos são conectados aos pinos correspondentes do chip
serial USB-para-TL ATmega8U2.
Interruptores Externos: 2 e 3. Estes pinos podem ser configurados para
disparar uma interrupção de acordo com alguma variação sensível pelo
circuíto. Veja a função attachInterrupt() para mais detalhes.
SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos dão suporte à
comunicação SPI utilizando a biblioteca SPI.
LED: 13. Há um LED integrado ao pino digital 13. Quando este pino está no
valor HIGH este LED está aceso, quando o pino está em LOW o LED está
apagado.
I2C: 4 (SDA) and 5 (SCL). Fornecem suporte a comunicação I2C (TWI)
utilizando a biblioteca Wire.
AREF. Voltagem de referência para as entradas analógicas. Utilizado com a
função analogReference().
Reset. Envio o valor LOW para esta linha para resetar o microcontrolador.
Tipicamente usado para adcionar um botão de de reset para shileds
montados sobre a placa original.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 16
O Uno tem 6 entradas analógicas, etiquetadas de A0 a A5, cada uma tem 10 bits de
resolução (i.e. 1024 valores diferentes). Por padrão elas medem de 0 a 5V, embora
seja possível alterar o limite superior utilizando o pino AREF e a função
analogReference().
5. 5 Comunicação
O Arduino Uno possui uma série de facilidades para se comunicar com um
computador, outro Arduino, ou outros microcontroladores. O ATmega328 fornece
comunicação serial UART TTL (5V) que está disponível nos pinos digitais 0 (RX) e 1
(TX). Um ATmega8U2 na placa canaliza esta comunicação para a USB e aparece
como uma porta virtual para o software no computador. O firmware do '8U2 utiliza os
drivers padrão USB COM e nenhum driver externo é necessário. Entretanto, no
Windows, um arquivo .inf é necessário. Ainda faltam as instruções específicas mas
em breve estarão disponíveis. O software do Arduino inclui um monitor serial que
permite dados textuais ser enviados e recebidos da placa. LEDs conectados ao RX
e TX piscarão enquanto dados estiverem sido transmitidos pelo chip USB-para-serial
e pela conexão USB (mas não para comunicação serial nos pinos 0 e 1).
Uma biblioteca de SoftwareSerial permite comunicação serial em qualquer dos pinos
digitais do Uno.
O ATmega328 também suporta comunicação I2C (TWI) e SPI. O software do
Arduino inclui uma biblioteca Wire para simplificar o uso do bus I2C, veja a
documentação para mais detalhes. Para comunicação SPI utilize a biblioteca SPI.
5.6 Programação
O Arduino Uno pode ser programado com o software Arduino (download).
Simplismente selecione "Arduino Uno" no menu Tools > Board.
O ATmega328 no Arduino Uno vem pré-gravado com um bootloader que permite a
você enviar código novo para ele sem a utilização de um programador de hardware
externo. Ele se comunica utilizando o protocolo original STK500 (referencia, arquivos
C header).
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 17
Você também pode saltar o bootloader e programar o microcontroaldor através do
conector ICSP (In-Circuit Serial Programming); veja estas instruções para mais
detalhes.
O código fonte do firmware do ATmega8U2 também está disponível. Este chip é
carregado com um bootloader DFU, que pode ser ativado conectando o jumper de
solda na parte posterior da placa (próximo ao mapa da Itália) e depois resetando o
8U2. Você pode utilizar o software FLIP da Atmel (Windows) ou o programador DFU
(Mac OS X e Linux) para carregar um novo firmware. Ou ainda utilizar um
programador externo (sobrescrevendo o bootloader DFU).
5.7 Reset automatico por software
Ao invés de necessitar do pressionamento físico de um botão antes de um upload, o
Arduino Uno é desenvolvido que permita esta operação ser feita por meio do
software rodando em um computador. Uma das linhas de controle de fluxo do
hardware (DTR) do ATmega8U2 é conectado à linha de reset do ATmega328
através de um capacitor de 100nF. Quando esta linha é declarada (rebaixada) a
linha de reset cai o suficiente para resetar o chip. O software do Arduino utiliza esta
capacidade para permitir o envio de código novo simplismente pressionando o botão
de upload na IDE. Isto significa que o bootloader pode ter um intervalo mais curto,
uma vez que o rebaixamento do DTR pode ser melhor coordenado com o início do
upload.
Esta configuração tem outras implicações. Quando o Uno é conectado a um
computador rodando Mac OS X ou Linux, ele é resetado cada vez que uma conexão
é estabelecida com o software (via USB). Durante o próximo meio segundo o
bootloader estará rodando no Uno. Uma vez que ele está programado para ignorar
dados malformados (i.e. qualquer coisa diferente do upload de um novo código), ele
irá interceptar os primeiros bytes de informação após a abertura da conexão. Se um
programa rodando na placa recebe alguma configuração ou outra informação
quando começa a rodar esteja seguro de que o software com o qual ela se comunica
espere por um segundo antes de começar a enviar dados.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 18
O Uno contem uma trilha que pode ser interrompida (cortada fisicamente) para
desabilitar o auto-reset. Os conectores de cada lado da trilha podem ser soldados
para reabilitar esta função. Ela está identificada como "RESET-EN". Você também
pode desabilitar o auto-reset conectando um resistor de 110Ω do 5V à linha de reset,
veja este tópico do fórum para mais detalhes.
5.8 Proteção contra sobre-corrente na USB
O Arduino Uno possui um polyfuse resetável que protege a porta USB do seu
computador contra sobre-corrente e curots circuítos. Embora muitos computadores
tenham sua própria proteção interna, o fuso fornece uma camada a mais de
proteção. Se mais de 500mA forem aplicados a porta USB ele automaticamente irá
interromper a conexão até que o curto ou a sobrecarga seja removido.
5.9 Características físicas
A largura e o comprimento máximos do PCB do Uno são 68,58 e 53,34mm
respectivamente (2,7" x 2,1"), com os conectores USB e de alimentação
extendendo-se além destas dimensões. Quatro orifícios para parafusos permitem
que a placa seja fixada a uma superfície ou encapsulamento. Verifique que a
distância entre os pinos digitais 7 e 8 é de 160mil (milésimos de polegada ou 0,16"),
não é nem mesmo um múltiplo dos 100mil que separam os outros pinos.
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 19
Figura 1 - Arduino Uno
5.10 Shield´s
Figura 2 - Shield Relay
6 Starter Kit
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 20
6.1 Laboratório de Garagem
O Laboratório de Garagem é uma iniciativa voltada para a integração, colaboração e
apoio aos desenvolvedores independentes de ciência e tecnologia, ou como
gostamos de ser chamados: garagistas.
Uma rede social, um laboratório comunitário localizado em São Paulo, uma
incubadora, uma loja virtual e um grupo de pessoas que acreditam que a próxima
revolução pode (e vai) sair de uma garagem, ainda mais se ela estiver conectada a
muitas outras garagens.
O kit utilizado no mini curso foi adquirido na loja Laboratório de Garagem e entregue
em uma caixa personalizada.
Figura 3 - Kit Starter da loja Laboratório de Garagem
6.2 Itens
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 21
Figura 4 - Itens do kit dentro da caixa
Figura 5 - Itens do kit starter
6.2.1 Cabo USB
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 22
Figura 6 - Cabo USB A-B
6.2.2 Protoboard
Figura 7 - Protoboard
6.2.3 Jumpers
Figura 8 - Jumpers para protoboard
6.2.4 Display LCD
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 23
Figura 9 - LCD 2x16 com backlight
Figura 10 - Fundo do LCD 2x16
Figura 11 - Datasheet dos pinos
6.2.5 Arduino UNO
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 24
Figura 12 - Arduino Uno
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 25
Figura 13 - Arduino Uno
Figura 14 - Pinout do Arduino Uno
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 26
Figura 15 - Detalhe do pinout do Arduino Uno
Figura 16 - Conector USB e de Alimentação
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 27
Figura 17 - Detalhe do botão de reset
Figura 18 - Detalhe do led ON e conector ICSP
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 28
Figura 19 - Detalhe para o conversor USB/Serial e Led´s de TX e RX
6.2.6 Resistores
6.2.6.1 Resistor 10 K
Figura 20 - Resistores de 10K
6.2.6.2 Resistor 330 R
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 29
Figura 21 - Resistores de 330R
6.2.7 LED’s
6.2.7.1 LED Verde
Figura 22 - Led Verde
6.2.7.2 LED Amarelo
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 30
Figura 23 - Led Amarelo
6.2.7.3 LED Vermelho
Figura 24 - Led Vermelho
6.2.8 Potenciometro Linear 10K
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 31
Figura 25 - Potenciômetro 10K
6.2.9 Sensor de Temperatura LM35
Figura 26 - Sensor de Temperatura LM35
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 32
6.2.10 Buzzer Contínuo
6.2.11 Push Button
Figura 27 - Push Button
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 33
Figura 28 - Terminais do Push Button
Figura 29 - Detalhe do Push Button
7 Electronic design automation (ECAD)
7.1 Fritzing
8 Práticas
8.1 Analog
8.1.1 Input
8.1.1.1 Potentiometer
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 34
Figura 30 - Protoboard
Figura 31- Esquemático
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 35
Figura 32 - PCB
Código Fonte:
int sensorPin = A0; // select the input pin for the potentiometer int ledPin = 13; // select the pin for the LED int sensorValue = 0; // variable to store the value coming from the sensor void setup() { // declare the ledPin as an OUTPUT: pinMode(ledPin, OUTPUT); } void loop() { // read the value from the sensor: sensorValue = analogRead(sensorPin); // turn the ledPin on digitalWrite(ledPin, HIGH); // stop the program for <sensorValue> milliseconds: delay(sensorValue); // turn the ledPin off: digitalWrite(ledPin, LOW); // stop the program for for <sensorValue> milliseconds: delay(sensorValue); }
8.2 Digital
8.2.1 Input
8.2.1.1 Button
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 36
Figura 33 - Protoboard
Figura 34 - PCB
Figura 35 - Esquemático
Código Fonte:
int ledPin = 13; // choose the pin for the LED int inputPin = 2; // choose the input pin (for a pushbutton) int val = 0; // variable for reading the pin status void setup() { Serial.begin(9600); pinMode(ledPin, OUTPUT); // declare LED as output pinMode(inputPin, INPUT); // declare pushbutton as input }
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 37
void loop(){ val = digitalRead(inputPin); // read input value Serial.println(val); if (val == HIGH) { // check if the input is HIGH digitalWrite(ledPin, LOW); // turn LED OFF } else { digitalWrite(ledPin, HIGH); // turn LED ON } }
8.2.2 Output
8.2.2.1 Blink
Figura 36 - Protoboard
Figura 37 - Esquemático
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 38
Figura 38 - PCB
Código Fonte: int led = 13; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinMode(led, OUTPUT); } // the loop routine runs over and over again forever: void loop() { digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(led, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second }
8.2.2.2 Loop
Figura 39 - Protoboard
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 39
Figura 40 - Esquemático
Figura 41 - PCB
Código Fonte
int timer = 100; // The higher the number, the slower the timing. int pins[] = { 2, 3, 4, 5, 6, 7 }; // an array of pin numbers int num_pins = 6; // the number of pins (i.e. the length of the array) void setup() { int i; for (i = 0; i < num_pins; i++) // the array elements are numbered from 0 to num_pins - 1 pinMode(pins[i], OUTPUT); // set each pin as an output } void loop() { int i; for (i = 0; i < num_pins; i++) { // loop through each pin... digitalWrite(pins[i], HIGH); // turning it on, delay(timer); // pausing, digitalWrite(pins[i], LOW); // and turning it off. } for (i = num_pins - 1; i >= 0; i--) { digitalWrite(pins[i], HIGH); delay(timer); digitalWrite(pins[i], LOW); }
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 40
}
8.2.2.3 Traffic Light
Figura 42 - Protoboard
Figura 43 - Esquemático
Figura 44 - PCB
Código Fonte:
int carRed = 12; int carYellow = 11; int carGreen = 10; int pedRed = 9; int pedGreen = 8;
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 41
int pedBtn = 2; int val = 0; void setup() { pinMode(pedRed, OUTPUT); pinMode(pedGreen, OUTPUT); pinMode(carRed, OUTPUT); pinMode(carYellow, OUTPUT); pinMode(carGreen, OUTPUT); pinMode(pedBtn, INPUT); } void loop(){ digitalWrite (pedRed, HIGH); digitalWrite (carGreen, HIGH); val = digitalRead(pedBtn); if (val == HIGH) { delay(2000); digitalWrite(carGreen, LOW); digitalWrite(carYellow, HIGH); delay(3000); digitalWrite(carYellow, LOW); digitalWrite(carRed, HIGH); delay(3000); digitalWrite(pedGreen, HIGH); digitalWrite(pedRed, LOW); delay(10000); digitalWrite(pedGreen, LOW); digitalWrite(pedRed, HIGH); delay(3000); digitalWrite(carYellow, HIGH); delay(3000); digitalWrite(carYellow, LOW); digitalWrite(carRed, LOW); } }
8.3 Light
8.3.1 Display
8.3.1.1 PrintData
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 42
Figura 45 - Protoboard
Figura 46 - Esquemático
Figura 47 - PCB
Código Fonte:
// include the library code: #include <LiquidCrystal.h> // initialize the library with the numbers of the interface pins LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // set up the LCD's number of columns and rows: lcd.begin(16, 2); // Print a message to the LCD. lcd.print("hello, world!");
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 43
} void loop() { // set the cursor to column 0, line 1 // (note: line 1 is the second row, since counting begins with 0): lcd.setCursor(0, 1); // print the number of seconds since reset: lcd.print(millis()/1000); }
8.3.2 Led
8.3.2.1 Analog In / Out (Pot and LED)
Figura 48 - Protoboard
Figura 49 - Esquemático
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 44
Figura 50 - PCB
Código Fonte
int sensorPin = A3; // select the input pin for the potentiometer int ledPin = 3; // select the pin for the LED int sensorValue = 0; // variable to store the value coming from the sensor void setup() { // declare the ledPin as an OUTPUT: pinMode(ledPin, OUTPUT); } void loop() { // read the value from the sensor: sensorValue = analogRead(sensorPin); // turn the ledPin on digitalWrite(ledPin, HIGH); // stop the program for <sensorValue> milliseconds: delay(sensorValue); // turn the ledPin off: digitalWrite(ledPin, LOW); // stop the program for for <sensorValue> milliseconds: delay(sensorValue); }
8.3.2.2 Color Fader (RGB LED)
Figura 51 - Protoboard
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 45
Figura 52 - Esquemático
Figura 53 - PCB
Código Fonte:
int LEDGreen=9; int LEDBlue=10; int LEDRed=11; int sensorPin=0; int val; void setup(){ Serial.begin(9600); pinMode(LEDRed,OUTPUT); pinMode(LEDGreen,OUTPUT); pinMode(LEDBlue,OUTPUT); } void loop(){ val=map(analogRead(sensorPin),0,1024,0,900); Serial.println(val); if (val<150) { analogWrite(LEDRed,0); analogWrite(LEDBlue,255); analogWrite(LEDGreen,255); } else if (val<300) {
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 46
analogWrite(LEDRed,map(val,150,300,0,255)); analogWrite(LEDBlue,map(val,150,300,255,0)); analogWrite(LEDGreen,255); } else if (val<450) { analogWrite(LEDRed,255); analogWrite(LEDBlue,0); analogWrite(LEDGreen,255); } else if (val<600) { analogWrite(LEDRed,255); analogWrite(LEDBlue,map(val,450,600,0,255)); analogWrite(LEDGreen,map(val,450,600,255,0)); } else if (val<750) { analogWrite(LEDRed,255); analogWrite(LEDBlue,255); analogWrite(LEDGreen,0); } else if (val<900) { analogWrite(LEDRed,map(val,750,900,255,0)); analogWrite(LEDBlue,255); analogWrite(LEDGreen,map(val,750,900,0,255)); } delay(10); }
8.4 Sensors
8.4.1 Temperature
8.4.1.1 Temperature Sensors
Figura 54 - Protoboard
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 47
Figura 55 - Esquemático
Figura 56 - PCB
Código Fonte: float temperature; // stores the temperature int sensorPin = 0; // pin where the sensor is connected to int startTemp=20; // the start temperature > at this temperature, no LED will light up void setup() { Serial.begin(9600); // initialisation of the serial connection for (int i=2;i<8; i++){ // output channels from 2 to 7 pinMode(i,OUTPUT); // pin is a output } } void loop() { temperature = analogRead(sensorPin); // reading analog sensor value temperature = temperature*0.488; // correcting to °C
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 48
for (int i=0;i<8; i++){ if (temperature>((i*2)+startTemp)){ // switch LED on, if temperature is higher than starttemp + (LED number*2) digitalWrite(i,HIGH); } else { digitalWrite(i,LOW); // else, switch it off } } Serial.print(temperature);Serial.println(" °C"); // send the temperarue to the serial monitor delay(500); // just wait a little }
8.5 Sound
8.5.1 Melody
Figura 57 - Protoboard
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 49
Figura 58 - Esquemático
Figura 59 - PCB
Código Fonte: int speakerPin = 11; int length = 15; // the number of notes char notes[] = "ccggaagffeeddc "; // a space represents a rest int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }; int tempo = 300; void playTone(int tone, int duration) { for (long i = 0; i < duration * 1000L; i += tone * 2) { digitalWrite(speakerPin, HIGH); delayMicroseconds(tone); digitalWrite(speakerPin, LOW); delayMicroseconds(tone); } }
FUNDAÇÃO EDUCACIONAL MONTES CLAROS – FEMC FACULDADE DE CIÊNCIA E TECNOLOGIA DE MONTES CLAROS – FACIT
ENGENHARIA DE COMPUTAÇÃO LABORATÓRIO DE SISTEMAS COMPUTACIONAIS
INTRODUÇÃO À COMPUTAÇÃO FÍSICA COM ARDUINO
Thalis Antunes – www.thalisantunes.com.br | 50
void playNote(char note, int duration) { char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' }; int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 }; // play the tone corresponding to the note name for (int i = 0; i < 8; i++) { if (names[i] == note) { playTone(tones[i], duration); } } } void setup() { pinMode(speakerPin, OUTPUT); } void loop() { for (int i = 0; i < length; i++) { if (notes[i] == ' ') { delay(beats[i] * tempo); // rest } else { playNote(notes[i], beats[i] * tempo); } // pause between notes delay(tempo / 2); } }