Minicurso Arduino

Mini-Curso
ARDUINO
Sensores & Ethernet Shield
Evandro Preuss
Frederico Westphalen, 2016

SUMÁRIO
Kit Arduino ................................................................................................................................................................................. 2

Conceitos Fundamentais.............................................................................................................................................................. 3
Arduino .................................................................................................................................................................................. 3
Programação ............................................................................................................................................................................... 6
Arduino IDE ........................................................................................................................................................................... 6
Estrutura Básica do Código ................................................................................................................................................. 7
Comandos Importantes ........................................................................................................................................................ 8
Funções ................................................................................................................................................................................. 9
Bibliotecas ............................................................................................................................................................................. 9
Resumo da Linguagem C ...................................................................................................................................................10
Componentes .............................................................................................................................................................................12
Matriz de Contato ................................................................................................................................................................12
Jumpers ................................................................................................................................................................................13
Led ........................................................................................................................................................................................13
Resistor.................................................................................................................................................................................14
Botão.....................................................................................................................................................................................15
Buzzer...................................................................................................................................................................................15
Ethernet Shield ....................................................................................................................................................................16
Referências Bibliográficas..........................................................................................................................................................16
Sites Especializados ...................................................................................................................................................................16
Exemplos ...................................................................................................................................................................................17
Semáforo ..............................................................................................................................................................................17
Som no Arduino ...................................................................................................................................................................18
Sensor de Temperatura ......................................................................................................................................................19
Botão que Liga-Desliga Led ...............................................................................................................................................21
Experimentos .............................................................................................................................................................................22
Servidor Web Básico que mostra os valores nas portas analógicas .............................................................................22
Servidor Web que mostra temperatura e permite ligar e desligar led ............................................................................24
Cliente Web que chama uma página php para inserir a temperatura numa base MySQL ..........................................27
Programa que acessa diretamente a base MySQL para inserir a temperatura ............................................................29
2 7º eati – Encontro Anual de Tecnologia da Informação
Kit Arduino
Imagem Descrição
Placa de Prototipagem compatível com Arduino UNO Rev 3
Cabo USB (para ligar o Arduino ao computador)
Matriz de contato (Protoboard)
Jumpers
Leds Coloridos
Leds Transparentes
Resistores
Botões
Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 2

Sensor de Temperatura – LM35
Sensor de Luminosidade -
Buzzer Contínuo
Conceitos Fundamentais
Arduino
Arduino é um projeto de hardware livre. Se constitui como uma plataforma de prototipagem

eletrônica que utiliza um microcontrolador de placa única e que pode ser programado por meio da
linguagem de programação C/C++. É formada por sistemas digitais ligados a sensores e atuadores, que
permitem construir sistemas que percebam a realidade e respondem com ações físicas, baseada em uma
simples placa de Entrada/Saída microcontrolada.
Nasceu na Itália com o objetivo de oferecer uma ferramenta acessível, de baixo custo e flexível
para o desenvolvimento de projetos.
A placa Arduino pode ser utilizada de forma independente (alimentada por pilhas, bateria ou fonte
de 7 a 12V) ou então conectada ao computador por meio de uma interface USB. Componentes adicionais
conhecidos como Shields podem ser acoplados ao Arduino lhe possibilitando, por exemplo, se conectar a
rede, comunicar-se com outro Arduino, gravar dados em um cartão de memória, etc.
Seu Hardware consiste basicamente em um microcontrolador Atmel AVR de 8 bits que pode
inclusive ser retirado da “placa mãe”. A placa Arduino UNO que compõe este kit tem um clock de 16 Mhz
e disponibiliza 32 Kb de memória flash para armazenar o software “programado” pelo usuário (sendo 2
Kb utilizados pelo bootloader). A memória SDRAM é de 2 KB sendo que no momento em que perde a
alimentação de energia é automaticamente zerada. A figura a seguir ilustra uma placa Arduino UNO

Arduino NANO

As principais Conexões do Arduino Uno são:
Permite que os shields

conheçam a voltagem dos IOREF Referência de tensão para entradas
pinos I/O AREF analógicas. Usados com
Envie o valor LOW para analogReference().
RESET
reiniciar o microcontrolador
Alimentação de 3,3 V GND Ground - pino terra
fornecida pelo controlador
3.3V
USB). A corrente máxima é 13 Entrada ou Saída Digital
de 50 mA
A fonte de alimentação 5V 12 Entrada ou Saída Digital
utilizada para o Entrada ou Saída Digital.
ARDUINO
5V ~11
microcontrolador e para outros Fornecem uma saída analógica PWM de
POWER
componentes ~10 8-bit com a função
Ground - pino terra GND ~9 analogWrite().
Ground - pino terra GND 8 Entrada ou Saída Digital
DIGITAL (PWM~)
Entrada de alimentação para 7 Entrada ou Saída Digital
o Arduino. Você pode fornecer
alimentação por este pino ou, ~6 Entrada ou Saída Digital. Fornecem uma
Vin saída analógica PWM de 8-bit com a
UNO
se usar o conector de
alimentação, acessar a ~5 função analogWrite().
alimentação por este pino 4 Entrada ou Saída Digital
Entrada ou Saída Digital. Fornecem uma
~3 saída analógica PWM de 8-bit com a
Entradas analógicas. A0
função analogWrite().
Cada uma delas está A1
ANALOG IN
2 Entrada ou Saída Digital

