Escola Técnica e Profissional do Ribatejo

Manual de Programação para

Arduino

Luís Magalhães
Introdução
Este pequeno manual destina-se apenas a ser utilizado como uma lista, de acesso rápido, de
algumas das instruções mais utilizadas na programação da placa Arduino. Assim, deve
considerar-se apenas como uma pequena introdução à programação da placa. Para aqueles
que pretendem explorar todos os recursos da Arduino recomenda-se outros manuais que
podem ser encontrados com grande facilidade na Internet.
A Placa Arduíno
Para melhor compreender o método de programação da placa Arduino deve começar-se por
entender como ele interage com o exterior. Deste modo, o primeiro passo deve consistir em
conhecer as suas portas, ou pinos, e quais as suas caraterísticas.
A seguinte figura ilustra os componentes mais importantes para a compreensão dos métodos
de programação para a entrada e saída de dados.

Pinos Digitais – pinos usados para a entrada/saída de sinais digitais

Pinos Analógicos- pinos usados para a entrada de sinais analógicos
Porta Serie – porta que permite a ligação da placa Arduino ao computador
Estrutura básica de um programa Arduino

A linguagem de programação para Arduino , inspirada na linguagem C, assenta numa estrutura

bastante simples. Como tal, um programa para Arduino é sempre composto por duas funções
essenciais: setup() e loop(). O seguinte exemplo, apesar de muito simples, demonstra como é
estruturado um programa para Arduino:

/*
* Olá Mundo!
*
* isto é o olá Mundo para Arduino.
* a mensagem será apresentada no ecrã do computador
*/

void setup() // executado uma vez. Quando o programa inicia

{
Serial.begin(9600); // define a velocidade da porta 9600 bps
}

void loop() // repete infinitamente

{
Serial.println("Olá Mundo!"); // escreve a mensagem e salta linha
delay(1000);
}

Esquema geral de um programa para Arduino

Declaração de variáveis globais;

Void setup() {
Instrução 1; // conjunto de instruções a serem
Instrução 2; // executadas apenas uma vez como a iniciação dos pinos a utilizar
(…)
}
Void loop() {
Instrução 3; // conjunto de instruções executadas
Instrução 4; // num ciclo
(…)
}
A Função setup()
Consiste na primeira função a ser executada num programa Arduino e é chamada apenas uma
vez. Este bloco é essencialmente dedicado a iniciar os pinos digitais e analógicos, e também a
porta serie.

A função loop()
Define o corpo principal do programa. Assim, todas as instruções que interagem com os pinos,
ciclos, operações matemáticas, entre outras, são colocadas no interior desta função. Isto não
faz regra, se se optar por criar subfunções para melhor modular o programa. No entanto, a
chamada a essas subfunções deve constar dentro desta função principal.
Tal como o seu nome indica, todas as instruções contidas nesta função são repetidas de forma
cíclica.

Símbolos
{ } – Chavetas: contém as instruções que a função deve executar
; - Ponto e vírgula: define o fim de uma instrução
// - Duas barras: comentário de linha
/* …*/ - Barra e asterisco: comentário com várias linhas

Constantes
São valores predefinidos que nunca podem ser alterados.
Existem 3 tipos de constantes:
TRUE/FALSE – constantes booleanas
HIGH/LOW – define a tensão dos pinos digitais (high – 5 volts; low – 0 volts)
INPUT/OUTPUT – constantes definidas pela função pinMode():
input para entrada no pino e output para saída do pino

Exemplos:
pinMode (10,OUTPUT);
digitalWrite(13, HIGH);
Variáveis
Variáveis Globais – São variáveis que que podem ser usadas em qualquer função do programa
Qualquer variável tem de ser declarada antes de ser chamada. Por isso, a sua definição é
efetuada antes do bloco setup().
A declaração consiste em definir um tipo e um nome à variável.

Tipos de Variáveis
byte – 8 bits (0-255)
int – número inteiro até 16 bits
long – número inteiro até 32 bits
float – número real até 32 bits
boolean – valor lógico que pode assumir dois estados: true ou false
char- apenas armazena um único carácter. Guarda o valor decimal correspondente a um
determinado caráter na tabela ASCII.

Exemplos:
char exemplo = ’A’; / /variável exemplo do tipo char com o caráter “A”
char exemplo = 78; // corresponde ao caráter “N”, segundo a tabela ASCII
byte exemplo = 1; // armazena o valor 1 em decimal

