ARDUINO LAB - GUIDE

R botic
ARDUINO LAB
ARDUINO PARA INICIANTES
WWW.ROBOTIC.COM.BR
R botic
Arduino Lab - Microcontroladores
Arduino Duemilanove Atmega 328

O arduino uma placa simples que contem tudo que voc precisa para comear a
trabalhar com eletrnica e programao de microcontroladores. Este diagrama ilustra
os principais componentes da placa:
Diferena entre Arduino UNO e Duemilanove:

O microcontrolador utilizado no UNO o Atmega 328, o mesmo do Duemilanove. Porm no Arduino UNO
existe um microcontrolador adicional (Atmega8U2) no lugar do chip FTDI utilizado no Duemilanove, que
responsvel pela converso USB/Serial. A gravao no UNO ficou mais rpida tambm.
www.robotic.com.br
R botic
Arduino UNO ou Duemilanove com Atmega328

O Arduino Uno uma placa de microcontrolador baseado no ATmega328. Ele tem 14 pinos de entrada/sada
digital (dos quais 6 podem ser usados como sadas PWM), 6 entradas analgicas, um cristal oscilador de
16MHz, uma conexo USB, uma entrada de alimentao uma conexo ICSP e um boto de reset. Ele contm
todos os componentes necessrios para suportar o microcontrolador, simplesmente conecte a um computador
pela porta USB ou alimentar com uma fonte ou com uma bateria e tudo pronto para comear.
A diferena do Uno para o Duemilanove que o Uno no utiliza o chip FTDI cara converso do sinal serial.
Utiliza no seu lugar um Atmega8U2 programado como conversor de USB para serial.
Resumo
Microcontrolador ATmega328
Voltagem Operacional 5V
Voltagem de entrada (recomendada) 7-12V
Voltagem de entrada (limites) 6-20V
Pinos E/S digitais 14 (dos quais 6 podems ser sadas PWM)
Pinos de entrada analgica 6
Corrente CC por pino E/S 40 mA
Corrente CC para o pino 3,3V 50 mA
Flash Memory 32 KB (ATmega328) dos quais 0,5KB so utilizados pelo bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Velocidade de Clock 16 Mhz
O arduino Uno pode ser alimentado pela porta USB ou com uma fonte externa. A alimentao selecionada
automaticamente. Alimentao externa pode ser tanto de uma fonte DC ou bateria.
Esta placa tem uma faixa recomendvel de alimentao externa de 7 a 12 volts evitando o superaquecimento
da placa.
Os pinos de alimentao so os seguintes:
VIN. A tenso de entrada para a placa Arduino, quando se est usando uma fonte externa de energia
(ao contrrio de 5 volts a partir da conexo USB). Voc pode fornecer a tenso atravs desse pino.
5V. A fonte de alimentao regulada usada para alimentar o microcontrolador e outros componentes na placa.
Isto pode vir tanto de VIN atravs de um regulador de bordo, ou seja alimentado por USB ou outra fonte de 5V
regulados.
3V3. gerada pelo chip FTDI-on. Mximo consumo de corrente de 50 mA.
Ground pinos GND..
Memria
O ATmega168 tem 16 KB de memria flash para armazenar o cdigo (de 2 KB que usado para o gerenciador
de inicializao).
ATmega328 tem 32 KB, (tambm com 2 KB utilizado para o bootloader). O ATmega168 tem 1 KB de SRAM e
512 bytes de EEPROM (que pode ser lido e escrito com a biblioteca EEPROM ), o ATmega328 tem 2 KB de
SRAM e 1 KB de EEPROM.
Entrada e Sada
Cada um dos 14 pinos digital no arduino pode ser usado como uma entrada ou sada, usando pinMode () ,
digitalWrite () , e digitalRead () funes. Eles operam em 5 volts. Cada pino pode fornecer ou receber um
mximo de 40 mA e tem um resistor pull-up interno (desligado por padro) de 20-50 kOhms.
www.robotic.com.br
R botic
Pinos com funes especficas:

Serial: 0 (RX) e 1 (TX). Usado para receber (RX) e transmitir (TX TTL srie de dados). Esses pinos so ligados
aos pinos correspondentes do chip FTDI USB-to-TTL Serial.
Interrupes externas: 2 e 3. Estes pinos podem ser configurados para disparar uma interrupo em um
valor baixo, um aumento ou diminuio de ponta, ou uma alterao no valor. (Veja a funo attachInterrupt )
PWM: 3, 5, 6, 9, 10 e 11. Pinos de sada PWM
LED: 13. H um built-in LED conectado ao pino digital 13.
Quando o pino est em valor alto , o LED est ligado, quando o pino baixo, ele est desligado
O arduino tem 6 entradas analgicas, cada uma das quais fornecem 10 bits de resoluo (ou seja, 1.024 valores
diferentes). Por padro, elas medem do GND para 5 volts, mas possvel mudar a extremidade superior de sua
escala com o pino AREF e analogReference () funo.
AREF. Tenso de referncia para as entradas analgicas. Usado com analogReference ().
Reset. Traga esta linha baixa para redefinir o microcontrolador. Tipicamente usado para adicionar um boto
de reset de escudos.
Comunicao
O Arduino tem uma srie de facilidades para se comunicar com um computador, outro Arduino, ou outros
microcontroladores. O ATmega168 e ATmega328 fornecer UART TTL (5V), comunicao serial,
que est disponvel nos pinos digitais 0 (RX) e 1 (TX). Um FT232RL FTDI os canais de comunicao
serial de USB e os drivers FTDI (includo com o software Arduino) oferecem uma porta virtual com o software no
computador. O software inclui um monitor Arduino serial que permite que dados simples de texto a ser enviado
e da placa Arduino. O RX e TX LEDs na placa pisca quando dados esto sendo transmitidos atravs do chip
FTDI e conexo USB para o computador (mas no para comunicao serial nos pinos 0 e 1).
A biblioteca Software Serial permite a comunicao serial em qualquer um dos pinos digitais do arduino.
O apoio tambm ATmega328 I2C (TWI) e comunicao SPI.
O software inclui uma biblioteca Arduino Wire para simplificar o uso do barramento I2C, veja a documentao
para mais detalhes. Para usar a comunicao SPI, consulte o datasheet ou ATmega328
Programao
O Arduino pode ser programado com o software IDE Arduino. Selecione "Arduino Duemilanove ou UNO Atmega
328 no menu Ferramentas (de acordo com o microcontrolador na placa).
O Arduino ATmega328 vem com um gerenciador (BOOTLOADER) que permite que voc faa o upload do novo
cdigo para ele sem a utilizao de um programador de hardware externo.
Ele se comunica utilizando o protocolo STK500 original ( de referncia , arquivos de cabealho C ).
Voc tambm pode ignorar o bootloader e programar o microcontrolador atravs do ICSP
(In-Circuit Serial Programming),
O Arduino tem um polyfuse resettable que protege as portas USB do seu computador a partir de shorts e
sobrecorrente. Embora a maioria dos computadores fornecem sua prpria proteo.
www.robotic.com.br
R botic
Instalando o Programa
1 Faa o download do ambiente de desenvolvimento do Arduino verso 23 em:
www.robotic.com.br Para programar uma placa Arduino voc precisa do ambiente de desenvolvimento.
Quando o download terminar descompacte (unzip) os arquivos. Certifique-se de preservar a estrutura das pastas.
Abra a pasta. Dentro voc vai encontrar alguns arquivos e sub-pastas. O aplicativo Arduino seu programa
ambiente de desenvolvimento.
2 Ao conectar a Placa Arduino na Porta USB e caso for solicitado drives localize os drivers USB
para o chip FTDI da placa na pasta drivers/FTDI USB Drivers da distribuio do Arduino ou na pasta drivers
para o UNO.
Configurando:
Certifique-se que o Arduino Duemilanove ou UNO (Atmega 328) est selecionado em: Tools > Board
www.robotic.com.br
R botic
Escolhendo a Porta Serial Selecione a porta serial menu Tools | Serial Port. No Windows deveria ser:
COM3, COM4 ou COM5 para uma placa USB. Para descobrir qual abra o Gerenciador de Dispositivos do
Windows (na aba Hardware do painel de controle do sistema). Procure por "USB Serial Port" na seo de Portas;
www.robotic.com.br
R botic
Ultrasom
Display LCD
RTC
Conectores
para o Arduino
Sensor de
Temperatura
Servo Motor
Mdulo Receptor
Infravermelho
3 LEDs comuns
1 LED infrared
Protoboard
Rel Chaves LDR Buzzer

