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 Graduao em Engenharia de Automao 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 FUNES .......................................................... 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 tpicos com finalidade de facilitar o envolvimento dos alunos iniciantes a programao com a praticidade de projetos envolvendo sistemas microcontrolados.

2. FUNDAMENTOS
Este tpico contem explicaes sobre alguns elementos do hardware e software do Arduino e algumas concepes contidas neles.

Bsicos Sketch: Os vrios componentes que compem a lgica e como eles funcionam.

Microcontroladores Digital Pins: Como os Pinos trabalham e o que significa para eles a configurao como entrada ou sada. Analog Input Pins: Detalhes sobre a converso anlogica para digital e outras utilidades dos Pinos. PWM: Como a funo analogWrite() simula uma saida analogical usando uma modulao de largura de pulso. Memory: Os vrios tipos de memria disponvel na placa Arduino.

Tcnicas de programao Variables Como definir variveis. Functions: Como definir funes. Libraries: Como escrever a prpria biblioteca.

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

3. PRIMEIRA SKETCH
No guia de iniciao (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 cdigo nico pode ser baixado para o hardware do Arduino e aps executado.

VARIVEIS 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 varivel 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 cdigo, o valor ser recuperado. Neste caso, o usurio somente escreve a varivel ledPin ao invs de ficar lembrando o pino 13 em todo cdigo.A vantagem de se utilizar uma varivel Le a facilidade de alterar por exemplo o pino que o LED esta sendo utilizado, alterando somente o valor da varivel voc no precisa alterar todo o cdigo. Frequentemente, entretanto, os valores da varivel podem mudar enquanto a Sketch est rodando. Por exemplo, um valor pode ser armazenado na varivel aps uma entrada.

FUNES Uma funo (com uma subrotina conhecida) o nome dado a um pedao do cdigo que pode ser usado em qualquer local de uma Sketch. Por exemplo, esta definido na funo setup() do exemplo Blink: void setup() { pinMode(ledPin, OUTPUT); }

// Seta o pino digital como sada.

A primeira linha providencia a informao a respeito da funo, como o nome j diz, setup. O texto antes e aps do nome especificado retorna o tipo de parmetro: explicado melhor a seguir. O cdigo entre { } chamado de corpo da funo, ou seja, o que a funo faz.

#INCLUDE #include utilizado para inserir bibliotecas na sua sketch. Possibilita ao programador acessar um grande grupo de bibliotecas C padro ( grupos de funes 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/avrlibc/user-manual/modules.html). Note que #include, similar com #define e no 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 espao do programa de memria flash ao invs da RAM. Isto salva o espao da RAM para memria dinmica 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 Descrio Um tipo de dado que utilize 1 byte de memria para armazenar valores de character. Caracteres literais so escritos em nicas citaes, como A ( Para mltiplos caracteres - string usam outras citaes com ABC. Caracteres sao armazenas como numeros. Pode ser visto o cdigo especifico na tabela ASCII. Isto significa que possvel realizar somas aritmticas 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 nmeros de -128 a 127. Para tipo de dados no assinados, um-byte (8 bits), usa-se o tipo de dado byte.

EXEMPLO char myChar = 'A'; char myChar = 65; // ambos so equivalentes

CHAR() Descrio Converte um valor ao tipo de character. Sintaxe char(x) Parametros x: valor de qualquer tipo Retorno char

SETUP() A funo setup() chamada quando se inicial uma sketch. utilizado para inicializar variveis, modos dos pinos, utilizao de bibliotecas, etc. A funo setup() ir funcionar somente uma vez, aps cada inicializao ou reset da Placa Arduino.

Exemplo int buttonPin = 3; void setup(){ Serial.begin(9600); pinMode(buttonPin, INPUT); } void loop() { // ... }

LOOP() Aps criar a funo setup(), que inicializa e seta os valores iniciais, a funo 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 boto void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); }

// loop checa o pino com boto a cada tempo // e envia dados serial quando boto pressionado void loop() { if (digitalRead(buttonPin) == HIGH) Serial.write('H'); else Serial.write('L');

delay(1000); }

