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