Tactils
OBS: Para os experimentos deste manual sero necessrios as seguintes bibliotecas:

- DallasTemperature
- MegaServo
- LiquidCrystal
- Wire
- Irremote
- Ultrasonic
Verifique no diretrio onde foi instalado a IDE do arduino se na pasta LIBRARIES
tem estas bibliotecas, caso falte alguma, baixe da pagina de download no site:
www.robotic.com.br e descompacte na pasta libraries.
www.robotic.com.br
R botic
Experimento 1: LED Diodo Emissor de Luz

Um led constitudo por uma juno PN de material semicondutor e por dois terminais, o nodo (A) e o Ctodo (K).
A cor da luz emitida pelo led depende do material semicondutor que o constitui.
Simbologia
O led est diretamente polarizado, e emite luz,

quando o nodo est positivo em relao ao ctodo.
O led est inversamente polarizado, e no emite luz,

quando o nodo est negativo em relao ao ctodo.
Ligando um LED no Arduino

Cada cor de LED possui uma tensao de trabalho (V) e uma corrente maxima
suportada (I) que varia para cada fabricante, mas varia pouco em torno destes valores:
Vermelhos e Amarelos - 1,7V a 2V Verdes - 2V a 3V Azul,Violeta e Ultra-violeta
Acima de 3V
Como os pinos do arduino trabalham com +5v necessrio um resistor em srie com
o LED afim de limitar a voltagem no LED impedindo sua queima.
www.robotic.com.br
R botic
Experimento 1: Led piscante

Faa as ligaes conforme abaixo
Conectando os Jumpers
D8 - Pino Digital 8 ligado ao LED
Copie e cole este programa na IDE do arduino

/* LED piscante
*
* Liga e Desliga um LED conectado a um pino digital 8
* em intervalos de 1 segundos.
*/
int ledPin = 8;
// LED conectado ao pino digital 8
void setup()
{
pinMode(ledPin, OUTPUT);
// configura pino digital como sada
}
void loop()
{
digitalWrite(ledPin, HIGH); // liga o LED
delay(1000);
// temporiza 1 segundo
digitalWrite(ledPin, LOW); // desliga o LED
delay(1000);
// aguarda mais um segundo
}
Passos:
www.robotic.com.br
R botic
Experimento 3: Gerando sons - Buzzer


/*
Melodia
D8 - Pino Digital 8 ligado ao BUZZER

Faa o download da biblioteca pitches
*/
#include "pitches.h"
// notas da melodia:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// duraes nota: 4 nota = trimestre, nota 8 = oitava, etc:
int noteDurations[] = {
4, 8, 8, 4,4,4,4,4 };
void setup() {
// iterao sobre as notas da melodia:
for (int thisNote = 0; thisNote < 8; thisNote++) {
// calcular a durao da nota, em um segundo
// dividido pelo tipo de nota.
// por exemplo semnima = 1000 / 4, colcheia = 1000 / 8, etc
int noteDuration = 1000/noteDurations[thisNote];
tone(8, melody[thisNote],noteDuration);
// para distinguir as notas, definir um tempo mnimo entre elas.
// durao da nota + 30% parece funcionar bem:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// parar a reproduo de tom:
noTone(8);
}
}
void loop() {
// para no repetir a melodia.
}
Passos:
www.robotic.com.br
R botic
Entendendo o Servo Motor RC (rdio controle)

Servo Motor RC so usadas para converter o sinal elctrico em movimento polar
ou linear.
Os servos RC so controlados com um sinal de PWM conduzido ao seu fio de sinal. Um sinal de PWM tem
trs parmetros que o caracteriza: O primeiro a amplitude (ou pico a tenso de pico) do sinal. No arduino
usa 5 volts. O segundo a frequncia. Em PWM, a frequncia normalmente fixado a um valor entre 30-50
Hz para um servo analgico e 300 a 400 Hz para servos digitais
O terceiro valor o mais crtico, o pulso positivo com PWM. A largura do pulso ter um resultado direto para
a posio de acionamento. Em outras palavras, para controlar a posio de um servo, deve alterar a durao
do pulso positivo do sinal de PWM conduzidos para o fio de sinal do servo.
Definio de: PWM: (Pulse Width Modulation) uma tcnica de modulao que gera impulsos de largura
varivel para representar a amplitude de um sinal de entrada analgico.
O servo espera um pulso a cada 20 ms a fim de obter informaes corretas sobre o ngulo. A largura de pulso
leva o servo diretamente para o ngulo. Os servos trabalham com larguras de pulso entre 1000 a 2000
microsegundos.
Tambm podemos posicionar o servo diretamente com o valor do ngulo a ser posicionado usando outra funo
do arduino
Pulsos PWM para movimentar um Servo
Largura de Pulso de 2000 microsegundos o servo gira em sentido anit-horrio
periodo 20 mS
Largura de Pulso de 1500 microsegundos o servo pra na posio central
Largura de Pulso de 1000 microsegundos o servo gira em sentido horrio
www.robotic.com.br
R botic
Experimento 4: Controlando um Servo Motor com pulsos em microsegundos

Obs. Para experimentos com motores necessrio
uma fonte externa de 9 ou 12 volts de no mnimo
800mA; pois a porta USB no fornece corrente suficiente.
SIN do Servo ao pino digital 9
Este servo um servo de posio, ou seja gira para determinados ngulos, existem os servos de
rotao contnua, que giram continuamente para os dois lados ou ficam parados conforme a largura
de pulso (PWM) ou conforme o ngulo.
#include <Servo.h> //inclue a biblioteca Servo

Servo meu_servo ; //Cria o objeto meu_servo
void setup(){ //Configurao inicial, no se repete
meu_servo.attach(9) ;
//Meu_servo ligado no pino 9 (PWM)
// Envia um pulso de 1500 microsegundo mantendo o servo parado em 90

meu_servo.writeMicroseconds(1500);
delay(1000); //epera 1 segundo
}
void loop() { //Repete enquanto for verdadeiro
meu_servo.writeMicroseconds(1000); // gira o servo horario para 0
delay(2000); //espera 2 segundos
meu_servo.writeMicroseconds(1500); // pra o servo na posio central 90
meu_servo.writeMicroseconds(2000); // gira o servo sentido contrrio para180
}
Passos:
www.robotic.com.br
R botic
Experimento 4.1: Controlando um Servo Motor por ngulos.

90
180
Este servo um servo de posio, ou seja gira para determinados ngulos, existem os servos de
rotao contnua, que giram continuamente para os dois lados ou ficam parados conforme a largura
de pulso (PWM) ou conforme o ngulo.
0 ->
180 ->
Largura de pulso 544

Largura de pulso 2400
#include <Servo.h> //inclue a biblioteca Servo

Servo myservo ;
//Cria o objeto meu_servo
void setup(){
//Configurao inicial, no se repete
myservo.attach(9,544,2400) ; //Meu servo ligado no pin9 (PWM) pulso mini e maximo para o servo
}
//fim do void setup
void loop() {
myservo.write(0) ;
delay(2000);
//Repete enquanto for verdadeiro

// gira o servo horario para 0
//espera 2 segundos
myservo.write(90) ; // pra o servo na posio central 90

delay(2000);
//espera 2 segundos
myservo.write(180) ; // gira o servo sentido contrrio para 180
delay(2000);
//espera 2 segundos
} //fim do void loop
Passos:
www.robotic.com.br
R botic
Experimento 4.2: Controlando um Servo Motor por ngulo via Serial Monitor

