Arduino comandos e outros

Prévia do material em texto

digitalRead ()
[Digital I / O]
Descrição
Lê o valor de um pino digital especificado, HIGHou LOW.
Sintaxe
digitalRead(pin)
Parâmetros
pin: o número do pino digital que você quer ler
Retorna
HIGH ou LOW
Exemplo de código
Define o pino 13 para o mesmo valor do pino 7, declarado como uma entrada.
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 de leitura
void setup ()
{
 pinMode (ledPin, OUTPUT); // define o pino digital 13 como saída
 pinMode (inPin, INPUT); // define o pino digital 7 como entrada
}
Void loop ()
{
 val = digitalRead (inPin); // le o pino de entrada
 digitalWrite (ledPin, val); // define o LED para o valor do botão
}
Notas e avisos
Se o pino não estiver conectado a nada, o digitalRead () pode retornar HIGH ou LOW (e isso pode mudar aleatoriamente).
Os pinos de entrada analógica podem ser usados ​​como pinos digitais, referidos como A0, A1, etc.
digitalWrite ()
[Digital I / O]
Descrição
HIGH=ALTO LOW=BAIXO
Escreva um HIGH ou um LOW valor para um pino digital.
Se o pino foi configurado como OUTPUT=saida com pinMode(), sua voltagem será ajustada para o valor correspondente: 5V (ou 3.3V em placas de 3.3V) para HIGH, 0V (terra) para LOW.
Se o pino estiver configurado como um INPUT=entrada, digitalWrite() ativará ( HIGH) ou desativará ( LOW) o pullup interno no pino de entrada. Recomenda-se a definir o pinMode()que INPUT_PULLUPpara habilitar o resistor interno pull-up. Veja o tutorial de pinos digitais para mais informações.
Se você não definir o pinMode()para OUTPUT, e conectar um LED a um pino, ao chamar digitalWrite(HIGH), o LED pode aparecer ofuscado. Sem definir explicitamente pinMode(), digitalWrite()terá habilitado o resistor de pull-up interno, que atua como um grande resistor limitador de corrente.
Sintaxe
digitalWrite(pin, value) value=valor
Parâmetros
pin: o número do pino
value=VALOR: HIGH ou LOW
Retorna
Nada
Exemplo de código
O código faz o pino digital 13 an OUTPUT=saida e alterna entre HIGHe LOWem um segundo passo.
void setup ()
{
 pinMode (13, OUTPUT); // define o pino digital 13 como saída
}
Void loop()
{
 digitalWrite (13, HIGH); // define o pino digital 13 como alto =ligado/ativado
 delay (1000); // espera por um segundo
 digitalWrite (13,LOW); // define o pino 13 como baixo =desligado/desativado
 delay(1000); // espera por um segundo
}
Notas e avisos
Os pinos de entrada analógica podem ser usados ​​como pinos digitais, referidos como A0, A1, etc.
pinMode ()
[Digital I / O]
Descrição
Configura o pino especificado para se comportar como entrada ou saída. Veja a descrição de ( pinos digitais ) para detalhes sobre a funcionalidade dos pinos.
A partir do Arduino 1.0.1, é possível habilitar os resistores internos de pullup com o modo INPUT_PULLUP. Além disso, o modo INPUT desativa explicitamente os pullups internos.
Sintaxe
pinMode(pin, mode)
Parâmetros
pin: o número do pin cujo modo você deseja definir
mode: INPUT, OUTPUTOu INPUT_PULLUP. (veja a página ( pinos digitais ) para uma descrição mais completa da funcionalidade.)
Retorna
Nada
Exemplo de código
O código faz o pino digital 13 OUTPUTe alterna HIGHeLOW
void setup ()
{
 pinMode (13, OUTPUT); // define o pino digital 13 como saída
}
Void loop ()
{
 digitalWrite (13, HIGH); // define o pino digital 13 como alto = ativado/ligado
 delay(1000); // espera por um segundo
 digitalWrite (13, LOW// define o pino digital 3 como baixo = desligado/desativado
 delay (1000); // espera por um segundo
}
Notas e avisos
Os pinos de entrada analógica podem ser usados ​​como pinos digitais, referidos como A0, A1, etc.
analogRead ()
[E / S analógica]
Descrição
Lê o valor do pino analógico especificado. A placa Arduino contém um conversor de analógico para digital de 6 canais (8 canais no Mini e Nano, 16 no Mega). Isso significa que ele mapeará as tensões de entrada entre 0 e 5 volts em valores inteiros entre 0 e 1023. Isso produz uma resolução entre leituras de: 5 volts / 1024 unidades ou, .0049 volts (4,9 mV) por unidade. O intervalo de entrada e resolução podem ser alterados usando analogReference () .
Demora cerca de 100 microssegundos (0,0001 s) para ler uma entrada analógica, portanto, a taxa máxima de leitura é de cerca de 10.000 vezes por segundo.
Sintaxe
analogRead(pin)
Parâmetros
pin: o número do pino de entrada analógica para ler (0 a 5 na maioria das placas, 0 a 7 no Mini e Nano, 0 a 15 na Mega)
Retorna
int (0 a 1023)
Exemplo de código
O código lê a voltagem no analogPin e o exibe.
int analogPin = 3; // // limpador do potenciômetro (terminal intermediário) conectado ao pino analógico 3
 // fora leva ao solo e + 5V
int val = 0; // variável para armazenar o valor lido
void setup()
{
 Serial.begin(9600); // setup serial /inicia o serial/ configura o seria
}
void loop()
{
 val = analogRead(analogPin); // le o pino de entrada 
 Serial.println(val); // valor de depuraçao
}
Notas e avisos
Se o pino de entrada analógica não estiver conectado a nada, o valor retornado por analogRead () flutuará com base em vários fatores (por exemplo, os valores das outras entradas analógicas, quão próxima sua mão está da placa, etc.).
analogReference ()
[E / S analógica]
Descrição
Configura a tensão de referência usada para entrada analógica (ou seja, o valor usado como o topo do intervalo de entrada). As opções são:
Placas AVR Arduino (Uno, Mega, etc.)
· PADRÃO: a referência analógica padrão de 5 volts (em placas 5V Arduino) ou 3.3 volts (em placas 3.3V Arduino)
· INTERNO: uma referência interna, igual a 1,1 volts no ATmega168 ou ATmega328P e 2,56 volts no ATmega8 (não disponível no Arduino Mega)
· INTERNAL1V1: uma referência embutida de 1.1V (apenas no Arduino Mega)
· INTERNAL2V56: uma referência 2.56V integrada (somente no Arduino Mega)
· EXTERNAL: a tensão aplicada ao pino AREF (apenas 0 a 5V) é usada como referência.
Placas SAMD Arduino (Zero, etc.)
· AR_DEFAULT: a referência analógica padrão de 3.3V
· AR_INTERNAL: uma referência interna de 2.23V
· AR_INTERNAL1V0: uma referência interna de 1.0V
· AR_INTERNAL1V65: uma referência de 1,65 V integrada
· AR_INTERNAL2V23: uma referência interna de 2.23V
· AR_EXTERNAL: a tensão aplicada ao pino AREF é usada como referência
Placas de SAM do Arduino (Due)
· AR_DEFAULT: a referência analógica padrão de 3.3V. Esta é a única opção suportada pelo Due.
Sintaxe
analogReference(type)
Parâmetros
type: qual tipo de referência usar (veja lista de opções na descrição).
Retorna
Nada
Notas e avisos
Depois de alterar a referência analógica, as primeiras leituras analogRead()podem não ser precisas.
Não use nada menor que 0V ou mais que 5V para tensão de referência externa no pino AREF! Se você estiver usando uma referência externa no pino AREF, deverá definir a referência analógica como EXTERNAL antes de chamar analogRead(). Caso contrário, você irá encurtar a tensão de referência ativa (gerada internamente) e o pino AREF, possivelmente danificando o microcontrolador na sua placa Arduino.
Alternativamente, você pode conectar a tensão de referência externa ao pino AREF através de um resistor de 5K, permitindo alternar entre as tensões de referência externa e interna. Note que o resistor irá alterar a tensão que é usada como referência porque existe um resistor interno de 32K no pino AREF. Os dois atuam como um divisor de tensão, portanto, por exemplo, 2,5 V aplicados através do resistor produzirão 2,5 * 32 / (32 + 5) = ~ 2,2V no pino AREF.
analogWrite ()
[E / S analógica]
Descrição
Escreve um valor analógico ( onda PWM ) em um pino. Pode ser usado para acender um LED com brilho variável ou acionar um motor em várias velocidades. Depois de uma chamada analogWrite(), o pino gerará uma onda quadrada estável do ciclo de serviço especificado até a próxima chamada analogWrite()(ou uma chamada para digitalRead()ou digitalWrite()) no mesmo pino. A frequência do sinal PWM na maioria dos pinos é de aproximadamente 490 Hz. Nas placas Unoe semelhantes, os pinos 5 e 6 têm uma frequência de aproximadamente 980 Hz.
Na maioria das placas Arduino (aquelas com ATmega168 ou ATmega328P), esta função funciona nos pinos 3, 5, 6, 9, 10 e 11. No Arduino Mega, funciona nos pinos 2 - 13 e 44 - 46. Arduino mais antigo placas com um ATmega8 suportam apenas os analogWrite()pinos 9, 10 e 11. 
O Arduino DUE suporta os analogWrite()pinos 2 a 13, além dos pinos DAC0 e DAC1. Ao contrário dos pinos PWM, DAC0 e DAC1 são conversores de Digital para Analógico e atuam como verdadeiras saídas analógicas. 
Você não precisa chamar pinMode()para definir o pino como uma saída antes de chamar analogWrite(). 
A analogWritefunção não tem nada a ver com os pinos analógicos ou a analogReadfunção.
Sintaxe
analogWrite(pin, value)
Parâmetros
pin: o pino para escrever. Tipos de dados permitidos: int. 
value: o ciclo de trabalho: entre 0 (sempre desligado) e 255 (sempre ligado). Tipos de dados permitidos: int
Retorna
Nada
Exemplo de código
Define a saída para o LED proporcional ao valor lido no potenciômetro.
int ledPin = 9; // LED conctado no pino digital 9
int analogPin = 3; // potentiometer conctado analog pin 3//potenciômetro no pino analógico 3
int val = 0; // variável para armazenar o valor de leitura
void setup()
{
 pinMode(ledPin, OUTPUT); // define o pino como saída 
}
void loop()
{
 val = analogRead(analogPin); // le o pino de entrada 
 analogWrite(ledPin, val / 4); // os valores de analogRead vão de 0 a 1023, valores de analogWrite de 0 a 255
}
Notas e avisos
As saídas PWM geradas nos pinos 5 e 6 terão ciclos de trabalho mais altos do que o esperado. Isso ocorre devido às interações com as funções millis()e delay(), que compartilham o mesmo temporizador interno usado para gerar essas saídas PWM. Isso será notado principalmente em configurações de ciclo de serviço baixo (por exemplo, 0 a 10) e pode resultar em um valor de 0 não desligando totalmente a saída nos pinos 5 e 6.
analogReadResolution ()
[Família Zero, Due & MKR]
Descrição
analogReadResolution () é uma extensão da API analógica para a família Arduino Due, Zero e MKR.
Define o tamanho (em bits) do valor retornado por analogRead(). O padrão é 10 bits (retorna valores entre 0 e 1023) para compatibilidade retroativa com placas baseadas em AVR.
As placas Família Due, Zero e MKR possuem recursos ADC de 12 bits que podem ser acessados ​​alterando a resolução para 12. Isso retornará valores analogRead()entre 0 e 4095.
Sintaxe
analogReadResolution(bits)
Parâmetros
bits: determina a resolução (em bits) do valor retornado pela analogRead()função. Você pode definir isso entre 1 e 32. Você pode definir resoluções superiores a 12, mas valores retornados por analogRead()sofrerão aproximação. Veja a nota abaixo para detalhes.
Retorna
Nada
Exemplo de código
// read the input on A0 at default resolution (10 bits)
 // and send it out the serial connection
 analogReadResolution(10);
 Serial.print("ADC 10-bit (default) : ");
 Serial.print(analogRead(A0));
 // change the resolution to 12 bits and read A0
 analogReadResolution(12);
 Serial.print(", 12-bit : ");
 Serial.print(analogRead(A0));
 // change the resolution to 16 bits and read A0
 analogReadResolution(16);
 Serial.print(", 16-bit : ");
 Serial.print(analogRead(A0));
 // change the resolution to 8 bits and read A0
 analogReadResolution(8);
 Serial.print(", 8-bit : ");
 Serial.println(analogRead(A0));
 // a little delay to not hog Serial Monitor
 delay(100);
}
O código mostra como usar o ADC com diferentes resoluções.
void setup () {
  // abre uma conexão serial
  Serial.begin (9600);
}
void loop () {
  // le a entrada em A0 na resolução padrão (10 bits)
  // e enviá-lo pela conexão serial
  analogReadResolution (10);
  Serial.print ("ADC 10-bit (padrão):");
  Serial.print (analogRead (A0));
  // muda a resolução para 12 bits e lê A0
  analogReadResolution (12);
  Serial.print (", 12 bits:");
  Serial.print (analogRead (A0));
  // muda a resolução para 16 bits e lê A0
  analiseReadResolution (16);
  Serial.print (", 16 bits:");
  Serial.print (analogRead (A0));
  // muda a resolução para 8 bits e lê A0
  analogReadResolution (8);
  Serial.print (", 8 bits:");
  Serial.println (analogRead (A0));
  // um pequeno atraso para não roubar o Monitor Serial
  delay (100);
Notas e avisos
Se você definir o analogReadResolution()valor para um valor maior do que os recursos da sua placa, o Arduino reportará apenas na sua resolução mais alta, preenchendo os bits extras com zeros.
Por exemplo: usar o método Due with analogReadResolution(16)lhe dará um número aproximado de 16 bits com os primeiros 12 bits contendo a leitura real do ADC e os últimos 4 bits preenchidos com zeros .
Se você definir o analogReadResolution()valor para um valor inferior aos recursos da sua placa, os bits extra menos significativos lidos do ADC serão descartados .
O uso de uma resolução de 16 bits (ou qualquer resolução maior do que a capacidade real de hardware) permite escrever esboços que manipulam automaticamente dispositivos com um ADC de resolução mais alta quando eles se tornam disponíveis em placas futuras sem alterar uma linha de código.
analogWriteResolution ()
[Família Zero, Due & MKR]
Descrição
analogWriteResolution() é uma extensão da API analógica para o Arduino Due.
analogWriteResolution()define a resolução da analogWrite()função. O padrão é 8 bits (valores entre 0-255) para compatibilidade retroativa com placas baseadas em AVR.
O Due tem os seguintes recursos de hardware:
· 12 pinos, cujo padrão é o PWM de 8 bits, como as placas baseadas em AVR. Estes podem ser alterados para resolução de 12 bits.
· 2 pinos com DAC de 12 bits (conversor digital para analógico)
Ao definir a resolução de gravação como 12, você pode usar analogWrite()com valores entre 0 e 4095 para explorar a resolução total do DAC ou para definir o sinal PWM sem rolar.
O Zero tem os seguintes recursos de hardware:
· 10 pinos, cujo padrão é o PWM de 8 bits, como as placas baseadas em AVR. Estes podem ser alterados para resolução de 12 bits.
· 1 pino com DAC de 10 bits (conversor digital para analógico).
Definindo a resolução de gravação como 10, você pode usar analogWrite()com valores entre 0 e 1023 para explorar a resolução total do DAC
A família de placas MKR possui os seguintes recursos de hardware:
· 4 pinos cujo padrão é o PWM de 8 bits, como as placas baseadas em AVR. Estes podem ser alterados de 8 (padrão) para resolução de 12 bits.
· 1 pino com DAC de 10 bits (conversor digital para analógico)
Ao definir a resolução de gravação para 12 bits, você pode usar analogWrite()com valores entre 0 e 4095 para sinais PWM; defina 10 bits no pino DAC para explorar a resolução DAC completa de 1024 valores.
Sintaxe
analogWriteResolution(bits)
Parâmetros
bits: determina a resolução (em bits) dos valores usados ​​na analogWrite()função. O valor pode variar de 1 a 32. Se você escolher uma resolução maior ou menor do que os recursos de hardware da placa, o valor usado analogWrite()será truncado se for muito alto ou preenchido com zeros se for muito baixo. Veja a nota abaixo para detalhes.
Retorna
Nada
Exemplo de código
Explicar Código
void setup(){
 // abrir uma conexão serial
 Serial.begin(9600);
 // faça o nosso pino digital uma saída
 pinMode(11, OUTPUT);
 pinMode(12, OUTPUT);
 pinMode(13, OUTPUT);
}
void loop(){
 // leia a entrada em A0 e mapeie para um pino PWM  
 // com um LED conectado
 int sensorVal = analogRead(A0);
 Serial.print("Analog Read) : ");
 Serial.print(sensorVal);
// a resolução padrão do PWM
 analogWriteResolution(8);
 analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));
 Serial.print(" , 8-bit PWM value : ");
 Serial.print(map(sensorVal, 0, 1023, 0 ,255));
 // altere a resolução do PWM para 12 bits  
 // a resolução completa de 12 bits é suportada apenas  
 // no vencimento
 analogWriteResolution(12);
 analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
 Serial.print(" , 12-bit PWM value : ");
 Serial.print(map(sensorVal, 0, 1023, 0, 4095));// alterar a resolução do PWM para 4 bits
 analogWriteResolution(4);
 analogWrite(13, map(sensorVal, 0, 1023, 0, 15));
 Serial.print(", 4-bit PWM value : ");
 Serial.println(map(sensorVal, 0, 1023, 0, 15));
 delay(5);
}
Notas e avisos
Se você definir o analogWriteResolution()valor para um valor maior que o da sua placa, o Arduino irá descartar os bits extras. Por exemplo: usando o Due with analogWriteResolution(16)em um pino DAC de 12 bits, somente os primeiros 12 bits dos valores passados analogWrite()serão usados ​​e os últimos 4 bits serão descartados.
Se você definir o analogWriteResolution()valor para um valor inferior aos recursos da placa, os bits ausentes serão preenchidos com zeros para preencher o tamanho necessário do hardware. Por exemplo: usando o Due with analogWriteResolution (8) em um pino DAC de 12 bits, o Arduino adicionará 4 bits zero ao valor de 8 bits usado analogWrite()para obter os 12 bits necessários.
notone()
[E / S avançada]
Descrição
Pára a geração de uma onda quadrada desencadeada por tone(). Não tem efeito se nenhum tom estiver sendo gerado.
Sintaxe
noTone(pin)
Parâmetros
pin: o pino no qual parar de gerar o tom
Retorna
Nada
Notas e avisos
Se você quiser reproduzir alturas diferentes em vários pinos, será necessário chamar noTone () em um pino antes de chamar tone()o próximo pino.
pulseIn ()
[E / S avançada]
Descrição
Lê um pulso (ou HIGHou LOW) em um pino. Por exemplo, se valuefor HIGH, pulseIn()espera que o pino vá de LOWpara HIGH, comece a cronometrar, espere que o pino vá LOWe pare de cronometrar. Retorna a duração do pulso em microssegundos ou desiste e retorna 0 se nenhum pulso completo foi recebido dentro do tempo limite.
O tempo dessa função foi determinado empiricamente e provavelmente mostrará erros em pulsos mais longos. Funciona em pulsos de 10 microssegundos a 3 minutos de duração.
Sintaxe
pulseIn(pin, value)
pulseIn(pin, value, timeout)
Parâmetros
pin: o número do pino no qual você deseja ler o pulso. (int)
value: tipo de pulso para ler: ALTO ou BAIXO . (int)
timeout(opcional): o número de microssegundos a aguardar o início do pulso; o padrão é um segundo (longo não assinado)
Retorna
o comprimento do pulso (em microssegundos) ou 0 se nenhum pulso for iniciado antes do tempo limite (longo não assinado)
Exemplo de código
O exemplo calculou a duração do tempo de um pulso no pino 7.
int pin = 7;
unsigned long duration;
void setup()
{
 pinMode(pin, INPUT);
}
void loop()
{
 duration = pulseIn(pin, HIGH);
}
pulseInLong ()
[E / S avançada]
Descrição
pulseInLong()é uma alternativa ao pulseIn (), que é melhor em lidar com pulsos longos e interromper cenários afetados.
Lê um pulso (ou HIGHou LOW) em um pino. Por exemplo, se valuefor HIGH, pulseInLong()espera que o pino vá de LOWpara HIGH, comece a cronometrar, espere que o pino vá LOWe pare de cronometrar. Retorna a duração do pulso em microssegundos ou desiste e retorna 0 se nenhum pulso completo foi recebido dentro do tempo limite.
O tempo desta função foi determinado empiricamente e provavelmente mostrará erros em pulsos mais curtos. Funciona em pulsos de 10 microssegundos a 3 minutos de duração. Esta rotina pode ser usada somente se as interrupções forem ativadas. Além disso, a maior resolução é obtida com grandes intervalos.
Sintaxe
pulseInLong(pin, value)
pulseInLong(pin, value, timeout)
Parâmetros
pin: o número do pino no qual você deseja ler o pulso. (int)
value: tipo de pulso para ler: ALTO ou BAIXO . (int)
timeout(opcional): o número de microssegundos a aguardar o início do pulso; o padrão é um segundo (longo não assinado)
Retorna
o comprimento do pulso (em microssegundos) ou 0 se nenhum pulso for iniciado antes do tempo limite (longo não assinado)
Exemplo de código
O exemplo calculou a duração do tempo de um pulso no pino 7.
int pin = 7;
unsigned long duration;
void setup() {
 pinMode(pin, INPUT);
}
void loop() {
 duration = pulseInLong(pin, HIGH);
}
Notas e avisos
Essa função depende de micros (), portanto, não pode ser usada no contexto noInterrupts () .
shiftIn ()
[E / S avançada]
Descrição
Desloca um byte de dados um bit por vez. Inicia a partir do bit mais significativo (ou seja, o mais à esquerda) ou o menor (à direita). Para cada bit, o pino do relógio é puxado para cima, o próximo bit é lido da linha de dados e, em seguida, o pino do relógio é retirado para baixo.
Se você estiver fazendo interface com um dispositivo com clock crescente, será necessário certificar-se de que o pino do relógio esteja baixo antes da primeira chamada shiftIn(), por exemplo, com uma chamada para digitalWrite(clockPin, LOW).
Nota: esta é uma implementação de software; O Arduino também fornece uma biblioteca SPI que usa a implementação de hardware, que é mais rápida, mas só funciona em pinos específicos.
Sintaxe
byte incoming = shiftIn(dataPin, clockPin, bitOrder)
Parâmetros
dataPin: o pino no qual inserir cada bit (int)
clockPin: o pino para alternar para sinalizar uma leitura de dataPin
bitOrder: qual a ordem para mudar nos bits; quer MSBFIRST ou LSBFIRST . (O bit mais significativo primeiro ou o bit menos significativo primeiro)
Retorna
o valor lido (byte)
shiftOut ()
[E / S avançada]
Descrição
Desloca um byte de dados um bit por vez. Inicia a partir do bit mais significativo (ou seja, o mais à esquerda) ou o menor (à direita). Cada bit é gravado por sua vez em um pino de dados, após o qual um pino de clock é pulsado (alto, depois baixo) para indicar que o bit está disponível.
Observação: se você estiver fazendo interface com um dispositivo com clock crescente, será necessário certificar-se de que o pino do relógio esteja baixo antes da chamada shiftOut(), por exemplo, com uma chamada para digitalWrite(clockPin, LOW).
Esta é uma implementação de software; veja também a biblioteca SPI , que fornece uma implementação de hardware mais rápida, mas funciona apenas em pinos específicos.
Sintaxe
shiftOut(dataPin, clockPin, bitOrder, value)
Parâmetros
dataPin: o pino no qual a saída de cada bit (int)
clockPin: o pino para alternar uma vez que o dataPin foi definido para o valor correto (int)
bitOrder: qual a ordem para deslocar os bits; MSBFIRST ou LSBFIRST. (O bit mais significativo primeiro ou o bit menos significativo primeiro)
value: os dados para mudar. (byte)
Retorna
Nada
Exemplo de código
Para acompanhar o circuito, veja o tutorial sobre como controlar um registrador de deslocamento 74HC595 .
//**************************************************************//
// 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 connectado to ST_CP of 74HC595
int latchPin = 8;
//Pin connectado to SH_CP of 74HC595
int clockPin = 12;
////Pin connectado to DS of 74HC595
int dataPin = 11;
void setup() {
  // configura os pinos para saída porque eles são endereçados no loop principal
 pinMode(latchPin, OUTPUT);
 pinMode(clockPin, OUTPUT);
 pinMode(dataPin, OUTPUT);
}
void loop() {
  // contagem de rotina
 for (int j = 0; j < 256; j++) {
 // trava do soloPin e segure baixo enquanto você estiver transmitindo
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, LSBFIRST, j);
    // retorne o pino de trava para sinalizar que ele
    // não precisa mais escutar informações
 digitalWrite(latchPin, HIGH);
 delay(1000);
 }
}
Notas e avisos
O dataPin e o clockPin já devem estar configurados como saídas por uma chamada para pinMode () .
O shiftOut é atualmente escrito para a saída de 1 byte (8 bits), de modo que requer uma operação em duas etapas para gerar valores maiores que 255.
// Faça isso para serial MSBFIRST
int data = 500;
// shift out highbyte
shiftOut(dataPin, clock, MSBFIRST, (data >>8));
// shift out lowbyte
shiftOut(dataPin, clock, MSBFIRST, data);
// Ou faça isso para serial LSBFIRST
data = 500;
// desloca o baixo byby
shiftOut(dataPin, clock, LSBFIRST, data);
// deslocar alto byby
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));
tom()tone
[E / S avançada]
Descrição
Gera uma onda quadrada da frequência especificada (e ciclo de trabalho de 50%) em um pino. Uma duração pode ser especificada, caso contrário, a onda continua até uma chamada para noTone () . O pino pode ser conectado a um sinal sonoro piezoelétrico ou outro alto-falante para reproduzir tons.
Apenas um tom pode ser gerado por vez. Se um som já estiver tocando em um pino diferente, a chamada para tone () não terá efeito. Se o tom estiver tocando no mesmo pino, a chamada definirá sua frequência.
O uso da tone()função interferirá na saída do PWM nos pinos 3 e 11 (em outras placas além da Mega).
Não é possível gerar tons inferiores a 31Hz. Para detalhes técnicos, veja as notas de Brett Hagman .
Sintaxe
tone(pin, frequency)
tone(pin, frequency, duration)
Parâmetros
pin: o pino no qual gerar o tom
frequency: a frequência do tom em hertz - unsigned int
duration: a duração do tom em milissegundos (opcional) - unsigned long
Retorna
Nada
Notas e avisos
Se você quiser reproduzir notas diferentes em vários pinos, será necessário chamar noTone()um pino antes de chamar tone()o próximo pino.
delay()
[Tempo]
Descrição
Pausa o programa pelo período de tempo (em milissegundos) especificado como parâmetro. (Há 1000 milissegundos em um segundo.)
Sintaxe
delay(ms)
Parâmetros
ms: o número de milissegundos a pausar ( unsigned long)
Retorna
Nada
Exemplo de código
O código pausa o programa por um segundo antes de alternar o pino de saída.
int ledPin = 13; // LED conectado ao pino digital 13
void setup()
{
 pinMode(ledPin, OUTPUT); // define o pino digital como saída
}
void loop()
{
 digitalWrite(ledPin, HIGH); //define led ligado
 delay(1000); // espera por um segundo 
 digitalWrite(ledPin, LOW); //define led desligado
 delay(1000); // espera por um segundo 
}
Notas e avisos
Embora seja fácil criar um LED intermitente com a delay()função, e muitos esboços usam atrasos curtos para tarefas como a de debounce de comutador, o uso de delay()um esboço tem desvantagens significativas. Nenhuma outra leitura de sensores, cálculos matemáticos ou manipulação de pinos pode continuar durante a função de atraso, então, de fato, ela interrompe a maioria das outras atividades. Para abordagens alternativas para controlar a temporização, consulte a função millis () e o esboço abaixo. Programadores mais experientes geralmente evitam o uso de delay()temporizações de eventos maiores que 10 de milissegundos, a menos que o esboço do Arduino seja muito simples.
Certas coisas acontecem enquanto a função delay () está controlando o chip Atmega, porque a função delay não desabilita as interrupções. A comunicação serial que aparece no pino RX é gravada, os valores PWM ( analogWrite ) e os estados dos pinos são mantidos e as interrupções funcionam como deveriam.
delayMicroseconds ()
[Tempo]
Descrição
Pausa o programa pelo período de tempo (em microssegundos) especificado como parâmetro. Há mil microssegundos em um milissegundo e um milhão de microssegundos em um segundo.
Atualmente, o maior valor que produzirá um atraso preciso é 16383. Isso pode mudar em futuras versões do Arduino. Para atrasos maiores que alguns milhares de microssegundos, você deve usar em delay()vez disso.
Sintaxe
delayMicroseconds(us)
Parâmetros
us: o número de microssegundos a pausar ( unsigned int)
Retorna
Nada
Exemplo de código
O código configura o pino número 8 para funcionar como um pino de saída. Ele envia um trem de pulsos de aproximadamente 100 microssegundos. A aproximação é devida à execução das outras instruções no código.
int outPin = 8; // digital pino 8
void setup()
{
 pinMode(outPin, OUTPUT); // define o pino digital como saída
}
void loop()
{
 digitalWrite(outPin, HIGH); // define o pino ligado
 delayMicroseconds(50); // pausa de 50 microseconds
 digitalWrite(outPin, LOW); // define o pino desligado
 delayMicroseconds(50); // pausa de 50 microseconds
}
Notas e avisos
Essa função funciona com muita precisão no intervalo de 3 microssegundos e acima. Não podemos garantir que o delayMicroseconds funcione com precisão para tempos de atraso menores.
A partir do Arduino 0018, o delayMicroseconds () não desativa mais as interrupções.
micros ()
[Tempo]
Descrição
Retorna o número de microssegundos desde que a placa do Arduino começou a executar o programa atual. Este número irá transbordar (voltar para zero), após aproximadamente 70 minutos. Em placas de 16 MHz Arduino (por exemplo, Duemilanove e Nano), esta função tem uma resolução de quatro microssegundos (ou seja, o valor retornado é sempre um múltiplo de quatro). Em placas Arduino de 8 MHz (por exemplo, o LilyPad), esta função tem uma resolução de oito microssegundos.
Sintaxe
time = micros()
Parâmetros
Nada
Retorna
Retorna o número de microssegundos desde que a placa do Arduino começou a executar o programa atual.
Exemplo de código
O código retorna o número de microssegundos desde o início da placa Arduino.
unsigned long time;
void setup(){
 Serial.begin(9600);
}
void loop(){
 Serial.print("Time: ");
 time = micros();
 Serial.println(time); // imprime tempo desde o início do programa
delay(1000); // espere um segundo para não enviar grandes quantidades de dados
}	
Notas e avisos
Existem 1.000 microssegundos em um milissegundo e 1.000.000 microssegundos em um segundo.
millis ()
[Tempo]
Descrição
Retorna o número de milissegundos desde que a placa do Arduino começou a executar o programa atual. Este número irá transbordar (voltar para zero), após aproximadamente 50 dias.
Sintaxe
time = millis()
Parâmetros
Nada
Retorna
Número de milissegundos desde o início do programa (longo não assinado)
Exemplo de código
O código lê o milissegundo desde o início da placa Arduino.
unsigned long time;
void setup(){
 Serial.begin(9600);
}
void loop(){
 Serial.print("Time: ");
 time = millis();
 Serial.println(time); // imprime tempo desde o início do programa
 delay(1000); // espere um segundo para não enviar grandes quantidades de dados
 
}
Notas e avisos
Por favor, note que o valor de retorno para millis () é um longo não assinado, erros lógicos podem ocorrer se um programador tentar fazer aritmética com tipos de dados menores, como int's. Até mesmo assinados podem encontrar erros, já que seu valor máximo é metade do de sua contraparte não assinada
math.
abs ()
[Matemática]
Descrição
Calcula o valor absoluto de um número.
Sintaxe
abs(x)
Parâmetros
x: o número
Retorna
x: se x for maior que ou igual a 0.
-x: se x for menor que 0.
Notas e avisos
Devido à maneira como a função abs () é implementada, evite usar outras funções dentro dos colchetes, isso pode levar a resultados incorretos.
abs(a++); // evite isso - produz resultados incorretos
abs(a); // use isso em vez disso -
a++; // mantém outra matemática fora da função
constrain ()
[Matemática]
Descrição
Restringe um número para estar dentro de um intervalo.
Sintaxe
constrain(x, a, b)
Parâmetros
x: o número a ser restringido, todos os tipos de dados a: a extremidade inferior da faixa, todos os tipos de dados b: a extremidade superior da faixa, todos os tipos de dados
Retorna
x: se x estiver entre a e b
a: se x for menor que um
b: se x for maior que b
Exemplo de código
O código limita os valores do sensor para entre 10 e 150.
sensVal = constrain(sensVal, 10, 150); // limits range // limites gama
mapa()map
[Matemática]
Descrição
Re-mapeia um número de um intervalo para outro. Isto é, um valor de fromLow iria ficar mapeado para toLow , um valor de fromHigh para toHigh , valoriza-nos entre os valores nas entrelinhas, etc.
Não restringe os valores dentro do intervalo, porque os valores fora do intervalo são às vezes planejadose úteis. A constrain()função pode ser usada antes ou depois desta função, se os limites para os intervalos forem desejados.
Observe que os "limites inferiores" de qualquer intervalo podem ser maiores ou menores que os "limites superiores", portanto, a map()função pode ser usada para reverter um intervalo de números, por exemplo
y = map(x, 1, 50, 50, 1);
A função também lida bem com números negativos, de modo que este exemplo
y = map(x, 1, 50, 50, -100);
também é válido e funciona bem.
A map()função usa matemática inteira para não gerar frações, quando a matemática pode indicar que deve fazê-lo. Os restos fracionários são truncados e não são arredondados ou calculados.
Sintaxe
map(value, fromLow, fromHigh, toLow, toHigh)
Parâmetros
value: o número para mapear
fromLow: o limite inferior do intervalo atual do valor
fromHigh: o limite superior do intervalo atual do valor
toLow: o limite inferior do intervalo de segmentação do valor
toHigh: o limite superior do intervalo de segmentação do valor
Retorna
O valor mapeado.
Exemplo de código
Mapear um valor analógico para 8 bits (0 a 255) * /
void setup() {}
void loop()
{
 int val = analogRead(0);
 val = map(val, 0, 1023, 0, 255);
 analogWrite(9, val);
}
Apêndice
Para o matematicamente inclinado, aqui está toda a função
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
 return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