ligada a um conversor
A2 Entrada ou Saída Digital
analógico-digital de 10 bits,
A3 TX1 Usado para transmitir (TX) dados seriais
que transformam a leitura TTL
analógica (0 a 5V) em um A4 Entrada ou Saída Digital
valor entre 0 a 1023. RX0 Usado para receber (RX) dados seriais
A5 TTL

Programação
Arduino IDE
O projeto Arduino prevê não só a placa para prototipação mas também um IDE (Integrated
Development Environment ou Ambiente Integrado de Desenvolviemnto). O IDE é escrito em Java o que
permite ao desenvolvedor utilizar qualquer plataforma de sistema opercional para desenvolver (MS
Windows, Linux ou MAC). O ambiente é bastante simples e por meio de sua interface principal podemos
realizar as seguitnes operações:
Compilar o código e verificar se o mesmo está correto (essa ação não envia o código para o
Arduino, apenas faz a verificação do mesmo no próprio computador);
Compilar e enviar, neste caso além de compilar o código será empacotado e gravado na
memória Flash do Arduino.
Cria um novo sketch (esboço) que vem a ser um projeto do Arduino.
Abre um sketch existente.
Salva o código do sketch no computador.
Abre a janela do monitor serial através da qual é possível se comunicar com o Arduino
enviando informações seriais ou recebendo dados seriais (como strings, por exemplo)
A imagem a seguir ilustra o IDE do Arduino e suas principais funcionalidades:
Além das ações também há uma área para edição do código (ao centro) e uma área de mensagens
de erro (na parte inferior). É através dessa mensagem que podemos saber se a compilação funcionou,
qual o tamanho do executável ou eventualmente conseguir alguma pista sobre onde estão os erros de
sintaxe do código.

Estrutura Básica do Código
A sintaxe utilizada pela linguagem para programar o Arduino é equivalente à linguagem c em alto
nível (podemos dizer que é basicamente linguagem c com algumas interfaces de programação prontas e
também com algumas limitações aos comandos tradicionais da linguagem c). Programar para o Arduino
consiste basicamente em codificar duas funções: setup() e loop(). A primeira é chamada uma única vez
quando o Arduino é ligado e normalmente é utilizada para inicializar o estado das portas, variáveis
auxiliares, etc. A segunda é executada infinitamente enquando o Arduino estiver energizado.
O código a seguir é um exemplo clássico que faz piscar um led ligado à porta digital 13 (que
acompanha o Arduino). Observe as funções setup() e loop() sendo implementadas:
# define LED_PIN 13 //Cria uma constant de nome LED_PIN e valor 13
void setup () {
pinMode (LED_PIN, OUTPUT); // habilita o pino 13 para saída digital (OUTPUT).
}
void loop () {
digitalWrite (LED_PIN, HIGH); // liga o LED.
delay (1000); // espera 1 segundo (1000 milissegundos).
digitalWrite (LED_PIN, LOW); // desliga o LED.
delay (1000); // espera 1 segundo.
}
O código acima não é diretamente enviado para o Arduino, o processo de compiliação utiliza o
código feito pelo usuário para compor o código da aplicação que será enviado, a seguir veja o código final
que é compilado e enviado ao Arduino, observe que as funções setup() e loop() são aproveitadas:
# include "WProgram.h"
# define LED_PIN 13
void setup () {
pinMode (LED_PIN, OUTPUT); // habilita o pino 13 para saída digital (OUTPUT).
}
void loop () {
digitalWrite (LED_PIN, HIGH); // liga o LED.
delay (1000); // espera 1 segundo (1000 milissegundos).
digitalWrite (LED_PIN, LOW); // desliga o LED.
delay (1000); // espera 1 segundo.
}
int main(void)
{
init(); // Função que inicializar o Arduino (interna)
setup();// Função do usuário que configura o Arduino

Estrutura do código
for (;;) //Laço infinto para chamar a função loop() principal do Arduino
loop();
return 0;
}

Comandos Importantes
A seguir vamos apresentar a sintaxe dos principais comandos que podem ser utilizados na
programação com o Arduino.
 pinMode(numero_do_pino, MODO);
Configura um determinado pino como INPUT (entrada) ou OUTPUT (saída).
Ex.: pinMode(10, OUTPUT); //Configura o pino 10 como saída
pinMode(8, INPUT); //Configura o pino 8 como entrada
 digitalWrite(numero_do_pino, VALOR);