#include <Servo.h> //Inclui a biblioteca Servo
Servo myservo;
//Cria a varivel myservo
int char_in ;
//Cria a varivel char_in para receber as opes do menu
void setup()
//Configurao inicial
{
Serial.begin(9600) ; //abre a porta serial, define a taxa de dados a 9600 bps
myservo.attach(9,544,2400) ; //Meu servo ligado no pin9 (PWM) pulso mini e maximo para o servo
colocaMenu() ;
//Cria o Menu
}
void loop() //Repete at verdadeiro
{
if(Serial.available() > 0 ) { //Verifica se a porta serial est disponvel
char_in = Serial.read() ; //L o valor na porta serial e carrega para a varivel
Serial.print(char_in,BYTE) ; //Mostra o valor carregado na varivel e muta para tipo byte
switch (char_in) { //A instruo switch espera valores numricos nicos para cada opo da funo case;
case '1': //caso o valor da varivel seja 1
myservo.write(0) ; //Posiciona o servo no ngulo 0 grau
Serial.println(" Vai ao angulo 0 grau") ; //mostra esta frase no serial monitor
break;
case '2': //caso o valor da varivel seja 2
myservo.write(90) ; //Posiciona o servo no ngulo 90 graus
Serial.println(" Vai ao angulo 90 graus") ; //mostra esta frase no serial monitor
break;
case '3':
//caso o valor da varivel seja 3
myservo.write(180) ; //Posiciona o servo no ngulo 180 graus
Serial.println(" Vai ao angulo 180 graus") ; //mostra esta frase no serial monitor
break;
} //fim da funo switch
} //fim da funo serial.available()
} //fim da void loop
void colocaMenu() { //Mostra o menu na tela
Serial.println("Teste de motor servo") ;
Serial.println("Selecione :") ;
Serial.println("1 - VAI PARA O ANGULO 0 GRAU") ;
Serial.println("2 - VAI PARA O ANGULO 90 GRAUS") ;
Serial.println("3 - VAI PARA O ANGULO 180 GRAUS") ;
Serial.println("Opcao ? ") ;
}
Passos:
www.robotic.com.br
R botic
Experimento 5: Controlando um LED pelo sersor de luz LDR
D2 - Pino digital 2 Ligado ao LDR

//Programa para controle de LED com LDR
int ledpin = 8;
int ldr = 2;
int val;
void setup () {
pinMode (ledpin, OUTPUT );
pinMode (ldr, INPUT );
}
void loop () {
val = digitalRead(ldr);
if (val == LOW ) {
digitalWrite (ledpin, LOW );
}
if (val == HIGH ) {
digitalWrite (ledpin, HIGH );
}
}
Passos:
www.robotic.com.br
R botic
Experimento 6: Controlando um Servo Motor pelo sensor de luz LDR

//Programa para controlar o servo com LDR

D10 - Pino Digital 10 ligado ao SIN do servo
D2 - Pino digital 2 Ligado ao LDR
#include <Servo.h>
Servo myservo;
int servo = 10;
int ldr = 2;
int val;
void setup(){
pinMode(servo,OUTPUT);
pinMode(ldr,INPUT);
myservo.attach(servo,880,2300) ; //Inicia com o servo parado
myservo.write(70);
delay(300);
}
void loop() {
val = digitalRead(ldr); //verifica o ldr e guarda seu status
if (val == LOW ) {
myservo.attach(servo,880,2300) ; //Pra o servo
myservo.write(70);
delay(300);
}
Passos:
if (val == HIGH ) {
myservo.attach(servo,880,2300) ; // aciona o servo
myservo.write(180) ;
delay(300);
}
}
www.robotic.com.br
R botic
Experimento 7: Controlando um LED pela Chave Tctil

D2 - Pino digital 2 Ligado ao Ch1

int chave = 2;
int led = 8;
int State = 0;
// Chave tctil no pin 2

// LED no pino 8
// varivel para armazenar o estado da chave
void setup() {
pinMode(led, OUTPUT);
pinMode(chave, INPUT);
}
void loop(){
State = digitalRead(chave);
if (State == HIGH) {
digitalWrite(led, HIGH);
}
else {
digitalWrite(led, LOW);
}
}
Passos:
www.robotic.com.br
R botic
Experimento 8: Controlando um Servo Motor pela Chave Tctil

* Ligaes das Chaves Tactils

PIN 6 - CH2 - Pino digital 6 ligado a Chave 2
PIN 7 - CH1 - Pino digital 7 ligado a Chave 1
#include <Servo.h>
* Ligao do Servo Motor
Servo myservo ;
int ST1;
//Declara varivel ST1
int ST2;
//Declara varivel ST2
int CHAVE_1 = 7;
//chave_1 ligada no pin digital 7
int CHAVE_2 = 6;
//chave_2 ligada no pin digital 6
void setup(){
myservo.attach(9,880,2300) ;
pinMode(CHAVE_1,INPUT);
//define as chaves como entrada
pinMode(CHAVE_2,INPUT);
myservo.write(70) ;
//enviando um ngulo de 70 graus, mantm o servo parado
}
void loop() {
PIN9 - SIN - Pino digital 9 ligado ao pino de sinal do servo
ST1 = digitalRead(CHAVE_1);
ST2 = digitalRead(CHAVE_2);
//faz a leitura da chave 1

//faz a leitura da chave 2
if (ST1 == HIGH and ST2==HIGH){PARA();}

if (ST1 == LOW and ST2==HIGH){GIRA();}
if (ST1 == HIGH and ST2==LOW){VOLTA();}
}
void GIRA() {
myservo.write(180); // gira o servo
delay(1000);
PARA();
}
void PARA() {
myservo.write(70); // pra o servo
delay(5);
}
void VOLTA() {
myservo.write(0); // gira o servo sentido contrrio
delay(1000);
PARA();
}
Passos:
www.robotic.com.br
R botic
Experimento 9: Controlando um LED atravs do potencimetro

D10 - Pino Digital 10 ligado a um LED
A5 - Pino 5 analgico do arduino ligado ao
pino central do potencimetro
int potPin = 5;
int ledPin = 10;
// pino de entrada para o potencimetro