Matrizes
Chama-se matriz, ou array, a um conjunto de variáveis do mesmo tipo. Um valor está
armazenado num determinado espaço de memória que é representado por um identificador
denominado de índice. O primeiro elemento de uma matriz tem o índice 0.
Sintaxe:
Tipo_de_variável nome_variavel[índice] = valor;
Declaração de uma matriz:
Int vetor[] = {16,17,10,45};
Declaração de uma matriz (outra forma):
Int vetor [3];
Escrever numa matriz:
Vetor [3] = 12; //guarda na 4ª posição o valor 12
Ler de uma matriz
Int x =vetor[4];
Operadores

Aritméticos
+ Adição
- Subtração
* Multiplicação
/ Divisão

Lógicos
&& E (and)
|| Ou (or)
! Não (not)

Relacionais

== Igual
!= Diferente
< Menor
> Maior
<= Menor ou igual
>= Maior ou igual

Símbolos compostos

x++ x=x+1
x-- X=x-1
x+=y x=x+y
x-=y x=x-y
x*=y x=x*y
x/=y x=x/y
Funções de tempo

Função Descrição Notas

Pára a execução do
programa por um
delay(ms) determinado período de 1 segundo = 1000ms
tempo, dado em
milissegundos
Pára a execução do
programa por um
delayMicroseconds(us) determinado período de 1 ms = 1000us
tempo, dado em
microssegundos
Retorna um número, em long valor = millis()
milissegundos, desde que o valor-variável do tipo long
millis() programa está em execução que guarda o tempo desde
que o programa está em
execução

Funções matemáticas

Função Descrição Notas

Função que permite gerar min – Valor mínimo possível
random(min,max) números aleatórios. (opcional- 0)
max – valor máximo possível
Devolve o valor absoluto de
abs(x) Var_modulo = abs(valor)
um número real
Devolve o menor de dois
min(valor1, valor2) Var_menor = min(5,3)
valores
Devolve o maior de dois
max(valor1, valor2) Var_maior = max(5,3)
valores
Devolve a raiz quadrada de
Sqrt(valor) Res = sqrt(valor)
valor

Outras funções
Função Descrição Notas
Valor – variável que contem o
Converte uma valor a ser convertido
Min1 e max1 - valores reais
faixa de valores
Map(valor,min1,max1,min2,max2) mínimos e máximos da
numa outra faixa variável;
definida Min2 e max2 – valores mínimos
e máximos após a conversão
Exemplo:
Int valor = map(analogRead(A0),0,1023,0,255);
Converte o valor analógico lido pelo pino A0, que pode oscilar entre 0 e 1023, num outro valor
balizado entre 0 e 255;
Pinos Digitais
Consistem em 14 pinos marcados com o título DIGITAL e permitem a entrada e saída de
valores lógicos digitais. Estes valores podem ser representados por 0v ou 5v; verdadeiro ou
falso; I/O; HIGH/LOW. Os pinos 6 a 9 podem ser utilizados para aplicar o mecanismo PWM.

Função Descrição Notas

Serve para definir o pino a
Pino - número do pino a ser
ser utilizado e qual o sentido
utilizado;
do fluxo de informação.
pinMode(pino,modo) Modo – INPUT para entrada e
Esta Função deve constar OUTPUT para saída
sempre dentro da função
Setup()
Permite ler o valor recebido O pino de ser configurado
digitalRead(pino) por um determinado pino e anteriormente com a função
colocá-lo numa variável pinMode()
Modo – HIGH para 5 Volts e 0
Permite que um volts para LOW
digitalWrite(pino,modo) determinado pino envie um O pino deve ser configurado
valor digital para o exterior anteriormente com a função
pinMode()
Pino - número do pino a ser
Permite gerar tensões utilizado;
Valor- define a amplitude de
analógicas em pinos digitais.
analogWrite(pino,valor) tensão que pode ser de 0 (0
Apenas os pinos PWM volts) a 255 (5 volts).
suportam esta função Não é necessário fazer a
iniciação com pinMode()
Exemplo 1:

/*
Pisca
O led acende durante um segundo, depois, apaga durante mais um segundo, repetindo
infinitamente
*/

// Pino 13 já contém um led na própria Arduino.

// Iniciamos a variável led com o valor 13 que corresponde ao pino digital 13:
int led = 13;

// a função setup é novamente chamada quando se prime o botão Reset:

void setup() {
// Iniciamos o pino 13 para saída.
pinMode(led, OUTPUT);
}