Escreve em um pino digital configurado como saída os valores 0 (LOW) ou 1 (HIGH)
Ex.: digitalWrite(10, LOW); //Desliga a energia do pino 10
digitalWrite(8, HIGH); //Liga a energia do pino 8
 digitalRead(numero_do_pino);
Retorna o valor digital presente no pino informado
Ex.: int x = digitalRead(10); //Guarda em x o valor lido do pino 10
 analogWrite(numero_do_pino, VALOR);
Escreve em um pino (analógico ou PWM) configurado como saída um valor entre 0 e 1023
Ex.: int x = analogWrite(A0, 50); //Grava o valor 50 no pino A0
 analogRead(numero_do_pino);
Retorna o valor analógico presente no pino informado
Ex.: int x = analogRead(A0); //Guarda em x o valor lido do pino A0
 tone(numero_do_pino, frequencia)
Utilizado para produzir um som de determinada freuuência em um buzzer ou alto-falante ligado ao pino
especificado. A frequencia é medida em Hz, o ouvido humano não consegue escutar frequências inferiores
à 20 Hz ou superiores à 20.000 Hz (aproximadamente). As notas musicais básicas tem as seguintes
frequências: dó - 256 Hz, ré - 288 Hz, mi - 320 Hz, fá - 341.3 Hz, sol - 384 Hz, lá - 426.7 Hz, si - 480 Hz.
Ex.: tone(7, 256); //Envia a nota dó para o alto-falante ligado no pino 7
 noTone(numero_do_pino)
Suspende a ação do comando tone() no pino especificado.
Ex.: noTone(7); //Suspende a frequencia enviada para o pino 7
 delay(milissegundos)
Aguarda um determinado número de milissegundos.
Ex.: delay(1); //Aguarda 1 segundo
 Serial.begin(velocidade)
Inicia a comunicação serial com a velocidade informada
Ex.: Serial.begin(9600); //Inicia a comunicação serial com 9600 bps
 Serial.print( val ) e Serial.println( val )

Envia um valor ASCII para a saída serial com ou sem o sinal de quebra de linha.
Ex.: Serial.prinln(“Olá Mundo”);

Funções
As principais funções são:

 Digital I/O
o pinMode() digitalWrite() digitalRead()
 Analógico I/O
o analogReference() analogRead() analogWrite() - PWM
 Avançaado I/O
o tone() noTone() shiftOut() pulseIn()
 Tempo
o millis() micros() delay() delayMicroseconds()
 Matemática
o min() max() abs() constrain() map() pow() sqrt()
 Trigonométrica
o sin() cos() tan()
 Números aleatórios
o randomSeed() random()
 Bits e Bytes
o lowByte() highByte() bitRead() bitWrite() bitSet() bitClear() bit()
 Interrupções externas
o attachInterrupt() detachInterrupt()
 Interrupções
o interrupts() noInterrupts()
 Comunicação Serial
o Serial.begin() Serial.print() Serial.println() Serial.read()
Bibliotecas
O uso de bibliotecas proporciona ampliar a programação usando rotinas prontas. Lembrando

que, para se fazer uso de uma biblioteca esta já deve estar instalada e disponível no seu
computador. As principais bibliotecas disponíveis são:
o EEPROM - leitura e escrita de armazenamento permanente.
o Ethernet - para se conectar a uma rede Ethernet usando o Arduino Ethernet Shield.
o Firmata - para se comunicar com os aplicativos no computador usando o protocolo
Firmata.
o LiquidCrystal - para controlar telas de cristal líquido (LCDs).
o Servo - para controlar servo motores.
o SPI - para se comunicar com dispositivos que utilizam barramento Serial Peripheral
Interface (SPI).
o SoftwareSerial - Para a comunicação serial em qualquer um dos pinos digitais.
o Stepper - para controlar motores de passo.
o Wire - Two Wire Interface (TWI/I2C) para enviar e receber dados atrav es de uma
rede de dispositivos ou sensores.

Resumo da Linguagem C
A seguir vamos apresentar a sintaxe de alguns comandos importantes que podem ser utilizados
na programação com o Arduino.
Estrutura básica de uma aplicação
#include <NomeDaBiblioteca.h> //inclui uma biblioteca
#define PI 3.14 //declaração de constantes
int a; //declaração de variáveis globais
float funcao_exemplo() { Tipos Primitivos

return 10; Tipo Tamanho Valores válidos
} char 1 byte -128 a 127
unsigned char 1 byte 0 a 255
void procedimento_exemplo (float f) {
short int 2 bytes -32.768 a 32.767
f = 10;
unsigned short int 2 bytes 0 a 65.535
}
long int 4 bytes -2.147.483.648 a 2.147.483.647
int main (void){ unsigned long int 4 bytes 0 a 4.294.967.295

//corpo principal do programa float 4 bytes 10-38 a 1038
} double 8 bytes 10-308 a 10308
Operadores
Tipo Operador Propósito Exemplo

