Estrutura de Condição. Professor Pedro

(1)

Estrutura de Condição

(2)

Continuando...

• Hoje vamos trabalhar com o arduino usando a estrutura de condição que já aprenderam nas aulas de lógica de programação.

If (condição verdadeira) {

Executa este trecho de código }

Else {

Executa este outro trecho de código }

(3)

Continuando...

• Para isso vamos fazer um semáforo que

funcione usando um botão onde deve trocar

de verde para carro para vermelho e

consequentemente para verde para pedestre.

(4)

Estrutura de condição

• Primeiro vamos digitar o código a baixo: // Projeto 4 – Semáforo interativo

int carRed = 12; // estabelece o semáforo para carros int carYellow = 11;

int carGreen = 10;

int pedRed = 9; // estabelece o semáforo para pedestres int pedGreen = 8;

int button = 2; // pino do botão

int crossTime = 5000; // tempo para que os pedestres atravessem

unsigned long changeTime; // tempo desde que o botão foi pressionado

(5)

Estrutura de condição

void setup() { pinMode(carRed, OUTPUT); pinMode(carYellow, OUTPUT); pinMode(carGreen, OUTPUT); pinMode(pedRed, OUTPUT); pinMode(pedGreen, OUTPUT);

pinMode(button, INPUT); // botão no pino 2 // acende a luz verde

digitalWrite(carGreen, HIGH); digitalWrite(pedRed, HIGH); }

(6)

Estrutura de condição