// repete infinitamente:
void loop() {
digitalWrite(led, HIGH); // Liga o Led (HIGH corresponde a uma saída de 5 volts)
delay(1000); // espera um segundo
digitalWrite(led, LOW); // desliga o led (LOW corresponde a uma saída de 0 volts)
delay(1000); // espera um segundo
}
Exemplo 2:

/*
Acende e apaga o led do pino 13, consoante se carrega, ou não, no botão ligado ao pino
digital 2
*/

// Definição dos pinos como constantes

const int buttonPin = 2; // o número do pino do botão
const int ledPin = 13; // o número do pino do led
int buttonState = 0; // variável que armazena o estado do botão

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT); // inicia o pino do botão para input:
}

void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
Porta Serie

A comunicação é efetuada através da porta USB. Deste modo, é possível a comunicação em

tempo real entre a Arduino e um computador. A transmissão de dados com o PC pode ser
realizada de forma simples com o recurso à ferramenta Terminal existente no IDE de
desenvolvimento.
Além disso, é possível a comunicação com a Arduino recorrendo a linguagens de programação
como Java, Processing, Python, entre outras.

Funcões Descrição Notas

Inicia a comunicação Serie e define Pode usar valores como
a velocidades de transmissão de 300, 2400, 9600,
Serial.begin() dados 115200, além de muitos
outros. O mais comum é
9600
Desativa a porta serie para que Esta função deve ser
seja possível a utilização dos pinos declarada dentro da
Serial.end() função setup()
digitais 0 e 1 para entrada e saída
de dados
Determina o número de bytes que Int val = serial.read();
são recebidos por série. Assim, Val guarda o primeiro
Serial.available() byte disponível na porta
permite determinar se estão a ser
recebidos dados ou não serial
Lê o primeiro byte do buffer da Retorna o valor -1
Serial.read() porta serie quando não há valores
disponíveis
Envia para a porta serie dados em Os dados podem ser
ASCII. O formato especifica o vistos através do
Serial.print(valor,formato) número de casas decimais ou base terminal do IDE da
numérica do número a ser Arduíno
transmitido
O mesmo que a anterior mas neste
Serial.println(valor,formato)
caso salta uma linha
Exemplo

void setup() {
// inicializa a porta serie e espera pela sua abertura
Serial.begin(9600);

// imprime um titulo
Serial.println("Tabela ASCII");
}
// primeiro caráter '!' corresponde ao valor 33:
int thisByte = 33;
// também poderia ser: int thisByte = '!';
void loop() {

// vai escrever o valor ASCII correspondente a 33

Serial.write(thisByte);

Serial.print(", dec: ");

// imprime os dados como string em dec
// mudamos para Serial.print() ou Serial.println()

Serial.print(thisByte);
// também se poderia fazer da seguinte forma
// Serial.print(thisByte, DEC);

Serial.print(", hex: ");

// imprime o valor como string em hexadecimal
Serial.print(thisByte, HEX);

Serial.print(", oct: ");

// imprime o valor em octal
 Serial.print(thisByte, OCT);

Serial.print(", bin: ");

// imprime o valor em binário
// e salta uma linha
Serial.println(thisByte, BIN);

// quando imprimir o caráter '~' ou 126, pára:

if(thisByte == 126) {
// entra em loop
while(true) {
continue;
}
}
// avança um caráter
thisByte++;
}
Pinos analógicos
São constituídos por 6 pinos e estão denominados na placa como ANALOG IN. Estes pinos
estão numerados de 0 a 5 e podem aceitar valores entre 0 a 5 volts. Ao contrário dos pinos
digitais, que permitem a entrada e saída de valores, os analógicos apenas permitem a receção
de valores. Para situações em é necessário o envio de valores analógicos, a Arduino recorre a
uma funcionalidade denominada PWM. Este mecanismo consiste em utilizar algumas das
portas digitais (9, 10 e 11) para a simulação de saídas analógicas. A explicação do
funcionamento do PWM foge do contexto deste manual.

Lê o valor analógico que O âmbito dos valores é de 0 (0

volts) a 1023 (5 volts).
entra na porta, permitindo,
analogRead(pino) Os pinos podem ser
ainda, guardá-lo numa representados de A0 a A5 ou 14
variável. a 19

Exemplo 1
/*

Lê um valor capturado pela porta analógica A0 e apresenta-o no monitor

Ligar o pino A0 ao pino central do potenciómetro, um dos laterais a +5V e o outro a gnd

*/

