id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
a63a3970df23-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
> Variables
> Conversion
> Intcast
int()
[Conversion]
Descrição
Converte um valor para o tipo de dado int.
Sintaxe
int(x)
Parâmetros | https://www.arduino.cc/reference/pt/language/variables/conversion/intcast/index.html |
a63a3970df23-1 | Sintaxe
int(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
O valor passado para a função, convertido para o tipo int
Ver Também
LINGUAGEM int | https://www.arduino.cc/reference/pt/language/variables/conversion/intcast/index.html |
35ef3122d792-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
> Variables
> Conversion
> Charcast
char()
[Conversion]
Descrição
Converte um valor para o tipo de dado char.
Sintaxe
char(x)
Parâmetros | https://www.arduino.cc/reference/pt/language/variables/conversion/charcast/index.html |
35ef3122d792-1 | Sintaxe
char(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
o valor passado para a função, convertido para o tipo char
Ver Também
LINGUAGEM char | https://www.arduino.cc/reference/pt/language/variables/conversion/charcast/index.html |
e8e8d3af9478-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
> Variables
> Conversion
> Floatcast
float()
[Conversion]
Descrição
Converte um valor para o tipo de dado float.
Sintaxe
float(x)
Parâmetros | https://www.arduino.cc/reference/pt/language/variables/conversion/floatcast/index.html |
e8e8d3af9478-1 | Sintaxe
float(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
o valor passado para a função, convertido para o tipo float
Notas e Advertências
Veja a página da referência para o tipo float para detalhes sobre a precisão e limitações dos números de ponto flutuante no Arduino.
Ver Também
LINGUAGEM float | https://www.arduino.cc/reference/pt/language/variables/conversion/floatcast/index.html |
63666df48e07-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
> Variables
> Conversion
> Longcast
long()
[Conversion]
Descrição
Converte um valor para o tipo de dado long.
Sintaxe
long(x)
Parâmetros | https://www.arduino.cc/reference/pt/language/variables/conversion/longcast/index.html |
63666df48e07-1 | Sintaxe
long(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
O valor passado para a função, convertido para o tipo long
Ver Também
LINGUAGEM long | https://www.arduino.cc/reference/pt/language/variables/conversion/longcast/index.html |
65d039c67897-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
> Variables
> Data types
> String
string
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-1 | > String
string
[Data Types]
Descrição
As strings de texto podem ser representadas de duas maneiras. Você pode usar o tipo de dado String, que é parte do core desde a versão 0019, ou você pode fazer uma string com um vetor do tipo char e terminá-lo em null. Essa página descreve o segundo método. Para mais detalhes sobre o objeto String, que possui mais funcionalidades ao custo de mais memória ocupada, veja a página sobre os objetos String.
Sintaxe
Todos as declarações seguintes são válidas para strings.
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-2 | char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
Possibilidades para declarar strings
Declarar um vetor de chars sem inicializá-lo, como em Str1
Declarar um vetor de chars (com um char extra) e o compilador irá adicionar o caractere null requerido, como em Str2
Adicionar o caractere null explicitamente, Str3
Inicializar uma string constante em aspas; o compilador irá ajustar o tamanho do vetor para a string mais o caractere null terminador, como em Str4
Inicializar o vetor com o tamanho explícito e a string constante, Str5 | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-3 | Inicializar o vetor com o tamanho explícito e a string constante, Str5
Inicializar o vetor, deixando espaço extra para uma string maior, Str6
Terminação em null
Geralmente, strings são terminadas com um caractere null (código ASCII 0). Isso permite que funções (como Serial.print()) saibam onde está o final de uma string. Do contrário, essas funções continuariam lendo bytes consequentes da memória que não fazem parte da string. | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-4 | Isso significa que sua string precisa ter espaço para mais um caractere além do texto que você quer que ela contenha. Por isso que Str2 e Str5 precisam ter oito carcteres, mesmo que "arduino" seja apenas sete - a última posição é automaticamente preenchida com um caractere null. Str4 é automaticamente ajustada para oito caracteres, sendo um para o null extra. Em Str3, o caractere null foi explicitamente incluído, adicionando-se '\0'. | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-5 | Note que é possível criar uma string sem uma caractere null no final (ex. se se você tivesse especificado o tamanho de Str2 como sete em vez de oito). Porém isso irá quebrar a maioria das funções que usam strings, então você não deve fazê-lo intencionalmente. Se você notar algo se comportando estranhamente no seu programa (operando em caracteres fora da string), isso pode ser o problema.
Aspas simples ou aspas duplas?
As strings são sempre definidas envoltas em aspas duplas ("Abc") e caracteres são sempre definidos envoltos em aspas simples('A').
Escrevendo strings muito longas
Você pode escrever uma string muito longa em várias linhas, da seguinte forma:
char myString[] = "Essa é a primeira linha"
" Essa é a segunda linha" | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-6 | " Essa é a segunda linha"
" etcetera";
Vetores de strings
Frequentemente é conveniente, quando lidando-se com grandes quantidades de texto, como um projeto com um display LCD, configurar um vetor de strings. Como strings por sí próprias já são vetores, isso é na verdade um exemplo de um vetor bidimensional.
No código abaixo, o asterisco depois do tipo de dado char “char*” indica que esse é um vetor de "ponteiros". Todos os nomes de vetores são na verdade ponteiros, então isso é necessário para criar um vetor de vetores. Ponteiros são uma partes mais esotéricas da linguagem C++ para inicinates entenderem, mas não é necessário entender ponteiros profundamente para usá-los efetivamente aqui.
Código de Exemplo | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
65d039c67897-7 | Código de Exemplo
char *myStrings[] = {"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5", "This is string 6"
};
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i = 0; i < 6; i++) {
Serial.println(myStrings[i]);
delay(500);
}
}
Ver Também
LINGUAGEM PROGMEM | https://www.arduino.cc/reference/pt/language/variables/data-types/string/index.html |
eb1c2791f125-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
> Variables
> Data types
> Void
void
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/void/index.html |
eb1c2791f125-1 | > Void
void
[Data Types]
Descrição
A palavra chave void é usada apenas em declarações de funções. Ela indica que é esperado que a função não retorne nenhuma informação para a função da qual foi chamada.
Código de Exemplo
O código mostra como usar a palavra chave void.
// são realizadas ações nas funções "setup" e "loop"
// porém não é retornada nenhuma informação quando as mesmas são executadas
void setup() {
// ...
}
void loop() {
// ...
}
Ver Também
LINGUAGEM Constantes Inteiras | https://www.arduino.cc/reference/pt/language/variables/data-types/void/index.html |
b8297dcfe4d8-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
> Variables
> Data types
> Int
int
[Data Types]
Descrição
Ints (integer ou inteiros) são o tipo o tipo de dados primário para armazenamento de números. | https://www.arduino.cc/reference/pt/language/variables/data-types/int/index.html |
b8297dcfe4d8-1 | No Arduino Uno (e outras placas baseadas em micros ATmega) um int armazena um valor 16-bit (2 bytes). Isso garante um intervalo de -32,768 a 32,767 (um valor mínimo de -2^15 e um valor máximo de (2^15) - 1).
No Arduino Due e outras placas baseadas em micros SAMD (como o MKR1000 e Zero), um int armazena um valor 32-bit (4 bytes). O que garante um intervalo de -2,147,483,648 a 2,147,483,647 (um valor mínimo de -2^31 e um valor máximo de (2^31) - 1). | https://www.arduino.cc/reference/pt/language/variables/data-types/int/index.html |
b8297dcfe4d8-2 | Variáveis int armazenam números negativos com uma técnica chamada (Complemento de 2). O bit mais significativo, as vezes chamado de o "bit de sinal", indica que o número é negativo. O resto dos bits são invertidos e 1 é adicionado.
O Arduino cuida dos detalhes nas operações com números negativos por você, tal que operações aritméticas funcionam transparentemente na maneira esperada. No entanto, pode-se haver uma complicação ao lidar com o operador de deslocamento de bits a direita (>>).
Sintaxe
int var = val;
=== Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo | https://www.arduino.cc/reference/pt/language/variables/data-types/int/index.html |
b8297dcfe4d8-3 | val: valor a ser atribuído à variável
Código de Exemplo
Esse código cria uma variável do tipo integer chamada 'contador', a qual é inicialmente atribuído o valor 0 (zero). A váriavel incrementa em 1 (um) a cada execução do loop e é mostrada no monitor serial.
int contador = 0; //cria uma variável integer chamada 'contador'
void setup() {
Serial.begin(9600); // usa a porta serial para imprimir o número
}
void loop() {
contador++; // soma 1 ao int contador a cada execução do loop
Serial.println(contador); // Imprime o estado atual do contador
delay(1000);
}
Notas e Advertências | https://www.arduino.cc/reference/pt/language/variables/data-types/int/index.html |
b8297dcfe4d8-4 | delay(1000);
}
Notas e Advertências
Quando variáveis com sinal são forçadas a exceder sua capacidade máxima ou mínima, elas estouram; ou do Inglês, sofrem overflow. O resultado de um overflow é imprevisível, então isso deve ser evitado. Um sintoma típico de um overflow é a variável "rolar" de sua capacidade máxima para a mínima ou vice-versa, mas não é sempre o caso. Se você deseja esse comportamento, use o tipo unsigned int.
Ver Também
LINGUAGEM Integer Constants | https://www.arduino.cc/reference/pt/language/variables/data-types/int/index.html |
72e4ed82b435-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
> Variables
> Data types
> Word
word
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/word/index.html |
72e4ed82b435-1 | > Word
word
[Data Types]
Descrição
Uma variável word armazena um número sem sinal de ao menos 16 bits, de 0 A 65535.
Sintaxe
word var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
O trecho de código abaixo cria uma variável do tipo word.
word w = 10000;
Ver Também | https://www.arduino.cc/reference/pt/language/variables/data-types/word/index.html |
1991c09b2823-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
> Variables
> Data types
> Float
float
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/float/index.html |
1991c09b2823-1 | > Float
float
[Data Types]
Descrição
Tipo de dado para números de ponto flutuante, ou seja, um número racional. Números de ponto flutuante são frequentemente usados para aproximar valores analógicos e contínuos porque possuem maior resolução que inteiros (int). Números de ponto flutuante podem ser tão grandes quanto 3.4028235E+38 ou pequenos quanto -3.4028235E+38. Floats são armazenados em 32 bits (4 bytes) de memória. | https://www.arduino.cc/reference/pt/language/variables/data-types/float/index.html |
1991c09b2823-2 | Floats possuem apenas 6-7 dígitos decimais de precisão. Isso para o número total de dígitos, não de dígitos à direita do ponto decimal. Diferentemente de outras plataformas, onde se pode ter mais precisão usando-se um double (até 15 dígitos), no Arduino, o double possui o mesmo tamanho que float.
Números de ponto flutuante não são exatos, e podem gerar resultados estranhos quando comparados. Por exemplo, 6.0 / 3.0 pode não ser igual a 2.0. Você deveria, em vez disso, checar se o valor absoluto da diferença entre dois números é menor que algum número. | https://www.arduino.cc/reference/pt/language/variables/data-types/float/index.html |
1991c09b2823-3 | A matemática em números de ponto flutuante também é muito mais lenta que em inteiros ao se realizar cálculos, então deve ser evitada se, por exemplo, um loop tem que ser executado em alta velocidade para uma função de tempo crítico. Programadores frequentemente fazem o possível para converter cálculos em números flutuantes para matemática em inteiros para aumentar a velocidade, mas sacrificando precisão.
Quando fizer cálculos com floats, você precisa adicionar um ponto decimal, do contrário o número será tratado como um int. Veja a página sobre constantes de ponto flutuante para mais detalhes.
Sintaxe
float var = val
=== Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo | https://www.arduino.cc/reference/pt/language/variables/data-types/float/index.html |
1991c09b2823-4 | val: valor a ser atribuído à variável
Código de Exemplo
O trecho de código demonstra algumas operações com floats.
float myfloat;
float sensorCalbrate = 1.117;
int x;
int y;
float z;
x = 1;
y = x / 2; // y agora contém 0, ints não podem guardar frações
z = (float)x / 2.0; // z agora contém 0.5 (você deve usar 2.0, não 2)
Ver Também | https://www.arduino.cc/reference/pt/language/variables/data-types/float/index.html |
b2562067c5e6-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
> Variables
> Data types
> Long
long
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/long/index.html |
b2562067c5e6-1 | > Long
long
[Data Types]
Descrição
Variáveis long são variáveis de tamanho extendido para armazenamento de números, armazenam 32 bits (4 bytes), de -2,147,483,648 a 2,147,483,647.
Ao se fazer cálculos com inteiros, pelo menos um dos números deve ser seguido por um L, forçando-o a ser um long. Veja a página sobre Constantes Inteiras para detalhes.
Sintaxe
long var = val;
=== Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
long speedOfLight = 186000L; // veja a página sobre constantes inteiras para uma explicação sobre o 'L'
Ver Também
LINGUAGEM Constantes Inteiras | https://www.arduino.cc/reference/pt/language/variables/data-types/long/index.html |
fa0adf61c8c3-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
> Variables
> Data types
> Boolean
boolean
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/boolean/index.html |
fa0adf61c8c3-1 | > Boolean
boolean
[Data Types]
Descrição
boolean é um alias de tipos de dados não padrão para bool definido pelo Arduino. É recomendado usar em vez disso o tipo padrão bool, que é idêntico.
Código de Exemplo
O código abaixo mostra como usar o tipo de dado boolean.
int LEDpin = 5; // LED no pino digital 5
int switchPin = 13; // botão conectado ao pino 13 e o outro terminal ao ground
boolean running = false; //variável do tipo boolean
void setup()
{
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // ativa o resistor pull-up
}
void loop()
{
if (digitalRead(switchPin) == LOW) | https://www.arduino.cc/reference/pt/language/variables/data-types/boolean/index.html |
fa0adf61c8c3-2 | void loop()
{
if (digitalRead(switchPin) == LOW)
{ // botão foi pressionado, o pull-up mantém o pino em HIGH internamente
delay(100); // delay para fazer o debounce no botão
running = !running; // troca o valor da variável running
digitalWrite(LEDpin, running); // indica via LED
}
}
Ver Também
LINGUAGEM constantes | https://www.arduino.cc/reference/pt/language/variables/data-types/boolean/index.html |
2e2620aaeded-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
> Variables
> Data types
> Bool
bool
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/bool/index.html |
2e2620aaeded-1 | > Bool
bool
[Data Types]
Descrição
O tipo bool pode armazenar dois valores: true or false. (Cada variável bool ocupa um byte na memória.)
Sintaxe
bool var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
O código abaixo mostra como usar o tipo de dado bool.
int LEDpin = 5; // LED no pino digital 5
int switchPin = 13; // botão conectado ao pino 13 e o outro terminal ao ground
bool running = false; //variável de tipo booleano
void setup() {
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // ativa o resistor pull-up
} | https://www.arduino.cc/reference/pt/language/variables/data-types/bool/index.html |
2e2620aaeded-2 | digitalWrite(switchPin, HIGH); // ativa o resistor pull-up
}
void loop() {
if (digitalRead(switchPin) == LOW) {
// botão foi pressionado, o pull-up mantém o pino em HIGH internamente
delay(100); // delay para fazer o debounce no botão
running = !running; // troca o valor da variável running
digitalWrite(LEDpin, running); // indica via LED
}
}
Ver Também
LINGUAGEM constantes | https://www.arduino.cc/reference/pt/language/variables/data-types/bool/index.html |
05c2bcbc13fb-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
> Variables
> Data types
> Stringobject
String()
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-1 | String()
[Data Types]
Descrição
Constrói uma instância da classe String. Há múltiplas versões que constroem Strings a partir de diferentes tipos de dados (ex. formatam-nos como uma sequência de caracteres), incluindo:
uma string constante de caracteres, em aspas duplas (ex. um vetor de caracteres)
um único caractere constante, em aspas simples
uma outra instância de um objeto String
um int constante ou long int
um int constante ou long int, usando uma base especificada
uma variável int ou long int
uma variável int ou long int, usando uma base especificada
um float ou double, usando um número especificado de casas decimais
Nesse texto, sequências de caracteres são chamadas strings, enquanto instâncias da classe String (objetos) são chamados String. | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-2 | Construir uma String a partir de um número resulta em uma String que contém a representação ASCII desse número. A base padrão é dez, então:
String thisString = String(13);
Fornece a String "13". No entanto, você pode usar outras bases. Por exemplo,
String thisString = String(13, HEX);
que fornece a String "D", que é a representação hexadecimal do valor 13. Ou se você preferir binário,
String thisString = String(13, BIN);
forneca a String "1101", que é a representação binária de 13.
Sintaxe
String(val)
String(val, base)
String(val, decimalPlaces)
Parâmetros | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-3 | String(val, base)
String(val, decimalPlaces)
Parâmetros
val: a variável a ser formatada como String - Tipos de dados permitidos: string, char, byte, int, long, unsigned int, unsigned long, float, double
base (opcional): a base na qual formatar valores inteiros
decimalPlaces (apenas se val é float ou double): o número desejado de casas decimais
Retorna
Uma instância da classe String.
Código de Exemplo
Todas a seguir são declarações válidas para Strings.
String stringOne = "Hello String"; // usando uma string constante
String stringOne = String('a'); // convertendo um caractere constante para uma String
String stringTwo = String("This is a string"); // convertendo uma string constante para um objeto String | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-4 | String stringOne = String(stringTwo + " with more"); // concatenando duas strings
String stringOne = String(13); // usando um inteiro constante
String stringOne = String(analogRead(0), DEC); // usando um int e uma base especificada (decimal)
String stringOne = String(45, HEX); // usando um int e uma base especificada (hexadecimal)
String stringOne = String(255, BIN); // usando um int e uma base especificada (binário)
String stringOne = String(millis(), DEC); // usando um long e uma base especificada
String stringOne = String(5.698, 3); // usando um float e o número de casas decimais
Funções
LINGUAGEM charAt()
LINGUAGEM compareTo()
LINGUAGEM concat()
LINGUAGEM c_str() | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-5 | LINGUAGEM concat()
LINGUAGEM c_str()
LINGUAGEM endsWith()
LINGUAGEM equals()
LINGUAGEM equalsIgnoreCase()
LINGUAGEM getBytes()
LINGUAGEM indexOf()
LINGUAGEM lastIndexOf()
LINGUAGEM length()
LINGUAGEM remove()
LINGUAGEM replace()
LINGUAGEM reserve()
LINGUAGEM setCharAt()
LINGUAGEM startsWith()
LINGUAGEM substring()
LINGUAGEM toCharArray()
LINGUAGEM toDouble()
LINGUAGEM toInt()
LINGUAGEM toFloat()
LINGUAGEM toLowerCase()
LINGUAGEM toUpperCase()
LINGUAGEM trim()
Operadores
LINGUAGEM [] (acesso de elementos)
LINGUAGEM + (concatenação) | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
05c2bcbc13fb-6 | LINGUAGEM + (concatenação)
LINGUAGEM += (anexação)
LINGUAGEM == (comparação)
LINGUAGEM > (maior que)
LINGUAGEM >= (maior ou igual a)
LINGUAGEM < (menor que)
LINGUAGEM <= (menor que ou igual a)
LINGUAGEM != (diferente de)
EXEMPLO Tutoriais sobre objetos String (Em Inglês)
Ver Também | https://www.arduino.cc/reference/pt/language/variables/data-types/stringobject/index.html |
500f227a78d1-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
> Variables
> Data types
> Size t
size_t
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/size_t/index.html |
500f227a78d1-1 | size_t
[Data Types]
Descrição
size_t é um tipo de dado capaz de representar o tamanho de qualquer objeto em bytes. Exemplos do uso de size_t são o tipo do retorno de sizeof() e Serial.print().
Sintaxe
size_t var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Ver Também | https://www.arduino.cc/reference/pt/language/variables/data-types/size_t/index.html |
8ce7ab5512d2-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
> Variables
> Data types
> Short
short
[Data Types]
Descrição
O tipo short é um tipo de dado 16-bit. | https://www.arduino.cc/reference/pt/language/variables/data-types/short/index.html |
8ce7ab5512d2-1 | Descrição
O tipo short é um tipo de dado 16-bit.
Em todos os Arduinos (baseados no ATMega ou ARM) um short armazena um valor 16-bit (2 bytes). Isso fornece um intervalo de -32,768 a 32,767 (valor mínimo de -2^15 e valor máximo de (2^15) - 1).
Sintaxe
short var = val;
=== Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
short ledPin = 13
Ver Também
LINGUAGEM Constantes Inteiras | https://www.arduino.cc/reference/pt/language/variables/data-types/short/index.html |
b282df9a41e3-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
> Variables
> Data types
> Double
double
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/double/index.html |
b282df9a41e3-1 | > Double
double
[Data Types]
Descrição
Número de Ponto flutuante Double. No UNO e outras placas baseadas no ATMEGA, ocupa 4 bytes. Isto é, nesses a impelmentação do double é exatamente a mesma do float, sem nenhum ganho em precisão.
No Arduino Due e outras placas com SAMD, doubles usam 8 bytes, ou seja, precisão de 64 bits.
Sintaxe
double var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Notas e Advertências | https://www.arduino.cc/reference/pt/language/variables/data-types/double/index.html |
b282df9a41e3-2 | val: valor a ser atribuído à variável
Notas e Advertências
Usuários que pegam código de outras fontes que inclua variáveis double podem desejar examinar o código para conferir se a precisão é diferente do que realmente é alcançado nas placas Arduino baseadas em microcontroladores ATMEGA.
Ver Também
LINGUAGEM Tipo de dado float | https://www.arduino.cc/reference/pt/language/variables/data-types/double/index.html |
bc345122e408-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
> Variables
> Data types
> Unsignedchar
unsigned char
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedchar/index.html |
bc345122e408-1 | unsigned char
[Data Types]
Descrição
Um tipo de dado sem sinal, que ocupa um byte na memória. O mesmo que o tipo de dado byte. O tipo de dado unsigned char armazena valores de 0 a 255.
Para consistência do estilo de programação Arduino, o tipo de dado byte é preferido.
Sintaxe
unsigned char var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
O trecho de código abaixo cria uma variável do tipo unsigned char
unsigned char myChar = 240;
Ver Também
LINGUAGEM Serial.println | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedchar/index.html |
52390f46ec98-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
> Variables
> Data types
> Unsignedint
unsigned int
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
52390f46ec98-1 | unsigned int
[Data Types]
Descrição
No UNO e outras placas baseadas nos microcontroladores ATmega, unsigned ints (inteiros sem sinal) são o mesmo que o tipo int no que esses também armazenam um valor de 2 bytes. Em vez de guardar números negativos, no entanto, esses apenas armazenam valores positivos, garantindo um intervalo útil de 0 a 65,535 ((2^16) - 1).
O Due e outras placas ARM armazenam um unsigned int em 4 bytes (32 bits), de 0 a 4,294,967,295 (2^32 - 1). | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
52390f46ec98-2 | A diferença entre unsigned ints e ints (com sinal), está na forma como o bit mais significativo, as vezes chamado de o bit "de sinal", é interpretado. No tipo int do Arduino (que possui sinal), se o bit mais significativo é "1", o número é interpretado como um número negativo, e os outros 15 bits são interpretados com (complemento de 2).
Sintaxe
unsigned int var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
O trecho de código abaixo cria uma variável unsigned int chamada ledPin e a atribui o valor 13.
unsigned int ledPin = 13;
Notas e Advertências | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
52390f46ec98-3 | unsigned int ledPin = 13;
Notas e Advertências
Quando variáveis unsigned tem sua capacidade máxima excedida, elas "estouram" e voltam para 0, e também o contrário. Exemplo:
unsigned int x;
x = 0;
x = x - 1; // x agora contém 65535
x = x + 1; // x agora contém 0
A matemática com variávies unsigned pode produzir resultados inesperados, mesmo se a variável unsigned nunca estourar.
O microcontrolador aplica as seguintes regras: | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
52390f46ec98-4 | O microcontrolador aplica as seguintes regras:
O cálculo é feito de acordo com a variável de destino. Exemplo, se a variável destino possui sinal, ele irá realizar o cálculo levando em conta o sinal, mesmo que ambas as variáveis de entrada sejam unsigned.
No entanto, em um cálculo que requer um resultado intermediário, o escopo da variável intermediária não é especificado pelo código. Nesse caso, o micro irá usar matemática sem sinal para o resultado intermediário, porque ambas as entradas são unsigned!
unsigned int x = 5;
unsigned int y = 10;
int resultado;
resultado = x - y; // 5 - 10 = -5, como esperado | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
52390f46ec98-5 | resultado = (x - y) / 2; // 5 - 10 com matemática unsigned é 65530! 65530/2 = 32765
// solução: usar variáveis com sinal, ou fazer o cálculo passo a passo.
resultado = x - y; // 5 - 10 = -5, como esperado
resultado = resultado / 2; // -5/2 = -2 (matemática inteira, casas decimais não são consideradas)
Então porque usar variáveis sem sinal?
Quando o comportamento de estouro é desejado, ex. contadores
A variável com sinal é muito pequena, e se quer evitar a perda de memória e performance de long/float.
Ver Também
LINGUAGEM Constantes Inteiras | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedint/index.html |
3605c5723757-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
> Variables
> Data types
> Char
char
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/char/index.html |
3605c5723757-1 | > Char
char
[Data Types]
Descrição
Um tipo de dado usado para armazenar um caractere. Caracteres literais são escritos em aspas simples, dessa forma: 'A' (para múltiplos caracteres - ou seja, strings - use aspas duplas: "ABC").
No entanto, caracteres são armazenados como números. Você pode ver a codificação na tabela ASCII. Isso significa que é possível fazer aritmética com caracteres, na qual o valor ASCII para o caractere é usado (ex. 'A' + 1 tem valor 66, pois o valor ASCII da letra maiúscula A é 65). Veja a referência de Serial.println para mais sobre como caracteres são traduzidos para números. | https://www.arduino.cc/reference/pt/language/variables/data-types/char/index.html |
3605c5723757-2 | O tipo de dado char ocupa ao menos 8 bits. É recomendado que se utilize char apenas para armazenar caracteres. Para um tipo de dado sem sinal, de um byte (8 bits), use o tipo de dado byte.
Sintaxe
char var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
char myChar = 'A';
char myChar = 65; // ambas as formas são equivalentes
Ver Também
LINGUAGEM Serial.println | https://www.arduino.cc/reference/pt/language/variables/data-types/char/index.html |
04dcab81f381-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
> Variables
> Data types
> Byte
byte
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/byte/index.html |
04dcab81f381-1 | > Byte
byte
[Data Types]
Descrição
Uma variável 'byte' armazena valores numéricos de 8-bit sem sinal, de 0 a 255.
Sintaxe
byte var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Ver Também
LINGUAGEM byte() | https://www.arduino.cc/reference/pt/language/variables/data-types/byte/index.html |
caae59bc810e-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
> Variables
> Data types
> Array
vetor
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
caae59bc810e-1 | > Array
vetor
[Data Types]
Descrição
Um vetor (array) é uma coleção de variáveis que são acessadas com um número índice. Vetores na linguagem C++, na qual o Arduino é baseado, podem ser complicados, mas usar vetores simples é relativamente fácil.
Criando-se um Vetor
Todos os métodos abaixo são formas válidas de criar (declarar) um vetor.
int meusInts[6];
int meusPinos[] = {2, 4, 8, 3, 6};
int meusValSens[6] = {2, 4, -8, 3, 2};
char mensagem[6] = "hello";
Você pode declarar um vetor sem inicializá-lo, como em meusInts. | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
caae59bc810e-2 | Você pode declarar um vetor sem inicializá-lo, como em meusInts.
Em meusPinos, nós declaramos um vetor sem explicitamente escolher um tamanho. O compilador conta os elementos e cria um vetor de tamanho apropriado.
Finalmente você pode inicializar e também especificar o tamanho do vetor, como em meusValSens. Note que quando declarar um vetor do tipo char, um elemento a mais que sua inicialização é requerido, para armazenar o caractere null necessário.
Acessando-se um Vetor
Vetores são indexados a partir de 0, isto é, referindo-se a inicialização dos vetores acima, o primeiro elemento do vetor está no índice 0, então
meusValSens[0] == 2, meusValSens[1] == 4, e assim por diante. | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
caae59bc810e-3 | Isso também significa que em um vetor com dez elementos, o índice nove é o último elemento. Então:
int meuVetor[10] = {9, 3, 2, 4, 3, 2, 7, 8, 9, 11};
// meuVetor[9] contém 11
// meuVetor[10] é inválido e contém informação aleatória (endereço de memória fora do vetor) | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
caae59bc810e-4 | Por esse motivo, você deve ser cuidadoso ao acessar vetores. Acessar um elemento depois do final de um vetor (usar um índice maior que o tamanho declarado - 1) é ler de uma parte da memória que pode estar em uso para outros propósitos. Ler desses locais provavelmente não vai fazer mais que retornar dados inválidos. Escrever em locais aleatórios da memória é definitivamente uma má ideia e pode frequentemente levar a péssimos resultados como crashes ou mal funcionamento do programa. Isso pode também ser um bug difícil de encontrar.
Diferentemente de BASIC ou JAVA, o compilador C++ não faz checagem para confirmar se o acesso a um elemento está dentro dos limites do tamanho declarado do vetor.
Para atribuir um valor a um elemento do vetor:
meusValSens[0] = 10; | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
caae59bc810e-5 | meusValSens[0] = 10;
Para ler um elemento de um vetor:
x = mySensVals[4];
Vetores e loops For
Vetores são frequentemente manipulados dentro de loops for, onde o contador do loop é usado como o índice para cada elemento. Por exemplo, para imprimir os elementos de um vetor através da porta serial, você pode fazer algo do tipo:
for (byte i = 0; i < 5; i = i + 1) {
Serial.println(meusPinos[i]);
}
Código de Exemplo
Para um programa completo que demonstra o uso de vetores, veja o exemplo da Super Máquina dos Tutoriais Arduino (Em Inglês).
Ver Também
LINGUAGEM PROGMEM | https://www.arduino.cc/reference/pt/language/variables/data-types/array/index.html |
41d62e3b378b-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
> Variables
> Data types
> Unsignedlong
unsigned long
[Data Types]
Descrição | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedlong/index.html |
41d62e3b378b-1 | unsigned long
[Data Types]
Descrição
Variáveis unsigned long são variáveis de tamanho extendido para armazenamento de números, que armazenam 32 bits (4 bytes). Diferentemente de longs padrão, unsigned longs não guardam números negativos, o que faz com que possam armazenar valores de 0 a 4,294,967,295 (2^32 - 1).
Sintaxe
unsigned long var = val;
=== Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Código de Exemplo
O código abaixo cria uma variável do tipo long para guardar o número de milissegundos desde que o programa iniciou.
unsigned long time; //variável do tipo long
void setup() {
Serial.begin(9600);
}
void loop() { | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedlong/index.html |
41d62e3b378b-2 | void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Time: ");
time = millis();
//imprime o tempo desde que o programa iniciou, em milissegundos
Serial.println(time);
// espera um segundo, para não enviar quantidades massivas de dados
delay(1000);
}
Ver Também
LINGUAGEM Constantes Inteiras | https://www.arduino.cc/reference/pt/language/variables/data-types/unsignedlong/index.html |
f1f8c201f3d8-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
> Variables
> Utilities
> Progmem
PROGMEM
[Utilities]
Descrição | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-1 | PROGMEM
[Utilities]
Descrição
Armazena dados na memória flash (memória de programa) em vez da SRAM. Uma descrição dos vários tipos de memória das placas Arduino pode ser encontrada (Em Inglês) nessa página.
A palavra-chave PROGMEM é um modificador de variáveis, que pode ser usada apenas com os modificadores de variáveis definidos em pgmspace.h. Ela diz ao compilador "armazene essa informação na memória flash", em vez da SRAM, onde seria normalmente armazenada. | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-2 | PROGMEM é parte da biblioteca pgmspace.h. Essa biblioteca é incluída automaticamente em versões modernas da IDE, porém se você estiver usando uma versão da IDE anterior à 1.0 (2011), irá precisar incluir ela no topo do seu sketch, da seguinte forma:
#include <avr/pgmspace.h>
Sintaxe
const dataType variableName[] PROGMEM = {data0, data1, data3…};
Onde:
dataType - qualquer tipo de dados
variableName - o nome do seu vetor de dados | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-3 | dataType - qualquer tipo de dados
variableName - o nome do seu vetor de dados
Note que porque PROGMEM é um modificador de variável, não há uma regra rigorosa de onde ele deve ir, então o compilador aceita todos os tipos de definição abaixo, que também são sinônimos. Mesmo assim, experimentos indicaram que, em várias versões do Arduino (relacionado a versão do GCC), PROGMEM pode funcionar em uma localização e não em outra. O exemplo da "tabela de strings" abaixo foi testado com a versão 13 do Arduino. Versões mais antigas da IDE podem funcionar melhor se PROGMEM for incluído depois do nome da variável.
const dataType variableName[] PROGMEM = {}; // use essa forma
const PROGMEM dataType variableName[] = {}; // ou essa
const dataType PROGMEM variableName[] = {}; // mas não essa | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-4 | const dataType PROGMEM variableName[] = {}; // mas não essa
Enquanto PROGMEM pode ser usada em uma única variável, realmente só vale a pena o trabalho de usá-lo se você tiver um bloco de dados maior para ser armazenado, o que geralmente é mais fácil de fazer com vetores (ou outra estrutura de dados da linguagem C++ fora do escopo da nossa discussão atual).
Usar PROGMEM é também um procedimento realizado em dois passos. Depois de resgatar os dados da memória flash, são requeridas funções especiais, também definidas na biblioteca pgmspace.h, para ler os dados da memória de programa para a memória SRAM, tal que possamos fazer algo com eles.
Código de Exemplo
Os fragmentos de código abaixo ilustram como ler e escrever unsigned chars (bytes) e ints (2 bytes) com PROGMEM. | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-5 | // armazena alguns unsigned ints
const PROGMEM uint16_t conjunto[] = {65000, 32796, 16843, 10, 11234};
// armazena alguns chars
const char mensagem[] PROGMEM = {"Um pequeno jabuti xereta viu dez cegonhas felizes"};
unsigned int displayInt;
char meuChar;
void setup() {
Serial.begin(9600);
while (!Serial); // Espera a porta serial conectar. Necessário para placas com USB nativa
// Lê da memória flash um int (2-bytes, ou word)
for (byte k = 0; k < 5; k++) {
displayInt = pgm_read_word_near(conjunto + k);
Serial.println(displayInt);
}
Serial.println();
// Lê um caractere da flash | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-6 | }
Serial.println();
// Lê um caractere da flash
for (byte k = 0; k < strlen_P(mensagem); k++) {
meuCHar = pgm_read_byte_near(mensagem + k);
Serial.print(meuCHar);
}
Serial.println();
}
void loop() {
//Nada aqui
}
Vetores de strings
É frequentemente conveniente, quando se trabalha com grandes quantidade de texto, como um projeto com display LCD, por exemplo, preparar vetores de strings. Porque strings por si próprias já são vetores, este é genuinamente um exemplo de um vetor bidimensional.
Essas estruturas tendem a ser muito grandes, de forma que colocá-las na memória pode ser desejável. O código abaixo ilustra a ideia.
/*
demo com strings e PROGMEM | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-7 | /*
demo com strings e PROGMEM
Como armazenar uma tabela de strings na memória de programa (flash),
e recuperá-los.
Informação resumida de:
http://www.nongnu.org/avr-libc/user-manual/pgmspace.html
Preparar uma tabela (vetor) de strings na memória de programa é relativamente complicado,
mas esse template pode ser seguido.
Preparar as strings é um processo em dois passos. O primeiro é definir as strings.
*/
#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0"; // "String 0" etc são as strings a serem armazenadas - adapte ao seu programa.
const char string_1[] PROGMEM = "String 1";
const char string_2[] PROGMEM = "String 2"; | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-8 | const char string_2[] PROGMEM = "String 2";
const char string_3[] PROGMEM = "String 3";
const char string_4[] PROGMEM = "String 4";
const char string_5[] PROGMEM = "String 5";
// Então crie uma tabela para apontar para as suas strings.
const char *const string_table[] PROGMEM = {string_0, string_1, string_2, string_3, string_4, string_5};
char buffer[30]; // Tenha certeza que esse buffer é grande o suficiente para armazenar a maior string
void setup() {
Serial.begin(9600);
while (!Serial); // Espera a porta serial conectar. Necessário para placas com USB nativa
Serial.println("OK");
}
void loop() { | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-9 | Serial.println("OK");
}
void loop() {
/* Usar a tabela de strings da memória de programa requer o uso de funções especiais para recuperar os dados.
A função strcpy_P copia uma string do espaço de programa para uma string na RAM (em um "buffer").
Tenha certeza que o seu buffer na RAM é grande o suficiente para armazenar o que quer que seja
que você estiver lendo da memória de programa. */
for (int i = 0; i < 6; i++) {
strcpy_P(buffer, (char *)pgm_read_word(&(string_table[i]))); // Casts e desreferência necessários, apenas copie.
Serial.println(buffer);
delay(500);
}
}
Notas e Advertências | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-10 | delay(500);
}
}
Notas e Advertências
Por favor note que as variáveis devem ser definidas globalmente OU com a palavra-chave static, para funcionarem com PROGMEM.
O código a seguir não funcionará dentro de uma função:
const char long_str[] PROGMEM = "Olá, gostaria de falar um pouco sobre mim mesmo.\n";
O código a seguir irá funcionar, mesmo se definido localmente dentro de uma função:
const static char long_str[] PROGMEM = "Olá, gostaria de falar um pouco sobre mim mesmo.\n";
A macro F()
Quando uma instrução do tipo:
Serial.print("Escreve algo no Monitor Serial"); | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
f1f8c201f3d8-11 | Serial.print("Escreve algo no Monitor Serial");
é usada, a string a ser impressa é normalmente salva na RAM. Se o seu sketch imprime muita coisa no Monitor Serial, você pode facilmente encher a RAM. Se você tiver espaço livre na memória flash, você pode facilmente indicar ao compilador que a string deve ser salva na FLASH usando a sintaxe:
Serial.print(F("Esse texto foi guardado na memória flash do Arduino"));
Ver Também
EXEMPLO Tipos de memória de uma placa Arduino (Em Inglês)
DEFINIÇÃO array
DEFINIÇÃO string | https://www.arduino.cc/reference/pt/language/variables/utilities/progmem/index.html |
6233e9685a97-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
> Variables
> Utilities
> Sizeof
sizeof()
[Utilities]
Descrição
O operador sizeof retorna o número de bytes de uma variável, ou o número de bytes ocupados em um vetor. | https://www.arduino.cc/reference/pt/language/variables/utilities/sizeof/index.html |
6233e9685a97-1 | Sintaxe
sizeof(variável)
Parâmetros
variável: uma variável ou vetor de qualquer tipo (ex: int, float, byte)
Retorna
O número de bytes em uma variável ou o número de bytes ocupados em um vetor. (size_t)
Código de Exemplo
O perador sizeof é útil para manipular arrays (tais como strings), onde é conveniente ser possível mudar o tamanho do vetor sem quebrar outras partes do programa.
O programa abaixo imprime um string um caractere de cada vez. Tente mudar o texto da frase.
char minhaStr[] = "Esse é um teste";
void setup() {
Serial.begin(9600);
}
void loop() {
for (byte i = 0; i < sizeof(minhaStr) - 1; i++) {
Serial.print(i, DEC); | https://www.arduino.cc/reference/pt/language/variables/utilities/sizeof/index.html |
6233e9685a97-2 | Serial.print(i, DEC);
Serial.print(" = ");
Serial.write(minhaStr[i]);
Serial.println();
}
delay(5000); // espera 5 segundos
}
Notas e Advertências
Note que sizeof retorna o número total de bytes. Então, para vetores de tipos de dados maiores, como int, o loop for parece algo do tipo abaixo.
int meusValores[] = {123, 456, 789};
// este loop for funciona corretamente com um array de qualquer tipo ou tamanho
for (byte i = 0; i < (sizeof(meusValores)/sizeof(meusValores[0])); i++) {
// fazer algo com meusValores[i]
}
Note também que uma string apropriadamente formatada é encerrada com o símbolo NULL, que tem valor ASCII 0. | https://www.arduino.cc/reference/pt/language/variables/utilities/sizeof/index.html |
6233e9685a97-3 | Ver Também | https://www.arduino.cc/reference/pt/language/variables/utilities/sizeof/index.html |
4b81970d6dbf-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
> Variables
> Constants
> Integerconstants
Constantes Inteiras
[Constants]
Descrição | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
4b81970d6dbf-1 | Constantes Inteiras
[Constants]
Descrição
Constantes Inteiras são números usados diretamente em um sketch, como 123. Por padrão, esses números são tratados como int mas você pode mudar isso com os modificadores U e L (ver abaixo).
Normalmente, constantes inteiras são tratadas como inteiros na base 10 (decimais), mas notações especiais (modificadores) podem ser usados para escrever-se números em outras bases.
Base
Exemplo
Modificador
Comentário
10 (decimal)
123
nenhum
2 (binário)
B1111011
prefixo 'B'
funciona apenas com valores 8-bit (0 a 255) caracteres 0 e 1 válidos
8 (octal)
0173
prefixo "0" | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
4b81970d6dbf-2 | 8 (octal)
0173
prefixo "0"
caracteres 0-7 válidos
16 (hexadecimal)
0x7B
prefixo "0x"
caracteres 0-9, A-F, a-f válidos
Decimal (base 10)
Essa é a matemática de senso comum a qual você já está acostumado. Constantes sem prefixos são assumidas como valores decimais.
Código de Exemplo:
n = 101; // o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)
Binário (base 2)
Apenas os caracteres 0 e 1 são válidos.
Código de Exemplo: | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
4b81970d6dbf-3 | Código de Exemplo:
n = B101; // o mesmo que 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)
O modificador binário funciona apenas em bytes (8 bits), ou seja, entre 0 (B0) e 255 (B11111111). Se for conveniente inserir um int (16 bits) em formato binário, você pode fazê-lo com um procedimento em dois passos, como:
meuInt = (B11001100 * 256) + B10101010; // B11001100 é o byte mais significativo
Octal (base 8)
Apenas os caracteres 0 a 7 são válidos. Valores octais são indicados pelo prefixo "0" (zero).
Código de Exemplo: | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
4b81970d6dbf-4 | Código de Exemplo:
n = 0101; // o mesmo que 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)
Cuidado: é possível criar um bug difícil de encontrar (acidentalmente), caso seja inserido um zero antes de uma constante, fazendo com que o compilador interprete sua constante como octal.
Hexadecimal (base 16)
Os caracteres válidos são 0 a 9 e as letras A a F; A possui valor 10, B é 11, até o F, que é 15. Valores hexadecimais são indicados pelo prefixo "0x". Note que as letras A-F podem ser também iseridas em minúsculo (a-f).
Código de Exemplo: | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
4b81970d6dbf-5 | Código de Exemplo:
n = 0x101; // o qmesmo que 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)
Notas e Advertências
Modificadores 'U' e 'L':
Por padrão, uma constante inteira é tratada como int com as mesmas limitações desse tipo de dado. Para especificar uma constante inteira com outro tipo de dado, termine-a com:
um 'u' ou 'U' para forçar a constante para formato unsigned (sem sinal). Exemplo: 33u
um 'l' ou 'L' para forçar a constante para formato long. Exemplo: 100000L
um 'ul' ou 'UL' para forçar a constante para formato unsigned long. Exemplo: 32767ul
Ver Também | https://www.arduino.cc/reference/pt/language/variables/constants/integerconstants/index.html |
b8488a57923d-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
> Variables
> Constants
> Constants
Constantes
[Constants]
Descrição | https://www.arduino.cc/reference/pt/language/variables/constants/constants/index.html |
b8488a57923d-1 | > Constants
Constantes
[Constants]
Descrição
Constantes são expressões predefinidas na linguagem Arduino. Essas são usadas para tornar os programas mais legíveis. As constantes da linguagem Arduino são classificadas nos grupos:
Definições de Constantes Booleanas: true e false
Existem duas constantes usadas para representar verdade e falsidade na linguagem Arduino: true e false.
false
false é o mais fácil dos dois de ser definido. Sendo definido apenas como 0 (zero).
true | https://www.arduino.cc/reference/pt/language/variables/constants/constants/index.html |
b8488a57923d-2 | true
true é freqeuentemente dito ser definido como 1, o que está correto, porém true possui uma definição mais ampla. Qualquer inteiro que não seja zero é true, em um sentido booleano. Então -1, 2 e -200 são todos definidos como true, também, em um sentido booleano.
Note que as constantes true e false são digitadas em caixa baixa, diferentemente de HIGH, LOW, INPUT, and OUTPUT.
Definições de níveis lógicos: HIGH e LOW
Quando lendo-se ou escrevendo-se o estado de um pino digital há apenas dois valores possíveis que esse pino pode assumir: HIGH e LOW.
HIGH | https://www.arduino.cc/reference/pt/language/variables/constants/constants/index.html |
b8488a57923d-3 | HIGH
O significado de HIGH (em relação a um pino) depende se o pino está configurado como entrada ou saída (INPUT ou OUTPUT). Qaundo um pino é configurado como INPUT com pinMode(), e lido com digitalRead(), o Arduino (ATmega) irá retornar HIGH se:
uma tensão maior que 3.0V está presente no pino (em placas 5V)
uma tensão maior que 2.0V está presente no pino (em placas 3.3V) | https://www.arduino.cc/reference/pt/language/variables/constants/constants/index.html |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.