+ Adição a = 4 + 1; // 5
- Subtração a = 4 – 1; // 3
Aritméticos * Multiplicação a = 2 * 4; // 8
/ Divisão a = 8 / 2; // 4
% Módulo (resto da divisão) a = 5 % 2; // 1
Atribuição = Atribuição simples a = 50;
&& “e” lógico (a > 1) && (b < 1)
Lógicos || “ou” lógico (a > 1) || (b < 1)
! não (inversão) !(a > 2)
== igual a (a == 0)
!= diferente de (a != 0)
< menor que (a < 0)
Relacionais (Comparação)
> maior que (a > 0)
<= menor ou igual a (a <= 0)
>= maior ou igual a (a >= 0)
++ Incremento a++;
Incremento e Decremento
-- Decremento a--;
int a; //variável inteira
& Retorna o “endereço de”
Referência int *p; //declaração de ponteiro
p = &a; //atribui o endereço de a
(Apontadores/Ponteiros) *p = 2; //atribui ao conteúdo
Operadores utilizados antes * Retorna o “conteúdo de” //apontado por p o valor 2;
do nome de variáveis //como p aponta para o endereço
//de a, então a recebe 2.
Comandos da Linguagem

Comando Propósito Sintaxe

Declaração de variável Declaração de variável tipo nome_variavel = valor_inicial;
Declaração de constante Declaração de constante #define NOME_CONSTANTE valor
Bloco Marcar um bloco de cód. { } //Abre e fecha chaves “{}“
if (a > b) {
printf(“%s”, "A é maior que B");
if Comando condicional } else {
printf(“%s”, "A é igual ou menor que B");
}
switch (i) {
case 0 :
printf(“%s”, "ZERO");
break;
case 1:
switch Comando condicional printf(“%s”, "UM");
break;
case 2:
printf(“%s”, "DOIS");
break;
}
int i = 1;
while (i <= 10) {
while Laço com pré validação
printf("%d", i++);
}
int i = 1;
do {
do Laço com pós validação printf("%d", i++);
} while (i <= 10);
for (i=1;i<=10;i++){
for Laço simplificado printf("\n%d", i);
}
break Saída de bloco break;
continue Reinício de bloco continue;
float area(float altura, float base) {
Funções return altura * base;
}
Sub-rotinas
void area(float altura, float base) {
Procedimentos printf("A area é: %f", altura * base);
}
int v[10]; //Vetor de inteiros
Vetores Variáveis unidimensionais //v[0] é o primeiro elemento e v[9] o último
Variáveis float mat[4][3]; //Tabela com 4 linhas
Matrizes //e 3 colunas
multidimensionais
struct ponto {
int x;
int y;
Tipos de dados
struct compostos
}
struct ponto p;
p.x = 10;
p.y = 20;
typedef struct ponto {
int x;
Definição de novos tipos int y;
typedef de dados } Ponto;
Ponto p;
p.x = 10;

Componentes
A seguir vamos detalhar um pouco o conceito e o funcinamento interno de alguns componentes

deste kit. Em algumca imagens utilizarmos uma simbologia que importante que você conheça:
 VCC – Entrada de energia, alimentação do componente (polo positivo + )
 GND – Aterramento da energia (polo negativo – )
Matriz de Contato
Também conhecida com protoboard a matriz de contato é uma superfície normalmente de plástico
ou acrílio repleta de pequenos orifícios interligados onde encaixamos os componentes eletrônicos e por
meio da qual podemos desenvolver um protótipo sem a necessidade de soldá-los. Ela é usada em tempo
de desenvolvimento, enquanto o circuito está em testes. É uma ferramenta de experimentação.
O tamanho da protoboard é medido em “furos” ou pontos e existem diferentes modelos e tamanhos.

Quanto maior o número de furos maior será sua capacidade de receber componentes. A matriz de
contato nos garante um contato perfeito entre os terminais do componente sem a necessidade de solda
para fixá-los. Facilita-nos a alteração, a qualqeur momento, do projeto apenas desconectando o
componente antigo e substituindo-o pelo novo.
A figura a seguir ilustar as interligaçõos internas existentes em uma matriz de contato.
+ +
- -
30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
A A
B B
C C
D D
E E
F F
G G
H H
I I
J J
30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
+ +
- -
Na figura acima temos uma protoboard de 400 furos. As setas indicam as áreas interligadas entre
si. As trilhas horizontais em vermelho (idicadas pelo sinal “+”) possuem todos os furos interligados entre
si, inclusive entre as baias formadas por 5 furos, no entanto a trilha vermelha da parte superior não se
comunica com a trilha vermelha inferior. O mesmo vale para a trilha horizontal em azul, indicada pelo
sinal de “–“. As trilhas em vermelho e azul não se comunicam entre si e são normalmente utilizadas para
ergizar o positivo (vermelho) e aterrar o negativo (azul.). Até este ponto temos ao todo 100 furos (25
azuis inferiores, 25 azuis superiores, 25 vermelhos inferiores e 25 vermelhos superiores).
O restante da matriz é dividida em duas partes onde as colunas são numeradas de 1 a 30 e as