max ()
[Matemática]
Descrição
Calcula o máximo de dois números.
Sintaxe
max(x, y)
Parâmetros
x: o primeiro número, qualquer tipo de dados y: o segundo número, qualquer tipo de dados
Retorna
O maior dos dois valores de parâmetro.
Exemplo de código
O código garante que sensVal seja pelo menos 20.
sensVal = max(sensVal, 20); // atribui sensVal ao maior de sensVal ou 20
                           // (efetivamente garantindo que seja pelo menos 20)
Notas e avisos
Talvez contra-intuitivamente, max()é freqüentemente usado para restringir o limite inferior do intervalo de uma variável, enquanto min()é usado para restringir o limite superior do intervalo.
Devido à maneira como a max()função é implementada, evite usar outras funções dentro dos colchetes, isso pode levar a resultados incorretos
max(a--, 0); // evite isso - produz resultados incorretos
		
max(a, 0); // use isso em vez disso -
a--; // mantém outra matemática fora da função
min ()
[Matemática]
Descrição
Calcula o mínimo de dois números.
Sintaxe
min(x, y)
Parâmetros
x: o primeiro número, qualquer tipo de dados
y: o segundo número, qualquer tipo de dados
Retorna
O menor dos dois números.
Exemplo de código
O código garante que nunca fique acima de 100.
sensVal = min(sensVal, 100); // atribui sensVal ao menor de sensVal ou 100
                             // garantindo que nunca fique acima de 100.
