You are on page 1of 70

Programação Arduino

Página | 1

Sumário:
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 += (adição composta)..................................28 -= (subtração composta)...............................28 *= (multiplicação composta)..........................28 /= (divisão composta)...................................28

Elementos de sintaxe y y y y y y
; (ponto e vírgula)...................................13 {} (chaves).............................................13 // (linha de comentário)...........................15 /* */ (bloco de comentário)......................15 #define..................................................16 #include.................................................17

Operadores aritméticos y y y y y y
= (igualdade).........................................18 + (adição)..............................................18 - (subtração)..........................................18 * (multiplicação).....................................18 / (divisão)..............................................18 % (resto da divisão)...............................19

Operadores de comparação 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 ! (não)....................................................21

Página | 2

Variáveis
Variáveis são expressões que você pode usar em programas para armazenar valores como a leitura de um sensor em um pino analógico.

Constantes
Constantes são valores particulares com significados específicos.

y y y y

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

Tipos de dados
Variáveis podem ser de vários 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

Conversão y y y y y
char()....................................................41 byte()....................................................41 int().......................................................41 long()....................................................41 float()....................................................42

Referência y
Tabela ASCII..........................................42

Página | 3

.........62 int Serial................................ bitOrder....................55 abs (x)....59 tan (rad).......................................... value)..43 digitalWrite (pin.. a...............58 sqrt (x).................available () int Serial...........61 Página | 4 ....46 analogWrite (pin..........59 Números aleatórios y y y randomSeed (seed) long random (min...................Funções Entrada e saída digital y y y pinMode (pin..... fromLow.... y).. value) ...................44 int digitalRead (pin).....................................................50 ............................................ toLow....................47 Entrada e saída avançada y y shiftOut (dataPin... clockPin............................................................................61 long random (max).... exponent)....... max) ......................50 unsigned long micros() delay(ms) delayMicroseconds( s) 2 Matemática . fromHigh...........................println (data).............................................45 Entrada e saída analógica Comunicação serial Usado para comunicação entre a placa Arduino e um computador ou outros dispositivos.56 constrain (x....58 pow (base.....51 ......................... toHigh) sq (x) 57 . Assim...... y y int analogRead (pin)..........56 map (value........ mode).....60 ..58 Trigonometria y y y sin (rad).. Esta comunicação ocorre através dos conectores serial ou USB da placa Arduino e nos pinos digitais 0 (RX) e 1 (TX)................65 Serial............................print (data)........begin (speed)............. y) ..48 unsigned long pulseIn (pin.... se você utilizar estas funções não poderá utilizar os pinos 0 e 1 para entrada e saída digital.......................read () Serial...................49 y y y y unsigned long millis()......... value) Tempo ................................... value) PWM.. b)..5 y y y y y y Serial.......59 cos (rad)........65 Serial.flush () 63 64 ........................54 max (x........68 y y y y y y y y min (x..............

etc. Exemplo int buttonPin = 3. void setup() { Serial.. a função loop() faz exatamente o que seu nome sugere. Esta função será executada apenas uma vez após a placa Arduino ser ligada ou ressetada. entra em looping (executa sempre o mesmo bloco de código). delay(1000). declarar o uso de livrarias. pinMode(buttonPin.setup() A função setup() é chamada quando um programa pomeça a rodar. Exemplo int buttonPin = 3.. // setup inicializa o serial e o pino do button (botão) void setup() { beginSerial(9600). else serialWrite('L'). } void loop() { // . Use esta função para controlar ativamente a placa Arduino. pinMode(buttonPin. } loop() Após criar uma fução setup() que declara os valores iniciais. } // loop checa o botão a cada vez. os modos dos pinos. permitindo ao seu programa fazer mudanças e responder. } Página | 5 . // e envia o serial se ele for pressionado void loop() { if (digitalRead(buttonPin) == HIGH) serialWrite('H'). Use esta função para inicializar as sua variáveis. INPUT). INPUT).begin(9600).

. mas a anterior sempre será veraddeira. desede que números diferentes de zero são sempre equiparados à verdadeiro. if (x > 120) {digitalWrite(LEDpin. que será sempre verdadeiro (TRUE).g. caso contrário o programa salta este bloco de código. Consequentemente. Isto ocorre por que a linguagem C (na qual o Arduino é baseado) atribui um valor à sentença (x=10) do seguinte modo: 10 é colocado na variável x (lembre o sinal de igual simples é um operador de designação). verifica se x é igual a 10 ou não. Página | 6 . if (x == 10) ). if (x = 10) será sempre verdadeiro. o programa realiza uma ação específica. HIGH). As chaves podem ser omitidas após uma sentença if se só houver uma única linha de código (definida pelo ponto e vírgula) que será executado de modo condicional: if (x > 120) digitalWrite(LEDpin. HIGH).else.g. Se for. A última senteça só é verdadeira se x for igual a 10. HIGH). Então o condicional 'if' atribui um valor a 10. que não é o que pretendemos quando usamos um 'if'. > (operadores de comparação) if. Colocado de outra maneira se a sentença que está dentro dos parêntesis é verdadeira o código que está dentro das chaves roda.} // todos são corretos A sentença que está sendo verificada necessita o uso de pelo menos um dos operadores: Operadores de comparação: x == y (x é igual a y) x != y (x é não 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 precaução com o uso acidental de apenas um sinal de igual (e. if (x > 120) digitalWrite(LEDpin. !=. Ao contrário o sinal de igal duplo (e. if (x = 10) ). <. verifica quando uma condição é satisfeita. que é usado juntamente com um operador de comparação. if também pode ser usado como parte de uma estrutura de controle ramificada através da construção if. O formato para uma verificação if é: if (algumaVariavel > 50) { // faça alguma coisa } O programa checa se algumaVariavel (colocar acentos em nomes de variáveis não é uma boa idéia) é maior que 50.if (condicional) e ==. Adcionalmente o valor 10 será guardado na variável x que também não é o que pretendemos. que é um operador de comparação. como por exemplo um input acima de um determinado valor. O sinal de igual simples é um operador de designação e coloca o valor 10 na variável x. então x agora contém 10.

mutuamente exclusivos. tornando possível que múltiplos testes sejam agrupados. podem ser realizados ao mesmo tempo.if / else if/else permite um controle maior sobre o fluxo de código do que a sentença if básica. if (pinFiveInput < 500) { // faça a coisa A } else if (pinFiveInput >= 1000) { // faça a coisa B } else { // faça a coisa C } Outro modo de fazer testes de ramificações mutuamente exclusivas é através da sentença switch case. Note que um bloco else if pode ser usado com ou sem um bloco else final. O código seria assim: if (pinFiveInput < 500) { // ação A } else { // ação B } else pode preceder outro teste if . Quando um teste com valor verdadeiro é encontrado o seu bloco de código associado é execuatod e então o programa salta para a sequencia após todo o bloco if/else. e assim mltiplos testes. Página | 7 . Se a nenhum teste é atribuido o valor verdadeiro o bloco que estiver no else sozinho é executado. uma entrada analógica poderia ser verificada e uma ação específica seria tomada se o valor de input fosse menor que 500 e outra ação seria tomada se o input fosse 500 ou mais. Cada teste precede o próximo até que um teste com vavlor verdadeiro é encontrado. se houver algum. Um número ilimitado destes ramos else if é permitido. Por exemplo.

A sentença for é util para quanquer operação repetitiva. incluindo BASIC. i). Qualquer destes elementos também podem ser substituidos por qualquer sentença válida em C com varáveis não correlatas. e então a condição é testada novamente. i++){ analogWrite(PWMpin. embora os ". Quando a condição se torna falsa o circuíto termina. e é frequentemente usada com arrays para operar em conjuntos de dados ou de pinos. Há três partes no cabeçalho do for: for (inicialização. } } Dica de programação Na linguagem C o circuito for é muito mais flexível que os circuitos for encontrados a algumas outras linguagens de programação. Cada vez que o circuíto é executado a condição é verificada. // um LED em série com um resisotr de 1k void setup() { // nenhum setup é necessário } void loop() { for (int i=0. condição. Estes tipos não usuais de sentenças for as vezes podem ser a solucão para alguns problemas raros de programação. se for verdadeira o bloco de código e o incremento são executados. no pino 10 Página | 8 . Exemplo // Aumentar o brilho de um LED usando um pino PWM int PWMpin = 10. i <= 255. incremento) { //sentença(s). Um contador com incremento normalmente é usado para controlar e finalizar o loop. Qualquer dos elementos do cabeçalho pode ser omitido." sejam necessários. delay(10).sentença for Descrição A sentença for é utilizada para repetir um bloco de código delimitado por chaves. } A inicialização ocorre primeiro e apenas uma vez.

sentença switch / case Do mesmo modo que as sentenças if. Se uma sentença break é encontrada o código sai da estrutura do mesmo modo que em uma construção if/else if.a variável para a qual você busca valores idênticos default . Exemplo switch (var) { case 1: //faça alguma coisa quando var == 1 break. o que pode não ser o que você deseja.se nenhuma outra condição for satisfeita o código que está no default é executado break . então o programa vai continuar a checar por mais valores idênticos entre os "casos" restantes.sem o break a sentença switch vai continuar checando as outras sentenças case para quanquer outro possível valor idêntico. Break indica ao switch para parar de procurar por outros valores idênticos e sai da sentença switch. Switch/case permite ao programador construir uma lista de "casos" dentro de um bloco delimitado por chaves. O programa checa cada caso com a vaiável de teste e executa o código se encontrar um valor idêntico. Switch / case é um pouco mais flexível que uma estrutura if/else de modo que o programador pode determinar se a estrutura switch deve continuar checando por valores idênticos na lista dos "caosos" após encontrar um valor idêntico. Parâmetros y y y var . as switch / case controlam o fluxo dos programas. default: // se nenhum valor for idêntico. Se a sentença break não é encontrada após a execução do bloco de código selecionado por um dos "casos". faça o default // default é opcional } Página | 9 . Se algum for encontrado será executado do mesmo modo. // break is optional case 2: //faça alguma coisa quando == 2 break.

// espera para que os sensores se estabilizem x = readSensors(). Enquanto no while. Exemplo do { delay(50). } do .while Descrição while fará com que o bloco de código entre chaves se repita continua e indefinidamente até que a expressão ente parentesis() se torne falsa. Syntax while(expressão){ // código } Parâmetros expressão . no do ele sempre será executado pelo menos uma vez.uma sentença boolena em C que possa ser verificada como verdadeira ou falsa Exemplo var = 0. Página | 10 . o bloco de código não será executado. do { // bloco de código } while (condição). se a condição for falsa. // verifica o sensor } while (x < 100). Algo tem que provocar uma mudança no valor da variável que está sendo verificada ou o código vai sempre ficar dando voltas dentro do while. while(var < 200){ // algum código que se repete 200 vezes var++. com a exceção de que a condição é testada no final do bloco de código. Isto poderia ser o incremento de uma variável ou uma condição externa como o teste de um sensor.while O do funciona da mesma maneira que o while loop.

delay(50). x). } // criar saltos de execução return Finaliza uma função e retorna um valor. se necessário. for. Sintaxe: return. uma brilhante idéia de programação return. x < 255. // restante do bloco de código não funcional // este código nunca será executado } Página | 11 . // ambas formas são válidas Parâmetros valor: alguma variável ou constante Exemplos: Uma função para comparar o valor de um sensor com um limite int checkSensor(){ if (analogRead(0) > 400) { return 1. } digitalWrite(PWMpin. x ++) { if (x > 40 && x < 120){ continue. Exemplo for (x = 0.continue continue é usado para saltar porções de código em blocos do. return valor. else{ return 0. ou while. Ele força com que o código avance até o teste da condição saltando todo o demais. } } A palavra-chave return é útil para testar uma seção de código sem ter que transformar em "comentário" um grande e possivelmente defeituoso bloco de código. void loop(){ // aqui.

mas usado com cautela pode simplificar alguns programas. há casos em que o goto pode ser útil e simplificar o código. No entanto. // envia o fluxo do programa para etiqueta Dica O uso do goto é desencorajado em programação C e inclusive alguns autores afirmam que o goto nunca é realmente necessário.. g > -1. r < 255. b++){ if (analogRead(0) > 250){ goto bailout.} // more statements . } } } bailout: Página | 12 . Exemplo for(byte r = 0.. g--){ for(byte b = 0. r++){ for(byte g = 255. Uma destas situações é provocar uma saída de um grupo de loops aglutinados ou de blocos lógicos if com uma determinada condição. A razão pela qual muitos programadores desaprovam seu uso é que com o uso indiscriminado é fácil de se criar um programa com um fluxo indefinido e muito difícil de ser depurado. b < 255.goto Transfere o fluxo do programa para um outro ponto etiquetado Sintaxe label: goto etiqueta.

A IDE (integrated development environment ou ambiente de desenvolvimento integrado) do Arduino inclui uma característica prática para checar o equilibrio das chaves. Inserte então alguns "ENTER" entre as chaves e comece a digitar o código. O texto sobre o erro pode ser óbvio e se referir a um ponto e vírgula faltando. Dica Esquecer de finalizar uma linha com ponto e vírgula causa um erro de compilação. ou não. Agindo assim suas chaves nunca ficarão desequilibradas. e isto pode algumas vezes ser confuso para iniciantes. Elas são usadas em muitas construções diferentes. Uma chave abrindo "{" deve sempre ser seguida por uma fechando "}". Página | 13 . Frequentemente nos referimos a esta condição como equilibrio entre as chaves. precedendo a linha indicada pelo compilador. No presente momento esta característica é um pouco defeituosa e a IDE frequentemente encontrará (incorretamente) uma chave em um bloco de texto que tenha sido comentado. Chaves desequilibradas causam erros de comilação bastante enigmáticos e que podem ser difíceis de rastrear em um programa longo. Exemplo int a = 13. Programadores principiantes e programadores vindos das linguagens C e do BASIC frequentemente consideram o uso das chaves confuso ou desalentador. Por causa de seus usos variados. as chaves são também incrivelmente importantes para a sintaxe de um programa e mover uma chave uma ou duas linhas pode alterar completamente o seu significado. a sentença ENDIF em uma condicional e a sentença NEXT em um FOR.. Afinal as mesmas chaves substituem a sentença RETURN em uma subrotina(função). descritas abaixo. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que sua companheira lógica seja destacada. ponto e vírgula Usada para terminar uma sentença. Por que o uso das chaves é tão variado. Se ocorrer um erro de compilação impenetrável ou aparenetemente ilógico uma das primeiras coisas a checar é um ponto e vírgula faltando na vizinhança. {} Chaves Chaves são uma parte essencial da linguagem de programação C. é uma boa prática de programação digitar o fecha-chaves "}" logo após digitar o abre-chaves "{" quando estiver fazendo uma construção que as requer.

Os principais usos das chaves Funções void myfunction(datatype argument){ sentença(s) } Loops while (expressão booleana) { sentença(s) } do { sentença(s) } while (expressão booleana). expressão de incremento) { sentença(s) } Sentenças condicionais if (expressão booleana) { sentença(s) } else if (expressão booleana) { sentença(s) } else { sentença(s) } Página | 14 . for (inicialização. condição de término.

} // não esqueça de fechar o bloco de comentário.usado para "comentar" blocos inteiros de código if (gwb == 0){ // não há problema em uma linha simples dentro de um bloco de comentário x = 3. // Esta é uma linha simples de comentário.Comentários Comentários são linhas no programa que são usados para informar a você mesmo ou outras pessoas sobre o modo como o progama trabalha. O único propósito dos comentários são ajudar a entender (ou relembrar) como o programa funciona. Exemplo x = 5. eles têm que ser equilibrados */ Dica Quando estiver experimentando com o código "comentar" partes do programa é um modo conveniente de remover linhas que podem conter problemas. ou quando um programa apresenta erros de compilação cujas explicações são obscuras ou inúteis. Elas são ignoradas pelo compilador e não são exportadas para o processador e portanto não ocupam a memória do chip ATmega. /* mas outro bloco de comentário é inválido */ Página | 15 . Há dois modos diferentes de marcar uma linha como um comentário. Este procedimento mantém as linhas no código mas as trasnforma em comentários de modo que o compilador as ignora. Isto pode ser especialmente útil quando tentamos localizar um problema. Qualquer coisa depois das barras é um comentário // até o fim da linha /* este é um bloco de comentário .