linhas de A a J. Na parte superior (neste exemplo) temos as letras A até E que formam uma matriz com

150 furos. Os furos de uma coluna se comunicam entre si ao longo das linhas. Isso significa dizer que os
furos A29, B29, C29, D29 e E29 (em verde) se comunicam entre si, no entanto não se comunicam com
os furos A28, B28, C28, D28 e E28 (em amarelo), mesmo sendo vizinhos. O mesmo vale para os furos
F29, G29, H29, I29 e J29 (em roxo) que mesmo estando na mesma linha dos furos em verde, não se
comunicam entre si, pois fazem parte da segunda parte da matriz (que também contém 150 furos).
Jumpers
Um jumper nada mais é do que um pedaço de fio de cobre (ou

outro material condutor de eletricidade) que serve para interligar trilhas
da protoboard entre sim e portas do arduino à protoboard. A figura abaixo
ilustra um típico exmplo de jumper, neste caso com as duas
extremidades “macho” utilizado para interligar componentes ao Arduino
UNO, por exemplo
Um jumper do tipo “fêmea” pode também ser útil em

algumas situações ou no caso do Arduino NANO (versão
miniatura) ele é a opção mais indicada. A figura a seguir ilustra
um conjunto de jumpers do tipo “fêmea”:
Podemos facilmente produzir jumpers de diferentes

tamanhos e cores utilizando um pequeno retalho de cabo UTP
(cabo de rede)
Led
O diodo emissor de luz também é conhecido pela sigla em inglês LED (Light Emitting Diode) é
normalemnte utilizado para sinalizar visualmente algo. Pode existir em várias cores ou modelos e
geralmente vai precisar de um resistor para não queimar. O led é um componente polarizado, ou seja,
preciamos prestar atenção na posição em que vamos ligar o VCC e o GND. Ele possui duas “pernas”
sendo a mais curta chamada de Catodo (Cathode) o polo negativo e a mais longa chamada de Anodo
(Anode) o polo positivo. Também há um chanfro na “cabeça” do led no lado negativo do mesmo. A figua
abaixo ilustra um LED e o seu símbolo em esquemas eletrônicos.

Resistor
Um resistor também conhedico

como “resistência” é um dispositivo
elétrico com a finalidade de oferecer uma
oposição à passagem de corrente
elétrica, através de seu material. A essa
oposição damos o nome de resistência
elétrica, que possui como unidade o
ohm. Causam uma queda de tensão em
alguma parte de um circuito elétrico, mas
não causam queda de corrente elétrica.
Existem diferente tipos de

resistores, cada um oferencendo uma
determinada resistência. Para determinar
a resitência de um resitor precisamos
recorrer a uma tabela de cores e
observar os anéis coloridos impressos
sobre o mesmo.
Este componente não tem

polaridade, ou seja pode ser ligado em
qualquer sentido que oferecerá o mesmo
efeito. A seguir são apresentados os
símbolos e a tabela de valores:

Botão
O botão é como um interruptor, ou seja, uma chave de acionamento manual. Há diferentes

tipos de botões, mas em geral seu fucnionamento consiste em permitir a passagem de corrente
(quando acionado) ou bloqueá-la quando não acionado. Observe na figura abaixo um típico
botão (switch button), neste caso a energia da perna de entrada somente sai pela porta de saída
se o botão estiver pressionado. Ao lado está o símbolo do botão.
Buzzer
O buzzer é uma espécie de alto-falante de tamanho reduzido que ao ser alimentado com
uma fonte de sinal, vibra da mesma frequência recebida. Normalmente é utilizado para fornecer
algum sinal de saída, se comunicando com o utilizador (um alarme, um bip, um conjunto de bips,
etc). É um componente polarizado, sendo que a fonte de energia deve ser fornecida no pino
indicado pelo sinal de “+”. A outra extremidade deve ser ligada ao GND. Observe a seguir a
imagem de um buzzer e o seu símbolo.

Ethernet Shield
Acoplando o Arduino Ethernet Shield W5100 ao seu Arduino, basta um simples cabo de
rede para que, em poucos minutos, você passe a monitorar o estado de sensores, chaves e
outros dispositivos à partir do browser do seu computador ou celular. Este Shield é baseado no
ethernet chip Wiznet W5100 (datasheet) e fornece um endereço IP compatível com os
protocolos TCP e UDP.
Referências Bibliográficas
BANZI, M. Getting Started with Arduino, 2ª Edição. Sebastopol – CA: O'Reilly Media, Inc, 2011.
MARGOLIS, M. Arduino Cookbook, Sebastopol – CA: O'Reilly Media, Inc, 2011.
MCROBERTS, M. Arduino Básico. São Paulo - SP: Editora Novatec, 2011.
BRAGA, N. C. Matrizes de Contato - Recurso Indispensável para Montagens Experimentais, Revista
Saber ELetrônica (nº 196/1989). São Paulo – SP: Ed. Saber Ltda, 1987.
CELES, W.; CERQUEIRA, R.; RANGEL, J. L. Introdução a Estruturas de Dados. Rio de Janeiro - RJ:
Campus, 2004.
Sites Especializados
http://arduino.cc
http://arduino.cc/en/Reference/HomePage
http://www.arduino.com.br/
http://www.youtube.com/user/graccula (video aulas básicas e avançadas por Renato Aloi)
http://www.labdegaragem.com.br/wiki/index.php?title=Sobre_Arduino
http://www.instructables.com/id/Arduino-Projects/
http://brasilrobotics.blogspot.com.br/
http://blog.webtronico.com/