void setup() {
// inicia a porta serie com uma velocidade de 9600 bits por segundo:

Serial.begin(9600);
}
void loop() {
// lê o valor que entra na porta analógica 0 (A0)

int sensorValue = analogRead(A0);

// escreve o valor lido

Serial.println(sensorValue);
delay(1); // pausa de 1 milessegundo
}
Exemplo 2
/*

Entrada analógica

Liga-se o pino analógico 0 ao pino do meio do potenciómetro.

Liga-se um pino lateral do potenciómetro ao pino 5v da Arduino

Liga-se o outro pino lateral do potenciómetro ao pino gnd da Arduino

O potenciómetro vai controlar o tempo em que o led se matem aceso ou apagado

*/

int sensorPin = A0; // A0 corresponde ao pino analógico 0

int ledPin = 13; // pode ser o led da Arduino

int sensorValue = 0; // variavel que guarda o valor da Arduino

void setup() {
// declara o ledPin para OUTPUT:

pinMode(ledPin, OUTPUT);
}

void loop() {
// Lê o valor do sensor
sensorValue = analogRead(sensorPin);
// acende o led
digitalWrite(ledPin, HIGH);
// interrompe o processo durante o tempo definido por sensorValue
delay(sensorValue);
// apaga o Led
digitalWrite(ledPin, LOW);
// interrompe o processo durante o tempo definido por sensorValue
delay(sensorValue);
}
Decisão

If
If (expressão) {
conjunto de instruções;
}
A instrução if impõe a execução do conjunto de instruções, se a expressão for verdadeira. Caso
contrário não executa a instrução

If … else
If (expressão) {
conjunto de instruções 1;
}
else {
conjunto de instruções 2;
}
A instrução if impõe a execução do conjunto de instruções 1 , se a expressão for verdadeira.
Caso contrário executa o conjunto de instruções 2

Switch
Switch (expressão) {
case 1: conjunto de instruções 1;
break;
case 2: conjunto de instruções 2;
break;
case 3: conjunto de instruções 3;
break;
default: conjunto de instruções 4;
}
A instrução switch é um teste de decisão múltipla, que numa sequência de instruções decide a
partir de qual começa a execução. A execução do conjunto de instruções n começa quando for
encontrado um valor do case coincidente com o valor da expressão.
Ciclos

While

While (expressão) {
conjunto de instruções;
}
Enquanto a expressão for verdadeira, o corpo do ciclo while é executado.

do… while

do {
conjunto de instruções;
}
while (expressão);

O ciclo do…while difere da instrução while pelo facto de o conjunto de instruções ser
executado pelo menos uma vez, dado que o teste à expressão só e efetuado após a conclusão
do ciclo.

for
For (variável; expressão; incremento){
conjunto de instruções;
}
A variável é iniciada normalmente com 0 ou 1. O parâmetro expressão deve conter o valor
máximo, ou mínimo, que o contador de atingir. incremento é o valor a ser incrementado à
variável cada vez que o bloco de instruções é executado.

Exemplo:
for (int i = 0; i <= 10; i++){
serial.println(contador);
delay(1000);
}
Exemplo da utilização do mecanismo de decisão IF:
/*

Exemplifica a utilização do IF

Lê um determinado valor de um potenciómetro, ligando ou desligando um led

Consoante esse valor

Pino central do led ligado a A0

Pinos laterais ligados a +5v e gnd

*/

const int analogPin = A0;

const int ledPin = 13;
const int limite = 400; // é estabelecido um valor limite

void setup() {
// inicia o pino do led para output:

pinMode(ledPin, OUTPUT);
// inicia a comunicação serie:

Serial.begin(9600);
}
void loop() {
// lê o valor do potenciómetro:

int analogValue = analogRead(analogPin);

// se ultrapassar o valor limite, acende o led

if (analogValue > limite) {

digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin,LOW);
}
// apresenta no terminal o valor do potenciómetro:

Serial.println(analogValue);
delay(1);
}
Exemplo com o ciclo for:
Fazer música

#define BUZZER 9
int notas[] = { 524, 588, 660, 699, 785, 881, 989 };
void setup() {
pinMode(BUZZER, OUTPUT);
}
void loop() {
for (int i = 0; i < 7; i++) {
tone(BUZZER, notas[i], 1000);
delay(1000);
}
delay(1000);
}
Exemplo de entrada de dados pela porta serial

int led1 = 9;
int led2 = 10;
char var;
void setup() {
Serial.begin(9600);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop() {
if (Serial.available() > 0) {
var = Serial.read();
switch (var) {
case 'a':
digitalWrite(led1, HIGH);
break;
case 'b':
digitalWrite(led2, HIGH);
break;
}
}
}