// pino de saida para o LED
void setup()
{
pinMode(ledPin, OUTPUT);
}
// declara ledPin como SAIDA
void loop()
{
digitalWrite(ledPin, HIGH);
delay(analogRead(potPin));
// ledPin em on
// Espera por um tempo potPin
digitalWrite(ledPin, LOW);
delay(analogRead(potPin));
// ledPin em off
// Espera por um tempo potPin
Passos:
www.robotic.com.br
R botic
Experimento 10: Controlando um Servo atravs do potencimetro

SIN - Pino de sinal do Servo ao Pin Digital 10
A5 - Pino 5 analgico do arduino ligado ao
pino central do potencimetro

#include <Servo.h>
Servo servo1;
// Biblioteca que permite controlar mais facilmete os Servos

// Criao de um objecto que permitira controlar o servo
int pinopot = 5;
analogico 5
int valor;
// Declarao da variavel para o pino que vai ler o valor do potenciometro, neste caso o pino 5
void setup()
{
servo1.attach(10);
}
// Declarao da variavel onde vai ser colocado o valor lido do pino analogico 0
// Porta onde ira ser ligado o servo
void loop()
{
valor = analogRead(pinopot);
valor = map(valor, 0, 1023, 0, 179);
servo1.write(valor);
delay(1);
}
// leitura do valor do potenciometro e escrita desse valor na variavel valor

// Escala para que o valor do potenciometro possa corresponder a um valor de posiao no
// Gira o servo de acordo com a escala da linha acima
// Espera de 1 milisegunda para que o servo possa atingir a sua posiao
Passos:
www.robotic.com.br
R botic
Experimento 11: RTC - Real Time Clock

Programando o RTC com a data e horas
atuais e visualizando no Serial Monitor.
* A4 -Ligar o pino analgico 4 ao SDA
* A5 -Ligar o pino analgico 5 ao SCL
OBS.: Aps carregar o programa,

desligue a chave L/D e ligue novamente,
depois verifique no monitor serial
Passos:
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
// Convert normal decimal numbers to binary coded decimal
// Ligar o SDA ao pin4 da entrada analgica e SCL ao pin5 da entrada analgica
byte decToBcd(byte val)
{
return ( (val/10*16) + (val%10) );
}
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return ( (val/16*10) + (val%16) );
}
void setDateDs1307(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.send(0);
Wire.send(decToBcd(second)); // 0 to bit 7 starts the clock
Wire.send(decToBcd(minute));
Wire.send(decToBcd(hour)); // If you want 12 hour am/pm you need to set
// bit 6 (also need to change readDateDs1307)
Wire.send(decToBcd(dayOfWeek));
Wire.send(decToBcd(dayOfMonth));
Wire.send(decToBcd(month));
Wire.send(decToBcd(year));
Wire.endTransmission();
}
// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Reset the register pointer
Wire.send(0);
Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
// A few of these need masks because certain bits are control bits
*second = bcdToDec(Wire.receive() & 0x7f);
*minute = bcdToDec(Wire.receive());
*hour = bcdToDec(Wire.receive() & 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.receive());
*dayOfMonth = bcdToDec(Wire.receive());
*month = bcdToDec(Wire.receive());
*year = bcdToDec(Wire.receive());
}
void setup()
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
Serial.begin(9600);
//Digite aqui os dados de Data e Hora atuais para configurar o RTC
second = 45;
//Segundos
minute = 32;
//Minutus
hour = 8;
//Hora
dayOfWeek = 2;
//Dia da semana sendo 1 domingo
dayOfMonth = 19; //Dia do ms
month = 3;
//Ms atual
year =12;
//Ano atual
setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
}
void loop()
{
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
Serial.print("Sao: ");
Serial.print(hour, DEC);
Serial.print(":");
Serial.print(minute, DEC);
Serial.print(":");
Serial.print(second, DEC);
Serial.print(" ");
Serial.print(dayOfMonth, DEC);
Serial.print("/");
Serial.print(month, DEC);
Serial.print("/20");
Serial.print(year, DEC);
switch(dayOfWeek){
case 1:Serial.print(" Domingo"); break;
case 2:Serial.print(" Segunda-feira"); break;
case 3:Serial.print(" Ter? a-feira"); break;
case 4:Serial.print(" Quarta-feira"); break;
case 5:Serial.print(" Quinta-feira"); break;
case 6:Serial.print(" Sexta-feira"); break;
case 7:Serial.print(" Sabado"); break;
default:Serial.print(" ");
}
Serial.println(dayOfWeek);
delay(1000);
}
www.robotic.com.br
R botic
Visualizando a data e hora no Display LCD
Ligaes do Display ao Arduino:
* RS - Pino digital 12
*E
- Enable pino digital 11
* D4 - Pino digital 5
Ligaes do RTC:
Obs.: Gire o Trimpot (azul) at aparecer

os caracteres no display
Passos:

#include "Wire.h"
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
{
return ( (val/10*16) + (val%10) );
}
{
return ( (val/16*10) + (val%16) );
}
byte hour, // 1-23
byte month, // 1-12
byte year) // 0-99
{
Wire.send(0);
}
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
Wire.send(0);
}
void setup() //Registrando a data atual no RTC
{
lcd.begin(8, 2);
//byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
}
void loop()
{
lcd.print(hour, DEC);
lcd.print(":");
lcd.print(minute, DEC);
lcd.print(":");
lcd.print(second, DEC);
lcd.setCursor(0,1); //Posiciona cursor na segunda linha
lcd.print(dayOfMonth, DEC);
lcd.print("/");
lcd.print(month, DEC);
lcd.print("/");
lcd.print("20");
lcd.print(year, DEC);
delay(1000);
lcd.clear();
}
www.robotic.com.br
R botic

Demostrativo de alarme - Acender um LED as 8:45h
* D13 pino digital 13 ligado ao LED
Passos:

#include "Wire.h"
int LED = 13; //led ligado ao pin 13
{
return ( (val/10*16) + (val%10) );
}
{
return ( (val/16*10) + (val%16) );
}
byte hour, // 1-23
byte month, // 1-12
byte year) // 0-99
{
Wire.send(0);
}
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
Wire.send(0);
}
{
Wire.begin();
Serial.begin(9600);
}
void loop()
{
Serial.print(":");
Serial.print(":");
Serial.print(" ");
Serial.print("/");
Serial.println(year, DEC);
// As 8:45h o led ir acender
if (hour == 8 and minute == 45) { digitalWrite(LED, HIGH);}
//Serial.println(dayOfWeek);
delay(1000);
}
www.robotic.com.br
R botic

Demostrativo de acionamento do servo motor de 8:45h s 8:47h
Ligaes do RTC:
* D13 pino digital 13 ligado ao SIN do servo
Passos:

#include "Wire.h"
#include <MegaServo.h> //Inclue a biblioteca MegaServos
#define NBR_SERVOS 12 // Numero de Servos ligados. Maximo de 48 arduino MEGA, 12 para outros
arduinos
#define FIRST_SERVO_PIN 3
MegaServo Servos[NBR_SERVOS] ;
int LED = 13; //led ligado ao pin 13
{
return ( (val/10*16) + (val%10) );
}
{
return ( (val/16*10) + (val%16) );
}
byte hour, // 1-23
byte month, // 1-12
byte year) // 0-99
{
Wire.send(0);
}
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
Wire.send(0);
}
{
Servos[1].attach(3,880,2300); //Servo na porta digital 3
Servos[1].write(70);
delay(15);
Wire.begin();
Serial.begin(9600);
}
void loop()
{
Serial.print(":");
Serial.print(":");
Serial.print(" ");
Serial.print("/");
Serial.println(year, DEC);
// As 8:45h o servo ser acionado e as 8:47 desligado
if (hour == 8 and minute >= 45) { Servos[1].write(180);}
if (hour == 8 and minute >= 47) { Servos[1].write(70);}
//Serial.println(dayOfWeek);
delay(1000);
}
www.robotic.com.br
R botic
Como funciona o protocolo do controle remoto infravermelho padro sony

