Baixe o app para aproveitar ainda mais
Prévia do material em texto
Programação Arduino Página | 1 Sumário: Estrutura • void setup ().............................................5 • void loop ()...............................................5 Estruturas de controle • if............................................................6 • if...else...................................................7 • for..........................................................8 • switch case.............................................9 • while.....................................................10 • do... while..............................................10 • break.....................................................69 • continue.................................................11 • return.....................................................11 • goto.......................................................12 Elementos de sintaxe • ; (ponto e vírgula)...................................13 • {} (chaves).............................................13 • // (linha de comentário)...........................15 • /* */ (bloco de comentário)......................15 • #define..................................................16 • #include.................................................17 Operadores aritméticos • = (igualdade).........................................18 • + (adição)..............................................18 • - (subtração)..........................................18 • * (multiplicação).....................................18 • / (divisão)..............................................18 • % (resto da divisão)...............................19 Operadores de comparação • == (igual a)...........................................20 • != (diferente de).....................................20 • < (menor que).......................................20 • > (maior que)........................................20 • <= (menor ou igual a)............................20 • >= (maior ou igual a).............................20 Operadores booleanos • && (e)....................................................21 • || (ou)....................................................21 • ! (não)....................................................21 Operadores de bits • & (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 Operadores compostos ++ (incrementar).........................................28 - (decrementar)..........................................28 += (adição composta)..................................28 = (subtração composta)...............................28 *= (multiplicação composta)..........................28 = (divisão composta)...................................28 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. • HIGH | LOW...........................................29 • INPUT | OUTPUT....................................29 • true | false.............................................29 • Constantes inteiras.................................31 Tipos de dados Variáveis podem ser de vários tipos: • 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 • char()....................................................41 • byte()....................................................41 • int().......................................................41 • long()....................................................41 • float()....................................................42 Referência • Tabela ASCII..........................................42 Página | 3 Funções Entrada e saída digital • pinMode (pin, mode).....................................43 • digitalWrite (pin, value).................................44 • int digitalRead (pin).......................................45 Entrada e saída analógica • int analogRead (pin)......................................46 • analogWrite (pin, value) – PWM....................47 Entrada e saída avançada • shiftOut (dataPin, clockPin, bitOrder, value)....48 • unsigned long pulseIn (pin, value)...................49 Tempo • unsigned long millis()....................................50 • unsigned long micros()......................................50 • delay(ms)...........................................................51 • delayMicroseconds(μs)......................................52 Matemática • min (x, y).....................................................54 • max (x, y)..........................................................55 • abs (x).........................................................56 • constrain (x, a, b).........................................56 • map (value, fromLow, fromHigh, toLow, toHigh)............57 • pow (base, exponent)...................................58 • sq (x).................................................................58 • sqrt (x).........................................................58 Trigonometria • sin (rad).......................................................59 • cos (rad)......................................................59 • tan (rad)......................................................59 Números aleatórios • randomSeed (seed)...........................................60 • long random (max).......................................61 • long random (min, max)...................................61 Comunicação serial Usado para comunicação entre a placa Arduino e um computador ou outros dispositivos. Esta comunicação ocorre através dos conectores serial ou USB da placa Arduino e nos pinos digitais 0 (RX) e 1 (TX). Assim, se você utilizar estas funções não poderá utilizar os pinos 0 e 1 para entrada e saída digital. • Serial.begin (s nt Serial.available ()..........................................63 nt Serial.read ()................................................64 Serial.flush ().....................................................65 Serial.println (data).......................................68 • Serial.print (data)..........................................65 Página | 4 setup() A função setup() é chamada quando um programa pomeça a rodar. Use esta função para inicializar as sua variáveis, os modos dos pinos, declarar o uso de livrarias, etc. Esta função será executada apenas uma vez após a placa Arduino ser ligada ou ressetada. Exemplo int buttonPin = 3; void setup() { Serial.begin(9600); pinMode(buttonPin, INPUT); } void loop() { // ... } loop() Após criaruma fução setup() que declara os valores iniciais, a função loop() faz exatamente o que seu nome sugere, entra em looping (executa sempre o mesmo bloco de código), permitindo ao seu programa fazer mudanças e responder. Use esta função para controlar ativamente a placa Arduino. Exemplo int buttonPin = 3; // setup inicializa o serial e o pino do button (botão) void setup() { beginSerial(9600); pinMode(buttonPin, INPUT); } // loop checa o botão a cada vez, // e envia o serial se ele for pressionado void loop() { if (digitalRead(buttonPin) == HIGH) serialWrite('H'); else serialWrite('L'); delay(1000); } Página | 5 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 | 6 if / else if/else permite um controle maior sobre o fluxo de código do que a sentença if básica, tornando possível que múltiplos testes sejam agrupados. Por exemplo, 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. O código seria assim: if (pinFiveInput < 500) { // ação A } else { // ação B } else pode preceder outro teste if , e assim mltiplos testes, mutuamente exclusivos, podem ser realizados ao mesmo tempo. Cada teste precede o próximo até que um teste com vavlor verdadeiro é encontrado. 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. Se a nenhum teste é atribuido o valor verdadeiro o bloco que estiver no else sozinho é executado, se houver algum. Note que um bloco else if pode ser usado com ou sem um bloco else final. Um número ilimitado destes ramos else if é permitido. 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. Página | 7 sentença for Descrição A sentença for é utilizada para repetir um bloco de código delimitado por chaves. Um contador com incremento normalmente é usado para controlar e finalizar o loop. A sentença for é util para quanquer operação repetitiva, 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; condição; incremento) { //sentença(s); } A inicialização ocorre primeiro e apenas uma vez. Cada vez que o circuíto é executado a condição é verificada; se for verdadeira o bloco de código e o incremento são executados, e então a condição é testada novamente. Quando a condição se torna falsa o circuíto termina. Exemplo // Aumentar o brilho de um LED usando um pino PWM int PWMpin = 10; // um LED em série com um resisotr de 1kΩ no pino 10 void setup() { // nenhum setup é necessário } void loop() { for (int i=0; i <= 255; i++){ analogWrite(PWMpin, i); delay(10); } } 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, incluindo BASIC. Qualquer dos elementos do cabeçalho pode ser omitido, embora os ";" sejam necessários. Qualquer destes elementos também podem ser substituidos por qualquer sentença válida em C com varáveis não correlatas. Estes tipos não usuais de sentenças for as vezes podem ser a solucão para alguns problemas raros de programação. Página | 8 sentença switch / case Do mesmo modo que as sentenças if, as switch / case controlam o fluxo dos programas. Switch/case permite ao programador construir uma lista de "casos" dentro de um bloco delimitado por chaves. O programa checa cada caso com a 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. Se a sentença break não é encontrada após a execução do bloco de código selecionado por um dos "casos", então o programa vai continuar a checar por mais valores idênticos entre os "casos" restantes. Se uma sentença break é encontrada o código sai da estrutura do mesmo modo que em uma construção if/else if. Parâmetros • var - a variável para a qual você busca valores idênticos • default - se nenhuma outra condição for satisfeita o código que está no default é executado • break - sem o break a sentença switch vai continuar checando as outras sentenças case para quanquer outro possível valor idêntico. Se algum for encontrado será executado do mesmo modo, o que pode não ser o que você deseja. Break indica ao switch para parar de procurar por outros valores idênticos e sai da sentença switch. Exemplo switch (var) { case 1: //faça alguma coisa quando var == 1 break; // break is optional case 2: //faça alguma coisa quando == 2 break; default: // se nenhum valor for idêntico, faça o default // default é opcional } Página | 9 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. 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. Isto poderia ser o incremento de uma variável ou uma condição externa como o teste de um sensor. Syntax while(expressão){ // código } Parâmetrosexpressão - uma sentença boolena em C que possa ser verificada como verdadeira ou falsa Exemplo var = 0; while(var < 200){ // algum código que se repete 200 vezes var++; } do - while O do funciona da mesma maneira que o while loop, com a exceção de que a condição é testada no final do bloco de código. Enquanto no while, se a condição for falsa, o bloco de código não será executado, no do ele sempre será executado pelo menos uma vez. do { // bloco de código } while (condição); Exemplo do { delay(50); // espera para que os sensores se estabilizem x = readSensors(); // verifica o sensor } while (x < 100); Página | 10 continue continue é usado para saltar porções de código em blocos do, for, ou while. Ele força com que o código avance até o teste da condição saltando todo o demais. Exemplo for (x = 0; x < 255; x ++) { if (x > 40 && x < 120){ // criar saltos de execução continue; } digitalWrite(PWMpin, x); delay(50); } return Finaliza uma função e retorna um valor, se necessário. Sintaxe: return; return valor; // 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; else{ return 0; } } 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, uma brilhante idéia de programação return; // restante do bloco de código não funcional // este código nunca será executado } Página | 11 goto Transfere o fluxo do programa para um outro ponto etiquetado Sintaxe label: goto etiqueta; // envia o fluxo do programa para etiqueta Dica O uso do goto é desencorajado em programação C e inclusive alguns autores afirmam que o goto nunca é realmente necessário, mas usado com cautela pode simplificar alguns programas. 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. No entanto, há casos em que o goto pode ser útil e simplificar o código. 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. Exemplo for(byte r = 0; r < 255; r++){ for(byte g = 255; g > -1; g--){ for(byte b = 0; b < 255; b++){ if (analogRead(0) > 250){ goto bailout;} // more statements ... } } } bailout: Página | 12 ; ponto e vírgula Usada para terminar uma sentença. Exemplo int a = 13; Dica Esquecer de finalizar uma linha com ponto e vírgula causa um erro de compilação. O texto sobre o erro pode ser óbvio e se referir a um ponto e vírgula faltando, ou não. 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, precedendo a linha indicada pelo compilador. {} Chaves Chaves são uma parte essencial da linguagem de programação C. Elas são usadas em muitas construções diferentes, descritas abaixo, e isto pode algumas vezes ser confuso para iniciantes. Uma chave abrindo "{" deve sempre ser seguida por uma fechando "}". Frequentemente nos referimos a esta condição como equilibrio entre as chaves. A IDE (integrated development environment ou ambiente de desenvolvimento integrado) do Arduino inclui uma característica prática para checar o equilibrio das chaves. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que sua companheira lógica seja destacada. 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. Programadores principiantes e programadores vindos das linguagens C e do BASIC frequentemente consideram o uso das chaves confuso ou desalentador. Afinal as mesmas chaves substituem a sentença RETURN em uma subrotina(função), a sentença ENDIF em uma condicional e a sentença NEXT em um FOR. Por que o uso das chaves é tão variado, é 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. Inserte então alguns "ENTER" entre as chaves e comece a digitar o código. Agindo assim suas chaves nunca ficarão desequilibradas. Chaves desequilibradas causam erros de comilação bastante enigmáticos e que podem ser difíceis de rastrear em um programa longo. 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. Página | 13 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); for (inicialização; condição de término; 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 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. 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. O único propósito dos comentários são ajudar a entender (ou relembrar) como o programa funciona. Há dois modos diferentes de marcar uma linha como um comentário. Exemplo x = 5; // Esta é uma linha simples de comentário. Qualquer coisa depois das barras é um comentário // até o fim da linha /* este é um 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; /* mas outro bloco de comentário é inválido */ } // não esqueça de fechar o bloco de comentário, 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. 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, ou quando um programa apresenta erros de compilação cujas explicações são obscuras ou inúteis. Página | 15 #define #define é um componente muito útil da linguagem C que permite ao programador dar um nome a uma constatnte antes que o programa seja compilado. Constantes definidas no Arduino não ocupam espaço em memória no chip. O compilador substitui referêancias a estas constantes pelo valor definido no momento da compilação. Isto pode causar alguns efeitos indesejáveis se, por exemplo, um nome de constante que tenha sido defindo por um #define é incluido em alguma outra constante ou nome de variável. Neste caso o texto deve ser substituido pelo valor (ou texto) do #define. Em general, a palavra chave const é preferível para definir constatntes e deve ser usada ao invés de #deine. A sintaxe do #define na linguagem Arduino é a mesma da linguagem C: Sintaxe #define nomeDeConstante valor Verifique que o # é necessário. Exemplo #define ledPin 3 // O compilador vai substituir quanquer menção a ledPin pelo valor 3 no momento da compilação. 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. #define ledPin 3; // 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 #include #include é usado para incluiroutras bibliotecas no seu programa. Isto permite ao programador acessar um grande número de bibliotecas padrão da linguagem C (grupos de funções pré-definidas), e também à bibliotecas desenvolvidas especificamente para o Arduino. 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. Verifique que #include, de modo similar ao #define, não leva ponto e vírgula no final. Exemplo Este exemplo inclui uma biblioteca que é utilizada para armazenar dados na memória flash ao invés de na ram. Isto economiza espaço na ram para as necessidades de memória dinâmica e torna o uso de grandes tabelas mais prático. #include <avr/pgmspace.h> prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 , 9128, 0, 25764, 8456, 0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500}; = operador de designação (sinal de igual simples) Armazena o valor do que está à direita do sinal de igual na variável que está à esquerda. O sinal de igual simples na linguagem de programação C é chamdo operador de designação. Ele tem um significado diferente daquele utilizado em álgebra, no qual indica uma equação ou iguladade. 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. Exemplo int sensVal; // declera uma variavel do tipo inteiro com o nome de sensVal senVal = analogRead(0); // armazena o valor da voltagem (digitalizado) no pino analógico 0 em sensVal Dicas de programação A variável à esquerda necessita ser capaz de reter o valor que se quer armazenar. Se ela não for grande o suficiente o valor armazenado pode ser incorreto. Não confunda o operador de designação [ = ] (sinal de igual simples) com o operador de comparação [ == ] (sinal de igual duplo), que calcula quando duas expressões são iguais ou não. Página | 17 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 • 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 Operadores Booleanos Estes operadores podem ser usados dentro da condição em uma sentença if. && ("E" lógico) Verdadeiro apenas se os dois operandos forem verdadeiros, ou seja a primeira condição "e" a segunda forem verdadeiras, e.g. if (digitalRead(2) == 1 && digitalRead(3) == 1) { // ler dois interruptores // ... } é verdadeiro apenas se os dois interruptores estiverem fechados. || ("OU" lógico) Verdadeiro se algum dos operandos for verdadeiro, ou seja se a primeira "ou" a segunda condição for verdadeira e.g. if (x > 0 || y > 0) { // ... } é verdadeiro apenas se x ou y forem maiores que 0. ! (negação) Verdadeiro apenas se o operando for falso e.g. if (!x) { // ... } é verdadeiro apenas se x for falso (i.e. se x for igual a 0). Cuidado Certifique-se de não confundir o operador booleano "E" representado por "&&" e o operador lógico de bits "E" representado apenas por "&". Eles são animais completamente diferentes. Do mesmo modo não confunda o booleano "OU" representado por "||" e o operador lógico de bits "|". O operador lógico de bits "NÃO" representado por um "~" não se parece com o operadorbooleano "!", mas mesmo assim tenha certeza de estar usando o que você deseja. Exemplos if (a >= 10 && a <= 20){} // verdadeiro se a estiver entre 10 e 20 Página | 21 Operadores de bits AND (&), OR (|), XOR (^) Operadores de bits Os operadores de bits realizam cálculos ao nível de bits das variáveis. Eles ajudama resolver uma grande quantidade de problemas de programação. Muito do material abaixo é de um excelente tutorial sobre este tema que pode ser encontrado aqui. Operador de bits AND (&) O operador de bits AND (e) em C++ é um simples & usado entre duas outras expressões inteiras. 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, caso contrário é 0. Outro modo de expressar esta regra é: 0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 0 0 1 (operando1 & operando2) - resultado de retorno Em Arduino o tipo int (inteiro) é um valor de 16 bits, portanto usando & entre duas expressões int faz com que ocorram 16 operações AND simultâneas. Em um fragmento de código: int a = 92; // em binario: 0000000001011100 int b = 101; // em binario: 0000000001100101 int c = a & b; // resultado: 0000000001000100, ou 68 em decimal. Cada um dos 16 bits em a AND b são processados usando este operador, e todos os 16 bits resultantes são armazenados em c resultado o valor 0000000001000100, que é 68 na notação decimal. Um dos usos mais comuns do operador de bits AND é selecionar alguns bits de um valor inteiro, freqüentemente chamado de máscara. Veja o exemplo abaixo para um exemplo. Operador de bits OR (|) O operador de bits OR (ou) em C++ é o símbolo de barra vertical, |. 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, caso contrário é 0. Em outras palavras: 0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 1 (operando1 | operando2) - resultado de retorno Em um fragmento de código: int a = 92; // in binario: 0000000001011100 int b = 101; // in binario: 0000000001100101 int c = a | b; // resultado: 0000000001111101, ou 125 em decimal. Programa de Exemplo Um uso comum para os operadores de bits AND e OR é o que os programadores chamam Ler-Modificar- Escrever em uma porta. Em microcontroladores uma porta é um número de 8 bits que representa algo sobre a condição dos pinos. Escrevendo em um controle de porta todos os pinos de uma vez. PORTD é uma constante pré-construída que se refere aos estados de saída dos pinos digitais 0,1,2,3,4,5,6,7. Se há um 1 em algum dos bits, então este pino está em HIGH. (os pinos ainda precisam ser defindos como pinos de saída pelo comando pinMode()). Deste modo se escrevemos PORTD = B00110001; o que fazemos é colocar os pinos 2,3 e 7 em HIGH. Um efeito colateral é que mudamos o estado dos pinos 0 e 1 que são usados pelo Arduino na comunicação serial, ou seja, interferimos nesta comunicação. Página | 22 Nosso algoritmo para este programa deve: • Ler o PORTD e limpar somente os bits que queremos controlar (com o operador AND). • Combinar o valor modificado de PORTD com o novo valor dos pinos que queremos controlar (com o operador OR). int i; // variável do contador int j; void setup(){ DDRD = DDRD | B11111100; // marca a direcao dos bits para os pinos 2 a 7 deixando o 0 e o 1 intocados (xx | 00 == xx) // o mesmo que pinMode(pin, OUTPUT) para os pinos 2 a 7 Serial.begin(9600); } void loop(){ for (i=0; i<64; i++){ PORTD = PORTD & B00000011; // limpa os bits de 2 - 7, deixa os pinos 0 e 1 intocados (xx & 11 == xx) j = (i << 2); // desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0 e 1 PORTD = PORTD | j; // combina a informação da porta com a nova informação para os pinos dos LEDs Serial.println(PORTD, BIN); // debug para verificar a máscara delay(100); } } 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"). Este operador é escrito com o símbolo do acento circunflexo ^. O resultado desta operação é 1 se os dois bits de entrada forem diferentes, caso contrário retorna 0: 0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 0 (operando1 ^ operando2) - resultado de retorno Um simpples código de exemplo: int x = 12; // binario: 1100 int y = 10; // binario: 1010 int z = x ^ y; // binario: 0110, or decimal 6 O operador XOR é freqüentemente utilizado para inverter alguns dos bits de uma expressão inteira. Na máscara deste operador se há um 1 o bit correspondente é invertido, se há um zero o bit é mantido como está. Abaixo há um programa para piscar o pino digital 5. // Piscar_Pino_5 // demonstração para o Exclusive OR void setup(){ DDRD = DDRD | B00100000; // marca o pino digital 5 como saida. Serial.begin(9600); } Página | 23 void loop(){ PORTD = PORTD ^ B00100000; // inverte o bit 5 (digital pino 5), mantem os demais intocados. delay(100); } Operador de bits NOT (~) O operador de bits NOT (não) em C++ é o acento til do português ~. Diferente dos operadores & e | este operador é aplicado sobre apenas 1 operando e retorna o valor inverso de cada bit. Por exemplo: 0 1 operando1 ---------- 1 0 ~ operando1 int a = 103; // binario: 0000000001100111 int b = ~a; // binario: 1111111110011000 = -104 Talvez você se surpreenda ao ver um número negativo como resultado desta operação. Isto ocorre por que o bit mais elevado em uma variável int é chamdo de bi de sinal. Se este bit é 1 o número é negativo. Este modo de encodar positivos e negativos é chamado de complemento para dois. Mais informações na Wikipedia. De modo complementar, é interessante notar que para qualquer inteiro x, ~x é o mesmo que -x-1. As vezes, o bit de sinal em uma expressão inteira pode causar algumas surpresas indesejadas. Página | 24 desvio de bits para a esquerda (<<) e para a direita (>>) Há dois operadores de desvio de bits em C++: o de desvio para a esquerda << e o para a direita >>. Estes operadores fazem com que os bits no operando da esquerda sejam desviados o número especificado de bits no operando da direita. Sintaxe variavel << numero_de_bits variavel >> numero_de_bits Parâmetros variavel - (byte, int, long) numero_de_bits inteiro <= 32 Exemplo: int a = 5; // binario: 0000000000000101 int b = a << 3; // binario: 0000000000101000, ou 40 em decimal int c = b >> 3; // binario: 0000000000000101, ou de volta ao 5 como no inicio Quando você desvia para a esquerda um valor x um y número de bits (x<<Y) os bits mais a esquerda em x são perdidos: int a = 5; // binario: 0000000000000101 int b = a << 14; // binario: 0100000000000000 - o primeiro 1 em 101 é descartado Se você tem certeza de que nenhum dos 1 em um valor vai ser deviado para fora do espaço , um modo simples de pensar no operador para a esquerda é que ele multiplica o operando da direita por 2 elevado ao operador da esquerda. Por exemplo para gerar potências de 2 as segintes expressões podem ser utilizadas: 1 << 0 == 1 1 << 1 == 2 1 << 2 == 4 1 << 3 == 8 ... 1 << 8 == 256 1 << 9 == 512 1 << 10 == 1024 ... Quando você desvia para a direita um valor x um y número de bits (x>>y), o comportamento depende do tipo de dados de x. Se x é do tipo int, o bit mais elevado é o bit de sinal que determina se x é negativo ou não. Neste caso o bit do sinal é copiado para os bits inferiores por razões históricas esotéricas: int x = -16; // binario: 1111111111110000 int y = x >> 3; // binario: 1111111111111110 Este comportamento é chamado extensão do sinal e freqüentemente não é o comportamento desejado. Entretanto, você pode desejar desviar preenchendo o espaço com zeros. 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; // binario: 1111111111110000 int y = (unsignedint)x >> 3; // binario: 0001111111111110 Se você for cauteloso em evitar a extensão do sinal, você pode usar o operador de desvio para a direita >> como um modo de dividir um número por potências de 2. Por exemplo: int x = 1000; int y = x >> 3; // divisão inteira de 1000 por 8, resultado y=125. Página | 25 operadores de bits compostos AND (&=) e OR (|=) Os operadores de bits compostos realizam seus cálculos no nível de bit das variáveis. São freqüentemente utilizados para limpar ou marcar bits específicos. Veja o operador de bits AND(&) e o operador de bits OR(|) para detalhes sobre seu funcionamento. 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. Sintaxe: x &= y; // equivalente a x = x & y; Parâmetros: x: uma variável do tipo char, int ou long y: uma constante do tipo char, int, ou long Exemplo: Primeiro, uma revisão do operador de bits AND (&) 0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 0 0 1 (operando1 & operando2) - resultado de retorno Bits que passam pelo operador AND um operando 0 são limpados para 0. Posrtanto se myByte é uma variável do tipo byte myByte & B00000000 = 0. Bits que passam pelo operador AND com um operando 1 se matém como estão. Portanto myByte & B11111111 = myByte. 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 variável 1 1 1 1 1 1 0 0 máscara ---------------------- 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 variável 1 1 1 1 1 1 0 0 máscara ---------------------- x x x x x x 0 0 Página | 26 variável não modificada bits limpos portato se: myByte = 10101010; myByte &= B1111100 == B10101000; 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. Sintaxe: x |= y; // equivalente a x = x | y; Parâmetros x: uma variável do tipo char, int ou long y: uma constante do tipo char, int, ou long Exemplo: First, a review of the Bitwise OR (|) operator 0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 1 (operando1 | operando2) - resultado de retorno Bits que passam pelo operador OR com um operando 0 são mantidos como estão, portanto se myByte é uma variável tipo byte, myByte | B00000000 = myByte; Bytes que passam pelo operador OR com um operando 1 são marcados com 1: myByte & B11111111 = B11111111; 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 variável 0 0 0 0 0 0 1 1 máscara ---------------------- 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 variável 0 0 0 0 0 0 1 1 máscara ---------------------- x x x x x x 1 1 variiável não modificada bits alterados So if: myByte = B10101010; myByte |= B00000011 == B10101011; Página | 27 ++ (incremento) / -- (decremento) Descrição Incrementar ou decrementar uma variável (adcionar ou subtrair 1) Sintaxe x++; // incrementa x em 1 e retorna o antigo valor de x ++x; // incrementa x em 1 e retorna o novo vaor de x x-- ; // decrementa x em 1 e retorna o antigo valor de x --x ; // decrementa x em 1 e retorna o novo valor de x 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. Exemplos x = 2; y = ++x; // x agora contém 3, y contém 3 y = x--; // x contém 2 de novo, y ainda contém 3 += , -= , *= , /= Descrição Realiza uma operação matemática em uma variável com outra constante ou variável. 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 + y; x -= y; // equivalente à expressão x = x - y; x *= y; // equivalente à expressão x = x * y; x /= y; // equivalente à expressão x = x / y; Parâmetros x: qualquer tipo de variável y: qualquer tipo de variável ou constante Exemplos x = 2; x += 4; // x agora contém 6 x -= 3; // x agora contém 3 x *= 10; // x agora contém 30 x /= 2; // x agora contém 15 Página | 28 Constantes Constantes são variáveis pre-definidas na linguagem Arduino. Elas são usadas para tornar os programas mais facilmente legíveis. Nós classificamos as constantes em grupos. Definindo níveis lógicos, verdadeiro e falso (constantes booleanas) Há duas constantes usadas para representar verdade ou falsidade na linguagem Arduino: true (verdadeiro), e false (falso). false false é a mais simples das duas e é definida como 0 (zero). true true é frequentemente definida como 1, o que é correto, mas true tem uma definição mais ampla. Qualquer inteiro que não é zero é TRUE, emum modo booleano. Assim, -1, 2 e -200 são todos definidos como true. Note que true e false são digitadas com minúsculas diferente de HIGH, LOW, INPUT, e OUTPUT. Definindo níveis de pinos, HIGH e LOW Quando estamos lendo ou escrevendo em um pino digital há apenas dois valores que um pino pode ter: HIGH (alto) e LOW(baixo). HIGH O significado de HIGH (em referência a um pino) pode variar um pouco dependendo se este pino é uma entrada (INPUT) ou saída (OUTPUT). Quando um pino é configurado como INPUT com pinMode, e lido com um digitalRead, o microcontrolador considera como HIGH se a voltagem for de 3 volts ou mais. Um pino também pode ser configurado como um INPUT com o pinMode, e posteriormente receber um HIGH com um digitalWrite, isto vai "levantar" o resistor interno de 20KΩ que vai manter a leitura do pino como HIGH a não ser que ela seja alterada para low por um circuíto externo. Quando um pino é configurado como OUTPUT com o pinMode, e marcado como HIGH com o digitalWrite, ele está a 5 volts. Neste estado ele pode enviar corrente como por exemplo acender um LED que está conectado com um resistor em série ao terra, ou a outro pino configurado como OUTPUT e marcado como LOW. LOW O significado de LOW também pode variar dependendo do pino ser marcado como INPUT ou OUTPUT. QUando um pino é configurado como um INPUT com o pinMode, e lido com o digitalRead, o microcontrolador considera como LOW se a voltagem for de 2 volts ou menos. Quando um pino é configurado como OUTPUT com pinMode, e marcado como LOW com o digitalWrite, ele está a 0 volts. Neste estado ele pode "drenar" corrente como por exemplo para acender um LED que está conectado com um resistor em série ao +5 volts, ou a outro pino configurado como OUTPUT e marcado como HIGH. Definindo pinos digitais, INPUT e OUTPUT Pinos digitais podem ser tanto de INPUT como de OUTPUT. Mudar um pino de INPUT para OUTPUT com pinMode() muda drasticamente o seu comportamento elétrico. Pinos configurados como Inputs Os pinos do Arduino (Atmega) configurados como INPUT com pinMode() estão em um estado de alta impedância. Um modo de explicar é que os pinos configurados como INPUT fazem demandas Página | 29 extremamente pequenas ao circuíto do qual estão tomando amostras, algo como um resistor de 100 Megaohms em série com o pino. Sendo assim é útil para ler um sensor mas não para energizar um LED. Pinos configurados como outputs Pinos configurados como OUTPUT com pinMode() estão em um estado de baixa impedância. Isto significa que eles podem fornecer grandes quantidades decorrente para outros circuítos. Os pinos do Atmega podem fornecer corrente positiva ou drenar corrente negativa até 40 mA (milliamperes) de/para outros dispositivos ou circuítos. Isto faz com que eles sejam úteis para energizar um LED mas disfuncionais para a leitura de sensores. Pinos configurados como outputs também podem ser danificados ou destruidos por curto-circuitos com o terra ou com outros pontos de 5 volts. A quantidade de corrente fornecida por um pino do Atmega também não é suficiente para ativar muitos relês e motores e, neste caso, algum circuíto de interface será necessário. Página | 30 Constantes inteiras Constantes inteiras são números usados diretamente no código. Por padrão estes números são tratatados como int's, mas você pode alterar este comportamento com os modificadores U e L (veja abaixo). Normalmente constantes inteiras são tratadas na base 10 (decimal), mas formatadores especiais podem ser usados para entrar números em outras bases. Base Exemplo Formatador Comentário 10 (decimal) 123 nenhum 2 (binário) B1111011 'B' inicial somente valores de 8 bits (0 a 255) caracteres válidos 0-1 8 (octal) 0173 '0' inicial caractres válidos: 0-7 16 (hexadecimal) 0x7B '0x' inicial caractres válidos: 0-9 A-F, a-f Decimal são na base 10. Esta é a matemática do senso comum com a qual você está acostumado. Constatntes sem outros prefixos são asumidas como decimais. 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). 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). 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; // entrada inválida myInt = (B11001100 * 256) + B10101010; // B11001100 é o primeiro byte e B10101010 o segundo Octais são na base oito. Apenas caracteres entre 0 e 7 são válidos. Valores octais são indicados pelo prefixo "0". Exemplo: 0101 // o mesmo que 65 decimal ((1 * 8^2) + (0 * 8^1) + 1) 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. Hexadecimais (ou hex) são na base 16. Caracteres válidos são de 0 a 9 e as letras de A a F; A vale 10, B vale 11 até F que vale 15. Valores hexadeciamis são indicados pelo prefixo "0x". Note A-F pode ser escrito tanto com maiusculas quanto com minúsculas (a-f). 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. Para especificar uma constante inteira com outro tipo de dado proceda assim: • um 'u' ou 'U' para forçar a constante como do tipo não assinalado (unsigned). Exemplo: 33u • um 'l' ou 'L' para forçar a constante como do tipo longo (long). Exemplo: 100000L • um 'ul' ou 'UL' para forçar a constante como do tipo longo não assinalado (unsigned long). Exemplo: 32767ul Página | 31 Variáveis booleanas * variáveis boolenas podem ter apenas dois valores verdadeiro (true) e falso (false). Exemplo int LEDpin = 5; // LED no pino 5 int switchPin = 13; // interruptor no, outro lado conectado ao terra. boolean running = false; void setup() { pinMode(LEDpin, OUTPUT); pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); // "levanta" o resistor } void loop() { if (digitalRead(switchPin) == LOW) { // interruptor é pressionado - resistor se mantém "levantado" delay(100); // espera para filtrar ruído da chave running = !running; // inverte o valor da variável running digitalWrite(LEDpin, running) // indica via LED } } * assim chamadas em homenagem a George Boole char Descrição Um tipo de dado que ocupa 1 byte de memória e armazena o valor de um caractere. Caracteres literais são escritos entre ' ' (em inglês estes caracteres se chamam single quotes, não consigo imaginar como possa ser em português) como este: 'A' (para cadeias de caracteres - strings - use aspas: "ABC"). Entretanto caracteres são armazenados como números. Você pode ver o código específico na tabela ASCII. Isto significa que é possível realizar operações artiméticas com caracteres, nos quais o valor ASCII do caractere é utilizado (e.g. 'A' + 1 vale 66, desde que o valor ASCII do A máiusculo é 65). Veja a referencia do Serial.println para mais informação de como os caracteres são traduzidos em números. O tipo de dado char é também do tipo assinalado, isso quer dizer que é possível codificar números de -128 a 127. Para um tipo de dado não assinalado de 1 byte (8 bits) use o tipo de dado byte. Exemplo char myChar = 'A'; char myChar = 65; // ambos são equivalentes Página | 32 byte Descrição Um byte armazena um número de 8 bits não assinalado, de 0 a 255. Exemplo byte b = B10010; // "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. Isto abrange a faixa de -32.768 a 32.767 (valor mínimo de -2^15 e valor máximo de (2^15) -1). Ints armazenam números negativos com uma técnica chamada Complemento para dois. O bit mais alto, as vezes chamado de bit de "sinal", e sinaliza se o número é positivo ou negatico. O Arduino cuida da manipulação de números nagativos para você, assim as operações aritméticas funcionam de modo transparente e esperado. Entretanto pode ocorrer uma complicação inesperada na manipulação operador para deslocar bits à direita (>>). Exemplo int ledPin = 13; Sintaxe int var = val; • var - o nome da variável int • val - 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. Note que isso ocorre nas duas direções. int x x = -32,768; x = x - 1; // x agora contém 32,767 - decaindo na direção negativa x = 32,767; x = x + 1; // x agora contém -32,768 - decaido Página | 33 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. Entretanto, ao invés de armazenar números negativos, armazenam somente valores positivos abrangendo a faixa de 0 a 65.535 ((2^16)-1). A diferença entre ints e ints não assinalados está no modo como o bit mais alto é interpretado.No Arduino o tipo int (que é assinalado), se o bit mais elevado é 1, o número é interpretado como negativo. Exemplo unsigned int ledPin = 13; Sintaxe unsigned int var = val; • var - nome da variável do tipo int não assinalado • 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. Note que isso ocorre nas duas direções. unsigned int x x = 0; x = x - 1; // x agora contém 65535 - decaindo na direção negatica x = x + 1; // x now contains 0 - decaindo long Descrição Variáveis do tipo Long têm um tamanho ampliado para armazenamento de números, e são capazes de armazenar 32 bits (4 bytes), de -2.147.483,648 a 2.147.483.647. Exemplo long speedOfLight = 186000L; // veja Constantes inteiras para a explicação do 'L' Sintaxe long var = val; • var - o nome da variável de tipo long • val - o valor designado para a variável Página | 34 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. Diferente dos longs padrão, os não assinalados não armazenam números negativos, abrangendo a faixade 0 a 4.294.967.295 (2^32 - 1). Exemplo unsigned long time; void setup() { Serial.begin(9600); } void loop() { Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa começou a rodar Serial.println(time); // espera um segundo de modo que o programa não envie quantidades absurdas de dados delay(1000); } Sintaxe unsigned long var = val; • var - o nome de sua variável tipo long • val - o valor designado para a variável Página | 35 float Descrição Tipo de dado para números de ponto flutuante, um número que tem um ponto decimal. 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. Números de ponto flutuante abrangem a faixa de 3,4028235E+38 a - 3,4028235E+38. Eles são armazenados em 32 bits (4 bytes) de informação. Números de ponto flutuante não são exatos e podem gerar resutados estranhos quando comparados. Por exemplo 6.0 / 3.0 pode não ser igua a 2.0. Você deve, em vez disso, verificar que o valor absoluto da diferença entre os números é menor que um valor pequeno pré-determinado. A matemática de ponto flutuante também é muito mais lenta que a dos inteiros na realização de cálculos, deve portanto ser evitada se, por exemplo, um loop tem que rodar a velocidade máxima para uma função em que o tempo é cr'tico. Programadares freqüentemente se esforçam para converter cálculos com pontos flutuantes em matemática de inteiros para aumentar a velocidade. Exemplos float myfloat; float sensorCalbrate = 1.117; Sintaxe float var = val; • var - o nome da sua variável de ponto flutuante • val - o valor designado para a variável Código de exemplo int x; int y; float z; x = 1; y = x / 2; // y agora contém 0, inteiros não suportam frações z = (float)x / 2.0; // z agora contém .5 (voce deve usar 2.0, não 2) Dica de programação Serial.println() trunca os floats (despreza as frações) em inteiros quando enviando comunicação serial. Multiplique por potências de 10 para preservar a resolução. Página | 36 double Descrição Número de ponto flutuante de precisão dupla. Ocupa 4 bytes. A implementação do double no Arduino é atualmente exatamente a mesma do float, sem ganho de precisão. 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. string Descrição Strings são representadas como arrays do tipo de dado char e terminadas por null (nulo). Exemplos Todos os seguintes são declarações válidas de strings. char Str1[15]; char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'}; char Str4[ ] = "arduino"; char Str5[8] = "arduino"; char Str6[15] = "arduino"; Possibilidades de declaração de strings • 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; 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). Isto permite às funções (como Serial.print()) saber onde está o final da string. De outro modo elas continuariam lendo os bytes subsequentes da memória que de fato não pertencem à string. Isto significa que sua string deve ter espaço para um caractere a mais do que o texto que ela contém. É por isso que Str2 e Str5 precisam ter 8 caracteres, embora "arduino" tenha apenas 7 - a última posição é automaticamente preenchida com o caracatere null. Str4 terá o tamanho determinado automaticamente como 8 caracteres, um extra para o null. Na Str3 nós incluimos explicitamente o caractere null (escrito como '\0'). Note que é possível ter uma string sem o caractere final null (e.g. se você tivesse especificado o tamanho da Str2 com sete ao invés de oito). Isto vai danificar a maioria das funções que usam strings, portanto você não deve fazer isso intencionalmente. Entretanto se você notar algo se comportando de maneira estranha (operações em caracteres que não pertencem à string) este poderia ser o problema. Aspas ou apóstrofos? Strings são sempre definidas com aspas ("Abc") e caracteres sempre definidos com apóstrofos('A'). Envolvendo strings longas Você pode envolver strings longas desse modo: Página | 37 char myString[] = "This is the first line" " this is the second line" " etcetera"; Arrays de strings Freqüentemente é conveniente, quando se está trabalhando com grandes quantidades de texto, como em um projeto com um display de LCD, configurar um array de strings. Devido ao fato de as strings serem elas mesmas arrays, este é de fato um exemplo de um array bi-dimencional. No código abaixo os asteriscos após o tipo de dado char "char*" indica que se trata de um array de "ponteiros". Todos os nomes de array são de fato ponteiros, e assim são requeridos para se configurar um array de arrays. Ponteiros são uma das partes mais esotéricas da linguagem C que os principiantes têm que entender, mas é necessário entender os ponteiros em detalhe para fazer um uso efetivo deles neste caso. Exemplo char* myStrings[]={"This is string 1", "This is string 2", "This is string 3", "This is string 4", "This is string 5","This is string 6"}; void setup(){ Serial.begin(9600); } void loop(){ for (int i = 0; i < 6; i++){ Serial.println(myStrings[i]); delay(500); } } Página | 38 Arrays Um array é uma coleção de variáveis que são acessadas com um índice numérico. Arrays na liguagem de programação C, na qual o Arduino é baseado, podem ser complicados, mas o uso de arrays simples é relativamente operacionalizável. Criando (Declarando) um Array Todos os métodos abaixo são modos válidos para criar (declarar) um array. int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = "hello"; Você pode declarar um array sem inicializar como em myInts. Em myPins declaramos um array sem escolher explicitamente um tamanho. O compilador conta os elementos e cria o array do tamanho apropriado. Finalmente, você pode inicializar e especificar o tamanho do array como em mySensVals. Note que quando declarar um array do tipo char, um elemento a mais é necessário para armazenar o caractere null de finalização. Acessando um Array Arrays são indexados a partir do zero, ou seja, fazendo referência à inicialização de arrays acima, o primeiro elemento do array está no índice 0, assim: mySensVals[0] == 2, mySensVals[1] == 4, e assim por diante. Isso também significa que em um array de 10 elementos o índice do último elemento é 9, assim: int myArray[10]={9,3,2,4,3,2,7,8,9,11}; // myArray[9] 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. 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. Ler destes locais provavelmente não vai gerar nada além de dados inválidos. Escrever em locais de memória aleatórios decididamente não é uma boa idéia, e provavelmente conduzirá a maus resultados como malfuncionamento ou travamento do programa. Isto também pode ser um bug difícil de rastrear. Diferente de algumas versões do BASIC, 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. Designar um valor para um array: mySensVals[0]= 10; Recuperar um valor de um array: x = mySensVals[4]; Arrays e FOR Arrays são freqüentemente manipulados dentro da sentença for, nas quais o contador é usado com índice para cada elemento. Por exemplo, para imprimir os elementos de um array através da porta serial você poderia fazer alguma coisa assim: int i; for (i = 0; i < 5; i = i + 1) { Serial.println(myPins[i]); } Página | 39 void A palavra-chave void é usada apenas em declarações de funções. Ela indica que a função não deve enviar nenhuma informação de retorno à função que a chamou. Exemplo: // ações são realizadas nas funções "setup" e "loop" // mas nenuma informação é enviada ao programa mais amplo void setup() { // ... } void loop() { // ... } Página | 40 char() Descrição Converte um valor para o tipo de dado char. 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 byte(x) Parâmetros x: um valor de qualquer tipo Retorno byte int() Descrição Converte um valor para o tipo de dado int. 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 long(x) Parâmetros x: um valor de qualquer tipo Retorno long Página | 41 float() Descrição Converte um valor para o tipo de dado float. 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. Ele é o modo padrão para codificar texto numericamente.* Note que os primeiros 32 caracteres (0-31) são caracteres não imprimíveis, também chamados de caracteres de controle. Os caracteres mais importantes foram nomeados na tabela abaixo: Valor Caractere Decimal 0 null 1 2 3 4 5 6 7 8 9 tab 10 line feed 11 12 13 carriage return 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 re Decimal ! 34 " 35 # & 39 ' 40 ( 41 , 45 - 46 . 47 2 51 3 52 4 56 8 57 9 61 = 62 > 63 Valor Caractere Decimal Valor Caractere Decimal 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ Valor Caractere Decimal Valor Caractere Decimal Valor Caractere Decimal 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 * Nota do tradutor: O código ASCII é um padrão para codificar texto numericamente e embora tenha muita importância histórica, vem sendo gradativamente substituido por padrões mais amplos como o UTF, em suas diversas variantes, e os conjuntos de caracteres (charset) definidos pela ISO (International Organization for Standardization). Página | 42 pinMode() Descrição Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma saída (output). Veja a descrição depinos digitais para mais detalhes. Sintaxe pinMode(pin, mode) Parâmetros pin: o número do pin o qual você deseja predeterminar. mode: pode ser INPUT ou OUTPUT Retorno Nenhum Exemplo int ledPin = 13; // LED conectado ao pino digital 13 void setup() { pinMode(ledPin, OUTPUT); // predetermina o pino digital como uma saída } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera um segundo digitalWrite(ledPin, LOW); // apaga o LED delay(1000); // espera um segundo } 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). Página | 43 digitalWrite() Descrição Escreve um valor HIGH ou um LOW em um pino digital. Se o pino foi configurado como uma saída (output) com o pinMode(), sua voltagem será determinada ao valor correspondente: 5V (ou 3.3V nas placas de 3.3V) para HIGH, 0V (terra) para LOW. Se o pino está configurado como uma entrada (input) escrever um HIGH levantará o resistor interno de 20KΩ (tutorial de pinos digitais). Escrever um LOW rebaixará o resistor. Sintaxw digitalWrite(pin, valor) Parâmetros pin: o número do pin valor: HIGH oo LOW Retorno nenhum Exemplo int ledPin = 13; // LED conectado ao pino digital 13 void setup() { pinMode(ledPin, OUTPUT); // determia o pino digital como uma saída } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera um segundo digitalWrite(ledPin, LOW); // apaga um led delay(1000); // espera um segundo } 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). Página | 44 digitalRead() Descrição Lê o valor de um pino digital especificado, HIGH ou LOW. 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; // LED conectado ao pino digital 13 int inPin = 7; // botão conectado ao pino digital 7 int val = 0; // variável para armazenar o valor lido void setup() { pinMode(ledPin, OUTPUT); // pré-determina o pino digital 13 como uma saída pinMode(inPin, INPUT); // pré-determina o pino dgital 7 como uma entrada } void loop() { val = digitalRead(inPin); // lê o pino de entrada digitalWrite(ledPin, val); // acende ou apaga o LED de acordo com o pino de entrada } Transfere para o pino 13 o valor lido no pino 7 que é uma entrada. Nota Se o pino não estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode variar aleatoriamente). 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). Página | 45 analogRead() Descrição Lê o valor de um pino analógico especificado. A placa Arduino contém um conversor analógico-digital de 10 bits com 6 canais (8 canais no Mini e no Nano). Com isto ele pode mapear voltagens de entrada entre 0 e 5 volts para valores inteiros entre 0 e 1023. Isto permite uma resolução entre leituras de 5 volts / 1024 unidades ou 0,0049 volts (4.9 mV) por unidade. São necessários aproximadamente 100 μs (0.0001 s) para ler uma entrada analógica, portanto a velocidade máxima de leitura é de aproximadamente 10.000 vezes por segundo. Sintaxe analogRead(pin) Parâmetros pin: o número do pino analógico que se deseja ler (0 a 5 na maioria das placas, 0 ta 7 no Mini e no Nano) Retorno int (0 a 1023) Note Se o pino 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.g. os valores de outras entradas analógicas, a distância de sua mão à placa, etc.). Na prática é um valor aleatório. Exemplo int analogPin = 3; // perna do meio de um potenciómetro conectada ao pino analógico 3 // pernas externas conectadas ao terra e ao +5V int val = 0; // variável para armazenar o valor lido void setup() { Serial.begin(9600); // inicial a comunicação serial } void loop() { val = analogRead(analogPin); // lê o pino de entrada Serial.println(val); // informa o valor lido } Página | 46 analogWrite() Descrição Escreve um valor analógico (onda PWM) em umpino. Pode ser usado para acender um LED variando o brilho ou girar um motor a velocidade variável. Depois de realizar um analogWrite(), 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). A freqüência do sinal PWM é de aproximadamente 490Hz. Nas novas placas Arduino (incluindo o Mini e o BT) com o chip ATmega168 esta função é eficiente nos pinos 3,5,6,9,10 e 11. Placas Arduino mais antigas com um ATmega8 suportam o analogWrite() apenas nos pinos 9,10 e 11. Sintaxe analogWrite(pin, valor) Parâmetros pin: o pino no qual se deseja escrever valor: o rendimento do ciclo: entre 0 (sempre desligado) e 255 (sempre ligado). Retorno nenhum Notas e problemas conhecidos Não é necessário realizar um pinMode() para pré-determinar o comportamento do pino como saída antes de realizar um analogWrite(). As saídas PWM geradas pelos pinos 5 e 6 terão rendimento de ciclo acima do esperado. Isto se deve às interações com as funções millis() e delay(), que compartilham o mesmo temporizador interno usado para gerar as saídas PWM. Exemplo Torna o brilho de um LED proporcional ao valor lido em um potenciómetro. int ledPin = 9; // LED conectado ao pino digital 9 int analogPin = 3; // potentiómetro conectado ao pino analógico 3 int val = 0; // variável para armazenar o valor lido void setup() { pinMode(ledPin, OUTPUT); // pré-determina o pino como saída } void loop() { val = analogRead(analogPin); // lê o pino de entrada analogWrite(ledPin, val / 4); // os valores do analogRead variam de 0 a 1023, os valores do analogWrite variam de 0 a 255 } Página | 47 shiftOut() Descrição Envia um byte para a saída um bit de cada vez. Pode começar tanto pelo bit mais significativo (mais à esquerda) quano pelo menos significativo (mais à direita). Os bits vão sendo escritos um de cada vez um pino de dados, em sincronia com as alterações de um pino de clock que indica que o próximo bit está disponível. Isto é conhecido como protocolo serial sincrônico e é um modo comumente usado para que os microcontroladores se comuniquem com sensores e com outros microcontroladores. Os dois sispositivos se mantêm sincronizados a velocidades próximas da máxima desde que ambos compartilhem a mesma linha de clock. Normamlemte esta característica é descrita comoSerial Peripheral Interface (SPI). na documentação dos chips. Sintaxe shiftOut(dataPin, clockPin, bitOrder, 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, pode ser MSBFIRST LSBFIRST. (Mais significativo primeiro ou menos significativo primeiro) value: a informação a enviar para a saída. (byte) Retorno Nenhum Note O dataPin e clockPin devem estar configurados como output pela função pinMode(). Exemplo Para o circuíto de referência deste exemplo veja tutorial on controlling a 74HC595 shift register. //**************************************************************// // Name : shiftOutCode, Hello World // // Author : Carlyn Maw,Tom Igoe // // Date : 25 Oct, 2006 // // Version : 1.0 // // Notes : Code for using a 74HC595 Shift Register // // : to count from 0 to 255 // //**************************************************************** //Pin connected to ST_CP of 74HC595 int latchPin = 8; //Pin connected to SH_CP of 74HC595 int clockPin = 12; ////Pin connected to DS of 74HC595 int dataPin = 11; void setup() { //set pins to output because they are addressed in the main loop pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } Página | 48 void loop() { //count up routine for (int j = 0; j < 256; j++) { //ground latchPin and hold low for as long as you are transmitting digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, j); //return the latch pin high to signal chip that it //no longer needs to listen for information digitalWrite(latchPin, HIGH); delay(1000); } } PulseIn() Descrição Lê um pulso (tanto HIGH como LOW) em um pino. Por exemplo, se valor for HIGH, pulseIn() espera que o pino vá paraHIGH, inicia a cronometragem, e então espera que o pino vá para LOW e para a cronometragem. Retorna a duração do pulso em microsegundos. Desiste e retorna 0 se nenhum pulso iniciar dentro de um tempo especificado. O tempo desta função foi determinado empiricamente e provavelmente dará erro em pulsos longos. Funciona com pulsos entre 10 microsegundos e 3 minutos. Syntaxe pulseIn(pino, valor) pulseIn(pino, valor, tempo) Parameters pino: o número do pino no qual você deseja ler o pulso. (int) valor: tipo de pulso a ler: tanto HIGH como LOW. (int) tempo (opcional): o número de microsegundos a esperar para que o pulso comece; 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; unsigned long duration; void setup() { pinMode(pin, INPUT); } void loop() { duration = pulseIn(pin, HIGH); } Página | 49 millis() Descrição Retorna o número de milisegundos desde que a placa Arduino começou a rodar o programa. Este número extrapolrá (voltará ao zero) depois de aproximamente 50 dias. Parâmetros Nenhum Retorno O número de milisegundos desde que o programa começou a rodar como um tipo longo não assinalado. Exemplo unsigned long time; void setup(){ Serial.begin(9600); } void loop(){ Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa começou Serial.println(time); // espera um segundo para não ficar enviando quantidades absurdas de dados delay(1000); } Dica: Verifique o retorno para o millis é um longo não assinalado. Erros podem ocorrer se um programador tentar realizar cálculos com outros tipos de dados, como inteiros. micros() Descrição Retorna o número de microsegundos desde que a placa Arduino começou a rodar o programa. Este número extrapolrá (voltará ao zero) depois de aproximamente 70 minutos. Nas placas Arduino de 16 MHz (e.g. Duemilanove e Nano), 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.g. LilyPad), esta função tem uma resolução de 8 microsegundos. Nota: em 1 milisegundo há 1.000 microsegundos e 1.000.000 de microsegundos em 1 segundo. Parâmetros Nenhum Retorno O número de microsegundos desde que o programa começou a rodar como um tipo longo não assinalado. Página | 50 Exempl0 unsigned long time; void setup() { Serial.begin(9600); } void loop() { Serial.print("Time: "); time = micros(); //imprime o tempo desde que o programa começou a rodar Serial.println(time); //espera um segundo para não ficar enviando quantidades absurdas de dados delay(1000); } delay(ms) Descrição Suspende a execução do programa pelo tempo (em milisegundos) especificado como parâmetro. (Em um segundo há 1.000 milisegundos.) Parâmetros ms (unsigned long): o número de milisegundos em que o programa ficará com a execução em suspenso. Retorno nenhum Exemplo int ledPin = 13; // LED conectado ao pino digital 13 void setup() { pinMode(ledPin, OUTPUT); // marca o pino digital como saída } void loop() { digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera por um segundo digitalWrite(ledPin, LOW); // apaga o LED delay(1000); // espera por um segundo } Cuidado Embora seja fácil criar um LED piscando com a função delay(), e muitos programas usam intervalos curtos para tarefas como a de filtrar ruídos, o uso do delay() em um programa tem aspectos negativos importantes. Nenhuma leitura de sensores, cálculo matemático, ou manipulação de pinos pode seguir durante a execução desta função, portanto muitas
Compartilhar