DELAY() Descrio 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 perodo de tempo (em milisegundos) especifico com parmetro. (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 FUNES

Segmentando cdigos em funes permite ao programador criar pedaos modulados de cdigo que fornece maior desempenho e define parmetros e retornos para certa rea do cdigo onde as funes foram chamadas. Este caso tpico de criao de funes utilizado quando necessrio um melhor desempenho da mesma ao em diferentes pontos do programa. Para o programador acostumado a utilizar o BASIC, o Arduino fornece funes ( e extenses) com utilidade de sub-rotinas (GOSUB em BASIC). Padronizando fragmentos de cdigos nas funes possibilita as seguintes vantagens: Funes ajudam ao programador a organizar melhor o cdigo. Ajudam tambm a contextualizar o programa. Funes possibilitam codificar uma ao a um local e assim esta funo somente precisa ser compilada uma vez.

Reduz tambm a chance de erros em modificaes , caso necessitem de modificao. Funes tornam as Sketchs menores e mais compactas devido as chamadas das funes conforme necessidade do cdigo. mais simples reutilizar o cdigo em outros programas fazendo os mesmo de forma modular, tendo um melhor efeito visual e facilitando a sua reutilizao de funes especificas. Existem duas funes requeridas na Sketch do Arduino, setuo() e loop(). Outras funes devem ser criadas fora do escopo das duas funes citadas acima. Como exemplo, ser criado uma simples funo para mltiplos de dois nmeros.

EXEMPLO

Para chamar essa simples funo com multiplas funes, necessrio passar os parmetros 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 funo precisa ser declarada for a de qualquer outra funo, ento "myMultiplyFunction()" poder ir antes ou depois da funo 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 funo ir ler um sensor 5 vezes com o analogRead() e calcular a media de cinco leituras. Os dados so 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); } sval = sval / 5; sval = sval / 4; // average // scale to 8 bits (0 - 255) // sensor on analog pin 0

sval = 255 - sval; // invert output

return sval; }

Para chamar a funo 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 configuraes. Quando o titulo do documento se refere a pinos digitais, importante notar que a vasta maioria dos tipos de Arduino (Atmega) pinos analgicos, 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, ento ele no preciso ser explicitamente configurados por declarao como entradas com o pinMode(). Os pinos configurados como entradas possuem um estado de alta impedncia. 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 necessrio um baixa corrente para mover a entrada de um estado para outro, o que torna os pinos utilizveis para varias aplicaes como leitor de LED como foto-diodo, implementao de sensor capacitivo, leitor de sensor analgico 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 alteraes aleatrias do estado dos pinos, assumindo um certo rudo do circuito, ou a capacitncia acoplada a o estado de um pino prximo. 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); digitalWrite(pin, HIGH); // Seta pino como entrada. // Aciona resistors de pullup.

Note que os resistores de pullup fornecem a corrente necessria 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 so controlados pelo o mesmo registrador (Local da memria interna do microcontrolador) que controla tambm o pino como ALTO ou BAIXO. Consequentemente o pino pode ser configurado como ALTO se o pino for trocado por uma sada 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 difcil 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 usurio habilitar os resistores de 20k (pullup), ir pendurar uma tenso de 1,7V ao contrario da esperada de 5V, devido ao LED da interno da placa, ou seja, se for necessrio utilizar o pino 13 como entrada utilize um resistor externo de pullup.

PROPRIEDADES DOS PINOS CONFIGURADOS COMO SADA Os pinos configurados como saida pelo pinMode() so usados com um estado de baixa impedncia. 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 no o suficiente para acionar motores, rels e solenoides. Pequenos circuitos nos pinos do Arduino, ou a tentativa de acionar dispositivos que demandam de grande corrente pode danificar ou destruir as sadas transistorizadas dos pinos ou danificar o microcontrolador Atmega. Frequentemente este ato resulta na alienao do pino do microcontrolador mas mantm o restante funcionando adequadamente. Por esta razo uma boa ideia conectar aos pinos de sada resistores de 470ohms ou 1K, a no ser que a corrente mxima for necessria para uma aplicao em particular.

PINMODE() Descrio Configura o pino especificado como entrada ou sada. Veja a descrio 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 analgicos de entrada pode ser usado como pino digital, referindo como A0, A1, etc.

DIGITALWRITE() Descrio Escreve valores ALTO ou BAIXO nos pinos digitais. Se o pino foi configure como saida com o pinMode(), a tenso 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; void setup() { pinMode(ledPin, OUTPUT); } void loop() { // seta o pino digital como saida // LED conectado ao pino digital 13

digitalWrite(ledPin, HIGH); // seta o LED ligado delay(1000); // aguarda um segundo // seta o LED desligado

digitalWrite(ledPin, LOW); delay(1000); }

// aguarda um segundo

Nota O pino analgico de sada pode ser usado como pino digital, referindo como A0, A1, etc.

DIGITALREAD() Descrio 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; // Varivel 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 boto

