35
arduino programação caderno Arduino Caderno de Programação Escrito e compilado por Brian W. Evans Com informações ou inspiração tomada de: http://www.arduino.cc http://www.wiring.org.co http://www.arduino.cc/en/Booklet/HomePage http://cslibrary.stanford.edu/101/ Material, incluindo escrito por : Paul Badger Massimo Banzi Hernando Barragán David Cuartielles Tom Igoe Daniel Jolliffe Todd Kurt David Mellis e outros publicado em: Primeira Edição agosto 2007 Segunda Edição setembro 2008 12c bao Esta obra está licenciada sob a Creative Commons Atribuição- Compartilhamento pela mesma licença 2.5 .

Arduino

Embed Size (px)

Citation preview

arduino

programação

caderno

Arduino Caderno de Programação

Escrito e compilado por Brian W. Evans

Com informações ou inspiração tomada de:

http://www.arduino.cc

http://www.wiring.org.co

http://www.arduino.cc/en/Booklet/HomePage

http://cslibrary.stanford.edu/101/

Material, incluindo escrito por :

Paul Badger

Massimo Banzi

Hernando Barragán

David Cuartielles

Tom Igoe

Daniel Jolliffe

Todd Kurt

David Mellis

e outros

publicado em:

Primeira Edição agosto 2007

Segunda Edição setembro 2008

12c bao

Esta obra está licenciada sob a Creative Commons

Atribuição- Compartilhamento pela mesma licença 2.5 .

Para ver uma cópia desta licença, visite:

http://creativecommons.org/licenses/by-sa/2.5/

Ou envie uma carta para:

Creative Commons

171 Second Street , Suite 300

San Francisco , Califórnia, 94105 , EUA

conteúdo

estrutura

estrutura 7

setup () 7

loop ( ) 7

funções 8

{} Chaves 8

, Vírgula 9

/ * ... * / Comentários bloco 9

/ / Linha comenta 9

variáveis

variáveis 10

declaração da variável 10

escopo de variáveis 11

tipos de dados

byte 12

int 12

longo 12

flutuador 12

13 matrizes

aritmética

aritmética 14

composto atribuições 14

operadores de comparação 15

operadores lógicos 15

constantes

constantes de 16

true / false 16

alto / baixo 16

input / output 16

controle de fluxo

se 17

if ... else 18

para 19

enquanto 20

fazer ... enquanto 20

Digital I / O

pinMode ( pin , mode) 21

digitalRead (pino ) 22

digitalWrite ( pin , value) 22

E / S analógica

analogRead (pino ) 23

analogWrite (pino , valor ) 23

tempo

delay ( ms ) 24

millis ( ) 24

matemática

min ( x , y ) 24

max ( x , y ) 24

acaso

randomSeed (semente) 25

random ( min, max) 25

serial

Serial.begin ( taxa ) 26

Serial.println ( dados ) 26

apêndice

saída digital 29

entrada digital 30

alta corrente de saída 31

saída PWM 32

entrada potenciômetro 33

entrada resistor variável 34

saída servo 35

prefácio

Isto serve como um computador portátil , fácil de utilizar referência programação conveniente para a estrutura de comando e de sintaxe básica do microcontrolador Arduino . Para mantê-lo simples , certas exclusões foram feitas que fazem essa referência de um novato melhor usado como uma fonte secundária ao lado de outros sites , livros , oficinas, ou classes . Esta decisão levou a uma ligeira ênfase no uso do Arduino para fins autônomos e , por exemplo, exclui os usos mais complexos de arrays ou formas avançadas de comunicação serial. Começando com a estrutura básica do C derivado linguagem de programação do Arduino , este notebook continua a descrever a sintaxe dos elementos mais comuns da língua e ilustra o seu uso com exemplos e fragmentos de código . Isto inclui muitas funções da biblioteca central seguido por um apêndice com esquemas de amostragem e os programas de arranque . O formato geral complementa O'Sullivan e Igoe da Computação , sempre que possível Física.

Para uma introdução ao Arduino e design interativo , consulte Banzi de Introdução ao Arduino , também conhecido como o Arduino Booklet . Para os corajosos poucos interessado nos meandros da programação em C, Kernighan e Ritchie The C Programming Language , segunda edição , bem como do Prinz e Crawford C em poucas palavras , fornecer algumas dicas sobre a sintaxe programação original .

Acima de tudo, este notebook não teria sido possível sem a grande comunidade de fabricantes de massa e corte de material original pode ser encontrada no site do Arduino , playground, e um fórum em http://www.arduino.cc .

estrutura | 7

estrutura

A estrutura básica da linguagem de programação Arduino é relativamente simples e é executado em pelo menos duas partes . Estas duas peças necessárias , ou funções , coloque blocos de instruções .

void setup ()

{

declarações ;

}

void loop ()

{

declarações ;

}

Onde setup () é a preparação , loop ( ) é a execução . Ambas as funções são necessários para que o programa funcione .

A função de configuração deve seguir a declaração de todas as variáveis no início do programa. É a primeira função a ser executada no programa, é executado apenas uma vez, e é usado para definir pinMode ou inicializar a comunicação serial.

A função loop segue próximo e inclui o código a ser executado de forma contínua - leitura de entradas , provocando saídas , etc Esta função é o núcleo de todos os programas do Arduino e faz a maior parte do trabalho .

setup ()

A função setup () é chamado uma vez quando o programa começa . Use-o para inicializar modos de pino , ou começar a série. Deve ser incluído em um programa, mesmo se não houver instruções a serem executadas .

