Você está na página 1de 70

Programao Arduino

Pgina | 1

Sumrio:
Estrutura
y y
void setup ().............................................5 void loop ()...............................................5

Operadores de bits y y y y y y y y
& (operador de bits AND)..............................22 | (operador de bits OR).................................22 ^ (operador de bits XOR)..............................22 ~ (operador de bits NOT)..............................24 << (desvio esquerda).................................25 >> (desvio direita).....................................25 &=(de bits composto AND)............................26 |=(de bits composto OR)...............................26

Estruturas de controle y y y y y y y y y y
if............................................................6 if...else...................................................7 for..........................................................8 switch case.............................................9 while.....................................................10 do... while..............................................10 break.....................................................69 continue.................................................11 return.....................................................11 goto.......................................................12

Operadores compostos y y y y y y
++ (incrementar).........................................28 -- (decrementar)..........................................28 += (adio composta)..................................28 -= (subtrao composta)...............................28 *= (multiplicao composta)..........................28 /= (diviso composta)...................................28

Elementos de sintaxe y y y y y y
; (ponto e vrgula)...................................13 {} (chaves).............................................13 // (linha de comentrio)...........................15 /* */ (bloco de comentrio)......................15 #define..................................................16 #include.................................................17

Operadores aritmticos y y y y y y
= (igualdade).........................................18 + (adio)..............................................18 - (subtrao)..........................................18 * (multiplicao).....................................18 / (diviso)..............................................18 % (resto da diviso)...............................19

Operadores de comparao y y y y y y
== (igual a)...........................................20 != (diferente de).....................................20 < (menor que).......................................20 > (maior que)........................................20 <= (menor ou igual a)............................20 >= (maior ou igual a).............................20

Operadores booleanos y y y
&& (e)....................................................21 || (ou)....................................................21 ! (no)....................................................21

Pgina | 2

Variveis
Variveis so expresses que voc pode usar em programas para armazenar valores como a leitura de um sensor em um pino analgico.

Constantes
Constantes so valores particulares com significados especficos.

y y y y

HIGH | LOW...........................................29 INPUT | OUTPUT....................................29 true | false.............................................29 Constantes inteiras.................................31

Tipos de dados
Variveis podem ser de vrios tipos:

y y y y y y y y y y y y

boolean..................................................32 char.......................................................32 byte.......................................................33 int..........................................................33 unsigned int............................................34 long.......................................................34 unsigned long.........................................35 float........................................................36 double....................................................37 string......................................................37 array.......................................................39 void........................................................40

Converso y y y y y
char()....................................................41 byte()....................................................41 int().......................................................41 long()....................................................41 float()....................................................42

Referncia y
Tabela ASCII..........................................42

Pgina | 3

Funes
Entrada e sada digital

y y y

pinMode (pin, mode).....................................43 digitalWrite (pin, value).................................44 int digitalRead (pin).......................................45 Entrada e sada analgica

Comunicao serial Usado para comunicao entre a placa Arduino e um computador ou outros dispositivos. Esta comunicao ocorre atravs dos conectores serial ou USB da placa Arduino e nos pinos digitais 0 (RX) e 1 (TX). Assim, se voc utilizar estas funes no poder utilizar os pinos 0 e 1 para entrada e sada digital.

y y

int analogRead (pin)......................................46 analogWrite (pin, value) PWM....................47

Entrada e sada avanada

y y

shiftOut (dataPin, clockPin, bitOrder, value) .48 unsigned long pulseIn (pin, value) Tempo .49

y y y y

unsigned long millis()....................................50 unsigned long micros() delay(ms) delayMicroseconds( s) 2 Matemtica ..50 ..51 ..5

y y y y y y

Serial.begin (speed)......................................62 int Serial.available () int Serial.read () Serial.flush () 63 64 ..65

Serial.print (data)..........................................65 Serial.println (data).......................................68

y y y y y y y y

min (x, y).....................................................54 max (x, y) .55 abs (x).........................................................56 constrain (x, a, b).........................................56 map (value, fromLow, fromHigh, toLow, toHigh) sq (x) 57 ..58 pow (base, exponent)...................................58 sqrt (x).........................................................58 Trigonometria

y y y

sin (rad).......................................................59 cos (rad)......................................................59 tan (rad)......................................................59 Nmeros aleatrios

y y y

randomSeed (seed) long random (min, max)

.60 ..61

long random (max).......................................61

Pgina | 4