Nota Se o pino no 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 descrio 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 analgico para digital. O conversor de 10 bits de resoluo, retornam inteiros de 0 a 1023. Enquanto a funo principal dos pinos analgicos para muitos usurios do Arduino so utilizados para leituras de sensores analgicos, os pinos analgicos possuem a funcionalidade de proposta geral de entrada e sada com pinos (GPIO), semelhante aos pinos digitais de 0-13. Consequentemente, se os usurios necessitaram dos pinos de proposta geral de entrada/saida, e todas as sadas analgicas no estiverem sendo usadas, os pinos de entrada analgica podem ser usadas para GPIO.

MAPEANDO OS PINOS Os pinos analgicos podem ser utilizados identicamente aos pinos digitais, Usando a analogia A0 (Para entrada analgica 0) A1, etc. Por exemplo, o cdigo abaixo seta o pino 0 como sada, e em nvel 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 caractersticas de comando com segue: digitalWrite(A0, HIGH); // seta pullup na entrada analogical do pino 0

Enquanto o pino uma entrada. necessario ateno no entanto pois alteraes sobre os resistores de pullup iro afetar os valores reportados ao analogRead().

DETALHES E ADVERTENCIAS O comando do analogRead no ir trabalhar corretamente se os pinos forem setados previamente como sadas, neste caso, sete o mesmo novamente como entrada antes de usar o analogRead. Similarmente se os pinos forem setados para o nvel ALTO de umam sada, os resistores de pullup sero setados, quando trocados novamente como entrada. O datasheet do Atmega possue alertas contra a mudana dos pinos de entrada analgica fechados com proximidade temporal para leituras A/D (analogRead) entre os outros pinos analgicos. Este pode causar rudo eltrico e introduzir oscilaes no sistema analgico. Isto pode ser desejvel, aps manipulao dos pinos analgicos ( no modo digital), para adicionar um pequeno delay aps utilizar o analogRead() para ler outro pino analgico.

7. SERIAL

Usado para comunicao 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 comunicao feita nos pinos digitais 0 (RX) e 1 (TX) assim como feita via porta USB com o computador. No entando, verificando as funcionalidades, no possvel utilizar os pinos digitais 0 e 1 como entradas ou sadas. Pode ser utilizado o ambiente embutido de monitorao do Arduino para vericar a comunicao da placa Arduino. Basta apenas acessar via boto serial monitor da barra de ferramentas e selecionar a mesma taxa de transmisso de dados usada na funo 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 comunicao com o computador pessoal necessrio 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. (No 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 so conectados nos correspondentes pinos do Atmega 16U2 que contem o chio serial de converso USB para TTL conectada a porta depuradora USB. Adicionalmente, possui uma porta no chip SAM3X de converso 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 comunicao USB CDC. Para mais informao, referente a placa Arduino Leonardo v ao site arduino.cc na pagina de hardware.

PRINTLN() Descrio 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() Descrio Seleciona um numero de bytes (caracteres) disponiveis para leitura via porta serial. Estes dados de recente chegada so 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() Descrio 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 no disponveis) int

Exemplo int incomingByte = 0; // Para dados de entrada serial void setup() { Serial.begin(9600); // Abre a porta serial com taxa de transmisso 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() Descrio Escreve dados binarios na porta serial. Este dados enviado com um byte ou uma serie de bytes. Para enviar caracteres representando os dgitos de um numero necessrio utilizar a funo print() no lugar da funo 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 trs 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 variveis quando esto rodando. EEPROM o espao de memoria que programadores podem usar para armazenar as informaes de longo prazo.