Notas e avisos	
Talvez contra-intuitivamente, max()é freqüentemente usado para restringir o limite inferior do intervalo de uma variável, enquanto min()é usado para restringir o limite superior do intervalo.
Devido à maneira como a min()função é implementada, evite usar outras funções dentro dos colchetes, isso pode levar a resultados incorretos
min(a++, 100); // evite isso - produz resultados incorretos
min(a, 100);
a++; // use isso - mantenha outras contas fora da função
pow()
[Matemática]
Descrição
Calcula o valor de um número elevado a uma potência. Pow()pode ser usado para aumentar um número para um poder fracionário. Isso é útil para gerar mapeamento exponencial de valores ou curvas.
Sintaxe
pow(base, exponent)
Parâmetros
base: o número ( float)
exponent: o poder para o qual a base é levantada ( float)
Retorna
O resultado da exponenciação. ( double)
Exemplo de código
Veja a função ( fscale ) na biblioteca de códigos.
sq ()
[Matemática]
Descrição
Calcula o quadrado de um número: o número multiplicado por si mesmo.
Sintaxe
sq(x)
Parâmetros
x: o número, qualquer tipo de dados
Retorna
O quadrado do número. (Duplo)
sqrt ()
[Matemática]
Calcula a raiz quadrada de um número.
Descrição
Sintaxe
sqrt(x)
Parâmetros
x: o número, qualquer tipo de dados
Retorna
A raiz quadrada do número. (Duplo)
cos ()
[Trigonometria]
Descrição
Calcula o cosseno de um ângulo (em radianos). O resultado será entre -1 e 1.
Sintaxe
cos(rad)
Parâmetros
rad: O ângulo em radianos (flutuação).
Retorna
O cos do ângulo ( double).
Sin()
[Trigonometria]
Descrição
Calcula o seno de um ângulo (em radianos). O resultado será entre -1 e 1.
Sintaxe
sin(rad)
Parâmetros
rad: O ângulo em radianos ( float).
Retorna
O seno do ângulo ( double).
 Tan()