Em general. um nome de constante que tenha sido defindo por um #define é incluido em alguma outra constante ou nome de variável.#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. Neste caso o texto deve ser substituido pelo valor (ou texto) do #define. por exemplo. O compilador substitui referêancias a estas constantes pelo valor definido no momento da compilação. Exemplo #define ledPin 3 // O compilador vai substituir quanquer menção a ledPin pelo valor 3 no momento da compilação. Isto pode causar alguns efeitos indesejáveis se. // isto é um erro Do mesmo modo o compilador gerará erros se após o #define houver um =. #define ledPin = 3 // isto também é um erro Página | 16 . A sintaxe do #define na linguagem Arduino é a mesma da linguagem C: Sintaxe #define nomeDeConstante valor Verifique que o # é necessário. #define ledPin 3. Constantes definidas no Arduino não ocupam espaço em memória no chip. Dica Não há ponto e vírgula após a declaração #define. Se você incluir um o compilador vai lançar erros críticos no final do programa. a palavra chave const é preferível para definir constatntes e deve ser usada ao invés de #deine.

analógico 0 em sensVal Dicas de programação A variável à esquerda necessita ser capaz de reter o valor que se quer armazenar. não leva ponto e vírgula no final.0. Ele tem um significado diferente daquele utilizado em álgebra.#include #include é usado para incluir outras bibliotecas no seu programa. 0.29762. // declera uma variavel do tipo inteiro com o nome de sensVal // armazena o valor da voltagem (digitalizado) no pino senVal = analogRead(0). 8456. 0. O operador de designação indica ao microcontrolador para calcular o valor da expressão à direita do sinal de igual e armazenar este valor na variável que está à esquerda. Verifique que #include. 702 .8968. 21140.29762.0. Exemplo Este exemplo inclui uma biblioteca que é utilizada para armazenar dados na memória flash ao invés de na ram.0. que calcula quando duas expressões são iguais ou não. e também à bibliotecas desenvolvidas especificamente para o Arduino. O sinal de igual simples na linguagem de programação C é chamdo operador de designação. Exemplo int sensVal. = operador de designação (sinal de igual simples) Armazena o valor do que está à direita do sinal de igual na variável que está à esquerda. no qual indica uma equação ou iguladade.0.0. Se ela não for grande o suficiente o valor armazenado pode ser incorreto.29810. 25764.4500}.0.0. A página principal de referência para as bibliotecas C AVR (AVR é a referência aos chips Atmel nos quais o Arduino está baseado) está aqui. Isto economiza espaço na ram para as necessidades de memória dinâmica e torna o uso de grandes tabelas mais prático. Isto permite ao programador acessar um grande número de bibliotecas padrão da linguagem C (grupos de funções pré-definidas). Não confunda o operador de designação [ = ] (sinal de igual simples) com o operador de comparação [ == ] (sinal de igual duplo). #include <avr/pgmspace.h> prog_uint16_t myConstants[] PROGMEM = {0. de modo similar ao #define. Página | 17 . 9128.

Adição, subtração, multiplicação e divisão
Descrição Estes operadores retornam a soma, diferença, profuto, ou quciente(respectivamente) de dois operandos. A operação é feita usando o tipo de dado dos operadores, assim, por exemplo 9/4 resulta em 2, desde que 9 e 4 são inteiros. Isto também significa que uma operação 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 cálculo. Se um dos operandos for do tipo float ou do tipo double, então a matemática de ponto flutuante será usada para o cálculo. 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; Parâmetros: value1: qualquer variável ou constante value2: qualquer variável ou constante Dicas de programação

y y y y y

Saiba que constantes inteiras são consideradas int, portanto alguns cáculos com constantes podem extrapolar (e.g. 60 * 1000 resultará em um número negativo). Escolha tamanhos de variáveis que sejam grandes o suficiente para reter os maiores resultados possíveis dos cálculos. Conheça o ponto em que sua variável pode "dar a volta" e também o que ocorre no sentido contrárioe.g. (0 - 1) ou (0 - 32768). Para matemática que necessita de frações use variáveis do tipo float, mas tenha em conta seus pontos negativos: tamanho maior e menor velocidade de computação. Use o operador de modelagem para converter diretamente um tipo de variável em outro e.g. (int)meuFloat.

Página | 18

% (resto da divisão)
Descrição Calcula o resto da divisão quando um inteiro é dividido por outro. É útil para manter uma variável dentro de um patamer específico (e.g. o tamanho de um array). Sintaxe resultado = dividendo % divisor Parâmetros dividendo: o número que será dividido divisor: o número a dividir por Retorna o restante Exemplo x = 7 % 5; // x agora comtém 2 x = 9 % 5; // x agora comtém 4 x = 5 % 5; // x agora comtém 0 x = 4 % 5; // x agora comtém 4 Código 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 divisão atualiza a variável } Dica O operador de resto da divisão não funciona com variáveis tipo float.

Página | 19

