terça-feira, 28 de agosto de 2018

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

segunda-feira, 20 de agosto de 2018

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

sexta-feira, 17 de agosto de 2018

Exercicio Semaforo

Sequenciamento - O semáforo


SEMÁFORO - WIKIPÉDIA

A ORIGEM DO SEMÁFORO - ORIGEM DAS COISAS





1. SEMÁFORO SIMPLES




Funcionamento de um semáforo de forma individual

1ª etapa - Acionamento do Verde

2ª etapa - Tempo de verde (15s por exemplo)

3ª etapa - Acionamento do Amarelo

4ª etapa - Tempo de amarelo (2s po exemplo)

5ª etapa - Acionamento do vermelho

6ª etapa - Tempo do vermelho (13s por exemplo)

Para completar o ciclo, volta a 1ª etapa


Atividade

Desenvolver um sketch utilizando uma placa Arduíno, para controlar um semáforo individual com o circuito correspondente.

  • Ligar o semáforo a saídas digitais
  • Escolher tempos para
    • Aberto (verde)
    • Atenção (amarelo)
    • Pare (vermelho)


Exemplo de montagem de um semáforo simples

2. SEMÁFORO CRUZAMENTO

Quando temos o cruzamento de duas vias, a preferência de tráfego corresponde a via de maior importância, ou seja, a que possui maior tráfego.

Quando as duas vias possuem a mesma importância trona-se necessário organizar o tempo em que cada uma delas terá a passagem. Isso é coordenado por um semáforo.

Cruzamento de duas vias


Diagrama de estados para os semáforos A e B






Atividade

Desenvolver um sketch utilizando uma placa Arduíno, para controlar um cruzamento de 2 vias.
Escolha os pinos de saída 

Sugestão de montagem dos dois semáforos



3. SEMÁFORO CRUZAMENTO COM TEMPOS DIFERENTES


Em alguns cruzamentos é necessário organizar com temporizações diferentes dependendo do sentido de fluxo.



Note na figura acima que é necessário termos tempos que organizem cada um dos fluxos para cada um deles (1, 2 e 3) ocorrer em tempos diferentes para cada um poder ter acesso as duas vias.

Diagrama de estados para os semáforos A B e C









Sugestão de montagem

terça-feira, 14 de agosto de 2018

Uso do IDE c.c

Os primeiros passos - BLINK

A IDE  do Arduino já vem "recheada" de exemplos.

O exemplo clássico é "Blink", que é um led piscante.


  • Piscar um LED corresponde a mudar o estado lógico de uma saída
  • Para termos o efeito visual de piscar um LED é necessário ligar e em sequência desligar uma saída lógica.
  • Esta ação deve acontecer de forma repetitiva (loop)

  • Como o microcontrolador trabalha sob um circuito de clock elevado (16MHz), as ações efetuadas ocorrem em um tempo muito pequeno, de forma que o olho humano não percebe essas mudanças.
  • Visualmente é como se o LED estivesse permanentemente ligado.
  • Para poder ver o efeito é necessário incluir um tempo visível ao olho humano .


  


  

Construindo um sketch através de um exemplo


Arduino.cc - Blink

Com seu Arduino conectado ao computador e devidamente configurado, abra o
menu Arquivo > Examplos > 01. Basics > Blink.



Uma nova janela deve ser aberta com um programa carregado.



Na "Área de programação" teremos um logo comentário explicando o que faz o programa como ele está configurado e dados sobre o autor e data.

O programa consiste em

  


  
// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

  


  

Transferindo o programa para placa


Clique no botão "Gravar o programa na placa", que o Sketch será compilado e transferido para a placa.

Botão "Gravar o programa na placa" marcado em vermelho

As placas UNO e MEGA tem um led ligado ao pino digital 13, por não há necessidade de ligar nenhum hardware externo a placa. Após a compilação e carga do programa o led começará a piscar com tempos de on e off de 1 segundo.



   

Placas UNO e Mega com led conectado a saída digital 13 marcado em vermelho 

 
Ligando a placa a um hardware externo (resistor e led) montado na protoboard



  

  

Usando um simulador

Clique no Menu  "Sketch/Exportar Binário Compilado"



A IDE compila o Sketch, verifica erros e gera um arquivo ".HEX" que contém o programa no formato que o microcontrolador entende. Esse aquivo pode ser utilizado no simulador.


  
  


Entendendo o Código


O código do exemplo Blink é relativamente simples, porém apresenta a estrutura básica de um programa desenvolvido na IDE Arduino. Inicialmente nota-se que existem duas funções obrigatórias em um programa Arduino, setup() e loop().

A função setup () é executada na inicialização do programa e é responsável pelas configurações iniciais do microcontrolador, tal como definição dos pinos de I/O, inicialização da comunicação serial, entre outras.

A função loop () será onde ocorrerá o laço infinito da programação, ou seja, onde será inserido o código que será executado continuamente pelo microcontrolador.

Dentro do loop principal está o código que fará o led ligado pino 13 piscar em intervalos de 1 segundo.

A função digitalWrite(led, HIGH); coloca o pino em nível lógico 1, ligando o led.

A função delay(1000); aguarda o tempo de 1000 ms, ou seja, 1 segundo para que possa ser executada a próxima instrução.

A função digitalWrite(led, LOW); coloca o pino em nível lógico 0, desligando o led.

E novamente é esperado 1 segundo com a função delay();

O loop é repetido infinitamente enquanto a placa estiver ligada.



  


  

Atividades:



  1. Construa um novo sketch baseado no exemplo blink e modifique o tempo de "on" para 2 segundos
  2. Construa um novo sketch baseado no exemplo blink e modifique a ligação do led para o pino 10
  3. Construa um novo sketch baseado no exemplo blink de forma a termos 2 led ligados nas saídas 11 e 12 de forma que pisquem de forma alternada (quando um está ON o outro está OFF) com tempos de ação de 1,5 segundos


segunda-feira, 13 de agosto de 2018

Conteudo Programático Arduino Linguagem Programação


Conteúdo Programático Arduino –Prof. Antonio



1 Apresentação

1.1           - Apresentação Pessoal

1.2           - O que é essa componente curricular

1.3           - Qual seu objetivo

1.4           - Formas de trabalho pratico teórico

1.5           - Uso kit Arduino UNO

1.6           - Simulador Proteus e Fritzing

1.7           - Proto Board e componentes







2           Introdução ao Arduino

2.1           - Página Oficial. O que é o Arduino

2.2           - Onde comprar a placa?

2.3           - Conhecendo as placas (Família Arduino)

2.4           - Baixando e instalando o IDE (Windows)

2.5           - Conhecendo o IDE Arduino.

3           Primeiros Passos

3.1- Sketch – Arquivos Arduino

3.2 – Exemplo 1 Blink e sua estrutura

3.3 –Conhendo a placa (hardware UNO)

3.4 – Sensores, Atuadores, Shields, módulos e componentes





4 Simulador on line ou os nossos

4.1 – Criando a conta e acessando

4.2 –Aprendendo com exemplos

4.3 – Editando exemplos

5 Programação

5.1 – Funções

5.2 – Variáveis locais, globais, constante

5.3 -Estruturas

5.4 – Bibliotecas

OBs: Se possível de uma forma prática.



6-Programando básico

6.1 -Estruturas entradas e saídas digitais

6.1 .1 – Setup e Loop

6.1.2 – pinMode()

6.1.3.- digitalRead()

6.1.4.- digitalWrite()



6.3 – Funções Time

Delay

DelaysMicrossegundo()

Micros()

Millis()



6.4 – Entradas e saídas Analógicas

analogRead()

analogReference()

analogWrite()