Ao apertar um boto de um controle remoto, o circuito integrado do controle detecta isso e envia o comando
binrio ao LED de infravermelho que fica na frente do controle remoto.
O LED envia uma srie de pulsos de luz que correspondem ao comando binrio "da tecla precionada".
Um exemplo de cdigo de controle remoto o protocolo Sony Control-S, usado pelas TVs Sony e inclui os
seguintes comandos binrios de 7 bits:
Alm do comando da tecla precionada o cdigo binrio tambm carrega outras informao:
Um comando iniciar Start bit,
O cdigo de comando da "tecla precionanada"
O endereo do aparelho (um cdigo binrio que identifica o aparelho receptor)
Um comando parar (disparado quando se libera o boto") stop bit
Start bit
Cdigo da tecla
Stop bit
Cdigo do aparelho
Os controles remotos de padro Sony usam um mtodo de codificao de espaos em que o comprimento dos
espaos entre os pulsos de luz representam 1 ou 0 (+5V, 0V) cdigo binrio.
O cdigo IR possui limitaes relacionadas natureza da luz infravermelha. Primeiro, eles tm um alcance de
apenas 10 metros e exigem linha de visada. Isso significa que sinais infravermelhos no so transmitidos atravs
de paredes nem fazem curvas mas podem ser refletidos. Alm disso, a luz infravermelha to comum que as
interferncias podem ser um problema.
Exemplo de fontes de luz infravermelha usadas diariamente:
luz do sol
lmpadas fluorescentes
corpo humano
www.robotic.com.br
R botic
CONFIGURAO DO CONTROLE REMOTO
Cdigos sony para cada tcla do controle

2704
2192
1168
144
656
3216
2640
Pino Digital 2 ligado ao Mdulo Infrared

Pino Digital 7 ligado a um LED
OBS:
Para este experimento necessrio a biblioteca: IRremote
Verifique no diretrio onde foi instalado a IDE do arduino se na pasta LIBRARIES
tem estas bibliotecas, caso falte alguma, baixe da pagina de download no site:
www.robotic.com.br e descompacte na pasta libraries.
www.robotic.com.br
R botic
Unidade Mvel Robotic - Microcontrolador
PROGRAMA - CONFIGURANDO O CONTROLE: Copie e cole na IDE do arduino
#include <IRremote.h>
// Inclue a biblioteca IRremote
const int RECV_PIN = 2;

int LED = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
//Receptor di IR no pino digital 2

//LED no pin 7
void setup()
{
pinMode(LED, OUTPUT);
irrecv.enableIRIn(); // Inicia o recebimento
}
void loop() {
if (irrecv.decode(&results)) {
if (results.value == 656){
//Tecla MUTE do controle remoto
digitalWrite(LED, HIGH);} //Acende o LED do pin 13
if (results.value == 2192){ //Tecla CH- do controle remoto
digitalWrite(LED, LOW); } //Apaga o LED do pin 13
if (results.value == 144){ //Tecla CH+ do controle remoto
digitalWrite(LED, HIGH); } //Apaga o LED do pin 13
irrecv.resume(); // Recebe proximo valor
}
}
2- Nas chaves CH+ e CH- voc testa

a configurao, o LED dever acender
e apagar.
1- Mantenha precione a tecla MUTE at
o LED acender.
www.robotic.com.br
R botic
Experimento 15: Mostrando os cdigos das teclas do controle remoto

no serial monitor
Pino Digital 2 ligado ao Mdulo Infrared
#include <IRremote.h> //Inclui a biblioteca Irremote

int RECV_PIN = 2;
//Sensor de IR ligado no pino 2
IRrecv irrecv(RECV_PIN); //Varivel irrecv recebe os dados emitidos pelo controle

//Separa os bits para saber qual tecla foi precionada e armazena na varivel results
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
irrecv.blink13(true);
}
//Inicializa a porta serial (Serial Monitor)

// Ativa o recebimento dos comandos do controle
//Pisca o LED13 enquanto recebe comandos
void loop() {
// Verifica se a varivel recebeu algum comando do controle
Serial.println(results.value);
// Mostra em uma nova linha o valor da varivel
irrecv.resume();
}
}
// Recebe proximo valor
Passos:
www.robotic.com.br
R botic
Experimento 16: Comandando um LED pelo controle remoto

D2 - Pino Digital 2 ligado ao Mdulo Infrared

#include <IRremote.h> //Inclui a biblioteca Irremote
int RECV_PIN = 2;
int LED = 7;
//Sensor de IR ligado no pino 2
//LED ligado ao pin 7
IRrecv irrecv(RECV_PIN); //Varivel irrecv recebe os dados emitidos pelo controle

//Separa os bits para saber qual tecla foi precionada e armazena na varivel results
void setup()
{
Serial.begin(9600);
//Inicializa a porta serial (Serial Monitor)

// Ativa o recebimento dos comandos do controle
//Pisca o LED13 enquanto recebe comandos
pinMode(LED, OUTPUT); //pino 7 definido como sada

}
void loop() {
// Verifica se a varivel recebeu algum comando do controle
// Mostra em uma nova linha o valor da varive
//Se a tecla CH+ for precionada
digitalWrite(LED, HIGH);} //envia +5v para o pin7
if (results.value == 2192){ //Se a tecla CH- for precionada
digitalWrite(LED, LOW); } ////envia 0v para o pin7
irrecv.resume();
}
}
Passos:
// Recebe proximo valor
OBS: Aps carregar o programa use as

teclas CH+ e CH- do controle para
acionar o LED
www.robotic.com.br
R botic
Experimento 17: Comandando um servo motor pelo controle remoto
INFRARED - Pin Digital 2
SIN - pin digital 9 (servo)

#include <IRremote.h> // Inclue a biblioteca IRremote
#define NBR_SERVOS 12 // Numero de Servos ligados.
const int RECV_PIN = 2; //Receptor di IR no pino digital 2
int servo = 9;
//servo no pino digital 9
void setup()
{
irrecv.enableIRIn(); // Inicia o recebimento
Servos[1].attach(servo,880,2400) ;
Servos[1].write(70) ;
delay(15);
}
void loop() {
if (results.value == 144){ //Tecla CH+ do controle remoto
delay(15); }
delay(15);}
if (results.value == 1168){ //Tecla VOL+ do controle remoto
delay(15);}
}
}
OBS: Numero de Servos ligados. Maximo de 48 para o arduino MEGA,

e 12 para outros arduinos
Passos:
www.robotic.com.br
R botic
Experimento 18: Comandando um REL pelo controle remoto
D7 - Pino Digital 8 ligado ao REL
CONEXES DO REL
Comum ao +5volts
NA - Ligar a um LED

// Inclue a biblioteca IRremote
const int RECV_PIN = 2; //Receptor di IR no pino digital 2

int RELE = 8;
//Rel no pino 8
void setup()
{
pinMode(RELE, OUTPUT);
// Inicia o recebimento
}
void loop() {
//Tecla CH+ do controle remoto
digitalWrite(RELE, LOW);} //Aciona o Rel
digitalWrite(RELE, HIGH); } //Desliga o Rel
}
}
Passos:
www.robotic.com.br
R botic
Sensor de Temperatura Dallas DS18B20

Este sensor de temperatura mede de -55c a +125C. e possui resoluo programvel dentre outros
recursos. Permite programar alarmes de temperatura, que ficaro registrados em sua memria no
voltil. Possui interface 1-wire, que requer apenas um pino do microcontrolador. Alm disso, ele
possui uma numerao nica por dispositivo, de 64 bits, que permite que se use vrios sensores no
mesmo pino. Ideal para projetos com microcontroladores.
Esquema de ligao
www.robotic.com.br
R botic
Experimento 19: Mostrando temperaturas no serial monitor

/*
DallasTemperature.CPP - Dallas Temperature Control Library 1.0.0
* DQ - Pino digital 12
*/
#include <DallasTemperature.h> //Inclui a biblioteca do sensor
DallasTemperature tempSensor; //Cria o objeto tempSensor
void setup() {
// initialize entradas e sadas

// inicializa a porta serial
Serial.begin(9600);
tempSensor.begin(12); // sensor ligado na porta digital 12
Serial.println("Temperatura Atual: "); //Mostra esta frase no serial monitor
}
void loop() { //repete emquanto verdadeiro
// Pega temperatura e envia para o monitor serial.
Serial.print(tempSensor.getTemperature());
Serial.print("C"); //Mostra o C de centgrado no serial monitor
Serial.println(); //Vai para a prxima linha
}
Passos:
www.robotic.com.br
R botic
Experimento 20: Mostrando temperaturas no display LCD