if (condicional) e ==, !=, <, > (operadores de comparação)
if, que é usado juntamente com um operador de comparação, verifica quando uma condição é satisfeita, como por exemplo um input acima de um determinado valor. O formato para uma verificação if é: if (algumaVariavel > 50) { // faça alguma coisa } O programa checa se algumaVariavel (colocar acentos em nomes de variáveis não é uma boa idéia) é maior que 50. Se for, o programa realiza uma ação específica. Colocado de outra maneira se a sentença que está dentro dos parêntesis é verdadeira o código que está dentro das chaves roda; caso contrário o programa salta este bloco de código. As chaves podem ser omitidas após uma sentença if se só houver uma única linha de código (definida pelo ponto e vírgula) 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 são corretos A sentença que está sendo verificada necessita o uso de pelo menos um dos operadores: Operadores de comparação: x == y (x é igual a y) x != y (x é não 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 precaução com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual simples é um operador de designação e coloca o valor 10 na variável x. Ao contrário o sinal de igal duplo (e.g. if (x == 10) ), que é um operador de comparação, verifica se x é igual a 10 ou não. A última senteça 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 à sentença (x=10) do seguinte modo: 10 é colocado na variável x (lembre o sinal de igual simples é um operador de designação), então x agora contém 10. Então o condicional 'if' atribui um valor a 10, que será sempre verdadeiro (TRUE), desede que números diferentes de zero são sempre equiparados à verdadeiro. Consequentemente, if (x = 10) será sempre verdadeiro, que não é o que pretendemos quando usamos um 'if'. Adcionalmente o valor 10 será guardado na variável x que também não é o que pretendemos. if também pode ser usado como parte de uma estrutura de controle ramificada através da construção if..else

Página | 20

. if (x > 0 || y > 0) { // . mas mesmo assim tenha certeza de estar usando o que você deseja.g. ou seja se a primeira "ou" a segunda condição for verdadeira e. ! (negação) Verdadeiro apenas se o operando for falso e. || ("OU" lógico) Verdadeiro se algum dos operandos for verdadeiro. if (!x) { // .. } é verdadeiro apenas se os dois interruptores estiverem fechados..Operadores Booleanos Estes operadores podem ser usados dentro da condição em uma sentença if..e. } é verdadeiro apenas se x ou y forem maiores que 0. ou seja a primeira condição "e" a segunda forem verdadeiras.. && ("E" lógico) Verdadeiro apenas se os dois operandos forem verdadeiros. se x for igual a 0). Exemplos if (a >= 10 && a <= 20){} // verdadeiro se a estiver entre 10 e 20 Página | 21 . } é verdadeiro apenas se x for falso (i. if (digitalRead(2) == 1 && digitalRead(3) == 1) { // ler dois interruptores // .g. Eles são animais completamente diferentes.. Cuidado Certifique-se de não confundir o operador booleano "E" representado por "&&" e o operador lógico de bits "E" representado apenas por "&". Do mesmo modo não confunda o booleano "OU" representado por "||" e o operador lógico de bits "|". e.g. O operador lógico de bits "NÃO" representado por um "~" não se parece com o operador booleano "!".

// em binario: 0000000001011100 // em binario: 0000000001100101 0000000001000100. freqüentemente chamado de máscara. Operador de bits OR (|) O operador de bits OR (ou) em C++ é o símbolo de barra vertical.5. |. Um efeito colateral é que mudamos o estado dos pinos 0 e 1 que são usados pelo Arduino na comunicação serial. int b = 101. Um dos usos mais comuns do operador de bits AND é selecionar alguns bits de um valor inteiro.resultado de retorno // in binario: 0000000001011100 // in binario: 0000000001100101 0000000001111101. Como o operador & ele realiza cálculos com cada bit de duas expressões seguindo a seguinte regra: o resultado da opração é 1 se um dos bits de entrada for 1. Página | 22 . Eles ajudama resolver uma grande quantidade de problemas de programação. Outro modo de expressar esta regra é: 0 0 1 1 0 1 0 1 ---------0 0 0 1 (operando1 & operando2) . // resultado: Cada um dos 16 bits em a AND b são processados usando este operador. que é 68 na notação decimal.3. Deste modo se escrevemos PORTD = B00110001. então este pino está em HIGH. caso contrário é 0.4. o que fazemos é colocar os pinos 2. PORTD é uma constante pré-construída que se refere aos estados de saída dos pinos digitais 0. (os pinos ainda precisam ser defindos como pinos de saída pelo comando pinMode()). Muito do material abaixo é de um excelente tutorial sobre este tema que pode ser encontrado aqui. XOR (^) Operadores de bits Os operadores de bits realizam cálculos ao nível de bits das variáveis. Em um fragmento de código: int a = 92. ou seja. Em um fragmento de código: int a = 92.2.1.Operadores de bits AND (&). Escrevendo em um controle de porta todos os pinos de uma vez. operando1 operando2 int c = a & b. Em microcontroladores uma porta é um número de 8 bits que representa algo sobre a condição dos pinos. int b = 101. interferimos nesta comunicação. operando1 operando2 int c = a | b. portanto usando & entre duas expressões int faz com que ocorram 16 operações AND simultâneas. ou 125 em decimal. Em outras palavras: 0 0 1 1 0 1 0 1 ---------0 1 1 1 (operando1 | operando2) . caso contrário é 0.resultado de retorno Em Arduino o tipo int (inteiro) é um valor de 16 bits. Ele realiza uma operação entre cada bit de cada uma destas expresões de acordo com a seguinte regra: se os dois bits de entrada forem 1 o resultado da operação também é 1.6. // 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. e todos os 16 bits resultantes são armazenados em c resultado o valor 0000000001000100.3 e 7 em HIGH.7. Operador de bits AND (&) O operador de bits AND (e) em C++ é um simples & usado entre duas outras expressões inteiras. OR (|). Se há um 1 em algum dos bits. Veja o exemplo abaixo para um exemplo. ou 68 em decimal.

caso contrário retorna 0: 0 0 1 1 0 1 0 1 ---------0 1 1 0 int x = 12. BIN). Combinar o valor modificado de PORTD com o novo valor dos pinos que queremos controlar (com o operador OR). void setup(){ DDRD = DDRD | B11111100. } Página | 23 . } } Operador de bits XOR (^) Há um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou exclusivo) também conhecido por XOR (em inglês se pronuncia "equis-or"). // binario: 0110. deixa os pinos 0 e 1 intocados (xx & 11 == xx) j = (i << 2). // Piscar_Pino_5 // demonstração para o Exclusive OR void setup(){ DDRD = DDRD | B00100000.Nosso algoritmo para este programa deve: y y Ler o PORTD e limpar somente os bits que queremos controlar (com o operador AND). // debug para verificar a máscara delay(100). int j. Este operador é escrito com o símbolo do acento circunflexo ^. se há um zero o bit é mantido como está. Serial. // marca o pino digital 5 como saida.begin(9600). e1 PORTD = PORTD | j.println(PORTD. Abaixo há um programa para piscar o pino digital 5. int y = 10. // limpa os bits de 2 . O resultado desta operação é 1 se os dois bits de entrada forem diferentes.7. } void loop(){ for (i=0. pinos dos LEDs Serial. OUTPUT) para os pinos 2 a 7 Serial. i++){ PORTD = PORTD & B00000011. (operando1 ^ operando2) .resultado de retorno // binario: 1100 // binario: 1010 Um simpples código de exemplo: operando1 operando2 // combina a informação da porta com a nova informação para os // desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0 // variável do contador int z = x ^ y. int i. or decimal 6 O operador XOR é freqüentemente utilizado para inverter alguns dos bits de uma expressão inteira. i<64. // 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.begin(9600). Na máscara deste operador se há um 1 o bit correspondente é invertido.

Este modo de encodar positivos e negativos é chamado de complemento para dois. // inverte o bit 5 (digital pino 5). Por exemplo: 0 1 operando1 ---------1 0 ~ operando1 int a = 103. } Operador de bits NOT (~) O operador de bits NOT (não) em C++ é o acento til do português ~. ~x é o mesmo que -x-1. Isto ocorre por que o bit mais elevado em uma variável int é chamdo de bi de sinal. mantem os demais intocados. // binario: 0000000001100111 // binario: 1111111110011000 = -104 Talvez você se surpreenda ao ver um número negativo como resultado desta operação. Mais informações na Wikipedia. é interessante notar que para qualquer inteiro x. Diferente dos operadores & e | este operador é aplicado sobre apenas 1 operando e retorna o valor inverso de cada bit. o bit de sinal em uma expressão inteira pode causar algumas surpresas indesejadas. Se este bit é 1 o número é negativo. As vezes. int b = ~a. De modo complementar. delay(100).void loop(){ PORTD = PORTD ^ B00100000. Página | 24 .

// binario: 0000000000000101 int b = a << 3. Neste caso o bit do sinal é copiado para os bits inferiores por razões históricas esotéricas: int x = -16. Neste caso você deve utilizar uma alteração do tipo de dados que possui uma regra diferente para inteiros não assinalados: int x = -16. long) numero_de_bits inteiro <= 32 Exemplo: int a = 5. um modo simples de pensar no operador para a esquerda é que ele multiplica o operando da direita por 2 elevado ao operador da esquerda. // divisão inteira de 1000 por 8. Por exemplo: int x = 1000.(byte. você pode usar o operador de desvio para a direita >> como um modo de dividir um número por potências de 2. // binario: 0100000000000000 . 1 << 8 == 256 1 << 9 == 512 1 << 10 == 1024 . int. Por exemplo para gerar potências de 2 as segintes expressões podem ser utilizadas: 1 << 0 == 1 << 1 == 1 << 2 == 1 << 3 == . o bit mais elevado é o bit de sinal que determina se x é negativo ou não. Sintaxe variavel << numero_de_bits variavel >> numero_de_bits Parâmetros variavel . Se x é do tipo int..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 >>. o comportamento depende do tipo de dados de x. Estes operadores fazem com que os bits no operando da esquerda sejam desviados o número especificado de bits no operando da direita.. int y = x >> 3. // binario: 0000000000000101 int b = a << 14. ou de volta ao 5 como no inicio Quando você desvia para a esquerda um valor x um y número de bits (x<<Y) os bits mais a esquerda em x são perdidos: int a = 5. ou 40 em decimal int c = b >> 3. // binario: 0000000000000101. // binario: 1111111111110000 int y = (unsigned int)x >> 3. resultado y=125. Quando você desvia para a direita um valor x um y número de bits (x>>y). 1 2 4 8 Página | 25 . Entretanto. // binario: 0001111111111110 Se você for cauteloso em evitar a extensão do sinal. você pode desejar desviar preenchendo o espaço com zeros..o primeiro 1 em 101 é descartado Se você tem certeza de que nenhum dos 1 em um valor vai ser deviado para fora do espaço . // binario: 1111111111111110 Este comportamento é chamado extensão do sinal e freqüentemente não é o comportamento desejado. // binario: 1111111111110000 int y = x >> 3. // binario: 0000000000101000..

