FACULDADE DO CENTRO LESTE

RENAN ROGER LOUZADA

MARCOS ANTONIO SILVA VIEIRA

APOSTILA ARDUINO

SERRA

2013

RENAN ROGER LOUZADA

MARCOS ANTONIO SILVA VIEIRA

APOSTILA ARDUINO

Projeto apresentado ao Curso de Graduação em Engenharia de Automação e Controle,

da Faculdade do Centro Leste, como anexo do TCC de Renan Louzada e Marcos Vieira.

SERRA

2013

ÍNDICE

1. RESUMO ..................................................................................................... 6

2. FUNDAMENTOS ......................................................................................... 6

3. PRIMEIRA SKETCH.................................................................................... 7

4. PROGRAMANDO POR FUNÇÕES .......................................................... 11

5. PINOS DIGITAIS ....................................................................................... 14

6. PINOS DE ENTRADA ANALOGICA......................................................... 19

7. SERIAL ...................................................................................................... 20

8. MEMORIA ................................................................................................. 26

9. PWM .......................................................................................................... 27

10. BIBLIOTECA SERVO ............................................................................ 28

1. RESUMO

Apostila elaborada a partir do site arduino.cc, sendo traduzido os principais tópicos com

finalidade de facilitar o envolvimento dos alunos iniciantes a programação com a

praticidade de projetos envolvendo sistemas microcontrolados.

2. FUNDAMENTOS

Este tópico contem explicações sobre alguns elementos do hardware e software do

Arduino e algumas concepções contidas neles.

Básicos

Sketch: Os vários componentes que compõem a lógica e como eles funcionam.

Microcontroladores

Digital Pins: Como os Pinos trabalham e o que significa para eles a configuração como

entrada ou saída.

Analog Input Pins: Detalhes sobre a conversão anlogica para digital e outras utilidades

dos Pinos.

PWM: Como a função analogWrite() simula uma saida analogical usando uma

modulação de largura de pulso.

Memory: Os vários tipos de memória disponível na placa Arduino.

Técnicas de programação

Variables Como definir variáveis.

Functions: Como definir funções.

Libraries: Como escrever a própria biblioteca.

Circuits

Arduino on a Breadboard: Usando o microcontrolador do Arduino em um Protoboard.

3. PRIMEIRA SKETCH

No guia de iniciação (Windows, Mac OS X, Linux), você irá encontrar uma Sketch que

pisca um LED. É um tutorial que irá ensinar como cada parte da Sketch funciona.

Caminho: Software arduino / File / Exemples / 01.Basics / Blink

SKETCH

Sketch é o nome que o arduino usa para a interface do programa (software). Este é o

local onde um código único pode ser baixado para o hardware do Arduino e após

executado.

VARIÁVEIS

A variavel é o local onde é armazenado um dado. Este possue um nome, tipo e valor.

Para demonstrar no Exemplo da Sketch Blink acima citada é declarada uma variável

como o nome ledPin, tipo inteiro e valor inicial igual a 13. Este é utilizado para indicar

em qual pino do Arduino o LED esta conectado.Toda vez que o nome ledPin aparecer

no código, o valor será recuperado. Neste caso, o usuário somente escreve a variável

ledPin ao invés de ficar lembrando o pino 13 em todo código.A vantagem de se utilizar

uma variável Le a facilidade de alterar por exemplo o pino que o LED esta sendo

utilizado, alterando somente o valor da variável você não precisa alterar todo o código.

Frequentemente, entretanto, os valores da variável podem mudar enquanto a Sketch está

rodando. Por exemplo, um valor pode ser armazenado na variável após uma entrada.

FUNÇÕES

Uma função (com uma subrotina conhecida) é o nome dado a um pedaço do código que

pode ser usado em qualquer local de uma Sketch. Por exemplo, esta definido na função

setup() do exemplo Blink:

void setup()

{

pinMode(ledPin, OUTPUT); // Seta o pino digital como saída.

}

A primeira linha providencia a informação a respeito da função, como o nome já diz,

“setup”. O texto antes e após do nome especificado retorna o tipo de parâmetro:

explicado melhor a seguir. O código entre { } é chamado de corpo da função, ou seja, o

que a função faz.

#INCLUDE

#include é utilizado para inserir bibliotecas na sua sketch. Possibilita ao programador

acessar um grande grupo de bibliotecas C padrão ( grupos de funções pré-realizadas), e

bibliotecas escritas especialmente para o Arduino.

A principal pagina de referencia para as bibliotecas AVR C ( AVR se refere ao

microcontrolador Atmel na placa Arduino) esta no site (http://www.nongnu.org/avr-

libc/user-manual/modules.html).

Note que #include, é similar com #define e não possui final com ponto e virgula,

apresentará erro se adicionado.

Exemplo

This example includes a library that is used to put data into the program space flash

instead of ram. This saves the ram space for dynamic memory needs and makes large

lookup tables more practical.