setup()
A funo setup() chamada quando um programa pomea a rodar. Use esta funo para inicializar as sua variveis, os modos dos pinos, declarar o uso de livrarias, etc. Esta funo ser executada apenas uma vez aps a placa Arduino ser ligada ou ressetada. Exemplo int buttonPin = 3; void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } void loop() { // ... }

loop()
Aps criar uma fuo setup() que declara os valores iniciais, a funo loop() faz exatamente o que seu nome sugere, entra em looping (executa sempre o mesmo bloco de cdigo), permitindo ao seu programa fazer mudanas e responder. Use esta funo para controlar ativamente a placa Arduino. Exemplo int buttonPin = 3; // setup inicializa o serial e o pino do button (boto) void setup() { beginSerial(9600); pinMode(buttonPin, INPUT); } // loop checa o boto a cada vez, // e envia o serial se ele for pressionado void loop() { if (digitalRead(buttonPin) == HIGH) serialWrite('H'); else serialWrite('L'); delay(1000); }

Pgina | 5

if (condicional) e ==, !=, <, > (operadores de comparao)


if, que usado juntamente com um operador de comparao, verifica quando uma condio satisfeita, como por exemplo um input acima de um determinado valor. O formato para uma verificao if : if (algumaVariavel > 50) { // faa alguma coisa } O programa checa se algumaVariavel (colocar acentos em nomes de variveis no uma boa idia) maior que 50. Se for, o programa realiza uma ao especfica. Colocado de outra maneira se a sentena que est dentro dos parntesis verdadeira o cdigo que est dentro das chaves roda; caso contrrio o programa salta este bloco de cdigo. As chaves podem ser omitidas aps uma sentena if se s houver uma nica linha de cdigo (definida pelo ponto e vrgula) que ser executado de modo condicional: if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) {digitalWrite(LEDpin, HIGH);} // todos so corretos A sentena que est sendo verificada necessita o uso de pelo menos um dos operadores: Operadores de comparao: x == y (x igual a y) x != y (x no igual a y) x < y (x menor que y) x > y (x maior que y) x <= y (x menor ou igual a y) x >= y (x maior ou igual a y) Cuidado: Tenha precauo com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual simples um operador de designao e coloca o valor 10 na varivel x. Ao contrrio o sinal de igal duplo (e.g. if (x == 10) ), que um operador de comparao, verifica se x igual a 10 ou no. A ltima sentea s verdadeira se x for igual a 10, mas a anterior sempre ser veraddeira. Isto ocorre por que a linguagem C (na qual o Arduino baseado) atribui um valor sentena (x=10) do seguinte modo: 10 colocado na varivel x (lembre o sinal de igual simples um operador de designao), ento x agora contm 10. Ento o condicional 'if' atribui um valor a 10, que ser sempre verdadeiro (TRUE), desede que nmeros diferentes de zero so sempre equiparados verdadeiro. Consequentemente, if (x = 10) ser sempre verdadeiro, que no o que pretendemos quando usamos um 'if'. Adcionalmente o valor 10 ser guardado na varivel x que tambm no o que pretendemos. if tambm pode ser usado como parte de uma estrutura de controle ramificada atravs da construo if..else.

Pgina | 6

if / else
if/else permite um controle maior sobre o fluxo de cdigo do que a sentena if bsica, tornando possvel que mltiplos testes sejam agrupados. Por exemplo, uma entrada analgica poderia ser verificada e uma ao especfica seria tomada se o valor de input fosse menor que 500 e outra ao seria tomada se o input fosse 500 ou mais. O cdigo seria assim: if (pinFiveInput < 500) { // ao A } else { // ao B } else pode preceder outro teste if , e assim mltiplos testes, mutuamente exclusivos, podem ser realizados ao mesmo tempo. Cada teste precede o prximo at que um teste com vavlor verdadeiro encontrado. Quando um teste com valor verdadeiro encontrado o seu bloco de cdigo associado execuatod e ento o programa salta para a sequencia aps todo o bloco if/else. Se a nenhum teste atribuido o valor verdadeiro o bloco que estiver no else sozinho executado, se houver algum. Note que um bloco else if pode ser usado com ou sem um bloco else final. Um nmero ilimitado destes ramos else if permitido. if (pinFiveInput < 500) { // faa a coisa A } else if (pinFiveInput >= 1000) { // faa a coisa B } else { // faa a coisa C } Outro modo de fazer testes de ramificaes mutuamente exclusivas atravs da sentena switch case.

Pgina | 7

sentena for
Descrio A sentena for utilizada para repetir um bloco de cdigo delimitado por chaves. Um contador com incremento normalmente usado para controlar e finalizar o loop. A sentena for util para quanquer operao repetitiva, e frequentemente usada com arrays para operar em conjuntos de dados ou de pinos. H trs partes no cabealho do for: for (inicializao; condio; incremento) { //sentena(s); } A inicializao ocorre primeiro e apenas uma vez. Cada vez que o circuto executado a condio verificada; se for verdadeira o bloco de cdigo e o incremento so executados, e ento a condio testada novamente. Quando a condio se torna falsa o circuto termina. Exemplo // Aumentar o brilho de um LED usando um pino PWM int PWMpin = 10; // um LED em srie com um resisotr de 1k void setup() { // nenhum setup necessrio } void loop() { for (int i=0; i <= 255; i++){ analogWrite(PWMpin, i); delay(10); } } Dica de programao Na linguagem C o circuito for muito mais flexvel que os circuitos for encontrados a algumas outras linguagens de programao, incluindo BASIC. Qualquer dos elementos do cabealho pode ser omitido, embora os ";" sejam necessrios. Qualquer destes elementos tambm podem ser substituidos por qualquer sentena vlida em C com varveis no correlatas. Estes tipos no usuais de sentenas for as vezes podem ser a soluco para alguns problemas raros de programao.
no pino 10

Pgina | 8

sentena switch / case


Do mesmo modo que as sentenas if, as switch / case controlam o fluxo dos programas. Switch/case permite ao programador construir uma lista de "casos" dentro de um bloco delimitado por chaves. O programa checa cada caso com a vaivel de teste e executa o cdigo se encontrar um valor idntico. Switch / case um pouco mais flexvel que uma estrutura if/else de modo que o programador pode determinar se a estrutura switch deve continuar checando por valores idnticos na lista dos "caosos" aps encontrar um valor idntico. Se a sentena break no encontrada aps a execuo do bloco de cdigo selecionado por um dos "casos", ento o programa vai continuar a checar por mais valores idnticos entre os "casos" restantes. Se uma sentena break encontrada o cdigo sai da estrutura do mesmo modo que em uma construo if/else if. Parmetros

y y y

var - a varivel para a qual voc busca valores idnticos default - se nenhuma outra condio for satisfeita o cdigo que est no default executado break - sem o break a sentena switch vai continuar checando as outras sentenas case para quanquer outro possvel valor idntico. Se algum for encontrado ser executado do mesmo modo, o que pode no ser o que voc deseja. Break indica ao switch para parar de procurar por outros valores idnticos e sai da sentena switch. Exemplo switch (var) { case 1: //faa alguma coisa quando var == 1 break; // break is optional case 2: //faa alguma coisa quando == 2 break; default: // se nenhum valor for idntico, faa o default // default opcional }

Pgina | 9

while
Descrio while far com que o bloco de cdigo entre chaves se repita continua e indefinidamente at que a expresso ente parentesis() se torne falsa. Algo tem que provocar uma mudana no valor da varivel que est sendo verificada ou o cdigo vai sempre ficar dando voltas dentro do while. Isto poderia ser o incremento de uma varivel ou uma condio externa como o teste de um sensor. Syntax while(expresso){ // cdigo } Parmetros expresso - uma sentena boolena em C que possa ser verificada como verdadeira ou falsa Exemplo var = 0; while(var < 200){ // algum cdigo que se repete 200 vezes var++; }

do - while
O do funciona da mesma maneira que o while loop, com a exceo de que a condio testada no final do bloco de cdigo. Enquanto no while, se a condio for falsa, o bloco de cdigo no ser executado, no do ele sempre ser executado pelo menos uma vez. do { // bloco de cdigo } while (condio); Exemplo do { delay(50); // espera para que os sensores se estabilizem x = readSensors(); // verifica o sensor } while (x < 100);

Pgina | 10

continue
continue usado para saltar pores de cdigo em blocos do, for, ou while. Ele fora com que o cdigo avance at o teste da condio saltando todo o demais. Exemplo for (x = 0; x < 255; x ++) { if (x > 40 && x < 120){ continue; } digitalWrite(PWMpin, x); delay(50); } // criar saltos de execuo

return
Finaliza uma funo e retorna um valor, se necessrio. Sintaxe: return; return valor; // ambas formas so vlidas Parmetros valor: alguma varivel ou constante Exemplos: Uma funo para comparar o valor de um sensor com um limite int checkSensor(){ if (analogRead(0) > 400) { return 1; else{ return 0; } } A palavra-chave return til para testar uma seo de cdigo sem ter que transformar em "comentrio" um grande e possivelmente defeituoso bloco de cdigo. void loop(){ // aqui, uma brilhante idia de programao return; // restante do bloco de cdigo no funcional // este cdigo nunca ser executado }

Pgina | 11

goto
Transfere o fluxo do programa para um outro ponto etiquetado Sintaxe label: goto etiqueta; // envia o fluxo do programa para etiqueta Dica O uso do goto desencorajado em programao C e inclusive alguns autores afirmam que o goto nunca realmente necessrio, mas usado com cautela pode simplificar alguns programas. A razo pela qual muitos programadores desaprovam seu uso que com o uso indiscriminado fcil de se criar um programa com um fluxo indefinido e muito difcil de ser depurado. No entanto, h casos em que o goto pode ser til e simplificar o cdigo. Uma destas situaes provocar uma sada de um grupo de loops aglutinados ou de blocos lgicos if com uma determinada condio.

Exemplo for(byte r = 0; r < 255; r++){ for(byte g = 255; g > -1; g--){ for(byte b = 0; b < 255; b++){ if (analogRead(0) > 250){ goto bailout;} // more statements ... } } } bailout:

Pgina | 12

; ponto e vrgula
Usada para terminar uma sentena. Exemplo int a = 13; Dica Esquecer de finalizar uma linha com ponto e vrgula causa um erro de compilao. O texto sobre o erro pode ser bvio e se referir a um ponto e vrgula faltando, ou no. Se ocorrer um erro de compilao impenetrvel ou aparenetemente ilgico uma das primeiras coisas a checar um ponto e vrgula faltando na vizinhana, precedendo a linha indicada pelo compilador.

{} Chaves
Chaves so uma parte essencial da linguagem de programao C. Elas so usadas em muitas construes diferentes, descritas abaixo, e isto pode algumas vezes ser confuso para iniciantes. Uma chave abrindo "{" deve sempre ser seguida por uma fechando "}". Frequentemente nos referimos a esta condio como equilibrio entre as chaves. A IDE (integrated development environment ou ambiente de desenvolvimento integrado) do Arduino inclui uma caracterstica prtica para checar o equilibrio das chaves. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que sua companheira lgica seja destacada. No presente momento esta caracterstica um pouco defeituosa e a IDE frequentemente encontrar (incorretamente) uma chave em um bloco de texto que tenha sido comentado. Programadores principiantes e programadores vindos das linguagens C e do BASIC frequentemente consideram o uso das chaves confuso ou desalentador. Afinal as mesmas chaves substituem a sentena RETURN em uma subrotina(funo), a sentena ENDIF em uma condicional e a sentena NEXT em um FOR. Por que o uso das chaves to variado, uma boa prtica de programao digitar o fecha-chaves "}" logo aps digitar o abre-chaves "{" quando estiver fazendo uma construo que as requer. Inserte ento alguns "ENTER" entre as chaves e comece a digitar o cdigo. Agindo assim suas chaves nunca ficaro desequilibradas. Chaves desequilibradas causam erros de comilao bastante enigmticos e que podem ser difceis de rastrear em um programa longo. Por causa de seus usos variados, as chaves so tambm incrivelmente importantes para a sintaxe de um programa e mover uma chave uma ou duas linhas pode alterar completamente o seu significado.

Pgina | 13

Os principais usos das chaves Funes void myfunction(datatype argument){ sentena(s) } Loops while (expresso booleana) { sentena(s) } do { sentena(s) } while (expresso booleana); for (inicializao; condio de trmino; expresso de incremento) { sentena(s) } Sentenas condicionais if (expresso booleana) { sentena(s) } else if (expresso booleana) { sentena(s) } else { sentena(s) }

Pgina | 14

Comentrios
Comentrios so linhas no programa que so usados para informar a voc mesmo ou outras pessoas sobre o modo como o progama trabalha. Elas so ignoradas pelo compilador e no so exportadas para o processador e portanto no ocupam a memria do chip ATmega. O nico propsito dos comentrios so ajudar a entender (ou relembrar) como o programa funciona. H dois modos diferentes de marcar uma linha como um comentrio. Exemplo x = 5; // Esta uma linha simples de comentrio. Qualquer coisa depois das barras um comentrio // at o fim da linha /* este um bloco de comentrio - usado para "comentar" blocos inteiros de cdigo if (gwb == 0){ // no h problema em uma linha simples dentro de um bloco de comentrio x = 3; } // no esquea de fechar o bloco de comentrio, eles tm que ser equilibrados */ Dica Quando estiver experimentando com o cdigo "comentar" partes do programa um modo conveniente de remover linhas que podem conter problemas. Este procedimento mantm as linhas no cdigo mas as trasnforma em comentrios de modo que o compilador as ignora. Isto pode ser especialmente til quando tentamos localizar um problema, ou quando um programa apresenta erros de compilao cujas explicaes so obscuras ou inteis. /* mas outro bloco de comentrio invlido */

Pgina | 15

#define
#define um componente muito til da linguagem C que permite ao programador dar um nome a uma constatnte antes que o programa seja compilado. Constantes definidas no Arduino no ocupam espao em memria no chip. O compilador substitui referancias a estas constantes pelo valor definido no momento da compilao. Isto pode causar alguns efeitos indesejveis se, por exemplo, um nome de constante que tenha sido defindo por um #define incluido em alguma outra constante ou nome de varivel. Neste caso o texto deve ser substituido pelo valor (ou texto) do #define. Em general, a palavra chave const prefervel para definir constatntes e deve ser usada ao invs de #deine. A sintaxe do #define na linguagem Arduino a mesma da linguagem C: Sintaxe #define nomeDeConstante valor Verifique que o # necessrio. Exemplo #define ledPin 3 // O compilador vai substituir quanquer meno a ledPin pelo valor 3 no momento da compilao. Dica No h ponto e vrgula aps a declarao #define. Se voc incluir um o compilador vai lanar erros crticos no final do programa. #define ledPin 3; // isto um erro

Do mesmo modo o compilador gerar erros se aps o #define houver um =. #define ledPin = 3 // isto tambm um erro

Pgina | 16

#include
#include usado para incluir outras bibliotecas no seu programa. Isto permite ao programador acessar um grande nmero de bibliotecas padro da linguagem C (grupos de funes pr-definidas), e tambm bibliotecas desenvolvidas especificamente para o Arduino. A pgina principal de referncia para as bibliotecas C AVR (AVR a referncia aos chips Atmel nos quais o Arduino est baseado) est aqui. Verifique que #include, de modo similar ao #define, no leva ponto e vrgula no final. Exemplo Este exemplo inclui uma biblioteca que utilizada para armazenar dados na memria flash ao invs de na ram. Isto economiza espao na ram para as necessidades de memria dinmica e torna o uso de grandes tabelas mais prtico. #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};

= operador de designao (sinal de igual simples)


Armazena o valor do que est direita do sinal de igual na varivel que est esquerda. O sinal de igual simples na linguagem de programao C chamdo operador de designao. Ele tem um significado diferente daquele utilizado em lgebra, no qual indica uma equao ou iguladade. O operador de designao indica ao microcontrolador para calcular o valor da expresso direita do sinal de igual e armazenar este valor na varivel que est esquerda. Exemplo int sensVal; // declera uma variavel do tipo inteiro com o nome de sensVal // armazena o valor da voltagem (digitalizado) no pino senVal = analogRead(0); analgico 0 em sensVal Dicas de programao A varivel esquerda necessita ser capaz de reter o valor que se quer armazenar. Se ela no for grande o suficiente o valor armazenado pode ser incorreto. No confunda o operador de designao [ = ] (sinal de igual simples) com o operador de comparao [ == ] (sinal de igual duplo), que calcula quando duas expresses so iguais ou no.

Pgina | 17

Adio, subtrao, multiplicao e diviso


Descrio Estes operadores retornam a soma, diferena, profuto, ou quciente(respectivamente) de dois operandos. A operao feita usando o tipo de dado dos operadores, assim, por exemplo 9/4 resulta em 2, desde que 9 e 4 so inteiros. Isto tambm significa que uma operao pode extrapolar se o resultado for maior do que o que pode ser armazenado no tipo de dado. (e.g. adicionado 1 a um int com o valor de 32.767 resulta gives -32.768). Se os operandos forem de tipos de dados diferentes o tipo maior usado no clculo. Se um dos operandos for do tipo float ou do tipo double, ento a matemtica de ponto flutuante ser usada para o clculo. Exemplos y = y + 3; x = x - 7; i = j * 6; r = r / 5; Sintaxe result = value1 + value2; result = value1 - value2; result = value1 * value2; result = value1 / value2; Parmetros: value1: qualquer varivel ou constante value2: qualquer varivel ou constante Dicas de programao

y y y y y

Saiba que constantes inteiras so consideradas int, portanto alguns cculos com constantes podem extrapolar (e.g. 60 * 1000 resultar em um nmero negativo). Escolha tamanhos de variveis que sejam grandes o suficiente para reter os maiores resultados possveis dos clculos. Conhea o ponto em que sua varivel pode "dar a volta" e tambm o que ocorre no sentido contrrioe.g. (0 - 1) ou (0 - 32768). Para matemtica que necessita de fraes use variveis do tipo float, mas tenha em conta seus pontos negativos: tamanho maior e menor velocidade de computao. Use o operador de modelagem para converter diretamente um tipo de varivel em outro e.g. (int)meuFloat.

Pgina | 18

% (resto da diviso)
Descrio Calcula o resto da diviso quando um inteiro dividido por outro. til para manter uma varivel dentro de um patamer especfico (e.g. o tamanho de um array). Sintaxe resultado = dividendo % divisor Parmetros dividendo: o nmero que ser dividido divisor: o nmero a dividir por Retorna o restante Exemplo x = 7 % 5; // x agora comtm 2 x = 9 % 5; // x agora comtm 4 x = 5 % 5; // x agora comtm 0 x = 4 % 5; // x agora comtm 4 Cdigo de exemplo /* atualizar os valores de um array um de cada vez em um bloco */ int values[10]; int i = 0; void setup() {} void loop() { values[i] = analogRead(0); i = (i + 1) % 10; // operador de resto de diviso atualiza a varivel } Dica O operador de resto da diviso no funciona com variveis tipo float.

Pgina | 19

if (condicional) e ==, !=, <, > (operadores de comparao)


if, que usado juntamente com um operador de comparao, verifica quando uma condio satisfeita, como por exemplo um input acima de um determinado valor. O formato para uma verificao if : if (algumaVariavel > 50) { // faa alguma coisa } O programa checa se algumaVariavel (colocar acentos em nomes de variveis no uma boa idia) maior que 50. Se for, o programa realiza uma ao especfica. Colocado de outra maneira se a sentena que est dentro dos parntesis verdadeira o cdigo que est dentro das chaves roda; caso contrrio o programa salta este bloco de cdigo. As chaves podem ser omitidas aps uma sentena if se s houver uma nica linha de cdigo (definida pelo ponto e vrgula) que ser executado de modo condicional: if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) digitalWrite(LEDpin, HIGH); if (x > 120) {digitalWrite(LEDpin, HIGH);} // todos so corretos A sentena que est sendo verificada necessita o uso de pelo menos um dos operadores: Operadores de comparao: x == y (x igual a y) x != y (x no igual a y) x < y (x menor que y) x > y (x maior que y) x <= y (x menor ou igual a y) x >= y (x maior ou igual a y) Cuidado: Tenha precauo com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual simples um operador de designao e coloca o valor 10 na varivel x. Ao contrrio o sinal de igal duplo (e.g. if (x == 10) ), que um operador de comparao, verifica se x igual a 10 ou no. A ltima sentea s verdadeira se x for igual a 10, mas a anterior sempre ser veraddeira. Isto ocorre por que a linguagem C (na qual o Arduino baseado) atribui um valor sentena (x=10) do seguinte modo: 10 colocado na varivel x (lembre o sinal de igual simples um operador de designao), ento x agora contm 10. Ento o condicional 'if' atribui um valor a 10, que ser sempre verdadeiro (TRUE), desede que nmeros diferentes de zero so sempre equiparados verdadeiro. Consequentemente, if (x = 10) ser sempre verdadeiro, que no o que pretendemos quando usamos um 'if'. Adcionalmente o valor 10 ser guardado na varivel x que tambm no o que pretendemos. if tambm pode ser usado como parte de uma estrutura de controle ramificada atravs da construo if..else

Pgina | 20

Operadores Booleanos
Estes operadores podem ser usados dentro da condio em uma sentena if. && ("E" lgico) Verdadeiro apenas se os dois operandos forem verdadeiros, ou seja a primeira condio "e" a segunda forem verdadeiras, e.g. if (digitalRead(2) == 1 && digitalRead(3) == 1) { // ler dois interruptores // ... } verdadeiro apenas se os dois interruptores estiverem fechados. || ("OU" lgico) Verdadeiro se algum dos operandos for verdadeiro, ou seja se a primeira "ou" a segunda condio for verdadeira e.g. if (x > 0 || y > 0) { // ... } verdadeiro apenas se x ou y forem maiores que 0.

! (negao)
Verdadeiro apenas se o operando for falso e.g. if (!x) { // ... } verdadeiro apenas se x for falso (i.e. se x for igual a 0). Cuidado Certifique-se de no confundir o operador booleano "E" representado por "&&" e o operador lgico de bits "E" representado apenas por "&". Eles so animais completamente diferentes. Do mesmo modo no confunda o booleano "OU" representado por "||" e o operador lgico de bits "|". O operador lgico de bits "NO" representado por um "~" no se parece com o operador booleano "!", mas mesmo assim tenha certeza de estar usando o que voc deseja. Exemplos if (a >= 10 && a <= 20){} // verdadeiro se a estiver entre 10 e 20

Pgina | 21

Operadores de bits AND (&), OR (|), XOR (^)


Operadores de bits Os operadores de bits realizam clculos ao nvel de bits das variveis. Eles ajudama resolver uma grande quantidade de problemas de programao. Muito do material abaixo de um excelente tutorial sobre este tema que pode ser encontrado aqui. Operador de bits AND (&) O operador de bits AND (e) em C++ um simples & usado entre duas outras expresses inteiras. Ele realiza uma operao entre cada bit de cada uma destas expreses de acordo com a seguinte regra: se os dois bits de entrada forem 1 o resultado da operao tambm 1, caso contrrio 0. Outro modo de expressar esta regra : 0 0 1 1 0 1 0 1 ---------0 0 0 1 (operando1 & operando2) - resultado de retorno Em Arduino o tipo int (inteiro) um valor de 16 bits, portanto usando & entre duas expresses int faz com que ocorram 16 operaes AND simultneas. Em um fragmento de cdigo: int a = 92; int b = 101; // em binario: 0000000001011100 // em binario: 0000000001100101 0000000001000100, ou 68 em decimal. operando1 operando2

int c = a & b; // resultado:

Cada um dos 16 bits em a AND b so processados usando este operador, e todos os 16 bits resultantes so armazenados em c resultado o valor 0000000001000100, que 68 na notao decimal. Um dos usos mais comuns do operador de bits AND selecionar alguns bits de um valor inteiro, freqentemente chamado de mscara. Veja o exemplo abaixo para um exemplo. Operador de bits OR (|) O operador de bits OR (ou) em C++ o smbolo de barra vertical, |. Como o operador & ele realiza clculos com cada bit de duas expresses seguindo a seguinte regra: o resultado da oprao 1 se um dos bits de entrada for 1, caso contrrio 0. Em outras palavras: 0 0 1 1 0 1 0 1 ---------0 1 1 1 (operando1 | operando2) - resultado de retorno // in binario: 0000000001011100 // in binario: 0000000001100101 0000000001111101, ou 125 em decimal. Em um fragmento de cdigo: int a = 92; int b = 101; operando1 operando2

int c = a | b; // resultado: Programa de Exemplo

Um uso comum para os operadores de bits AND e OR o que os programadores chamam Ler-ModificarEscrever em uma porta. Em microcontroladores uma porta um nmero de 8 bits que representa algo sobre a condio dos pinos. Escrevendo em um controle de porta todos os pinos de uma vez. PORTD uma constante pr-construda que se refere aos estados de sada dos pinos digitais 0,1,2,3,4,5,6,7. Se h um 1 em algum dos bits, ento este pino est em HIGH. (os pinos ainda precisam ser defindos como pinos de sada pelo comando pinMode()). Deste modo se escrevemos PORTD = B00110001; o que fazemos colocar os pinos 2,3 e 7 em HIGH. Um efeito colateral que mudamos o estado dos pinos 0 e 1 que so usados pelo Arduino na comunicao serial, ou seja, interferimos nesta comunicao.

Pgina | 22

Nosso algoritmo para este programa deve:

y y

Ler o PORTD e limpar somente os bits que queremos controlar (com o operador AND). Combinar o valor modificado de PORTD com o novo valor dos pinos que queremos controlar (com o operador OR). int i; int j; void setup(){ DDRD = DDRD | B11111100; // marca a direcao dos bits para os pinos 2 a 7 deixando o 0 e o 1 intocados (xx | 00 == xx) // o mesmo que pinMode(pin, OUTPUT) para os pinos 2 a 7 Serial.begin(9600); } void loop(){ for (i=0; i<64; i++){ PORTD = PORTD & B00000011; // limpa os bits de 2 - 7, deixa os pinos 0 e 1 intocados (xx & 11 == xx) j = (i << 2); e1 PORTD = PORTD | j; pinos dos LEDs Serial.println(PORTD, BIN); // debug para verificar a mscara delay(100); } } Operador de bits XOR (^) H um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou exclusivo) tambm conhecido por XOR (em ingls se pronuncia "equis-or"). Este operador escrito com o smbolo do acento circunflexo ^. O resultado desta operao 1 se os dois bits de entrada forem diferentes, caso contrrio retorna 0: 0 0 1 1 0 1 0 1 ---------0 1 1 0 int x = 12; int y = 10; (operando1 ^ operando2) - resultado de retorno // binario: 1100 // binario: 1010 Um simpples cdigo de exemplo: operando1 operando2 // combina a informao da porta com a nova informao para os // desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0 // varivel do contador

int z = x ^ y; // binario: 0110, or decimal 6 O operador XOR freqentemente utilizado para inverter alguns dos bits de uma expresso inteira. Na mscara deste operador se h um 1 o bit correspondente invertido, se h um zero o bit mantido como est. Abaixo h um programa para piscar o pino digital 5. // Piscar_Pino_5 // demonstrao para o Exclusive OR void setup(){ DDRD = DDRD | B00100000; // marca o pino digital 5 como saida. Serial.begin(9600); }

Pgina | 23

void loop(){ PORTD = PORTD ^ B00100000; // inverte o bit 5 (digital pino 5), mantem os demais intocados. delay(100); }

Operador de bits NOT (~)


O operador de bits NOT (no) em C++ o acento til do portugus ~. Diferente dos operadores & e | este operador aplicado sobre apenas 1 operando e retorna o valor inverso de cada bit. Por exemplo: 0 1 operando1

---------1 0 ~ operando1 int a = 103; int b = ~a; // binario: 0000000001100111 // binario: 1111111110011000 = -104

Talvez voc se surpreenda ao ver um nmero negativo como resultado desta operao. Isto ocorre por que o bit mais elevado em uma varivel int chamdo de bi de sinal. Se este bit 1 o nmero negativo. Este modo de encodar positivos e negativos chamado de complemento para dois. Mais informaes na Wikipedia. De modo complementar, interessante notar que para qualquer inteiro x, ~x o mesmo que -x-1. As vezes, o bit de sinal em uma expresso inteira pode causar algumas surpresas indesejadas.

Pgina | 24

desvio de bits para a esquerda (<<) e para a direita (>>)


H dois operadores de desvio de bits em C++: o de desvio para a esquerda << e o para a direita >>. Estes operadores fazem com que os bits no operando da esquerda sejam desviados o nmero especificado de bits no operando da direita. Sintaxe variavel << numero_de_bits variavel >> numero_de_bits Parmetros variavel - (byte, int, long) numero_de_bits inteiro <= 32 Exemplo: int a = 5; // binario: 0000000000000101 int b = a << 3; // binario: 0000000000101000, ou 40 em decimal int c = b >> 3; // binario: 0000000000000101, ou de volta ao 5 como no inicio Quando voc desvia para a esquerda um valor x um y nmero de bits (x<<Y) os bits mais a esquerda em x so perdidos: int a = 5; // binario: 0000000000000101 int b = a << 14; // binario: 0100000000000000 - o primeiro 1 em 101 descartado Se voc tem certeza de que nenhum dos 1 em um valor vai ser deviado para fora do espao , um modo simples de pensar no operador para a esquerda que ele multiplica o operando da direita por 2 elevado ao operador da esquerda. Por exemplo para gerar potncias de 2 as segintes expresses podem ser utilizadas: 1 << 0 == 1 << 1 == 1 << 2 == 1 << 3 == ... 1 << 8 == 256 1 << 9 == 512 1 << 10 == 1024 ... Quando voc desvia para a direita um valor x um y nmero de bits (x>>y), o comportamento depende do tipo de dados de x. Se x do tipo int, o bit mais elevado o bit de sinal que determina se x negativo ou no. Neste caso o bit do sinal copiado para os bits inferiores por razes histricas esotricas: int x = -16; // binario: 1111111111110000 int y = x >> 3; // binario: 1111111111111110 Este comportamento chamado extenso do sinal e freqentemente no o comportamento desejado. Entretanto, voc pode desejar desviar preenchendo o espao com zeros. Neste caso voc deve utilizar uma alterao do tipo de dados que possui uma regra diferente para inteiros no assinalados: int x = -16; // binario: 1111111111110000 int y = (unsigned int)x >> 3; // binario: 0001111111111110 Se voc for cauteloso em evitar a extenso do sinal, voc pode usar o operador de desvio para a direita >> como um modo de dividir um nmero por potncias de 2. Por exemplo: int x = 1000; int y = x >> 3; // diviso inteira de 1000 por 8, resultado y=125. 1 2 4 8

Pgina | 25

operadores de bits compostos AND (&=) e OR (|=)


Os operadores de bits compostos realizam seus clculos no nvel de bit das variveis. So freqentemente utilizados para limpar ou marcar bits especficos. Veja o operador de bits AND(&) e o operador de bits OR(|) para detalhes sobre seu funcionamento.

operador de bits composto AND (&=)


Descrio O operador de bits composto AND (&=) freqentemente utilizado entre uma varivel e uma constante para forar que alguns bits em particular da varivel sejam marcados como LOW (como 0). Este conceito aparece em manuais de programao como "limpeza" ou "resetting" de bits. Sintaxe: x &= y; // equivalente a x = x & y; Parmetros: x: uma varivel do tipo char, int ou long y: uma constante do tipo char, int, ou long Exemplo: Primeiro, uma reviso do operador de bits AND (&) 0 0 1 1 0 1 0 1 ---------0 0 0 1 (operando1 & operando2) - resultado de retorno operando1 operando2

Bits que passam pelo operador AND um operando 0 so limpados para 0. Posrtanto se myByte uma varivel do tipo byte myByte & B00000000 = 0. Bits que passam pelo operador AND com um operando 1 se matm como esto. Portanto myByte & B11111111 = myByte. Consequentemente para limpar (marcar como zero) alguns dos bits de uma varivel deixando os demais como esto s usar o operador de bits composto AND (&=) com uma constante por exemplo B11111100 1 0 1 0 1 0 1 0 1 1 1 1 1 1 0 0 ---------------------1 0 1 0 1 0 0 0 varivel no modificada bits limpos Aqui est a mesma representao com os bits da varivel subtituidos pelo smbolo x x x x x x x x x 1 1 1 1 1 1 0 0 ---------------------x x x x x x 0 0 varivel mscara varivel mscara

Pgina | 26

varivel no modificada bits limpos portato se: myByte = 10101010; myByte &= B1111100 == B10101000;

operador de bits composto OR (|=)


Descrio O operador de bits composto OR (|=) frequentemente utilizado entre uma varivel e uma constatnte para forar que alguns bits em particular sejam marcados como 1. Sintaxe: x |= y; // equivalente a x = x | y; Parmetros x: uma varivel do tipo char, int ou long y: uma constante do tipo char, int, ou long Exemplo: First, a review of the Bitwise OR (|) operator 0 0 1 1 0 1 0 1 ---------0 1 1 1 (operando1 | operando2) - resultado de retorno Bits que passam pelo operador OR com um operando 0 so mantidos como esto, portanto se myByte uma varivel tipo byte, myByte | B00000000 = myByte; Bytes que passam pelo operador OR com um operando 1 so marcados com 1: myByte & B11111111 = B11111111; Consequentemente para marcar os bits 0 e 1 de uma varivel deixando o restante sem mudanas use o operador de bits composto OR (|=) com a constante B00000011 1 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 ---------------------1 0 1 0 1 0 1 1 variivel no modificada bits alterados Aqui a mesma representao com as variveis substituidas pelo smbolo x x x x x x x x x 0 0 0 0 0 0 1 1 ---------------------x x x x x x 1 1 variivel no modificada bits alterados So if: myByte = B10101010; myByte |= B00000011 == B10101011; varivel mscara varivel mscara operando1 operando2

Pgina | 27

++ (incremento) / -- (decremento)
Descrio Incrementar ou decrementar uma varivel (adcionar ou subtrair 1) Sintaxe x++; // incrementa x em 1 e retorna o antigo valor de x ++x; // incrementa x em 1 e retorna o novo vaor de x x-- ; // decrementa x em 1 e retorna o antigo valor de x --x ; // decrementa x em 1 e retorna o novo valor de x Parmetros x: uma variavel do tipo integer ou long (possivelmente no assinalada) Retornos O original ou recentemente incrementedo / decrementedo valor da varivel. Exemplos x = 2; y = ++x; y = x--; // x agora contm 3, y contm 3 // x contm 2 de novo, y ainda contm 3

+= , -= , *= , /=
Descrio Realiza uma operao matemtica em uma varivel com outra constante ou varivel. O operador += (e os outros) so apenas abreviaes prticas da sintaxe expandida listada abaixo: Sintaxe x += y; // equivalente expresso x = x + y; x -= y; // equivalente expresso x = x - y; x *= y; // equivalente expresso x = x * y; x /= y; // equivalente expresso x = x / y; Parmetros x: qualquer tipo de varivel y: qualquer tipo de varivel ou constante Exemplos x = 2; x += 4; x -= 3; x *= 10; x /= 2; // x agora contm 6 // x agora contm 3 // x agora contm 30 // x agora contm 15

Pgina | 28

Constantes
Constantes so variveis pre-definidas na linguagem Arduino. Elas so usadas para tornar os programas mais facilmente legveis. Ns classificamos as constantes em grupos.

Definindo nveis lgicos, verdadeiro e falso (constantes booleanas)


H duas constantes usadas para representar verdade ou falsidade na linguagem Arduino: true (verdadeiro), e false (falso).

false
false a mais simples das duas e definida como 0 (zero).

true
true frequentemente definida como 1, o que correto, mas true tem uma definio mais ampla. Qualquer inteiro que no zero TRUE, emum modo booleano. Assim, -1, 2 e -200 so todos definidos como true. Note que true e false so digitadas com minsculas diferente de HIGH, LOW, INPUT, e OUTPUT.

Definindo nveis de pinos, HIGH e LOW


Quando estamos lendo ou escrevendo em um pino digital h apenas dois valores que um pino pode ter: HIGH (alto) e LOW(baixo).

HIGH
O significado de HIGH (em referncia a um pino) pode variar um pouco dependendo se este pino uma entrada (INPUT) ou sada (OUTPUT). Quando um pino configurado como INPUT com pinMode, e lido com um digitalRead, o microcontrolador considera como HIGH se a voltagem for de 3 volts ou mais. Um pino tambm pode ser configurado como um INPUT com o pinMode, e posteriormente receber um HIGH com um digitalWrite, isto vai "levantar" o resistor interno de 20K
que vai manter a leitura do pino

como HIGH a no ser que ela seja alterada para low por um circuto externo. Quando um pino configurado como OUTPUT com o pinMode, e marcado como HIGH com o digitalWrite, ele est a 5 volts. Neste estado ele pode enviar corrente como por exemplo acender um LED que est conectado com um resistor em srie ao terra, ou a outro pino configurado como OUTPUT e marcado como LOW.

LOW
O significado de LOW tambm pode variar dependendo do pino ser marcado como INPUT ou OUTPUT. QUando um pino configurado como um INPUT com o pinMode, e lido com o digitalRead, o microcontrolador considera como LOW se a voltagem for de 2 volts ou menos. Quando um pino configurado como OUTPUT com pinMode, e marcado como LOW com o digitalWrite, ele est a 0 volts. Neste estado ele pode "drenar" corrente como por exemplo para acender um LED que est conectado com um resistor em srie ao +5 volts, ou a outro pino configurado como OUTPUT e marcado como HIGH.

Definindo pinos digitais, INPUT e OUTPUT


Pinos digitais podem ser tanto de INPUT como de OUTPUT. Mudar um pino de INPUT para OUTPUT com pinMode() muda drasticamente o seu comportamento eltrico. Pinos configurados como Inputs Os pinos do Arduino (Atmega) configurados como INPUT com pinMode() esto em um estado de alta impedncia. Um modo de explicar que os pinos configurados como INPUT fazem demandas

Pgina | 29

extremamente pequenas ao circuto do qual esto tomando amostras, algo como um resistor de 100 Megaohms em srie com o pino. Sendo assim til para ler um sensor mas no para energizar um LED.

Pinos configurados como outputs


Pinos configurados como OUTPUT com pinMode() esto em um estado de baixa impedncia. Isto significa que eles podem fornecer grandes quantidades de corrente para outros circutos. Os pinos do Atmega podem fornecer corrente positiva ou drenar corrente negativa at 40 mA (milliamperes) de/para outros dispositivos ou circutos. Isto faz com que eles sejam teis para energizar um LED mas disfuncionais para a leitura de sensores. Pinos configurados como outputs tambm podem ser danificados ou destruidos por curto-circuitos com o terra ou com outros pontos de 5 volts. A quantidade de corrente fornecida por um pino do Atmega tambm no suficiente para ativar muitos rels e motores e, neste caso, algum circuto de interface ser necessrio.

Pgina | 30

Constantes inteiras
Constantes inteiras so nmeros usados diretamente no cdigo. Por padro estes nmeros so tratatados como int's, mas voc pode alterar este comportamento com os modificadores U e L (veja abaixo). Normalmente constantes inteiras so tratadas na base 10 (decimal), mas formatadores especiais podem ser usados para entrar nmeros em outras bases. Base 10 (decimal) 2 (binrio) 8 (octal) Exemplo 123 B1111011 0173 Formatador nenhum 'B' inicial somente valores de 8 bits (0 a 255) caracteres vlidos 0-1 '0' inicial 0x7B '0x' inicial caractres vlidos: 0-7 caractres vlidos: 0-9 A-F, a-f Comentrio

16 (hexadecimal)

Decimal so na base 10. Esta a matemtica do senso comum com a qual voc est acostumado. Constatntes sem outros prefixos so asumidas como decimais. Exemplo: 101 // o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1) Binrios so na base 2. Apenas os caracteres 0 e 1 so vlidos. Exemplo: B101 // o memso que 5 decimal ((1 * 2^2) + (0 * 2^1) + 1) O formatador binrio trabalha apenas com bytes (8 bits) entre 0 (B0) e 255 (B11111111). Se for conveniente entrar um nmero de 16 bits na forma binria voc pode fazer isso seguindo o algoritmo abaixo: The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). If it is convenient to input an int (16 bits) in binary form you can do it a two-step procedure such as: myInt = B1100110010101010; myInt = (B11001100 * 256) + B10101010; segundo Octais so na base oito. Apenas caracteres entre 0 e 7 so vlidos. Valores octais so indicados pelo prefixo "0". Exemplo: 0101 Cuidado possivel gerar um erro difcil de encontrar (no intencional) incluindo um zero frente de uma constatnte o que far com que o compilador interprete o valor como octal. Hexadecimais (ou hex) so na base 16. Caracteres vlidos so de 0 a 9 e as letras de A a F; A vale 10, B vale 11 at F que vale 15. Valores hexadeciamis so indicados pelo prefixo "0x". Note A-F pode ser escrito tanto com maiusculas quanto com minsculas (a-f). Exemplo: 0x101 // o mesmo que 257 decmal ((1 * 16^2) + (0 * 16^1) + 1) Formatadores U e L Por padro uma constante inteira tratada como um int com as limitaes pertinentes nos valores. Para especificar uma constante inteira com outro tipo de dado proceda assim: // o mesmo que 65 decimal ((1 * 8^2) + (0 * 8^1) + 1) // entrada invlida // B11001100 o primeiro byte e B10101010 o

y y y

um 'u' ou 'U' para forar a constante como do tipo no assinalado (unsigned). Exemplo: 33u um 'l' ou 'L' para forar a constante como do tipo longo (long). Exemplo: 100000L um 'ul' ou 'UL' para forar a constante como do tipo longo no assinalado (unsigned long). Exemplo: 32767ul

Pgina | 31

Variveis booleanas *
variveis boolenas podem ter apenas dois valores verdadeiro (true) e falso (false). Exemplo int LEDpin = 5; // LED no pino 5 int switchPin = 13; // interruptor no, outro lado conectado ao terra. boolean running = false; void setup() { pinMode(LEDpin, OUTPUT); pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); } void loop() { if (digitalRead(switchPin) == LOW) { // interruptor pressionado - resistor se mantm "levantado" delay(100); running = !running; } } * assim chamadas em homenagem a George Boole // espera para filtrar rudo da chave // inverte o valor da varivel running // indica via LED // "levanta" o resistor

digitalWrite(LEDpin, running)

char
Descrio Um tipo de dado que ocupa 1 byte de memria e armazena o valor de um caractere. Caracteres literais so escritos entre ' ' (em ingls estes caracteres se chamam single quotes, no consigo imaginar como possa ser em portugus) como este: 'A' (para cadeias de caracteres - strings - use aspas: "ABC"). Entretanto caracteres so armazenados como nmeros. Voc pode ver o cdigo especfico na tabela ASCII. Isto significa que possvel realizar operaes artimticas com caracteres, nos quais o valor ASCII do caractere utilizado (e.g. 'A' + 1 vale 66, desde que o valor ASCII do A miusculo 65). Veja a referencia do Serial.println para mais informao de como os caracteres so traduzidos em nmeros. O tipo de dado char tambm do tipo assinalado, isso quer dizer que possvel codificar nmeros de -128 a 127. Para um tipo de dado no assinalado de 1 byte (8 bits) use o tipo de dado byte. Exemplo char myChar = 'A'; char myChar = 65; // ambos so equivalentes

Pgina | 32

byte
Descrio Um byte armazena um nmero de 8 bits no assinalado, de 0 a 255. Exemplo byte b = B10010; // "B" o formatador binrio (B10010 = 18 decimal)

int
Descrio Inteiro o principal tipo de dado para armazenamento numrico capaz de nmeros de 2 bytes. Isto abrange a faixa de -32.768 a 32.767 (valor mnimo de -2^15 e valor mximo de (2^15) -1). Ints armazenam nmeros negativos com uma tcnica chamada Complemento para dois. O bit mais alto, as vezes chamado de bit de "sinal", e sinaliza se o nmero positivo ou negatico. O Arduino cuida da manipulao de nmeros nagativos para voc, assim as operaes aritmticas funcionam de modo transparente e esperado. Entretanto pode ocorrer uma complicao inesperada na manipulao operador para deslocar bits direita (>>). Exemplo int ledPin = 13; Sintaxe int var = val;

y y

var - o nome da varivel int val - o valor designado para a varivel Dica de programao Quando uma varivel excede seu valor mximo de que capaz ela "decai" ao valor mnimo de que capaz. Note que isso ocorre nas duas direes. int x x = -32,768; x = x - 1; x = 32,767; x = x + 1; // x agora contm -32,768 - decaido // x agora contm 32,767 - decaindo na direo negativa

Pgina | 33

int no assinalado (unsigned int)


Descrio Ints no assinalados (inteiros sem sinal) so o mesmo que ints no modo como armazenam valores de 2 bytes. Entretanto, ao invs de armazenar nmeros negativos, armazenam somente valores positivos abrangendo a faixa de 0 a 65.535 ((2^16)-1). A diferena entre ints e ints no assinalados est no modo como o bit mais alto interpretado.No Arduino o tipo int (que assinalado), se o bit mais elevado 1, o nmero interpretado como negativo. Exemplo unsigned int ledPin = 13; Sintaxe unsigned int var = val;

y y

var - nome da varivel do tipo int no assinalado val - o valor designado para a varivel Dica de programao Quando variveis excedam sua capacidade mxima elas "decaem" para o valor de sua capacidade mnima. Note que isso ocorre nas duas direes. unsigned int x x = 0; x = x - 1; x = x + 1; // x agora contm 65535 - decaindo na direo negatica // x now contains 0 - decaindo

long
Descrio Variveis do tipo Long tm um tamanho ampliado para armazenamento de nmeros, e so capazes de armazenar 32 bits (4 bytes), de -2.147.483,648 a 2.147.483.647. Exemplo long speedOfLight = 186000L; // veja Constantes inteiras para a explicao do 'L' Sintaxe long var = val;

y y

var - o nome da varivel de tipo long val - o valor designado para a varivel

Pgina | 34

long no assinalado (unsigned long)


Descrio Longs no assinalados (longos sem sinal) so variveis de tamanho ampliado para armazenamento numrico. Diferente dos longs padro, os no assinalados no armazenam nmeros negativos, abrangendo a faixa de 0 a 4.294.967.295 (2^32 - 1). Exemplo unsigned long time; void setup() { Serial.begin(9600); } void loop() { Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa comeou a rodar Serial.println(time); // espera um segundo de modo que o programa no envie quantidades absurdas de dados delay(1000); } Sintaxe unsigned long var = val;

y y

var - o nome de sua varivel tipo long val - o valor designado para a varivel

Pgina | 35

float
Descrio Tipo de dado para nmeros de ponto flutuante, um nmero que tem um ponto decimal. Nmeros de ponto flutuante so freqentemente usados para aproximar valores anlogos e contnuos porque tm mais resoluo que os inteiros. Nmeros de ponto flutuante abrangem a faixa de 3,4028235E+38 a 3,4028235E+38. Eles so armazenados em 32 bits (4 bytes) de informao. Nmeros de ponto flutuante no so exatos e podem gerar resutados estranhos quando comparados. Por exemplo 6.0 / 3.0 pode no ser igua a 2.0. Voc deve, em vez disso, verificar que o valor absoluto da diferena entre os nmeros menor que um valor pequeno pr-determinado. A matemtica de ponto flutuante tambm muito mais lenta que a dos inteiros na realizao de clculos, deve portanto ser evitada se, por exemplo, um loop tem que rodar a velocidade mxima para uma funo em que o tempo cr'tico. Programadares freqentemente se esforam para converter clculos com pontos flutuantes em matemtica de inteiros para aumentar a velocidade. Exemplos float myfloat; float sensorCalbrate = 1.117; Sintaxe float var = val;

y y

var - o nome da sua varivel de ponto flutuante val - o valor designado para a varivel Cdigo de exemplo int x; int y; float z; x = 1; y = x / 2; // y agora contm 0, inteiros no suportam fraes z = (float)x / 2.0; // z agora contm .5 (voce deve usar 2.0, no 2) Dica de programao Serial.println() trunca os floats (despreza as fraes) em inteiros quando enviando comunicao serial. Multiplique por potncias de 10 para preservar a resoluo.

Pgina | 36

double
Descrio Nmero de ponto flutuante de preciso dupla. Ocupa 4 bytes. A implementao do double no Arduino atualmente exatamente a mesma do float, sem ganho de preciso. Dica Usurios que utilizam cdigos de outras fontes que incluem varivei do tipo double devem examinar o cdigo para para verificar se a preciso implicada diferente daquela realmente alcanada pelo Arduino.

string
Descrio Strings so representadas como arrays do tipo de dado char e terminadas por null (nulo). Exemplos Todos os seguintes so declaraes vlidas de strings. char Str1[15]; char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'}; char Str4[ ] = "arduino"; char Str5[8] = "arduino"; char Str6[15] = "arduino"; Possibilidades de declarao de strings

y y y y y y

Declarar um array de chars sem inicializar como em Str1 Declarar um array de chars (com um char a mais) e o compilador vai adcionar o caractere null necessrio como em Str2 Adcionar explicitamente o caractere null como em Str3 Inicializar com uma string constante entre aspas; o compilador determina o tamanho de modo a armazenar a string e o caractere null final como em Str4 Inicializar o array com uma string constante e o tamanho explicitos como em Str5 Inicializar o array deixando espao extra para uma string maior como em Str6 Terminao em Null Geralmente strings so terminadas com o caractere null (cdigo ASCII 0). Isto permite s funes (como Serial.print()) saber onde est o final da string. De outro modo elas continuariam lendo os bytes subsequentes da memria que de fato no pertencem string. Isto significa que sua string deve ter espao para um caractere a mais do que o texto que ela contm. por isso que Str2 e Str5 precisam ter 8 caracteres, embora "arduino" tenha apenas 7 - a ltima posio automaticamente preenchida com o caracatere null. Str4 ter o tamanho determinado automaticamente como 8 caracteres, um extra para o null. Na Str3 ns incluimos explicitamente o caractere null (escrito como '\0'). Note que possvel ter uma string sem o caractere final null (e.g. se voc tivesse especificado o tamanho da Str2 com sete ao invs de oito). Isto vai danificar a maioria das funes que usam strings, portanto voc no deve fazer isso intencionalmente. Entretanto se voc notar algo se comportando de maneira estranha (operaes em caracteres que no pertencem string) este poderia ser o problema. Aspas ou apstrofos? Strings so sempre definidas com aspas ("Abc") e caracteres sempre definidos com apstrofos('A'). Envolvendo strings longas Voc pode envolver strings longas desse modo:

Pgina | 37

char myString[] = "This is the first line" " this is the second line" " etcetera"; Arrays de strings Freqentemente conveniente, quando se est trabalhando com grandes quantidades de texto, como em um projeto com um display de LCD, configurar um array de strings. Devido ao fato de as strings serem elas mesmas arrays, este de fato um exemplo de um array bi-dimencional. No cdigo abaixo os asteriscos aps o tipo de dado char "char*" indica que se trata de um array de "ponteiros". Todos os nomes de array so de fato ponteiros, e assim so requeridos para se configurar um array de arrays. Ponteiros so uma das partes mais esotricas da linguagem C que os principiantes tm que entender, mas necessrio entender os ponteiros em detalhe para fazer um uso efetivo deles neste caso. Exemplo char* myStrings[]={"This is string 1", "This is string 2", "This is string 3", "This is string 4", "This is string 5","This is string 6"}; void setup(){ Serial.begin(9600); } void loop(){ for (int i = 0; i < 6; i++){ Serial.println(myStrings[i]); delay(500); } }

Pgina | 38

Arrays
Um array uma coleo de variveis que so acessadas com um ndice numrico. Arrays na liguagem de programao C, na qual o Arduino baseado, podem ser complicados, mas o uso de arrays simples relativamente operacionalizvel. Criando (Declarando) um Array Todos os mtodos abaixo so modos vlidos para criar (declarar) um array. int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = "hello"; Voc pode declarar um array sem inicializar como em myInts. Em myPins declaramos um array sem escolher explicitamente um tamanho. O compilador conta os elementos e cria o array do tamanho apropriado. Finalmente, voc pode inicializar e especificar o tamanho do array como em mySensVals. Note que quando declarar um array do tipo char, um elemento a mais necessrio para armazenar o caractere null de finalizao. Acessando um Array Arrays so indexados a partir do zero, ou seja, fazendo referncia inicializao de arrays acima, o primeiro elemento do array est no ndice 0, assim: mySensVals[0] == 2, mySensVals[1] == 4, e assim por diante. Isso tambm significa que em um array de 10 elementos o ndice do ltimo elemento 9, assim: int myArray[10]={9,3,2,4,3,2,7,8,9,11}; // myArray[9] contm 11 // myArray[10] invlido e contm informao aleatria (outro endereo de memria) Por esta razo voc deve acessar arrays cuidadosamente. Acessar um array aps o seu final (usando um ndice maior do que o declarado) ler uma faixa de memria que est sendo utilizada para outros propsitos. Ler destes locais provavelmente no vai gerar nada alm de dados invlidos. Escrever em locais de memria aleatrios decididamente no uma boa idia, e provavelmente conduzir a maus resultados como malfuncionamento ou travamento do programa. Isto tambm pode ser um bug difcil de rastrear. Diferente de algumas verses do BASIC, o compilador C no checa para ver se um acesso a um array est dentro das margens legais do tamanho com que o array foi declarado. Designar um valor para um array: mySensVals[0] = 10; Recuperar um valor de um array: x = mySensVals[4]; Arrays e FOR Arrays so freqentemente manipulados dentro da sentena for, nas quais o contador usado com ndice para cada elemento. Por exemplo, para imprimir os elementos de um array atravs da porta serial voc poderia fazer alguma coisa assim: int i; for (i = 0; i < 5; i = i + 1) { Serial.println(myPins[i]); }

Pgina | 39

void
A palavra-chave void usada apenas em declaraes de funes. Ela indica que a funo no deve enviar nenhuma informao de retorno funo que a chamou. Exemplo: // aes so realizadas nas funes "setup" e "loop" // mas nenuma informao enviada ao programa mais amplo void setup() { // ... } void loop() { // ... }

Pgina | 40

char()
Descrio Converte um valor para o tipo de dado char. Sintaxe char(x) Parmetros x: um valor de qualquer tipo Retorno char

byte()
Descrio Converte um valor para o tipo de dado byte. Sintaxe byte(x) Parmetros x: um valor de qualquer tipo Retorno byte

int()
Descrio Converte um valor para o tipo de dado int. Sintaxe int(x) Parmetros x: um valor de qualquer tipo Retorno int

long()
Descrio Converte um valor para o tipo de dado long. Sintaxe long(x) Parmetros x: um valor de qualquer tipo Retorno long

Pgina | 41

float()
Descrio Converte um valor para o tipo de dado float. Sintaxe float(x) Parmetros x: um valor de qualquer tipo Retorno float

Tabela ASCII
O cdigo ASCII (American Standard Code for Information Interchange) est em uso desde a dcada de 1960. Ele o modo padro para codificar texto numericamente.* Note que os primeiros 32 caracteres (0-31) so caracteres no imprimveis, tambm chamados de caracteres de controle. Os caracteres mais importantes foram nomeados na tabela abaixo:
Valor Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 return 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 Caractere Valor Decimal 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 Caractere Valor Decimal 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 Caractere Valor Decimal 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 Caractere

null

tab line feed

carriage

espao ! " # $ % & ' ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _

` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~

* Nota do tradutor: O cdigo ASCII um padro para codificar texto numericamente e embora tenha muita importncia histrica, vem sendo gradativamente substituido por padres mais amplos como o UTF, em suas diversas variantes, e os conjuntos de caracteres (charset) definidos pela ISO (International Organization for Standardization).

Pgina | 42

pinMode()
Descrio Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma sada (output). Veja a descrio depinos digitais para mais detalhes. Sintaxe pinMode(pin, mode) Parmetros pin: o nmero do pin o qual voc deseja predeterminar. mode: pode ser INPUT ou OUTPUT Retorno Nenhum Exemplo int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); delay(1000); } Nota Os pinos de entrada analgica podem ser usados como pinos digitais e devem ser referenciados com os nmeros de 14 (entrada analgica 0) a 19 (entrada analgica 5). // espera um segundo // apaga o LED // espera um segundo digitalWrite(ledPin, LOW); // predetermina o pino digital como uma sada // LED conectado ao pino digital 13

Pgina | 43

digitalWrite()
Descrio Escreve um valor HIGH ou um LOW em um pino digital. Se o pino foi configurado como uma sada (output) com o pinMode(), sua voltagem ser determinada ao valor correspondente: 5V (ou 3.3V nas placas de 3.3V) para HIGH, 0V (terra) para LOW. Se o pino est configurado como uma entrada (input) escrever um HIGH levantar o resistor interno de 20K tutorial de pinos digitais). Escrever um LOW rebaixar o resistor. ( Sintaxw digitalWrite(pin, valor) Parmetros pin: o nmero do pin valor: HIGH oo LOW Retorno nenhum Exemplo int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); delay(1000); } Nota Os pinos de entrada analgica podem ser usados como pinos digitais e devem ser referenciados com os nmeros de 14 (entrada analgica 0) a 19 (entrada analgica 5). // espera um segundo // apaga um led // espera um segundo digitalWrite(ledPin, LOW); // determia o pino digital como uma sada // LED conectado ao pino digital 13

Pgina | 44

digitalRead()
Descrio L o valor de um pino digital especificado, HIGH ou LOW. Sintaxe digitalRead(pin) Parmetros pin: o nmero do pin digital que voc quer ler (int) Retorno HIGH ou LOW Exemplo int ledPin = 13; // LED conectado ao pino digital 13 int inPin = 7; // boto conectado ao pino digital 7 int val = 0; void setup() { pinMode(ledPin, OUTPUT); pinMode(inPin, INPUT); } void loop() { val = digitalRead(inPin); // l o pino de entrada digitalWrite(ledPin, val); } Transfere para o pino 13 o valor lido no pino 7 que uma entrada. Nota Se o pino no estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode variar aleatoriamente). Os pinos de entrada analgica podem ser usados como pinos digitais e devem ser referenciados com os nmeros de 14 (entrada analgica 0) a 19 (entrada analgica 5). // acende ou apaga o LED de acordo com o pino de entrada // pr-determina o pino digital 13 como uma sada // pr-determina o pino dgital 7 como uma entrada // varivel para armazenar o valor lido

Pgina | 45

analogRead()
Descrio L o valor de um pino analgico especificado. A placa Arduino contm um conversor analgico-digital de 10 bits com 6 canais (8 canais no Mini e no Nano). Com isto ele pode mapear voltagens de entrada entre 0 e 5 volts para valores inteiros entre 0 e 1023. Isto permite uma resoluo entre leituras de 5 volts / 1024 unidades ou 0,0049 volts (4.9 mV) por unidade. So necessrios aproximadamente 100 Sintaxe analogRead(pin) Parmetros pin: o nmero do pino analgico que se deseja ler (0 a 5 na maioria das placas, 0 ta 7 no Mini e no Nano) Retorno int (0 a 1023) Note Se o pino analgico no estiver conectado a nada o valor de retorno do analogRead() vai variar de acordo com uma grande quantidade de fatores (e.g. os valores de outras entradas analgicas, a distncia de sua mo placa, etc.). Na prtica um valor aleatrio. Exemplo int analogPin = 3; int val = 0; void setup() { Serial.begin(9600); } void loop() { val = analogRead(analogPin); Serial.println(val); } // l o pino de entrada // informa o valor lido // inicial a comunicao serial // perna do meio de um potencimetro conectada ao pino analgico 3
s (0.0001 s) para ler uma entrada analgica, portanto a

velocidade mxima de leitura de aproximadamente 10.000 vezes por segundo.

// pernas externas conectadas ao terra e ao +5V // varivel para armazenar o valor lido

Pgina | 46

analogWrite()
Descrio Escreve um valor analgico (onda PWM) em um pino. Pode ser usado para acender um LED variando o brilho ou girar um motor a velocidade varivel. Depois de realizar um analogWrite(), o pino vai gerar uma onda quadrada estvel com o ciclo de rendimento especificado at que o prximo analogWrite() seja realizado (ou que seja realizado um digitalRead() oudigitalWrite() no mesmo pino). A freqncia do sinal PWM de aproximadamente 490Hz. Nas novas placas Arduino (incluindo o Mini e o BT) com o chip ATmega168 esta funo eficiente nos pinos 3,5,6,9,10 e 11. Placas Arduino mais antigas com um ATmega8 suportam o analogWrite() apenas nos pinos 9,10 e 11. Sintaxe analogWrite(pin, valor) Parmetros pin: o pino no qual se deseja escrever valor: o rendimento do ciclo: entre 0 (sempre desligado) e 255 (sempre ligado). Retorno nenhum Notas e problemas conhecidos No necessrio realizar um pinMode() para pr-determinar o comportamento do pino como sada antes de realizar um analogWrite(). As sadas PWM geradas pelos pinos 5 e 6 tero rendimento de ciclo acima do esperado. Isto se deve s interaes com as funes millis() e delay(), que compartilham o mesmo temporizador interno usado para gerar as sadas PWM. Exemplo Torna o brilho de um LED proporcional ao valor lido em um potencimetro. int ledPin = 9; int val = 0; void setup() { pinMode(ledPin, OUTPUT); // pr-determina o pino como sada } void loop() { val = analogRead(analogPin); // l o pino de entrada analogWrite(ledPin, val / 4); // os valores do analogRead variam de 0 a 1023, os valores do analogWrite variam de 0 a 255 } // LED conectado ao pino digital 9 // varivel para armazenar o valor lido

int analogPin = 3; // potentimetro conectado ao pino analgico 3

Pgina | 47

shiftOut()
Descrio Envia um byte para a sada um bit de cada vez. Pode comear tanto pelo bit mais significativo (mais esquerda) quano pelo menos significativo (mais direita). Os bits vo sendo escritos um de cada vez um pino de dados, em sincronia com as alteraes de um pino de clock que indica que o prximo bit est disponvel. Isto conhecido como protocolo serial sincrnico e um modo comumente usado para que os microcontroladores se comuniquem com sensores e com outros microcontroladores. Os dois sispositivos se mantm sincronizados a velocidades prximas da mxima desde que ambos compartilhem a mesma linha de clock. Normamlemte esta caracterstica descrita comoSerial Peripheral Interface (SPI). na documentao dos chips. Sintaxe shiftOut(dataPin, clockPin, bitOrder, value) Parmetros dataPin: o pino no que ser a sada de cada bit (int) clockPin: o pino que alterado quando um novo valor foi enviado ao dataPin (int) bitOrder: qual a ordem de envio dos bits, pode ser MSBFIRST LSBFIRST. (Mais significativo primeiro ou menos significativo primeiro) value: a informao a enviar para a sada. (byte) Retorno Nenhum Note O dataPin e clockPin devem estar configurados como output pela funo pinMode(). Exemplo Para o circuto de referncia deste exemplo veja tutorial on controlling a 74HC595 shift register. //**************************************************************// // Name // Date : shiftOutCode, Hello World : 25 Oct, 2006 // // // // // // // Author : Carlyn Maw,Tom Igoe // Version : 1.0 // : to count from 0 to 255

// Notes : Code for using a 74HC595 Shift Register

//**************************************************************** //Pin connected to ST_CP of 74HC595 int latchPin = 8; //Pin connected to SH_CP of 74HC595 int clockPin = 12; ////Pin connected to DS of 74HC595 int dataPin = 11; void setup() { //set pins to output because they are addressed in the main loop pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); }

Pgina | 48

void loop() { //count up routine for (int j = 0; j < 256; j++) { //ground latchPin and hold low for as long as you are transmitting digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, j); //return the latch pin high to signal chip that it //no longer needs to listen for information digitalWrite(latchPin, HIGH); delay(1000); } }

PulseIn()
Descrio L um pulso (tanto HIGH como LOW) em um pino. Por exemplo, se valor for HIGH, pulseIn() espera que o pino v paraHIGH, inicia a cronometragem, e ento espera que o pino v para LOW e para a cronometragem. Retorna a durao do pulso em microsegundos. Desiste e retorna 0 se nenhum pulso iniciar dentro de um tempo especificado. O tempo desta funo foi determinado empiricamente e provavelmente dar erro em pulsos longos. Funciona com pulsos entre 10 microsegundos e 3 minutos. Syntaxe pulseIn(pino, valor) pulseIn(pino, valor, tempo) Parameters pino: o nmero do pino no qual voc deseja ler o pulso. (int) valor: tipo de pulso a ler: tanto HIGH como LOW. (int) tempo (opcional): o nmero de microsegundos a esperar para que o pulso comece; o padro um segundo (unsigned long) Returno a durao do pulso (em microsegundos) ou 0 se nehum pulso iniciar antes do tempo especificado (unsigned long) Exemplo int pin = 7; unsigned long duration; void setup() { pinMode(pin, INPUT); } void loop() { duration = pulseIn(pin, HIGH); }

Pgina | 49

millis()
Descrio Retorna o nmero de milisegundos desde que a placa Arduino comeou a rodar o programa. Este nmero extrapolr (voltar ao zero) depois de aproximamente 50 dias. Parmetros Nenhum Retorno O nmero de milisegundos desde que o programa comeou a rodar como um tipo longo no assinalado. Exemplo unsigned long time; void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa comeou Serial.println(time); // espera um segundo para no ficar enviando quantidades absurdas de dados delay(1000); } Dica: Verifique o retorno para o millis um longo no assinalado. Erros podem ocorrer se um programador tentar realizar clculos com outros tipos de dados, como inteiros.

micros()
Descrio Retorna o nmero de microsegundos desde que a placa Arduino comeou a rodar o programa. Este nmero extrapolr (voltar ao zero) depois de aproximamente 70 minutos. Nas placas Arduino de 16 MHz (e.g. Duemilanove e Nano), esta funo tem uma resoluo de 4 microsegundos (o valor de retorno ser sempre um mltiplo de 4) Nas placas Arduino de 8MHz (e.g. LilyPad), esta funo tem uma resoluo de 8 microsegundos. Nota: em 1 milisegundo h 1.000 microsegundos e 1.000.000 de microsegundos em 1 segundo. Parmetros Nenhum Retorno O nmero de microsegundos desde que o programa comeou a rodar como um tipo longo no assinalado.

Pgina | 50

Exempl0 unsigned long time; void setup() { Serial.begin(9600); } void loop() { Serial.print("Time: "); time = micros(); //imprime o tempo desde que o programa comeou a rodar Serial.println(time); //espera um segundo para no ficar enviando quantidades absurdas de dados delay(1000); }

delay(ms)
Descrio Suspende a execuo do programa pelo tempo (em milisegundos) especificado como parmetro. (Em um segundo h 1.000 milisegundos.) Parmetros ms (unsigned long): o nmero de milisegundos em que o programa ficar com a execuo em suspenso. Retorno nenhum Exemplo int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); delay(1000); } Cuidado Embora seja fcil criar um LED piscando com a funo delay(), e muitos programas usam intervalos curtos para tarefas como a de filtrar rudos, o uso do delay() em um programa tem aspectos negativos importantes. Nenhuma leitura de sensores, clculo matemtico, ou manipulao de pinos pode seguir durante a execuo desta funo, portanto muitas outras funes ficam em espera. Para controles de tempo alternativos veja a funo millis() e e seu programa de exemplo. Programadores com mais conhecimento normalmente evitam o uso de delay() para cronometrar eventos mais logos do que 10 milisegundos, a no ser que o programa seja muito simples. // espera por um segundo // apaga o LED // espera por um segundo digitalWrite(ledPin, LOW); // marca o pino digital como sada // LED conectado ao pino digital 13

Pgina | 51

Algumas coisas de fato continuam acontecendo enquanto a funo delay() est controlando o chip ATmega porque as interrupes no so desabilitadas. A comunicao que aparece no pino RX continua sendo gravada. os pinos e as leituras de PWM (analogWrite) so mantidos, e as interrupes continuam funcionando.

delayMicroseconds(s)
Descrio Suspende a execuo do programa pelo tempo (em microsegundos) especificado como parmetro. Um 1 milisegundo h 1.000 microsegundos e em 1 segundo h 1 milho. Atualmente o maior valor que produzir uma suspeno precisa 16383. Isto pode mudar em distribuies futuras do Arduino. Para suspenes maiores que milhares de microsegundo voc deve utilizar a funo delay(). Parmetros
s: o nmero de microsegundos da suspeno.

Retorno Nenhum Exemplo int outPin = 8; void setup() { pinMode(outPin, OUTPUT); } void loop() { digitalWrite(outPin, HIGH); // ativa o pino delayMicroseconds(50); digitalWrite(outPin, LOW); delayMicroseconds(50); } configura o pino 8 para trabalhar como uma sada. Envia uma cadeia de de pulsos com um perodo de 100 microsegundos. Cuidados e problemas conhecidos Esta funo funciona com bastante preciso na faixa dos 3 microsegundos e acima. No podemos nos assegurar que funcione com preciso para tempos de suspeno menores. Para assegurar suspenes mais precisas esta funo desabilita as interrupes durante sua operao. Isto significa que algumas coisas (como o recebimento de informaes seriais, ou que a atualizao do valor de retorno da funo mills() ) no funcionaro. Desse modo, voc deve usar esta funo apenas para suspenes curtas, e usar delay() para as mais longas. delayMicroseconds(0) gerar uma suspano muito maior do que a esperada (~1020 parmetro for um nmero negativo.
s) bem como se o

// digital pino 8

// marca o pino digital como sada

// suspeno de 50 microsegundos // desativa o pino // suspeno de 50 microsegundos

Pgina | 52

delayMicroseconds(s)
Descrio Suspende a execuo do programa pelo tempo (em microsegundos) especificado como parmetro. Um 1 milisegundo h 1.000 microsegundos e em 1 segundo h 1 milho. Atualmente o maior valor que produzir uma suspeno precisa 16383. Isto pode mudar em distribuies futuras do Arduino. Para suspenes maiores que milhares de microsegundo voc deve utilizar a funo delay(). Parmetros
s: o nmero de microsegundos da suspeno.

Retorno Nenhum Exemplo int outPin = 8; void setup() { pinMode(outPin, OUTPUT); } void loop() { digitalWrite(outPin, HIGH); // ativa o pino delayMicroseconds(50); digitalWrite(outPin, LOW); delayMicroseconds(50); } configura o pino 8 para trabalhar como uma sada. Envia uma cadeia de de pulsos com um perodo de 100 microsegundos. Cuidados e problemas conhecidos Esta funo funciona com bastante preciso na faixa dos 3 microsegundos e acima. No podemos nos assegurar que funcione com preciso para tempos de suspeno menores. Para assegurar suspenes mais precisas esta funo desabilita as interrupes durante sua operao. Isto significa que algumas coisas (como o recebimento de informaes seriais, ou que a atualizao do valor de retorno da funo mills() ) no funcionaro. Desse modo, voc deve usar esta funo apenas para suspenes curtas, e usar delay() para as mais longas. delayMicroseconds(0) gerar uma suspano muito maior do que a esperada (~1020 parmetro for um nmero negativo.
s) bem como se o

// digital pino 8

// marca o pino digital como sada

// suspeno de 50 microsegundos // desativa o pino // suspeno de 50 microsegundos

Pgina | 53

min(x, y)
Descrio Calcula o mnimo entre dois nmeros. Parmetros x: o primeiro nmero, de qualquer tipo de dado y: o segundo nmero, de qualquer tipo de dado Retorno O menor dos dois nmeros. Exemplos sensVal = min(sensVal, 100); // assinala varivel sensVal o mnimo entre seu prrio valor e 100 // assegurando que seu valor nunca seja menor que 100 Nota Talvez, de modo no-intuitivo, max() frequentemente utilizado para restringir o valor mais baixo de uma varivel, enquanto min() utilizado para restringir o valor mais alto. Cuidado: Devido ao modo como a funo min() foi implementada voc deve evitar utilizar outras funes dentro dos parnteses, isto pode levar a resultados incorretos min(a++, 100); // evite isso a++; min(a, 100); // usse isso, mantenha outros clculos fora da funo

Pgina | 54

max(x, y)
Descrio Calcula o mximo entre dois nmeros Parmetros x: o primeiro nmero, de qualquer tipo de dado y: o segundo nmero, de qualquer tipo de dado Retorno O maior dos dois nmeros Exemplo sensVal = max(senVal, 20); // assinala varivel sensVal o mximo entre seu prrio valor e 20 // assegurando que seu valor seja pelo menos 20 Nota Talvez, de modo no-intuitivo, max() frequentemente utilizado para restringir o valor mais baixo de uma varivel, enquanto min() utilizado para restringir o valor mais alto. Cuidado Devido ao modo como a funo max() foi implementada voc deve evitar utilizar outras funes dentro dos parnteses, isto pode levar a resultados incorretos max(a--, 0); // evite isso a--; // use isso, mantenha outros clculos fora da funo

max(a, 0);

Pgina | 55

abs(x)
Descrio Calcula o valor absoluto de um nmero. Parmetros x: o nmero Retorno x: se x for maior ou igual a 0 -x: se x for menor que 0. Cuidado Devido ao modo como a funo abs() foi implementada voc deve evitar utilizar outras funes dentro dos parnteses, isto pode levar a resultados incorretos abs(a++); // evite isso a++; abs(a); // use isso, mantenha outros clculos fora da funo

constrain(x, a, b)
Descrio Restring um nmero dentro de uma faixa. Parmetros x: o nmero a restringir, todos os tipos de dados a: o extremo inferior da faixa, todos os tipos de dados b: o extremo superior da faixa, todos os tipos de dados Retorno x: se x estiver entre a e b a: se x for menor que a b: se x for mairo que b Exemplo sensVal = constrain(sensVal, 10, 150); // limita o valor da varivel sensVal a valores entre 10 e 150

Pgina | 56

map(value, fromLow, fromHigh, toLow, toHigh)


Descrio Re-mapeia um nmero de uma faixa de valores para outra. Isto , um valor de fromLow mapeado para toLow, um valor fromHigh para toHigh, e valores intermedirios da primeira faixa para a segunda faixa, mantendo-se a proporo entre eles. No restringe valores dentro da faixa, porque valores que extrapolem podem ser teis e intencionais. A funo constrain() pode ser utilizada tantes antes como depois desta funo se limites para as faixas forem necessrios. Verifique que os limites inferiores de uma faixa podem ser maiores ou menores que os limites superiores. Desse modo a funo map() pode ser utilizada para colocar em ordem reversa uma faixa de valores, como por exemplo: y = map(x, 1, 50, 50, 1); A funo tambm pode utilizar nmeros negativos como neste exemplo: y = map(x, 1, 50, 50, -100); A funo map() utiliza nmeros inteiros e no gera fraes. Quando o resultado for fracionrio ele ser truncado e no arredondado. Parmetros value: o nmero a ser mapeado fromLow: limite inferior da faixa atual de value fromHigh: limite superior da faixa atual de value toLow: limite inferior da faixa para a qual se quer mapear toHigh: limite superior da faixa para a qual se quer mapear Retorno O valor mapeado. Exemplo /* Mapear uma entrada analgica de 10 bits para uma sada analgica de 8 bits (0 a 255) */ void setup() {} void loop() { int val = analogRead(0); val = map(val, 0, 1023, 0, 255); analogWrite(9, val); } Apndice Para aqueles com inclinao matemtica aqui est a funo completa: long map(long x, long in_min, long in_max, long out_min, long out_max) { return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; }

Pgina | 57

pow(base, expoente)
Descrio Calcula o valor de um nmero elevado a uma potncia. Pow() pode ser utilizado com uma potncia fracionria. til para gerar mapeamentos exponenciais de valores ou curvas. Parmetros base: o nmero(float) expoente: a potncia qual a base elevada (float) Retorno Oresultado da exponeciao (double) Exemplo Veja a funo fscale na bibliteca de cdigo.

sq(x)
Descrio Calcula o quadrado de um nmero. O nmero multiplicado por ele mesmo. Parmetros x: o nmero, qualquer tipo de dado Retorno o quadrado do nmero

sqrt(x)
Descrio Calcula a raz quadrada de um nmero. Parmetros x: o nmero, qualquer tipo de dado Retorno double, a raz quadrada do nmero.

Pgina | 58

sin(rad)
Descrio Calcula o seno de um ngulo (em redianos). O resultado ser entre -1 e 1. Parmetros rad: o ngulo em radianos (float) Retorno o seno do ngulo (double) Nota Serial.print() e Serial.println() atualmente no suportam floats.

cos(rad)
Descrio Calcula o cosseno de um ngulo (em redianos). O resultado ser entre -1 e 1. Parmetros rad: o ngulo em radianos (float) Retorno o cosseno do ngulo (double) Nota Serial.print() e Serial.println() atualmente no suportam floats.

tan(rad)
Descrio Calcula a tangente de um ngulo (em redianos). Parmetros rad: o ngulo em radianos (float) Retorno a tangente do ngulo (double) Nota Serial.print() e Serial.println() atualmente no suportam floats.

Pgina | 59

randomSeed(seed)
Descrio randomSeed() inicializa um gerador de nmeros pseudo-aleatrios, fazendo com que a seqncia gerada comece por um ponto arbitrrio de uma seqncia aleatria. Esta seqncia , embora muito longa e aleatria, sempre a mesma. Se for importante para uma seqncia de valores gerados pela funo random() ser diferente, a cada execuo de um programa, use randomSeed() para inicializar o gerador de nmeros aleatrios a partir de um valor tambm aleatrio, como um analogRead() de um pino que no esteja conectado. De modo semelhante, pode ocasionalmente ser til usar seqncias pseudo-aleatrias que se repetem exatamente a cada execuo de um programa. Isto pode ser obtido atravz da funo randomSeed() de um nmero fixado, antes de se iniciar a seqncia aleatria. Parmetros long, int - um nmero para gerar o incio da seqncia. Retorno nenhum Exemplo long randNumber; void setup(){ Serial.begin(9600); randomSeed(analogRead(0)); } void loop(){ randNumber = random(300); Serial.println(randNumber); delay(50); }

Pgina | 60

random()
Descrio A funo random gera nmeros pseudo-aleatrios. Sintaxe long random(max) long random(min, max) Parmetros min - limite inferior do valor aleatrio, inclusivo (opcional) max - limite superior do valor aleatrio, exclusivo Retorno long - um nmero aleatrio entre min e (max-1) Note: Se for importante para uma seqncia de valores gerados pela funo random() ser diferente, a cada execuo de um programa, use randomSeed() para inicializar o gerador de nmeros aleatrios a partir de um valor tambm aleatrio, como um analogRead() de um pino que no esteja conectado. De modo semelhante, pode ocasionalmente ser til usar seqncias pseudo-aleatrias que se repetem exatamente a cada execuo de um programa. Isto pode ser obtido atravz da funo randomSeed() de um nmero fixado, antes de se iniciar a seqncia aleatria. Exemplo long randNumber; void setup(){ Serial.begin(9600); // se o pino de entrada analgica 0 no estiver conectado, rudo analgico // aleatrio far com que a funo randomSeed() gere // diferente nmeros de incio cada vez que o programa for executado. // randomSeed() ir embralhar a funo random. randomSeed(analogRead(0)); } void loop() { // imprime um nmero aleatrio entre 0 e 299 randNumber = random(300); Serial.println(randNumber); // imprime um nmero aleatrio entre 10 e 19 randNumber = random(10, 20); Serial.println(randNumber); delay(50); }

Pgina | 61

Serial.begin(int velocidade)
Descrio Ajusta o taxa de transferncia em bits por segundo (baud) para transmisso de dados pelo padro serial. Para comunicao com um computador use uma destas taxas: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 57600, 115200. Voc pode, entretanto, especificar outras velocidades por exemplo para comunicao atravs dos pinos 0 e 1 com um componente que requer uma taxa especfica. Parameters int velocidade, em bits por segundo (baud) Retorno nenhum Exemplo: void setup() { Serial.begin(9600); // abre a porta serial e ajusta a taxa de transferncia de dados para 9600 bps } void loop() {} Exemplo para o Arduino Mega: // Arduino Mega usando as quatro portas seriais simultaneamente // (Serial, Serial1, Serial2, Serial3), // com diferentes taxas de transferncia: void setup(){ Serial.begin(9600); Serial1.begin(38400); Serial2.begin(19200); Serial3.begin(4800); Serial.println("Hello Computer"); Serial1.println("Hello Serial 1"); Serial2.println("Hello Serial 2"); Serial3.println("Hello Serial 3"); } void loop() {}

Pgina | 62

int Serial.available()
Descrio Obtem o nmero de bytes (caracteres) disponveis para leitura atravs da porta serial. Parmetros Nenhum Retorno O nmero de bytes disponveis para leitura no buffer serial. O buffer serial pode armazenar at 128 bytes. Exemplo int incomingByte = 0; void setup() { Serial.begin(9600); // abre a porta serial e ajusta a taxa de transferncia para 9600 bps } void loop() { // envia dados apenas quando dados forem tambm recebidos: if (Serial.available() > 0) { // l o byte que est entrando: incomingByte = Serial.read(); // diga o que voc recebeu: Serial.print("Eu recebi : "); Serial.println(incomingByte, DEC); } } Exemplo para o Arduino Mega: void setup() { Serial.begin(9600); Serial1.begin(9600); } void loop() { // l na porta 0 e envia para a porta 1: if (Serial.available()) { int inByte = Serial.read(); Serial1.print(inByte, BYTE); } // l na porta 1 e envia para a porta 0: if (Serial1.available()) { int inByte = Serial1.read(); Serial.print(inByte, BYTE); } } // para dados seriais que esto entrando

Pgina | 63

int Serial.read()
Descrio L dados que estejam entrando pela porta serial. Parmetros Nenhum Retorno o primeiro byte disponvel na entrada da porta serial (ou -1 se no hover dados disponveis) int Exemplo int incomingByte = 0; void setup() { Serial.begin(9600); // abre a porta serial e ajusta a velocidade para 9600 bps } void loop() { // envia dados apenas quando recebe dados: if (Serial.available() > 0) { // l o primeiro byte disponvel: incomingByte = Serial.read(); // imprime na tela o byte recebido: Serial.print("Eu recebi: "); Serial.println(incomingByte, DEC); } } // para entrada serial

Pgina | 64

Serial.flush()
Descrio Esvasia o buffer de entrada da porta serial. Isto , qualquer chamada Serial.read() ou Serial.avaiable somente retornaro dados recebidos aps a ltima chamada Serial.flush(). Parmetros nenhum Returns nenhum

Serial.print(data)
Serial.print(data) Descrio Envia dados pela porta serial. Parmetro data: todos os tipos inteiros incluindo caracteres Sintaxe Este comando pode assumir diversas formas: Serial.print(b) sem nenhum formato especificado, imprime b como um nmero decimal em uma string ASCII. Por exemplo: int b = 79; Serial.print(b); imprime a string ASCII "79". Serial.print(b, DEC) imprime b como um nmero decimal em uma string ASCII. Por exemplo: int b = 79; Serial.print(b, DEC); imprime a string ASCII "79". Serial.print(b, HEX) imprime b como um nmero hexadecimal em uma string ASCII. Por exemplo: int b = 79; Serial.print(b, HEX); imprime a string string "4F". Serial.print(b, OCT) imprime b como um nmero octal em uma string ASCII. Por exemplo: int b = 79; Serial.print(b, OCT); imprime a string "117". Serial.print(b, BIN) imprime b como um nmero binrio em uma string ASCII. Por exemplo: int b = 79; Serial.print(b, BIN); imprime a string "1001111". Serial.print(b, BYTE) imprime b como um byte nico. Por exemplo: int b = 79; Serial.print(b, BYTE); imprime a string "O" que o caractr ASCII representado pelo valor 79. Para mais informaes veja a Tabela ASCII.

Pgina | 65

Serial.print(str) se str for uma string ou um array de chars imprime uma string ASCII. Por exemplo: Serial.print("Hello World!"); imprime a string "Hello World!". Parmetros b: o byte a imprimir, ou str: a string a imprimir Retorno Nenum Exemplo: /* Usa um bloco FOR para dados e imprime um nmero em vrios formatos. */ int x = 0; // varivel

void setup() { Serial.begin(9600); } void loop() { // imprime etiquetas Serial.print("SEM FORMATO"); Serial.print("\t"); Serial.print("DEC"); Serial.print("\t"); Serial.print("HEX"); Serial.print("\t"); Serial.print("OCT"); Serial.print("\t"); Serial.print("BIN"); Serial.print("\t"); Serial.println("BYTE"); for(x=0; x< 64; x++){ // apenas parte da tabela ASCII // imprime uma etiqueta // imprime um tab // abre a porta serial e ajusta a velocidade para 9600 bps

// imprime em vrios formatos Serial.print(x); Serial.print("\t"); // imprime um ASCII decimal - o mesmo que "DEC" // imprime um tab

Serial.print(x, DEC); // imprime um ASCII decimal Serial.print("\t"); // imprime um tab

Serial.print(x, HEX); // imprime um ASCII hexadecimal Serial.print("\t"); // imprime um tab

Pgina | 66

Serial.print(x, OCT); // imprime um ASCII octal Serial.print("\t"); // imprime um tab

Serial.print(x, BIN); // imprime um ASCII binario Serial.print("\t"); // imprime um tab // imprime como um byte nico e adciona um "cariage return"

Serial.println(x, BYTE); // delay(200); } Serial.println(""); }

com o "println" // espera 200 millisegundos // imprime outro carriage return

Dicas de programao e problemas conhecidos Serial.print() no funciona com floats, portanto voc precisa fazer uma converso para um tipo inteiro, perdendo a informao dos valores fracionrios. Em algumas situaes til multiplicar um float por uma potncia de 10 para preservar (ao menos em parte) a informao fracionria. Seja cuidadoso ao fazer clculos desntro dos parntesis e.g. Serial.print(x-2, DEC); Os tipos de dados unsigned char, e byte iro gerar resultados incorretos e atuar como se fossem do tipo de dado assinalado. A funo Serial.print envia os dados para um buffer. Ele esperar que um caractere seja enviado antes de seguir para o prximo. Entretanto a funo envia o retorno antes de enviar o ltimo caractere

Pgina | 67

Serial.println()
D e s cr i o Imprime os dados para a porta serial como legvel texto ASCII seguido por um caractere retorno de carro (ASCII 13, ou '\ r') e um caractere nova linha (ASCII 10, ou '\ n'). Este comando tem as mesmas formas como Serial.print (). Si n t a xe Serial.println (val) Serial.println (val, formato) Pa r me t r o s val: o valor para impresso - qualquer tipo de dados formato: especifica o nmero base (para tipos de dados integrais) ou o nmero de casas decimais (para tipos de ponto flutuante) R e t o rn a Nenhum E x a m pl e : /* Analog input

reads an analog input on analog in 0, prints the value out.

created 24 March 2006 by Tom Igoe */

int analogValue = 0;

// variable to hold the analog value

void setup() { // open the serial port at 9600 bps: Serial.begin(9600); }

void loop() { // read the analog input on pin 0: analogValue = analogRead(0);

// print it out in many formats: 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

Pgina | 68

Serial.println(analogValue, BIN); // print as an ASCII-encoded binary Serial.println(analogValue, BYTE); // print as a raw byte value

// delay 10 milliseconds before the next reading: delay(10); }

break
break usado para sair de um bloco do, for, ou while, se sobrepondo condio normal de verificao. Tambm usado para sair de uma sentena switch. Examplo for (x = 0; x < 255; x ++) { digitalWrite(PWMpin, x); sens = analogRead(sensorPin); if (sens > threshold){ x = 0; break; } delay(50); } // checar a deteco por um sensor

Pgina | 69

Apostila feita por Eduardo Almeida (nareba). A fonte dessa apostila foi tirada toda do site: http://multilogica-shop.com/Referencia que foi escrita por Andr.

Pgina | 70