MINICURSO​ ​DE​ ​ARDUINO

Lucas​ ​Ladeira​ ​R.​ ​Bellinazzi

João​ ​Victor​ ​Fabri
2016
 SUMÁRIO

1.​ ​INTRODUÇÃO 2
2.​ ​FUNDAMENTOS​ ​DE​ ​LINGUAGEM​ ​C 2
2.1.​ ​Estruturas 2
2.1.1.​ ​Estruturas​ ​de​ ​Controle 2
2.1.2.​ ​Outras​ ​sintaxes 5
2.1.3.​ ​Operadores​ ​aritméticos 5
2.1.4.​ ​Operadores​ ​de​ ​comparação 6
2.1.5.​ ​Operadores​ ​booleanos​ ​(lógicos) 6
2.1.6.​ ​Operadores​ ​de​ ​acesso​ ​de​ ​ponteiro 6
2.1.7.​ ​Operadores​ ​bit-a-bit 6
2.1.8.​ ​Operadores​ ​Compostos 7
2.2.​ ​Valores 7
2.2.1.​ ​Constantes 7
2.2.2.​ ​Tipos​ ​de​ ​dados 8
2.2.4.​ ​Qualificadores 9
2.3.​ ​Funções 9
2.3.1.​ ​Digital​ ​I/O 9
2.3.2.​ ​Analógica​ ​I/O 9
2.3.3.​ ​Tempo 10
3.​ ​CÓDIGO​ ​MORSE 10
4.​ ​GENIUS 10
FONTES​ ​BIBLIOGRÁFICAS 10
 1.​ ​INTRODUÇÃO
O Projeto Arduino teve início em 2005 na cidade de Ivrea (Itália). Trata-se de uma
plataforma de prototipagem eletrônica de hardware livre, a qual possui uma linguagem de
programação padrão com origem em Wiring e é essencialmente C/C++. O projeto teve início com o
intuito de interagir em projetos escolares de forma a ter um custo menor que outros sistemas de
prototipagem​ ​disponíveis​ ​naquela​ ​época.

2.​ ​FUNDAMENTOS​ ​DE​ ​LINGUAGEM​ ​C

A estrutura de programação do Arduino é constituída por duas funções principais: a ​setup e
a​ ​loop​.
➢ setup( ): Essa é a primeira função a ser chamada quando o programa inicia. E é
executada apenas nessa primeira vez. Esta é uma função de preparação, ela dita o
comportamento​ ​dos​ ​pinos​ ​do​ ​Arduino​ ​e​ ​inicializa​ ​a​ ​porta​ ​serial.
➢ loop( ): É chamada logo a seguir e todas as funções embarcadas nela são repetidamente
executadas. Ela fica lendo os pinos de entrada do Arduino e comandando os pinos de
saída​ ​e​ ​a​ ​porta​ ​serial.
Programas de Arduino podem ser divididos em três partes principais: ​estruturas​, ​valores
(variáveis​ ​e​ ​constantes)​ ​e​ ​funções​.

2.1.​ ​Estruturas
2.1.1.​ ​Estruturas​ ​de​ ​Controle
If - É um controle de fluxo usado para selecionar uma ou mais instruções baseado no
resultado de um ou mais testes de comparação. Todas as entre as chaves são executadas somente se
o resultado dos testes for verdadeiro; caso contrário, essas instruções não são executadas.
Classifica-se como “verdadeiro” qualquer resultado mesmo que negativo que satisfaça as condições
dos​ ​testes.​ ​Exemplo:
 If...else - Ao se acrescentar mais um bloco de instruções no loop do comando ​if pode-se
criar o comando ​if..else​, para fazer um teste novo quando o resultado da expressão for falsa.
Exemplo:

switch...case - É possível inserir comandos ​if...else na posição do segundo bloco de

instruções (​else​) de outro comando ​if...else criando uma estrutura encadeada para testar muitas
expressões. Porém é possível substitui a estrutura ​if..else pelo comando ​switch...case​, simplificando
muito a seleção de comandos. Esse comando compara uma mesma variável inteira (ou uma
expressão​ ​que​ ​retorne​ ​um​ ​inteiro)​ ​com​ ​vários​ ​valores​ ​possíveis.​ ​Exemplo:

