LPAM

Introdução a Lógica de programação

Clique aqui e resolva os exercícios de lógica, antes de continuar.

Programe em blocos e estude lógica de programação através do ArduBlock. Assista ao vídeo:

Atividade 1: Utilizando o ArduBlock, simule o Semágoro de pedestres em frente à nossa Escola.

Divirta-se neste link, seguindo as instruções.

1- Ementa Linguagem de Programação Aplicada a Microcontroladores:

Desenvolver circuitos e aplicações em sistema micro-controlados.

2- Conteúdo Programático:

Desenvolvimento de aplicações para micro-controladores

3- Metodologia de Avaliação:

3.1- Atividades em sala de Aula:

        Atividades propostas apresentadas e entregues via meio eletrônico.

3.2- Índice de Frequência:

        Corresponde a um mínimo de frequência de 80% em sala de aula.

3.3- Projetos de Pesquisa:

       Atividades Livres para desenvolvimento;

3.4 - Provas:

        Avaliações individuais por escrito;

3.5- Recuperações Paralelas ao longo do processo.

       Avaliações extras para aqueles alunos que não atingiram o rendimento mínimo nas avaliações ou prorrogações de prazos com desconto na pontuação.

3.6- Critérios para Aprovação:

        Cada item receberá um índice A ou NA, o aluno obterá o conceito A, se obtiver 80% de rendimento em todas as avaliações propostas ou índice NA, caso não execute ou obtenha rendimento inferior a 80% em cada proposta avaliativa.

3.7 -Material Necessário para as Aulas

- Arduino Uno ou superior;

- Matriz de Contatos;

- Leds, resistores, potenciômetros;

- Teclas push button, 4mm ou similares;

- Display LCD 16x2 azul(i2C se possível);

- Cabos e Jumpers para interconexão;

- Instrumentos e componentes utilizados nas demais disciplinas;

- Motores CC de baixo consumo obtidos em desmanche(vídeo cassetes,dvds, 3x1, entre outros);

Obs.: A utilização de notebooks e celulares pessoais será bem-vinda.

Aula 1:

O que é Arduino

O Arduino foi criado em 2005 por um grupo de 5 pesquisadores : Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. O objetivo era elaborar um dispositivo que fosse ao mesmo tempo barato, funcional e fácil de programar, sendo dessa forma acessível a estudantes e projetistas amadores. Além disso, foi adotado o conceito de hardware livre, o que significa que qualquer um pode montar, modificar, melhorar e personalizar o Arduino, partindo do mesmo hardware básico.

Assim, foi criada uma placa composta por um microcontrolador Atmel, circuitos de entrada/saída e que pode ser facilmente conectada à um computador e programada via IDE (Integrated Development Environment, ou Ambiente de Desenvolvimento Integrado) utilizando uma linguagem baseada em C/C++, sem a necessidade de equipamentos extras além de um cabo USB.

Depois de programado, o microcontrolador pode ser usado de forma independente, ou seja, você pode colocá-lo para controlar um robô, uma lixeira, um ventilador, as luzes da sua casa, a temperatura do ar condicionado, pode utilizá-lo como um aparelho de medição ou qualquer outro projeto que vier à cabeça.

O que você pode fazer com o Arduino

A lista de possibilidades é praticamente infinita. Você pode automatizar sua casa, seu carro, seu escritório, criar um novo brinquedo, um novo equipamento ou melhorar um já existente. Tudo vai depender da sua criatividade.

Para isso, o Arduino possui uma quantidade enorme de sensores e componentes que você pode utilizar nos seus projetos. Grande parte do material utilizado está disponível em módulos, que são pequenas placas que contém os sensores e outros componentes auxiliares como resistores, capacitores e leds.

Existem também os chamados Shields, que são placas que você encaixa no Arduino para expandir suas funcionalidades. A imagem abaixo mostra um Arduino Ethernet Shield encaixado no Arduino Mega 2560. Ao mesmo tempo que permite o acesso à uma rede ou até mesmo à internet, mantém os demais pinos disponíveis para utilização, assim você consegue, por exemplo, utilizar os pinos para receber dados de temperatura e umidade de um ambiente, e consultar esses dados de qualquer lugar do planeta:

Para você ter uma idéia das possibilidades de criação com o Arduino, dê uma olhada nesses dois projetos (clique nas imagens para mais detalhes). O primeiro é de um tênis que se amarra sozinho…

… o outro é de um robô que sobe em árvores…

Modelos de Placas Arduino

O tipo de placa que você vai utilizar depende muito do projeto a ser desenvolvido e o número de portas necessárias. As opções vão das mais comuns, como o Arduino Uno e suas 14 portas digitais e 6 analógicas, passando por placas com maior poder de processamento, como o Arduino Mega, com microcontrolador ATmega2560 e 54 portas digitais, e o Arduino Due, baseado em processador ARM de 32 bits e 512 Kbytes de memória:

Aqui no blog temos um artigo específico abordando as principais placas disponíveis no mercado, onde você pode verificar as especificações, detalhes e características de cada placa.

Estrutura de um programa em Arduino

Escrever um programa em Arduino é muito simples. Tudo o que você precisa é conectá-lo ao computador por meio de um cabo USB e utilizar um ambiente de programação chamado IDE, onde você digita o programa, faz os testes para encontrar eventuais erros e transfere o programa para o dispositivo.

Na imagem abaixo temos a IDE já com um programa carregado. No site oficial do Arduino você pode fazer o download da IDE gratuitamente:

Uma vez feito o programa, basta transferí-lo para o Arduino e o mesmo começa a funcionar.

Você não precisa ser expert em linguagem C para programá-lo. Além da grande quantidade de exemplos que você encontra aqui no blog, você pode começar um programa utilizando a estrutura básica do Arduino, que é composta  por duas partes, ou dois blocos:

setup() – É nessa parte do programa que você configura as opções iniciais do seu programa: os valores iniciais de uma variável, se uma porta será utilizada como entrada ou saída, mensagens para o usuário, ec.

loop() – Essa parte do programa repete uma estrutura de comandos de forma contínua ou até que algum comando de “parar” seja enviado ao Arduino.

Vamos ver exatamente como isso funciona, levando em consideração o programa abaixo, que acende e apaga o led embutido na placa em intervalos de 1 segundo:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

//Programa : Pisca Led Arduino //Autor : FILIPEFLOP void setup() {   //Define a porta do led como saida   pinMode(13, OUTPUT); } void loop() {   //Acende o led   digitalWrite(13, HIGH);       //Aguarda o intervalo especificado   delay(1000);       //Apaga o led   digitalWrite(13, LOW);       //Aguarda o intervalo especificado   delay(1000); }

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:

Comece uma linha com barras duplas ( //) e tudo o que vier depois dessa linha será tratado como um comentário. Uma das boas práticas de programação é documentar o seu código por meio das linhas de comentário. Com elas, você pode inserir observações sobre como determinada parte do programa funciona ou o que significa aquela variável AbsXPT que você criou. Isso será útil não só para você, se precisar alterar o código depois de algum tempo, como também para outras pessoas que utilizarão o seu programa.

Após os comentários, vem a estrutura do SETUP. É nela que definimos que o pino 13 do Arduino será utilizado como saída.

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:

A linha do código contendo digitalWrite(13, HIGH) coloca a porta 13 em nível alto (HIGH, ou 1), acendendo o led embutido na placa. O comando delay(1000), especifica o intervalo, em milisegundos, no qual o programa fica parado antes de avançar para a próxima linha.

O comando digitalWrite(13, LOW), apaga o led, colocando a porta em nível baixo (LOW, ou 0), e depois ocorre uma nova parada no programa, e o processo é então reiniciado.

Começando com o Arduino

Como vimos acima, você não precisa de nenhum componente adicional para começar a programar um Arduino. Basta um computador, uma placa e a IDE para efetuar a programação e enviar o programa para a placa.

Para quem está iniciando, recomendamos o Kit Arduino Start, onde além da placa, você tem resistores, leds e sensor de temperatura, além de diversos outros componentes. O Kit Beginning, onde você pode começar a mexer com displays e sensores ultrasônicos. Para níveis mais avançados,  o Kit Advanced, que já vem com o Arduino Mega 2560:

Fonte: https://www.flipeflop.com

Como programar em boas práticas:

Seu programa deverá estar disposto com as seguintes partes:

1- Cabeçalho contendo descrição completa do autor, controle de versão e referências,

O controle de versão deve estar disposto da seguinte forma:

0.0.0 - onde o último dígito determina quantas falhas foram corrigidas, o segundo as melhorias implementadas e o primeiro a tecnologia incrementada, por exemplo versão Android  7.2.3,significa que este código teve 7 incrementos de tecnologia(hardware), 2 melhorias e foram corrigidas 3 falhas ou bugs.

2- Inclusão de bibliotecas, exemplo:

#include <Arduino.h>

//3- Definição dos pinos, exemplo:

#define ledPino 13

4- Declaração de variáveis ou estruturas, exemplo:

int teclaUm;

5- Setup, definição do hardware, exemplo:

void setup {

pinMode(ledPino,OUTPUT);

pinMode(teclaPino,OUTPUT);

}

6- Função loop ou principal:

void loop(){

// Aqui vai o código principal

}

7- Construção das Isrs, estruturas ou subrotinas:

void piscaLed  (){

// aqui vai o código;

}

void ligaMotor () {

// aqui vai o código

}

Nosso primeiro programa ficaria assim depois do exemplo blink ser salvo na versão 0.1.0, considerando que fizemos melhorias:
//Início do Código

/* Parte 1 - Cabeçalho

  Título: Pisca Led

  Autor: Professor Luis Aransegui

  Empresa: Escola Técnica Parobé

  Data: 12/03/2019

  Modificado: 13/03/2019

  Versão 0.1.0

     Este programa pisca o led interno da placa com um intervalo de 1000ms( 1 segundo)

  Referência em http://www.arduino.cc/en/Tutorial/Blink

*/

// Parte 2 - Bibliotecas

#include <Arduino.h> // carrega bibliotecas

// Parte 3 - Pinos

#define ledPino 13 // dá um rótulo ao pino 13

#define teclaPino 2 // Rótulo ao pino 2

// Parte 4 - Variáveis

void ligaLed (); // Declara função para ligar o led

void desLigaLed (); // declara a função para desligar o Led

int estadoTecla = 1; // inicializa o botão em GND.

//Parte 4 Setup do Hardware

void setup() {

  pinMode(ledPino, OUTPUT); // define o pino 13 como saída

  pinMode(teclaPino, INPUT); // define o pino 2 como entrada

}

// Parte 5- Função Principal

void loop() {

  estadoTecla = digitalRead(teclaPino); // lê o valor da push button

  // Rotina de teste da tecla:

  

  if (estadoTecla == LOW) {

    ligaLed (); // Chama a estrutura para ligar o Led

  } else {

    desligaLed(); // chama a função desligaLed

  }

}

void ligaLed() {

  digitalWrite(ledPino, HIGH);// liga o led

}

void desligaLed () {

  digitalWrite(ledPino, LOW);// desliga o led

}

// Final do Código

Observações:

1- Planeje antes de executar;

2- Comente todas as linhas;

3- Organize a estrutura do código

4- O ponto e vírgula (;), não pode ser utilizado antes de chaves;

5- Estruturas iniciam e terminam com chaves;

6- Estude o código, evite o copiar e colar;

Importante: Os programas não escritos dentro de boas práticas não serão corrigidos e desconsiderados nas avaliações.

Para estas atividades utilizem os exemplos de programas já dados anteriormente.

Atividade 1:

1-Utilize este código de exemplo salvando como piscaled010
2- Modifique para que um led pisque quando o botão for apertado
3- Faça seus testes e guarde bem o trabalho.

Atividade 2:

Siga este link do Professor Pilger e resolva os problemas propostos:

Atividade 3:

Se você chegou sozinho atá agora parabéns!

Nesta a atividade você contruirá um semáforo de pedestres contendo:

- Leds Verde, amarelo, verde, vermelho simulando o semáforo de carros;
- Leds vermelho e verde para pedestres;
- Um botão para pedestres;

1-O semáforo deverá ficar no modo automático para os carros;
2- Quando o pedestre aperta o botão, deve fechar o sinal para os carros e abrir para os pedestres.

Correção do Exercício

// Início do Código
/

// Parte 1- Cabeçalho
/*Ttulo
   nome
   Empresa
   Versão 0.0.0
   Referências: www.arduino.cc
*/
// Parte 2- Bibliotecas
#include <Arduino.h>

// Parte 3- Planejamento Dar nome aos pinos

#define teclaPino 2
#define vermelhoCarro 3
#define amareloCarro 4
#define verdeCarro 5
#define vermelhoPedestre 6
#define verdePedestre 7

// Parte 4 Declaração das das ISRs(Estruturas)e variáveis

void semaforoPedestre();
void semaforoCarro ();

int teclaEstado = 1; // garante o estado inicial

//Estruturas Principais
// Estrutura de configuração
void setup() {

  pinMode(teclaPino, INPUT_PULLUP);
  pinMode(vermelhoCarro, OUTPUT);
  pinMode(amareloCarro, OUTPUT);
  pinMode(verdeCarro, OUTPUT);
  pinMode(vermelhoPedestre, OUTPUT);
  pinMode(verdePedestre, OUTPUT);
}

// Função Principal
void loop() {
  teclaEstado = digitalRead(teclaPino);
  // Teste da tecla

  if (teclaEstado == LOW) {
    semaforoPedestre ();
  } else {
    semaforoCarro();
  }
}
void semaforoCarro () {
  digitalWrite(verdeCarro, HIGH);
  digitalWrite(amareloCarro, LOW);
  digitalWrite(vermelhoCarro, LOW);
  digitalWrite(vermelhoPedestre, HIGH);
  digitalWrite(verdePedestre, LOW);
}
// Estrutura Carro
void semaforoPedestre() {
  delay(1000);
  digitalWrite(verdeCarro, LOW);
  delay(1000);
  digitalWrite(amareloCarro, HIGH);
  delay(1000);
  digitalWrite(amareloCarro,LOW);
  delay(1000);
  digitalWrite(vermelhoCarro, HIGH);
  delay(1000);
  //  Estrutura pisca tres vezes
  for (int x = 0; x <= 2; x++) {
    digitalWrite(vermelhoPedestre, LOW);
    delay(500);
    digitalWrite(vermelhoPedestre, HIGH);
    delay(500);
  }
  digitalWrite(vermelhoPedestre, LOW);
  digitalWrite(verdePedestre, HIGH);
  delay(10000);
}

// Fim do código

Exercício LCD: Teste o código abaixo e melore se necessário, utilizando hardware real.

// Início do Código
// Parte 1- Cabeçalho
/*Título: Semáforo com Display
   Nome:
   Empresa:
   Versão 1.1.0 - Implementação de Display
   Referências: www.arduino.cc
*/
// Parte 2- Bibliotecas de Hardware
#include <Arduino.h> // Biblioteca Opcional
#include <LiquidCrystal.h>

// Parte 3- Planejamento Dar nome aos pinos

#define teclaPino 2
#define vermelhoCarro 3
#define amareloCarro 4
#define verdeCarro 5
#define vermelhoPedestre 6
#define verdePedestre 7
// Colocar potenciometro de contraste ao pino Vo ou VEE
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;// RW ao GND
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Parte 4 Declaração das das ISRs(Estruturas)e variáveis

void semaforoPedestre();
void semaforoCarro ();
int teclaEstado = 1; // garante o estado inicial

//Estruturas Principais
// Estrutura de configuração
void setup() {

  pinMode(teclaPino, INPUT_PULLUP);
  pinMode(vermelhoCarro, OUTPUT);
  pinMode(amareloCarro, OUTPUT);
  pinMode(verdeCarro, OUTPUT);
  pinMode(vermelhoPedestre, OUTPUT);
  pinMode(verdePedestre, OUTPUT);
  lcd.begin(16,2);
}

// Função Principal
void loop() {
  teclaEstado = digitalRead(teclaPino);
  // Teste da tecla

  if (teclaEstado == LOW) {
    semaforoPedestre ();
  } else {
    semaforoCarro();
  }
}
void semaforoCarro () {
  lcd.setCursor(6,0);
  lcd.print("PARE");
  digitalWrite(verdeCarro, HIGH);
  digitalWrite(amareloCarro, LOW);
  digitalWrite(vermelhoCarro, LOW);
  digitalWrite(vermelhoPedestre, HIGH);
  digitalWrite(verdePedestre, LOW);
}
// Estrutura Carro
void semaforoPedestre() {

  delay(1000);
  digitalWrite(verdeCarro, LOW);
  delay(1000);
  digitalWrite(amareloCarro, HIGH);
  delay(1000);
  digitalWrite(amareloCarro,LOW);
  delay(1000);
  digitalWrite(vermelhoCarro, HIGH);
  delay(1000);
  //  Estrutura pisca tres vezes
  for (int x = 0; x <= 2; x++) {
    digitalWrite(vermelhoPedestre, LOW);
    delay(500);
    digitalWrite(vermelhoPedestre, HIGH);
    delay(500);
  }
  lcd.setCursor(6,0);
  lcd.print("SIGA");
  digitalWrite(vermelhoPedestre, LOW);
  digitalWrite(verdePedestre, HIGH);
  delay(10000);
}


// Fim do código

Tipos de Loops ou Laços

Clique aqui, assista e divirta-se no Brincando com Idéias:

Toda a documentação está disponível neste link,clique aqui.

Agora exercite:

1- Rodar o programa exemplo;
2- Comentar todas as linhas;
3- Imprimir em LCD.

O Portal Embarcados poderá fornecer informações úteis sobre a plataforma Arduino. acesse aqui.

Seguido Tutoriais - Switch Case

A instrução switch case serve para controlar individualmente cada etapa do programa, para aprender vamos segui o tutorial neste link Brincando com Idéias.

Exercício:

Reproduza o programa de vídeo, adaptando às boas práticas com cabeçalho, nome do arquivo com controle de versão e programa estruturado(uma função para cada processo).

Atividade para apresentar;

FUP, utilizando o switch case em boas práticas e seguindo as premissas.

- Apertando tecla A acende 0 e respectivamente todos com as demais teclas.


Atividade Final:

Aproveite o exercício

- Apertando a tecla uma vez, dispara o contador regressivo e ativa uma saída por um segundo.

- Apertando duas vezes aborta a contagem,



Apresente o hardware,envie o código ara profaransegui@aransegui.com.br e boas férias.