operador de bits composto AND (&=) Descrição O operador de bits composto AND (&=) é freqüentemente utilizado entre uma variável e uma constante para forçar que alguns bits em particular da variável sejam marcados como LOW (como 0). Este conceito aparece em manuais de programação como "limpeza" ou "resetting" de bits. uma revisão do operador de bits AND (&) 0 0 1 1 0 1 0 1 ---------0 0 0 1 (operando1 & operando2) . Parâmetros: x: uma variável do tipo char. Posrtanto se myByte é uma variável do tipo byte myByte & B00000000 = 0.operadores de bits compostos AND (&=) e OR (|=) Os operadores de bits compostos realizam seus cálculos no nível de bit das variáveis. // equivalente a x = x & y. ou long Exemplo: Primeiro. Veja o operador de bits AND(&) e o operador de bits OR(|) para detalhes sobre seu funcionamento. int ou long y: uma constante do tipo char. Consequentemente para limpar (marcar como zero) alguns dos bits de uma variável deixando os demais como estão é 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 variável não modificada bits limpos Aqui está a mesma representação com os bits da variável subtituidos pelo símbolo 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 variável máscara variável máscara Página | 26 . Bits que passam pelo operador AND com um operando 1 se matém como estão. Sintaxe: x &= y. São freqüentemente utilizados para limpar ou marcar bits específicos. Portanto myByte & B11111111 = myByte.resultado de retorno operando1 operando2 Bits que passam pelo operador AND um operando 0 são limpados para 0. int.

myByte |= B00000011 == B10101011.variável não modificada bits limpos portato se: myByte = 10101010. ou long Exemplo: First. myByte | B00000000 = myByte.resultado de retorno Bits que passam pelo operador OR com um operando 0 são mantidos como estão. operador de bits composto OR (|=) Descrição O operador de bits composto OR (|=) é frequentemente utilizado entre uma variável e uma constatnte para forçar que alguns bits em particular sejam marcados como 1. // equivalente a x = x | y. myByte &= B1111100 == B10101000. a review of the Bitwise OR (|) operator 0 0 1 1 0 1 0 1 ---------0 1 1 1 (operando1 | operando2) . int ou long y: uma constante do tipo char. Parâmetros x: uma variável do tipo char. variável máscara variável máscara operando1 operando2 Página | 27 . Sintaxe: x |= y. Bytes que passam pelo operador OR com um operando 1 são marcados com 1: myByte & B11111111 = B11111111. int. portanto se myByte é uma variável tipo byte. Consequentemente para marcar os bits 0 e 1 de uma variável deixando o restante sem mudanças 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 variiável não modificada bits alterados Aqui a mesma representação com as variáveis substituidas pelo símbolo 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 variiável não modificada bits alterados So if: myByte = B10101010.

y. *= . // incrementa x em 1 e retorna o novo vaor de x x-. Exemplos x = 2. y = ++x.++ (incremento) / -. // equivalente à expressão x = x + y. // x agora contém 3. // decrementa x em 1 e retorna o novo valor de x Parâmetros x: uma variavel do tipo integer ou long (possivelmente não assinalada) Retornos O original ou recentemente incrementedo / decrementedo valor da variável. y ainda contém 3 += . // incrementa x em 1 e retorna o antigo valor de x ++x. Parâmetros x: qualquer tipo de variável y: qualquer tipo de variável ou constante Exemplos x = 2. /= Descrição Realiza uma operação matemática em uma variável com outra constante ou variável. x *= y. // equivalente à expressão x = x * y. x -= 3. // equivalente à expressão x = x / y. x /= y. x /= 2. x *= 10.(decremento) Descrição Incrementar ou decrementar uma variável (adcionar ou subtrair 1) Sintaxe x++. y contém 3 // x contém 2 de novo. // x agora contém 6 // x agora contém 3 // x agora contém 30 // x agora contém 15 Página | 28 . y = x--. // decrementa x em 1 e retorna o antigo valor de x --x . O operador += (e os outros) são apenas abreviações práticas da sintaxe expandida listada abaixo: Sintaxe x += y. // equivalente à expressão x = x .. -= . x += 4. x -= y.

false false é a mais simples das duas e é definida como 0 (zero). Definindo pinos digitais. 2 e -200 são todos definidos como true. Nós classificamos as constantes em grupos. verdadeiro e falso (constantes booleanas) Há duas constantes usadas para representar verdade ou falsidade na linguagem Arduino: true (verdadeiro). Elas são usadas para tornar os programas mais facilmente legíveis. INPUT e OUTPUT Pinos digitais podem ser tanto de INPUT como de OUTPUT. isto vai "levantar" o resistor interno de 20K que vai manter a leitura do pino como HIGH a não ser que ela seja alterada para low por um circuíto externo. 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). QUando um pino é configurado como um INPUT com o pinMode. Quando um pino é configurado como INPUT com pinMode. emum modo booleano. ele está a 0 volts. Assim. Um modo de explicar é que os pinos configurados como INPUT fazem demandas Página | 29 . Mudar um pino de INPUT para OUTPUT com pinMode() muda drasticamente o seu comportamento elétrico. e lido com um digitalRead. Quando um pino é configurado como OUTPUT com pinMode. o microcontrolador considera como HIGH se a voltagem for de 3 volts ou mais. e false (falso). LOW O significado de LOW também pode variar dependendo do pino ser marcado como INPUT ou OUTPUT. HIGH O significado de HIGH (em referência a um pino) pode variar um pouco dependendo se este pino é uma entrada (INPUT) ou saída (OUTPUT). o que é correto. Definindo níveis lógicos. Quando um pino é configurado como OUTPUT com o pinMode. e posteriormente receber um HIGH com um digitalWrite. true true é frequentemente definida como 1. Neste estado ele pode "drenar" corrente como por exemplo para acender um LED que está conectado com um resistor em série ao +5 volts. e marcado como LOW com o digitalWrite. Neste estado ele pode enviar corrente como por exemplo acender um LED que está conectado com um resistor em série ao terra. INPUT. e lido com o digitalRead. Definindo níveis de pinos.Constantes Constantes são variáveis pre-definidas na linguagem Arduino. o microcontrolador considera como LOW se a voltagem for de 2 volts ou menos. ou a outro pino configurado como OUTPUT e marcado como HIGH. -1. ele está a 5 volts. Pinos configurados como Inputs Os pinos do Arduino (Atmega) configurados como INPUT com pinMode() estão em um estado de alta impedância. e OUTPUT. mas true tem uma definição mais ampla. e marcado como HIGH com o digitalWrite. Um pino também pode ser configurado como um INPUT com o pinMode. Qualquer inteiro que não é zero é TRUE. LOW. Note que true e false são digitadas com minúsculas diferente de HIGH. ou a outro pino configurado como OUTPUT e marcado como LOW.

Página | 30 . Isto significa que eles podem fornecer grandes quantidades de corrente para outros circuítos. Isto faz com que eles sejam úteis para energizar um LED mas disfuncionais para a leitura de sensores. algo como um resistor de 100 Megaohms em série com o pino. A quantidade de corrente fornecida por um pino do Atmega também não é suficiente para ativar muitos relês e motores e. Pinos configurados como outputs também podem ser danificados ou destruidos por curto-circuitos com o terra ou com outros pontos de 5 volts. neste caso. algum circuíto de interface será necessário.extremamente pequenas ao circuíto do qual estão tomando amostras. Pinos configurados como outputs Pinos configurados como OUTPUT com pinMode() estão em um estado de baixa impedância. Os pinos do Atmega podem fornecer corrente positiva ou drenar corrente negativa até 40 mA (milliamperes) de/para outros dispositivos ou circuítos. Sendo assim é útil para ler um sensor mas não para energizar um LED.

Valores octais são indicados pelo prefixo "0". 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 inválida // B11001100 é o primeiro byte e B10101010 o y y y um 'u' ou 'U' para forçar a constante como do tipo não assinalado (unsigned). 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. Caracteres válidos são de 0 a 9 e as letras de A a F. Exemplo: 100000L um 'ul' ou 'UL' para forçar a constante como do tipo longo não assinalado (unsigned long). Exemplo: 0x101 // o mesmo que 257 decmal ((1 * 16^2) + (0 * 16^1) + 1) Formatadores U e L Por padrão uma constante inteira é tratada como um int com as limitações pertinentes nos valores. Base 10 (decimal) 2 (binário) 8 (octal) Exemplo 123 B1111011 0173 Formatador nenhum 'B' inicial somente valores de 8 bits (0 a 255) caracteres válidos 0-1 '0' inicial 0x7B '0x' inicial caractres válidos: 0-7 caractres válidos: 0-9 A-F. Apenas caracteres entre 0 e 7 são válidos. segundo Octais são na base oito.Constantes inteiras Constantes inteiras são números usados diretamente no código. Exemplo: 33u um 'l' ou 'L' para forçar a constante como do tipo longo (long). Note A-F pode ser escrito tanto com maiusculas quanto com minúsculas (a-f). myInt = (B11001100 * 256) + B10101010. A vale 10. Hexadecimais (ou hex) são na base 16. Constatntes sem outros prefixos são asumidas como decimais. Valores hexadeciamis são indicados pelo prefixo "0x". Esta é a matemática do senso comum com a qual você está acostumado. Exemplo: 101 // o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1) Binários são na base 2. Apenas os caracteres 0 e 1 são válidos. Exemplo: B101 // o memso que 5 decimal ((1 * 2^2) + (0 * 2^1) + 1) O formatador binário trabalha apenas com bytes (8 bits) entre 0 (B0) e 255 (B11111111). mas formatadores especiais podem ser usados para entrar números em outras bases. a-f Comentário 16 (hexadecimal) Decimal são na base 10. Exemplo: 32767ul Página | 31 . B vale 11 até F que vale 15. Por padrão estes números são tratatados como int's. Normalmente constantes inteiras são tratadas na base 10 (decimal). mas você pode alterar este comportamento com os modificadores U e L (veja abaixo). Se for conveniente entrar um número de 16 bits na forma binária você pode fazer isso seguindo o algoritmo abaixo: The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). Exemplo: 0101 Cuidado É possivel gerar um erro difícil de encontrar (não intencional) incluindo um zero à frente de uma constatnte o que fará com que o compilador interprete o valor como octal.

Entretanto caracteres são armazenados como números. running = !running.strings . isso quer dizer que é possível codificar números de -128 a 127. O tipo de dado char é também do tipo assinalado. HIGH). void setup() { pinMode(LEDpin. } } * assim chamadas em homenagem a George Boole // espera para filtrar ruído da chave // inverte o valor da variável running // indica via LED // "levanta" o resistor digitalWrite(LEDpin. boolean running = false. Para um tipo de dado não assinalado de 1 byte (8 bits) use o tipo de dado byte.g. char myChar = 65. digitalWrite(switchPin.resistor se mantém "levantado" delay(100).Variáveis booleanas * variáveis boolenas podem ter apenas dois valores verdadeiro (true) e falso (false). Você pode ver o código específico na tabela ASCII. } void loop() { if (digitalRead(switchPin) == LOW) { // interruptor é pressionado . // ambos são equivalentes Página | 32 . Exemplo int LEDpin = 5. não consigo imaginar como possa ser em português) como este: 'A' (para cadeias de caracteres . desde que o valor ASCII do A máiusculo é 65).println para mais informação de como os caracteres são traduzidos em números. 'A' + 1 vale 66. Isto significa que é possível realizar operações artiméticas com caracteres. nos quais o valor ASCII do caractere é utilizado (e. Caracteres literais são escritos entre ' ' (em inglês estes caracteres se chamam single quotes. running) char Descrição Um tipo de dado que ocupa 1 byte de memória e armazena o valor de um caractere. Veja a referencia do Serial. // LED no pino 5 int switchPin = 13. Exemplo char myChar = 'A'. INPUT).use aspas: "ABC"). pinMode(switchPin. // interruptor no. OUTPUT). outro lado conectado ao terra.