void setup ()

{

pinMode ( pin , OUTPUT ) / / define o ' pin' como saída

}

loop ( )

Depois de chamar a função setup () , a função loop ( ) faz exatamente o que seu nome sugere, e loops consecutivamente , permitindo que o programa para mudar , responder e controlar a placa Arduino .

void loop ()

{

digitalWrite ( pin , HIGH) ; ' pin' / / voltas em

delay ( 1000) ; / / pausa por um segundo

digitalWrite ( pin , LOW ); ' pin' / / Desliga

delay ( 1000) ; / / pausa por um segundo

}

funções

Uma função é um bloco de código que tem um nome e um bloco de instruções que são executadas quando a função é chamada . As funções void setup () e void loop () já foram discutidas e outras funções built-in será discutido mais tarde .

As funções personalizadas podem ser escritas para realizar tarefas repetitivas e reduzir a desordem em um programa. As funções são declarados pela primeira declarando o tipo de função . Este é o tipo de valor a ser retornado pela função , como 'int' para uma função de tipo inteiro. Se nenhum valor deve ser devolvido o tipo de função seria nula . Após tipo , declarar o nome dado à função e entre parênteses qualquer parâmetro que está sendo passado para a função.

digite functionName ( parâmetros )

{

declarações ;

}

A seguinte função delayVal tipo inteiro () é usado para definir um valor de atraso em um programa de ler o valor de um potenciômetro. Primeiro, ele declara uma variável local v , v define o valor do potenciómetro que dá um número entre 0-1023 , depois divide esse valor por 4 para um valor final entre 0-255 , e finalmente retorna esse valor de volta para o programa principal .

int delayVal ( )

{

int v; / / cria variável 'v' temporário

v = analogRead (pote ) / / valor do potenciômetro ler

v / 4 = / / converte 0-1023 a 0-255

voltar v; / / retorna valor final

}

{} Chaves

Chaves ( também referida como apenas " chaves " ou " chaves ") definem o início eo fim de blocos de funções e blocos de instrução , como a void loop () e os para e se declarações.

tipo de função ()

{

declarações ;

}

Uma chave de abertura { deve ser sempre seguido por uma chave de fechamento } . Isso é muitas vezes referido como as chaves sendo equilibrado . Suspensórios desequilibradas muitas vezes pode levar a erros de compilador , impenetráveis enigmáticas que às vezes pode ser difícil de rastrear em um grande programa.

O ambiente Arduino inclui um recurso conveniente para verificar o saldo de chaves. Basta selecionar uma cinta , ou mesmo clique no ponto de inserção imediatamente após uma cinta, e seu companheiro lógico será destacado.

8 | estrutura

, ponto e vírgula

Um ponto e vírgula deve ser usada para acabar com uma declaração e elementos separados do programa. Um ponto e vírgula também é usada para separar elementos em um loop for .

int x = 13 / / declara variável 'x' como o inteiro 13

Nota: Esquecendo-se de acabar com uma linha em um ponto e vírgula irá resultar em um erro do compilador. O texto de erro pode ser óbvia, e se referem a um ponto e vírgula faltando, ou talvez não . Se um erro do compilador impenetrável ou aparentemente ilógico surge, uma das primeiras coisas a verificar é um ponto e vírgula em falta , perto da linha onde o compilador reclamou.

Comentários / * ... * / bloco

Bloqueie comentários ou comentários multi- linha , são áreas de texto ignorados pelo programa e são utilizados para grandes descrições de texto de código ou comentários que ajudam os outros a entender as partes do programa . Eles começam com / * e terminam com * / e pode abranger várias linhas .

/ * Isto é um comentário de bloco fechado

não se esqueça do comentário de fechamento -

eles têm que ser equilibrado !

* /

Como os comentários são ignorados pelo programa e não ter espaço de memória que deve ser utilizada com generosidade e também pode ser usado para "comentar " blocos de código para fins de depuração .

Nota: Embora seja possível para incluir comentários de linha única dentro de um bloco de comentário , colocando um segundo bloco de comentário não é permitido.

Comentários / / linha

Única linha comenta começam com / / e termina com a seguinte linha de código. Como blocos de comentários , eles serão ignorados pelo programa e não ter espaço de memória .

/ / Esta é uma única linha de comentário

Comentários de linha única são muitas vezes utilizados depois de uma declaração válida para fornecer mais informações sobre o que a declaração realiza ou para fornecer um lembrete futuro.

estrutura | 9

10 | variáveis

variáveis

Uma variável é uma forma de nomear e armazenar um valor numérico para uso posterior pelo programa. Como o seu xará sugere, as variáveis são números que podem ser continuamente alteradas ao contrário de constantes cujo valor nunca muda. Uma variável deverá ser declarada e, opcionalmente, o valor atribuído a necessidade de ser armazenado . O código a seguir declara uma variável chamada inputVariable e , em seguida, atribui o valor obtido no pino de entrada analógica 2:

int inputVariable = 0; / / declara uma variável e

/ / Atribui o valor de 0

inputVariable = analogRead (2); variável / / set para o valor de

/ / Pino analógico 2

' InputVariable ' é a própria variável. A primeira linha declara que ele irá conter um int , short para o número inteiro. A segunda linha define a variável com o valor no pino analógico 2. Isso faz com que o valor de pino 2 acessíveis em outras partes do código .