Exemplos
Semáforo
Este experimento demonstra o uso de leds para simular um semáforo simples,

temporizado.
void setup() {
pinMode(8, OUTPUT); // conectado no led verde
pinMode(9, OUTPUT); // conectado no led amarelo
pinMode(10, OUTPUT);// conectado no led vermelho
}
void loop() {
digitalWrite(10, LOW); // desliga o led vermelho
digitalWrite(9, LOW); // desliga o led amarelo
digitalWrite(8, HIGH); // liga o led verde
delay(8000);
digitalWrite(8, LOW); // desliga o led verde
digitalWrite(9, HIGH); // liga o led amarelo
delay(2000);
digitalWrite(9, LOW); // desliga o led amarelo
digitalWrite(10, HIGH);// liga o led vermelho
delay(10000);
}

Som no Arduino
Este experimento demonstra o uso do Buzzer para produzir uma música.
#define pinoAudio 6
#define T 250
void setup(){
pinMode(pinoAudio,OUTPUT);//define o pino 6 do arduino como saida digital
}
void loop(){
tone(pinoAudio,660);
delay(2*T);
delay(T);
delay(T);
delay(2*T);
delay(T);
delay(T);
delay(2*T);
delay(6*T);
delay(2*T);
delay(T);
delay(T);
delay(2*T);
delay(T);
delay(T);
delay(6*T);
delay(T);
delay(T);
delay(T);
noTone(pinoAudio);
delay(10000);
}

Sensor de Temperatura
Este experimento demonstra o uso do sensor de temperatura LM35 e acende um led verde
se a temperatura tiver inferior a 25º C ou o led vermelho se ela estiver acima.
/*
Exemplo para ligar o LM35 ao Arduino
Conversor Analógico->Digital de 10 bits (1024).
O valor máximo que pode entrar no A/D é 5V.
Sendo assim, quando entrar:
-> 5V o valor lido será 1023
-> 2.5V o valor lido será 511 ou (1023/2)
-> 0V o valor lido será 0
Resumindo, é uma regra de três normal onde:
5V - 1023
X - Y
*/
int pinoSensor = 0; //pino que está ligado o terminal central do LM35 (porta analogica 0)
int valorLido = 0; //valor lido na entrada analogica
float temperatura = 0; //valorLido convertido para temperatura

void setup() {
Serial.begin(9600); //Inicializa comunicação Serial
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}
void loop() {
valorLido = analogRead(pinoSensor);
temperatura = (valorLido * 0.00488); // 5V / 1023 = 0.00488 (precisão do A/D)
temperatura = temperatura * 100; //Converte milivolts para graus celcius
// a cada 10mV equivalem a 1 grau celcius
Serial.print("Temperatura atual: ");
Serial.println(temperatura);
if (temperatura>25)
{
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
}
else
{
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
}
delay(2000); //espera 2 segundos para fazer nova leitura

}
Clique no menu Ferramentas => Monitor Serial e veja a temperatura atual.

Botão que Liga-Desliga Led
Este experimento demonstra o uso de um botão que liga e desliga um led.
Obs.: Usar um resistor de pelo menos 300 no led e um resistor de pelo memps 1K para o botão.
int var=0; // valor instantaneo enviado pelo botão

int var2=0; // valor guardado
int estado=0; // guarda o valor 0 ou 1 (HIGH ou LOW)
void setup()
{
pinMode(13,OUTPUT); // led no pino 13
pinMode(12,INPUT); // botão no pino 12
}
void loop()
{
var=digitalRead(botao); // ler o valor enviado pelo botão: "HIGH" ou "LOW"
if ((var == HIGH) && (var2 == LOW)) {
if (estado==1) estado=0;
else estado=1;
delay(20);
}
var2=var;
if (estado == 1) {
digitalWrite(13, HIGH); // liga o led
} else {
digitalWrite(13, LOW); // desliga o led
}
}

Experimentos
Servidor Web Básico que mostra os valores nas portas analógicas
Este exemplo demonstra a criação de um servidor web para mostrar os valores das entradas
analógicas, usando o Arduino Ethernet Shield.
Circuito:
 Ethernet shield usando os pinos 10, 11, 12, 13
 Entradas Analógicas usando os pinos A0 até A5