A biblioteca LiquidCrystal permite-lhe controlar os display de LCD
O LCDs tm um interface paralelo, o que significa que o microcontrolador tem de manipular pinos de interface
de uma s vez para controlar a exibio. A interface consiste dos pinos seguintes:
Pino +5v para alimentar o LCD
Pino (RS) registo select, que controla onde na memria do LCD que voc est escrevendo dados. Voc
pode selecionar o registo de dados, que detm o que se passa na tela, ou um registrador de instruo, que
onde o controlador de LCD procura por instrues sobre o que fazer em seguida.
(E) Pino ENABLE para ativar ou desativar o LCD
(R / W) Pino para selecionar o modo de leitura ou escrita. Em nossos experimentos usaremos sempre o
modo escrita; portanto este pino est configurado como modo de escrita.
8 pinos de dados (D0-D7). Os estados desses pinos (alto ou baixo) so os bits que voc est escrevendo
para um registo.
(Vo) pino de constrast onde est ligado o trimpot azul afim de ajustar o contraste da tela
O processo de controlar a exibio envolve colocar os dados que formam a imagem do que voc deseja exibir
para os registradores de dados, em seguida, colocar instrues no registrador de instrues. A Biblioteca
LiquidCrystal simplifica isso para voc, assim voc no precisa saber as instrues de baixo nvel.
O LCDs pode ser controlado em dois modos: 4 bits ou 8 bits. O modo de 4-bit requer sete pinos I / O do
Arduino, enquanto o modo de 8 bits requer 11 pinos. Voc pode fazer quase tudo, em modo 4 bits.
Trimpot
Esquema de ligao do LCD
www.robotic.com.br
R botic
Experimento 20: Mostrando temperaturas no display LCD
* RS
*E
* D4
* D5
* D6
* D7
- Pino digital 12
- Pino digital 5
- Pino digital 4
- Pino digital 3
- Pino digital 2
Ligaes do Sensor DS18B20:

* DQ do Sensor de Temperatura ao pino digital 6
/*
Mostrando a temperatura no Display
*/
#include <DallasTemperature.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
DallasTemperature tempSensor;
void setup(void) {
// initialize entradas e sadas
lcd.clear();
lcd.begin(8, 2);
lcd.print("Temp.:"); // envia a mensagem para o LCD.
}
void loop(void) {
// Pega temperatura e envia para o monitor serial.
lcd.setCursor(0,1); //Posiciona cursor na segunda linha
lcd.print(tempSensor.getTemperature());
lcd.print("C");
delay(1000); //espera 1 segundo para fazer a leitura novamente
lcd.clear();
}
Passos:
www.robotic.com.br
R botic
Experimento 21: Os leds acendem de acordo com a temperatura
D8 - Pino digital 8 ligado ao LED Azul
D9 - Pino digital 9 Ligado ao Led Amarelo
D10 - Pino digital 10 Ligado ao Led Vermelho
D12 - Pino digital 12 ligado ao DQ do DS18B20

/*
SENSOR DE TEMPERATURA
- Este programa acende o led azul para temperatura abaixo de 25 graus
- Acende o led amarelo para temperaturas entre 25 e 30 graus
- Acende o led vermelho para temperaturas maiores que 30 graus
*/
int led_azul = 8;
//led azul no pino 8
int led_amar = 9;
//led amarelo no pino 9
int led_verm = 10;
//led vermelho no pino 10
int temp;
void setup() { // inicializando entradas e sadas
LED Azul acende para temperaturas menores que 25

LED Amarelo acende para temperaturas entre 25 e 30
LED Vermelho acende para temperaturas maiores que 30
Passos:
pinMode(led_azul, OUTPUT);
pinMode(led_amar, OUTPUT);
pinMode(led_verm, OUTPUT);
Serial.begin(9600); // inicializa a porta serial
Serial.println("Temperatura Atual: ");
}
void loop() {
// envia para o monitor serial.
Serial.print("C");
Serial.println();
if (tempSensor.getTemperature() < 25)
{
digitalWrite(led_azul, HIGH);
//verifica se a temperatura menor que 20 graus
digitalWrite(led_amar, LOW);
digitalWrite(led_verm, LOW);
}
if (tempSensor.getTemperature() > 25 and tempSensor.getTemperature() < 30) {
digitalWrite(led_azul, LOW);
digitalWrite(led_amar, HIGH);
digitalWrite(led_verm, LOW);
}
if (tempSensor.getTemperature() > 30) {
digitalWrite(led_azul, LOW);
digitalWrite(led_amar, LOW);
digitalWrite(led_verm, HIGH);
}
}
www.robotic.com.br
R botic
Experimento 22: O servo acionado de acordo com a temperatura
D7 - Pino Digital 7 ligado ao SIN do servo
D12 - Pino Digital 12 ligado ao DQ do DS18B20
OBS:
Para este experimento sero necessrios:

/*
SENSOR DE TEMPERATURA
Este programa aciona um servo de acordo com a temperatura
*/
#define NBR_SERVOS 12 // Numero de Servos ligados
int temp;
- uma pedra de gelo envolvida por um pano.

- Um isqueiros (Cuidado somente adultos)
void setup() { // inicializando entradas e sadas
Ao aproximar o isquiro do sensor tome os devidos cuidados para no cometer nenhum acidente.
Servos[1].attach(7,880,2300); //Servo na porta digital 7

delay(15);
Serial.begin(9600); // inicializa a porta serial
Serial.println("Temperatura Atual: ");
}
Temperatura menores que 25 servo gira para um lado

Temperaturas entre 25 e 30 servo se mantm parado
Temperaturas maiores que 30 servo gira em sentido contrrio
void loop() {
// envia para o monitor serial.
Serial.print("C");
Serial.println(" ");
//Serial.println(tempSensor.getTemperature());
if (tempSensor.getTemperature() < 25)
{
Servos[1].write(0);
delay(30);
}
if (tempSensor.getTemperature() > 25 and tempSensor.getTemperature() < 30) {
delay(30);
}
if (tempSensor.getTemperature() > 30) {
delay(30);
}
}
Passos:
www.robotic.com.br
R botic
Entendendo o Sensor de Ultrassom
O sensor possue dois transdutores com cristais piezoeltricos que ressonam em uma frequncia
ultra-snica os transdutores convertem energia eltrica em energia acstica e vice-versa, um mdulo emite o sinal (trigger) e o outro recebe o eco (echo).
Os pulsos so emitidos em uma forma de cone com um feixe destinado a um objeto alvo. Os Pulsos so refletidos pelo
alvo para o sensor atravs de ecos. O dispositivo mede o tempo entre cada pulso emitido e o eco para determinar com preciso a distncia entre sensor e o alvo.
.
Quando utilizado para funes de deteco, o mtodo de ultrassons tem vantagens nicas sobre os sensores convencionais de
infravermelho: O sensor de ultrassom detectar alvos feitos de praticamente qualquer material, independentemente da cor. Eles
detectam alvos claros, transparentes e brilhantes to facilmente como materiais escuros e opaco. Esta capacidade permite que
os sensores de ultrassom sejam usados para detectar materiais que vo desde frascos de vidro transparente at pneus de
borracha preta e etc.
A placa Arduino envia um impulso curto no pino TRIG para desencadear a deteco, em seguida,
ouve um pulso de retorno no pin de echo. A durao deste segundo pulso igual ao tempo necessrio
para o ultrassom viajar ao objecto e voltar para o sensor.
www.robotic.com.br
R botic
Experimento 23: Medindo distncias e mostrando no serial monitor
ECHO - Pin Digital 7
TRIG - Pin Digital 6
// HC-SR04 SENSOR DE ULTRASSOM //