Uma vez que uma variável foi atribuído , ou re- atribuído , você pode testar o seu valor para ver se ele atende certas condições, ou você pode usar o seu valor diretamente. Como exemplo

para ilustrar três operações úteis com variáveis, os seguintes testes de código se o inputVariable é inferior a 100 , se for verdade que atribui o valor 100 a inputVariable , em seguida, define um atraso baseado em inputVariable que agora é um mínimo de 100:

if ( inputVariable <100) / / testa variável , se inferior a 100

{

inputVariable = 100 / / se verdadeiro atribui valor de 100

}

delay ( inputVariable ) / / utiliza como variável atraso

Nota: As variáveis devem receber nomes descritivos , para tornar o código mais legível. Nomes de variáveis como tiltSensor ou botão ajudar o programador e qualquer outra pessoa que leia o código para entender o que a variável representa. Os nomes das variáveis como var ou valor , por outro lado , pouco fazem para tornar o código legível e só são utilizados aqui como exemplos . Uma variável pode ser chamado de qualquer palavra que não é já uma das palavras-chave na linguagem Arduino .

declaração da variável

Todas as variáveis têm de ser declarado antes que eles possam ser utilizados . Declarar uma variável significa definir seu tipo de valor , como em int, long , float, etc , estabelecendo um nome especificado e, opcionalmente, a atribuição de um valor inicial. Isso só precisa ser feito uma vez em um programa, mas o valor pode ser alterado a qualquer momento usando a aritmética e várias atribuições .

O exemplo a seguir declara que inputVariable é um int, ou tipo inteiro , e que seu valor inicial igual a zero . Isso é chamado de atribuição simples .

int inputVariable = 0 ;

Uma variável pode ser declarada em vários locais ao longo do programa e onde esta definição ocorre determina quais partes do programa pode usar a variável .

escopo de variáveis

Uma variável pode ser declarada no início do programa , antes void setup () , localmente dentro de funções, e , por vezes, dentro de um bloco de declaração , como para loops. Quando a variável é declarada determina o alcance variável , ou a capacidade de certas partes de um programa para fazer uso da variável .

Uma variável global é aquele que pode ser visto e utilizado por cada função e instrução de um programa . Esta variável é declarado , no início do programa , antes da configuração da função ( ) .

Uma variável local é aquela que é definida dentro de uma função ou como parte de um loop for . Ele só é visível e só pode ser usado dentro da função em que foi declarada. Por

conseguinte, é possível ter duas ou mais variáveis do mesmo nome , em diferentes partes do mesmo programa , que contêm valores diferentes . A garantia de que apenas uma função tem acesso a suas variáveis simplifica o programa e reduz o potencial de erros de programação .

O exemplo a seguir mostra como declarar alguns tipos diferentes de variáveis e demonstra a visibilidade de cada variável :

valor int / / 'valor' é visível

/ / Para qualquer função

void setup ()

{

/ / Nenhuma configuração necessária

}

void loop ()

{

for (int i = 0; i < 20 ;) / / ' i' só é visível

{/ / Dentro do loop for

i + + ;

}

flutuar f / / 'f' só é visível

} / / Loop dentro

variáveis | 11

12 | tipos de dados

byte

Byte armazena um valor numérico de 8 bits , sem casas decimais. Eles têm uma gama de 0-255 .

byte someVariable = 180 / / declara ' someVariable '

/ / Como um tipo byte

int

Inteiros são o tipo de dados primário para o armazenamento de números sem pontos decimais e armazenar um valor de 16 bits com uma gama de 32.767 para 32.768 .

int someVariable = 1500 / / declara ' someVariable '

/ / Como um tipo integer

Nota: variáveis Integer vai rolar se forçado passado os limites máximos ou valores mínimos de uma atribuição ou comparação. Por exemplo, se x = 32767 e uma declaração posterior adiciona 1 para x, x = x + 1 ou x + +, x , então, capotamento e igual -32.768 .

longo

Prolongado tipo de dados de tamanho para inteiros longos , sem pontos decimais , armazenados em um valor de 32 bits com um intervalo de 2147483647 a -2147483648 .

longo someVariable = 90000 / / declara ' someVariable '

/ / Como um tipo long

flutuador

Um tipo de dados para números de ponto flutuante , ou números que têm um ponto decimal. Números de ponto flutuante têm maior resolução do que números inteiros e são armazenados como um valor de 32 bits com um intervalo de 38 a 3,4028235 3,4028235 +38.

flutuar someVariable = 3.14 / / declara ' someVariable '

/ / Como um tipo de ponto flutuante

Nota: Os números de ponto flutuante não são exatas , e podem produzir resultados estranhos quando comparados. Matemática de ponto flutuante também é muito mais lento do que matemática inteiro na realização de cálculos , por isso deve ser evitado , se possível.

matrizes

Uma matriz é um conjunto de valores que são acessados com um número de índice . Qualquer valor na matriz pode ser chamado chamando o nome da matriz eo número de índice do valor. Arrays são indexados a zero , com o primeiro valor na matriz começando no número de índice 0 . Uma matriz precisa de ser declarada e, opcionalmente, os valores atribuídos antes que eles possam ser utilizados .

int Matriz [ ] = { valor0 , valor1, valor2 ...}

Da mesma forma , é possível declarar uma matriz , declarando o tipo eo tamanho da matriz e, posteriormente, atribuir valores a uma posição de índice :

int Matriz [ 5] / / declara inteiro conjunto w / 6 posições