for - É usado para repetir um bloco de instruções entre chaves. Um contador de incremento
é normalmente usado para incrementar e encerrar o loop. A instrução ​for é útil para qualquer
operação repetitiva e frequentemente usada em combinação com matrizes para operar em coleções
de​ ​dados/pinos.​ ​Exemplo:
 while - Esta estrutura irá repetir continuamente até que a condição dentro dos parênteses
torne-se falsa. Algo deve mudar a variável testada ou a condição nunca se tornará falsa impedindo
que o loop do ​while seja finalizado; isto poderia ser representado em seu código como uma variável
incrementada​ ​ou​ ​uma​ ​condição​ ​externa​ ​como​ ​o​ ​teste​ ​de​ ​um​ ​sensor.​ ​Exemplo:

do...while - Funciona da mesma forma que a estrutura while porém garante que o bloco de
instruções seja executado ao menos uma vez, isso se deve ao fato de que a condição de repetição
será​ ​testada​ ​apenas​ ​no​ ​final​ ​do​ ​ciclo.​ ​Exemplo:

break - Utilizado para finalizar uma estrutura de repetição (​do​, ​for ou ​while​) ignorando a
condição de ciclo normal. E como visto anteriormente, também usado para saída de uma instrução
switch​.​ ​Exemplo:
 continue - Esta instrução pula o resto da iteração atual de uma repetição (​do​, ​for ou ​while​).
Ele continua checando a expressão condicional e prossegue com as iterações subsequentes.
Exemplo:

return - Terminar uma função e retornar um valor de uma função para a função de
chamada,​ ​se​ ​desejar.​ ​Exemplo:

2.1.2.​ ​Outras​ ​sintaxes

;​ ​(ponto​ ​e​ ​vírgula)​​ ​-​ ​Usado​ ​para​ ​terminar​ ​uma​ ​declaração.
{} (chaves) - Uma chave de abertura "{" deve ser sempre seguido por uma chave de
fechamento​ ​"}".
// (comentário de uma linha) ou ​/* */ (comentário de várias linhas) - Comentários são linhas
no programa que são usados para se informar ou outros sobre a forma como o programa funciona.
Eles​ ​são​ ​ignorados​ ​pelo​ ​compilador​ ​e​ ​não​ ​exportados​ ​para​ ​o​ ​processador.
#define - É um componente útil em C que permite que ao programador dar um nome a um
valor constante antes de o programa ser compilado. Constantes definidas em arduino não ocupam
qualquer espaço de memória no microcontrolador. O compilador irá substituir as referências a essas
constantes​ ​com​ ​o​ ​valor​ ​definido​ ​em​ ​tempo​ ​de​ ​compilação.
 #include - Usado para incluir bibliotecas externas em seu programa. Isto dá ao programador
acesso de um grande grupo de bibliotecas-padrão da linguagem C (grupos de funções
pré-fabricadas)​ ​e​ ​também​ ​às​ ​bibliotecas​ ​escritas​ ​especialmente​ ​para​ ​Arduino.

2.1.3.​ ​Operadores​ ​aritméticos

= (operador de atribuição) - Armazena o valor à direita do sinal de igual na variável à
esquerda​ ​do​ ​sinal​ ​de​ ​igual.
+ (adição)​, ​- (subtração)​, ​* (multiplicação) e ​/ (divisão) - Estes operadores retornam
respectivamente​ ​a​ ​soma,​ ​diferença,​ ​produto​ ​ou​ ​quociente​ ​de​ ​dois​ ​em​ ​dois​ ​operandos.
% (resto de divisão) - Calcula o restante quanto um número inteiro é dividido por outro. Isso
é​ ​útil​ ​para​ ​manter​ ​uma​ ​variável​ ​em​ ​um​ ​intervalo​ ​específico.

2.1.4.​ ​Operadores​ ​de​ ​comparação