void loop() {

int state = digitalRead(button);

/* verifica se o botão foi pressionado e se transcorreram 5 segundos desde a última vez que isso ocorreu */

if (state == HIGH && (millis() - changeTime) > 5000) { changeLights();

// Chama a função para alterar as luzes }

(7)

Estrutura de condição

void changeLights() {

digitalWrite(carGreen, LOW); // apaga o verde

digitalWrite(carYellow, HIGH); // acende o amarelo delay(2000); // espera 2 segundos

digitalWrite(carYellow, LOW); // apaga o amarelo digitalWrite(carRed, HIGH); // acende o vermelho delay(1000); // espera 1 segundo, por segurança

(8)

Estrutura de condição

digitalWrite(pedRed, LOW); // apaga o vermelho dos pedestres digitalWrite(pedGreen, HIGH); // acende o verde dos pedestres delay(crossTime); // espera por um intervalo de tempo

predefinido

// pisca o verde dos pedestres for (int x=0; x<10; x++) { digitalWrite(pedGreen, HIGH); delay(250); digitalWrite(pedGreen, LOW); delay(250); }

(9)

Estrutura de condição

// acende o vermelho dos pedestres digitalWrite(pedRed, HIGH);

delay(500);

digitalWrite(carYellow, HIGH); // acende o amarelo digitalWrite(carRed, LOW); // apaga o vermelho delay(1000);

(10)

Estrutura de condição

digitalWrite(carGreen, HIGH); // acende o verde digitalWrite(carYellow, LOW); // apaga o amarelo // registra o tempo desde a última alteração no

semáforo

changeTime = millis();

// depois retorna para o loop principal do programa }

(11)

Estrutura de condição

• Com base nos projetos anteriores, você já

deve compreender e reconhecer a maioria

do código deste projeto. Destacarei apenas

as novas palavras-chave e conceitos.

unsigned long changeTime;

• Aqui temos um novo tipo de dados para uma

variável. Anteriormente, você criou tipos de

dados inteiros, capazes de armazenar um

numero entre -32.768 e 32.767.

(12)

Estrutura de condição

• Dessa vez, você criou um tipo de dado long, que pode armazenar um numero entre -2.137.483.648 e 2.147.483.647. Entretanto, você especificou um unsigned long, o que significa que a variável não pode armazenar números negativos, assim o intervalo vai de 0 a 4.294.967.295. Se você estivesse utilizando um inteiro para armazenar o intervalo de tempo desde a ultima troca no semáforo, teria um tempo Maximo de apenas 32 segundos, antes que a variável atingisse um numero maior do que o valor que ela pode armazenar.

(13)

Estrutura de condição

• Em seguida, temos:

pinMode(button, INPUT);

• Isso diz ao Arduino que você deseja utilizar o

pino digital 2 (button = 2) como INPUT. Você

utilizara o pino digital 2 para escutar quando o

botão e pressionado, por isso seu modo deve

ser definido como entrada.

(14)

Estrutura de condição

• No loop principal do programa, você verifica o

estado do pino 2 com esta instrução:

int state = digitalRead(button);

• Isso inicializa um inteiro state, e então define

seu valor como o valor do pino digital 2. A

instrução digitalRead lê o estado do pino

dentro dos parênteses, retornando esse

estado para o valor inteiro ao qual você o

atribuiu.

(15)

Estrutura de condição

• Depois, você pode verificar o valor em state

para ver se o botão foi ou não pressionado:

if (state == HIGH && (millis() - changeTime) >

5000) {

// Chama a função para alterar as luzes

changeLights();

(16)

Estrutura de condição

• A instrução if e um exemplo de uma estrutura de controle, cujo propósito e verificar se determinada condição foi ou não atingida. Caso a condição seja verdadeira, a instrução executa o código dentro de seu bloco de código. Por exemplo, se você quisesse acender um LED, caso uma variável x atingisse um valor superior a 500, poderia escrever o seguinte:

(17)

Estrutura de condição

• Quando você lê um pino utilizando o comando

digitalRead, o estado do pino será HIGH ou

LOW. Assim, o comando if em seu sketch tem

a seguinte apresentação:

if (state == HIGH && (millis() - changeTime) >

5000)

(18)

Estrutura de condição

• Quando você lê um pino utilizando o comando digitalRead, o estado do pino será HIGH ou LOW. Assim, o comando if em seu sketch tem a seguinte apresentação:

if (state == HIGH && (millis() - changeTime) > 5000)

• Aqui, verificamos se duas condições foram

atingidas. A primeira e a de que a variável

state seja HIGH. Se o botão foi pressionado,

state será HIGH, pois você já definiu este

como o valor a ser lido do pino digital 2.

(19)

Estrutura de condição

• Você também esta conferindo se o valor de millis() - changeTime e maior que 5000 (utilizando o comando lógico E, &&). millis() e uma função integrada a linguagem do Arduino, que retorna o numero de milissegundos desde que o Arduino iniciou a execução do programa atual. Sua variável changeTime inicialmente não armazenara nenhum valor, mas depois que a função changeLights() tiver sido executada, changeTime será definida como o valor atual de millis().

(20)

Estrutura de condição

• Subtraindo o valor na variável changeTime do

valor atual de millis(), você pode verificar se

transcorreram cinco segundos desde que

changeTime foi definida pela ultima vez. O

calculo de millis() - changeTime e colocado

dentro de seus próprios parênteses, para

garantir que você compare o valor de state ao

resultado dessa operação, e não ao valor de

millis() por si so.

(21)

Estrutura de condição

• O símbolo && que vemos entre state == HIGH e o calculo é um exemplo de um operador booleano. Nesse caso, ele significa E. Para entender o que isso quer dizer, vamos analisar todos os operadores booleanos:

• && E lógico • || OU lógico; • ! NAO

• Note que essas são instruções lógicas, podendo ser utilizadas para testar diversas condições em instruções if.

(22)

Estrutura de condição

• O comando dentro da instrução if é changeLights();

• Esse e um exemplo de uma chamada de função. Uma função e simplesmente um bloco de código separado que recebeu um nome. Entretanto, funções também podem receber parâmetros e/ou retornar dados. Nesse caso, você não passou nenhum dado a função, nem fez com que ela retornasse dados. No futuro, falarei mais detalhadamente sobre a transmissão de parâmetros e o retorno de dados em funções.

(23)

Estrutura de condição

• Quando changeLights() e chamada, a execução do código pula da linha atual para a função, executa o código dentro dela, e depois retorna ao ponto no código, logo depois da chamada a função.

• Nesse caso, se as condições da instrução if forem atendidas, o programa executara o código dentro da função e retornara para a linha seguinte, depois de changeLights(), na instrução if.

(24)

Estrutura de condição

• O código dentro da função simplesmente altera o semáforo dos veículos para vermelho, passando pelo amarelo, e então acende a luz verde para pedestres. Depois de um intervalo de tempo definido pela variável crossTime, a luz dos pedestres pisca algumas vezes para alertar que o tempo esta se esgotando, e então passa para o vermelho. Enquanto isso, o semáforo dos veículos muda de vermelho para verde, passando pelo amarelo e retornando, dessa forma, ao seu estado normal.

(25)

Estrutura de condição

• O loop principal do programa verifica

continuamente se o botão para pedestres foi

ou não pressionado. Se isso ocorrer e (&&) o

tempo desde a ultima alteração do semáforo

for maior que 5 segundos, o loop chamara

novamente a função changeLights().

(26)

(27)

Exercícios

• Faça uma alteração no semáforo de vocês

fazendo com que se ninguém pressionar o

botão por mais de 10 segundos, é para o

semáforo trocar as luzes e deixar o pedestre

passar mesmo assim.

• Pegue 05 leds vermelhor e 05 resistores e

façam ascender da direita para a esquerda

de um em um segundo até acender todos e

depois

apague

tudo

e

comece

tudo

(28)

Resposta da 1

// Semáforo Interativo com Botão //declarando variáveis para os carros int carRed = 12;

int carYellow = 11; int carGreen = 10;

//declarando variáveis para os pedestres int pedRed = 9;

int pedGreen = 8;

//declarando outras variáveis int button = 2;//pino do botão

int crossTime = 5000;//tempo para os pedestres passarem de 5 seg. unsigned long changeTime;//tempo desde que o botão foi

(29)

Resposta da 1

//carregando o sistema void setup(){

//declarando tipo de cada elemento (entrada ou saida) pinMode(carRed,OUTPUT); pinMode(carYellow,OUTPUT); pinMode(carGreen,OUTPUT); pinMode(pedRed,OUTPUT); pinMode(pedGreen,OUTPUT); pinMode(button,INPUT);

//acende as luzes iniciais

digitalWrite(carGreen, HIGH); digitalWrite(pedRed, HIGH); }

(30)

Resposta da 1

//carregando função do programa void loop(){

int state = digitalRead(button);

if (state == HIGH && (millis()-changeTime)>5000){//se o botão foi pressionado e se passaram mais de 5 seg desde a ultima vez que isso ocorreu então ele entra...

changeLights();//chama a função para acender a luz }//fim da condição principal

else if(millis()-changeTime>10000){//se passaram mais de 10 seg desde a ultima vez que isso ocorreu então ele entra...

changeLights();//chama a função para acender a luz }//fim da condição principal

(31)

Resposta da 1

//função acende a luz void changeLights(){

digitalWrite(carGreen, LOW);//apaga luz verde de carro. digitalWrite(carYellow, HIGH);//acende luz amarela

delay(2000);//espera 2 segundos

digitalWrite(carYellow, LOW);//apaga luz amarela

digitalWrite(carRed, HIGH);//acende luz vermelha carro. delay(1000);//espera 1 segundo de segurança

digitalWrite(pedRed, LOW);//apaga luz vermelha de pedestre digitalWrite(pedGreen, HIGH);//acende luz verde de pedestre

(32)

Resposta da 1

//pisca o verde dos pedestres indicando que tempo esta esgotando for(int x=0; x<10; x++){ digitalWrite(pedGreen, HIGH); delay(250); digitalWrite(pedGreen, LOW); delay(250); }//fim do for

(33)

Resposta da 1

//acende vermelho dos pedestres digitalWrite(pedRed, HIGH);

delay(500);

digitalWrite(carYellow, HIGH);//acende amarelo digitalWrite(carRed, LOW);//apaga vermelho carro delay(1000);

digitalWrite(carGreen, HIGH);//acende luz verde carro digitalWrite(carYellow, LOW);//apaga amarelo carro

//registra o tempo desde a última alteração no semáforo changeTime=millis();

//depois retorna para o loop principal do programa }