Este exemplo está disponível na IDE do Arduino em
 Arquivo -> Exemplos -> Ethernet -> Webserver
Obs.: Configurar o IPAdress de acordo com a rede local. Acessar o servidor, através de um
browser, informando o IPAdress configurado
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress ip(192, 168, 1, 177);
// Inicializa o Ethernet server com IP e porta 80 (default HTTP):

EthernetServer server(80);
void setup() {
Serial.begin(9600);
while (!Serial) {
; // espera pela comunicação pela porta serial e Terminal via USB
}
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 5"); // refresh da página automaticamente a
cada 5s
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
} else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
delay(1);
client.stop();
Serial.println("client disconnected");
}
}

Servidor Web que mostra temperatura e permite ligar e desligar led
Este exemplo demonstra o uso de ethernet shield para criar um servidor web que mostra a
temperatura atual lida através de um sensor LM35 e permite ligar e desligar um led. Ao invés de
ligar um led poderia ser um relé, que ligaria uma lâmpada, um ventilador, um aquecedor ou um
arcondicionado.
#include <SPI.h>
// Biblioteca utilizada para comunicação com o Arduino
// A linha abaixo permite definir o endereço físico (MAC ADDRESS) da placa...

//de rede.
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 10, 1, 1, 99 }; // Define o endereço IP.
// Porta onde estará aberta para comunicação Internet e Arduino.

EthernetServer server(80);
String readString;
int Pin = 9; // Pino digital onde será ligado e desligado o LED.
void setup(){

pinMode(Pin, OUTPUT); // Define o Pino 9 como saída.

Ethernet.begin(mac, ip); // Chama o MAC e o endereço IP da placa Ethernet.
// Inicia o servidor que esta inserido junto a placa Ethernet.
server.begin();
}
void loop(){
int pinoSensor = 0; //pino que está ligado o terminal central do LM35 (porta
analogica 0)
EthernetClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
char c = client.read();
if (readString.length() < 100) {

readString += c;
}
if (c == '\n') {
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Refresh: 1"); // refresh da página a cada 1segundo
client.println();
// A partir daqui começa os códigos html.
client.println("<HTML>");
client.println("<BODY>");
client.println("<H1>Controle de LED</H1>");
client.println("<hr />");
client.println("<br />");
if (digitalRead(Pin)==LOW) {
client.println("LED DESLIGADO<br><br>");
client.println("<a href=\"LedOn\"><button type=\"button\">Ligar
Led</button></a> ");
}
else {
client.println("LED LIGADO<br><br>");
client.println("<a href=\"LedOff\"><button type=\"button\">Desligar
Led</button></a><br />");
}
client.println("<hr>");
client.println("<h1>Temperatura</h1>");
String t = String(temperatura);
client.println(t);
client.println("</BODY>");
client.println("</HTML>");
delay(1);
client.stop();
if(readString.indexOf("LedOn") > 0)
{
digitalWrite(Pin, HIGH); // Liga LED.
}
else {
if(readString.indexOf("LedOff") > 0)
{
digitalWrite(Pin, LOW); // Desliga LED.
}
}
readString="";
}
}
}
}
}

Cliente Web que chama uma página php para inserir a temperatura numa base MySQL
Este exemplo demonstra o uso de ethernet shield para criar um cliente web que chama
uma página em php para atualizar uma base de dados mysql com a temperatura atual.
#include <SPI.h>
byte mac[] = { 0xEE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress server(10,10,9,247);
IPAddress ip(10, 10, 9, 246);
EthernetClient client;
char st[20];
void setup()
{
// Inicia a serial
Serial.begin(9600);
// Inicia SPI bus
Serial.println();
SPI.begin();
}
int pinoSensor = 0; //pino que está ligado o terminal central do LM35 (porta analogica
0)
float tempanterior = 0;
void loop()
{
Serial.print("temperatura: ");
if (tempanterior != temperatura) {
tempanterior = temperatura;
if (client.connect(server, 80)) {
Serial.println("connected");
// Make a HTTP request:
String pedido = "GET /temp/atualiza.php?temp=";
pedido.concat(temperatura);
client.println(pedido);
client.println("Connection: close");
client.println();
} else {
Serial.println("connection failed");
}
if (!client.connected()) {
Serial.println();
Serial.println("disconnecting.");
}
client.stop();
}
delay(1000);
}

