View
133
Download
0
Category
Preview:
Citation preview
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
}
Recommended