Matriz [ 3] = 10; / / atribui o quarto índice o valor 10

Para recuperar um valor de uma matriz, atribuir uma variável para a posição array e índice :

x = Matriz [ 3] / / x agora é igual a 10

As matrizes são muitas vezes utilizados em loops , onde o incremento do contador é também utilizado como o índice de posição para cada valor de matriz . O exemplo a seguir usa uma matriz para piscar um LED. Usando um loop for , o contador começa em 0, escreve o valor contido na posição de índice 0 no flicker array [ ] , neste caso 180, para o pino PWM 10 , faz uma pausa para 200ms , então se move para a próxima posição de índice.

int ledPin = 10 / / LED no pino 10

byte de cintilação [ ] = { 180 , 30 , 255 , 200 , 10 , 90 , 150 , 60 } ;

/ / Acima conjunto de 8

void setup () / / valores diferentes

{

pinMode ( ledPin , OUTPUT); pin / / configura SAÍDA

}

void loop ()

{

for (int i = 0; i < 7; i + +) / / loop é igual ao número

{/ / De valores na matriz

analogWrite ( ledPin , cintilação [i] ); valor do índice / / gravação

delay (200) ; 200ms / / pausa

}

}

tipos de dados | 13

14 | aritmética

aritmética

Operadores aritméticos incluem adição, subtração , multiplicação e divisão. Eles retornam a soma , diferença , produto ou quociente (respectivamente) de dois operandos.

y = y + 3;

x = x - 7;

i = j * 6;

r = r / 5 ;

A operação é realizada utilizando o tipo de dados dos operandos , por isso , por exemplo , 9/ 4 resultados em 2 em vez de 2,25 desde 9 e 4 são inteiros e são incapazes de usar pontos decimais. Isto também significa que a operação pode transbordar se o resultado é maior do que o que pode ser armazenado no tipo de dados .

Se os operandos são de diferentes tipos , o tipo maior é usado para o cálculo . Por exemplo , se um dos números ( operandos) são do tipo de flutuador e a outra do tipo inteiro , ponto flutuante matemática vai ser usado para o cálculo .

Escolha tamanhos variáveis que são grandes o suficiente para manter os maiores resultados de seus cálculos. Saiba em que ponto a variável vai rolar e também o que acontece no outro sentido , por exemplo (0 - 1) OU ( 0-32768 ) . Para matemática que requer frações , use variáveis de flutuação , mas esteja ciente de suas desvantagens: velocidades de grande porte e de computação lento.

Nota: Use o operador de conversão , por exemplo, (int) myFloat para converter um tipo de variável para outro em tempo real. Por exemplo , i = ( int ) 3,6 irá definir i igual a 3 .

atribuições compostos

Atribuições compostos combinam uma operação aritmética com uma atribuição de variável . Estes são comumente encontrados em loops , conforme descrito mais tarde. As atribuições de compostos mais comuns incluem:

x + + / / o mesmo que x = x + 1 , ou incrementos de x por um

x - / / o mesmo que x = x - 1, ou diminui x por -1

x + y = / / o mesmo que x = x + y , ou incrementos de x por y +

x - = y / / o mesmo que x = x - y, x ou diminui por -y

x * = y / / o mesmo que x = x * y , ou multiplica x por y

x / y = / / o mesmo que x = x / y , ou divide x por y

Nota: Por exemplo, x * = 3 triplicaria o valor antigo de x e re- atribuir o valor resultante para x .

operadores de comparação

Comparações de uma variável ou constante contra outro são muitas vezes utilizados em if para testar se uma condição especificada for verdadeira. Nos exemplos encontrados nas páginas seguintes , ? é utilizado para indicar qualquer uma das seguintes condições :

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 do que ou igual a y

operadores lógicos

Os operadores lógicos são geralmente uma maneira de comparar duas expressões e retornar VERDADEIRO ou FALSO, dependendo do operador. Existem três operadores lógicos , AND, OR e NOT , que são muitas vezes utilizados em if :

E lógico :

if ( x > 0 && x < 5) / / true somente se ambos

/ / Expressões são verdadeiras

Lógico OR:

if ( x > 0 | | y> 0) / / true se qualquer

/ / Expressão é verdadeira

NOT lógica:

if (! x > 0) / / true somente se

/ / Expressão é falsa

aritmética | 15

16 | constantes

constantes

A linguagem Arduino tem alguns valores pré-definidos , que são chamadas constantes. Eles são usados para tornar os programas mais fáceis de ler . Constantes são classificados em grupos .

true / false

Estes são constantes booleanas que definem níveis lógicos . FALSE é facilmente definido como 0 (zero ), enquanto TRUE é muitas vezes definido como 1, mas também pode ser qualquer outra coisa , exceto zero. Assim, em um sentido booleano , -1 , 2 e -200 são todos também definido como TRUE.

if ( b == TRUE);

{

doSomething ;

}

alta / baixa

Essas constantes definem níveis de pino alto ou baixo e são usados durante a leitura ou a escrita para os pinos digitais. ALTA é definida como nível lógico 1 , ON, ou 5 volts enquanto LOW é nível lógico 0 , OFF ou 0 volts.

digitalWrite (13, HIGH);

input / output

Constantes usadas com a função pinMode () para definir o modo de um pino digital como entrada ou saída .

pinMode (13, OUTPUT);

se

if testar se uma determinada condição for alcançada, como um valor analógico de ser acima de um determinado número, e executa todas as declarações dentro dos colchetes , se a afirmação é verdadeira . Se for falso o programa pula o comunicado. O formato para um caso de teste é :