Atualiza.php
<?php
if (isset($_GET['temp'])) {
try {
$pdo = new PDO('mysql:host=localhost;dbname=temperatura', "temperatura",
"temp");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo->prepare('insert into temperatura (temperatura, datahora) values

(:temp, now())');
$stmt->execute(array(
':temp' => $_GET['temp'],
));
echo $stmt->rowCount();
} catch(PDOException $e) {
echo 'Error: ' . $e->getMessage();
}
}
?>

Programa que acessa diretamente a base MySQL para inserir a temperatura
Este exemplo demonstra o uso de ethernet shield acessar diretamente uma base de dados
mysql para inserir a temperatura atual e buscar um valor de controle para saber se precisa ou
não ligar o pino da porta 8. Esse programa necessita da biblioteca MySQL_Connector_Arduino-
master.zip
#include <SPI.h>
#include <MySQL_Connection.h>
#include <MySQL_Cursor.h>
byte mac[] = { 0xEE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress server(10,10,9,247);
IPAddress ip(10, 10, 9, 246);
EthernetClient client;
MySQL_Connection conn((Client *)&client);
char user[] = "temperatura"; // MySQL user login username
char password[] = "temp"; // MySQL user login password
char st[20];
void setup()
{
pinMode(8, OUTPUT);
// Inicia a serial
Serial.begin(9600);
if (conn.connect(server, 3306, user, password)) {
Serial.println("Conectou no MySQL");
delay(1000);
}
else{
Serial.println("Connection failed.");
}
}
int pinoSensor = 0; //pino que está ligado o terminal central do LM35 (porta analogica
0)
float tempanterior = 0;
int valor = 0;
void loop()
{
row_values *row = NULL;
Serial.print("temperatura: ");
if (tempanterior != temperatura) {
tempanterior = temperatura;
// Initiate the query class instance
MySQL_Cursor *cur_mem = new MySQL_Cursor(&conn);
char sql[256];
char str_temp[6];

dtostrf(temperatura, 4, 2, str_temp);
sprintf(sql, "INSERT INTO temperatura.temperatura (temperatura, datahora) VALUES
(%s, now())", str_temp);
Serial.println(sql);
cur_mem->execute(sql);
delete cur_mem;
cur_mem = new MySQL_Cursor(&conn);
char query[] = "SELECT valor FROM temperatura.controle WHERE id = 8";
cur_mem->execute(query);
column_names *columns = cur_mem->get_columns();
do {
row = cur_mem->get_next_row();
if (row != NULL) {
valor = atol(row->values[0]);
}
} while (row != NULL);
delete cur_mem;
Serial.print("Valor do pino 8 = ");
Serial.println(valor);
if (valor==1) digitalWrite(8, HIGH);
else digitalWrite(8, LOW);
}
delay(10000);
}

Minicurso Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Minicurso Arduino

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Minicurso Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Mini-Curso

Frederico Westphalen, 2016

Kit Arduino ................................................................................................................................................................................. 2

Placa de Prototipagem compatível com Arduino UNO Rev 3

Cabo USB (para ligar o Arduino ao computador)

Matriz de contato (Protoboard)

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 2

Sensor de Temperatura – LM35

Arduino é um projeto de hardware livre. Se constitui como uma plataforma de prototipagem

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 3

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 4

As principais Conexões do Arduino Uno são:

Permite que os shields

2 Entrada ou Saída Digital

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 5

Cria um novo sketch (esboço) que vem a ser um projeto do Arduino.

Abre um sketch existente.

Salva o código do sketch no computador.

A imagem a seguir ilustra o IDE do Arduino e suas principais funcionalidades:

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 6

Estrutura Básica do Código

# define LED_PIN 13 //Cria uma constant de nome LED_PIN e valor 13

setup();// Função do usuário que configura o Arduino

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 7

 Serial.print( val ) e Serial.println( val )

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 8

As principais funções são:

O uso de bibliotecas proporciona ampliar a programação usando rotinas prontas. Lembrando

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 9

Estrutura básica de uma aplicação

#include <NomeDaBiblioteca.h> //inclui uma biblioteca

#define PI 3.14 //declaração de constantes

int a; //declaração de variáveis globais

float funcao_exemplo() { Tipos Primitivos

int main (void){ unsigned long int 4 bytes 0 a 4.294.967.295

Tipo Operador Propósito Exemplo

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 10

Comando Propósito Sintaxe

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 11

A seguir vamos detalhar um pouco o conceito e o funcinamento interno de alguns componentes

 VCC – Entrada de energia, alimentação do componente (polo positivo + )

 GND – Aterramento da energia (polo negativo – )

O tamanho da protoboard é medido em “furos” ou pontos e existem diferentes modelos e tamanhos.

A figura a seguir ilustar as interligaçõos internas existentes em uma matriz de contato.

O restante da matriz é dividida em duas partes onde as colunas são numeradas de 1 a 30 e as

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 12

Um jumper nada mais é do que um pedaço de fio de cobre (ou

Um jumper do tipo “fêmea” pode também ser útil em

Podemos facilmente produzir jumpers de diferentes

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 13

Um resistor também conhedico

Existem diferente tipos de

Este componente não tem

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 14

O botão é como um interruptor, ou seja, uma chave de acionamento manual. Há diferentes

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 15

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 16

Este experimento demonstra o uso de leds para simular um semáforo simples,

Mini-Curso – ARDUINO - Sensores & Ethernet Shield Página 17