int echoPin = 7; //Varivel echopin definida como inteiro e ligado ao pin 7
int trigPin = 6; //Varivel trigpin definida como inteiro e ligado ao pin 6
void setup() {
Serial.begin (9600);
//inicia a porta serial e define velocidade transferncia de dados
pinMode(trigPin, OUTPUT); //define pino 6 como saida
pinMode(echoPin, INPUT); //define o pino 7 como entrada
}
void loop() {
//repete at verdadeiro
// Varivei que estabelece a durao do trigger,

// O resultado da distncia em centmetros:
int duration, cm;
// O trig accionado por um pulso baixo (LOW) de 2 microssegundos.
// D um pulso elevado (HIGH) de 10 microssegundos.
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
/* Pulso cuja durao o tempo (em microssegundos) a partir do envio do trig
para a recepo de seu eco fora de um objeto. */
duration = pulseIn(echoPin, HIGH);
/* Converter o tempo em uma distncia, sabendo que a velocidade do som
de 340 m / s ou 29 microssegundos por centmetro. Objeto fica na metade
da distncia percorrida.*/
cm = duration / 29 / 2;
Passos:
Serial.print(cm);
//Imprime o valor da varilvel cm no serial monitor
Serial.println(" cm"); //Imprime o nome cm e pula para uma nova linha
delay(500);
//Espera 0,5 segundo
}
www.robotic.com.br
R botic
Experimento 24: Medindo distncias e mostrando no display LCD

// HC-SR04 Ultrasonic Sensor - Robotic.com.br //
* RS - Pino digital 12
*E
* R/W - Pino GND
* ECHO - Pino digital 7
* TRIG - Trig pino digital 6
//Chama a biblioteca do LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //define os pinos do arduino para o LCD
void setup() {
Serial.begin (9600);
//inicia a porta serial e define velocidade transferncia de dados
lcd.begin(8, 2);
//Inicializa LCD e define numero de colunas/ linhas
lcd.clear();
//Limpa a tela do LCD
}
void loop() {
lcd.setCursor(0, 0); // Posiciona o cursor do LCD para a coluna 0, linha 0

int duration, cm;
Passos:
lcd.clear();
//Limpa a rea do lcd
lcd.print(cm);
//Imprime o valor da varilvel cm no LCD
lcd.print(" cm"); //Imprime a sigla cm
delay(100);
//Espera 100 milisegundos
}
www.robotic.com.br
R botic
Experimento 25: Medindo distncias e comandando um servo

Ao detectar um objeto a menos de 20 cm de distncia o servo deve girar
// HC-SR04 Sensor de Ultrassom e Servo Motor //

SIN - Pin PWM 10 (servo)
Este programa ir comandar o servo

usando a distncia de um obstculo
#include <Servo.h> //Inclui a biblioteca Servo

Servo meu_servo ; // Cria o objeto meu_servo para controlar um servo motor
void setup() {
Serial.begin(9600); //inicial a porta serial e define velocidade em bytes por segundos
meu_servo.attach(10) ; //meu_servo ligado no pin10 (porta PWM)
}
void loop() {
meu_servo.writeMicroseconds(1500); // Centraliza o cervo

delay(500); //espera 0,5 segundos
int duration, cm;
Serial.println(cm);
//mostra no serial monitor a distacia em nova linha
if (cm <= 20) {

meu_servo.writeMicroseconds(1000); // gira o servono sentido horario
delay(2000); //espera 2 segundosgira();
}
//Objeto a menos de 20cm o servo gira em um sentido
delay(500);
Passos:
//Espera 0,5 segundo
www.robotic.com.br
R botic
Experimento 26: Alarme de Incndio com o sensor DS18B20
D8 - Pino Digital 8 ligado ao Buzzer
D12 - Pino Digital 12 ligado ao DQ do DS18B20

/*
Alarme de Incndio com Dallas DS18B20
- Este programa aciona um alarme quando a temperatura
ambiente for maior que 30 graus.
*/
int temp;
int del = 250;
// Durao do Tom
int lowrange = 2000; // Valor mais baixo da freqencia usada
int highrange = 4000; // Frequencia mais alta
void setup() {
// inicializando entradas e sadas
pinMode(8, OUTPUT); // Buzzer porta 8
}
void loop() {
if (tempSensor.getTemperature() > 30){
for (int a = lowrange; a<=highrange; a++)
{
tone (8, a, del);
}
// Reduo dos tons
for (int a = highrange; a>=lowrange; a--)
{
tone (8, a, del);
}
}
}
Passos:
www.robotic.com.br
R botic
Experimento 27: Alarme de intruso com ultrasom
BUZZER - ligado ao pino digital 8

//Alarme de intruso com sensor de ultrasom
int cm;
int trig = 6;
int echo = 7;
long microseconds;
int temp;
int del = 250;
// Durao do Tom
int lowrange = 2000; // Valor mais baixo da freqencia usada
int highrange = 4000; // Frequencia mais alta
void setup() {
Serial.begin(9600);
pinMode(trig, OUTPUT);
pinMode(echo, INPUT);
pinMode(8, OUTPUT); // Buzzer porta 8
OBS: Este sistema ir emitir um alarme

tipo sirene, sempre que for detectado a
presena de um intruso no ressinto.
}
void loop() {
long duration, cm;
digitalWrite(trig, LOW);
digitalWrite(trig, HIGH);
digitalWrite(trig, LOW);
duration = pulseIn(echo, HIGH);
cm = microsecondsToCentimeters(duration);
Serial.print(cm);
Serial.print("cm");
Serial.println();
delay(100);
if (cm <= 250){alarme();} //Objeto a menos de 250cm
else {digitalWrite(8,LOW);}
}
long microsecondsToCentimeters(long microseconds) { return microseconds / 29 / 2;}
void alarme() {
Passos:
for (int a = lowrange; a<=highrange; a++)

{
tone (8, a, del);
}
// Reduo dos tons
for (int a = highrange; a>=lowrange; a--)
{
tone (8, a, del);
}
}
www.robotic.com.br
R botic
Detectando objetos com infravermelho
Sinal a 38Khz
GND
LED emissor de Infravermelho
Mdulo Receptor
de Infravermelho
Objeto
LED emissor de Infravermelho
Mdulo Receptor
de Infravermelho
www.robotic.com.br
R botic
Experimento 28: Detectando obstculos com Infrared
D4 - Pino Digital 4 ligado ao LED INFRAVERMELHO
Aproxime um obstculo do sensor de IR

//define pinos.
#define irLedPin 4
// lED infrared no pino 4
#define irSensorPin 5
// Sensor infrared no pino 5
int irRead(int readPin, int triggerPin);
//funo prottipo
int LED = 7;
void setup()
{
pinMode(irSensorPin, INPUT);
pinMode(irLedPin, OUTPUT);
delay(100);
}
void loop()
{
if (irRead(irSensorPin, irLedPin) == 0){digitalWrite(LED, HIGH);}
if (irRead(irSensorPin, irLedPin) == 1){digitalWrite(LED, LOW);}
delay(10); //Aguarda o envio
}
int irRead(int readPin, int triggerPin)
{
//um perodo em 38.5khZ de aproximadamente 26 microssegundos, ciclos int = 38
int halfPeriod = 13;
//26 microssegundos * 38 mais ou menos um milissegundo
int cycles = 38;
int i;
for (i=0; i <=cycles; i++)
{
digitalWrite(triggerPin, HIGH);
delayMicroseconds(halfPeriod);
digitalWrite(triggerPin, LOW);
delayMicroseconds(halfPeriod - 1);
// - 1 para compensar a sobrecarga digitaWrite
}
return digitalRead(readPin);
}
Passos:
www.robotic.com.br
R botic
Experimento : Enviando comandos infravermelho de um Arduino Lab para outro

Vamos precisar de 2 Arduino Lab para acionar um LED remotamente
No Arduino Lab 1(receptor), faa as ligaes conforme abaixo:
Conectando os Jumpers LAB1

No arduino Lab 2 (transmissor), Faa as ligaes conforme abaixo:
Conectando os Jumpers LAB2

D3 - Ao LED infravermelho
www.robotic.com.br
R botic
Carregue este programa no LAB1 (Receptor)
const int RECV_PIN = 2; //Receptor ligado ao pin 2
int LED = 7;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
void loop() {
digitalWrite(LED, HIGH);}
digitalWrite(LED, HIGH);}
digitalWrite(LED, LOW); }
}
}
Passos:
www.robotic.com.br
R botic
Carregue este programa na LAB 2 (emissor)