==​ ​(igual​ ​a)
!=​ ​(diferente​ ​de)
<​ ​(menor​ ​que)
>​ ​(maior​ ​que)
<=​ ​(menor​ ​que​ ​ou​ ​igual​ ​a)
>=​ ​(maior​ ​que​ ​ou​ ​igual​ ​a)

2.1.5.​ ​Operadores​ ​booleanos​ ​(lógicos)

Os​ ​operadores​ ​booleanos​ ​podem​ ​ser​ ​usados​ ​dentro​ ​da​ ​condição​ ​de​ ​uma​ ​estrutura​ ​if​.
&&​ ​(E​ ​lógico)​​ ​-​ ​Verdadeiro​ ​somente​ ​se​ ​ambos​ ​os​ ​operandos​ ​são​ ​verdadeiros.
||​ ​(OU​ ​lógico)​​ ​-​ ​Verdadeiro​ ​se​ ​pelo​ ​menos​ ​um​ ​operando​ ​for​ ​verdadeiro.
!​ ​(negação)​​ ​–​ ​Verdadeiro​ ​se​ ​o​ ​operando​ ​for​ ​falso​ ​e​ ​vice-versa.

2.1.6.​ ​Operadores​ ​de​ ​acesso​ ​de​ ​ponteiro

Os ponteiros são um dos assuntos mais complicados para iniciantes ao aprender C e é
possível escrever a grande maioria dos programas Arduino sem nunca encontrar ponteiros. No
entanto, para a manipulação de certas estruturas de dados, o uso de ponteiros pode simplificar o
código e o conhecimento da manipulação de ponteiros é útil para ter no seu conjunto de
ferramentas.
 Os​ ​operadores​ ​de​ ​ponteiros​ ​são:
&​ ​(referenciar)
*​ ​(desreferenciar)

2.1.7.​ ​Operadores​ ​bit-a-bit

Os operadores bit-a-bit executam seus cálculos em bits de variáveis. Eles ajudam a resolver
uma​ ​ampla​ ​gama​ ​de​ ​problemas​ ​comuns​ ​de​ ​programação.
&​ ​(E​ ​bit-a-bit)
|​ ​(OU​ ​bit-a-bit)
^​ ​(OU​ ​EXCLUSIVO​ ​bit-a-bit)
~​ ​(NÃO​ ​bit-a-bit)
<<​ ​(mudança​ ​de​ ​bit​ ​à​ ​esquerda)
>>​ ​(mudança​ ​de​ ​bit​ ​à​ ​direita)

2.1.8.​ ​Operadores​ ​Compostos

++​ ​(incremento)
--​ ​(decremento)
+=​ ​(adição​ ​composta)
-=​ ​(subtração​ ​composta)
*=​ ​(multiplicação​ ​composta)
/=​ ​(divisão​ ​composta)
%=​ ​(resto​ ​de​ ​divisão​ ​composta)
&=​ ​(E​ ​bit-a-bit​ ​composta)
|=​ ​(OU​ ​bit-a-bit​ ​composta)

2.2.​ ​Valores
2.2.1.​ ​Constantes
Constantes são expressões pré-definidas na linguagem própria do Arduino. Elas são usadas
para​ ​fazer​ ​os​ ​programas​ ​mais​ ​fáceis​ ​de​ ​ler.​ ​Classificamos​ ​constantes​ ​em​ ​grupos:
➢ Definindo​ ​nível​ ​lógico:​ ​true​ ​ou​ ​false​ ​(constantes​ ​booleanas)
false​​ ​é​ ​definido​ ​como​ ​0​ ​(zero);
 true é frequentemente definido como 1, porém true tem uma definição mais ampla. Qualquer
valor inteiro diferente de zero é true, no que se refere a lógica booleana. Dessa forma -1, 2, -200 são
todos​ ​definidos​ ​como​ ​true​ ​pela​ ​lógica​ ​booleana.

➢ Definindo​ ​nível​ ​de​ ​pino:​ ​HIGH​ ​e​ ​LOW

