Programação com Arduino

Prof. Leonardo
Sumário

 Introdução
 Funções principais
 Tipos de dados
 Operadores lógicos
 Operadores de comparação
 Operadores aritméticos
 Estruturas condicionais
 Estruturas de repetição
 Funções digitais
 Funções analógicas
Sketches

 Softwares escritos usando Arduino

 Salvos com extensão .ino
 Sketchbook: local (pasta) padrão para o armazenamento dos seus
programas (sketches)
Bibliotecas Arduino

 Fornecem funcionalidades extras para uso em sketches

 Exemplo:
 Uso em componentes de hardware específicos
 Manipulação de dados
 Várias já vêm instaladas
 É possível realizar o download de outras
 Também é possível realizar a criação de novas bibliotecas
 Para usar:
 Clique em Sketch -> Incluir Biblioteca
 Em nível de programação (biblioteca já existente):
 #include <LiquidCrystal.h>
Linguagem Arduino

 Linguagem semelhante a C/C++

 Tipos de dados (variáveis)
 Operadores lógicos e aritméticos
 Estruturas condicionais e de repetição
 Funções digitais e analógicas
Funções Principais

 setup():
 Função chamada quando o programa inicia sua execução
 Inicialização das variáveis e os modos dos pinos
 Executada uma única vez
 loop():
 Bloco executado enquanto a placa Arduino estiver ligada
 Controle contínuo do ambiente
 Tipos de Dados
Tipo de dados RAM Intervalo numérico
boolean 1 byte 0 ou 1 (false ou true)
byte 1 byte 0 a 255
char 1 byte -128 a 127
unsigned char 1 byte 0 a 255
int 2 bytes -32.768 a 32.767
unsigned int 2 bytes 0 a 65.535
word 2 bytes 0 a 65.535
long 4 bytes -2.147.483.648 a 2.147.483.647
unsigned long 4 bytes 0 a 4.294.967.295
float 4 bytes -3,4028235E+38 a 3,4028235E+38
double 4 bytes -3.4028235E+38 a 3,4028235E+38
string 1 byte + x Sequência de caracteres
array 1 byte + x Coleção de variáveis
Operadores Lógicos

 E lógico (&&)
 OU lógico (||)
 Negação (!)
Operadores de Comparação

 Igualdade (==)
 Desigualdade (!=)
 Menor que (<)
 Maior que (>)
 Menor ou igual (<=)
 Maior ou igual (>=)
Operadores Aritméticos

 Soma (+)
 Subtração (-)
 Multiplicação (*)
 Divisão (/)
 Resto da divisão (%)
 Atribuição (=)
Estruturas Condicionais

 Switch/case

switch (var) {
case 1:
//realiza ação caso var == 1
case 2:
//realiza ação caso var == 2
default:
// caso nenhum case seja executado, será executado o default
// default é opcional
}
Exercício
 Implemente um algoritmo que acenda um led apenas caso o botão esteja acionado,
utilizando a estrutura switch/case.

const byte botao = 2;

const byte led = 4;
boolean estadoBotao;

void setup() {
pinMode(botao, INPUT);
pinMode(led, OUTPUT);
}

void loop() {
estadoBotao = digitalRead(botao);

switch(estadoBotao) {
case HIGH: digitalWrite(led,HIGH);
break;
case LOW: digitalWrite(led,LOW);
break;
}
}
Estruturas Condicionais

 If/else
if (input < 500)
{
// fazer ação 1
}
else // caso contrário, isto é input >= 500
{
// fazer ação 2
}
Exercício 1

 Crie um circuito com dois botões e um led. O led deverá acender se um

botão ou o outro estiverem pressionados.
Circuito
const byte botao1 = 2, botao2 = 3;

const byte led = 4;

boolean estadoBotao1, estadoBotao2;

void setup() {

pinMode(botao1, INPUT);

pinMode(botao2, INPUT);

pinMode(led, OUTPUT);

void loop() {

estadoBotao1 = digitalRead(botao1);

estadoBotao2 = digitalRead(botao2);

if(estadoBotao1 || estadoBotao2) {

digitalWrite(led, HIGH);

} else {

digitalWrite(led, LOW);

}
Estruturas Condicionais
 If/elseif/else

if (input < 500)

{
// fazer ação 1
}
else if (input >= 1000)
{
// fazer ação 2
}
else
{
// fazer ação 3
}
Estruturas de Repetição

 While

var = 0;
while(var < 200){
//código que se repete 200 vezes
var++;
}
const byte botao = 3;
const byte led = 13;
boolean estadoBotao;

void setup() {
pinMode(botao, INPUT);
pinMode(led, OUTPUT);
}

void loop() { O que faz o código ao lado?

estadoBotao = digitalRead(botao);

while(!estadoBotao) {
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led,LOW);
delay(1000);

estadoBotao = digitalRead(botao);
}
}
Estruturas de Repetição

 Do ... While

do
{
// bloco de intruções

} while (condição);
Estruturas de Repetição

 For

for (inicialização; condição; incremento)

{

//Bloco de instruções

}
Comando Break

 Utilizado para sair de uma estrutura de repetição ignorando a condição

da mesma

for (int x = 0; x <= 255; x++)

{
analogWrite(pino, x);
sens = analogRead(pinoSensor);
if (sens > limite){ // se atingir um limite
break;
}
delay(50);
}
Funções Digitais

 pinMode(pin, mode): função que configura como o pino irá se comportar

(entrada ou saída)
 digitalRead(pin): lê o valor (HIGH ou LOW) de um pino digital especificado
 digitalWrite(pin,valor): escreve um valor HIGH ou LOW no pino digital
especificado
Funções Analógicas

 analogRead(pin): lê o valor de um pino analógico especificado

 O Arduino UNO tem seis entradas/saídas (canais) analógicas com um conversor
analógico-digital de 10 bits
 Com 10 bits: 210 representações – de 0 a 1023
 Assim, o pino analógico pode ler voltagens entre 0V e 5V, usando valores inteiros
entre 0 (0V) e 1023 (5V)
 Resolução de 5V/1024 unidades, ou 4,9 mV por unidade
 analogWrite(pin, valor): escreve “valor” no pino “pin” especificado
 Deve ser utilizado um pino com função PWM (~)
 Resolução de 8 bits: de 0 a 255
Exemplo

// Aumentar o brilho de um LED usando um pino PWM

const byte PWMpin = 10; // LED no pino 10
void setup()
{
pinMode(PWMpin, OUTPUT);
}
void loop()
{
for (int i=0; i <= 255; i++){
analogWrite(PWMpin, i);
delay(10);
}
}