//Programa Emissor
IRsend irsend;
int flag = 0 ;
int char_in ;
void setup()
{
Serial.begin(9600) ;
colocaMenu() ;
}
void loop() {
//piscaled() ;
if(Serial.available() > 0 ) {
char_in = Serial.read() ;
if(char_in != -1) {
Serial.println(char_in,BYTE) ;
switch (char_in) {
case '1':
irsend.sendSony(144, 12);
Serial.println("Acende LED") ;
delay(1000);
break;
case '2':
Serial.println("Apaga LED") ;
delay(1000);
break;
default :
delay(1000);
break;
}
}
}
}
void colocaMenu() {
Serial.println("CONTROLANDO A UMR PELA PORTA SERIAL USB") ;
Serial.println("1 - ACENDE LED") ;
Serial.println("2 - APAGA LED") ;
Serial.println("OPCAO ? ") ;
}
Passos:
www.robotic.com.br
R botic
Experimento 29: Controlando a Unidade Mvel Robotic Remotamente Pelo Notebook
Material Necessrio:
1 - UMR - Unidade Mvel Robotic
1 - Arduino Lab
1 - Led Infravermelho de 5mm
1 - Transistor PN2222A
A UMR ser controlada a partir do Arduino Lab conectado

a porta USB. No monitor serial ir mostrar 5 opes de movimentos para UMR. Os sinais
sero emitidos pelo LED infravermelho. Para o correto funcionamento teremos
que carregar 2 programas um no Arduino Lab (emissor) e o outro na UMR (receptor)
Faa as ligaes conforme abaixo (emissor)
PN2222A
EBC
+5v
LED INFRARED 5MM
RESISTOR
100R
GND
PIN3
www.robotic.com.br
R botic
PROGRAMA EMISSOR: Copie e cole na IDE do arduino

Este programa deve ser carregado no Arduino Lab que ir emitir os sinais pelo LED IR.
IRsend irsend;
int flag = 0 ;
int char_in ;
void setup()
{
Serial.begin(9600) ;
colocaMenu() ;
}
void loop() {
//piscaled() ;
if(Serial.available() > 0 ) {
char_in = Serial.read() ;
if(char_in != -1) {
Serial.println(char_in,BYTE) ;
switch (char_in) {
case '1':
Serial.println("frente") ;
delay(1000);
break;
case '2':
Serial.println("Traz") ;
delay(1000);
break;
case '3':
Serial.println("Direita") ;
delay(1000);
break;
case '4':
Serial.println("Esquerda") ;
delay(1000);
break;
case '5':
Serial.println("Parar") ;
delay(1000);
break;
default :
delay(1000);
break;
}
}
}
}
void colocaMenu() {
Serial.println("CONTROLANDO A UMR PELA PORTA SERIAL USB") ;
Serial.println("1 - FRENTE") ;
Serial.println("2 - TRAZ") ;
Serial.println("3 - DIREITA") ;
Serial.println("4 - ESQUERDA") ;
Serial.println("5 - PAPAR") ;
Serial.println("OPCAO ? ") ;
}
www.robotic.com.br
R botic
PROGRAMA RECEPTOR: Copie e cole na IDE do arduino

Este programa deve ser carregado na UMR (Unidade Mvel Robotic).
#define NBR_SERVOS 12 // Numero de Servos ligados. Maximo de 48 arduino MEGA, 12 para outros arduinos
const int RECV_PIN = 2; //SENSOR DE INFRARED NO PIN 2
void setup()
{
Serial.begin(9600);
Servos[1].attach(8,880,2400) ; //SERVO DIREITO NO PIN 8
Servos[2].attach(9,880,2400) ; //SERVO ESQUERDO NO PIN 9
irrecv.enableIRIn(); // Start the receiver
delay(15);
}
void loop() {
if (results.value == 144){ //Chave CH+ frente
delay(15);}
if (results.value == 2192){ //Chave CH- volta
delay(15); }
if (results.value == 1168){ //Chave VOL+ direita
delay(15); }
if (results.value == 3216){ //Chave VOL+ esquerda
delay(15); }
if (results.value >= 3536){ //Chave JUMP PRA
delay(15); }
}
}
www.robotic.com.br
UNIDADE MVEL ROBOTIC

Sensor de Ultrasom
Shield Navigation
Arduino
Controle Remoto
Servos
Sensor de Trilha
R botic
Montagem
1 - Inserir o shield Navigation nos conectores do arduino

www.robotic.com.br

ARDUINO LAB - GUIDE

Enviado por

Dados do documento

Título 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

ARDUINO LAB - GUIDE

Enviado por

Direitos autorais:

Formatos disponíveis

R botic

Arduino Lab - Microcontroladores

Arduino Duemilanove Atmega 328

Diferena entre Arduino UNO e Duemilanove:

Arduino Lab - Microcontroladores

Arduino UNO ou Duemilanove com Atmega328

Arduino Lab - Microcontroladores

Pinos com funes especficas:

Arduino Lab - Microcontroladores

Arduino Lab - Microcontroladores

Arduino Lab - Microcontroladores

Rel Chaves LDR Buzzer

OBS: Para os experimentos deste manual sero necessrios as seguintes bibliotecas:

Arduino Lab - Microcontroladores

Experimento 1: LED Diodo Emissor de Luz

O led est diretamente polarizado, e emite luz,

O led est inversamente polarizado, e no emite luz,

Ligando um LED no Arduino

Arduino Lab - Microcontroladores

Experimento 1: Led piscante

Copie e cole este programa na IDE do arduino

Arduino Lab - Microcontroladores

Experimento 3: Gerando sons - Buzzer

Copie e cole este programa na IDE do arduino

D8 - Pino Digital 8 ligado ao BUZZER

Arduino Lab - Microcontroladores

Entendendo o Servo Motor RC (rdio controle)

Pulsos PWM para movimentar um Servo

Largura de Pulso de 2000 microsegundos o servo gira em sentido anit-horrio

Largura de Pulso de 1000 microsegundos o servo gira em sentido horrio

Arduino Lab - Microcontroladores

Experimento 4: Controlando um Servo Motor com pulsos em microsegundos

#include <Servo.h> //inclue a biblioteca Servo

//Meu_servo ligado no pino 9 (PWM)

// Envia um pulso de 1500 microsegundo mantendo o servo parado em 90

Arduino Lab - Microcontroladores

Experimento 4.1: Controlando um Servo Motor por ngulos.

Largura de pulso 544

#include <Servo.h> //inclue a biblioteca Servo

//Cria o objeto meu_servo

//Repete enquanto for verdadeiro

myservo.write(90) ; // pra o servo na posio central 90

Arduino Lab - Microcontroladores

Copie e cole este programa na IDE do arduino

Arduino Lab - Microcontroladores

Experimento 5: Controlando um LED pelo sersor de luz LDR

Faa as ligaes conforme abaixo

Copie e cole este programa na IDE do arduino

Arduino Lab - Microcontroladores

Experimento 6: Controlando um Servo Motor pelo sensor de luz LDR

Copie e cole este programa na IDE do arduino

//Programa para controlar o servo com LDR

Arduino Lab - Microcontroladores

Experimento 7: Controlando um LED pela Chave Tctil

Copie e cole este programa na IDE do arduino

// Chave tctil no pin 2

Arduino Lab - Microcontroladores

Experimento 8: Controlando um Servo Motor pela Chave Tctil

Copie e cole este programa na IDE do arduino

* Ligaes das Chaves Tactils

* Ligao do Servo Motor

PIN9 - SIN - Pino digital 9 ligado ao pino de sinal do servo

//faz a leitura da chave 1