o valor designado para a variável Dica de programação Quando uma variável excede seu valor máximo de que é capaz ela "decai" ao valor mínimo de que é capaz. x = x + 1. de 0 a 255.byte Descrição Um byte armazena um número de 8 bits não assinalado. x = 32. Entretanto pode ocorrer uma complicação inesperada na manipulação operador para deslocar bits à direita (>>). y y var . Exemplo byte b = B10010.767 (valor mínimo de -2^15 e valor máximo de (2^15) -1). e sinaliza se o número é positivo ou negatico. x = x .767.768.768 . // x agora contém -32.o nome da variável int val . // "B" é o formatador binário (B10010 = 18 decimal) int Descrição Inteiro é o principal tipo de dado para armazenamento numérico capaz de números de 2 bytes. assim as operações aritméticas funcionam de modo transparente e esperado. Ints armazenam números negativos com uma técnica chamada Complemento para dois. as vezes chamado de bit de "sinal". Isto abrange a faixa de -32.1.768 a 32. Exemplo int ledPin = 13. O Arduino cuida da manipulação de números nagativos para você. Sintaxe int var = val.767 . Note que isso ocorre nas duas direções. int x x = -32.decaindo na direção negativa Página | 33 . O bit mais alto.decaido // x agora contém 32.

e são capazes de armazenar 32 bits (4 bytes). Entretanto.nome da variável do tipo int não assinalado val . A diferença entre ints e ints não assinalados está no modo como o bit mais alto é interpretado.decaindo long Descrição Variáveis do tipo Long têm um tamanho ampliado para armazenamento de números. Note que isso ocorre nas duas direções. de -2. Exemplo unsigned int ledPin = 13.535 ((2^16)-1). Sintaxe unsigned int var = val.No Arduino o tipo int (que é assinalado).483. // veja Constantes inteiras para a explicação do 'L' Sintaxe long var = val.o valor designado para a variável Dica de programação Quando variáveis excedam sua capacidade máxima elas "decaem" para o valor de sua capacidade mínima.1.o nome da variável de tipo long val .648 a 2. // x agora contém 65535 . o número é interpretado como negativo. unsigned int x x = 0. se o bit mais elevado é 1.647. ao invés de armazenar números negativos. armazenam somente valores positivos abrangendo a faixa de 0 a 65. y y var .o valor designado para a variável Página | 34 .decaindo na direção negatica // x now contains 0 .147. Exemplo long speedOfLight = 186000L.int não assinalado (unsigned int) Descrição Ints não assinalados (inteiros sem sinal) são o mesmo que ints no modo como armazenam valores de 2 bytes. x = x + 1. y y var . x = x .147.483.