if ( someVariable ? valor )

{

doSomething ;

}

O exemplo acima compara algumaVariavel para outro valor , o que pode ser uma variável ou constante . Se a comparação , ou condição entre parênteses for verdadeira, os comandos dentro dos colchetes são executados. Se não , o programa salta sobre eles e continua após os suportes .

Nota : Cuidado do uso acidental ' = ' , tal como no caso ( x = 10 ) , enquanto tecnicamente válida , define a variável de x para o valor de 10 e , como resultado é sempre verdadeira . Em vez disso, use '==' , como em if ( x == 10), que só testa se x acontece para igualar o valor 10 ou não. Pense em '=' como " é igual a" oposição a '==' ser " é igual a" .

controle de fluxo | 17

if ... else

if ... else permite ' ou-ou ' decisões a serem tomadas . Por exemplo, se você quiser testar uma entrada digital, e fazer uma coisa se a entrada foi HIGH ou em vez fazer outra coisa se a entrada era baixa , você escreveria que desta forma:

if ( InputPin == HIGH)

{

doThingA ;

}

outro

{

doThingB ;

}

mais também pode preceder outro se teste, de modo que múltipla, testes mutuamente exclusivos pode ser executado ao mesmo tempo . É ainda possível ter um número ilimitado de esses ramos outro lugar. Lembre-se , porém, apenas um conjunto de declarações será executada de acordo com os testes de condição :

if ( InputPin <500 )

{

doThingA ;

}

else if ( InputPin > = 1000)

{

doThingB ;

}

outro

{

doThingC ;

}

Nota: Um comando if simplesmente testa se a condição dentro do parêntese é verdadeira ou falsa . Esta indicação pode ser qualquer instrução válida C , como no primeiro exemplo , se ( InputPin == ALTA ) . Neste exemplo, a instrução if somente verifica para ver se de fato a entrada especificada está no nível lógico alto , ou 5 v

18 | controle de fluxo

para

A instrução for é usado para repetir um bloco de instruções entre chaves de um determinado número de vezes . Um contador de incremento é freqüentemente usado para aumentar e terminar o loop. Há três partes, separadas por ponto e vírgula (;) , para o cabeçalho para loop:

for ( inicialização; condição ; expressão)

{

doSomething ;

}

A inicialização de uma variável local, ou o contador de incremento, acontece a primeira e única vez. Cada vez através do loop, a seguinte condição é testada. Se a condição for verdade, as seguintes declarações e expressão são executados e a condição é testada novamente. Quando a condição se torna falsa , o loop termina.

O exemplo a seguir inicia o inteiro i em 0, testa para ver se eu ainda é menor do que 20 e se for verdade, incrementos i em 1 e executa as instruções entre :

for (int i = 0; i < 20; i + +) / / declara i , os testes se menos

{/ / De 20, incrementos i por 1

digitalWrite (13, HIGH); / / vira pin 13 na

delay ( 250 ) / / faz uma pausa por 1 /4 segundo

digitalWrite (13, LOW) ; / / vira pin 13 off

delay ( 250 ) / / faz uma pausa por 1 /4 segundo

}

Nota: A C loop for é muito mais flexível do que loops encontrados em algumas outras linguagens de computador , incluindo BASIC. Qualquer um ou todos os três elementos de cabeçalho pode ser omitida , embora sejam necessárias a ponto e vírgula . Também as declarações para a inicialização , condição e expressão pode ser quaisquer declarações válidas C e as variáveis independentes . Estes tipos de incomum para declarações podem fornecer soluções para alguns problemas de programação raras.

controle de fluxo | 19

enquanto

while irá repetir continuamente e infinitamente , até que a expressão dentro dos parênteses se torna falsa . Algo precisa mudar a variável testada , ou o loop while nunca vai sair. Isso poderia ser em seu código , como uma variável incrementado , ou uma condição externa , tais como teste de um sensor.

while ( ? valor someVariable )

{

doSomething ;

}

Os testes a seguir exemplo, se ' someVariable ' é inferior a 200 e se for verdade executa os comandos dentro dos colchetes e continuará até looping ' someVariable ' não é mais menos de 200.

enquanto ( SomeVariable <200 ) / / testa se a menos de 200

{

declarações / / executa fechados; doSomething

someVariable + + / / Incrementa a variável em 1

}

do ... while

O circuito do é um laço inferior impulsionada que funciona da mesma maneira que o circuito , enquanto , com a excepção de que a condição é testada no final do ciclo, de modo a fazer circular irá sempre executar pelo menos uma vez .

fazer

{

doSomething ;

} While ( valor someVariable ? );

O exemplo a seguir atribui readSensors () para a variável ' x', faz uma pausa por 50 milésimos de segundo, em seguida, faz um loop indefinidamente até que 'x' não é mais menos de 100:

fazer

{

x = readSensors () / / atribui o valor de

/ / ReadSensors ( ) ax

delay ( 50 ) / / faz uma pausa de 50 milissegundos

} Enquanto ( x < 100 ) / / lacetes se x é inferior a 100

20 | controle de fluxo

E / S Digital | 21

pinMode ( pin , mode)

Usado em void setup () para configurar um pino especificado se comportar tanto como uma entrada ou uma saída .

pinMode ( pin , OUTPUT); ' pin' / / configura a saída