Este exemplo inclui uma biblioteca que é utilizada para colocar dados no espaço do

programa de memória flash ao invés da RAM. Isto salva o espaço da RAM para

memória dinâmica e torna a mesa de pesquisa mais pratica.

#include <avr/pgmspace.h>

prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 , 9128, 0, 25764, 8456,

0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};

CHAR

Descrição

Um tipo de dado que utilize 1 byte de memória para armazenar valores de character.

Caracteres literais são escritos em únicas citações, como ‘A’ ( Para múltiplos caracteres

- string – usam outras citações com ‘ABC’.

Caracteres sao armazenas como numeros. Pode ser visto o código especifico na tabela

ASCII. Isto significa que é possível realizar somas aritméticas com caracteres, conforme

cada valor da tabela.

The char datatype is a signed type, meaning that it encodes numbers from -128 to 127.

For an unsigned, one-byte (8 bit) data type, use the byte data type.

O tipo de dado char é assinado, o que significa que codifica números de -128 a 127.

Para tipo de dados não assinados, um-byte (8 bits), usa-se o tipo de dado byte.

EXEMPLO

char myChar = 'A';

char myChar = 65; // ambos são equivalentes

CHAR()

Descrição

Converte um valor ao tipo de character.

Sintaxe

char(x)

Parametros

x: valor de qualquer tipo

Retorno

char

SETUP()

A função setup() é chamada quando se inicial uma sketch. É utilizado para inicializar

variáveis, modos dos pinos, utilização de bibliotecas, etc. A função setup() irá funcionar

somente uma vez, após cada inicialização ou reset da Placa Arduino.

Exemplo

int buttonPin = 3;

void setup(){

Serial.begin(9600);

pinMode(buttonPin, INPUT);

}

void loop()

{

// ...

}

LOOP()

Após criar a função setup(), que inicializa e seta os valores iniciais, a função loop() faz

precisamente os que o nome sugere, faz um loop consecutivo, permitindo seu programa

alterar suas respostas. Use esta controlar ativamente a placa Arduino.

Example

const int buttonPin = 3;

// setup inicializa o serial o pino com botão

void setup()

{

Serial.begin(9600);

pinMode(buttonPin, INPUT);

}

// loop checa o pino com botão a cada tempo

// e envia dados serial quando botão pressionado

void loop()

{

if (digitalRead(buttonPin) == HIGH)

Serial.write('H');

else

Serial.write('L');

delay(1000);

}

DELAY()

Descrição

Pauses the program for the amount of time (in miliseconds) specified as parameter.

(There are 1000 milliseconds in a second.)

Pausa o programa por um período de tempo (em milisegundos) especifico com

parâmetro. (1000ms = 1 segundo)

Sintaxe

delay(ms)

Parametros

ms: numero de milisegundo para pausa

Retorno

Nenhum

Exemplo

int ledPin = 13; // LED conectado ao pino digital 13

void setup()

{

pinMode(ledPin, OUTPUT); // Seta o pino digital como saida

}

void loop()

{

digitalWrite(ledPin, HIGH); // Seta o LED ligado

delay(1000); // Aguarda um segundo

digitalWrite(ledPin, LOW); // Seta o LED desligado

delay(1000); // Aguarda um segundo

}

4. PROGRAMANDO POR FUNÇÕES

Segmentando códigos em funções permite ao programador criar pedaços modulados de

código que fornece maior desempenho e define parâmetros e retornos para certa área do

código onde as funções foram chamadas. Este caso típico de criação de funções é

utilizado quando é necessário um melhor desempenho da mesma ação em diferentes

pontos do programa.

Para o programador acostumado a utilizar o BASIC, o Arduino fornece funções ( e

extensões) com utilidade de sub-rotinas (GOSUB em BASIC).

Padronizando fragmentos de códigos nas funções possibilita as seguintes vantagens:

Funções ajudam ao programador a organizar melhor o código. Ajudam também a

contextualizar o programa.

Funções possibilitam codificar uma ação a um local e assim esta função somente precisa

ser compilada uma vez.

Reduz também a chance de erros em modificações , caso necessitem de modificação.

Funções tornam as Sketchs menores e mais compactas devido as chamadas das funções

conforme necessidade do código.

É mais simples reutilizar o código em outros programas fazendo os mesmo de forma

modular, tendo um melhor efeito visual e facilitando a sua reutilização de funções

especificas.

Existem duas funções requeridas na Sketch do Arduino, setuo() e loop(). Outras funções

devem ser criadas fora do escopo das duas funções citadas acima. Como exemplo, será

criado uma simples função para múltiplos de dois números.

EXEMPLO

Para “chamar” essa simples função com multiplas funções, é necessário passar os

parâmetros com os tipos de dados esperados.

void loop{

int i = 2;

int j = 3;

int k;

k = myMultiplyFunction(i, j); // k agora contem 6

}

A função precisa ser declarada for a de qualquer outra função, então

"myMultiplyFunction()" poderá ir antes ou depois da função “loop()”.

Toda a Sketch deverá se apresentar da seguinte forma:

void setup(){

Serial.begin(9600);

}

void loop() {

int i = 2;

int j = 3;

int k;

k = myMultiplyFunction(i, j); // k agora contem 6

Serial.println(k);

delay(500);

}

int myMultiplyFunction(int x, int y){

int result;

result = x * y;

return result;

}

OUTRO EXEMPLO

Esta função irá ler um sensor 5 vezes com o analogRead() e calcular a media de cinco

leituras. Os dados são colocados em escala de 8 bits (0-255), inverte, retorna o resultado

invertido.

int ReadSens_and_Condition(){

int i;

int sval = 0;

for (i = 0; i < 5; i++){

sval = sval + analogRead(0); // sensor on analog pin 0

}

sval = sval / 5; // average

sval = sval / 4; // scale to 8 bits (0 - 255)

sval = 255 - sval; // invert output

return sval;

}

Para chamar a função basta apenas assimilar uma variavel.

int sens;

sens = ReadSens_and_Condition();

5. PINOS DIGITAIS

Os pinos digitais do arduino podem ser configurados como entradas e saidas. Este

documento explica o funcionamento dos pinos nesta configurações. Quando o titulo do

documento se refere a pinos digitais, é importante notar que a vasta maioria dos tipos de

Arduino (Atmega) pinos analógicos, podem ser configurados e usados, exatamente, da

mesma forma que os pinos digitais.

PROPIEDADES DOS PINOS DIGITAIS CONFIGURADOS COM ENTRADA

O Arduino (Atmega) possui seus pinos configurados por default como entradas, então

ele não precisão ser explicitamente configurados por declaração como entradas com o

pinMode(). Os pinos configurados como entradas possuem um estado de alta

impedância. Um caminho para explicar tal fato é o pino de entrada demandar

extremamente de uma pequena amostra do circuito, equivalente a uma serie de resistor

de 100 megaohms na frente do pino. Isto significa que é necessário um baixa corrente

para mover a entrada de um estado para outro, o que torna os pinos utilizáveis para

varias aplicações como leitor de LED como foto-diodo, implementação de sensor

capacitivo, leitor de sensor analógico configurado como RCTime.

Este tambem significa que os pinos de entrada com nada conectados aos mesmos, ou

com cabos conectados ao mesmo sem estarem conctados a outros circuitos, será

reportado aparentemente com alterações aleatórias do estado dos pinos, assumindo um

certo ruído do circuito, ou a capacitância acoplada a o estado de um pino próximo.

Resistores de Pullup

Frequentemente é utilizado para eliminar tais ruidos nas entradas dos pinos os resistors

de pullup (conectado ao +5) ou resistors de pulldown (conectado ao terra) com o valor

comumente utilizado de 10Kohms.

There are also convenient 20K pullup resistors built into the Atmega chip that can be

accessed from software. These built-in pullup resistors are accessed in the following

manner.

Existe tambem o conveniente de acessar os resistors de pullup de 20K construidos

internamente no microcontrolador Atmenga que pode ser acessado via software. Estes

podem ser acessados como se segue:

pinMode(pin, INPUT); // Seta pino como entrada.

digitalWrite(pin, HIGH); // Aciona resistors de pullup.

Note que os resistores de pullup fornecem a corrente necessária para acender um LED

conectado ao pino configurado como entrada. Se o LED conectado aparecer trabalhando

muito vagamente, provavelmente estará ocorrendo devido o programador esquecer de

utilizar o pinMode() para setar o pino como saida.

Note tambem que os resistores de pullup são controlados pelo o mesmo registrador

(Local da memória interna do microcontrolador) que controla também o pino como

ALTO ou BAIXO. Consequentemente o pino pode ser configurado como ALTO se o

pino for trocado por uma saída com o pinMode(), ou tambem, uma saida pode ser

deixada em ALTA e o pullup trocado por uma entrada com o pinMode().

NOTA: O pino digital 13 é mais difícil de usar como entrada digital do que os outros

devido ele possuir um LED e um resistor acoplado ao mesmo na maioria das placas

Arduino. Se o usuário habilitar os resistores de 20k (pullup), irá pendurar uma tensão de

1,7V ao contrario da esperada de 5V, devido ao LED da interno da placa, ou seja, se for

necessário utilizar o pino 13 como entrada utilize um resistor externo de pullup.

PROPRIEDADES DOS PINOS CONFIGURADOS COMO SAÍDA

Os pinos configurados como saida pelo pinMode() são usados com um estado de baixa

impedância. Isto significa que pode ser fornecido uma quantidade substencial de

corrente ao circuito. Os pinos do Atmega podem fornecer uma corrente positiva ou

negativa de 40mA para os circuitos conectados. Esta é uma corrente suficiente para

ascender um LED (sem esquecer do resistor em serie), ou acionar diversos sensores por

exemplo, mas não o suficiente para acionar motores, relés e solenoides.

Pequenos circuitos nos pinos do Arduino, ou a tentativa de acionar dispositivos que

demandam de grande corrente pode danificar ou destruir as saídas transistorizadas dos

pinos ou danificar o microcontrolador Atmega. Frequentemente este ato resulta na

alienação do pino do microcontrolador mas mantém o restante funcionando

adequadamente. Por esta razão é uma boa ideia conectar aos pinos de saída resistores de

470ohms ou 1K, a não ser que a corrente máxima for necessária para uma aplicação em

particular.

PINMODE()

Descrição

Configura o pino especificado como entrada ou saída. Veja a descrição dos pinos

digitais e suas funcionalidades.

As of Arduino 1.0.1, it is possible to enable the internal pullup resistors with the mode

INPUT_PULLUP. Additionally, the INPUT mode explicitly disables the internal

pullups.

Com o Arduino 1.0.1, é possivel habilitar os resistors de pullup interno com o modo

INPUT_PULLUP. Adicionando, o modo explicitado INPUT desabilita os pullups

internos.

Sintaxe

pinMode(pin, mode)

Parametros

pin: Numero do pino que necessita configurar.

modo: INPUT, OUTPUT, or INPUT_PULLUP.

Retorno

Nenhum

Exemplo

int ledPin = 13; // LED conectado ao pino digital 13

void setup()

{

pinMode(ledPin, OUTPUT); // seta o pino digital como saida

}

void loop()

{

digitalWrite(ledPin, HIGH); // seta o led ligado

delay(1000); // aguarda um segundo

digitalWrite(ledPin, LOW); // seta o led desligado

delay(1000); // aguarda um segundo

}

Nota

Os pino analógicos de entrada pode ser usado como pino digital, referindo como A0,

A1, etc.

DIGITALWRITE()

Descrição

Escreve valores ALTO ou BAIXO nos pinos digitais.

Se o pino foi configure como saida com o pinMode(), a tensão será setada ao

correspondente valor: 5V(ou 3,3V na placas especificas) para Alto e 0V (Terra) para

Baixo.

Se os pinos forem configurados com entrada, escrevendo o valor ALTO com o

digitalWrite() irá habilitar os resistores de pullup interno de 20K. Escrevendo BAIXO

irá desabilitar o pullup.

Sintaxe

digitalWrite(pin, value)

Parametros

pin: Numero do pino

value: Alto ou Baixo

Retorno

Nenhum

Example

int ledPin = 13; // LED conectado ao pino digital 13

void setup()

{

pinMode(ledPin, OUTPUT); // seta o pino digital como saida

}

void loop()

{

digitalWrite(ledPin, HIGH); // seta o LED ligado

delay(1000); // aguarda um segundo

digitalWrite(ledPin, LOW); // seta o LED desligado

delay(1000); // aguarda um segundo

}

Nota

O pino analógico de saída pode ser usado como pino digital, referindo como A0, A1,

etc.

DIGITALREAD()

Descrição

Reads the value from a specified digital pin, either HIGH or LOW.

Lê os valores especificos dos pinos digitais, como ALTO ou BAIXO.

Sintaxe

digitalRead(pin)

Parametros

pin: numero do pino digital que deseja ler (int)

Retorno

HIGH or LOW

Example

Seta o pino 13 com o mesmo valor que o pino 7, declarado como entrada.

int ledPin = 13; // LED conectado ao pino digital 13

int inPin = 7; // pushbutton conectado ao pino digital 7

int val = 0; // Variável para armazenar o valor lido

void setup()

{

pinMode(ledPin, OUTPUT); // Seta o pino digital 13 como saida

pinMode(inPin, INPUT); // Seta o pino digital 7 como entrada

}

void loop()

{

val = digitalRead(inPin); // realiza leitura do pino digital

digitalWrite(ledPin, val); // seta o LED com o valor do botão

Nota

Se o pino não estiver conectado com nada, o digitalRead() pode retornar ALTO ou

BAIXO (aleatoriamente).

6. PINOS DE ENTRADA ANALOGICA

A description of the analog input pins on an Arduino chip (Atmega8, Atmega168,

Atmega328, or Atmega1280).

Uma descrição dos pinos analogicos de entrada do microcontrolador do Arduino

(Atmega8, Atmega168, Atmega328, ou Atmega1280).

CONVERSOR ANALOGICO/DIGITAL

O controlador Atmega usado no Arduino contem embutido 6 canais conversores de

analógico para digital. O conversor de 10 bits de resolução, retornam inteiros de 0 a

1023. Enquanto a função principal dos pinos analógicos para muitos usuários do

Arduino são utilizados para leituras de sensores analógicos, os pinos analógicos

possuem a funcionalidade de proposta geral de entrada e saída com pinos (GPIO),

semelhante aos pinos digitais de 0-13.

Consequentemente, se os usuários necessitaram dos pinos de proposta geral de

entrada/saida, e todas as saídas analógicas não estiverem sendo usadas, os pinos de

entrada analógica podem ser usadas para GPIO.

MAPEANDO OS PINOS

Os pinos analógicos podem ser utilizados identicamente aos pinos digitais, Usando a

analogia A0 (Para entrada analógica 0) A1, etc. Por exemplo, o código abaixo seta o

pino 0 como saída, e em nível ALTO.

pinMode(A0, OUTPUT);

digitalWrite(A0, HIGH);

RESITORES DE PULLUP

Os pinos analogicos possuem resistors de pullup, que trabalham identicamente aos

resistors de pullup dos pinos digitais. Estes possuem características de comando com

segue:

digitalWrite(A0, HIGH); // seta pullup na entrada analogical do pino 0

Enquanto o pino é uma entrada.

É necessario atenção no entanto pois alterações sobre os resistores de pullup irão afetar

os valores reportados ao analogRead().

DETALHES E ADVERTENCIAS

O comando do analogRead não irá trabalhar corretamente se os pinos forem setados

previamente como saídas, neste caso, sete o mesmo novamente como entrada antes de

usar o analogRead. Similarmente se os pinos forem setados para o nível ALTO de

umam saída, os resistores de pullup serão setados, quando trocados novamente como

entrada.

O datasheet do Atmega possue alertas contra a mudança dos pinos de entrada analógica

fechados com proximidade temporal para leituras A/D (analogRead) entre os outros

pinos analógicos. Este pode causar ruído elétrico e introduzir oscilações no sistema

analógico. Isto pode ser desejável, após manipulação dos pinos analógicos ( no modo

digital), para adicionar um pequeno delay após utilizar o analogRead() para ler outro

pino analógico.

7. SERIAL

Usado para comunicação entre a placa Arduino e o computador ou outros dispositivos.

Todas as placas arduino possuem a ultima porta como porta serial ( Tambem conhecida

como UART e USART): Serial. A comunicação é feita nos pinos digitais 0 (RX) e 1

(TX) assim como é feita via porta USB com o computador. No entando, verificando as

funcionalidades, não é possível utilizar os pinos digitais 0 e 1 como entradas ou saídas.

Pode ser utilizado o ambiente embutido de monitoração do Arduino para vericar a

comunicação da placa Arduino. Basta apenas acessar via botão serial monitor da barra

de ferramentas e selecionar a mesma taxa de transmissão de dados usada na função

Begin().

O Arduino Mega possui tres portas serial adicionais: Serial 1 no pino 19 (RX) e 18

(TX), Serial 2 no pino 17(RX) e 16 (TX), Serial 3 no pino 15 (RX) e 14 (TX). Para usar

estes pinos para comunicação com o computador pessoal é necessário um adaptador

adicional USB para Serial. Para comunicar externamente com um dispositivo TTL

serial, conecte o pino TX no pino do seu dispositivo RX, o pino RX no pino TX do seu

dispositivo e o terra do seu dispositivo com o terra do Arduino. (Não conecte os pinos

diretamente com a porta serial RS232, pois esta opera com + ou – 12V e pode danificar

sua placa Arduino).

O Arduino Due possui tres adicionais portas serial 3.3V TLL. Serial 1 no pino 19 (RX)

e 18 (TX), Serial 2 no pino 17(RX) e 16 (TX), Serial 3 no pino 15 (RX) e 14 (TX). Os

pinos 0 e 1 são conectados nos correspondentes pinos do Atmega 16U2 que contem o

chio serial de conversão USB para TTL conectada a porta depuradora USB.

Adicionalmente, possui uma porta no chip SAM3X de conversão Serial para USB.

A placa Arduino Leonardo utiliza o Serial 1 para comunicar via TTL (5V) serial no pino

0 (RX) e 1 (TX). O serial é reservado para a comunicação USB CDC. Para mais

informação, referente a placa Arduino Leonardo vá ao site arduino.cc na pagina de

hardware.

PRINTLN()

Descrição

Imprime os dados na porta serial readaptado para entendimento simples como segue na

tabela ASCII. Este comando segue da mesma forma no Serial.print().

Sintaxe

Serial.println(val)

Serial.println(val, format)

Parametros

val: o valor a ser impresso, qualquer tipo de dado.

format: Especifica o numero base (dados de tipo integral) ou numerous de locais

decimais (tipos ponteiros flutuante).

Retorno

size_t (long): println() Retorna o numero de bytes escritos, embora a leitura do numero

seja opcional.

Example:

/*

Entrada analogical

Le a entrada analogical no pino 0 e imprime o valor.

*/

int analogValue = 0; // Variavel para assegurar o valor analogico

void setup() {

// open the serial port at 9600 bps:

Serial.begin(9600);

}

void loop() {

// Le o valor analogico no pino 0

analogValue = analogRead(0);

// Imprime os valores em diferentes formatos.

Serial.println(analogValue); // print as an ASCII-encoded decimal

Serial.println(analogValue, DEC); // print as an ASCII-encoded decimal

Serial.println(analogValue, HEX); // print as an ASCII-encoded hexadecimal

Serial.println(analogValue, OCT); // print as an ASCII-encoded octal

Serial.println(analogValue, BIN); // print as an ASCII-encoded binary

// Tempo de 10 milisegundos até a proxima leitura.

delay(10);

}

AVAILABLE()

Descrição

Seleciona um numero de bytes (caracteres) disponiveis para leitura via porta serial.

Estes dados de recente chegada são armazenados no buffer de recebimento do receptor

serial (que segura 64 bytes). available() herda da Stream a utilidade da classe.

Sintaxe

Serial.available()

Somente no Arduino Mega:

Serial1.available()

Serial2.available()

Serial3.available()

Parametros

Nenhum

Retorno

O numero de bytes disponiveis para leitura

Exemplo

int incomingByte = 0; // para entrada de dados serial

void setup() {

Serial.begin(9600); // abre a porta serial, seta a taxa de dados para 9600 bps

}

void loop() {

// Envia os dados somente quando recebe os dados:

if (Serial.available() > 0) {

// Lê os dados de entrada:

incomingByte = Serial.read();

// escreve o recebimento:

Serial.print("I received: ");

Serial.println(incomingByte, DEC);

}

}

Arduino Mega example:

void setup() {

Serial.begin(9600);

Serial1.begin(9600);

}

void loop() {

// read from port 0, send to port 1:

if (Serial.available()) {

int inByte = Serial.read();

Serial1.print(inByte, BYTE);

}

// read from port 1, send to port 0:

if (Serial1.available()) {

int inByte = Serial1.read();

Serial.print(inByte, BYTE);

}

}

READ()

Descrição

Lê a entrada de dados serial. read() herda a classe da utilidade STREAM

Sintaxe

Serial.read()

Somente no Arduino Mega.

Serial1.read()

Serial2.read()

Serial3.read()

Parametros

Nenhum

Retorno

O primeiro byte dos dados de entrada serial disponivel ( ou 1 se dados não disponíveis)

– int

Exemplo

int incomingByte = 0; // Para dados de entrada serial

void setup() {

Serial.begin(9600); // Abre a porta serial com taxa de transmissão de 9600bps

}

void loop() {

// Envia dados somente quando recebe os dados

if (Serial.available() > 0) {

// Lê o byte de entrada

incomingByte = Serial.read();

// Exibe qual dado recebido.

Serial.print("I received: ");

Serial.println(incomingByte, DEC);

}

}

WRITE()

Descrição

Escreve dados binarios na porta serial. Este dados é enviado com um byte ou uma serie

de bytes. Para enviar caracteres representando os dígitos de um numero é necessário

utilizar a função print() no lugar da função write().

Sintaxe

Serial.write(val)

Serial.write(str)

Serial.write(buf, len)

No Arduino Mega suporta: Serial1, Serial2, Serial3 (No lugar de Serial)

Parametros

val: valor a ser enviado como um unico byte

str: string a ser enviada como uma serie de bytes

buf: Uma ordem para envio de uma serie de bytes

len: o tamanho do buffer

Retorno

byte

write() irá retornar o numero de bytes escritos, embora a leitura seja opicional.

Exemplo

void setup(){

Serial.begin(9600);

}

void loop(){

Serial.write(45); // envia um byte com o valor 45

int bytesSent = Serial.write(“hello”); //envia uma string “hello” e retorna o tamanho

da mesma

}

8. MEMORIA

Existem três pools de memoria no microcontrolador usado na placa Arduino:

Memoria Flash (Espaco do programa) é quando a Sketch do Arduino é armazenada.

SRAM (memoria de acesso estatico randomico) é quando a Sketch cria e manipula as

variáveis quando estão rodando.

EEPROM é o espaço de memoria que programadores podem usar para armazenar as

informações de longo prazo.

Memoria Flash e memoria EEPROM sao nao volateis ( a informação persiste após

desligamento da alimentação). Memória SRAM é volátil e ira perder dados no ciclo de

alimentação.

O microprocessador Atmega328 encontrado no Arduino Uno possui as seguintes

caracateriscas de memoria:

Flash 32k bytes (of which .5k is used for the bootloader)

SRAM 2k bytes

EEPROM 1k byte

O Atmega 2560 no Arduino Mega2560 possui maior espaço de memoria

Flash 256k bytes (of which 8k is used for the bootloader)

SRAM 8k bytes

EEPROM 4k byte

Note que o Arduino Uno nao possui muita memoria SRAM disponivel. É simples

utilizar todo espaço disponível tendo strings no programa. Por exemplo, na declaração:

char message[] = "I support the Cape Wind project.";

Adiciona 32 bytes na SRAM ( cada character utilize um byte). Este não apresenta ser

muito, mas demora muito para atingir 2048, especialmente se utilizado um texto grande

para exibir no display, ou uma grande tabela de procura, por exemplo.

Se o funcionamento for for a da SRAM, seu programa pode apresentar falhas

inesperadas de diferentes formas. Irá ocorrer de realizar o upload normal, porem ao

rodar o programa irá ocorrer comandos estranhos. Para checar o que esta ocorrendo,

usa-se comentar ou encurtar as strings em toda estrutura de dados da Sketch (Sem

alterar o código). Caso funcione com sucesso, provavelmente o programa esta rodando

fora da SRAM. Existem algumas atitudes a serem feitas para endereçar este problema:

Se a Sketch compartilha com um programa rodando em um computador

(desktop/laptop), pode-se tentar alterar os dados calculados no computador, reduzindo o

carregamento do Arduino.

Se possue tabelas de pesquisa ou matrizes longas, utilize o menor tipo de dado

necessário para armazenar os valores que precisa. Por exemplo, um valor inteiro utiliza

dois bytes, enquanto um byte utiliza apenas um ( mas armazena um range menor de

valores).

Se não for necessário alterar as strings ou os dados enquando a Sketch estiver rodando,

pode-se armazenar os dados na memória flash (programa) ao invés da SRAM, para isto,

utilize a palavra chave PROGMEM (http://www.arduino.cc/en/Reference/PROGMEM).

9. PWM

O exemplo Fading demonstra a utilização da saída analógica (PWM) que reduz a

luminosidade de uma LED. Este exemplo esta deipsonivel em Software Arduino / File /

Sketchbook / Examples / Analog.

Modulação por largura de pulso, ou PWM, é uma técnica utilizada para obter resultados

analógicos por meios digitais. O controle digital é utilizado para criar uma onda

quadrada, ou seja, um sinal chaveado entre ligado e desligado. Este liga/desliga

padronizado pode simular tensões entre 0(mínimo) e 5V(Máximo) alterando a parcela

de tempo que o sinal e utilizado associado ao tempo em que o sinal é retirado. A

duração deste “tempo” é chamado de largura de pulso. Para ter valores analógicos

variando, é alterado ou modulado a largura do pulso. Se repetido este liga/desliga o

mais rápido possível com um LED por exemplo, o resultado será um sinal estável de

voltagem entre 0 e 5V controlando a luminosidade do mesmo.

In the graphic below, the green lines represent a regular time period. This duration or

period is the inverse of the PWM frequency. In other words, with Arduino's PWM

frequency at about 500Hz, the green lines would measure 2 milliseconds each. A call to

analogWrite() is on a scale of 0 - 255, such that analogWrite(255) requests a 100% duty

cycle (always on), and analogWrite(127) is a 50% duty cycle (on half the time) for

example.

No gráfico a seguir, as linhas verdes representão um período regular de tempo. Esta

duração ou período é o inverso da frequência PWM. Em outras palavras, com a

frequência PWM do Arduino entre 500Hz, a linha verde ira demonstrar 2 milissegundos

cada. A chamada da função analogWrite() possui a escala entre 0 e 255, sendo o 255 o

cliclo Maximo (Sempre ligado) e o 0 o cicli mínimo (Desligado).

Figura 1 - Ciclo PWM

10. BIBLIOTECA SERVO

Esta biblioteca permite que a placa Arduino controle RC (Atividade) dos servo motores.

Os servos possuem integrados engrenagens e eixo que pode sem precisamente

controlada. Os servos por padrão permitem que o eixo seja posicionado em vários

ângulos, usualmente entre 0 e 180 Graus. Servos com rotação continua permitem que o

eixo possua rotação com diferentes velocidades.

A Biblioteca Servo suporta 12 motores em praticamente todas as placas Arduino e 48 na

placa Arduino Mega. As placas excluindo a Mega, usam a biblioteca desativando a

função analogWrite() (PWM) funcionalmente nos pinos 9 e 10, querendo ou não esta

funcionalidade para Servos neste pinos. Na placa Mega pode ser usado 12 Servos ou

mais sem interferir na funcionalidade PWM. Usando entre 12 e 23 motores irá

desabilitar o PWM nos pinos 11 e 12.

CIRCUITO

Servo motores possuem 3 cabos de conexão: Alimentação, Terra e Sinal. A conexão de

alimentação geralmente é vermelha, e deve ser conectada no pino de 5V do Arduino. A

conexão Terra geralmente é preta ou marrom e deve ser conectada no pino de Terra do

Arduino. A conexão de sinal é tipicamente amarela, laranja ou branca e deve ser

conectada no pino digital correspondente a lógica no Arduino. Lembrando que os Sevos

consomem consideravelmente corrente e se necessário controlar mais que 2 , será

necessário uma alimentação externa (i.e. Diferente do pino +5V do Arduino). Certifique

de conectar o terra do Arduino junto com o terra da fonte externa.

FUNÇÃO ATTACH()

Descrição

Liga a variável Servo a um pino do Arduino. A biblioteca Servo suporta servos em

apenas dois pinos, o 9 e 10 no Arduino 0016 ou mais antigo.

Sintaxe

servo.attach(pin)

servo.attach(pin, min, max)

Parâmetros

Servo: uma variavel do tipo Servo.

Pin: O numero do pino do Arduino que o Servo esta conectado.

Min (opcional): a largura de pulso, em microsegundos, correspondente ao mínimo (0

Graus) ângulo do Servo (valor padrão é 544)

Max (opcional): a largura de pulso, em microsegundos, correspondente ao maximo (180

Graus) ângulo do Servo (valor padrão é 2400)

Exemplo:

#include <Servo.h>

Servo myservo;

void setup()

{

myservo.attach(9);

}

void loop() {}

FUNÇÃO DETACH()

Descrição

Retira a ligação da variável Servo de um pino do Arduino. Se todas as variáveis

estiverem sem ligações, os pinos 9 e 10 podem ser usados para saída PWM com a

função analogWrite().

Sintaxe

servo.detach()

Parameters

Servo: uma variável do tipo Servo.

FUNÇÃO WRITE()

Descrição

Escreve um valor de referencia para o servo, controla o posicionamento do eixo

correspondendo ao valor de referencia. No Servo por padrão, irá definir o ângulo do

eixo (em graus), movendo o eixo para a orientação. Para servos de rotação continua,

este irá definir a velocidade do servo ( Com 0 sendo velocidade máxima em uma

direção, 180 sendo velocidade máxima na direção contraria e valores próximo a 90

inicia o movimento.

Sintaxe

servo.write(angulo)

Paramentros

Servo: uma variavel do tipo Servo.

Ângulo: Valor a ser posicionado o Servo, de 0 a 180.

Exemplo

#include <Servo.h>

Servo myservo;

void setup()

{

myservo.attach(9);

myservo.write(90); // set servo to mid-point

}

void loop() {}

FUNÇÃO READ()

Descrição

Lê o valor do ângulo atual do servo (o valor definido na ultima função write())

Sintaxe

servo.read()

Paramentros

Servo: uma variavel do tipo Servo.

Retorno

O ângulo do Servo, de 0 a 180 graus.

FUNÇÃO ANALOGWRITE()

Descrição

Escreve um valor analogico (onda PWM) em um pino. Pode ser usado para ascender um

LED variando sua luminosidade ou controlando um motor em varias velocidades. Após

realizar a chamada da função analogWrite(), o pino irá gerar uma onda quadrada estável

para o ciclo especifico ante da próxima chamada da função analogWrite() novamente

(ou chamando a função digitalRead() ou digitalWrite() no mesmo pino). A frequencia

do sinal PWM é aproximadamente 490Hz.

Na maioria das places Arduino ( Que possuem o ATmega168 ou ATmega328), estas

funções funcionam nos pinos 3,5,6,9,10,11. No Arduino Mega, funcionam nos pinos

entre 2 e 13. Arduinos mais antigos que os citados acima que possuem o ATmega8

somente suportam a função analogWrite nos pinos 9,10 e 11.

O Arduino Due suporta a função analogWrite() entre os pinos 2 e 13, contando os pinos

DAC0 e DAC1. Ao contrário os pinos PWM, DAC0 e DAC1 são convertedores digital

para analógico. E agem como verdadeiras saídas analógicas.

Não é necessario realizar a chamada da função pinMode() para escolher as saídas antes

de utilizar a função analogWrite().

The analogWrite function has nothing to do with the analog pins or the analogRead

function.

A função analogWrite() não se relaciona com os pinos analógicos da função

analogRead().

Sintaxe

analogWrite(pin, value)

Parameters

pin: o pino a ser utilizado.

value: a onda quadrada: entre 0 (sempre desligado) and 255 (sempre ligado).

Retorno

Não possue retorno

Notas e questões conhecidas

A saida PWM gerada nos pinos 5 e 6 serão maiores do que o experado do ciclo. Isto

acontece devido a interação das funções millis() e delay(), Assim compartilha o mesmo

temporizador interno gerado nas saídas PWM. Será melhor notado nos ciclos com a

configuração mais baixa(e.g 0-10) e será resultado um valor de 0 totalmente desligado

na saída dos pinos 5 e 6.

Example

Ajustando a luminosidade do LED conforme um potenciômetro.

int ledPin = 9; // LED conectodo no pino digita 9.

int analogPin = 3; // Potenciomentro conectado no pino analogico 3.

int val = 0; // Variavel para armazenar o valor lido

void setup()

{

pinMode(ledPin, OUTPUT); // Configurando o pino como saida

}

void loop()

{

val = analogRead(analogPin); // Lendo o pino de entrada

analogWrite(ledPin, val / 4); // analogRead valores vão de 0 até 1023, //

analogWrite irá de 0 até 255

}