[Trigonometria]
Descrição
Calcula a tangente de um ângulo (em radianos). O resultado será entre infinito negativo e infinito.
Sintaxe
tan(rad)
Parâmetros
rad: O ângulo em radianos ( float).
Retorna
A tangente do ângulo ( double).
isAlpha ()
[Personagens]
Descrição
Analise se um caractere é alfa (isso é uma letra). Retorna true se thisChar contiver uma letra.
Sintaxe
isAlpha(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é alfa.
Exemplo de código
if (isAlpha(this)) // testa se esta é uma carta
{
	Serial.println("The character is a letter"); // O personagem é uma carta
}
else
{
	Serial.println("The character is not a letter");// O personagem não é uma carta
}
isAlphaNumeric ()
[Personagens]
Descrição
Analise se um caractere é alfanumérico (ou seja, uma letra ou um número). Retorna true se thisChar contiver um número ou uma letra.
Sintaxe
`isAlphaNumeric(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é alfanumérico.
Exemplo de código
if (isAlphaNumeric(this)) // testa se esta é uma letra ou um número
{
	Serial.println("The character is alphanumeric"); // O caractere é alfanumérico
}
else
{
	Serial.println("The character is not alphanumeric");// O caractere não é alfanumérico"
}
isAscii ()
[Personagens]
Descrição
Analise se um char é Ascii. Retorna true se thisChar contiver um caractere Ascii.
Sintaxe
`isAscii(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é Ascii.
Exemplo de código
if (isAscii(this)) // testa se este é um personagem Ascii 
{
	Serial.println("The character is Ascii");//"O caractere é Ascii"
}
else
{
	Serial.println("The character is not Ascii");// O caractere não é Ascii
}
isControl ()
[Personagens]
Descrição
Analise se um char é um caractere de controle. Retorna true se thisChar for um caractere de controle.
Sintaxe
`isControl(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um caractere de controle.
Exemplo de código
if (isControl(this)) // testa se este é um personagem de controle
{
	Serial.println("The character is a control character"); // O caractere é um caractere de controle
}
else
{
	Serial.println("The character is not a control character");// O caractere não é um caractere de controle
}
isDigit ()
[Personagens]
Descrição
Analise se um caractere é um dígito (isto é, um número). Retorna true se thisChar for um número.
Sintaxe
isDigit(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um número.
Exemplo de código
if (isDigit(this)) // testa se este é um dígito
{
	Serial.println("The character is a number"); // O caractere é um número
}
else
{
	Serial.println("The character is not a number");// O personagem não é um número
}
isGraph ()
[Personagens]
Descrição
Analise se um caractere é imprimível com algum conteúdo (o espaço é imprimível, mas não tem conteúdo). Retorna true se thisChar for imprimível.
Sintaxe
`isGraph(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é imprimível.
Exemplo de código
if (isGraph(this)) // testa se este é um caractere imprimível, mas não um espaço em branco.
{	
	Serial.println("The character is printable");// O caractere é imprimível
}
else
{
	Serial.println("The character is not printable");//O caractere não é imprimível}
isHexadecimalDigit ()
[Personagens]
Descrição
Analise se um caractere é um dígito hexadecimal (AF, 0-9). Retorna true se thisChar contiver um dígito hexadecimal.
Sintaxe
`isHexadecimalDigit(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um dígito hexadecimal.
Exemplo de código
if (isHexadecimalDigit(this)) // testa se este é um dígito hexadecimal
{
	Serial.println("The character is an hexadecimal digit");// O caractere é um dígito hexadecimal
}
else
{
	Serial.println("The character is not an hexadecimal digit");// O caractere não é um dígito hexadecimal
}
isLowerCase ()
[Personagens]
Descrição
Analise se um caractere é minúsculo (ou seja, uma letra minúscula). Retorna true se thisChar contiver uma letra em minúscula.
Sintaxe
`isLowerCase(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é minúsculo.
Exemplo de código
if (isLowerCase(this)) // testa se esta é uma letra minúscula
{
	Serial.println("The character is lower case");// O personagem é minúsculas
}
else
{
	Serial.println("The character is not lower case");// O personagem não é minúsculas
}
isPrintable ()
[Personagens]
Descrição
Analise se um caractere é imprimível (ou seja, qualquer caractere que produza uma saída, até mesmo um espaço em branco). Retorna true se thisChar for imprimível.
Sintaxe
`isAlpha(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é imprimível.
Exemplo de código
if (isPrintable(this)) // testa se isso é imprimível{
	Serial.println("The character is printable");// O personagem é imprimível
}
else
{
	Serial.println("The character is not printable");// O personagem não é imprimível
}
isPunct ()
[Personagens]
Descrição
Analise se um caracter é pontuação (ou seja, uma vírgula, um ponto e vírgula, uma marca de exlamação e assim por diante). Retorna verdadeiro se thisChar for pontuação.
Sintaxe
`isPunct(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é uma pontuação.
Exemplo de código
if (isPunct(this)) // testa se esse é um caractere de pontuação
{
	Serial.println("The character is a punctuation");// O personagem é uma pontuação
}
else
{
	Serial.println("The character is not a punctuation");// O personagem não é uma pontuação
}
isSpace ()
[Personagens]
Descrição
Analise se um char é o caractere de espaço. Retorna true se thisChar contiver o caractere de espaço.
Sintaxe
`isSpace(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um espaço.
Exemplo de código
if (isSpace(this)) // testa se esse é o caractere de espaço{
	Serial.println("The character is a space"); // O personagem é um espaço
}
else
{
	Serial.println("The character is not a space");// O personagem não é um espaço
}
isUpperCase ()
[Personagens]
Descrição
Analise se um caractere é maiúsculo (isso é uma letra maiúscula). Retorna true se thisChar for maiúsculo.
Sintaxe
`isUpperCase(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar for maiúsculo.
Exemplo de código
if (isUpperCase(this)) // testa se esta é uma letra maiúscula
{
	Serial.println("The character is upper case");// O caractere é maiúsculo
}
else
{
	Serial.println("The character is not upper case");// O caractere não é maiúsculo
}
isWhitespace ()
[Personagens]
Descrição
Analise se um char é um espaço em branco, ou seja, espaço, formfeed ('\ f'), newline ('\ n'), retorno de carro ('\ r'), guia horizontal ('\ t') e guia vertical ('\ v')). Retorna true se thisChar contiver um espaço em branco.
Sintaxe
`isWhitespace(thisChar)`
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um espaço em branco.
Exemplo de código
if (isWhitespace(this)) // testa se este é um espaço em branco
{
	Serial.println("The character is a white space");// "O personagem é um espaço em branco
}
else
{
	Serial.println("The character is not a white space");// O personagem não é um espaço em branco
}
aleatória()random
[Números aleatórios]
Descrição
A função aleatória gera números pseudo-aleatórios.
Sintaxe
random(max)
random(min, max)
Parâmetros
min - limite inferior do valor aleatório, inclusive (opcional)
max - limite superior do valor aleatório, exclusivo
Retorna
Um número aleatório entre min e max-1 ( long).
Exemplo de código
O código gera números aleatórios e os exibe.
long randNumber;
void setup(){
 Serial.begin(9600);
// se o pino de entrada analógica 0 estiver desconectado, analógico aleatório
  // noise fará com que a chamada randomSeed () gere
  // diferentes números de sementes cada vez que o esboço é executado.
  // randomSeed () irá então embaralhar a função aleatória.
  randomSeed (analogRead (0));
.
 randomSeed(analogRead(0));
}
void loop() {
 // imprima um número aleatório de 0 a 299
 randNumber = random(300);
 Serial.println(randNumber);
 // imprime um número aleatório de 10 a 19
 randNumber = random(10, 20);
 Serial.println(randNumber);
 delay(50);
}
Notas e avisos
Se for importante para uma seqüência de valores gerados por random()diferir, em execuções subseqüentes de um esboço, use randomSeed()para inicializar o gerador de números aleatórios com uma entrada bastante aleatória, como analogRead()em um pino não conectado.
Por outro lado, ocasionalmente pode ser útil usar seqüências pseudo-aleatórias que se repetem exatamente. Isso pode ser feito chamando randomSeed()com um número fixo, antes de iniciar a seqüência aleatória.
O maxparâmetro deve ser escolhido de acordo com o tipo de dados da variável na qual o valor é armazenado. Em qualquer caso, o máximo absoluto está ligado à longnatureza do valor gerado (32 bits - 2.147.483.647). A configuração maxpara um valor mais alto não gerará um erro durante a compilação, mas durante a execução do sketch, os números gerados não serão os esperados.
randomSeed ()
[Números aleatórios]
Descrição
randomSeed()Inicializa o gerador de números pseudo-aleatórios, fazendo com que ele inicie em um ponto arbitrário em sua seqüência aleatória. Essa sequência, embora muito longa e aleatória, é sempre a mesma.
Se for importante para uma seqüência de valores gerados por random()diferir, em execuções subseqüentes de um esboço, use randomSeed () para inicializar o gerador de números aleatórios com uma entrada bastante aleatória, como analogRead()em um pino não conectado.
Por outro lado, ocasionalmente pode ser útil usar seqüências pseudo-aleatórias que se repetem exatamente. Isso pode ser feito chamando randomSeed()com um número fixo, antes de iniciar a seqüência aleatória.
Parâmetros
seed - número para inicializar a sequência pseudoaleatória (longa não assinada).
Retorna
Nada
Exemplo de código
A explicação do código é necessária.
long randNumber;
void setup(){
 Serial.begin(9600);
 randomSeed(analogRead(0));
}
void loop(){
 randNumber = random(300);
 Serial.println(randNumber);
 delay(50);
}
Bit()
[Bits e bytes]
Descrição
Calcula o valor do bit especificado (bit 0 é 1, bit 1 é 2, bit 2 é 4, etc.).
Sintaxe
bit(n)
Parâmetros
n: o bit cujo valor para computar
Retorna
O valor do bit.
bitClear ()
[Bits e bytes]
Descrição
Limpa (escreve um 0 a) um pouco de uma variável numérica.
Sintaxe
bitClear(x, n)
Parâmetros
x: a variável numérica cujo bit para limpar
n: qual bit para limpar, começando em 0 para o bit menos significativo (mais à direita)
Retorna
Nada
bitRead ()
[Bits e bytes]
Descrição
Lê um pouco de um número.
Sintaxe
bitRead(x, n)
Parâmetros
x: o número a partir do qual ler
n: qual bit para ler, começando em 0 para o bit menos significativo (mais à direita)
Retorna
o valor do bit (0 ou 1).
bitSet ()
[Bits e bytes]
Define (escreve um 1 a) um bit de uma variável numérica.
Descrição
Sintaxe
bitSet(x, n)
Parâmetros
x: a variável numérica cujo bit é definido
n: which bit to set, iniciando em 0 para o bit menos significativo (mais à direita)
Retorna
Nada
bitWrite ()
[Bits e bytes]
DescriçãoEscreve um pouco de uma variável numérica.
Sintaxe
bitWrite(x, n, b)
Parâmetros
x: a variável numérica na qual escrever
n: qual bit do número para escrever, começando em 0 para o bit menos significativo (mais à direita)
b: o valor para gravar no bit (0 ou 1)
Retorna
Nada
highByte ()
[Bits e bytes]
Descrição
Extrai o byte de alta ordem (mais à esquerda) de uma palavra (ou o segundo byte mais baixo de um tipo de dados maior).
Sintaxe
highByte(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
byte
lowByte ()
[Bits e bytes]
Descrição
Extrai o byte de menor ordem (mais à direita) de uma variável (por exemplo, uma palavra).
Sintaxe
lowByte(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
byte
attachInterrupt ()
[Interrupções externas]
Descrição
Pinos Digitais Com Interrupções
O primeiro parâmetro para attachInterrupt é um número de interrupção. Normalmente você deve usar digitalPinToInterrupt (pin) para traduzir o pino digital real para o número de interrupção específico. Por exemplo, se você se conectar ao pino 3, use digitalPinToInterrupt (3) como o primeiro parâmetro para attachInterrupt.
	BORDA
	PINOS DIGITAIS UTILIZÁVEIS ​​PARA INTERRUPÇÕES
	Uno, Nano, Mini, outros baseados em 328
	2, 3
	Uno WiFi Rev.2
	todos os pinos digitais
	Mega, Mega2560, MegaADK
	2, 3, 18, 19, 20, 21
	Micro, Leonardo, outros baseados em 32u4
	0, 1, 2, 3, 7
	Zero
	todos os pinos digitais, exceto 4
	MKR Family boards
	0, 1, 4, 5, 6, 7, 8, 9, A1, A2
	Vencimento
	todos os pinos digitais
	101
	todos os pinos digitais (somente os pinos 2, 5, 7, 8, 10, 11, 12, 13 trabalham com CHANGE )
Notas e avisos
Nota
Dentro da função anexada, delay()não funcionará e o valor retornado por millis()não será incrementado. Dados seriais recebidos enquanto na função podem ser perdidos. Você deve declarar como volátil quaisquer variáveis ​​que você modifique dentro da função anexada. Veja a seção sobre ISRs abaixo para mais informações.
Usando interrupções
Interrupções são úteis para fazer coisas acontecerem automaticamente em programas de microcontroladores e podem ajudar a resolver problemas de tempo. Boas tarefas para usar uma interrupção podem incluir a leitura de um codificador rotativo ou a monitoração da entrada do usuário.
Se você quisesse assegurar que um programa sempre captasse os pulsos de um codificador rotativo, de modo que nunca perdesse um pulso, tornaria muito complicado escrever um programa para fazer qualquer outra coisa, porque o programa precisaria pesquisar constantemente o sensor linhas para o codificador, a fim de capturar pulsos quando eles ocorreram. Outros sensores também têm uma interface dinâmica semelhante, como tentar ler um sensor de som que está tentando capturar um clique ou um sensor de slot infravermelho (foto-interruptor) tentando pegar uma moeda. Em todas essas situações, o uso de uma interrupção pode liberar o microcontrolador para executar outro trabalho sem perder a entrada.
Sobre Rotinas de Serviço de Interrupção
Os ISRs são tipos especiais de funções que possuem algumas limitações exclusivas que a maioria das outras funções não possuem. Um ISR não pode ter nenhum parâmetro e não deve retornar nada.
Geralmente, um ISR deve ser o mais curto e rápido possível. Se o seu esboço usa múltiplos ISRs, apenas um pode ser executado por vez, outras interrupções serão executadas após o atual terminar em uma ordem que depende da prioridade que eles têm. millis () depende de interrupções para contar, por isso nunca incrementará dentro de um ISR. Como o delay () requer interrupções para o trabalho, ele não funcionará se chamado dentro de um ISR. micros () funciona inicialmente, mas vai começar a se comportar de forma irregular após 1-2 ms. delayMicroseconds () não usa nenhum contador, então funcionará normalmente.
Geralmente variáveis ​​globais são usadas para passar dados entre um ISR e o programa principal. Para garantir que as variáveis ​​compartilhadas entre um ISR e o programa principal sejam atualizadas corretamente, declare-as como volatile.
Para mais informações sobre interrupções, veja as notas de Nick Gammon .
Sintaxe
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);(recomendado) 
attachInterrupt(interrupt, ISR, mode);(não recomendado) 
attachInterrupt(pin, ISR, mode);(não recomendado Arduino Due, Zero, MKR1000, apenas 101)
Parâmetros
interrupt: o número da interrupção ( int) 
pin: o número do pino (Arduino Due, Zero, MKR1000 apenas)
ISR : o ISR para chamar quando a interrupção ocorrer; esta função não deve ter parâmetros e não devolver nada. Esta função é por vezes referida como uma rotina de serviço de interrupção. 
mode: define quando a interrupção deve ser acionada. Quatro constantes são predefinidas como valores válidos:
· BAIXO para acionar a interrupção sempre que o pino estiver baixo
· MUDANÇA para acionar a interrupção sempre que o pino alterar o valor
· AUMENTAR para disparar quando o pino vai de baixo para alto
· FALLING para quando o pino vai de alto a baixo.
As placas Due, Zero e MKR1000 também permitem:
· HIGH para acionar a interrupção sempre que o pino estiver alto.
Retorna
Nada
Exemplo de código
const byte ledPin = 13;
const byte interruptPin = 2;
volatile byte state = LOW;
void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(interruptPin, INPUT_PULLUP);
 attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE);
}
void loop() {
 digitalWrite(ledPin, state);
}
void blink() {
 state = !state;
}
const byte ledPin = 13;
const byte interruptPin = 2;
estado de byte volátil = BAIXO;
void setup () {
  pinMode (ledPin, OUTPUT);
  pinMode (interruptPin, INPUT_PULLUP);
  attachInterrupt (digitalPinToInterrupt (interruptPin), pisca, MUDANÇA);
}
void loop () {
  digitalWrite (ledPin, estado);
}
void blink () {
  estado = estado;
}
Números de Interrupção
Normalmente você deve usar digitalPinToInterrupt (pin), em vez de colocar um número de interrupção diretamente no seu sketch. Os pinos específicos com interrupções e seu mapeamento para interromper o número variam em cada tipo de placa. O uso direto de números de interrupção pode parecer simples, mas pode causar problemas de compatibilidade quando o esboço é executado em uma placa diferente.
No entanto, os esboços mais antigos geralmente têm números de interrupção diretos. Muitas vezes, o número 0 (para o pino digital 2) ou o número 1 (para o pino digital 3) foram usados. A tabela abaixo mostra os pinos de interrupção disponíveis em várias placas.
Observe que na tabela abaixo, os números de interrupção se referem ao número a ser passado para attachInterrupt (). Por razões históricas, esta numeração nem sempre corresponde diretamente à numeração de interrupção no chip atmega (por exemplo, int.0 corresponde a INT4 no chip Atmega2560).
	BORDA
	INT.0
	INT.1
	INT.2
	INT.3
	INT.4
	INT.5
	Uno, Ethernet
	2
	3
	
	
	
	
	Mega2560
	2
	3
	21
	20
	19
	18
	Baseado em 32u4 (por exemplo, Leonardo, Micro)
	3
	2
	0
	1
	7
	
Para Uno WiFiRev.2, Due, Zero, Família MKR e 101 placas, o número de interrupção = número de pinos .
detachInterrupt ()
[Interrupções externas]
Descrição
Desativa a interrupção dada.
Sintaxe
detachInterrupt()
detachInterrupt(pin) (Somente Arduino Due)
Parâmetros
interrupt: o número da interrupção a ser desabilitada (veja attachInterrupt () para mais detalhes).
pin: o número do pino da interrupção a desabilitar (apenas Arduino Due)
Retorna
Nada
interrompe () 
[Interrompe]
Descrição
Reabilita interrupções (depois de terem sido desativadas por nointerrupts () . Interrupções permitem que certas tarefas importantes ocorram em segundo plano e são ativadas por padrão. Algumas funções não funcionarão enquanto as interrupções estiverem desativadas e a comunicação de entrada poderá ser ignorada. No entanto, pode atrapalhar um pouco o tempo do código e pode ser desativado para seções de código particularmente críticas.
Sintaxe
interrupts()
Parâmetros
Nada
Retorna
Nada
Exemplo de código
O código permite interrupções.
void setup() {}
void loop()
{
 noInterrupts();
// código crítico sensível ao tempo aqui
 interrupts();
// outrocódigo aqui
}
noInterrupts ()
[Interrompe]
Descrição
Desativa as interrupções (você pode reativá-las com interrupts()). Interrupções permitem que certas tarefas importantes aconteçam em segundo plano e são ativadas por padrão. Algumas funções não funcionarão enquanto as interrupções estiverem desativadas e a comunicação de entrada poderá ser ignorada. No entanto, as interrupções podem afetar levemente o tempo do código e podem ser desabilitadas para seções de código particularmente críticas.
Sintaxe
noInterrupts()
Parâmetros
Nada
Retorna
Nada
Exemplo de código
O código mostra como ativar interrupções.
void setup() {}
void loop()
{
 noInterrupts();
// código crítico sensível ao tempo aqui
 interrupts();
 // outro código aqui
}
Corrente () fluxo
[Comunicação]
Descrição
Stream é a classe base para fluxos baseados em caracteres e binários. Não é chamado diretamente, mas invocado sempre que você usa uma função que depende dele.
Stream define as funções de leitura no Arduino. Ao usar qualquer funcionalidade principal que use um read()método semelhante, você pode seguramente assumir que ele chama na classe Stream. Para funções como print()Stream, herda da classe Print.
Algumas das bibliotecas que dependem do Stream incluem:
· Serial
· Fio
· Ethernet
· SD
Funções
available () 
Stream.available ()
Descrição
available()Obtém o número de bytes disponíveis no fluxo. Isto é apenas para bytes que já chegaram.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.available()
Parâmetros
stream : uma instância de uma classe que herda do Stream.
Retorna
int : o número de bytes disponíveis para leitura
read () 
Stream.read ()
Descrição
read() lê caracteres de um fluxo de entrada para o buffer.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe stream para mais informações.
Sintaxe
stream.read()
Parâmetros
stream : uma instância de uma classe que herda do Stream.
Retorna
O primeiro byte de dados recebidos disponíveis (ou -1 se não houver dados disponíveis).
flush () 
Stream.flush ()
Descrição
flush() limpa o buffer assim que todos os caracteres de saída forem enviados.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe stream para mais informações.
Sintaxe
stream.flush()
Parâmetros
stream : uma instância de uma classe que herda do Stream.
Retorna
Nada
procurar () 
Stream.find ()
Descrição
find() lê dados do fluxo até que a cadeia de destino de determinado tamanho seja encontrada A função retorna verdadeiro se a cadeia de destino for encontrada, false se expirar.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe stream para mais informações.
Sintaxe
stream.find(target)
Parâmetros
stream : uma instância de uma classe que herda do Stream.
target : a string para procurar por (char)
Retorna
bool
findUntil ()  
Stream.findUntil ()
Descrição
findUntil() lê dados do fluxo até que a cadeia de destino de determinado comprimento ou cadeia terminadora seja encontrada.
A função retorna true se a string de destino for encontrada, false se expirar
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja oLÍNGUA Página principal da classe Stream para mais informações.
Sintaxe
stream.findUntil(target, terminal)
Parâmetros
stream.findUntil(target, terminal)
Retorna
bool
peek () 
Stream.peek ()
Descrição
Leia um byte do arquivo sem avançar para o próximo. Ou seja, as chamadas sucessivas peek()retornarão o mesmo valor, assim como a próxima chamada read().
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.peek()
Parâmetros
stream : uma instância de uma classe que herda do Stream.
Retorna
O próximo byte (ou caractere) ou -1 se nenhum estiver disponível.
Exemplo de código
readBytes () 
Stream.readBytes ()
Descrição
readBytes()ler caracteres de um fluxo em um buffer. A função termina se o comprimento determinado tiver sido lido ou expirar (consulte setTimeout () ).
readBytes()retorna o número de bytes colocados no buffer. Um 0 significa que nenhum dado válido foi encontrado.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.readBytes(buffer, length)
Parâmetros
stream : uma instância de uma classe que herda do Stream.
buffer: o buffer para armazenar os bytes em ( char[]ou byte[])
length : o número de bytes a read(int)
Retorna
O número de bytes colocados no buffer ( size_t)
readBytesUntil () 
Stream.readBytesUntil ()
Descrição
readBytesUntil()lê caracteres de um fluxo em um buffer. A função termina se o caractere terminador for detectado, o comprimento determinado tiver sido lido ou expirar (consulte setTimeout () ).
readBytesUntil()retorna o número de bytes colocados no buffer. Um 0 significa que nenhum dado válido foi encontrado.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.readBytesUntil(character, buffer, length)
Parâmetros
stream : uma instância de uma classe que herda do Stream.
character: o caractere para procurar por ( char)
buffer: o buffer para armazenar os bytes em ( char[]ou byte[])
length : the number of bytes to `read(int)
Retorna
O número de bytes colocados no buffer.
lerString () 
Stream.readString ()
Descrição
readString()lê caracteres de um fluxo em um String. A função termina se expirar (consulte setTimeout () ).
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.readString()
Parâmetros
Nada
Retorna
Um String lido de um fluxo.
lerStringUntil () 
Stream.readStringUntil ()
Descrição
readStringUntil()lê caracteres de um fluxo em um String. A função termina se o caractere terminador for detectado ou expirar (consulte setTimeout () ).
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.readString(terminator)
Parâmetros
terminator: o caractere para procurar por ( char)
Retorna
A String inteira é lida de um fluxo, até que o caractere terminador seja detectado.
parseInt () 
Stream.parseInt ()
Descrição
parseInt()retorna o primeiro número inteiro válido (longo) da posição atual. Caracteres iniciais que não são inteiros (ou o sinal de menos) são ignorados.
Em particular:
· Caracteres iniciais que não são dígitos ou um sinal de menos, são ignorados;
· A análise é interrompida quando nenhum caractere foi lido por um valor de tempo limite configurável ou um não dígito é lido;
· Se nenhum dígito válido foi lido quando o tempo limite (consulte Stream.setTimeout () ) ocorrer, será retornado 0;
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações.
Sintaxe
stream.parseInt(list)
stream.parseInt(''list', char skipchar')
Parâmetros
stream : uma instância de uma classe que herda do Stream.
list: o fluxo para verificar ints ( char)
skipChar: usado para pular o caractere indicado na pesquisa. Usado, por exemplo, para ignorar milhares de divisores.
Retorna
long
parseFloat () 
Stream.parseFloat ()
Descrição
parseFloat()retorna o primeiro número de ponto flutuante válido da posição atual. Caracteres iniciais que não são dígitos (ou o sinal de menos) são ignorados. parseFloat()é terminado peloprimeiro caractere que não é um número de ponto flutuante.
Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja a página principal da classe Stream para mais informações
Sintaxe
stream.parseFloat(list)
Parâmetros
stream : uma instância de uma classe que herda do Stream.
list: o fluxo para verificar se há flutuadores ( char)
Retorna
float
setTimeout ()
Stream.setTimeout ()
Descrição
setTimeout()define o máximo de milissegundos para aguardar dados de fluxo, o padrão é 1000 milissegundos. Esta função faz parte da classe Stream, e é chamada por qualquer classe que herda dela (Wire, Serial, etc). Veja oLÍNGUA Página principal da classe Stream para mais informações.
Sintaxe
stream.setTimeout(time)
Parâmetros
stream: uma instância de uma classe que herda do Stream. time: duração do tempo limite em milissegundos ( long).
Retorna
Nada
Serial
[Comunicação]
Descrição
Usado para comunicação entre a placa Arduino e um computador ou outros dispositivos. Todas as placas Arduino possuem pelo menos uma porta serial (também conhecida como UART ou USART): Serial. Ele se comunica nos pinos digitais 0 (RX) e 1 (TX), bem como com o computador via USB. Assim, se você usar essas funções, não poderá usar os pinos 0 e 1 para entrada ou saída digital. 
Você pode usar o monitor serial interno do ambiente do Arduino para se comunicar com uma placa Arduino. Clique no botão do monitor serial na barra de ferramentas e selecione a mesma taxa de transmissão usada na chamada begin().
A comunicação serial nos pinos TX / RX usa níveis lógicos TTL (5V ou 3.3V dependendo da placa). Não conecte esses pinos diretamente a uma porta serial RS232; eles operam a +/- 12V e podem danificar sua placa Arduino.
O Arduino Mega possui três portas seriais adicionais: Serial1nos pinos 19 (RX) e 18 (TX), Serial2nos pinos 17 (RX) e 16 (TX), Serial3nos pinos 15 (RX) e 14 (TX). Para usar esses pinos para se comunicar com seu computador pessoal, você precisará de um adaptador USB para serial adicional, já que eles não estão conectados ao adaptador USB para serial do Mega. Para usá-los para se comunicar com um dispositivo serial TTL externo, conecte o pino TX ao pino RX do seu dispositivo, o RX ao pino TX do seu dispositivo eo solo do seu Mega ao chão do seu dispositivo.
O Arduino DUE possui três portas seriais 3.3V TTL adicionais: Serial1nos pinos 19 (RX) e 18 (TX); Serial2nos pinos 17 (RX) e 16 (TX), Serial3nos pinos 15 (RX) e 14 (TX). Os pinos 0 e 1 também são conectados aos pinos correspondentes do chip Serial USB para TTL ATmega16U2, que é conectado à porta de depuração USB. Além disso, há uma porta USB serial nativa no chip SAM3X, SerialUSB '.
A placa Arduino Leonardo usa Serial1para comunicar via serial TTL (5V) nos pinos 0 (RX) e 1 (TX). Serialestá reservado para comunicação USB CDC. Para mais informações, consulte a página inicial e a página de hardware do Leonardo.
Funções
if (Serial)
Descrição
Indica se a porta serial especificada está pronta.
No Leonardo, if (Serial)indica se a conexão serial USB do CDC está aberta ou não. Para todos os outros casos, inclusive if (Serial1)no Leonardo, isso sempre retornará verdadeiro.
Isso foi introduzido no Arduino IDE 1.0.1.
Sintaxe
Todas as placas:
if (Serial)
Arduino Leonardo específico:
if (Serial1)
Arduino Mega específico:
if (Serial1)
if (Serial2)
if (Serial3)
Parâmetros
Nada
Retorna
bool: retorna verdadeiro se a porta serial especificada estiver disponível. Isso só retornará false se você consultar a conexão serial do CDC USB do Leonardo antes de estar pronto.
Exemplo de código
void setup() {
 // Inicialize serial e espere a porta abrir:
 Serial.begin(9600);
 while (!Serial) {
 ; // aguarde a porta serial se conectar. Necessário para USB nativo
 }
}
void loop() {
 // prosseguir normalmente
}
 Serial.available ()
Descrição
Obtenha o número de bytes (caracteres) disponíveis para leitura na porta serial. Esses são dados que já chegaram e são armazenados no buffer de recebimento serial (que contém 64 bytes). available()herda da classe do utilitário Stream.
Sintaxe
Serial.available()
Arduino Mega apenas:
Serial1.available()
Serial2.available()
Serial3.available()
Parâmetros
Nenhum
Retorna
O número de bytes disponíveis para leitura.
Exemplo de código
O código a seguir retorna um caractere recebido pela porta serial.
int incomingByte = 0;	// for incoming serial data
void setup() {
	Serial.begin(9600);	// opens serial port, sets data rate to 9600 bps
}
void loop() {
	// resposta somente quando você receber dados:
	if (Serial.available() > 0) {
		// lê o byte de entrada:
		incomingByte = Serial.read();
		// Diga o que tem:
		Serial.print("I received: ");
		Serial.println(incomingByte, DEC);
	}
}
Arduino Mega exemplo: Este código envia dados recebidos em uma porta serial do Arduino Mega para outra. Isso pode ser usado, por exemplo, para conectar um dispositivo serial ao computador através da placa Arduino.
void setup() {
 Serial.begin(9600);
 Serial1.begin(9600);
}
void loop() {
 // leitura de porta 0, enviar para porta 1:
 if (Serial.available()) {
 int inByte = Serial.read();
 Serial1.print(inByte, DEC);
 }
 // ler da porta 1, envie para a porta 0:
 if (Serial1.available()) {
 int inByte = Serial1.read();
 Serial.print(inByte, DEC);
 }
}
availableForWrite () 
Serial.availableForWrite ()
Descrição
Obtenha o número de bytes (caracteres) disponíveis para gravação no buffer serial sem bloquear a operação de gravação.
Sintaxe
Serial.availableForWrite()
Arduino Mega apenas:
Serial1.availableForWrite()
Serial2.availableForWrite()
Serial3.availableForWrite()
Parâmetros
Nada
Retorna
O número de bytes disponíveis para gravação.
begin () 
Serial.begin ()
Descrição
Define a taxa de dados em bits por segundo (baud) para transmissão de dados serial. Para se comunicar com o computador, use uma das seguintes taxas: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 ou 115200. Você pode, no entanto, especificar outras taxas - por exemplo, comunicar os pinos 0 e 1 com um componente que requer uma taxa de transmissão específica.
Um segundo argumento opcional configura os dados, a paridade e os bits de parada. O padrão é 8 bits de dados, sem paridade, um bit de parada.
Sintaxe
Serial.begin(speed) Serial.begin(speed, config)
Arduino Mega apenas:
Serial1.begin(speed)
Serial2.begin(speed)
Serial3.begin(speed)
Serial1.begin(speed, config)
Serial2.begin(speed, config)
Serial3.begin(speed, config)
Parâmetros
speed: em bits por segundo (baud) - long
config: define dados, paridade e bits de parada. Valores válidos são
SERIAL_5N1
SERIAL_6N1
SERIAL_7N1
SERIAL_8N1 (o padrão)
SERIAL_5N2
SERIAL_6N2
SERIAL_7N2
SERIAL_8N2
SERIAL_5E1
SERIAL_6E1
SERIAL_7E1
SERIAL_8E1
SERIAL_5E2
SERIAL_6E2
SERIAL_7E2
SERIAL_8E2
SERIAL_5O1
SERIAL_6O1
SERIAL_7O1
SERIAL_8O1
SERIAL_5O2
SERIAL_6O2
SERIAL_7O2
SERIAL_8O2
Retorna
Nada
Exemplo de código
void setup() {
 Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}
void loop() {}
Arduino Mega exemplo:
// Arduino Mega usando todos os quatro de suas portas seriais Arduino Mega usando todos os quatro de suas portas seriais // (Serial, Serial1, Serial2, Serial3),
// com taxas de transmissão diferentes:
void setup(){
 Serial.begin(9600);
 Serial1.begin(38400);
 Serial2.begin(19200);
 Serial3.begin(4800);
 Serial.println("Hello Computer");
 Serial1.println("Hello Serial 1");
 Serial2.println("Hello Serial 2");
 Serial3.println("Hello Serial 3");
}
void loop() {}
Obrigado a Jeff Gray pelo mega exemplo
end () 
Serial.end ()
Descrição
Desativa a comunicação serial, permitindo que os pinos RX e TX sejam usados ​​para entrada e saída gerais. Para reativar a comunicação serial, chame Serial.begin () .
Sintaxe
Serial.end()
Arduino Mega apenas:
Serial1.end()
Serial2.end()
Serial3.end()
Parâmetros
Nada
Retorna
Nada
find () 
Serial.find ()
Descrição
Serial.find () lê os dados do buffer serial até que a string de destino de determinado tamanho seja encontrada. A função retorna true se astring de destino for encontrada, false se expirar.
Serial.find () herda da classe do utilitário de fluxo .
Sintaxe
Serial.find(target)
Parâmetros
target : a string para procurar por (char)
Retorna
bool
findUntil () 
Serial.findUntil ()
Descrição
Serial.findUntil() lê dados do buffer serial até que uma string de destino de determinado comprimento ou string de terminador seja encontrada.
A função retorna true se a string de destino for encontrada, false se expirar.
Serial.findUntil()herda da classe do utilitário Stream .
Sintaxe
Serial.findUntil(target, terminal)
Parâmetros
target: a string para procurar (char) terminal: a string do terminal na pesquisa (char)
Retorna
bool
Notas e avisos
flush () 
Serial.flush ()
Descrição
Aguarda pela transmissão de dados seriais de saída para concluir. (Antes do Arduino 1.0, isso removia todos os dados seriais recebidos em buffer.)
flush()herda da classe do utilitário Stream .
Sintaxe
Serial.flush()
Arduino Mega apenas:
Serial1.flush()
Serial2.flush()
Serial3.flush()
Parâmetros
Nada
Retorna
Nada
parseFloat () 
Serial.parseFloat ()
Descrição
Serial.parseFloat()retorna o primeiro número de ponto flutuante válido do buffer Serial. Caracteres que não são dígitos (ou o sinal de menos) são ignorados. parseFloat()é terminado pelo primeiro caractere que não é um número de ponto flutuante.
Serial.parseFloat()herda da classe do utilitário Stream .
Sintaxe
Serial.parseFloat()
Parâmetros
Nada
Retorna
float
parseInt () 
Serial.parseInt ()
Descrição
Procura o próximo inteiro válido na série recebida, stream.parseInt()herda da classe do utilitário Stream .
Em particular:
· Caracteres iniciais que não são dígitos ou um sinal de menos, são ignorados;
· A análise é interrompida quando nenhum caractere foi lido por um valor de tempo limite configurável ou um não dígito é lido;
· Se nenhum dígito válido foi lido quando o tempo limite (consulte Serial.setTimeout ()) ocorrer, será retornado 0;
Sintaxe
Serial.parseInt() Serial.parseInt(char skipChar)
Arduino Mega apenas:
Serial1.parseInt()
Serial2.parseInt()
Serial3.parseInt()
Parâmetros
skipChar: usado para pular o caractere indicado na pesquisa. Usado, por exemplo, para ignorar milhares de divisores.
Retorna
long : o próximo inteiro válido
espiada () 
Serial.peek ()
Descrição
Retorna o próximo byte (caractere) dos dados seriais recebidos sem removê-lo do buffer serial interno. Ou seja, as chamadas sucessivas peek()retornarão o mesmo caractere, assim como a próxima chamada read(). peek()herda da classe do utilitário Stream .
Sintaxe
Serial.peek()
Arduino Mega apenas:
Serial1.peek()
Serial2.peek()
Serial3.peek()
Parâmetros
Nada
Retorna
O primeiro byte de dados seriais recebidos disponíveis (ou -1 se não houver dados disponíveis) - int
print () 
Serial.print ()
Descrição
Imprime dados na porta serial como texto ASCII legível por humanos. Este comando pode ter várias formas. Os números são impressos usando um caractere ASCII para cada dígito. Flutuadores são impressos da mesma forma que os dígitos ASCII, com o padrão de duas casas decimais. Bytes são enviados como um único caractere. Caracteres e strings são enviados como estão. Por exemplo-
· Serial.print(78) gives "78"
· Serial.print(1.23456) gives "1.23"
· Serial.print('N') gives "N"
· Serial.print("Hello world.") gives "Hello world."
Um segundo parâmetro opcional especifica a base (formato) a ser usada; valores permitidos são BIN(binary, or base 2), OCT(octal, or base 8), DEC(decimal, or base 10), HEX(hexadecimal, or base 16). Para números de ponto flutuante, esse parâmetro especifica o número de casas decimais a serem usadas. Por exemplo-
· Serial.print(78, BIN) gives "1001110"
· Serial.print(78, OCT) gives "116"
· Serial.print(78, DEC) gives "78"
· Serial.print(78, HEX) gives "4E"
· Serial.print(1.23456, 0) gives "1"
· Serial.print(1.23456, 2) gives "1.23"
· Serial.print(1.23456, 4) gives "1.2346"
Você pode passar strings baseadas em memória flash para Serial.print () agrupando-as com F () . Por exemplo:
Serial.print(F(“Hello World”))
Para enviar dados sem conversão para sua representação como caracteres, use Serial.write () .
Sintaxe
Serial.print(val)
Serial.print(val, format)
Parâmetros
val: o valor a imprimir - qualquer tipo de dados
Retorna
size_t: print()retorna o número de bytes escritos, embora a leitura desse número seja opcional.
Exemplo de código
/*
Uses a for loop to print numbers in various formats.// Usa um loop para imprimir números em vários formatos.
*/
void setup() {
 Serial.begin(9600); // Abra a porta serial a 9600 bps:
}
void loop() {
 // print labels
 Serial.print("NO FORMAT"); // imprime uma etiqueta
 Serial.print("\t"); // imprime uma guia
 Serial.print("DEC");
 Serial.print("\t");
 Serial.print("HEX");
 Serial.print("\t");
 Serial.print("OCT");
 Serial.print("\t");
 Serial.print("BIN");
 Serial.println(); // retorno após a última etiqueta
 for (int x = 0; x < 64; x++) { // apenas uma parte do gráfico de ASCII, mudança para se adequar
 // imprimi-lo em vários formatos: 
Serial.print(x); // imprimir como um decimal codificado em ASCII - o mesmo que "DEC"
Serial.print("\t\t"); // imprime duas guias para acomodar o comprimento da etiqueta
 Serial.print(x, DEC); // imprimir como um decimal codificado em ASCII	
 Serial.print("\t"); // imprime uma guia
 Serial.print(x, HEX); // imprimir como um hexadecimal codificado em ASCII
 Serial.print("\t"); // imprime uma guia
 Serial.print(x, OCT); // imprimir como um codificado em ASCII octal 
 Serial.print("\t"); // imprime uma guia
 Serial.println(x, BIN); // imprimir como um binário codificado em ASCII
 // em seguida, adiciona o retorno de carro com "println"
 delay(200); // atraso de 200 milissegundos
 }
 Serial.println(); // imprime um outro retorno
}
Notas e avisos
A partir da versão 1.0, a transmissão serial é assíncrona; Serial.print()retornará antes que qualquer caractere seja transmitido.
println ()  
Serial.println ()
Descrição
Imprime dados na porta serial como texto ASCII legível por humanos seguido por um caractere de retorno de carro (ASCII 13 ou '\ r') e um caractere de nova linha (ASCII 10 ou '\ n'). Esse comando usa os mesmos formulários do Serial.print () .
Sintaxe
Serial.println(val)
Serial.println(val, format)
Parâmetros
val: o valor a imprimir - qualquer tipo de dados
format: especifica a base numérica (para tipos de dados integrais) ou o número de casas decimais (para tipos de ponto flutuante)
Retorna
size_t: println()retorna o número de bytes escritos, embora a leitura desse número seja opcional
Exemplo de código
/*
Entrada analógica lê uma entrada analógica no analógico em 0, imprime o valor.
 criado em 24 de março de 2006 by Tom Igoe
 */
int analogValue = 0; // variável para armazenar o valor analógico
void setup() {
 // Abra a porta serial a 9600 bps: Serial.begin(9600);
}
void loop() {
 // ler a entrada analógica no pino 0:
 analogValue = analogRead(0);
 // print it out in many formats:
 Serial.println(analogValue); // imprimir como um decimal codificado em ASCII
 Serial.println(analogValue, DEC); // imprimir como um decimal codificado em ASCII
 Serial.println(analogValue, HEX); // imprimir como um hexadecimal codificado em ASCII
 Serial.println(analogValue, OCT); // imprimir como um codificado em ASCII octal Serial.println(analogValue, BIN); // imprimir como um binário codificado em ASCII
 // Demora 10 milissegundos antes da próxima leitura:
 delay(10)	
read () 
Serial.read ()
Descrição
Lê dados seriais recebidos. read () herda da classe do utilitário Stream .
Sintaxe
Serial.read()
Arduino Mega apenas:
Serial1.read()
Serial2.read()
Serial3.read()
Parâmetros
Nada
Retorna
O primeiro byte de dados seriais recebidos disponíveis (ou -1 se não houver dados disponíveis) - int.
Exemplo de código
int incomingByte = 0; // para entrada de dados serial
void setup() {
 Serial.begin(9600); // Abre a porta serial, define a taxa de dados para 9600 bps