Pinos digitais do Arduino padrão para entradas , para que eles não precisam ser explicitamente declarados como entradas com pinMode (). Pinos configurados como entrada estão a ser dito em um estado de alta impedância .

Existem também resistências de pull-up 20KΩ conveniente construídas no chip Atmega que pode ser acessado a partir de software. Estes resistores pull-up internos são acessados da seguinte forma :

pinMode ( pin , INPUT ); / / set ' pin ' para entrada

digitalWrite ( pin , HIGH) ; / / ligue resistores de pull-up

Resistores Pullup seria normalmente utilizado para conectar insumos como switches. Observe no exemplo acima que não converte o pino para uma saída , é apenas um método para ativar os internos pull-ups .

Pinos configurados como OUTPUT estão a ser dito em um estado de baixa impedância e pode fornecer 40 mA ( miliamperes ) de corrente para outros dispositivos / circuitos . Este é corrente suficiente para brilhantemente luz um LED ( não se esqueça do resistor em série ) , mas não o suficiente atual para executar a maioria dos relés, solenóides, ou motores .

Curto-circuitos nos pinos do Arduino e corrente excessiva pode danificar ou destruir o pino de saída , ou danificar todo o chip Atmega . Muitas vezes, é uma boa idéia para conectar um pino de saída para um dispositivo externo em série com um resistor de 470Ω ou 1k .

digitalRead (pino )

Lê o valor de um pino digital especificado com o resultado de alto ou baixo . O pino pode ser especificado como uma variável ou constante ( 0-13 ) .

valor = digitalRead (Pin ), ' valor' / / configura igual a

/ / O pino de entrada

digitalWrite ( pin , value)

Saídas ou nível lógico HIGH ou LOW em ( liga ou desliga ) um pino digital especificado. O pino pode ser especificado como uma variável ou constante ( 0-13 ) .

digitalWrite ( pin , HIGH) ; ' pin' / / configura a alta

O exemplo a seguir lê um botão ligado a uma entrada digital e acende um LED conectado a uma saída digital quando o botão foi pressionado :

int levou = 13 / / conectar LED ao pino 13

int pin = 7; / / conecta botão ao pino 7

int valor = 0; / / variável para armazenar o valor de leitura

void setup ()

{

pinMode (liderada , OUTPUT) ; / / configura o pino 13 como saída

pinMode ( pin , INPUT ) / / define o pino 7 como entrada

}

void loop ()

{

valor = digitalRead (pino ); ' valor' / / configura igual a

/ / O pino de entrada

digitalWrite ( led, value); / / configura ' levou ' para o

} / / O valor do botão

22 | E / S Digital

E / S analógica | 23

analogRead (pino )

Lê o valor de um pino analógico especificado com uma resolução de 10 bits. Esta função só funciona com o analógico em pinos (0-5) . Os valores inteiros resultantes variam de 0 a 1023.

valor = analogRead (pino ); / / configura ' valor' igual a ' pin'

Nota: pinos analógicos , ao contrário os digitais , não precisam ser declarados pela primeira vez como entrada ou OUTPUT.

analogWrite (pino , valor )

Grava um valor pseudo- analógica usando hardware habilitado modulação de largura de pulso (PWM) para um pino de saída marcado PWM . Em Arduinos mais recentes com o chip ATmega168 , essa função funciona nos pinos 3, 5, 6, 9 , 10 e 11. Arduinos mais velhos com uma ATmega8 suportam apenas pinos 9, 10 e 11. O valor pode ser especificado como uma variável ou constante com um valor entre 0-255 .

analogWrite (pino , valor ); / / escreve ' valor' para analógico ' pin'

Um valor de 0 gera uma saída constante de 0 volts no pino especificado , um valor de 255 gera uma saída constante de 5 volts no pino especificado . Para valores entre 0 e 255 , o pino alterna rapidamente entre 0 e 5 volts - quanto maior for o valor, mais frequentemente o pino é ALTO ( 5 volts ) . Por exemplo , um valor de 64 0 volts será de três quartos do tempo , e 5 volts quarto do tempo , um valor de 128 será em metade do tempo 0 e 255 da metade do tempo , e um valor de 192 vai ser 0 volts quarto do tempo e 5 volts três quartos do tempo.

Porque esta é uma função de hardware, o pino irá gerar uma onda constante após uma chamada para analogWrite em segundo plano até a próxima chamada para analogWrite ( ou uma chamada para digitalRead ou digitalWrite no mesmo pino ) .

Nota: pinos analógicos , ao contrário os digitais , não precisam ser declarados pela primeira vez como entrada ou OUTPUT.

O exemplo a seguir lê um valor analógico de um pino de entrada analógico , converte o valor de divisão por quatro , e gera um sinal PWM para um pino de PWM :

int levou = 10 / / LED com 220 resistor no pino 10

int pin = 0; / / potenciômetro no pino analógico 0

valor int / / valor para a leitura

void setup () { } / / nenhuma configuração necessária

void loop ()

{

valor = analogRead (pino ); / / configura ' valor' igual a ' pin'

valor / = 4 / / converte para 0-1023 0-255

analogWrite (liderada , value) ; sinal PWM / / imprime a levou

}

delay ( ms )

Pausa um programa para a quantidade de tempo , conforme especificado em milissegundos , onde 1000 é igual a 1 segundo.

delay (1000 ) / / aguarda um segundo

millis ()

Retorna o número de milissegundos desde a placa Arduino começou a executar o programa atual como um valor a longo sem sinal.

valor = millis (); / / configura ' valor' igual a millis ()

