Medindo temperatura com ARduino

Medindo-temperatura-com-arduino/

Semaforo com Arduino

Semaforo-com-led.html

LDR com Arduino

Sensor-de-luz-com-ldr

Operadores Matemáticos com Arduino

Operadores Matemáticos

Display 7 segmentos Anodo e Catodo Comum

/*
*_****Titulo: Aula 04****
* código sugestão
*_local: E.T.E. Parobé
*_autor:
*_data: 17/09/2018
*_versão: 2.1.0
*_
*_referências: sketch disponivel em www.arduino.cc
*/
#include <arduino.h>  //inclui a bibliotéca arduino.h
#define segA 2  //define o pino 13 como led1 segA
#define segB 3 //define o pino 12 como led2 segB
#define segC 4 //define o pino 11 como led3 segC
#define segD 5 //define o pino 10 como led4 segD
#define segE 6  //define o pino 09 como led5 segE
#define segF 7  //define o pino 08 como led7 segF
#define segG 8  //define o pino 07 como led8 segG
#define segPT 9  //define o pino 06 como led9 segPT

void setup()
{
  pinMode (2 , OUTPUT);  //define led1 como saida
  pinMode (3 , OUTPUT);  //define led2 como saida
  pinMode (4 , OUTPUT);  //define led3 como saida
  pinMode (5 , OUTPUT);  //define led4 como saida
  pinMode (6 , OUTPUT);  //define button1 como saida
  pinMode (7 , OUTPUT);  //define button2 como entrada
  pinMode (8 , OUTPUT);  //define button3 como entrada
  pinMode (9 , OUTPUT);  //define button4 como entrada
  digitalWrite(9,0);// desliga o ponto
}
void loop()
{
  //escrever (9)
  digitalWrite(segA,1);
  digitalWrite(segB,1);
  digitalWrite(segC,1);
  digitalWrite(segD,0);
  digitalWrite(segE,0);
  digitalWrite(segF,1);
  digitalWrite(segG,1);
  delay(1000);
 


 
}

Funções

Funções, como criar, como usar

A estrutura um skecth de arduino  deve seguir uma ordem, esta ordem tem por objetivo organizar e facilitar o entendimento:

1. Declarar as variáveis, constantes ou "apelidos"
2. Declarar / escrever funções próprias
3. Escrever a função "setup" que define I/Os, inicializa periféricos, ou seja, ajusta as configurações inicias
4. Escrever a função "loop" que cria a rotina de looping para execução do programa

O QUE SÃO FUNÇÕES.

Uma função é, em linhas gerais, uma sequência de comandos que pode ser reutilizada várias vezes ao longo de um programa. Para criar uma função e dizer o que ela faz, nós precisamos fazer uma declaração de função.

Para entender o conceito de função vamos utilizar como exemplo um led ligado ao pino 0 de um Arduino UNO que pisca.



Código para piscar um led que usaremos como exemplo

 


/*
  Objetivo: entender o uso de funções
  Passo 1 - Exemplo de uma atividade: piscar um led ligado ao pino 0
*/

#define led_saida 0   // cria um apelido "led_saida" para o valor 0 (pino 0)

void setup() {  // função executada uma única vez quando pressionado o reset
  pinMode(led_saida, OUTPUT); // inicializa o pino 0 como saída
}

void loop() { // função que fará o programa rodar executar as instruções listadas repetidas vezes
  digitalWrite(led_saida, HIGH);  // liga o led. Coloca nível de tensão alto no pino 0
  delay(1000);                    // espera 1 segundo
  digitalWrite(led_saida, LOW);   // desliga o led. Coloca nível de tesão baixo no pino 0
  delay(1000);                    // espera 1 segundo
}

 



Criando uma função
Note que na função loop temos os comandos que fazem a ação, ou seja, o led piscar
Poderíamos substitui esse conjuntos de comandos a associar a eles um "nome" que permitisse lembrar o que esses comandos fazem (piscar o led).
Abaixo o código para piscar um led com os comandos colocados dentro de uma função

 



/*

  Objetivo: entender o uso de funções
  Passo 2 - Criar uma função que execute alguns comandos
*/

#define led_saida 0   // cria um apelido "led_saida" para o valor 0 (pino 0)

void pisca_led (void){
  digitalWrite(led_saida, HIGH);   // liga o led. Coloca nível de tensão alto no pino 0
  delay(1000);                               // espera 1 segundo
  digitalWrite(led_saida, LOW);    // desliga o led. Coloca nível de tesão baixo no pino 0
  delay(1000);                               // espera 1 segundo
}

void setup() {  // função executada uma única vez quando pressionado o reset
  pinMode(led_saida, OUTPUT); // inicializa o pino 0 como saída
}

void loop() { // função que fará o programa rodar executar as instruções listadas repetidas vezes
  pisca_led();  // executa os comandos que faão o led piscar
}

 


Colocando um parâmetro
Que tal se fosse possível controlar o tempo de on/off do led piscante?
para isso basta passar um dado que indique esse tempo. Aqui este dados é chamado de parâmtero
Abaixo o código para piscar um led com os comandos colocados dentro de uma função recebendo um parâmetro de tempo em segundos

 


/*
  Objetivo: entender o uso de funções
  Passo 3 - Criar uma função que execute alguns comandos recebendo um parâmetro de tempo
*/

