CURSO BÁSICO DE ARDUINO MÓDULO I: PASSOS INICIAIS PARA ROBÓTICA
CMCF CENTRO DE MATEMÁTICA, CIÊNCIAS E FILOSOFIA
NAR NÚCLEO DE AUTOMAÇÃO E ROBÓTICA
Me. Hélio Evangelista da Silva Prof. Antônio Fernandes Souza Filho
1
Sumário CURSO BÁSICO DE ARDUINO ........................................................................................................................... 3 MÓDULO I: PASSOS INICIAIS PARA ROBÓTICA ........................................................................................... 3 1 - O QUE VOU APRENDER? ................................................................................................................................. 3 2 – CONHECENDO O ROBÔ DUDE: CARACTERÍSTICAS E FUNÇÕES ........................................................... 3 2.1 Design ......................................................................................................................................................... 3 2.2 Componentes ............................................................................................................................................. 3 2.3 Ardublock – Programação gráfica para Arduino ................................................................................... 3 2.4 Programando com o Ardublock............................................................................................................... 4 2.4.1 Led piscando, com uma cor, usando o setar pin digital ................................................................... 4 2.4.2 Led piscando, com cores diferentes, utilizando o led RGB .............................................................. 4 2.4.3 Buzzer ...................................................................................................................................................... 5 2.4.4 Sensor de luz: LDR ................................................................................................................................. 5 2.4.5 Sensor ultrassônico e servo motor ...................................................................................................... 5 2.4.6 Dog Inteligente com LEDs ..................................................................................................................... 6 3 - ARDUINO ............................................................................................................................................................ 6 3.1 PLACA ARDUINO ....................................................................................................................................... 7 3.2 SHIELDS PARA ARDUINO ........................................................................................................................ 7 4 - PROTOBOARD ................................................................................................................................................... 7 5 - Seção de Exemplos Práticos............................................................................................................................ 8 Exemplo 1 – Ligando o Led ............................................................................................................................ 8 Exemplo 2 – Utilizando o Buzzer ................................................................................................................. 11 Exemplo 3 – Utilizando o botão Push-buton .............................................................................................. 12 Exemplo 4 – Sensor de luz LDR ................................................................................................................... 12 Exemplo 5 - Acionando o Micro Servo 9g SG90 TowerPro ...................................................................... 13 Exemplo 6 – Sensor de Distância Ultrassônico HC-SR04 ........................................................................ 15 Exemplo 7 – Sensor Infravermelho ............................................................................................................. 16 Exemplo 8 – Potenciômetro ......................................................................................................................... 17 6 - BIBLIOTECAS ................................................................................................................................................... 18 6.1 Usando o gerenciador de bibliotecas ................................................................................................... 18 6.2 Importando uma biblioteca .zip ............................................................................................................. 18 6.3 Instalação manual.................................................................................................................................... 18 7 - Considerações finais....................................................................................................................................... 18 Referências ............................................................................................................................................................ 19 PROJETO FINAL ................................................................................................................................................... 19 ANEXOS ................................................................................................................................................................... 1
2
CURSO BÁSICO DE ARDUINO MÓDULO I: PASSOS INICIAIS PARA ROBÓTICA através de servo motores programáveis. Outros sensores podem ser acoplados através de uma porta de comunicação na sua parte superior. O robô é alimentado por um conjunto de 6 pilhas AA e programado através de um cabo do tipo USB. Seus componentes são:
1 - O QUE VOU APRENDER? Muitas vezes pensamos que os temas tecnológicos pedem uma grande habilidade técnica e um grande conhecimento, mas isso não é verdade. Nosso objetivo com esta apostila é fazer com que esses processos tecnológicos sejam simples de entender, e demonstrar que aqueles mais complexos na verdade são a união de vários processos simples. Com esta apostila você vai aprender conceitos que poderá aplicar em seus próprios projetos.
1. 2. 3. 4. 5. 6. 7. 8.
2 – CONHECENDO O ROBÔ DUDE: CARACTERÍSTICAS E FUNÇÕES
Placa Arduino e Shield; Sensor ultrassônico; Sensor seguidor de linha; Sensor infravermelho; Sensor de luz: LDR; Buzzer; Led RGB; Servo motor.
2.3 Ardublock – Programação gráfica para Arduino
2.1 Design
Ardublock é uma linguagem de programação que utiliza blocos de funções prontas. Do mesmo jeito que o Arduino ajuda entusiastas a entrar no meio da eletrônica e automação, o Ardublock ajuda a quem não tem conhecimento em linguagens de programação a criar programas para o Arduino de forma simples e intuitiva.
O design do robô foi constituído basicamente para comportar a interface de controle Arduino e o sistema de locomoção é baseado em servo motores. Pensando na utilização de crianças do Ensino Fundamental, o chassi/carcaça do robô foi construído em plástico injetado, a fim de não preocupar os professores com quebras devido a fragilidade do material.
Como os blocos disponíveis do Ardublock se equiparam a funções de uma linguagem de programação, o Ardublock possui uma vasta possibilidade de utilização e aplicação.
2.2 Componentes O robô é capaz de algumas atividades préestabelecidas, como: seguir linhas, desviar de obstáculos com o seu sistema de infravermelho ou com o sonar. Também pode ser utilizado para medir variáveis ambientais como temperatura, luminosidade ou som. Pode emitir sons e sinais luminosos através de LEDs. Se movimenta
Exemplo de programa feito no Ardublock
3
2.4 Programando com o Ardublock 2.4.1 Led piscando, com uma cor, usando o setar pin digital Vamos demonstrar aqui como realizar um programa simples de piscar um LED no ambiente de programa em blocos (Ardublock). À esquerda do Ardublock se encontram todas as funções disponíveis, desde operadores lógicos e condições de estado até controles das entradas e saídas do Arduino. Este bloco possui 2 argumentos: Número do pino e estado lógico desejado. Selecione o pino 13 e nível lógico alto (HIGH); Vamos utilizar o bloco controle espera (ms) para fazer um atraso de 1 segundo. Seu parâmetro é o tempo de atraso em milissegundos.
Clique no botão Enviar para Arduino para gravar o programa no seu Arduino. Observações: Certifique-se na seção tools da janela do Arduino que a placa e a porta de comunicação foram selecionadas corretamente. O Ardublock se encarrega de configurar as entradas e saídas dos pinos, de forma a facilitar para o usuário.
O Ardublock, assim como a linguagem do Arduino, é sequencial, portanto ele executará uma função de cada vez. Para dar as ordens das instruções no Ardublock conectamos uma função em baixo da outra, simplesmente arrastando e conectando um bloquinho embaixo do outro. Faça isto para os 2 últimos blocos criados. Colocando o espera (ms) em baixo do setar pin digital. Agora estes 2 blocos formam um bloco só. Como queremos ligar o LED por um segundo e em seguida desligá-lo por um segundo precisamos de um segundo bloco deste para fazer a segunda operação. Clique com o botão direito neste bloco e aperte o botão clone para fazer uma cópia. Encaixe a cópia do bloco criado em baixo do bloco original, e configure o segundo setar pin digital para LOW (desligado).
2.4.2 Led piscando, com cores diferentes, utilizando o led RGB Para a programação desejada utilize a Biblioteca ROBO+EDU e a seguir selecione, arraste e encaixe o LED RGB no Loop; 4
No LED RGB, selecione verdadeiro para a cor que deseja deixar em evidência e falso para as outras duas.
Agora é só enviar para o Dude e ouça o resultado.
2.4.4 Sensor de luz: LDR Para a programação desejada utilize Controle e a seguir selecione, arraste e encaixe a função se/então no Loop; Clique no menu teste e escolha a função maior que ( > ) e encaixe em teste;
Através da função Controle selecione, arraste e encaixe o bloco espera (ms) no Loop e mude o tempo para 2000 (Correspondente a 2 segundos).
Na Biblioteca ROBO+EDU selecione a função Sensor de luz de topo e encaixe no lado esquerdo da função maior que (>); Na função Variáveis/Constantes selecione a função Constante inteira e insira o valor 50. Na Biblioteca ROBO+EDU selecione, arraste e encaixe a função Led RGB ao lado de então. Queremos mostrar que: se o valor do sensor de luz for maior que 50, então liga o led, senão desliga o led.
Faça a mesma programação para as cores verde e azul. Depois coloque duas cores verdadeiras e envie para o Dude e veja o resultado.
Clique com o botão direito neste bloco e aperte o botão clone para fazer uma cópia. Encaixe a cópia do bloco criado ao lado de Senão, e configure as cores para falso.
2.4.3 Buzzer Para a programação desejada utilize a Biblioteca ROBO+EDU e a seguir selecione, arraste e encaixe a função Buzzer – Soar por um tempo no Loop; No Buzzer – Soar por um tempo, altere a frequência para 400 e o tempo para 100. Como queremos uma sirene, precisamos de um segundo bloco deste para alterar a frequência.
Agora é só enviar novamente para o Dude e observe o resultado.
Clique com o botão direito neste bloco e aperte o botão clone para fazer uma cópia.
2.4.5 Sensor ultrassônico e servo motor
Encaixe a cópia do bloco criado em baixo do bloco original, e configure o segundo Frequência para 800.
Para a programação desejada utilize Controle e a seguir selecione, arraste e encaixe a função se/então no Loop; Clique no menu teste e escolha a função menor que (<) e encaixe em teste; Na Biblioteca ROBO+EDU selecione a função Sensor ultrassônico e encaixe no lado esquerdo da função menor que (<); 5
Na função Variáveis/Constantes selecione a função Constante inteira e insira o valor 15.
O Robô ficar parado e com a luz de topo azul, se o sensor ultrassônico estiver entre 15 e 25.
Selecione, arraste e encaixe no menu então: Re servomotor esquerdo e Re servomotor direito obtidos na Biblioteca ROBO+EDU;
3 - ARDUINO
No menu Controle selecione espera (ms) e encaixe abaixo da função Re servomotor direito inserindo o valor 1000;
Arduino é uma plataforma de eletrônica aberta para a criação de protótipos baseada em software e hardware livres, flexíveis e fáceis de usar. Foi desenvolvida para artistas, designers, hobistas e qualquer pessoa interessada em criar objetos ou ambientes interativos. O Arduino pode adquirir informação do ambiente através de seus pinos de entrada, para isso uma completa gama de sensores pode ser usada. Por outro lado, o Arduino pode atuar no ambiente controlando luzes, motores ou outros atuadores. Os campos de atuação para o controle de sistemas são imensos, podendo ter aplicações na área de impressão 3D, robótica, engenharia de transportes, engenharia agronômica, musical, moda e tantas outras. O microcontrolador da placa Arduino é programado mediante a linguagem de programação Arduino, baseada em Wiring, e o ambiente de desenvolvimento (IDE) está baseado em Processing. Os projetos desenvolvidos com Arduino podem ser executados mesmo sem a necessidade de estar conectados a um computador, apesar de que também podem ser feitos comunicando-se com diferentes tipos de software (como Flash, Processing ou MaxMSP). As placas podem ser feitas a mão ou compradas montadas de fábrica. O download do software pode ser feito de forma gratuita e os desenhos da placa estão disponíveis sob uma licença aberta, assim você também é livre para adaptá-lo às suas necessidades.
Abaixo da função espera (ms), encaixe Servomotor esquerdo e, a seguir, Re servomotor direito e espera (ms) inserindo valor 1000. Selecione, arraste e encaixe no menu senão: Servomotor esquerdo e Servomotor direito obtidos na Biblioteca ROBO+EDU.
Com os procedimentos anteriores se o valor do sensor ultrassônico for menor que 15, então o robô irá dar uma ré e virar para a direita 90 graus, senão o robô andará para frente.
2.4.6 Dog Inteligente com LEDs A programação abaixo consiste em: O Robô andar para frente e com a luz de topo verde, se o sensor ultrassônico for maior ou igual a 25; O Robô andar para trás e com a luz de topo vermelha, se o sensor ultrassônico for menor ou igual a 15;
www.arduino.cc
6
3.2 SHIELDS PARA ARDUINO
3.1 PLACA ARDUINO
Um shield é uma placa que permite expandir as funcionalidades originais do Arduino.
4 - PROTOBOARD
1. 2. 3. 4. 5. 6.
Conector USB para o cabo tipo AB Botão de reset Pinos de entrada e saída digital e PWM LED vermelho de placa ligada LED laranja conectado ao pin13 ATmega encarregado da comunicação com o computador 7. - LED TX (transmissor) e RX (receptor) da comunicação serial 8. Porta ICSP para programação serial 9. Microcontrolador ATmega 328, cérebro do Arduino 10. Cristal de quartzo 16Mhz 11. Regulador de voltagem 12. Conector fêmea 2,1mm com centro positivo 13. Pinos de voltagem e terra 14. Entradas analógicas
Protoboard é uma palavra em inglês que vem da junção das palavras prototyping (prototipagem) e board (placa). Uma protoboard é uma matriz de contato, uma placa com furos e conexões condutoras para montagem de circuitos eletrônicos experimentais. A grande vantagem de usar uma protoboard é na montagem de circuitos pois é muito fácil inserir componentes e testar um circuito, uma vez que não necessita de soldagem. É uma placa reutilizável usada para construir protótipos de circuitos eletrônicos sem solda. Uma protoboard é feita por blocos de plástico perfurados e várias lâminas finas de uma liga metálica de cobre, estanho e fósforo. Vamos entender como ela é constituída. Por dentro, a protoboard é conectada desta forma:
7
aspecto prático da montagem, não necessariamente você precisa de ler toda a parte introdutória para montar os circuitos abaixo. Em cada exemplo vamos apresentar os materiais utilizados, o diagrama de circuito e o código base com as devidas explicações e sugestões de referências.
Exemplo 1 – Ligando o Led Neste primeiro projeto iremos fazer um led piscar. Parece um projeto simples demais, mas isso exemplifica a utilização do Arduino para controle de dispositivos externos. Os conceitos aprendidos neste exemplo servem para acionamento de outros dispositivos como ventilador, lâmpadas, motores entre outros.
As colunas de cada um dos lados da protoboard são conectadas entre si. As linhas externas também possuem conexões internas:
O que é um LED? LED (do inglês, Light Emitting Diode) é um diodo emissor de luz, sendo basicamente é uma lâmpada que consome pouca energia. Por seu baixo consumo, está se tornando cada vez mais comum o seu uso em casas. Outra grande vantagem do LED é a facilidade de fabricação em diversas cores e nesse kit você receberá LEDs das cores amarelo, verde e vermelho.
Desta forma, conectando um terminal do componente a umas das colunas, podemos utilizar qualquer outro furo desta coluna para incluir o terminal do componente que deve se ligar a ele.
O LED, assim como alguns componentes, possui um lado positivo “+” e um lado negativo “-“, essa característica também é conhecida como polaridade. Para esses componentes, se ligar de modo invertido, ele não irá funcionar e pode até acabar danificando. A haste (perna) maior do LED é o lado positivo e a menor é o lado negativo. Você pode ver também pelo lado mais achatado, que é o lado negativo enquanto o lado arredondado é o positivo.
5 - Seção de Exemplos Práticos Agora vamos entrar nas seções de exemplos em si. Os conceitos da Parte I são importantes caso você esteja começando a trabalhar com eletrônica. No entanto, devido ao 8
Em todos os projetos teremos uma seção que mostra os componentes que iremos utilizar. Se você tiver alguma dúvida sobre qual é o componente, você pode voltar na lista de materiais: 1x LED Vermelho 5 mm 1x Resistor 220 ohm 1x Protoboard 2x Jumper macho-macho 1x Cabo USB 1x Placa Uno
do resistor é fixo e é indicado pelas faixas de cores pintada nele.
Aviso! O kit pode conter resistores de coloração ou faixa de cores diferentes da ilustração acima, mas não se preocupe, basta olhar o valor escrito na etiqueta do pacote de resistores. Caso venham na cor amarela e quatro faixas, identifique-os de acordo com a ilustração abaixo:
A montagem correta de um LED em uma protoboard é feita como mostrado na figura abaixo. Os dois terminais do LED não podem ficar na mesma coluna da protoboard, lembrando que os furos das colunas são conectados entre si na vertical. Esse mesmo princípio de montagem se aplica também a outros componentes do kit.
Utilizando um resistor de valor 220 ohm, por exemplo, reduzimos a corrente do circuito para trabalhar nos valores que o LED suporta. Sem o resistor, a corrente que passa pelo LED seria muito grande e acabaria queimando ele. Você pode ligar um resistor tranquilamente pois ele não tem lado positivo ou negativo, ou seja, tanto faz o lado que é conectado. Jumper é o fio que liga os vários componentes de um circuito. Você pode ligá-los na protoboard, na placa Arduino ou mesmo direto no componente. Para ajudar na organização do seu circuito os jumpers vêm em diversas cores, mas as cores não alteram em nada o seu funcionamento.
O que é um resistor? O resistor é o componente elétrico mais comum que existe. Uma das aplicações de um resistor, e a mais comum, é limitar o fluxo da corrente elétrica que passa em um circuito. Os resistores têm diferentes valores de resistência, quanto mais alta a resistência, mais ele irá limitar a corrente que passa por ele. O valor 9
Montagem do circuito No caso do nosso projeto, a fonte de energia vem da porta 11 do Arduino. Com a programação correta, é possível ligar e desligar a energia do pino 11, fazendo o LED acender e apagar. No esquema da montagem do circuito, as linhas coloridas são a representação gráfica dos jumpers. Utilize-os para ligar os componentes entre si conforme a ilustração abaixo. Note que o pino 11 está conectado ao lado positivo do LED, enquanto o GND vai no pino negativo, passando antes pelo resistor. Como funciona um circuito eletrônico? Antes de montarmos o primeiro circuito é interessante aprender um pouco sobre o que é um circuito e alguns conceitos básicos. Um circuito elétrico basicamente é um laço onde circula energia elétrica, fazendo com que cada componente funcione. Veja abaixo um circuito básico de eletrônica composto de uma fonte de energia, resistor e LED.
Não é necessário conectar os componentes exatamente nos mesmos furos como indicados acima, basta apenas que os terminais de cada componente não estejam na mesma coluna. Também não importa se o resistor está antes ou depois do LED, ele vai reduzir a corrente do laço estando antes ou depois. Veja abaixo montagem alternativa do circuito acima mas que funciona da mesma maneira. Note que o pino GND do Arduino ainda está conectado no negativo do LED e o pino 11 ainda está no positivo do LED.
O lado positivo da fonte é chamada de VCC ou 5V e o lado negativo é chamado de GND. Uma fonte pode ser uma bateria ou pilha que quando ligada faz com que o circuito funcione. Também veremos que algumas portas do Arduino podem fazer um papel de fonte, assim podemos ligar e desligar o circuito utilizando programação. Nesse exemplo, o LED acende quando a fonte de energia é ligada e ao se desligar a fonte de energia, o LED apagará. O resistor é colocado para reduzir a corrente que passa pelo circuito inteiro.
10
//Aguarda intervalo de tempo em milissegundos delay(1000); //Apaga o led digitalWrite(11, LOW); //Aguarda intervalo de tempo em milissegundos delay(1000); }
Veja abaixo o circuito representando a montagem acima.
A linha do código contendo digitalWrite(11, HIGH);, liga o pino 11, acendendo o led. O comando delay (1000);, especifica o intervalo, em milésimos de segundos (milissegundos), no qual o programa fica parado antes de avançar para a próxima linha. Quanto maior esse número, mais tempo o programa vai esperar para passar para a próxima linha. O comando digitalWrite (11, LOW);, apaga o LED, desligando o pino 11, e depois ocorre uma nova parada (delay) no programa. Após essa espera, o processo é então reiniciado, voltando para o início do loop(). Você reparou que todo comando termina com um ponto e vírgula “;“? Ele é muito importante na programação porque define que o comando acabou ali. Se está faltando um “;” o programa não irá funcionar de jeito nenhum!
alternativo
Primeiramente vamos explicar um programa em partes e logo mais abaixo você verá um programa completo. A primeira coisa que fazemos no início do programa é colocar uma pequena observação sobre o nome do programa, sua função e quem o criou:
O programa para ligar o Led encontra-se no exemplo 1 do Anexo. Agora é com você, monte um circuito com vários Leds. Antes você pode simular no Tinkercad: https://www.tinkercad.com/
// Programa : Led Pisca // Autor : FILIPEFLOP Comece uma linha com barras duplas “// ” e tudo o que vier depois nessa linha será tratado como um comentário. Após os comentários, vem a estrutura do setup(). É nela que definimos que o pino 11 do Arduino será utilizado como saída, para servir como fonte de energia para o circuito. void setup() { //Define a porta do led como saida pinMode (11, OUTPUT); } Por último, temos o loop(), que contém as instruções para acender e apagar o LED, e também o intervalo entre essas ações: void loop() { //Acende o led digitalWrite(11, HIGH);
Exemplo 2 – Utilizando o Buzzer Abaixo apresentamos o circuito utilizado no vídeo para criar sons com a Arduino e um alto falante:
11
Você pode também utilizar um buzzer para esta finalidade. Utilizando um buzzer de 5V, o circuito ficaria assim:
Esse pequeno código abaixo mostra como ler entradas digitais e com acionar as saídas digitais. Na função void Setup(), é preciso configurar qual pino será usado como saída e qual será usado como entrada. Depois de configurar os pinos, para acioná-los basta chamar a função digitalWrite(pino,HIGH). A função digitalWrite() aciona ou desaciona um pino digital dependendo do valor passado no argumento. Se for “HIGH”, o pino é acionado. Se for “LOW”, o pino é desligado. Na função void Loop(), fizemos um if no qual a função digitalRead é usada para saber se o pushButton está acionado ou não. Caso ele esteja acionado, nós acendemos o Led, caso ele esteja desligado, nós desligamos o led. Carregue o código do exemplo 3 no Anexo e pressione o botão para acender o LED.
Faça o teste no Tinkercad: https://www.tinkercad.com/ Monte o circuito e faça o upload do código do exemplo 2 no Anexo para a sua placa. Em seguida, abra o Monitor Serial e digite diferentes valores. O valor inserido corresponde à frequência da nota que será tocada.
Exemplo 3 – Utilizando o botão Push-buton
Referências: ● https://www.arduino.cc/reference/en/langu age/functions/digital-io/digitalread/ ● https://www.arduino.cc/reference/en/langu age/functions/digital-io/digitalwrite/
Os push-buttons (chaves botão) e leds são elementos presentes em praticamente qualquer circuito eletrônico. As chaves são usadas para enviar comandos para o Arduino e os Leds são elementos de sinalização luminosa. Esses dois componentes são trabalhados por meio das entradas e saídas digitais do Arduino. Neste exemplo vamos fazer uma aplicação básica que você provavelmente vai repetir muitas vezes. Vamos ler o estado de um push-button e usá-la para acender ou apagar um led. Ou seja, sempre que o botão for acionado, vamos apagar ou desligar o Led. • • • • • • •
Exemplo 4 – Sensor de luz LDR O sensor LDR é um sensor de luminosidade. LDR é um Light Dependent Resistor, ou seja, um resistor cuja resistência varia com a quantidade de luz que incide sobre ele. Esse é seu princípio de funcionamento. Quanto maior a luminosidade em um ambiente, menor a resistência do LDR. Essa variação na resistência é medida através da queda de tensão no sensor, que varia proporcionalmente (de acordo com a lei Ohm) com a queda na resistência elétrica. A imagem abaixo mostra o sensor em mais detalhes:
Para esse exemplo você vai precisar: 2 resistores de 330 ohms; 1 Led vermelho (ou de outra cor de sua preferência); Push-button (chave botão); 1 Arduino UNO; Protoboard; Jumpers de ligação.
Diagrama de circuito:
Fotoresistor (LDR)
12
• •
É importante considerar a potência máxima do sensor, que é de 100 mW. Ou seja, com uma tensão de operação de 5V, a corrente máxima que pode passar por ele é 20 mA. Felizmente, com 8K ohms (que medimos experimentalmente com o ambiente bem iluminado), que é a resistência mínima, a corrente ainda está longe disso, sendo 0,625mA. Dessa forma, podemos interfacear o sensor diretamente com o Arduino. *Nota: Nas suas medições, pode ser que você encontre um valor de resistência mínimo diferente, pois depende da iluminação local.
Protoboard; Jumpers de ligação.
Diagrama de circuito:
No diagrama, o sensor é ligado como parte de um divisor de tensão no pino analógico A0, de forma que a tensão de saída do divisor varia de acordo com a variação da resistência do sensor. Assim, vamos identificar as variações na intensidade de luz pelas variações na tensão do sensor. Quanto maior a intensidade de luz, menor a resistência do sensor e, consequentemente, menor a tensão de saída. Carregue o código do exemplo 4 no Anexo e varie a luminosidade sobre o LDR. No código acima usamos funcionalidades de todos os exemplos anteriores. Como o sensor é um elemento de um divisor de tensão, fazemos a sua leitura do mesmo modo que nos exemplos do potenciômetro e divisor de tensão. Nesse caso, definimos uma tensão de limiar, a partir da qual desligamos ou ligamos um led para indicar que a intensidade da luz ultrapassou determinado valor. Esse limiar pode ser ajustado por você para desligar o led em intensidades diferentes de luz ambiente. É importante que o sensor esteja exposto à iluminação ambiente e não sofra interferência de fontes luminosas próximas, mas que não sejam parte do ambiente.
Especificações do LDR: • Modelo: GL5528 • Diâmetro: 5mm • Tensão máxima: 150VDC • Potência máxima: 100mW • Temperatura de operação: -30°C a 70°C • Comprimento com terminais: 32mm • Resistência no escuro: 1 MΩ (Lux 0) • Resistência na luz: 10-20 KΩ (Lux 10) Este sensor de luminosidade pode ser utilizado em projetos com arduino e outros microcontroladores para alarmes, automação residencial, sensores de presença e vários outros. Nesse exemplo, vamos usar uma entrada analógica do Arduino para ler a variação de tensão no LDR e, consequentemente, saber como a luminosidade ambiente está se comportando. Veja na especificação que com muita luz, a resistência fica em torno de 10-20 KΩ, enquanto que no escuro pode chegar a 1MΩ. Para podermos ler as variações de tensão resultantes da variação da resistência do LDR, vamos usar o sensor como parte de um divisor de tensão. Assim, a saída do divisor será dependente apenas da resistência do sensor, pois a tensão de entrada e a outra resistência são valores conhecidos. No nosso caso, vamos usar um resistor de 10K e uma tensão de operação de 5V. Assim, o sinal que vamos ler no arduino terá uma variação de 2,2V (quando o LDR for 8K) e 5V (quando o LDR tiver resistências muito maiores que o resistor de 10K).
Referências: ● https://maker.pro/education/using-an-ldrsensor-with-arduino-a-tutorial-forbeginners ● http://blog.eletrogate.com/controle-deluminosidade-com-arduino-e-sensorldr/
Exemplo 5 - Acionando o Micro Servo 9g SG90 TowerPro Um servomotor é um equipamento eletromecânico que possui um encoder e um controlador acoplado. Diferentemente de motores tradicionais, como de corrente contínua, o servo motor apresenta movimento rotativo
Para esse exemplo você vai precisar: • LDR; • Resistor de 10k; • 1 Arduino UNO; 13
proporcional a um comando de forma a atualizar • sua posição. Ao invés de girar continuamente • como os motores de corrente contínua, o servo, • ao receber um comando, gira até a posição especificada pelo mesmo. Ou seja, o servo motor é um atuador rotativo para controle de posição, que atua com precisão e velocidade controlada em malha fechada. De acordo com a largura do pulso aplicado no pino de controle PWM, a posição do rotor é definida (0 a 180 graus). Os pulsos devem variar entre 0,5 ms e 2,5 ms.
Antes de mais nada, vamos separar os componentes que precisamos para montar o servomotor junto com o arduino. A nossa lista de componentes é a seguinte: ● ● ● ●
Micro Servo 9g SG90 TowerPro; Arduino UNO + cabo USB; Potenciômetro de 10k; Fonte 5V de protoboard para alimentar o servo; ● Jumpers para conexão no protoboard; ● Push button. A montagem é simples. O servomotor em si deve ser ligado à alimentação conforme as cores apresentadas na introdução. De acordo com as especificações de tensão e corrente dos pinos do arduino UNO, os pinos de VCC e GND da placa conseguem fornecer até 200 mA. Ao utilizar servomotores, é recomendado que você utilize uma fonte externa, como a fonte para protoboard que inserimos na lista de materiais.
Posição do Servo de acordo com a largura do pulso Fonte : electronics.stackexchange.com
• •
Marron: GND, Vermelho: Alimentação positiva, Laranja: Sinal de controle PWM.
Existem dois tipos de Servomotores: Servomotor analógico Servomotor digital
Diagrama de circuito A montagem para uma aplicação de controle do servo em qualquer posição, fica da seguinte forma:
Servomotores analógicos são os mais comuns e mais baratos. O controle da posição do rotor utiliza um método analógico através da leitura de tensão sobre um potenciômetro interno. No caso dos servomotores digitais, mais caros e mais precisos, o controle da posição do rotor utiliza um encoder digital. A figura abaixo mostra um típico servo motor analógico. Trata-se do Micro Servo Tower Pro SG90 9G que acompanha o kit Arduino.
Carregue o código do exemplo 5 no Anexo e gire o potenciômetro para o Servo motor girar. O aspecto mais importante desse software é a utilização da biblioteca servo.h. Esta biblioteca possui as funções necessárias para posicionar a servo para a posição desejada. Na função Void Setup() nós associamos o objeto servomotor, do tipo Servo, a um pino do arduino. Na mesma função, nós inicializamos o servo na posição 0º, utilizando o método write do objeto que acabamos de criar. Na função Void Loop(), o procedimento consiste em ler o valor do potenciômetro e usálo como referência para atualizar a posição do servo. A leitura analógica do potenciômetro
Os Servos são acionados por meio de três fios, dois para alimentação e um correspondente ao sinal de controle para determinar a posição. Em geral, os três fios são: 14
retorna um valor entre 0 e 1023. Para controlar o servo nós usamos valores de 0 a 179, correspondendo ao meio giro de 180º do mesmo. Assim, Ê necessårio usar a função Map() para traduzir a escala de 0-1023 para a escala de 0179. Dessa forma, os valores lidos do potenciômetro podem ser usados como referência para determinar a posição do servomotor. Para atualizar a posição do servo a cada iteração do loop, nós chamamos o mÊtodo write() do objeto servomotor, passando como parâmetro o valor lido do potenciômetro traduzido para a escala de 0-179. Assim, sempre que mexermos no potenciômetro, o servo motor irå atuar e atualizar a sua posição. Referências:
â&#x2014;? Circuito de controle â&#x20AC;&#x201C; Controla o conjunto transmissor/receptor, calcula o tempo entre a emissĂŁo e recepção do sinal;
â&#x2014;? http://blog.eletrogate.com/servo-motor-paraaplicacoes-com-arduino/ â&#x2014;? https://www.arduino.cc/en/Tutorial/Knob â&#x2014;? https://www.allaboutcircuits.com/projects/ser vo-motor-control-with-anarduino/ â&#x2014;? http://www.instructables.com/id/ArduinoServo-Motors/
1. O circuito externo (Arduino) envia um pulso de trigger de pelo menos 10us em nĂvel alto;
O funcionamento consiste em trĂŞs etapas:
2. Ao receber o sinal de trigger, o sensor envia 8 pulsos de 40khz e detecta se hĂĄ algum sinal de retorno ou nĂŁo; 3. Se algum sinal de retorno for identificado pelo receptor, o sensor gera um sinal de nĂvel alto no pino de saĂda cujo tempo de duração ĂŠ igual ao tempo calculado entre o envio e o retorno do sinal ultrassĂ´nico;
Exemplo 6 â&#x20AC;&#x201C; Sensor de Distância UltrassĂ´nico HC-SR04 O princĂpio de funcionamento do Sensor HC-SR04 consiste na emissĂŁo de sinais ultrassĂ´nicos e na leitura do sinal de retorno (reflexo/eco) desse mesmo sinal. A distância entre o sensor e o objeto que refletiu o sinal ĂŠ calculada com base no tempo entre o envio e leitura de retorno.
Por meio desse pulso de saĂda cujo tempo ĂŠ igual a duração entre emissĂŁo e recepção, nĂłs calculamos a distância entre o sensor e o objeto/obstĂĄculo, por meio da seguinte equação: đ??ˇđ?&#x2018;&#x2013;đ?&#x2018; đ?&#x2018;Ąđ?&#x2018;&#x17D;đ?&#x2018;&#x203A;đ?&#x2018;?đ?&#x2018;&#x2013;đ?&#x2018;&#x17D; = (Tempo de duração do sinal de saĂda x velocidade do sol) / 2 Em que o Tempo de duração do sinal de saĂda ĂŠ o tempo no qual o sinal de output permanece em nĂvel alto e a velocidade do som = 340 m/s. Repare que as unidades devem estar coerentes para o resultado da conta ser correto. Assim, se a velocidade do som ĂŠ dada em metros/segundo, o tempo de duração do sinal de saĂda deve estar em segundos para que possamos encontrar a distância em metros. Para este exemplo vocĂŞ vai usar os seguintes componentes:
â&#x20AC;&#x153;Sinais UltrassĂ´nicos sĂŁo ondas mecânicas com frequĂŞncia acima de 40 KHzâ&#x20AC;?. Como ouvido humano sĂł consegue identificar ondas mecânicas atĂŠ a frequĂŞncia de 20KHz, os sinais emitidos pelo sensor UltrassĂ´nico nĂŁo podem ser escutados por nĂłs. O sensor HC-SR04 ĂŠ composto de trĂŞs partes principais: â&#x2014;? Transmissor UltrassĂ´nico â&#x20AC;&#x201C; Emite as ondas ultrassĂ´nicas que serĂŁo refletidas pelos obstĂĄculos; â&#x2014;? Um receptor â&#x20AC;&#x201C; Identifica o eco do sinal emitido pelo transmissor;
â&#x2014;? Protoboard; â&#x2014;? Jumpers de ligação; â&#x2014;? Sensor ultrassĂ´nico HCSR-04 15
Diagrama de circuito:
Exemplo 7 – Sensor Infravermelho O Sensor Infravermelho Reflexivo de Obstáculo funciona através de um sistema de reflexão infravermelho, onde um LED emissor IR e um fototransistor IR ficam lado a lado e quando um obstáculo ou objeto atravessa dentro do raio de ação de ambos o sensor coloca a saída em nível baixo e um LED verde será aceso na placa indicando presença de um obstáculo ou objeto. Este sensor possui um potenciômetro ajustável para controle da sensibilidade da distância de detecção que pode ficar entre 2cm e 30cm. Vale ressaltar que o tamanho e cor do obstáculo ou objeto influenciam na distância de detecção.
A montagem é bem direta, basta interligar o sensor com o Arduino. Não há necessidade de conversão de níveis lógicos ou ligação de componentes externos. Monte o circuito e faça o upload do código do exemplo 6 no Anexo para a sua placa. As variáveis declaradas são para determinar os pinos de trigger (pino 2) e de leitura do sensor (pino 3). Temos três variáveis do tipo float utilizadas para medir o tempo do pulso no output do sensor e calcular a distância. Na função void setup(), inicializamos o pino 2 como saída e o 3 com entrada. Além disso, configuramos a comunicação serial para 9600 de baud rate. Na função void loop(), onde o programa será executado continuamente, executa-se três passos básicos:
OBS: você pode fazer o ajuste de sensibilidade de detecção do sensor, a partir do trimpot que se encontra na placa. – Especificações e características: – Controlador: LM393 – Tensão de operação: 3,3 a 5VDC – Distância de detecção: 2cm até 30cm – Faixa de detecção: 35º
1. Enviar pulso de 10us para o pino de trigger do sensor. Isto é feito com a função DisparaPulsoUltrassonico(); 2. Ler o pino de output do sensor e medir o tempo de duração do pulso utilizando a função PulseIn. Esta função retorna o tempo de duração do pulso em microsegundos para que o mesmo seja armazenado em uma variável; 3. Por fim, chamamos a função CalculaDistancia (tempo) passando como parâmetro o tempo lido com a função PulseIn. Esta função calcula a distância entre o sensor e o obstáculo. Nós chamamos esta função de dentro da função Serial.println(), de forma que o resultado já é impresso diretamente no terminal serial;
– Saída Digital e Analógica – LED indicador de sensor ativado – LED indicador de tensão no sensor – Sensibilidade ajustável através de trimpot – Aplicações: Projetos com Arduino ou outras plataformas microcontroladas em que seja necessário fazer a detecção de obstáculos. Referência: https://blogmasterwalkershop.com.br/arduino/co mo-usar-com-arduino-sensor-infravermelhoreflexivo-de-obstaculo/
A função DisparaPulsoUltrassonico() apenas ativa o pino 2 em nível alto, espera 10 microsegundos e volta a setar o pino para nível baixo. Lembre que 10 us é o tempo mínimo que o pulso deve perdurar para disparar o sensor HCSR04. A função CalculaDistancia() recebe como parâmetro o tempo do pulso no pino Echo do sensor. Com esse tempo nós usamos a equação, para calcular a distância entre o sensor e o obstáculo.
Utilize o sensor infravermelho do robô Dude e o código do exemplo 7 no anexo.
16
Valor = (V/5)*1024
Exemplo 8 – Potenciômetro O potenciômetro nada mais do que um resistor cujo valor de resistência pode ser ajustado de forma manual. Existem potenciômetros slides e giratórios. Na figura abaixo mostramos um potenciômetro giratório dos mais comumente encontrados no mercado.
Em que 5V é o valor de referência configurado no conversor analógico-digital (uma configuração já padrão, não se preocupe com ela) e 1024 é igual 2 elevado a 10. No nosso código, queremos saber o valor de tensão na saída do potenciômetro, e não esse número de 0 a 1023, assim, rearranjar a equação para o seguinte: Tensão = Valor*(5/1024) Agora, vamos à montagem em si. Para esse exemplo você vai precisar: • Arduino UNO; • Protoboard; • Potenciômetro 10K; • Jumpers de ligação;
Em ambos, ao variar a posição da chave manual, seja ela giratória ou slide, o valor da resistência entre o terminal de saída e um dos outros terminais se altera. O símbolo do potenciômetro é o mostrado na seguinte imagem:
Diagrama de circuito Monte o circuito conforme diagrama abaixo e carregue o código do exemplo 8 no anexo:
Nesse exemplo, vamos ligar a saída de um potenciômetro a uma entrada analógica da Arduino UNO. Dessa forma, vamos ler o valor de tensão na saída do potenciômetro e vê-la variando de 0 a 1023. Mas como assim, 0 a 1023? Isso se deve ao seguinte. Vamos aplicar uma tensão de 5V nos terminais do potenciômetro. A entrada analógica do Arduino, ao receber um sinal de tensão externo, faz a conversão do mesmo para um valor digital, que é representado por um número inteiro de 0 a 1023. Esses números são assim devido à quantidade de bits que o conversor analógico digital do Arduino trabalha, que são 10 bits (2 elevado a 10 = 1024). Ou seja, o arduino divide o valor de tensão de referência em 1024 unidades (0 a 1023) de 0,00488 volts. Assim, se a tensão lida na entrada analógica for de 2,5V, o valor capturado pelo arduino será metade de 2,5/0,00488 = 512. Se for 0V, será 0, e ser for 5V, será 1023, e assim proporcionalmente para todos os valores. Assim, digamos que o valor de tensão se dado por V. O valor que o Arduino vai te mostrar é:
O Potenciômetro possui 3 terminais, sendo que o do meio é o que possui resistência variável. A ligação consiste em ligar os dois terminais fixos a uma tensão de 5V. Assim, o terminal intermediário do potenciômetro terá um valor que varia de 0 a 5V à medida que você dá gira seu knob. O terminal intermediário é ligado diretamente a uma entrada analógica do Arduino (A0). Como a tensão é de no máximo 5V, então não há problema em ligar direto. Carregue o código abaixo no Arduino e você verá as leituras no Monitor serial da IDE arduino. No código, nós declaramos a variável sensorValue para armazenar as leituras da entrada analógica A0 e a variável do tipo float Voltage para armazenar o valor lido convertido para tensão. Na função void Setup(), nós inicializamos o terminal serial com uma taxa de transmissão de 9600 kbps. Na função void Loop(), primeiro fazse a leitura da entrada analógica A0 com a função 17
analogRead(SensorPin) e armazenamos a mesma na variável sensorValue. Em seguida, aplicamos a fórmula para converter a leitura (que é um número entre 0 e 1023) para o valor de tensão correspondente. O resultado é armazenado na variável Voltage e em seguido mostrado na interface serial da IDE Arduino.
Após concluir a instalação, a biblioteca aparecerá na lista de Sketch > Incluir Biblioteca. Ao selecioná-la, você verá uma nova linha de código no início do seu programa. No caso da biblioteca Tone, teremos: #include <Tone.h>
6.2 Importando uma biblioteca .zip
Referência: 1.https://www.arduino.cc/en/Tutorial/ReadAnalog Voltage
Se você quiser incluir alguma biblioteca que encontrou na Internet e que não está disponível na lista acima, você pode instalá-la a partir de um arquivo .zip. Para isso, faça o download do arquivo .zip correspondente à biblioteca para o seu computador. Em seguida, na IDE vá até Sketch > Incluir Biblioteca > Incluir Biblioteca .ZIP. Selecione o arquivo .zip salvo no seu computador e clique em Abrir. Por fim, em Sketch > Incluir Biblioteca, selecione a biblioteca que você acabou de adicionar, que aparecerá ao final da lista.
6 - BIBLIOTECAS Muitas vezes precisamos de códigos bastante complexos para criar determinados programas de Arduino, especialmente quando utilizamos determinados sensores e atuadores que requerem códigos específicos para funcionar. Bibliotecas são conjuntos de códigos que tornam mais fácil a utilização de sensores e módulos específicos ou que facilitam a criação de determinadas funcionalidades no comportamento da placa. Assim, ao invés de ter que escrever estes códigos longos e específicos, podemos chamá-los de uma biblioteca externa que já os contém. Diversas bibliotecas já vêm instaladas na IDE, como a biblioteca Servo (para utilizar um servo motor) ou a LiquidCrystal (para utilizar displays de LCD). Mas você pode também utilizar bibliotecas criadas por outras pessoas, disponíveis na Internet (existem centenas!), ou criar a sua própria biblioteca. Abaixo, apresentamos algumas formas de instalar uma biblioteca:
6.3 Instalação manual Você também pode fazer a instalação manual de bibliotecas, adicionando os arquivos da pasta .zip aos diretórios correspondentes da Arduino. Existem muitas informações disponíveis na Internet sobre como fazer isso.
7 - Considerações finais Essa apostila tem por objetivo apresentar alguns exemplos básicos sobre como utilizar os componentes do Kit Arduino, a partir dos quais você pode combinar e fazer projetos mais elaborados por sua própria conta. Nas seções de referências de cada exemplo e nas referências finais, também tentamos indicar boas fontes de conteúdo objetivo e com projetos interessantes. Sobre isso ponto, que consideramos fundamental, gostaríamos de destacar algumas fontes de conhecimento que se destacam por sua qualidade. O fórum oficial Arduino possui muitas discussões e exemplos muito bons. A comunidade de desenvolvedores é bastante ativa e certamente pode te ajudar em seus projetos. No
6.1 Usando o gerenciador de bibliotecas Uma das formas de incluir uma biblioteca é selecioná-la em Sketch > Incluir Biblioteca. Se a biblioteca desejada não estiver disponível na lista que aparece, você pode instalá-las em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas (recurso disponível da versão 1.6.2 em diante). No Gerenciador de Bibliotecas você encontrará uma lista de bibliotecas que estão prontas para instalação ou já instaladas. Busque a biblioteca desejada (por exemplo, a biblioteca Tone) e, em seguida, clique em Instalar.
18
Project Hub poderá encontrar milhares de projetos com Arduino.
PROJETO FINAL Nesta semana teremos a tarefa final do
● Fórum oficial Arduino: https://forum.arduino.cc/ ● Project Hub Arduino: https://create.arduino.cc/projecthub
curso.
Ela será
dividida em três etapas,
detalhadas abaixo, e você deve completar todas elas para que possa ser avaliado:
O Instructables é a ótima referência do mundo maker atual. Pessoas que buscam construir suas próprias coisas e projetos encontram referências e compartilham suas experiências no site. ● Instructables: https://www.instructables.com/
Etapa 1: Você vai montar um projeto que envolve:
O Maker pro é outro site referência no mundo em relação aos projetos com Arduino. Há uma infinidade de projetos, todos bem explicados e com bom conteúdo. ● Maker pro: https://maker.pro/projects/arduino
•
Criar um circuito
•
Representar o seu circuito (utilizando o programa Tinkercad ou similar)
• Em relação à eletrônica, teoria de circuitos e componentes eletrônicos em geral, deixamos alguns livros essenciais na seção finais de referências. O leitor que quer se aprofundar no mundo da eletrônica certamente precisará de um livro basilar e de bons conhecimentos em circuitos eletro-eletrônicos. No mais, esperamos que essa apostila seja apenas o início de vários outros projetos e, quem sabe, a adoção de Kits mais avançados.
Documentar o seu projeto, explicando o seu funcionamento e anexando uma foto ou vídeo.
•
Incluir o código utilizado na Arduino.
Após montar o seu projeto, documente estas informações em um arquivo PDF e envie-o para o email: evangelistahelio7@gmail.com.
Etapa 2: Depois de enviar seu PDF, você
Referências
receberá projetos de 3 colegas do curso para
1. Fundamentos de Circuitos Elétricos. Charles K. Alexander; Matthew N. O. Sadiku. Editora McGraw-Hill. 2. Circuitos elétricos. James W. Nilsson, Susan A. Riedel. Editora: Pearson; Edição: 8. 3. Microeletrônica - 5ª Ed. - Volume Único (Cód: 1970232). Sedra,Adel S. Editora Pearson. 4. Fundamentals of Microelectronics. Behzad Razavi. Editora John Wiley & Sons; Edição: 2nd Edition (24 de dezembro de 2012). 5. Site: http://blog.eletrogate.com/ 6. Site: https://blogmasterwalkershop.com.br/ 7. Site: https://www.filipeflop.com/
avaliá-los (avaliação pelos pares).
Etapa 3: Por fim, você vai avaliar o seu próprio projeto (auto avaliação).
19
ANEXOS // Exemplo 1: Programa Led Pisca // Autor :
void setup() {
//Define a porta do led como saĂda pinMode(11, OUTPUT);
}
void loop() {
//Acende o led digitalWrite(11, HIGH);
//Aguarda intervalo de tempo em milissegundos
delay(1000);
//Apaga o led
digitalWrite(11, LOW);
//Aguarda intervalo de tempo em milissegundos
delay(1000); }
// Exemplo 2 – Emissão de tom com Buzzer /* Código p/ emissão de tom conforme frequência informada */ int pinoFalante = 11; void setup() { pinMode(pinoFalante, OUTPUT); Serial.begin(9600); Serial.println("Insira a frequência que quer ouvir: "); } void loop() { if (Serial.available()) { int duracao = 2000; int frequencia = Serial.parseInt(); tone (pino Falante, frequência, duração); delay (duração); noTone (pino Falante); } }
// Exemplo 3 - Entradas e saídas digitais - push-button + led #define PinButton 8 #define ledPin 7
// define pino digital D8 // define pino digital D7
void setup() { pinMode(PinButton, INPUT); // configura D8 como entrada digital pinMode(ledPin, OUTPUT); // configura D7 como saída digital Serial.begin(9600); // monitor serial - velocidade 9600 Bps delay(100); // atraso de 100 milisegundos } void loop() { if ( digitalRead(PinButton) == HIGH) // se chave = nível alto { digitalWrite(ledPin, HIGH); // liga LED com 5V Serial.print("Acendendo Led"); // imprime no monitor serial } else // senão chave = nível baixo { digitalWrite(ledPin, LOW); // desliga LED com 0V Serial.print("Desligando led"); // imprime no monitor serial } delay(100); // atraso de 100 milisegundos } 2
// Exemplo 4 - Sensor de luz LDR #define AnalogLDR A0 #define Limiar 1.5 #define ledPin 13 int Leitura = 0; float VoltageLDR; float ResLDR; void setup()
// define pino analógico A0 // define constante igual a 1.5 // define pino digital D13 // variável inteiro igual a zero // variável número fracionário // variável número fracionário
{ pinMode(ledPin, OUTPUT); Serial.begin(9600); Bps delay(100);
// configura D13 como saída digital // monitor serial - velocidade 9600 // atraso de 100 milisegundos
} void loop() { Leitura = analogRead(AnalogLDR); A0 VoltageLDR
// leitura da tensão no pino analógico
Serial.print = ( "Leitura sensor LDR = "Leitura * (5.0/1024); ); // cálculo da tensão no LDR// imprime no monitor serial Serial.println(VoltageLDR); // imprime a tensão do LDR if (VoltageLDR > Limiar) // se a tensão LDR maior do que limiar digitalWrite(ledPin, HIGH); // liga LED com 5V else // senão a tensão LDR < limiar delaydigitalWrite(500); (ledPin, LOW); // desliga LED com 0V// atraso de 500 milisegundos }
3
// Exemplo 5 - Acionando o Micro Servo TowerPro #include <Servo.h> Servo myservo; #define potpin A0 int val; void setup() { myservo.attach(6);
// usando bilbioteca Servo // cria o objeto myservo // define pino analógico A0 // variável inteiro
// configura pino D6 - controle do Servo
} void loop() { val = analogRead(potpin); // leitura da tensão no pino A0 val = map(val, 0, 1023, 0, 179); // converte a leitura em números (0-179) myservo.write(val); // controle PWM do servo delay(15); // atraso de 15 milisegundos }
4
// Exemplo 6 - Sensor de Distância Ultrassônico HC-SR04 int PinTrigger = 2; // pino usado para disparar os pulsos do sensor int PinEcho = 3; // pino usado para ler a saída do sensor float TempoEcho = 0; // variável tempo do eco const float velocidadeSom_mps = 340; // em metros por segundo const float velocidadeSom_mpus = 0.000340; // em metros por microsegundo void setup() { pinMode(PinTrigger, OUTPUT); // configura pino Trigger como saída digitalWrite(PinTrigger, LOW); // pino trigger - nível baixo pinMode(PinEcho, INPUT); // configura pino ECHO como entrada Serial.begin(9600); // inicializa monitor serial 9600 Bps delay(100); // atraso de 100 milisegundos } void loop() { DisparaPulsoUltrassonico (); // dispara pulso ultrassonico TempoEcho = pulseIn(PinEcho, HIGH); // mede duração do pulso HIGH de eco em microsegundos Serial.print("Distancia em metros: "); // mostra no monitor serial Serial.println(CalculaDistancia(TempoEcho)); // mostra o cálculo de distância em metros Serial.print("Distancia em centimentros: "); // mostra no monitor serial Serial.println(CalculaDistancia(TempoEcho) * 100); // mostra o calculo de distancia em cm delay(2000); // atraso de 2 segundos } void DisparaPulsoUltrassonico() { digitalWrite(PinTrigger, HIGH); // pulso alto de Trigger delayMicroseconds(10); // atraso de 10 milisegundos digitalWrite(PinTrigger, LOW); // pulso baixo de Trigger } float CalculaDistancia(float tempo_us) { return ((tempo_us * velocidadeSom_mpus) / 2 ); // calcula distancia em metros }
5
// Exemplo 7: Sensor Ultrassônico
const int pinoLed = 12; //PINO DIGITAL UTILIZADO PELO LED const int pinoSensor = 8; //PINO DIGITAL UTILIZADO PELO SENSOR
void setup () { pinMode (pinoSensor, INPUT); //DEFINE O PINO COMO ENTRADA pinMode (pinoLed, OUTPUT); //DEFINE O PINO COMO SAÍDA digitalWrite (pinoLed, LOW); //LED INICIA DESLIGADO } void loop () { if (digitalRead(pinoSensor) == LOW) {
//SE A LEITURA DO PINO FOR IGUAL A LOW, FAZ digitalWrite (pinoLed, HIGH); //ACENDE O LED }
Else {
//SENÃO, FAZ digitalWrite (pinoLed, LOW); //APAGA O LED }
}
6
// Exemplo 8: Usando potenciometro para fazer leituras analógicas
#define sensorPin A0 // define entrada analógica A0 int sensorValue = 0; float voltage;
// variável inteiro igual a zero // variável número fracionário
void setup() { Serial.begin(9600); delay(100);
// monitor serial - velocidade 9600 Bps // atraso de 100 milisegundos }
void loop() { sensorValue = analogRead(sensorPin); // leitura da entrada analógica A0 voltage = sensorValue * (5.0 / 1024);
// cálculo da tensão
Serial.print("Tensão do potenciometro: "); // imprime no monitor serial Serial.print(voltage);
// imprime a tensão
Serial.print("
// imprime no monitor serial
Valor: ");
Serial.println(sensorValue); delay(500);
// imprime o valor // atraso de 500 milisegundos
}
7