time = millis().print("Time: "). } void loop() { Serial.println(time).967.294. void setup() { Serial. //imprime o tempo desde que o programa começou a rodar Serial. Diferente dos longs padrão. // espera um segundo de modo que o programa não envie quantidades absurdas de dados delay(1000). os não assinalados não armazenam números negativos.1). y y var .o valor designado para a variável Página | 35 .long não assinalado (unsigned long) Descrição Longs não assinalados (longos sem sinal) são variáveis de tamanho ampliado para armazenamento numérico.o nome de sua variável tipo long val .295 (2^32 . abrangendo a faixa de 0 a 4. Exemplo unsigned long time. } Sintaxe unsigned long var = val.begin(9600).

não 2) Dica de programação Serial.0. Eles são armazenados em 32 bits (4 bytes) de informação. verificar que o valor absoluto da diferença entre os números é menor que um valor pequeno pré-determinado.4028235E+38 a 3. Multiplique por potências de 10 para preservar a resolução.0 / 3. Números de ponto flutuante são freqüentemente usados para aproximar valores análogos e contínuos porque têm mais resolução que os inteiros. um loop tem que rodar a velocidade máxima para uma função em que o tempo é cr'tico. Exemplos float myfloat. Por exemplo 6. Sintaxe float var = val.o nome da sua variável de ponto flutuante val .0 pode não ser igua a 2. por exemplo. Você deve. A matemática de ponto flutuante também é muito mais lenta que a dos inteiros na realização de cálculos. y = x / 2.println() trunca os floats (despreza as frações) em inteiros quando enviando comunicação serial. // y agora contém 0.117.o valor designado para a variável Código de exemplo int x. Números de ponto flutuante abrangem a faixa de 3. y y var .0.5 (voce deve usar 2.4028235E+38. um número que tem um ponto decimal. Programadares freqüentemente se esforçam para converter cálculos com pontos flutuantes em matemática de inteiros para aumentar a velocidade. em vez disso. float sensorCalbrate = 1. x = 1. int y. float z.0.float Descrição Tipo de dado para números de ponto flutuante. deve portanto ser evitada se. // z agora contém . Números de ponto flutuante não são exatos e podem gerar resutados estranhos quando comparados. Página | 36 . inteiros não suportam frações z = (float)x / 2.

Str4 terá o tamanho determinado automaticamente como 8 caracteres. char Str2[8] = {'a'. portanto você não deve fazer isso intencionalmente.a última posição é automaticamente preenchida com o caracatere null. Isto permite às funções (como Serial. Isto vai danificar a maioria das funções que usam strings. 'u'. char Str3[8] = {'a'. se você tivesse especificado o tamanho da Str2 com sete ao invés de oito). A implementação do double no Arduino é atualmente exatamente a mesma do float. char Str6[15] = "arduino". sem ganho de precisão. Isto significa que sua string deve ter espaço para um caractere a mais do que o texto que ela contém. Na Str3 nós incluimos explicitamente o caractere null (escrito como '\0'). um extra para o null. Dica Usuários que utilizam códigos de outras fontes que incluem variávei do tipo double devem examinar o código para para verificar se a precisão implicada é diferente daquela realmente alcançada pelo Arduino. Aspas ou apóstrofos? Strings são sempre definidas com aspas ("Abc") e caracteres sempre definidos com apóstrofos('A'). 'i'. embora "arduino" tenha apenas 7 . 'd'. Possibilidades de declaração 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 necessário como em Str2 Adcionar explicitamente o caractere null como em Str3 Inicializar com uma string constante entre aspas. char Str5[8] = "arduino". 'o'. 'n'. Envolvendo strings longas Você pode envolver strings longas desse modo: Página | 37 . '\0'}. É por isso que Str2 e Str5 precisam ter 8 caracteres. 'r'. 'u'. 'n'. De outro modo elas continuariam lendo os bytes subsequentes da memória que de fato não pertencem à string. string Descrição Strings são representadas como arrays do tipo de dado char e terminadas por null (nulo). Ocupa 4 bytes. 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 espaço extra para uma string maior como em Str6 Terminação em Null Geralmente strings são terminadas com o caractere null (código ASCII 0). Entretanto se você notar algo se comportando de maneira estranha (operações em caracteres que não pertencem à string) este poderia ser o problema. char Str1[15]. 'd'.g. Exemplos Todos os seguintes são declarações válidas de strings. 'i'. 'o'}.double Descrição Número de ponto flutuante de precisão dupla. char Str4[ ] = "arduino". 'r'. Note que é possível ter uma string sem o caractere final null (e.print()) saber onde está o final da string.

"This is string 2". No código abaixo os asteriscos após o tipo de dado char "char*" indica que se trata de um array de "ponteiros". quando se está trabalhando com grandes quantidades de texto. como em um projeto com um display de LCD. "This is string 4". e assim são requeridos para se configurar um array de arrays. configurar um array de strings. mas é necessário entender os ponteiros em detalhe para fazer um uso efetivo deles neste caso. Devido ao fato de as strings serem elas mesmas arrays. Ponteiros são uma das partes mais esotéricas da linguagem C que os principiantes têm que entender. este é de fato um exemplo de um array bi-dimencional. "This is string 5". Exemplo char* myStrings[]={"This is string 1"."This is string 6"}. } void loop(){ for (int i = 0.println(myStrings[i]). delay(500). void setup(){ Serial. i < 6. i++){ Serial. "This is string 3". } } Página | 38 . Todos os nomes de array são de fato ponteiros.begin(9600).char myString[] = "This is the first line" " this is the second line" " etcetera". Arrays de strings Freqüentemente é conveniente.

Acessando um Array Arrays são indexados a partir do zero. assim: int myArray[10]={9. int myInts[6].2. Recuperar um valor de um array: x = mySensVals[4].4.println(myPins[i]). Isto também pode ser um bug difícil de rastrear. Isso também significa que em um array de 10 elementos o índice do último elemento é 9. for (i = 0. o compilador C não checa para ver se um acesso a um array está dentro das margens legais do tamanho com que o array foi declarado. assim: mySensVals[0] == 2. e assim por diante. mySensVals[1] == 4. int myPins[] = {2. 6}. Note que quando declarar um array do tipo char. um elemento a mais é necessário para armazenar o caractere null de finalização. Diferente de algumas versões do BASIC. e provavelmente conduzirá a maus resultados como malfuncionamento ou travamento do programa. Arrays na liguagem de programação C. para imprimir os elementos de um array através da porta serial você poderia fazer alguma coisa assim: int i. Escrever em locais de memória aleatórios decididamente não é uma boa idéia. // myArray[9] contém 11 // myArray[10] é inválido e contém informação aleatória (outro endereço de memória) Por esta razão você deve acessar arrays cuidadosamente. Você pode declarar um array sem inicializar como em myInts. Designar um valor para um array: mySensVals[0] = 10.Arrays Um array é uma coleção de variáveis que são acessadas com um índice numérico.8. int mySensVals[6] = {2. nas quais o contador é usado com índice para cada elemento.7.3. na qual o Arduino é baseado.2. Por exemplo. podem ser complicados. o primeiro elemento do array está no índice 0.9. i < 5. mas o uso de arrays simples é relativamente operacionalizável. ou seja. 3. 3. 4. Arrays e FOR Arrays são freqüentemente manipulados dentro da sentença for. Em myPins declaramos um array sem escolher explicitamente um tamanho. Acessar um array após o seu final (usando um índice maior do que o declarado) é ler uma faixa de memória que está sendo utilizada para outros propósitos.11}. O compilador conta os elementos e cria o array do tamanho apropriado. Ler destes locais provavelmente não vai gerar nada além de dados inválidos.3. } Página | 39 . Criando (Declarando) um Array Todos os métodos abaixo são modos válidos para criar (declarar) um array. i = i + 1) { Serial. 4. você pode inicializar e especificar o tamanho do array como em mySensVals. 8. 2}. -8. Finalmente. fazendo referência à inicialização de arrays acima. char message[6] = "hello".

} void loop() { // .. Ela indica que a função não deve enviar nenhuma informação de retorno à função que a chamou.. } Página | 40 . Exemplo: // ações são realizadas nas funções "setup" e "loop" // mas nenuma informação é enviada ao programa mais amplo void setup() { // ...void A palavra-chave void é usada apenas em declarações de funções.

Sintaxe char(x) Parâmetros x: um valor de qualquer tipo Retorno char byte() Descrição Converte um valor para o tipo de dado byte. Sintaxe long(x) Parâmetros x: um valor de qualquer tipo Retorno long Página | 41 . Sintaxe int(x) Parâmetros x: um valor de qualquer tipo Retorno int long() Descrição Converte um valor para o tipo de dado long. Sintaxe byte(x) Parâmetros x: um valor de qualquer tipo Retorno byte int() Descrição Converte um valor para o tipo de dado int.char() Descrição Converte um valor para o tipo de dado char.

< = > ? @ 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 código ASCII é um padrão para codificar texto numericamente e embora tenha muita importância histórica. Página | 42 . / 0 1 2 3 4 5 6 7 8 9 : . Sintaxe float(x) Parâmetros x: um valor de qualquer tipo Retorno float Tabela ASCII O código ASCII (American Standard Code for Information Interchange) está em uso desde a década de 1960.* Note que os primeiros 32 caracteres (0-31) são caracteres não imprimíveis. Ele é o modo padrão para codificar texto numericamente. vem sendo gradativamente substituido por padrões mais amplos como o UTF.float() Descrição Converte um valor para o tipo de dado float. . também chamados de caracteres de controle. e os conjuntos de caracteres (charset) definidos pela ISO (International Organization for Standardization). 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 espaço ! " # $ % & ' ( ) * + . em suas diversas variantes.

// predetermina o pino digital como uma saída // LED conectado ao pino digital 13 Página | 43 . mode) Parâmetros pin: o número do pin o qual você deseja predeterminar. OUTPUT). mode: pode ser INPUT ou OUTPUT Retorno Nenhum Exemplo int ledPin = 13. } Nota Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5). Veja a descrição depinos digitais para mais detalhes. LOW). delay(1000). // espera um segundo // apaga o LED // espera um segundo digitalWrite(ledPin. void setup() { pinMode(ledPin. } void loop() { digitalWrite(ledPin. HIGH).pinMode() Descrição Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma saída (output). // acende o LED delay(1000). Sintaxe pinMode(pin.

} void loop() { digitalWrite(ledPin. Se o pino foi configurado como uma saída (output) com o pinMode(). // acende o LED delay(1000). Escrever um LOW rebaixará o resistor. // espera um segundo // apaga um led // espera um segundo digitalWrite(ledPin. delay(1000). Se o pino está configurado como uma entrada (input) escrever um HIGH levantará o resistor interno de 20K tutorial de pinos digitais). ( Sintaxw digitalWrite(pin.3V nas placas de 3. valor) Parâmetros pin: o número do pin valor: HIGH oo LOW Retorno nenhum Exemplo int ledPin = 13.3V) para HIGH. } Nota Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5). LOW). OUTPUT). 0V (terra) para LOW. // determia o pino digital como uma saída // LED conectado ao pino digital 13 Página | 44 . HIGH).digitalWrite() Descrição Escreve um valor HIGH ou um LOW em um pino digital. sua voltagem será determinada ao valor correspondente: 5V (ou 3. void setup() { pinMode(ledPin.

HIGH ou LOW. // botão conectado ao pino digital 7 int val = 0. Nota Se o pino não estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode variar aleatoriamente). void setup() { pinMode(ledPin. // acende ou apaga o LED de acordo com o pino de entrada // pré-determina o pino digital 13 como uma saída // pré-determina o pino dgital 7 como uma entrada // variável para armazenar o valor lido Página | 45 . INPUT). OUTPUT). pinMode(inPin. // lê o pino de entrada digitalWrite(ledPin. Sintaxe digitalRead(pin) Parâmetros pin: o número do pin digital que você quer ler (int) Retorno HIGH ou LOW Exemplo int ledPin = 13. val). } Transfere para o pino 13 o valor lido no pino 7 que é uma entrada. } void loop() { val = digitalRead(inPin). Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5). // LED conectado ao pino digital 13 int inPin = 7.digitalRead() Descrição Lê o valor de um pino digital especificado.

Exemplo int analogPin = 3.println(val). etc. Na prática é um valor aleatório. os valores de outras entradas analógicas. Isto permite uma resolução entre leituras de 5 volts / 1024 unidades ou 0. 0 ta 7 no Mini e no Nano) Retorno int (0 a 1023) Note Se o pino analógico não estiver conectado a nada o valor de retorno do analogRead() vai variar de acordo com uma grande quantidade de fatores (e.).begin(9600). a distância de sua mão à placa. A placa Arduino contém um conversor analógico-digital de 10 bits com 6 canais (8 canais no Mini e no Nano). São necessários aproximadamente 100 Sintaxe analogRead(pin) Parâmetros pin: o número do pino analógico que se deseja ler (0 a 5 na maioria das placas. portanto a velocidade máxima de leitura é de aproximadamente 10. Serial. } void loop() { val = analogRead(analogPin).analogRead() Descrição Lê o valor de um pino analógico especificado.g.000 vezes por segundo.0049 volts (4.0001 s) para ler uma entrada analógica. void setup() { Serial.9 mV) por unidade. // pernas externas conectadas ao terra e ao +5V // variável para armazenar o valor lido Página | 46 . } // lê o pino de entrada // informa o valor lido // inicial a comunicação serial // perna do meio de um potenciómetro conectada ao pino analógico 3 s (0. int val = 0. Com isto ele pode mapear voltagens de entrada entre 0 e 5 volts para valores inteiros entre 0 e 1023.

Nas novas placas Arduino (incluindo o Mini e o BT) com o chip ATmega168 esta função é eficiente nos pinos 3.9. Placas Arduino mais antigas com um ATmega8 suportam o analogWrite() apenas nos pinos 9.5. Isto se deve às interações com as funções millis() e delay(). int ledPin = 9.10 e 11. OUTPUT). As saídas PWM geradas pelos pinos 5 e 6 terão rendimento de ciclo acima do esperado. // pré-determina o pino como saída } void loop() { val = analogRead(analogPin). val / 4). int val = 0.6. void setup() { pinMode(ledPin.10 e 11. A freqüência do sinal PWM é de aproximadamente 490Hz. Exemplo Torna o brilho de um LED proporcional ao valor lido em um potenciómetro. // os valores do analogRead variam de 0 a 1023. // potentiómetro conectado ao pino analógico 3 Página | 47 . Depois de realizar um analogWrite(). os valores do analogWrite variam de 0 a 255 } // LED conectado ao pino digital 9 // variável para armazenar o valor lido int analogPin = 3. o pino vai gerar uma onda quadrada estável com o ciclo de rendimento especificado até que o próximo analogWrite() seja realizado (ou que seja realizado um digitalRead() oudigitalWrite() no mesmo pino). valor) Parâmetros pin: o pino no qual se deseja escrever valor: o rendimento do ciclo: entre 0 (sempre desligado) e 255 (sempre ligado). que compartilham o mesmo temporizador interno usado para gerar as saídas PWM. Sintaxe analogWrite(pin. Pode ser usado para acender um LED variando o brilho ou girar um motor a velocidade variável.analogWrite() Descrição Escreve um valor analógico (onda PWM) em um pino. Retorno nenhum Notas e problemas conhecidos Não é necessário realizar um pinMode() para pré-determinar o comportamento do pino como saída antes de realizar um analogWrite(). // lê o pino de entrada analogWrite(ledPin.

Sintaxe shiftOut(dataPin. Os bits vão sendo escritos um de cada vez um pino de dados. pinMode(clockPin.Tom Igoe // Version : 1. Normamlemte esta característica é descrita comoSerial Peripheral Interface (SPI). } Página | 48 . Pode começar tanto pelo bit mais significativo (mais à esquerda) quano pelo menos significativo (mais à direita). OUTPUT). pinMode(dataPin. OUTPUT). Exemplo Para o circuíto de referência deste exemplo veja tutorial on controlling a 74HC595 shift register. //**************************************************************// // Name // Date : shiftOutCode. Isto é conhecido como protocolo serial sincrônico e é um modo comumente usado para que os microcontroladores se comuniquem com sensores e com outros microcontroladores. OUTPUT).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. em sincronia com as alterações de um pino de clock que indica que o próximo bit está disponível. ////Pin connected to DS of 74HC595 int dataPin = 11.shiftOut() Descrição Envia um byte para a saída um bit de cada vez. void setup() { //set pins to output because they are addressed in the main loop pinMode(latchPin. Hello World : 25 Oct. na documentação dos chips. value) Parâmetros dataPin: o pino no que será a saída 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. (byte) Retorno Nenhum Note O dataPin e clockPin devem estar configurados como output pela função pinMode(). clockPin. (Mais significativo primeiro ou menos significativo primeiro) value: a informação a enviar para a saída. pode ser MSBFIRST LSBFIRST. bitOrder. Os dois sispositivos se mantêm sincronizados a velocidades próximas da máxima desde que ambos compartilhem a mesma linha de clock. //Pin connected to SH_CP of 74HC595 int clockPin = 12. 2006 // // // // // // // Author : Carlyn Maw.

INPUT). clockPin. j++) { //ground latchPin and hold low for as long as you are transmitting digitalWrite(latchPin. valor. LOW). unsigned long duration. e então espera que o pino vá para LOW e para a cronometragem. se valor for HIGH. j < 256. (int) valor: tipo de pulso a ler: tanto HIGH como LOW. j). pulseIn() espera que o pino vá paraHIGH. inicia a cronometragem. O tempo desta função foi determinado empiricamente e provavelmente dará erro em pulsos longos. HIGH). } void loop() { duration = pulseIn(pin. Syntaxe pulseIn(pino. Desiste e retorna 0 se nenhum pulso iniciar dentro de um tempo especificado. Funciona com pulsos entre 10 microsegundos e 3 minutos. (int) tempo (opcional): o número de microsegundos a esperar para que o pulso comece. valor) pulseIn(pino. shiftOut(dataPin. Retorna a duração do pulso em microsegundos. Por exemplo. } Página | 49 . tempo) Parameters pino: o número do pino no qual você deseja ler o pulso. void setup() { pinMode(pin. HIGH). o padrão é um segundo (unsigned long) Returno a duração do pulso (em microsegundos) ou 0 se nehum pulso iniciar antes do tempo especificado (unsigned long) Exemplo int pin = 7. LSBFIRST.void loop() { //count up routine for (int j = 0. delay(1000). } } PulseIn() Descrição Lê um pulso (tanto HIGH como LOW) em um pino. //return the latch pin high to signal chip that it //no longer needs to listen for information digitalWrite(latchPin.

Duemilanove e Nano). Página | 50 . Nota: em 1 milisegundo há 1. } Dica: Verifique o retorno para o millis é um longo não assinalado. esta função tem uma resolução de 8 microsegundos.println(time). como inteiros. Este número extrapolrá (voltará ao zero) depois de aproximamente 70 minutos.000 microsegundos e 1. Parâmetros Nenhum Retorno O número de microsegundos desde que o programa começou a rodar como um tipo longo não assinalado. LilyPad). micros() Descrição Retorna o número de microsegundos desde que a placa Arduino começou a rodar o programa. Parâmetros Nenhum Retorno O número de milisegundos desde que o programa começou a rodar como um tipo longo não assinalado.print("Time: ").begin(9600).millis() Descrição Retorna o número de milisegundos desde que a placa Arduino começou a rodar o programa. Erros podem ocorrer se um programador tentar realizar cálculos com outros tipos de dados. Exemplo unsigned long time. void setup(){ Serial. //imprime o tempo desde que o programa começou Serial.g. Nas placas Arduino de 16 MHz (e. esta função tem uma resolução de 4 microsegundos (o valor de retorno será sempre um múltiplo de 4) Nas placas Arduino de 8MHz (e.000 de microsegundos em 1 segundo. } void loop(){ Serial.g. // espera um segundo para não ficar enviando quantidades absurdas de dados delay(1000). time = millis(). Este número extrapolrá (voltará ao zero) depois de aproximamente 50 dias.000.

000 milisegundos. Para controles de tempo alternativos veja a função millis() e e seu programa de exemplo.begin(9600). } void loop() { digitalWrite(ledPin. time = micros(). e muitos programas usam intervalos curtos para tarefas como a de filtrar ruídos. ou manipulação de pinos pode seguir durante a execução desta função.Exempl0 unsigned long time.) Parâmetros ms (unsigned long): o número de milisegundos em que o programa ficará com a execução em suspenso. cálculo matemático. OUTPUT). // acende o LED delay(1000). portanto muitas outras funções ficam em espera. o uso do delay() em um programa tem aspectos negativos importantes. (Em um segundo há 1. // marca o pino digital como saída // LED conectado ao pino digital 13 Página | 51 . void setup() { Serial. } Cuidado Embora seja fácil criar um LED piscando com a função delay().println(time). Programadores com mais conhecimento normalmente evitam o uso de delay() para cronometrar eventos mais logos do que 10 milisegundos.print("Time: "). } void loop() { Serial. Nenhuma leitura de sensores. delay(1000). //espera um segundo para não ficar enviando quantidades absurdas de dados delay(1000). //imprime o tempo desde que o programa começou a rodar Serial. void setup() { pinMode(ledPin. a não ser que o programa seja muito simples. Retorno nenhum Exemplo int ledPin = 13. HIGH). LOW). } delay(ms) Descrição Suspende a execução do programa pelo tempo (em milisegundos) especificado como parâmetro. // espera por um segundo // apaga o LED // espera por um segundo digitalWrite(ledPin.

Atualmente o maior valor que produzirá uma suspenção precisa é 16383. Isto significa que algumas coisas (como o recebimento de informações seriais. e as interrupções continuam funcionando. Retorno Nenhum Exemplo int outPin = 8.Algumas coisas de fato continuam acontecendo enquanto a função delay() está controlando o chip ATmega porque as interrupções não são desabilitadas. digitalWrite(outPin. delayMicroseconds(—s) Descrição Suspende a execução do programa pelo tempo (em microsegundos) especificado como parâmetro. e usar delay() para as mais longas. Parâmetros s: o número de microsegundos da suspenção. Para suspenções maiores que milhares de microsegundo você deve utilizar a função delay(). // ativa o pino delayMicroseconds(50). Para assegurar suspenções mais precisas esta função desabilita as interrupções durante sua operação. A comunicação que aparece no pino RX continua sendo gravada. Isto pode mudar em distribuições futuras do Arduino. Um 1 milisegundo há 1. Cuidados e problemas conhecidos Esta função funciona com bastante precisão na faixa dos 3 microsegundos e acima. } void loop() { digitalWrite(outPin. HIGH).000 microsegundos e em 1 segundo há 1 milhão. Envia uma cadeia de de pulsos com um período de 100 microsegundos. os pinos e as leituras de PWM (analogWrite) são mantidos. delayMicroseconds(50). s) bem como se o // digital pino 8 // marca o pino digital como saída // suspenção de 50 microsegundos // desativa o pino // suspenção de 50 microsegundos Página | 52 . Desse modo. } configura o pino 8 para trabalhar como uma saída. OUTPUT). LOW). ou que a atualização do valor de retorno da função mills() ) não funcionarão. void setup() { pinMode(outPin. Não podemos nos assegurar que funcione com precisão para tempos de suspenção menores. você deve usar esta função apenas para suspenções curtas. delayMicroseconds(0) gerará uma suspanção muito maior do que a esperada (~1020 parâmetro for um número negativo.

HIGH). ou que a atualização do valor de retorno da função mills() ) não funcionarão. Desse modo. Parâmetros s: o número de microsegundos da suspenção. delayMicroseconds(50). // ativa o pino delayMicroseconds(50). Envia uma cadeia de de pulsos com um período de 100 microsegundos. LOW). você deve usar esta função apenas para suspenções curtas. delayMicroseconds(0) gerará uma suspanção muito maior do que a esperada (~1020 parâmetro for um número negativo. } configura o pino 8 para trabalhar como uma saída.000 microsegundos e em 1 segundo há 1 milhão. Isto pode mudar em distribuições futuras do Arduino. Retorno Nenhum Exemplo int outPin = 8. void setup() { pinMode(outPin. Atualmente o maior valor que produzirá uma suspenção precisa é 16383. Não podemos nos assegurar que funcione com precisão para tempos de suspenção menores. s) bem como se o // digital pino 8 // marca o pino digital como saída // suspenção de 50 microsegundos // desativa o pino // suspenção de 50 microsegundos Página | 53 . Para suspenções maiores que milhares de microsegundo você deve utilizar a função delay(). Um 1 milisegundo há 1.delayMicroseconds(—s) Descrição Suspende a execução do programa pelo tempo (em microsegundos) especificado como parâmetro. Para assegurar suspenções mais precisas esta função desabilita as interrupções durante sua operação. e usar delay() para as mais longas. } void loop() { digitalWrite(outPin. Isto significa que algumas coisas (como o recebimento de informações seriais. OUTPUT). digitalWrite(outPin. Cuidados e problemas conhecidos Esta função funciona com bastante precisão na faixa dos 3 microsegundos e acima.

max() é frequentemente utilizado para restringir o valor mais baixo de uma variável. isto pode levar a resultados incorretos min(a++. y) Descrição Calcula o mínimo entre dois números. // assinala à variável sensVal o mínimo entre seu prório valor e 100 // assegurando que seu valor nunca seja menor que 100 Nota Talvez. de modo não-intuitivo. mantenha outros cálculos fora da função Página | 54 . Exemplos sensVal = min(sensVal. // usse isso. enquanto min() é utilizado para restringir o valor mais alto. 100). de qualquer tipo de dado Retorno O menor dos dois números. min(a. de qualquer tipo de dado y: o segundo número. // evite isso a++. 100). Cuidado: Devido ao modo como a função min() foi implementada você deve evitar utilizar outras funções dentro dos parênteses. 100). Parâmetros x: o primeiro número.min(x.

isto pode levar a resultados incorretos max(a--.max(x. Cuidado Devido ao modo como a função max() foi implementada você deve evitar utilizar outras funções dentro dos parênteses. de modo não-intuitivo. max() é frequentemente utilizado para restringir o valor mais baixo de uma variável. // evite isso a--. 0). y) Descrição Calcula o máximo entre dois números Parâmetros x: o primeiro número. mantenha outros cálculos fora da função max(a. // assinala à variável sensVal o máximo entre seu prório valor e 20 // assegurando que seu valor seja pelo menos 20 Nota Talvez. // use isso. de qualquer tipo de dado Retorno O maior dos dois números Exemplo sensVal = max(senVal. Página | 55 . de qualquer tipo de dado y: o segundo número. 0). enquanto min() é utilizado para restringir o valor mais alto. 20).

// use isso. mantenha outros cálculos fora da função constrain(x. // evite isso a++.abs(x) Descrição Calcula o valor absoluto de um número. 150). Parâmetros x: o número a restringir. a. todos os tipos de dados b: o extremo superior da faixa. // limita o valor da variável sensVal a valores entre 10 e 150 Página | 56 . abs(a). isto pode levar a resultados incorretos abs(a++). 10. Cuidado Devido ao modo como a função abs() foi implementada você deve evitar utilizar outras funções dentro dos parênteses. Parâmetros x: o número Retorno x: se x for maior ou igual a 0 -x: se x for menor que 0. b) Descrição Restring um número dentro de uma 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. todos os tipos de dados a: o extremo inferior da faixa.

long in_min. } Apêndice Para aqueles com inclinação matemática aqui está a função completa: long map(long x. long in_max. mantendo-se a proporção entre eles.map(value. toHigh) Descrição Re-mapeia um número de uma faixa de valores para outra. -100). Verifique que os limites inferiores de uma faixa podem ser maiores ou menores que os limites superiores. um valor fromHigh para toHigh. 50. 1023. } Página | 57 . Isto é.out_min) / (in_max . 1). analogWrite(9. Não restringe valores dentro da faixa. long out_min. 255). 50. fromLow. como por exemplo: y = map(x. 0. val). e valores intermediários da primeira faixa para a segunda faixa. A função constrain() pode ser utilizada tantes antes como depois desta função se limites para as faixas forem necessários. A função também pode utilizar números negativos como neste exemplo: y = map(x. 1. Exemplo /* Mapear uma entrada analógica de 10 bits para uma saída analógica de 8 bits (0 a 255) */ void setup() {} void loop() { int val = analogRead(0). val = map(val. 0. Parâmetros value: o número 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. Quando o resultado for fracionário ele será truncado e não arredondado. 50.in_min) * (out_max . um valor de fromLow é mapeado para toLow. toLow. 50. fromHigh. long out_max) { return (x . Desse modo a função map() pode ser utilizada para colocar em ordem reversa uma faixa de valores.in_min) + out_min. 1. A função map() utiliza números inteiros e não gera frações. porque valores que extrapolem podem ser úteis e intencionais.

Parâmetros x: o número.pow(base. a raíz quadrada do número. Pow() pode ser utilizado com uma potência fracionária. Página | 58 . Parâmetros base: o número(float) expoente: a potência à qual a base é elevada (float) Retorno Oresultado da exponeciação (double) Exemplo Veja a função fscale na bibliteca de código. qualquer tipo de dado Retorno double. É útil para gerar mapeamentos exponenciais de valores ou curvas. Parâmetros x: o número. O número multiplicado por ele mesmo. expoente) Descrição Calcula o valor de um número elevado a uma potência. qualquer tipo de dado Retorno o quadrado do número sqrt(x) Descrição Calcula a raíz quadrada de um número. sq(x) Descrição Calcula o quadrado de um número.

print() e Serial. Parâmetros rad: o ângulo em radianos (float) Retorno o seno do ângulo (double) Nota Serial. O resultado será entre -1 e 1.sin(rad) Descrição Calcula o seno de um ângulo (em redianos). O resultado será entre -1 e 1. Página | 59 . Parâmetros rad: o ângulo em radianos (float) Retorno a tangente do ângulo (double) Nota Serial.print() e Serial.println() atualmente não suportam floats.println() atualmente não suportam floats.println() atualmente não suportam floats.print() e Serial. cos(rad) Descrição Calcula o cosseno de um ângulo (em redianos). Parâmetros rad: o ângulo em radianos (float) Retorno o cosseno do ângulo (double) Nota Serial. tan(rad) Descrição Calcula a tangente de um ângulo (em redianos).

antes de se iniciar a seqüência aleatória.randomSeed(seed) Descrição randomSeed() inicializa um gerador de números pseudo-aleatórios. como um analogRead() de um pino que não esteja conectado.begin(9600). void setup(){ Serial. De modo semelhante. use randomSeed() para inicializar o gerador de números aleatórios a partir de um valor também aleatório. pode ocasionalmente ser útil usar seqüências pseudo-aleatórias que se repetem exatamente a cada execução de um programa. Serial. Retorno nenhum Exemplo long randNumber. int . embora muito longa e aleatória. delay(50). Parâmetros long. Esta seqüência .println(randNumber).um número para gerar o início da seqüência. } void loop(){ randNumber = random(300). randomSeed(analogRead(0)). a cada execução de um programa. Isto pode ser obtido atravéz da função randomSeed() de um número fixado. fazendo com que a seqüência gerada comece por um ponto arbitrário de uma seqüência aleatória. } Página | 60 . é sempre a mesma. Se for importante para uma seqüência de valores gerados pela função random() ser diferente.

ruído analógico // aleatório fará com que a função randomSeed() gere // diferente números de início cada vez que o programa for executado.random() Descrição A função random gera números pseudo-aleatórios. // randomSeed() irá embralhar a função random. antes de se iniciar a seqüência aleatória.begin(9600). Exemplo long randNumber. // se o pino de entrada analógica 0 não estiver conectado.limite superior do valor aleatório.limite inferior do valor aleatório. randomSeed(analogRead(0)). De modo semelhante. } Página | 61 . } void loop() { // imprime um número aleatório entre 0 e 299 randNumber = random(300). Serial.println(randNumber). void setup(){ Serial.um número aleatório entre min e (max-1) Note: Se for importante para uma seqüência de valores gerados pela função random() ser diferente. 20). Serial. inclusivo (opcional) max . pode ocasionalmente ser útil usar seqüências pseudo-aleatórias que se repetem exatamente a cada execução de um programa. Sintaxe long random(max) long random(min. delay(50). Isto pode ser obtido atravéz da função randomSeed() de um número fixado. a cada execução de um programa. como um analogRead() de um pino que não esteja conectado. max) Parâmetros min . exclusivo Retorno long . // imprime um número aleatório entre 10 e 19 randNumber = random(10. use randomSeed() para inicializar o gerador de números aleatórios a partir de um valor também aleatório.println(randNumber).

9600.println("Hello Serial 2"). Serial1.begin(19200).begin(4800).begin(9600). 2400. 57600. Serial2. entretanto. Serial3. // com diferentes taxas de transferência: void setup(){ Serial. Serial3.begin(9600).begin(int velocidade) Descrição Ajusta o taxa de transferência em bits por segundo (baud) para transmissão de dados pelo padrão serial. } void loop() {} Página | 62 . Você pode. // abre a porta serial e ajusta a taxa de transferência de dados para 9600 bps } void loop() {} Exemplo para o Arduino Mega: // Arduino Mega usando as quatro portas seriais simultaneamente // (Serial. Serial2. 19200.println("Hello Computer"). 28800. Serial2. 14400. 1200. Parameters int velocidade. Serial3). Serial1. Para comunicação com um computador use uma destas taxas: 300.println("Hello Serial 1"). Serial1. Serial. 4800. 115200.println("Hello Serial 3"). em bits por segundo (baud) Retorno nenhum Exemplo: void setup() { Serial.Serial.begin(38400). especificar outras velocidades por exemplo para comunicação através dos pinos 0 e 1 com um componente que requer uma taxa específica.

int Serial. // diga o que você recebeu: Serial. BYTE).begin(9600).print(inByte.print("Eu recebi : ").available()) { int inByte = Serial1. Parâmetros Nenhum Retorno O número de bytes disponíveis para leitura no buffer serial. BYTE). // abre a porta serial e ajusta a taxa de transferência para 9600 bps } void loop() { // envia dados apenas quando dados forem também recebidos: if (Serial.available() Descrição Obtem o número de bytes (caracteres) disponíveis para leitura através da porta serial. Serial.available() > 0) { // lê o byte que está entrando: incomingByte = Serial. void setup() { Serial.read(). } // lê na porta 1 e envia para a porta 0: if (Serial1. DEC).read().print(inByte. } } Exemplo para o Arduino Mega: void setup() { Serial. O buffer serial pode armazenar até 128 bytes. Serial1.println(incomingByte.available()) { int inByte = Serial.begin(9600). Serial.begin(9600). Exemplo int incomingByte = 0. } } // para dados seriais que estão entrando Página | 63 . } void loop() { // lê na porta 0 e envia para a porta 1: if (Serial.read(). Serial1.

// imprime na tela o byte recebido: Serial.println(incomingByte. Parâmetros Nenhum Retorno o primeiro byte disponível na entrada da porta serial (ou -1 se não hover dados disponíveis) int Exemplo int incomingByte = 0.int Serial. } } // para entrada serial Página | 64 .read() Descrição Lê dados que estejam entrando pela porta serial.read(). DEC). // 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 disponível: incomingByte = Serial. Serial. void setup() { Serial.begin(9600).print("Eu recebi: ").

Parâmetros nenhum Returns nenhum Serial.print(b. Por exemplo: int b = 79.Serial. BIN). Serial. imprime b como um número decimal em uma string ASCII. Serial.print(data) Serial.print(data) Descrição Envia dados pela porta serial.print(b.print(b). Serial. qualquer chamada à Serial.read() ou Serial.flush() Descrição Esvasia o buffer de entrada da porta serial. Serial.print(b) sem nenhum formato especificado. BYTE) imprime b como um byte único. Serial.print(b. imprime a string string "4F". Serial. DEC) imprime b como um número decimal em uma string ASCII. HEX). imprime a string ASCII "79". BYTE).avaiable somente retornarão dados recebidos após a última chamada à Serial. Serial.print(b. Serial. Por exemplo: int b = 79. Parâmetro data: todos os tipos inteiros incluindo caracteres Sintaxe Este comando pode assumir diversas formas: Serial.print(b. imprime a string ASCII "79". DEC). Por exemplo: int b = 79. Serial. BIN) imprime b como um número binário em uma string ASCII. imprime a string "117". Por exemplo: int b = 79.print(b. Serial. imprime a string "1001111".print(b. imprime a string "O" que é o caractér ASCII representado pelo valor 79.print(b. Página | 65 .print(b. OCT) imprime b como um número octal em uma string ASCII. HEX) imprime b como um número hexadecimal em uma string ASCII.flush(). Isto é. Para mais informações veja a Tabela ASCII.print(b. Por exemplo: int b = 79. Serial. Por exemplo: int b = 79. OCT).

print("SEM FORMATO"). Por exemplo: Serial.print("BIN").print("\t"). Serial. // variável void setup() { Serial. Serial.print("\t").begin(9600).print("\t").print("\t"). 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 vários formatos Serial.print("\t"). Serial. Serial. ou str: a string a imprimir Retorno Nenum Exemplo: /* Usa um bloco FOR para dados e imprime um número em vários formatos. Serial. Serial.Serial. Serial. for(x=0.print("OCT"). // imprime um tab Serial. // imprime um tab Página | 66 . */ int x = 0. DEC).println("BYTE"). HEX).print("HEX").print("\t"). x< 64. // imprime um ASCII decimal .print(x.print("\t"). Serial. Serial.o mesmo que "DEC" // imprime um tab Serial. imprime a string "Hello World!".print("DEC").print(x.print("\t"). Serial. // imprime um ASCII hexadecimal Serial. Parâmetros b: o byte a imprimir.print(str) se str for uma string ou um array de chars imprime uma string ASCII. // imprime um ASCII decimal Serial. Serial.print(x). } void loop() { // imprime etiquetas Serial.print("Hello World!").

Serial. portanto você precisa fazer uma conversão para um tipo inteiro.print() não funciona com floats. // imprime um ASCII binario Serial.print(x.print envia os dados para um buffer. BIN). // delay(200).print(x.println(x. BYTE). } Serial. Os tipos de dados unsigned char. Entretanto a função envia o retorno antes de enviar o último caractere Página | 67 .g.print("\t"). // imprime um ASCII octal Serial. e byte irão gerar resultados incorretos e atuar como se fossem do tipo de dado assinalado. DEC). A função Serial.print("\t"). Ele esperará que um caractere seja enviado antes de seguir para o próximo. perdendo a informação dos valores fracionários. Em algumas situações é útil multiplicar um float por uma potência de 10 para preservar (ao menos em parte) a informação fracionária. Serial. // imprime um tab // imprime como um byte único e adciona um "cariage return" Serial.println(""). Seja cuidadoso ao fazer cálculos desntro dos parêntesis e. } com o "println" // espera 200 millisegundos // imprime outro carriage return Dicas de programação e problemas conhecidos Serial. OCT). // imprime um tab Serial.print(x-2.

println (val. created 24 March 2006 by Tom Igoe */ int analogValue = 0.println(analogValue). Si n t a xe Serial. // print as an ASCII-encoded hexadecimal Serial. // print as an ASCII-encoded decimal Serial. prints the value out.Serial. ou '\ r') e um caractere nova linha (ASCII 10. Este comando tem as mesmas formas como Serial.println(analogValue. // variable to hold the analog value void setup() { // open the serial port at 9600 bps: Serial. // print as an ASCII-encoded octal Página | 68 .println(analogValue. formato) Pa r â me t r o s val: o valor para impressão . OCT).println() D e s cr i ç ão Imprime os dados para a porta serial como legível texto ASCII seguido por um caractere retorno de carro (ASCII 13.println(analogValue. HEX). DEC).println (val) Serial.print ().begin(9600). // print it out in many formats: Serial. ou '\ n'). } void loop() { // read the analog input on pin 0: analogValue = analogRead(0). // print as an ASCII-encoded decimal Serial.qualquer tipo de dados formato: especifica o número base (para tipos de dados integrais) ou o número 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.

BYTE). x < 255. Examplo for (x = 0. for. // print as an ASCII-encoded binary Serial. break.println(analogValue. Também é usado para sair de uma sentença switch. se sobrepondo à condição normal de verificação. if (sens > threshold){ x = 0. BIN).Serial.println(analogValue. x ++) { digitalWrite(PWMpin. // print as a raw byte value // delay 10 milliseconds before the next reading: delay(10). x). } // checar a detecção por um sensor Página | 69 . ou while. } break break é usado para sair de um bloco do. sens = analogRead(sensorPin). } delay(50).

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