Nota: Este número vai transbordar (reset de volta para zero), depois de cerca de 9 horas.

min ( x , y )

Calcula o mínimo de dois números de qualquer tipo de dados e devolve o número menor .

valor = min (valor, 100 ) / / sets ' valor ' para o menor dos

/ / ' Valor' ou 100 , garantindo que

/ / Ele nunca fica acima de 100.

max ( x , y )

Calcula o máximo de dois números de qualquer tipo de dados e retorna o número maior.

valor = max (valor, 100 ) / / sets ' valor ' para o maior dos

/ / ' Valor' ou 100 , garantindo que

/ / Ele é de pelo menos 100 .

24 | tempo e matemática

randomSeed (semente)

Define um valor , ou semente, como o ponto de partida para a função random () .

randomSeed (valor) ; / / configura ' valor' como a semente aleatória

Como o Arduino é capaz de criar um número verdadeiramente aleatório , randomSeed permite que você coloque uma variável , constante ou outra função para a função aleatória , o que ajuda a gerar mais números aleatórios "aleatórios" . Há uma variedade de diferentes sementes , ou funções , que podem ser usados nesta função , incluindo millis ( ) ou mesmo analogRead ( ) para ler o ruído eléctrico por meio de um pino analógico .

random ( max)

random ( min, max)

A função de reprodução aleatória permite que você retorne números pseudo-aleatórios dentro de um intervalo especificado pelos valores mínimo e máximo .

valor = random (100, 200); ' valor' / / sets a um aleatório

/ / Número entre 100-200

Nota : Utilize este depois de usar o randomSeed () função.

O exemplo a seguir cria um valor aleatório entre 0-255 e emite um sinal PWM em um pino PWM igual ao valor aleatório :

int randNumber / / variável para armazenar o valor aleatório

int levou = 10 / / LED com 220 resistor no pino 10

void setup () { } / / nenhuma configuração necessária

void loop ()

{

randomSeed ( millis ()) / / define millis () como semente

randNumber = random (255 ) / / número aleatório 0-255

analogWrite (liderada , randNumber ); sinal PWM / / imprime

delay (500 ) / / pausas para meio segundo

}

aleatório | 25

Serial.begin ( taxa )

Abre a porta serial e define a taxa de transmissão para a transmissão de dados serial. A taxa de transmissão típico para se comunicar com o computador é de 9600 , embora outras velocidades são suportadas.

void setup ()

{

Serial.begin (9600 ) / / abre a porta serial

} / / Define a taxa de dados de 9600 bps

Nota: Ao utilizar a comunicação serial, pinos digitais 0 (RX ) e 1 ( TX ) não podem ser usados ao mesmo tempo.

Serial.println ( dados )

Imprime os dados para a porta serial , seguido por um retorno de carro automático e alimentação de linha . Este comando assume a mesma forma que Serial.print (), mas é mais fácil para a leitura de dados no Monitor de série .

Serial.println ( analogValue ) / / envia o valor de

/ / ' AnalogValue '

Nota: Para mais informações sobre as diversas permutações da Serial.println () e Serial.print () funções por favor consulte o site do Arduino .

O seguinte exemplo simples faz uma leitura de Pin0 analógico e envia esses dados para o computador de cada 1 segundo.

void setup ()

{

Serial.begin (9600 ) / / define serial para 9600 bps

}

void loop ()

{

Serial.println ( analogRead (0) ) / / envia valor analógico

delay (1000 ) / / faz uma pausa durante 1 segundo

}

26 | série

apêndice

saída digital

Este é o programa básico 'Olá mundo ' usado para simplesmente transformar algo ligado ou desligado. Neste exemplo , um diodo emissor de luz é ligado ao pin13 , e é piscar a cada segundo . A resistência pode ser omitido neste pino uma vez que o Arduino tem um construído dentro

int ledPin = 13 / / LED no pino digital 13

void setup () / / executado uma vez

{

pinMode ( ledPin , OUTPUT ) / / define o pino 13 como saída

}

void loop () / / executar uma e outra vez

{

digitalWrite ( ledPin , HIGH) ; / / transforma o LED

delay (1000 ) / / faz uma pausa durante 1 segundo

digitalWrite ( ledPin , LOW ); / / transforma o LED desligado

delay (1000 ) / / faz uma pausa durante 1 segundo

} Apêndice | 29

entrada digital

Esta é a forma mais simples de entrada com apenas dois estados possíveis : ligado ou desligado. Este exemplo lê um simples interruptor ou botão conectado a pin2 . Quando a chave é fechada o pino de entrada lerá ALTA e ligar um LED.

int ledPin = 13 ; pin / / saída para o LED

int inPin = 2 / / pino de entrada (para um switch)

void setup ()

{

pinMode ( ledPin , OUTPUT); / / declara LED como saída

pinMode ( inPin , INPUT ); / / switch declarar como entrada

}

void loop ()

{

if ( digitalRead ( inPin ) == HIGH) / / verifica se a entrada for ALTA

{

digitalWrite ( ledPin , HIGH) ; / / transforma o LED

delay ( 1000) ; / / pause por 1 segundo

digitalWrite ( ledPin , LOW ); / / transforma o LED desligado

delay ( 1000) ; / / pause por 1 segundo

}

}

30 | apêndice

alta corrente de saída

Por vezes, é necessário para controlar mais do que 40 mA a partir do Arduino . Neste caso, um transistor MOSFET ou poderia ser utilizado para exibir altas cargas de corrente . O exemplo a seguir transforma rapidamente dentro e fora do MOSFET 5 vezes a cada segundo.