#define led_saida 0   // cria um apelido "led_saida" para o valor 0 (pino 0)

void pisca_led (int segundos){
  digitalWrite(led_saida, HIGH);   // liga o led. Coloca nível de tensão alto no pino 0
  delay(1000 * segundos);                               // espera quantos segundos foram passados
  digitalWrite(led_saida, LOW);    // desliga o led. Coloca nível de tesão baixo no pino 0
  delay(1000 * segundos);                               // espera quantos segundos foram passados
}

void setup() {  // função executada uma única vez quando pressionado o reset
  pinMode(led_saida, OUTPUT); // inicializa o pino 0 como saída
}

void loop() { // função que fará o programa rodar executar as instruções listadas repetidas vezes
  pisca_led(2);  // executa os comandos que farão o led piscar com 2 segundos de tempo on e off
}

 



Trabalhando com mais parâmetros
Poderíamos controlar os tempo de on e off?
Para isso basta passar o tempo de on e o tempo de off.
Abaixo o código para piscar um led com os comandos colocados dentro de uma função recebendo dois parâmetros de tempo para on e off em segundos

 


/*
  Objetivo: entender o uso de funções
  Passo 4 - Criar uma função que execute alguns comandos recebendo dois parâmetros de tempo on e off
*/

#define led_saida 0   // cria um apelido "led_saida" para o valor 0 (pino 0)

void pisca_led (int segundos_on, int segundos_off){
  digitalWrite(led_saida, HIGH);   // liga o led. Coloca nível de tensão alto no pino 0
  delay(1000 * segundos_on);                               // espera quantos segundos de on foram passados
  digitalWrite(led_saida, LOW);    // desliga o led. Coloca nível de tesão baixo no pino 0
  delay(1000 * segundos_off);                               // espera quantos segundos de off foram passados
}

void setup() {  // função executada uma única vez quando pressionado o reset
  pinMode(led_saida, OUTPUT); // inicializa o pino 0 como saída
}

void loop() { // função que fará o programa rodar executar as instruções listadas repetidas vezes
  pisca_led(3,2);  // executa os comandos que farão o led piscar com 3 segundos de tempo on 2 segundos de tempo off
}

 

ATIVIDADE:

Utilizando a função delay (que gera um atraso de 1ms) construa um skech com:
• uma função que gere múltiplos de 1s
• pisque um led utilizando essa função, com tempos de ON=1s e OFF=2s

Ligação de botão (Chave)

Botão como entrada digital

Objetivo: controlar o estado de um led (on/off), pela ação de um botão (pressionado/solto)

Carregue o exemplo do botão

A explicação do hardware a ser montado temos no site do arduino Bottun - Botão

A ideia de funcionamento do sketch está no fluxograma abaixo:

Entendendo o sketch

const int

const int buttonPin = 2;
const int ledPin =  13;

Cria variáveis do tipo int constantes (que não mudam durante a execução) para indicar as portas (pinos) utilizadas para ligar o botão (buttonPin) e led (ledPin)

int buttonState = 0;
Cria uma variável para indicar o estado do botão e inicializa ela com o valor zero (Falso)
Note que este tipo é diferente do anterior (const int) pois permite sua modificação durante a execução

void setup()

A função setup () é chamada quando um iniciamos um skecth.
Nela podemos:

• Inicializar variáveis, 
• Modos de pino, 
• Inicializar bibliotecas

A função de setup() será executada apenas uma vez, após cada energização ou reset da placa Arduino.

pinMode()

pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);

Configura o pino especificado se comportar tanto como uma entrada ou uma saída. Veja a descrição dos pinos digitais para obter detalhes sobre a funcionalidade dos pinos.

loop()

Após a configuração de parâmetros iniciais - setup() - a função loop mantem o programa em funcionamento repetindo a sequência de comandos.

digitalRead()

buttonState = digitalRead(buttonPin);

Lê o valor digital especificado em um pino, devolvendo o nível HIGH ou LOW.
No nosso exemplo a variável buttonSate receberá o nível do pino especificado para o botão

if / else

if (buttonState == HIGH)

Avalia condição estabelecida no comando if entre os parenteses. 
No nosso exemplo pergunta se o nível lógico do botão é alto
Se a condição for verdadeira (TRUE ou "1") executa a instrução ou conjunto de instruções entre as chaves após a condição
Se a condição for falsa (FALSE ou "0") executa a instrução ou conjunto de instruções entre as chaves após o else. O else não é obrigatório, podendo existir apenas a instrução para a situação de verdadeiro.

digitalWrite()

digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);

Escreve HIGH (nível alto, "1") ou LOW (nível baixo, "0") no pino especificado

==============================================================

Atividades complementares 

Montagem do sketch

Crie novos sketchs para cada atividade usando como base o exemplo do botão

1. Modifique a ação do botão em relação ao estado do led.
2. Modifique os pinos do botão e do led.
3. Modifique o botão para usar o resistor de pullup.
4. Coloque 2 entradas e duas saídas de forma que cada botão controle uma saída.
5. Coloque 2 entradas de forma que elas controle 3 saídas com a seguinte lógica:

• Saída 1: função AND entre as duas entradas
• Saída 2: função NOR entre as duas entradas
• Saída 3: função OR entre as duas entradas