Memoria Flash e memoria EEPROM sao nao volateis ( a informao persiste aps desligamento da alimentao). Memria SRAM voltil e ira perder dados no ciclo de alimentao. 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 espao 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 espao disponvel tendo strings no programa. Por exemplo, na declarao: char message[] = "I support the Cape Wind project."; Adiciona 32 bytes na SRAM ( cada character utilize um byte). Este no 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 cdigo). Caso funcione com sucesso, provavelmente o programa esta rodando fora da SRAM. Existem algumas atitudes a serem feitas para enderear 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 necessrio 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 no for necessrio alterar as strings ou os dados enquando a Sketch estiver rodando, pode-se armazenar os dados na memria flash (programa) ao invs da SRAM, para isto, utilize a palavra chave PROGMEM (http://www.arduino.cc/en/Reference/PROGMEM).

9. PWM
O exemplo Fading demonstra a utilizao da sada analgica (PWM) que reduz a luminosidade de uma LED. Este exemplo esta deipsonivel em Software Arduino / File / Sketchbook / Examples / Analog. Modulao por largura de pulso, ou PWM, uma tcnica utilizada para obter resultados analgicos 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 tenses entre 0(mnimo) e 5V(Mximo) alterando a parcela de tempo que o sinal e utilizado associado ao tempo em que o sinal retirado. A durao deste tempo chamado de largura de pulso. Para ter valores analgicos variando, alterado ou modulado a largura do pulso. Se repetido este liga/desliga o mais rpido possvel com um LED por exemplo, o resultado ser um sinal estvel 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 grfico a seguir, as linhas verdes represento um perodo regular de tempo. Esta durao ou perodo o inverso da frequncia PWM. Em outras palavras, com a frequncia PWM do Arduino entre 500Hz, a linha verde ira demonstrar 2 milissegundos cada. A chamada da funo analogWrite() possui a escala entre 0 e 255, sendo o 255 o cliclo Maximo (Sempre ligado) e o 0 o cicli mnimo (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 padro permitem que o eixo seja posicionado em vrios ngulos, usualmente entre 0 e 180 Graus. Servos com rotao continua permitem que o eixo possua rotao 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 funo analogWrite() (PWM) funcionalmente nos pinos 9 e 10, querendo ou no 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 conexo: Alimentao, Terra e Sinal. A conexo de alimentao geralmente vermelha, e deve ser conectada no pino de 5V do Arduino. A conexo Terra geralmente preta ou marrom e deve ser conectada no pino de Terra do Arduino. A conexo de sinal tipicamente amarela, laranja ou branca e deve ser conectada no pino digital correspondente a lgica no Arduino. Lembrando que os Sevos consomem consideravelmente corrente e se necessrio controlar mais que 2 , ser necessrio uma alimentao externa (i.e. Diferente do pino +5V do Arduino). Certifique de conectar o terra do Arduino junto com o terra da fonte externa.

FUNO ATTACH() Descrio Liga a varivel 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)

Parmetros 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 mnimo (0 Graus) ngulo do Servo (valor padro 544) Max (opcional): a largura de pulso, em microsegundos, correspondente ao maximo (180 Graus) ngulo do Servo (valor padro 2400)

Exemplo: #include <Servo.h> Servo myservo; void setup() { myservo.attach(9); } void loop() {}

FUNO DETACH() Descrio Retira a ligao da varivel Servo de um pino do Arduino. Se todas as variveis estiverem sem ligaes, os pinos 9 e 10 podem ser usados para sada PWM com a funo analogWrite().

Sintaxe servo.detach() Parameters Servo: uma varivel do tipo Servo.

FUNO WRITE() Descrio Escreve um valor de referencia para o servo, controla o posicionamento do eixo correspondendo ao valor de referencia. No Servo por padro, ir definir o ngulo do eixo (em graus), movendo o eixo para a orientao. Para servos de rotao continua, este ir definir a velocidade do servo ( Com 0 sendo velocidade mxima em uma direo, 180 sendo velocidade mxima na direo contraria e valores prximo 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() {}

FUNO READ() Descrio L o valor do ngulo atual do servo (o valor definido na ultima funo write())

Sintaxe servo.read()

Paramentros Servo: uma variavel do tipo Servo.

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

FUNO ANALOGWRITE() Descrio 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. Aps realizar a chamada da funo analogWrite(), o pino ir gerar uma onda quadrada estvel para o ciclo especifico ante da prxima chamada da funo analogWrite() novamente (ou chamando a funo 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 funes 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 funo analogWrite nos pinos 9,10 e 11. O Arduino Due suporta a funo analogWrite() entre os pinos 2 e 13, contando os pinos DAC0 e DAC1. Ao contrrio os pinos PWM, DAC0 e DAC1 so convertedores digital para analgico. E agem como verdadeiras sadas analgicas. No necessario realizar a chamada da funo pinMode() para escolher as sadas antes de utilizar a funo analogWrite(). The analogWrite function has nothing to do with the analog pins or the analogRead function. A funo analogWrite() no se relaciona com os pinos analgicos da funo 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 No possue retorno

Notas e questes conhecidas A saida PWM gerada nos pinos 5 e 6 sero maiores do que o experado do ciclo. Isto acontece devido a interao das funes millis() e delay(), Assim compartilha o mesmo temporizador interno gerado nas sadas PWM. Ser melhor notado nos ciclos com a configurao mais baixa(e.g 0-10) e ser resultado um valor de 0 totalmente desligado na sada dos pinos 5 e 6.

Example Ajustando a luminosidade do LED conforme um potencimetro. 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 vo de 0 at 1023, analogWrite ir de 0 at 255 }

//