Nota : O esquema mostra um diodo de motor e de protecção, mas as outras cargas indutivas não pode ser utilizado sem o diodo .

int outPin = 5 / / pino de saída para o MOSFET

void setup ()

{

pinMode ( outPin , OUTPUT ) / / define pin5 como saída

}

void loop ()

{

for (int i = 0; i < = 5; i + +) / / loops de 5 vezes

{

digitalWrite ( outPin , HIGH) ; / / transforma em MOSFET

delay ( 250); / / pausa 1 /4 segundo

digitalWrite ( outPin , LOW ); / / transforma MOSFET off

delay ( 250); / / pausa 1 /4 segundo

}

delay (1000 ) / / faz uma pausa um segundo

}

apêndice | 31

saída PWM

Pulsewidth Modulation ( PWM) é uma maneira de falsificar uma saída analógica pulsando a saída . Isto poderia ser usado para diminuir e iluminar um LED ou mais tarde para controlar um servo-motor . O exemplo a seguir lentamente clareia e escurece um LED usando loops .

int ledPin = 9; / / pin PWM para o LED

void setup () { } / / nenhuma configuração necessária

void loop ()

{

for (int i = 0; i < = 255 ; i + +) / / Valor de ascendente para i

{

analogWrite ( ledPin , i); / / configura Brightess nível para i

delay (100); / / pausas para 100ms

}

for (int i = 255; i> = 0; i - ) / / descendente valor para i

{

analogWrite ( ledPin , i); / / configura Brightess nível para i

delay (100); / / pausas para 100ms

}

}

32 | apêndice

entrada potenciômetro

Usando um potenciômetro e um de analógico para digital conversão do Arduino (ADC) pinos , é possível ler os valores analógicos 0-1024 . O exemplo a seguir usa um potenciômetro para controlar a taxa de um LED de piscar.

int potPin = 0 / / pino de entrada para o potenciômetro

int ledPin = 13 ; pin / / saída para o LED

void setup ()

{

pinMode ( ledPin , OUTPUT); / / declara ledPin como OUTPUT

}

void loop ()

{

digitalWrite ( ledPin , HIGH) ; / / transforma em ledPin

delay ( analogRead ( potPin ) ); programa / / pausa

digitalWrite ( ledPin , LOW ); / / transforma ledPin off

delay ( analogRead ( potPin ) ); programa / / pausa

} Apêndice | 33

entrada resistor variável

Os resistores variáveis incluem sensores CdS luz, termistores , sensores de cabo flexível, e assim por diante . Este exemplo faz uso de uma função de ler o valor analógico e definir um tempo de atraso . Isto controla a velocidade com que um LED ilumina e escurece .

int ledPin = 9; / / pin PWM para o LED

int analogPin = 0; / / resistor variável no pino analógico 0

void setup () { } / / nenhuma configuração necessária

void loop ()

{

for (int i = 0; i < = 255 ; i + +) / / Valor de ascendente para i

{

analogWrite ( ledPin , i); / / configura Brightess nível para i

delay ( delayVal () ) / / recebe o valor do tempo e pausas

}

for (int i = 255; i> = 0; i - ) / / descendente valor para i

{

analogWrite ( ledPin , i); / / configura Brightess nível para i

delay ( delayVal () ) / / recebe o valor do tempo e pausas

}

}

int delayVal ( )

{

int v; / / cria variável temporária

v = analogRead ( analogPin ) / / ler o valor analógico

v / = 8; / / converter para 0-1024 0-128

voltar v / / retorna valor final

34 } | apêndice

saída do servo

Servos do passatempo são um tipo de motor auto-suficiente que pode mover-se em um arco de 180 º . Tudo que é necessário é um pulso enviado a cada 20ms . Este exemplo usa uma função servoPulse para mover o servo de 10 º -170 º e vice-versa .

int servoPin = 2; / / servo conectado ao pino digital 2

int MeuAngulo / / ângulo do servo aproximadamente 0-180

/ / variável de função servoPulse ; int pulsewidth

void setup ()

{

pinMode ( servoPin , OUTPUT ) / / define o pino 2 como saída

}

servoPulse void ( int servoPin , int MeuAngulo )

{

pulsewidth = ( MeuAngulo * 10) + 600 / / determina atraso

digitalWrite ( servoPin , HIGH) ; / / configura servo alta

delayMicroseconds ( Largura de Pulso ) / / microssegundo pausa

digitalWrite ( servoPin , LOW ); / / configura servo baixo

}

void loop ()

{

/ / Servo começa em 10 ° e roda de 170 graus

for ( MeuAngulo = 10; MeuAngulo < = 170 ; MeuAngulo + +)

{

servoPulse ( servoPin , MeuAngulo ) / / enviar pino eo ângulo

delay ( 20 ) / / ciclo de atualização

}

/ / Servo começa em 170 graus e gira a 10 graus

for ( MeuAngulo = 170 ; MeuAngulo > = 10; MeuAngulo -)

{

servoPulse ( servoPin , MeuAngulo ) / / enviar pino eo ângulo

delay ( 20 ) / / ciclo de atualização

}

}

apêndice | 35

Google Tradutor para empresas:Google Toolkit de tradução para appsTradutor de sitesGlobal Market Finder

Desativar tradução instantâneaSobre o Google TradutorCelularPrivacidadeAjudaEnv