terça-feira, 4 de dezembro de 2018
quinta-feira, 27 de setembro de 2018
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);
}
*_****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);
}
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
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
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:
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
Nela podemos:
A função de setup() será executada apenas uma vez, após cada energização ou reset da placa Arduino.
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.
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
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(ledPin, LOW);
Escreve HIGH (nível alto, "1") ou LOW (nível baixo, "0") no pino especificado
==============================================================
Crie novos sketchs para cada atividade usando como base o exemplo do botão
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
- Modifique a ação do botão em relação ao estado do led.
- Modifique os pinos do botão e do led.
- Modifique o botão para usar o resistor de pullup.
- Coloque 2 entradas e duas saídas de forma que cada botão controle uma saída.
- 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
3ª etapa - Acionamento do Amarelo
5ª etapa - Acionamento do vermelho
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.
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.
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
}
Clique no botão "Gravar o programa na placa", que o Sketch será compilado e transferido para a placa.
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
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:
- Construa um novo sketch baseado no exemplo blink e modifique o tempo de "on" para 2 segundos
- Construa um novo sketch baseado no exemplo blink e modifique a ligação do led para o pino 10
- 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()
Assinar:
Postagens (Atom)