Quando ler ou gravar um pino digital há apenas dois valores possível atribuídos ao pino:
HIGH​ ​ou​ ​LOW.
HIGH - Quando um pino é configurado como INPUT com pinMode() e lido com
digitalRead(),​ ​o​ ​Arduino​ ​irá​ ​reportar​ ​HIGH​ ​se:
-​ ​Uma​ ​tensão​ ​superior​ ​a​ ​3​ ​volts​ ​está​ ​presente​ ​no​ ​pino​ ​(placas​ ​de​ ​5V);
-​ ​Uma​ ​tensão​ ​superior​ ​a​ ​2​ ​volts​ ​está​ ​presente​ ​no​ ​pino​ ​(placas​ ​de​ ​3,3V).
Quando um pino é configurado com OUTPUT com pinMode() e definido como HIGH com
digitalWrite(),​ ​o​ ​pino​ ​está​ ​em:​ ​5​ ​volts​ ​(placas​ ​de​ ​5V)​ ​ou​ ​3,3​ ​volts​ ​(placas​ ​de​ ​3,3V).
LOW - Quando um pino é configurado como INPUT com pinMode() e lido com
digitalRead(),​ ​o​ ​Arduino​ ​irá​ ​reportar​ ​LOW​ ​se:
-​ ​Uma​ ​tensão​ ​inferior​ ​a​ ​3​ ​volts​ ​está​ ​presente​ ​no​ ​pino​ ​(placas​ ​de​ ​5V);
-​ ​Uma​ ​tensão​ ​inferior​ ​a​ ​2​ ​volts​ ​está​ ​presente​ ​no​ ​pino​ ​(placas​ ​de​ ​3,3V).
Quando um pino é configurado com OUTPUT com pinMode() e definido como HIGH com
digitalWrite(),​ ​o​ ​pino​ ​está​ ​em​ ​0​ ​volts.

➢ Definindo​ ​modo​ ​digital​ ​de​ ​pino:​ ​INPUT,​ ​INPUT_PULLUP​ ​e​ ​OUTPUT

Pinos digitais podem ser usados como INPUT, INPUT_PULLUP ou OUTPUT. Alterando
um​ ​pino​ ​com​ ​pinMode()​ ​muda​ ​o​ ​comportamento​ ​elétrico​ ​do​ ​pino.
INPUT - Pinos configurados com INPUT têm uma demanda extremamente pequena sobre o
circuito de amostragem que são equivalentes a uma resistência em série de 100MΩ. Isto torna-os
úteis​ ​para​ ​a​ ​leitura​ ​de​ ​um​ ​sensor.
INPUT_PULLUP - Monitora o estado de um interruptor através do estabelecimento de
comunicação​ ​serial​ ​entre​ ​o​ ​Arduino​ ​e​ ​o​ ​computador​ ​através​ ​de​ ​entrada​ ​USB.
OUTPUT – Pinos configurados como OUTPUT podem receber uma quantidade substancial
de corrente; estes também podem ser danificados ou destruídos se estiverem ligados ao terra ou à
alimentação.
 2.2.2.​ ​Tipos​ ​de​ ​dados
void (vazio) - Usado apenas em declaração de funções. Ele indica que a função espera
nenhuma​ ​informação​ ​para​ ​retornar​ ​a​ ​partir​ ​da​ ​qual​ ​foi​ ​chamado.
boolean (booleano) - Uma variável booleana possui um dos dois valores: verdadeiro (true)
ou​ ​falso​ ​(false).​ ​Cada​ ​variável​ ​booleana​ ​ocupa​ ​um​ ​byte​ ​de​ ​memória.
char (caractere) - Este tipo de dado armazena um valor de caractere que ocupa um byte de
memória.
int​​ ​(inteiro)​ ​-​ ​é​ ​o​ ​tipo​ ​de​ ​dado​ ​primário​ ​para​ ​armazenar​ ​números.
unsigned int (inteiro sem sinal) - armazena valor numérico inteiro e positivo que ocupa de 2
a​ ​4​ ​bytes​ ​de​ ​memória.
float (real) - armazena valor de números com parcela decimal ou ponto flutuante que ocupa
4​ ​bytes​ ​de​ ​memória.
double - semelhante à float, a diferente é o tamanho do número que este tipo de dado é capaz
de armazenar, ocupa 4 bytes de memória no Arduino Uno podendo armazenar um número que
ocupe​ ​até​ ​8​ ​bytes​ ​em​ ​outras​ ​placas.

