plataforma arduino
• microcontrolador Atmel
• programação usando Wiring (subconjunto de processing, baseado em C/C++)
• open-source: evolução da plataforma através de contribuições dos usuários
Plataforma eletrônica Arduino
• O Arduino não é um microcontrolador e sim uma plataforma eletrônica que possui uma série de dispositivos eletrônicos agregados a um microcontrolador em uma placa de circuito integrado.
• A placa foi adaptada para conectar-se facilmente com outros dispositivos, pois possui a descrição bem detalhada de suas portas de entrada e saída bem como o acesso facilitado para sua comunicação com outros dispositivos e até mesmo a placas de expansão que também são confeccionadas para adaptar-se à placa principal.
Plataforma eletrônica Arduino
• Embora o Arduino seja uma plataforma que pode ser desenvolvida com base em qualquer microcontrolador, o modelo mais utilizado nas versões comerciais é o ATMEL.
Desenvolvido por: Massimo Banzi, David
Cuartielles, Tom Igoe, Gianluca Martino e
David Mellis, na Itália, em 2005.
Site oficial: www.arduino.cc
Arduino é Open Source!• Todo o hardware é aberto e os projetos estão
disponíveis;
• O software de programação também é livre e está
disponível para download gratuitamente;
• Quem quiser, pode comprar os componentes e montar a sua placa!
plataforma arduino - hardware
Duemilanovemini
lilypad
boarduino
paperduinomegapro
plataforma arduino - hardware
• Os microchips utilizados nas placas Arduino são: ATMEGA8, ATMEGA168, ATMEGA328, ATMEGA1280 e ATMEGA2560. Cada qual possui peculiaridades, como disposição dos pinos, mas a programação é a mesma e vale para qualquer um deles.
• No Arduino ainda é utilizado um cristal ressonador de 16 MHz como gerador do sinal de "clock" externo dos microcontroladores. Isto possibilita que o microcontrolador execute cerca de 16 milhões de instruções por segundo.
Alguns conceitos básicos sobre as características destes microcontroladores são:• Portas de I/O são as portas de entrada e saída de dados, analógicos
ou digitais, e que servem para comunicar externamente o microcontrolador e hardware.
• A memória flash delimita o tamanho máximo do programa que será executado pelo Arduino. O bootloader do Arduino ainda utiliza uma pequena parcela desta memória.
Alguns conceitos básicos sobre as características destes microcontroladores são:• A memória EEPROM é uma memória utilizada para armazenar dados,
os quais só serão excluídos quando o programa sobrescrevê-los.
• A memória SRAM é uma memória utilizada para armazenar dados temporários.
• Canais A/D são canais que convertem dados analógicos em digitais. No ATMEGA a conversão A/D tem precisão de 10 bits.
• UART é um periférico responsável pela comunicação serial entre o microcontrolador e o mundo externo, como por exemplo a comunicação serial entre Arduino e PC.
plataforma arduino - instalação
• driver
windows: FTDI Serial USB
linux: não precisa instalar nada :-)
• software
é só descompactar e executar
Instalação da IDE no WindowsApos baixar os arquivos necessários do Windows pelo site, extraia-os para o local
desejado e execute o programa do Arduino, localizado na raiz da pasta principal. Em
seguida:
▪ Conecte o Arduino ao computador usando o cabo USB. A luz com nome PWR
(Power) deve acender, indicando que a placa esta ligada.
▪ Deve-se ser solicitado que um novo driver seja instalado. Para isso, recuse que o
Windows procure os drivers automaticamente na internet e, na seleçãao manual,
peca para que sejam procurados os drivers na pasta do Arduino que extraistes no
primeiro passo.
▪ Caso não seja acionada a deteção automática de driver, vá ao Painel de Controle,
abra o Gerenciador de Dispositivos e procure por drivers desatualizados. Selecione
a atualização manual do driver e indique a pasta mencionada no passo anterior.
▪ Após isso, a instalação deve estar concluída.
O IDE do Arduino e bastante simples.
Foi projetado para ser uma interface
amigavel a
pessoas que nunca tiveram contato
com desenvolvimento de software, e
portanto e bastante intuitiva. Foi
desenvolvido em Java e possui
recursos simples de realce de
palavras-chave e uma base com
diversos códigos prontos para servir
como exemplo.
plataforma arduino - instalação
• Selecionando a placa e a porta serial
menu Boards
plataforma arduino – ambiente
área de código
área de status
parar execução
novo
abrir
salvar
exibir serial
plataforma arduino – estrutura do sketch
Sketches
• Softwares escritos usando Arduino são chamados de Sketches. Estes Sketches são escritos no editor de texto da IDE do Arduino e são salvos com a extensão de arquivo .ino.
• Este editor tem características de cortar/colar e para buscar/substituir texto.
• A área de mensagem dá feedback ao salvar e exportar arquivos e também exibe informações de erros ao compilar Sketches.
• O canto direito inferior da janela exibe a placa atual e a porta serial. Os botões da barra de ferramentas permitem que você verifique, carregue, crie, abra e salve Sketches ou abra o monitor serial.
Sketches
Nota:
• Nas versões do IDE antes de 1.0 os Sketches são salvos com a extensão .pde.
• É possível abrir esses arquivos com a versão 1.0, mas você será solicitado a salvar o Sketch com a extensão .ino.
plataforma arduino – linguagem
• linguagem baseada em C (mas bem mais fácil)
• comandos básicos
• pinMode() – define um pino com entrada ou saída
• digitalWrite() – liga ou desliga uma saída digital
• delay() – “espera” um determinado tempo
Portas digitais e analógicas Na prática ligamos componentes em portas digitais e analógicas e
através do código Arduino, manipulamos as portas:
–pinMode(<porta>, <modo>): configura uma porta digital para ser lida ou para
enviarmos dados;
–digitalWrite(<porta>, 0 ou 1): envia 0 ou 1 para porta digital
–digitalRead(<porta>): retorna um 0 ou 1 lido da porta
–analogRead(<porta>): retorna de 0 a 1023 com o valor da porta analógica
–analogWrite(<porta>, <valor>): escreve em uma porta PWM um valor de 0 a 255
plataforma arduino – linguagem
• Exemplos
• pinMode(num_do_pino, OUTPUT);
• digitalWrite(num_do_pino, valor);
valor é LOW ou HIGH (0 ou 1, 0V ou 5V)
• delay(milisegundos);
plataforma arduino – linguagem
• constantes
LOW | HIGH – indica nível baixo (0V) e alto (5V) nos pinos
INPUT | OUTPUT – define se um pino vai ser pino de entrada ou de saída
Questões – Arduino 11. O que é o Arduino?
2. Descreve o hardware utilizado em uma placa arduino.
3. Fale sobre a placa arduino mega.
4. Quais são os pinos de energia da placa arduno?
5. Fale sobre a programação do arduno.
6. Quais são os tipos de arduino disponível?
7. Defina open-source.
8. Explique os comandos:• Digital:• pinMode()• digitalRead()• digitalWrite()• Analógico:• delay()• anologWrite()
9. O que são os Shields para arduino?
Na Linguagem C, letras maiúsculas, minúsculas e conjuntos
de palavras fazem a diferença. Ou seja, se você for escrever
algo como, por exemplo, “ledPin”, não será a mesma coisa
que “LedPin”.
O programa precisa identificar qual é o fim de uma linha de
programação para poder seguir rodando o programa, para
isso, é necessário ao final de cada linha onde possa ser
identificado um comando, o uso de ; (ponto e vírgula).
prática
• fazer o programa hello arduino, que pisca um
led
• use o pino 13 de saída digital, a placa já possui
um led ligado a ele :-)
FerramentasPlacaArduino Duemilanove
SELECIONAR PORTA
ERRO
COM1 COM2
int led = 13;
void setup() { pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH); delay(1000); digitalWrite(led, LOW); delay(1000);
}
CLICARCARREGAR
Matriz de contatos (Protoboard)
LED (Light Emitting Diode)
• LED’s são dispositivos eletrônicos que emitem luz pela passagem de uma pequena corrente elétrica. Por isso, é necessário conectar um resistor ao LED para evitar sobrecorrente. Um LED só permite passagem de luz em um sentido. Portanto, é necessário identificar os pólos para conectar o LED corretamente dentro do circuito eletrônico.
01 - LED Piscante
Neste projeto, você aprenderá a criar um circuito simples usando um LED e um resistor e o fará
piscar.
O que você vai precisar:
01 placa Arduino
02 cabos jumpers
01 resistor 220 Ω
01 LED
01 - LED Piscante
Montagem
01 LED Piscante
Programação
int led = 10; // define a porta em que o LED está conectado
void setup()
{
pinMode (led, OUTPUT); // define o LED como atuador
}
void loop()
{
digitalWrite (led, HIGH); // liga o LED
delay (1000); // espera por 1000 milisegundos
digitalWrite (led, LOW); // desliga o LED
delay (1000); // espera por 1000 milisegundos}
Alterando o código
1 – Altere o intervalo de ligar e desligar o LED para um valor
definido por você.
2 – Altere o valor do delay para 50 milisegundos. O LED estará desligando e acendendo?
EXERCÍCIO:
Faça um circuito onde três LEDs acendam em sequência, com um
atraso de um segundo entre eles, e depois apaguem igualmente em
sequência.
int led1 = 10;
int led2 = 11;
int led3 = 12;
void setup()
{
pinMode (led1, OUTPUT); // define o LED como atuador
pinMode (led2, OUTPUT);
pinMode (led3, OUTPUT);
}
void loop()
{
digitalWrite (led1, HIGH);
delay (1000);
digitalWrite (led2, HIGH);
delay (1000);
digitalWrite (led3, HIGH);
delay (1000);
digitalWrite (led1, LOW);
delay (1000);
digitalWrite (led2, LOW);
delay (1000);
digitalWrite (led3, LOW);
delay (1000);
}
Usando um LED vermelho, um amarelo e um verde, crie um semáforo de trânsito ou seja, o LED verde deve ficarligado por um determinado intervalo de tempo, seguido pelo amarelo, depois o vermelho, voltando para o verde.
int ledDelay = 10000;
int vermelho = 10;
int amarelo = 9;
int verde = 8;
void setup()
{
pinMode (vermelho, OUTPUT);
pinMode (amarelo, OUTPUT);
pinMode (verde, OUTPUT);
}
void loop()
{
digitalWrite (vermelho, HIGH);
delay (ledDelay);
digitalWrite (verde, HIGH);
digitalWrite (vermelho, LOW);
digitalWrite (amarelo, LOW);
delay (ledDelay);
digitalWrite (amarelo, HIGH);
digitalWrite (verde, HIGH;
delay (2000);
digitalWrite(verde,LOW);
digitalWrite(amarelo, HIGH);
delay(500);
digitalWrite (amarelo, LOW);
delay(200);
}
Comunicação Serial
• Se quisermos, por exemplo, controlar algum componente do Arduino através do computador? E para isso que servem as portas de comunicação serial. Utilizando a comunicação USB (Universal Serial Bus) que usamos normalmente para fazer o upload de dados do Arduino, podemos enviar sinais e comandos para alterar o seu estado.
•Antes de mais nada, precisamos iniciar a comunicação informando a velocidade da transferência de dados. Depois, poderemos enviar e receber dados do Arduino e visualizá-los através do monitor serial:
Comunicação Serial• Serial.begin(velocidade)Esta função diz ao Arduino que iremos iniciar a interface serial, utilizando o parâmetrovelocidade como taxa de transferência. Por padrão, normalmente utiliza-se 9600 como taxa.• Serial.print(”Mensagem”)Exibe uma mensagem no monitor serial. Podemos informar qual a leitura que um sensor está recebendo do ambiente, por exemplo, ou apenas informar alguma mensagem qualquer.• Serial.available()Retorna o número de bytes sendo lidos pela porta serial. No caso de não haver nenhuma valor, retorna zero. Utilizamos esta função para o Arduinosaber quando enviamos ou recebemos algum dado - um botão que pressionamos, por exemplo.• Serial.read()Esta função lê os dados que digitamos pelo teclado e os envia ao Arduino. E nosso principal meio de comunicação!
void setup()
{
Serial.begin(9600);
}
int i = 0;
void loop()
{
Serial.print("Olaaaa - ");
Serial.println(i);
i++;
delay(1000);
}
Comunicação Serial
Prática
• Desenvolver um programa para apagar e acender um LED usando um comando no teclado.
• Para isso, verificamos se há alguma informação a ser lida, ou seja, se algum comando foi enviado do computador ao Arduino. Se sim, guardamos esta informação e a processamos de acordo com o que queremos. Em nosso caso, vamos acender o led no pino 13 caso enviarmos o caractere ‘L’ ao Arduino.
const int led=13;
void setup()
{
pinMode(led,OUTPUT);
Serial.begin(9600);
}
void loop() {
if(Serial.available())
{
int liga = Serial.read();
if(liga == 'L')
{
digitalWrite(led, HIGH);
delay(2000);
}
else
{
digitalWrite(led, LOW);
delay(2000);
}
}
}
Prática
• Acender e apagar três leds ligados nas portas: 10 (led vermelho), 9 (led amarelo) e 8(led verde). Utilizar o monitor serial.
int vermelho = 10;
int amarelo = 9;
int verde = 8;
char led;
void setup()
{
pinMode(vermelho,OUTPUT);
pinMode(verde,OUTPUT);
pinMode(amarelo,OUTPUT);
Serial.begin(9600);
}
void loop()
{
if(Serial.available())
{
led = Serial.read();
if(led =='V')
{
digitalWrite(vermelho,HIGH);
}
else
{
if(led==‘D')
{
digitalWrite(verde,HIGH);
}
else if(led==‘M')
{
digitalWrite(amarelo,HIGH);
}
}
if(led =='v')
{
digitalWrite(vermelho,LOW);
}
else
{
if(led=='d')
{
digitalWrite(verde,LOW);
}
else if(led=='m')
{
digitalWrite(amarelo,LOW);
}
}
}
}
const int BOT = 12;
void setup()
{
pinMode (BOT , INPUT );
Serial.begin(9600);
}
void loop()
{
int Leitura = digitalRead(BOT);
Serial.print("Estado do Botão = ");
Serial.println(Leitura,DEC);
delay(150); }
EXERCÍCIO:
Faca um circuito onde utilize um botão, esse botão deverá ser
monitorado pela comunicação serial.
Neste projeto, o brilho de um LED irá variar de acordo com uma onda senoidal, a partir do controle de uma porta de saída de pulso modulado (PWM).
O que você vai precisar01 Arduino01 placa protoboard01 LED01 resistor de 220 Ω02 cabos jumpers
02 - Um LED pulsante
int ledPin = 10;
float sinVal;
int ledVal;
void setup()
{
pinMode (ledPin, OUTPUT);
}
void loop()
{
for (int x=0; x<180; x++)
{
sinVal = (sin(x*(3.1415/180))); // convertegrausa radianos e obtém o
valor do seno
ledVal = int(sinVal*255);
analogWrite (ledPin, ledVal); // define a saída PWM
delay(25);
}
}
1. Usando um LED vermelho, um amarelo e um verde, crie um semáforo de trânsito ou seja, o LED verde deve ficar ligado por um determinado intervalo de tempo, seguidopelo amarelo, depois o vermelho, voltando para o verde.
3. Crie um LED inteligente: ou seja, utilizando um sensor de luminosidade, faca-o ligarse o ambiente estiver escuro demais.
4. Projete o protótipo de uma fechadura com senha - ou seja, a porta so abre se a senhadigitada for correta. Para facilitar, utilize um LED vermelho para representar a portafechada e um LED verde para representar que a senha digitada foi aceita.
5. Melhore seu protótipo adicionando um atuador sonoro, que avisa caso a senha estejaerrada, caso ela esteja certa e denuncie caso alguém erre a senha mais de três vezes.Utilize sons diferentes para cada caso.
6. Utilizando um potenciômetro, crie um ajustador de volume para um buzzer. Emoutras palavras, aumenta ou diminua a intensidade do som do buzzer através dopotenciômetro.
O que você vai precisar saber:
• Sinais de comparação
== (semelhante a)!= (diferente de)< (menor que)> (maior que)<= (menor ou igual a)>= (maior ou igual a)
03 Projeto com led e button
• Liga e desliga um LED conectado ao pino digital 13 quando pressionado um botão conectado ao pino 2.
• O Circuito:➢LED conectado ao pino 13 e ao terra
➢botão conectado ao pino 2 desde 5V
➢resistor de 10K conectado ao pino 2 desde o terra
//BUTTON_LED
// constantes não são alteradas
// São usadas aqui para definir os números dos pinos:
const int buttonPin = 2;
const int ledPin = 13;
int buttonState = 0;
void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop()
{
// faz a leitura do valor do botão
buttonState = digitalRead(buttonPin);
if (buttonState == LOW) { // liga o LED
digitalWrite(ledPin, HIGH);
}
else { // desliga o LED
digitalWrite(ledPin, LOW);
}
}
Acender e Apagar um LED utilizando apenas um botão
• Componentes:
• Um led ligado no pino 13 e um botão ligado no pino 7
const int led = 13;
const int button = 7;
int val = 0;
int old_val =0 ;
int state = 0;
//botão NF
void setup()
{
pinMode(led,OUTPUT);
pinMode(button, INPUT);
}
void loop()
{
val = digitalRead(button);
if((val == LOW) && (old_val == HIGH))
{
state = 1 - state;
}
old_val = val;
if(state == 1)
{
digitalWrite(led,HIGH);
}
else
{
digitalWrite(led,LOW);
}
}
04 Leitura de um sinal analógico no computador
• Neste projeto, você deve construir um circuito que possibilite a leitura de um valor analógico (0 a 1023) fornecido por um potenciômetro, enviando-o através de uma comunicação serial no computador. A comunicação serial no computador é vista em uma tela à parte, que pode ser acessada pelo atalho Ctrl+Shift+M (Serial monitor).
O que você vai precisar:
01 placa Arduino
03 cabos jumpers
01 potenciômetro
void setup(){Serial.begin (9600);}void loop(){int sensorValue = analogRead (A0);Serial.println (sensorValue, DEC);delay (1000);}
• A linha intsensorValue = analogRead(A0); porta analógica 0 na variável sensorValue.
• Ao girar o potenciômetro, o novo valor do sinal analógico
Alterando a montagem
• Substitua o potenciômetro por um LDR (Light Dependent Resistor) e efetue medidas da luminosidade ambiente.
• A montagem deve ficar com o seguinte aspecto: LDR (Light Dependent Resistence)
Dispositivo eletrônico que apresenta como uma
resistência variável, cujo valor depende da luz
incidente. É necessário conectá-lo a um resistor para que
possa atuar como sensor analógico.
LDR• O LDR é um resistor sensível à luz que varia sua resistência conforme
é alterada a intensidade luminosa que incide sobre ele. À medida que a intensidade luminosa aumenta (o ambiente fica mais claro) a sua resistência diminui para algumas dezenas de Ohms, e quando a intensidade luminosa diminui (o ambiente fica mais escuro) a sua resistência aumenta para alguns mega Ohms.
• Através dessa característica pode-se utilizar esse sensor para detectar a luminosidade do ambiente, para tomar uma decisão como, por exemplo, ligar uma lâmpada, como ocorre nas fotocélulas.
• Ele é um sensor de baixo custo e está presente em muitos circuitos eletrônicos que necessitam monitorar a luz ambiente. O seu uso é bem simples, onde através de um circuito divisor resistivo a variação de resistência é convertida em tensão e usada pelo circuito de controle.
LDR• Para fazer a leitura da variação de luminosidade, ou seja, a variação
de resistência do LDR, é necessário montar um divisor de tensão, conforme o esquema abaixo:
LDR• Através do circuito apresentado pode-se calcular o valor da tensão de
saída para uma determinada resistência do LDR, através da seguinte fórmula:
• Por exemplo, em uma ambiente quase escuro o LDR apresenta resistência de aproximadamente 500 KOhm, e o valor de tensão de saída será:
LDR
• E em uma ambiente claro a resistência do LDR cai para aproximadamente 300 Ohm. Assim, a tensão de saída será:
• Nota-se através dos cálculos que a tensão de saída do conversor aumenta quando a intensidade luminosa aumenta e diminui quando ambiente vai ficando escuro.
int sensorPin = 0;
int val;
void setup() {
Serial.begin(9600);
}
void loop() {
val = analogRead(sensorPin);
Serial.println(val);
delay(1000);
}
O sketch a seguir fará com que a lâmpada acenda quando estiver escuro, e apague quando estiver claro:
int rele = 8;
int sensorpin = A0;
int val;
void setup()
{
Serial.begin(9600);
pinMode(rele,OUTPUT);
}
void loop() {
val = analogRead(sensorpin);
Serial.println(val);
if(val<400)
{
digitalWrite(rele,HIGH);
}
else
{
digitalWrite(rele,LOW);
}
delay(500);
}
Alterando a frequência com que o LED pisca
• Componentes: 1 Potênciometro, 1 LED
• Este projeto é muito simples e tratará da utilização do potenciômetro, que é um componente que possui resistência elétrica ajustável.
• A frequência com que o LED pisca vai dependerdiretamente do ajuste do potenciômetro.
int potPin = A0;int ledPin = 11;int val = 0;
void setup()
{pinMode(ledPin, OUTPUT);
}void loop()
{val = analogRead(potPin);digitalWrite(ledPin, HIGH);delay(val);digitalWrite(ledPin, LOW);delay(val);
}
Operadores booleanos
Estes operadores podem ser usados dentro da condição em uma sentença if.
• && (“e” lógico)
Verdadeiro apenas se os dois operandos forem verdadeiros, ou seja, a primeira condição e a segunda forem verdadeiras. Exemplo:
if (digitalRead(2) == 1 && digitalRead(3) == 1) { // ler dois interruptores
}
• é verdadeiro apenas se os dois interruptores estiverem fechados.
|| (“ou” lógico)
• Verdadeiro se algum dos operandos for verdadeiro, ou seja, se a primeira ou a segunda condição for verdadeira. Exemplo:
if (x > 0 || y > 0) {// ...}
• é verdadeiro apenas se x ou y forem maiores que 0.
! (negação)
• Verdadeiro apenas se o operando for falso. Exemplo:if (!x) {// ...}
• é verdadeiro apenas se x for falso (ou seja, se x for igual a 0).
Exercício:
• Para evitar acidentes no ambiente de trabalho, uma regra de segurança em vários equipamentos industriais é obrigar que um usuário aperte dois botões, um com cada mão, para acionar uma máquina. É o caso da máquina de corte usada em fábricas de papel.
• O LED somente acende se os dois botões do circuito estiverem pressionados.
• Faça mais uma programação para que você possa acender o LED do pino 13 pressionando ou o botão 1 ou o botão 2 (reed switch). Ao deixar de pressionar, o LED se apaga.
const int but2 = 2;
const int but3 = 3;
const int ledPin = 13;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(but2, INPUT);
pinMode(but3, INPUT);
}
void loop(){
if (digitalRead(but2) == 1 && digitalRead(but3) == 1)
{
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}
Reed Switch• É um interruptor elétrico ativado por um campo magnético, por
exemplo com um ímã. Quando os contatos estão abertos se fechamna presença de um campo magnético. Quando estão fechados seabrem.
• É comumente usado em sensores de portas e janelas de alarmes anti-roubo. O ímã vai preso à porta e o reed switch ao batente.
LED RGB
• O led RGB é um tipo de led, com quatro perninhas, capaz de emitir diversos tipos de cores diferentes. Suas cores básicas são vermelho, verde e azul.
• Desta forma é possível formar milhares de cores ajustando de maneira individual cada cor.
• Os três LED´s estão unidos por um negativo ou cátodo.
LED RGB
Os fios deverão ser conectados da seguinte forma no arduino:
• fio azul no pino digital 8 do arduino;
• fio verde no pino digital 9 do arduino;
• fio vermelho no pino digital 10 do arduino;
• e 5V.
const int ledAzul = 8; //pino digital 8.
const int ledVerde = 9; //pino digital 9.
const int ledVermelho = 10; // pino digital 10.
void setup() {
pinMode(ledAzul,OUTPUT);
pinMode(ledVerde,OUTPUT);
pinMode(ledVermelho,OUTPUT);
}
void loop() {
digitalWrite(ledAzul,HIGH);
delay(500);
digitalWrite(ledAzul,LOW);
digitalWrite(ledVerde,HIGH);
delay(500);
digitalWrite(ledVerde,LOW);
digitalWrite(ledVermelho,HIGH);
delay(500);
digitalWrite(ledVermelho,LOW);
//Misturando as cores do led para obter cores diferentes.
digitalWrite(ledAzul,HIGH);
digitalWrite(ledVerde,HIGH);
digitalWrite(ledVermelho,HIGH);
delay(1500);
digitalWrite(ledAzul,HIGH);
digitalWrite(ledVerde,HIGH);
digitalWrite(ledVermelho,LOW);
delay(1500);
digitalWrite(ledAzul,LOW);
digitalWrite(ledVerde,HIGH);
digitalWrite(ledVermelho,HIGH);
delay(1500);
digitalWrite(ledAzul,HIGH);
digitalWrite(ledVerde,LOW);
digitalWrite(ledVermelho,HIGH);
delay(1500);
}
int redPin = 10; int greenPin = 9; int bluePin = 8; int potPin = A0; int tempo = 0;
void setup() {Serial.begin(9600); pinMode(redPin, OUTPUT);pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT);
}
void loop ()
{
tempo = analogRead(potPin);
analogWrite(redPin, random(10, 255));
analogWrite(greenPin, random(10, 255));
analogWrite(bluePin, random(10, 255));
tempo = map(tempo, 0, 1023, 50, 3000 );
delay(random(50, 500));
Serial.print(tempo);
Serial.println(" milisegundos");
delay(tempo);
}
const int vermelho = 10;
const int verde = 9;
const int azul = 8;
int cor = 0;
void setup() {
Serial.begin(9600);
pinMode(vermelho, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
}
void loop() {
analogWrite(vermelho, cor);
analogWrite(verde, cor);
analogWrite(azul, cor);
delay (400);
cor = cor + 10; // incrementar a intensidade da cor
if (cor > 255) {
cor = 0;
delay(10);
}
}
const int azul = 8;
const int verde = 9;
const int vermelho = 10;
String cor;
void setup()
{
Serial.begin(9600);
pinMode(azul, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(vermelho, OUTPUT);
}
//Funções responsáveis por executar o brilho selecionado
void vermelhoFuncao(){
digitalWrite(azul, LOW);
digitalWrite(verde, LOW);
digitalWrite(vermelho, HIGH);
}
void brancoFuncao(){
digitalWrite(azul, HIGH);
digitalWrite(verde, HIGH);
digitalWrite(vermelho, HIGH);
}
void loop()
{
if(Serial.available()){
cor = Serial.readString();
Serial.println(cor);
}
if(cor == "Vermelho"){
vermelhoFuncao();
}
if(cor == "Azul"){
azulFuncao();
}
if(cor == "Verde"){
verdeFuncao();
}
if(cor == "Amarelo"){
amareloFuncao();
}
if(cor == "Roxo"){
roxoFuncao();
}
if(cor == "Branco"){
brancoFuncao();
}
}
void azulFuncao(){
digitalWrite(azul, HIGH);
digitalWrite(verde, LOW);
digitalWrite(vermelho, LOW);
}
void verdeFuncao(){
digitalWrite(azul, LOW);
digitalWrite(verde, HIGH);
digitalWrite(vermelho, LOW);
}
void amareloFuncao(){
analogWrite(azul, 0);
analogWrite(verde, 50);
analogWrite(vermelho, 255);
}
void roxoFuncao(){
analogWrite(azul, 207);
analogWrite(verde, 0);
analogWrite(vermelho, 255);
}
LM35
Arduino+LM35
• O sensor LM35 é um sensor de precisão, fabricado pela NationalSemiconductor, que apresenta uma saída de tensão linear proporcional à temperatura a que se encontra, no nosso caso esta tensão varia entre 0V e 5V, pois o sensor é alimentado com 5V.
• O LM35 não necessita de qualquer calibração externa ou “trimming” para fornecer os dados com exactidão, porém para ser lido pelo Arduino necessita de conversão, pois o Arduino lê apenas valores inteiros entre 0 e 1023. Assim sabendo que este sensor tem uma resolução de 10mV por cada 1ºC poderemos deduzir uma expressão para a temperatura em função do valor lido.
Arduino+LM35
• O sensor será alimentado pelo Arduino que fornece 5V, como as entradas analógicas têm uma resolução de 10 bits, ou seja, 2^10 = 1024 e cada grau corresponde a 10 mV então a expressão da temperatura em função do valor lido na entrada analógica do Arduino será:
temperatura = (valorlido * (5/1023))*100
temperatura = 0,0048875855*valorlido
Arduino+LM35
• Todos os condutores quando sujeitos a corrente elétrica dissipam energia, sob várias formas, entre elas sob a forma de calor, assim para que seja fiável e as suas leituras sejam tão próximas do real quanto possível é necessário que a energia dissipada na forma de calor seja também a mais baixa possível.
• Este foi um dos pontos que tivemos em consideração na escolha do sensor de temperatura a utilizar. A escolha recaiu então no LM35, entre outros aspectos pelo seu baixo auto-aquecimento, pois este sensor apenas dissipa 60uA sob a forma de calor, ou seja, o aumento de temperatura que sofre devido à energia dissipada é de apenas 0.1ºC.
Arduino+LM35
const int LM35 = A0;
int Temperatura = 0;
void setup()
{
pinMode(LM35,INPUT);
Serial.begin(9600);
}
void loop()
{
Temperatura = analogRead(LM35);
Temperatura = (5 * Temperatura * 100)/1023;
Serial.print("Temperatura = ");
Serial.println(Temperatura,DEC);
delay(150);
}
Exercício
Desenvolver um programa que quando a temperatura medida pelosensor LM35, for maior que 30°C acenda um led (vermelho – pino 9), equando for menor igual a 30°C acenda outro led (verde – pino 10).
EM DUPLA
const int LM35 = A0;
int Temperatura = 0;
int verdepin = 10;
Int vermpin = 9;
void setup()
{
pinMode(LM35,INPUT);
pinMode(verdepin,OUTPUT);
pinMode(vermpin,OUTPUT);
Serial.begin(9600);
}
void loop()
{
Temperatura = analogRead(LM35);
Temperatura = (5 * Temperatura * 100)/1023;
Serial.print("Temperatura = ");
Serial.println(Temperatura,DEC);
delay(150);
if(Temperatura>30)
{
digitalWrite(vermpin,HIGH);
digitalWrite(verdepin,LOW);
}
else
{
digitalWrite(verdepin,HIGH);
digitalWrite(vermpin,LOW);
}
delay(500);
}
Observe como é fácil gravar as sequência das cores dos resistores:
PRETO
MARROM
VERMELHO
LARANJA
AMARELO
VERDE
AZUL
VIOLETA
CINZA
BRANCO
Se a coisa tá Preta, Marrom ou Vermelha, LAVA VC até ficar Branco.
Top Related