id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
a6a2c7a3fc5f-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Advanced io
> Pulseinlong
pulseInLong()
[Advanced I/O]
Descrição | https://www.arduino.cc/reference/pt/language/functions/advanced-io/pulseinlong/index.html |
a6a2c7a3fc5f-1 | pulseInLong()
[Advanced I/O]
Descrição
pulseInLong() é uma alternativa à função pulseIn(), sendo melhor para lidar com pulsos longos e situações afetadas por interrupções.
Lê um pulso (HIGH ou LOW) em um pino. Por exemplo, se o valor for HIGH, pulseInLong() espera que o pino vá HIGH, começa a cronometrar e, em seguida, espera que o pino vá LOW e pára de cronometrar. Retorna a duração do pulso em microssegundos ou 0 se nenhum pulso completo foi recebido dentro do tempo limite. | https://www.arduino.cc/reference/pt/language/functions/advanced-io/pulseinlong/index.html |
a6a2c7a3fc5f-2 | A temporização dessa função foi determinada empiricamente e irá provavelmente mostrar erros em pulsos mais curtos. Funciona em pulsos de 10 microssegundos a 3 minutos de duração. Por favor note que se a função for configurada para recebr um pulso HIGH e o pino já estiver no estado HIGH quando a função for chamada, essa irá primeiro esperar o pino ir para estado LOW e então HIGH antes de começar a contar. Essa função pode ser utilizada apenas quando interrupções estiverem ativadas. Além disso, resoluções maiores são alcançadas com intervalos maiores.
Sintaxe
pulseInLong(pino, valor)
pulseInLong(pino, valor, tempo_de_espera)
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/advanced-io/pulseinlong/index.html |
a6a2c7a3fc5f-3 | pulseInLong(pino, valor, tempo_de_espera)
Parâmetros
pino: o número do pino do Arduino no qual se quer capturar a duração de um pulso. (int)
valor: tipo de pulso a ser lido: pode ser HIGH ou LOW. (int)
tempo_de_espera (opcional): o número de microssegundos a se esperar pelo começo do pulso; o padrão é um segundo. (unsigned long)
Retorna
A duração do pulso (em microssegundos) ou 0 se nenhum pulso começar antes de se esgotar o tempo de espera (unsigned long).
Código de Exemplo
O exemplo abaixo imprime na porta serial a duração de um pulso no pino 7.
int pino = 7; // pino para a entrada do pulso | https://www.arduino.cc/reference/pt/language/functions/advanced-io/pulseinlong/index.html |
a6a2c7a3fc5f-4 | int pino = 7; // pino para a entrada do pulso
unsigned long duracao; // variável para guardar a duração do pulso
void setup() {
Serial.begin(9600);
pinMode(pino, INPUT);
}
void loop() {
duracao = pulseInLong(pino, HIGH);
Serial.println(duracao);
}
Notes and Warnings
Essa função depende da função micros(), então não pode ser usada quando interrupções estiverem desativadas com noInterrupts().
Ver Também | https://www.arduino.cc/reference/pt/language/functions/advanced-io/pulseinlong/index.html |
17cfd5a6b3fb-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Advanced io
> Shiftout
shiftOut()
[Advanced I/O]
Descrição | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-1 | shiftOut()
[Advanced I/O]
Descrição
Transfere um byte de dados um bit de cada vez. Começa com ou o bit mais significante (o mais à esquerda) ou o menos significante (mais à direita). Cada bit é escrito em sequência em um pino data, logo após o pino clock é pulsado (colocado em HIGH, depois LOW) para indicar que aquele bit está disponível.
Nota - se você está conectando um dispositivo que é sincronizado pela borda de subida do clock, irá precisar fazer com que o pino clock seja low antes de chamar shiftOut(), ex. com digitalWrite(clockPin, LOW). | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-2 | Essa é uma implementação por software; O Arduino também provê uma biblioteca SPI que faz a implementação em hardware, que é mais rápida, mas apenas funciona em pinos específicos.
Sintaxe
shiftOut(dataPin, clockPin, bitOrder, value)
Parâmetros
dataPin: o pino no qual transferir cada bit (int)
clockPin: o pino a ser pulsado uma vez que o pino data estiver com o bit a ser trasnferido (int)
bitOrder: em que ordem receber os bits; pode ser MSBFIRST ou LSBFIRST. Respectivamente, primeiro o bit mais significativo (Most Significant Bit First), ou o primeiro o bit menos significativo (Least Significant Bit First)
value: o valor a ser transferido. (byte)
Retorna
Nada
Código de Exemplo | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-3 | Retorna
Nada
Código de Exemplo
Para o circuito, ver o tutorial sobre o controle de um registrador de deslocamento 74HC595 (Em Inglês).
//**************************************************************//
// 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 //
//****************************************************************
//Pino conectado a ST_CP no 74HC595
int latchPin = 8;
//Pino conectado a SH_CP no 74HC595
int clockPin = 12;
//Pino conectado a DS no 74HC595 | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-4 | //Pino conectado a DS no 74HC595
int dataPin = 11;
void setup() {
//configura os pinos usados no loop principal como saídas
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
//rotina de contagem de 0 até 255
for (int j = 0; j < 256; j++) {
//coloca e mantém o pino latch em low enquanto ocorre a transmissão
digitalWrite(latchPin, LOW);
//transmite o valor de j, a começar pelo bit menos significativo
shiftOut(dataPin, clockPin, LSBFIRST, j);
//retorna o pino latch para high para sinalizar ao chip
//que esse não precisa mais esperar por informação | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-5 | //que esse não precisa mais esperar por informação
digitalWrite(latchPin, HIGH);
delay(1000);
}
}
Notas e Advertências
Os pinos data e clock devem ser configurados como saídas com uma chamada de pinMode().
A função shiftOut() atualmente funciona para transferir apenas 1 byte (8 bits) então requer uma operação em dois passos para transferir valores maiores que 255.
// Para serial MSBFIRST, faça:
int data = 500;
// transfere o byte mais significativo
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// trasnfere o byte menos significativo
shiftOut(dataPin, clock, MSBFIRST, data);
// Para serial LSBFIRST, faça:
data = 500;
// transfere o byte menos significativo | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
17cfd5a6b3fb-6 | data = 500;
// transfere o byte menos significativo
shiftOut(dataPin, clock, LSBFIRST, data);
// transfere o byte mais significativo
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));
Ver Também | https://www.arduino.cc/reference/pt/language/functions/advanced-io/shiftout/index.html |
fceab10f8268-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Advanced io
> Notone
noTone()
[Advanced I/O]
Descrição | https://www.arduino.cc/reference/pt/language/functions/advanced-io/notone/index.html |
fceab10f8268-1 | noTone()
[Advanced I/O]
Descrição
Interrompe a geração de uma onda quadrada iniciada pela função tone(). Não tem nenhum efeito se nenhum tom está sendo gerado.
Sintaxe
noTone(pino)
Parâmetros
pino: o pino do Arduino no qual se quer parar de gerar um tom.
Retorna
Nada
Notas e Advertências
Se você quiser tocar tons diferentes em múltiplos pinos, você precisa chamar noTone() em um pino antes de chamar tone() no próximo pino.
Ver Também | https://www.arduino.cc/reference/pt/language/functions/advanced-io/notone/index.html |
3527583f4968-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Random numbers
> Randomseed
randomSeed()
[Random Numbers]
Descrição | https://www.arduino.cc/reference/pt/language/functions/random-numbers/randomseed/index.html |
3527583f4968-1 | randomSeed()
[Random Numbers]
Descrição
randomSeed() inicializa o gerador de números pseudoaleatórios, fazendo o começar em um ponto arbitrário em sua sequência aleatória. Essa sequência, enquanto muito longa, e aleatória, é sempre a mesma.
Se é importante que uma sequência de valores gerados por random() seja diferente em execuções subsequentes de um sketch, use randomSeed() para inicializar o gerador de números aleatórios com uma entrada significantemente aleatória, como analogRead() em um pino desconectado.
Por outro lado, pode ser ocasionalmente útil usar sequências pseudoaleatórias exatamente repetidas. Isso pode ser conseguido chamando-se randomSeed() com um número fixo, antes de começar a usar a sequência aleatória.
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/random-numbers/randomseed/index.html |
3527583f4968-2 | Parâmetros
seed - número para inicializar a sequência pseudoaleatória (long).
Retorna
Nada
Código de Exemplo
O código abaixo imprime números aleatórios na porta serial.
long randNumber;
void setup() {
// inicializa a porta serial.
Serial.begin(9600);
// inicializa o gerador de números aleatórios.
// um pino analógico desconectado irá retornar um
// valor aleatório de tensão em analogRead()
randomSeed(analogRead(0));
}
void loop() {
// calcula o próximo número aleatório entre 0 e 299
randNumber = random(300);
// imprime o valor na porta serial
Serial.println(randNumber);
delay(50);
}
Ver Também | https://www.arduino.cc/reference/pt/language/functions/random-numbers/randomseed/index.html |
a601f1b2b6e3-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Random numbers
> Random
random()
[Random Numbers]
Descrição
A função random() gera números pseudoaleatórios.
Sintaxe
random(max) | https://www.arduino.cc/reference/pt/language/functions/random-numbers/random/index.html |
a601f1b2b6e3-1 | Sintaxe
random(max)
random(min, max)
Parâmetros
min - menor limite do valor aleatório, inclusivo e opcional (long)
max - maior limite do valor aleatório, exclusivo (long)
Retorna
Um número inteiro aleatório entre min e max-1 (long) .
Código de exemplo
O código abaixo gera números aleatórios e os imprime na porta serial.
long randNumber;
void setup() {
Serial.begin(9600);
// Se o pino de entrada analógica 0 é deixado desconectado,
// o ruído aleatório analógico irá causar a chamada de randomSeed()
// gerar sementes aleatórias diferentes cada vez que o sketch roda.
// randomSeed() basicamente "embaralha" a função random(). | https://www.arduino.cc/reference/pt/language/functions/random-numbers/random/index.html |
a601f1b2b6e3-2 | // randomSeed() basicamente "embaralha" a função random().
randomSeed(analogRead(0));
}
void loop() {
// imprime um número aleatório entre 0 e 299
randNumber = random(300);
Serial.println(randNumber);
// imprime um valor aleatório entre 10 e 19
randNumber = random(10, 20);
Serial.println(randNumber);
delay(50);
}
Notas e Advertências
Se é importante que uma sequência de valores gerados por random() seja diferente em execuções subsequentes de um sketch, use randomSeed() para inicializar o gerador de números aleatórios com uma entrada significantemente aleatória, como analogRead() em um pino desconectado. | https://www.arduino.cc/reference/pt/language/functions/random-numbers/random/index.html |
a601f1b2b6e3-3 | Por outro lado, pode ser ocasionalmente útil usar sequências pseudoaleatórias exatamente repetidas. Isso pode ser conseguido chamando-se randomSeed() com um número fixo, antes de começar a usar a sequência aleatória.
O parâmetro max deve ser escolhido de acordo com o tipo de dado da variável na qual o valor será guardado. De qulquer forma, o valor máximo absoluto é limitado pela natureza long (32 bit - 2,147,483,647) do valor gerado. Escolher um valor max maior que isso não irá gerar erros durante a compilação, mas durante a execução do sketch, os números gerados irão se comportar de forma impredizível.
Ver Também | https://www.arduino.cc/reference/pt/language/functions/random-numbers/random/index.html |
237514a186e1-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Ishexadecimaldigit
isHexadecimalDigit()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/ishexadecimaldigit/index.html |
237514a186e1-1 | isHexadecimalDigit()
[Characters]
Descrição
Analisa se uma caractere é um digito hexadecimal (A-F, 0-9). Retorna true se thisChar contém um digito hexadecimal.
Sintaxe
isHexadecimalDigit(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um digito hexadecimal.
Código de Exemplo
if (isHexadecimalDigit(meuChar)) { // testa se meuChar é um digito hexadecimal
Serial.println("The character is an hexadecimal digit");
}
else {
Serial.println("The character is not an hexadecimal digit");
}
Ver Também
INGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/ishexadecimaldigit/index.html |
237514a186e1-2 | LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/ishexadecimaldigit/index.html |
3a041ab9d574-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Islowercase
isLowerCase()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/islowercase/index.html |
3a041ab9d574-1 | isLowerCase()
[Characters]
Descrição
Analisa se uma caractere é minúsculo (isto é, uma letra minúscula). Retorna true se thisChar contém uma letra minúscula.
Sintaxe
isLowerCase(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é minúsculo.
Código de Exemplo
if (isLowerCase(meuChar)) { // testa se meuChar é uma letra minúscula
Serial.println("The character is lower case");
}
else {
Serial.println("The character is not lower case");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/islowercase/index.html |
ca00061aa337-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Ispunct
isPunct()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/ispunct/index.html |
ca00061aa337-1 | isPunct()
[Characters]
Descrição
Analisa se uma caractere é pontuação (isto é, uma vírgula, um ponto-e-vírgula, um ponto de exlamação etc). Retorna true se thisChar é um caractere de pontuação.
Sintaxe
isPunct(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um caractere de pontuação
Código de Exemplo
if (isPunct(meuChar)) { // testa se meuChar é um caractere de pontuação
Serial.println("The character is a punctuation");
}
else {
Serial.println("The character is not a punctuation");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/ispunct/index.html |
ca00061aa337-2 | LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/ispunct/index.html |
fb3714ea16df-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isuppercase
isUpperCase()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isuppercase/index.html |
fb3714ea16df-1 | isUpperCase()
[Characters]
Descrição
Analisa se uma caractere é maiúsculo (isto é, uma letra maisúcula). Retorna true se thisChar é uma letra maiúscula.
Sintaxe
isUpperCase(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é uma letra maiúscula.
Código de Exemplo
if (isUpperCase(meuChar)) { // testa se meuChar é uma letra maiúscula
Serial.println("The character is upper case");
}
else {
Serial.println("The character is not upper case");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/isuppercase/index.html |
fb3714ea16df-2 | LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isuppercase/index.html |
6d7e08c0a253-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isspace
isSpace()
[Characters]
Descrição
Analisa se uma caractere é o caractere de espaço. Retorna true se thisChar contém um espaço. | https://www.arduino.cc/reference/pt/language/functions/characters/isspace/index.html |
6d7e08c0a253-1 | Sintaxe
isSpace(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é o caractere de espaço.
Código de Exemplo
if (isSpace(meuChar)) { // testa se meuChar é o caractere de espaço
Serial.println("The character is a space");
}
else {
Serial.println("The character is not a space");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isspace/index.html |
547fe1753988-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isalpha
isAlpha()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isalpha/index.html |
547fe1753988-1 | isAlpha()
[Characters]
Descrição
Analisa se um caractere é alfabético (isto é, se é uma letra). Retorna true (verdadeiro) se thisChar contém uma letra.
Sintaxe
isAlpha(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um caractere alfabético.
Código de Exemplo
if (isAlpha(meuChar)) { // testa se a variável meuChar é uma letra
Serial.println("The character is a letter");
}
else {
Serial.println("The character is not a letter");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isalpha/index.html |
5aa7d964bf6a-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isprintable
isPrintable()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isprintable/index.html |
5aa7d964bf6a-1 | isPrintable()
[Characters]
Descrição
Analisa se uma caractere é imprimível (isto é, qualquer caractere que produz uma saída, até mesmo um espaço). Retorna true se thisChar é imprimível. Por impimível diz-se os caracteres que pode ser impressos, como letras e números. Alguns caracteres são para controle e não podem ser impressos como o new line ('\n') e o tab ('\t').
Sintaxe
isPrintable(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é imprimível.
Código de Exemplo
if (isPrintable(meuChar)) { // testa se meuChar é imprimível
Serial.println("The character is printable");
}
else {
Serial.println("The character is not printable"); | https://www.arduino.cc/reference/pt/language/functions/characters/isprintable/index.html |
5aa7d964bf6a-2 | }
else {
Serial.println("The character is not printable");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isprintable/index.html |
4689ce9cb8ea-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Iscontrol
isControl()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/iscontrol/index.html |
4689ce9cb8ea-1 | isControl()
[Characters]
Descrição
Analisa se uma caractere é um caractere de controle. Retorna true (verdadeiro) se thisChar é 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.
Código de Exemplo
if (isControl(meuChar)) { // testa se a variável meuChar é um caractere de controle
Serial.println("The character is a control character");
}
else {
Serial.println("The character is not a control character");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/iscontrol/index.html |
4689ce9cb8ea-2 | LINGUAGEM while (operadores condicionais)
LINGUAGEME read() | https://www.arduino.cc/reference/pt/language/functions/characters/iscontrol/index.html |
e95a266efa95-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isgraph
isGraph()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isgraph/index.html |
e95a266efa95-1 | isGraph()
[Characters]
Descrição
Analisa se um caractere é imprimível com algum conteúdo (espaços são imprimíveis, mas não possuem conteúdo). Retorna true se thisChar é imprimível.
Sintaxe
isGraph(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é imprimível.
Código de Exemplo
if (isGraph(meuChar)) { // testa se meuChar é um caractere imprimível mas não um espaço.
Serial.println("The character is printable");
}
else {
Serial.println("The character is not printable");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/isgraph/index.html |
e95a266efa95-2 | LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isgraph/index.html |
634cb78fe827-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Iswhitespace
isWhitespace()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/iswhitespace/index.html |
634cb78fe827-1 | isWhitespace()
[Characters]
Descrição
Analisa se um caractere é um espaço em branco, isto é o próprio caractere de espaço (' '), formfeed ('\f'), nova linha ('\n'), retorno ('\r'), tab horizontal tab ('\t') e tab vertical ('\v')).
Retorna true se thisChar contém um espaço em branco.
Sintaxe
isWhitespace(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um caractere de espaço em branco.
Código de Exemplo
if (isWhitespace(meuChar)) { // testa se meuChar é um caractere de espaço em branco
Serial.println("The character is a white space");
}
else {
Serial.println("The character is not a white space");
}
Ver Também | https://www.arduino.cc/reference/pt/language/functions/characters/iswhitespace/index.html |
634cb78fe827-2 | Serial.println("The character is not a white space");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/iswhitespace/index.html |
bfcb9512249e-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isascii
isAscii()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isascii/index.html |
bfcb9512249e-1 | isAscii()
[Characters]
Descrição
Analisa se um caractere é Ascii. Retorna true se a variável thisChar contém um caractere Ascii.
Sintaxe
isAscii(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um caractere Ascii.
Código de Exemplo
if (isAscii(meuChar)) { // testa se meuChar é um caractere Ascii
Serial.println("The character is Ascii");
}
else {
Serial.println("The character is not Ascii");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isascii/index.html |
1234c56ed96e-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isalphanumeric
isAlphaNumeric()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isalphanumeric/index.html |
1234c56ed96e-1 | isAlphaNumeric()
[Characters]
Descrição
Analisa se um caractere é alfanumérico (isto é, uma letra ou um número). Retorna true (verdadeiro) se thisChar contém ou uma letra ou um número.
Sintaxe
isAlphaNumeric(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se a variável thisChar é uma letra ou um número..
Código de Exemplo
if (isAlphaNumeric(meuChar)) { // testa se meuChar é uma letra ou um número
Serial.println("The character is alphanumeric");
}
else {
Serial.println("The character is not alphanumeric");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais) | https://www.arduino.cc/reference/pt/language/functions/characters/isalphanumeric/index.html |
1234c56ed96e-2 | LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isalphanumeric/index.html |
f0b14ae32e6d-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Characters
> Isdigit
isDigit()
[Characters]
Descrição | https://www.arduino.cc/reference/pt/language/functions/characters/isdigit/index.html |
f0b14ae32e6d-1 | isDigit()
[Characters]
Descrição
Analisa se uma caractere é um digito (isto é, um número). Retorna true (verdadeiro) se thisChar é um número.
Sintaxe
isDigit(thisChar)
Parâmetros
thisChar: variável. Tipos de dados permitidos: char
Retorna
true: se thisChar é um número.
Código de Exemplo
if (isDigit(meuChar)) { // testa se meuChar é um digito
Serial.println("The character is a number");
}
else {
Serial.println("The character is not a number");
}
Ver Também
LINGUAGEM char
LINGUAGEM if (operadores condicionais)
LINGUAGEM while (operadores condicionais)
LINGUAGEM read() | https://www.arduino.cc/reference/pt/language/functions/characters/isdigit/index.html |
1a698d48f82a-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Zero due mkr family
> Analogwriteresolution
analogWriteResolution()
[Zero, Due & MKR Family]
Descrição | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-1 | [Zero, Due & MKR Family]
Descrição
analogWriteResolution() é uma extensão da API Analog para os Arduinos Due, Zero e MKR.
analogWriteResolution() configura a resolução da função analogWrite(). O padrão é 8 bits (valores entre 0-255) para compatibilidade com placas baseadas em microcontroladores AVR.
O Due possui as seguintes capacidades em seu hardware:
12 pinos com PWM de 8-bit por padrão, como as placas baseadas em AVR. Estes podem ser mudados para resolução 12-bits.
2 pinos com DAC 12-bit (Do Inglês, Digital-to-Analog Converter). | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-2 | Ao configurar a resolução para 12 bits, você pode usar analogWrite() com valores entre 0 e 4095 para tirar vantagem da resolução completa do DAC ou do sinal PWM.
O Zero possui as seguintes capacidades em seu hardware:
10 pinos com PWM de 8-bit por padrão, como as placas baseadas em AVR. Estes podem ser mudados para resolução 12-bits.
1 pinos com DAC 12-bit (Do Inglês, Digital-to-Analog Converter).
Ao configurar a resolução para 10 bits, você pode usar analogWrite() com valores entre 0 e 1023 para tirar vantagem da resolução completa do DAC.
A família MKR de placas possui as seguintes capacidades em seu hardware: | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-3 | A família MKR de placas possui as seguintes capacidades em seu hardware:
4 pinos com PWM de 8-bit por padrão, como as placas baseadas em AVR. Estes podem ser mudados para resolução 12-bits.
1 pino com DAC 10-bit (Do Inglês, Digital-to-Analog Converter).
Ao configurar a resolução para 12 bits, você pode usar analogWrite() com valores entre 0 e 4095 para sinais PWM; Use 10 bits no pino do conversor digital-analógico para tira vantagem da resoulção completa de 1024 valores do DAC.
Sintaxe
analogWriteResolution(bits)
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-4 | Sintaxe
analogWriteResolution(bits)
Parâmetros
bits: determina a resolução (em bits) dos valores usados na função analogWrite(). Se você escolher uma resolução maior ou menor que a capacidade do hardware da sua placa, o valor usado em analogWrite() será ou truncado se é muito grande ou completo com preenchido com zeros se for muito pequeno. Veja a nota abaixo para detalhes.
Retorna
Nada
Código de Exemplo
O código configura a resolução da saída PWM para diferentes valores.
void setup() {
// inicia a porta serial
Serial.begin(9600);
// configura os pinos digitais 11 a 13 como saída
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}
void loop() { | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-5 | pinMode(13, OUTPUT);
}
void loop() {
// Lê o valor analógico em A0 e mapeia-o para
// um pino PWM com um LED conectado
int sensorVal = analogRead(A0);
Serial.print("Analog Read) : ");
Serial.print(sensorVal);
// a resolução PWM padrão
analogWriteResolution(8);
analogWrite(11, map(sensorVal, 0, 1023, 0, 255));
Serial.print(" , 8-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 255));
// Muda a reolução PWM para 12 bits
// A resolução completa de 12 bits é suportada
// apenas no Due
analogWriteResolution(12); | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-6 | // apenas no Due
analogWriteResolution(12);
analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
Serial.print(" , 12-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));
// Muda a reolução 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 Advertências | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-7 | delay(5);
}
Notas e Advertências
Se você configurar analogWriteResolution() com um valor maior que a capacidade de sua placa, o Arduino irá descartar os bits extras. Por exemplo: ao configurar o Due com analogWriteResolution(16) em um pino DAC 12-bit, apenas os primeiros 12 bits dos valores passados para analogWrite() serão usados e os outros 4 bits serão descartados. | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
1a698d48f82a-8 | Se você configurar analogWriteResolution() com um valor menor que a capacidade de sua placa, os bits ausentes serão completos com zeros para preencher o tamanho requerido pelo hardware. Por exemplo: ao configurar o Due com analogWriteResolution(8) em um pino DAC 12-bit, o Arduino irá adicionar 4 bits zero a esquerda do valor 8-bit usado em analogWrite() para obter os 12 bits requeridos.
Ver Também
LINGUAGEM analogWrite()
LINGUAGEM analogRead()
LINGUAGEM map()
EXAMPLO Descrição dos pinos analógicos de entrada(Em Inglês) | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogwriteresolution/index.html |
f35862558bca-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Zero due mkr family
> Analogreadresolution
analogReadResolution()
[Zero, Due & MKR Family]
Descrição | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
f35862558bca-1 | [Zero, Due & MKR Family]
Descrição
analogReadResolution() é um extensão da API Analog para o Arduino Due, Zero e família MKR.
Configura o tamanho (em bits) do valor retornado por analogRead(). O padrão é 10 bits (retorna valores entre 0-1023) para compatibilidade com placas baseadas em microcontroladores AVR.
As placas Due, Zero e da família MKR possuem um conversor analógico digital (ADC) com capacidade 12-bits que pode ser accessado, em completude, mudando-se a resolução para 12. Isso fará com que os valores retornados por analogRead() estejam entre 0 e 4095.
Sintaxe
analogReadResolution(bits)
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
f35862558bca-2 | Sintaxe
analogReadResolution(bits)
Parâmetros
bits: determina a resolução (em bits) dos valores retornados pela função analogRead(). Você pode configurar esse valor entre 1 e 32. Você pode escolher resoluções mais altas que 12, porém assim, valores retornados por analogRead() irão sofrer aproximação. Veja a nota abaixo para detalhes.
Retorna
Nada
Código de Exemplo
O código abaixo mostra como usar o conversor analógico digital com resoluções diferentes.
void setup() {
// abre a conexão serial
Serial.begin(9600);
}
void loop() {
// lê o valor no pino A0 na resolução padrão (10 bits)
// e o envia pela conexão serial
analogReadResolution(10); | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
f35862558bca-3 | // e o envia 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ê o pino A0
analogReadResolution(12);
Serial.print(", 12-bit : ");
Serial.print(analogRead(A0));
// muda a resolução para 16 bits e lê o pino A0
analogReadResolution(16);
Serial.print(", 16-bit : ");
Serial.print(analogRead(A0));
// muda a resolução para 8 bits e lê o pino
analogReadResolution(8);
Serial.print(", 8-bit : ");
Serial.println(analogRead(A0)); | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
f35862558bca-4 | Serial.print(", 8-bit : ");
Serial.println(analogRead(A0));
// um pequeno delay para não enviar dados muito rapidamente para o Serial Monitor
delay(100);
}
Notas e Advertências
Se você configurar o valor de analogReadResolution() para um valor maior que acapacidade de sua placa, o Arduino irá retornar apenas na sua resolução máxima, preenchendo os bits extras com zeros.
Por exemplo: usando-se o DUE com analogReadResolution(16) irá retornar um número 16-bit aproximado, com os primerios 12 bits contendo a leitura real do ADC e os últimos 4 bits preenchidos com zeros. | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
f35862558bca-5 | Se você configurar o valor de analogReadResolution() para um valor menor que acapacidade de sua placa, os bits menos significantes extras lidos do ADC serão descartados.
Usar uma resolução de 16 bits (ou qualquer resolução mais alta que as capacidades reais do hardware) permite escrever sketches que automaticamente suportam dispositivos com uma resolução do ADC mais alta quando estes estiverem disponíveis em placas futuras, sem a necessidade de se fazer mudanças no código.
Ver Também
EXEMPLO Descrição dos pinos analógicos de entrada(Em Inglês)
LINGUAGEM analogRead() | https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-family/analogreadresolution/index.html |
0b1b9f886b9d-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Time
> Millis
millis()
[Time]
Descrição | https://www.arduino.cc/reference/pt/language/functions/time/millis/index.html |
0b1b9f886b9d-1 | millis()
[Time]
Descrição
Retorna o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 50 dias.
Sintaxe
time = millis()
Parâmetros
Nenhum
Retorna
O número de milissegundos passados desde que o programa iniciou (unsigned long)
Código de Exemplo
O código imprime na porta serial o tempo em milissegundos passado desde que a placa Arduino começou a executar o código em si.
unsigned long time;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Time: ");
time = millis(); | https://www.arduino.cc/reference/pt/language/functions/time/millis/index.html |
0b1b9f886b9d-2 | void loop() {
Serial.print("Time: ");
time = millis();
Serial.println(time); // imprime o tempo desde que o programa iniciou
delay(1000); // espera um segundo, para não enviar quantidades massivas de dados
}
Notas e Advertências
Note que o valor retornado por millis() é unsigned long, erros podem ser gerados se o programador tentar fazer operações matemáticas com outros tipos de dados, como int. Até mesmo o tipo long com sinal pode causar erros, já que seu valor máximo é metade de sua contraparte sem sinal.
Ver Também
EXEMPLO Blink Sem Delay (Em Inglês) | https://www.arduino.cc/reference/pt/language/functions/time/millis/index.html |
bdc04971befa-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Time
> Delay
delay()
[Time]
Descrição | https://www.arduino.cc/reference/pt/language/functions/time/delay/index.html |
bdc04971befa-1 | > Delay
delay()
[Time]
Descrição
Pausa o programa por uma quantidade especificada de tempo (em milissegundos). Cada segundo equivale a 1000 milissegundos.
Sintaxe
delay(ms)
Parâmetros
ms: o número de milissegundos para pausar o programa (unsigned long)
Retorna
Nada
Código de Exemplo
O código pausa o programa por um segundo antes de trocar o estado do pino 13.
int ledPin = 13; // LED conectado ao pino digital 13
void setup() {
pinMode(ledPin, OUTPUT); // configura o pino digital como saída
}
void loop() {
digitalWrite(ledPin, HIGH); // acende o LED
delay(1000); // espera por um segundo | https://www.arduino.cc/reference/pt/language/functions/time/delay/index.html |
bdc04971befa-2 | delay(1000); // espera por um segundo
digitalWrite(ledPin, LOW); // apaga o LED
delay(1000); // espera por um segundo
}
Notas e Advertências | https://www.arduino.cc/reference/pt/language/functions/time/delay/index.html |
bdc04971befa-3 | }
Notas e Advertências
Mesmo que seja fácil fazer um LED piscar usando a função delay(), e muitos sketches usam delays pequenos para tarefas como debouncing de botões, o uso de delay() em um sketch possui desvantagens significantes. Nenhuma leitura de sensores, cálculos matemáticos, ou manipulação de pinos podem ocorrer durante a função delay(), para resumir, causa a pausa de qualquer atividade. Para métodos alternativos de controlar temporizações, veja o sketch Blink Sem Delay (Em Inglês), que verifica a função millis() até que o tempo suficiente tenha passado. Programadores mais habilidosos usualmente evitam o uso da função delay() para timing de eventos mais longos que dezenas de milissegundos, a menos que o sketch Arduino seja muito simples. | https://www.arduino.cc/reference/pt/language/functions/time/delay/index.html |
bdc04971befa-4 | No entanto, certas coisas continuam a acontecer enquanto a função delay() está controlando o microcontrolador, porque a função delay não desativa interrupções. Comunicação serial recebida no pino RX é armazenada, valores PWM de (analogWrite) e estados dos pinos são mantidos, e interrupções externas irão funcionar como devem.
Ver Também
EXEMPLO Blink Sem Delay (Em Inglês) | https://www.arduino.cc/reference/pt/language/functions/time/delay/index.html |
0330f06dee75-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Time
> Delaymicroseconds
delayMicroseconds()
[Time]
Descrição | https://www.arduino.cc/reference/pt/language/functions/time/delaymicroseconds/index.html |
0330f06dee75-1 | delayMicroseconds()
[Time]
Descrição
Pausa o programa pela quantidade de tempo especificada como parâmetro (em microssegundos). Há mil microssegundos em um milissegundo, e um milhão de microssegundos em um segundo.
Atualmente, o maior valor que irá porduzir um delay preciso é 16383. Isso pode mudar em versões futuras do Arduino. Para delays mais longos que alguns milhares de microssegundos, você deve usar delay() em vez disso.
Sintaxe
delayMicroseconds(us)
Parâmetros
us: o número emm microssegundos para pausar o programa (unsigned int)
Retorna
Nada
Código de Exemplo | https://www.arduino.cc/reference/pt/language/functions/time/delaymicroseconds/index.html |
0330f06dee75-2 | Retorna
Nada
Código de Exemplo
O código abaixo configura o pino 8 para funcionar como pino de saída. Ele então gera um trem de pulsos com período de 100 microssegundos.
int outPin = 8; // pino digital 8
void setup() {
pinMode(outPin, OUTPUT); // configura o pino digital como saída
}
void loop() {
digitalWrite(outPin, HIGH); // ativa o pino
delayMicroseconds(50); // pausa por 50 microssegundos
digitalWrite(outPin, LOW); // desativa o pino
delayMicroseconds(50); // pausa por 50 microssegundos
}
Notas e Advertências | https://www.arduino.cc/reference/pt/language/functions/time/delaymicroseconds/index.html |
0330f06dee75-3 | }
Notas e Advertências
Essa função funciona bastante precisamente para valores maiores que 3 microssegundos. Não é possível assegurar que delayMicroseconds() irá funcionar corretamente para valores menores.
A partir da versão Arduino 0018, delayMicroseconds() não mais desativa interrupções.
Ver Também | https://www.arduino.cc/reference/pt/language/functions/time/delaymicroseconds/index.html |
02fe8fdd671b-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Time
> Micros
micros()
[Time]
Descrição | https://www.arduino.cc/reference/pt/language/functions/time/micros/index.html |
02fe8fdd671b-1 | micros()
[Time]
Descrição
Retorna o número de microssegundos passados desde que a placa Arduino começou a executar o programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 70 minutos. Em placas Arduino 16 MHz (ex. UNO e Nano), essa função possui uma resolução de quatro microssegundos (isto é, o número retornado é sempre um múltiplo de quatro). Em placas Arduino 8 MHz (ex. LilyPad), essa função possui uma resolução de oito microssegundos.
Sintaxe
time = micros()
Parâmetros
Nenhum
Retorna
O número de microssegundos desde que o programa iniciou (unsigned long).
Código de Exemplo | https://www.arduino.cc/reference/pt/language/functions/time/micros/index.html |
02fe8fdd671b-2 | Código de Exemplo
O código abaixo imprime o número de microssegundos passados desde que a placa Arduino foi ligada.
unsigned long time;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Time: ");
time = micros();
Serial.println(time); // imprime o tempo desde que o programa iniciou
delay(1000); // espera um segundo, para não enviar quantidades massivas de dados
}
Notas e Advertências
Há 1000 (mil) microssegundos em um milissegundo e 1000000 (um milhão) de microssegundos em um segundo.
Ver Também | https://www.arduino.cc/reference/pt/language/functions/time/micros/index.html |
6f04810cbcef-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Interrupts
> Nointerrupts
noInterrupts()
[Interrupts]
Descrição | https://www.arduino.cc/reference/pt/language/functions/interrupts/nointerrupts/index.html |
6f04810cbcef-1 | noInterrupts()
[Interrupts]
Descrição
Desativa interrupções (você pode reativá-las com interrupts()). Interrupções permitem certas tarefas importantes acontecerem ao fundo e são, por padrão, ativadas. Algumas funções não irão funcionar enquanto as interrupções estiverem desativadas, e dados recebidos podem ser ignorados. Interrupções podem levemente interferir no timing do código, no entanto, e podem ser desativadas em seções particulamente críticas do código.
Sintaxe
noInterrupts()
Parâmetros
Nothing
Retorna
Nada
Código de Exemplo
O código abaixo mostra como desativar e reativar interrupções.
void setup() {}
void loop() {
noInterrupts(); | https://www.arduino.cc/reference/pt/language/functions/interrupts/nointerrupts/index.html |
6f04810cbcef-2 | void setup() {}
void loop() {
noInterrupts();
// código crítico e sensível ao tempo aqui
interrupts();
// códigos regulares aqui
}
Ver Também | https://www.arduino.cc/reference/pt/language/functions/interrupts/nointerrupts/index.html |
8b65aa545374-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Interrupts
> Interrupts
interrupts()
[Interrupts]
Descrição | https://www.arduino.cc/reference/pt/language/functions/interrupts/interrupts/index.html |
8b65aa545374-1 | interrupts()
[Interrupts]
Descrição
Reativa interrupções (quando elas tiverem sido desativadas por nointerrupts(). Interrupções permitem certas tarefas importantes acontecerem ao fundo e são, por padrão, ativadas. Algumas funções não irão funcionar enquanto as interrupções estiverem desativadas, e dados recebidos podem ser ignorados. Interrupções podem levemente interferir no timing do código, no entanto, e podem ser desativadas em seções particulamente críticas do código.
Sintaxe
interrupts()
Parâmetros
Nothing
Retorna
Nada
Código de Exemplo
O código abaixo mostra como desativar e reativar interrupções.
void setup() {}
void loop() {
noInterrupts(); | https://www.arduino.cc/reference/pt/language/functions/interrupts/interrupts/index.html |
8b65aa545374-2 | void setup() {}
void loop() {
noInterrupts();
// código crítico e sensível ao tempo aqui
interrupts();
// códigos regulares aqui
}
Ver também
LINGUAGEM attachInterrupts()
LINGUAGEM detachInterrupts() | https://www.arduino.cc/reference/pt/language/functions/interrupts/interrupts/index.html |
171276977e2c-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Math
> Sq
sq()
[Math]
Descrição
Calcula o quadrado de um número: o número multiplicado por si mesmo.
Sintaxe
sq(x) | https://www.arduino.cc/reference/pt/language/functions/math/sq/index.html |
171276977e2c-1 | Sintaxe
sq(x)
Parâmetros
x: o número que se deseja calcular o quadrado, qualquer tipo de dados
Retorna
O quadrado do número. (double)
Notas e Advertências
Por causa da forma como a função sq() é implementada, evite usar outras funções dentro dos parênteses, pois isso pode levar a resultados incorretos.
Esse código gerará resultados incorretos:
int inputSquared = sq(Serial.parseInt()); // evite isso
Faça dessa forma:
int input = Serial.parseInt(); // manter outras operações fora da função sq()
int inputSquared = sq(input);
Ver Também | https://www.arduino.cc/reference/pt/language/functions/math/sq/index.html |
4def51b0555e-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Math
> Min
min()
[Math]
Descrição
Calcula o menor de dois números.
Sintaxe
min(x, y)
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/math/min/index.html |
4def51b0555e-1 | Sintaxe
min(x, y)
Parâmetros
x: o primeiro número, qualquer tipo de dado
y: o segundo número, qualquer tipo de dado
Retorna
O menor dos dois números passados para a função.
ECódigo de Exemplo
O código garante que o valor de sensVal nunca é maior que 100.
sensVal = min(sensVal, 100); // atribui a sensVal o menor valor, seja sensVal ou 100
// garantindo que esse nunca seja maior que 100.
Notas e Advertências
Talvez contraintuitivamente, max() é constantemente usada para restringir o extremo inferior do intervalo de uma variável, enquanto min() é usado para restringir o extremo superior do intervalo. | https://www.arduino.cc/reference/pt/language/functions/math/min/index.html |
4def51b0555e-2 | Por causa da forma em que a função max() é implementada, evite usar outras funções dentro dos parênteses, isso pode levar a resultados incorretos.
min(a++, 100); // evitar isso - causa resultados incorretos
min(a, 100); // ao invés disso, usar esta forma
a++; // manter a aritmética fora da função
Ver Também | https://www.arduino.cc/reference/pt/language/functions/math/min/index.html |
84de8d77f70f-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Math
> Pow
pow()
[Math]
Descrição | https://www.arduino.cc/reference/pt/language/functions/math/pow/index.html |
84de8d77f70f-1 | > Pow
pow()
[Math]
Descrição
Calcula o valor de um número elevado a uma potência. pow() pode ser usada para transformar um número em uma potência fracionária. Isso pode ser útil para gerar mapeamentos exponenciais de valores ou curvas.
Sintaxe
pow(base, expoente)
Parâmetros
base: o número (float)
expoente: a potência a qual o número deve ser elevado (float)
Retorna
O resultado da exponenciação (double)
Código de exemplo
Z recebe o valor de x elevado a y:
z = pow(x, y);
Veja o sketch (fscale) para um exemplo mais complexo do uso de pow().
Ver Também
DEFINIÇÃO float
DEFINIÇÃO double | https://www.arduino.cc/reference/pt/language/functions/math/pow/index.html |
d174a814313e-0 | Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Functions
> Math
> Max
max()
[Math]
Descrição
Calcula o maior de dois números.
Sintaxe
max(x, y)
Parâmetros | https://www.arduino.cc/reference/pt/language/functions/math/max/index.html |
d174a814313e-1 | Sintaxe
max(x, y)
Parâmetros
x: o primeiro número, qualquer tipo de dado
y: o segundo número, qualquer tipo de dado
Retorna
O maior dos dois números passados para a função.
Código de Exemplo
O código garante que o valor de sensVal seja pelo menos 20.
sensVal = max(sensVal, 20); // atribui a sensVal o maior valor, seja sensVal ou 20
// (efetivamente garantindo que sensVal seja ao menos 20)
Notas e Advertências
Talvez contraintuitivamente, max() é constantemente usada para restringir o extremo inferior do intervalo de uma variável, enquanto min() é usado para restringir o extremo superior do intervalo. | https://www.arduino.cc/reference/pt/language/functions/math/max/index.html |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.