2.2.4.​ ​Qualificadores
static (estático) - Uma variável declarada como ‘static’ só será criada e inicializada pela
primeira quando a função é chamada. Usada quando for necessário que a variável local de uma
função permaneça com o seu valor mantido, permitindo assim na próxima chamada utilizar o valor
anterior.
volatile (volátil) - Uma variável volátil indica ao compilador que a variável pode ser
modifica sem o conhecimento do programa principal. Dessa forma, o compilador não pode prever
com segurança se pode otimizar trechos de programa onde esta variável se encontra. No Arduino, o
único lugar que este é provável de ocorrer é em seções de código associados com interrupções,
chamado​ ​de​ ​uma​ ​rotina​ ​de​ ​interrupção​ ​do​ ​serviço.
const​​ ​(constante)​ ​–​ ​Permite​ ​que​ ​a​ ​variável​ ​não​ ​possa​ ​mais​ ​ser​ ​alterada​ ​depois​ ​de​ ​declarada.

2.3.​ ​Funções
A segmentação do código em funções permite ao programador criar módulos de código que
executam uma tarefa definida e em seguida retornar a uma área específica do código da qual a
função foi chamada. O típico caso de criação de uma função ocorre quando é necessário executar
uma​ ​ou​ ​mais​ ​ações​ ​várias​ ​vezes​ ​em​ ​um​ ​programa.

2.3.1.​ ​Digital​ ​I/O

pinMode()​​ ​-​ ​Configura​ ​o​ ​pino​ ​especificado​ ​como​ ​uma​ ​entrada​ ​ou​ ​uma​ ​saída.
digitalWrite()​​ ​-​ ​Grava​ ​um​ ​valor​ ​HIGH​ ​ou​ ​LOW​ ​em​ ​um​ ​pino​ ​digital.
digitalRead()​​ ​-​ ​Lê​ ​o​ ​valor​ ​de​ ​um​ ​pino​ ​digital​ ​específico,​ ​podendo​ ​ser​ ​este​ ​HIGH​ ​ou​ ​LOW.

2.3.2.​ ​Analógica​ ​I/O

analogReference() - Configura a tensão de referência utilizada para a entrada analógica
(valor​ ​utilizado​ ​como​ ​a​ ​parte​ ​superior​ ​do​ ​intervalo​ ​de​ ​entrada).
analogRead()​​ ​-​ ​Lê​ ​o​ ​valor​ ​de​ ​um​ ​pino​ ​analógico​ ​específico.
analogWrite() - Grava um valor analógico (onda PWM) em um pino. Pode ser usado para
acender um LED com intensidades diferentes ou conduzir um motor com várias velocidades. A
frequência do sinal PWM na maioria dos pinos é de aproximadamente 490Hz. Nas placas Uno e
similares,​ ​pinos​ ​5​ ​e​ ​6​ ​têm​ ​uma​ ​frequência​ ​de​ ​aproximadamente​ ​980Hz.
 2.3.3.​ ​Tempo
delay() - Pausa o programa por uma quantidade de tempo (em milissegundos) especificada
como​ ​parâmetro​ ​(Há​ ​1000​ ​milissegundos​ ​em​ ​um​ ​segundo).
millis() - Retorna o número de milissegundos desde que a placa Arduino começou a rodar o
programa​ ​atual.​ ​Este​ ​número​ ​terá​ ​‘overflow’​ ​(voltar​ ​para​ ​zero)​ ​após​ ​cerca​ ​de​ ​50​ ​dias.

3.​ ​CÓDIGO​ ​MORSE

4.​ ​GENIUS

FONTES​ ​BIBLIOGRÁFICAS
MONK, Simon. Programação com Arduino: começando com Sketches. Porto Alegre:
Bookman,​ ​2013.
MONK,​ ​Simon.​ ​30​ ​projetos​ ​com​ ​Arduino.​ ​2ª​ ​ed.​ ​Porto​ ​Alegre:​ ​Bookman,​ ​2014.
www.arduino.cc