gavmac00/arduino-docs huggingface dataset:
> 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)
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
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
> 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
}
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
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
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.
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
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
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()
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)
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
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
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.
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
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
> 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
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
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
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
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).
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
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:
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
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
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
> 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.
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
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
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
> 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.
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.
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)
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;
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
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
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() {
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
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
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.
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
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
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.
// 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
}
  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
/*
  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";
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() {
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
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");
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
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.
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);
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.
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
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"
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:
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:
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:
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
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
> 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
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
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)
Um pino pode também ser configurado como entrada (INPUT) com pinMode(), e posteriormente colocado em HIGH com digitalWrite(). Isso irá ativar os resistores de 20K internos para pullup, o que irá forçar o estado do pino para  HIGH a menos que esse seja forçado para LOW por um circuito externo. Isso é exatamente como a opção INPUT_PULLUP funciona, sendo descrita abaixo em mais detalhes.
Quando um pino é configurado como saída (OUTPUT) com pinMode(), e colocado em estado HIGH com digitalWrite(), a tensão no pino é:
5 volts (em placas 5V)
3.3 volts (em placas 3.3V)
3.3 volts (em placas 3.3V)
Nesse estado, o pino pode fornecer corrente (ver limites para sua placa, geralmente 40.0mA). Isso pode ser usado, por exemplo, para acender um LED que está conecatdo ao ground através de um resistor limitador de corrente.
LOW
O significado de LOW depende também 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 LOW se:
uma tensão menor que 1.5V está presente no pino (em placas 5V)
uma tensão menor que 1.0V (aproxidamente) está presente no pino (em placas 3.3V)
Quando um pino é configurado como OUTPUT com pinMode(), e colocado em estado LOW com digitalWrite(), a tensão no pino é 0 volts (tanto em placas de 5V como 3.3V boards). Nesse estado o pino pode absorver corrente, o que pode ser usado, por exemplo, para acender um LED conectado através de um resistor limitador de corrente aos +5 volts (ou +3.3 volts).
Definições de modos para Pinos Digitais: INPUT, INPUT_PULLUP e OUTPUT
Pinos digitais pode ser usados como entrada, entrada com pull-up ou saída  (INPUT, INPUT_PULLUP ou OUTPUT, respectivamente). Mudar o modo de um pino com pinMode() muda o comportamento elétrico do pino.
Pinos Configurados como entrada - INPUT
Pinos Configurados como entrada - INPUT
Pinos configurados como INPUT com pinMode() são ditos estarem em um estado de alta-impedância. Quando  configurados como INPUT, esses pinos exigem multíssimo pouco dos circuitos que estão verificando, equivalente a um resistor de 100 Megohm na frente do pino. Isso faz com que sejam muito úteis para ler sensores.
Se você configurar um pino como INPUT, e ler o estado de um botão conectado a 5V, por exemplo, quando o botão estiver em estado aberto, a entrada estará "flutuando", resultando em leituras imprevisíveis. Isso acontece porque quando o botão está aberto, o pino não está conectado a nenhuma tensão. Para assegurar uma leitura correta quando o botão está aberto, um resistor de pull-up ou pull-down deve ser usado. O propósito desse resistor é colocar o pino em um estado conhecido quando o botão estiver aberto. Um resistor de 10K ohm é usado geralmente, pois possui valor baixo o suficiente para previnir confiavelmente o estado flutuante, ao mesmo tempo que é grande o suficiente para não usar muita corrente qaundo o botão
Se um resistor de pull-down é usado, o pino de entrada estará em LOW quando o botão estiver aberto e HIGH quando o btoão estiver pressionado.
Se um resistor de pull-up é usado, o pino de entrada estará em HIGH quando o botão estiver aberto e LOW quando o btoão estiver pressionado.
Pinos Configuradoos como entrada com pull-up - INPUT_PULLUP
O microcontrolador ATmega na maioria das placas Arduino possui resistores pull-up internos (resistores conectados a alimentação internamente) que você pode acessar. Se você preferir usar estes em vez de resistores de pull-up externos, você pode usar o argumento INPUT_PULLUP na função pinMode().
Veja o tutorial Input Pullup Serial (Em Inglês) para um exemplo do uso desses resistores.
Pinos Configurados como saída - OUTPUT
Pinos configurados como OUTPUT com pinMode() são ditos estarem em um estado de baixa-impedância. Isso significa que esses podem fornecer uma quantidade substancial de corrente para outros circuitos. Os pinos de um ATmega podem fornecer ou absorver correntes de até 40 mA (miliamperes) para/de outros dispositivos/circuitos. Isso faz com que sejam úteis para alimentar LEDs, pois LEDs tipicamente usam menos de 40 mA. Cargas que exigem mais de 40 mA (ex. motores) irão reqeurer um transistor ou um outro circuito de interface.
Pinos configurados como saídas podem ser danificados ou destruídos se forem conectados diretamente ao ground ou na tensão de alimentação.
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
            > Floatingpointconstants
          
Constantes de Ponto Flutuante
          [Constants]
          
Descrição
Constantes de Ponto Flutuante
          [Constants]
          
Descrição
Similar as constantes inteiras, constantes de ponto flutuante são usadas para tornar o código mais legível. Constantes de ponto flutuante são trocadas em tempo de compilação para o valor calculado para a expressão.
Código de Exemplo
n = 0.005;  // 0.005 é uma constante de ponto flutuante
Notas e Advertências
Constantes de ponto flutuante podem ser também expressas em uma variedade de notações científicas. 'E' e 'e' são ambas aceitas como indicadores de expoente.
Constante de ponto flutuante
Interpretada como:
Interpretada também como:
10.0
10
2.34E5
2.34 * 10^5
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
            >  Digital io
            > Digitalread
          
digitalRead()
          [Digital I/O]
          
Descrição
Lê o valor de um pino digital especificado, que pode ser HIGH ou LOW.
Lê o valor de um pino digital especificado, que pode ser HIGH ou LOW.
Sintaxe
digitalRead(pino)
Parâmetros
pino: o número do pino digital do Arduino que você quiser verificar
Retorna
HIGH ou LOW
Código de Exemplo
Aciona o pino 13 para o mesmo valor que o pino 7, declarado como entrada.
int ledPin = 13;  // LED conectado ao pino digital 13
int inPin = 7;    // botão conectado ao pino digital 7
int val = 0;      // variável para guardar o valor lido
void setup() {
  pinMode(ledPin, OUTPUT);    // configura o pino digital 13 como saída
  pinMode(inPin, INPUT);      // configura o pino digital 7 como entrada
}
void loop() {
}
void loop() {
  val = digitalRead(inPin);   // lê o pino de entrada
  digitalWrite(ledPin, val);  // aciona o LED com o valor lido do botão
}
Notas e Advertências
Se o pino não está conectado a nada, digitalRead() pode retornar tanto HIGH como LOW (e isso pode mudar aleatoriamente).
Os pinos de entrada analógica podem ser também usados como pinos digitais, referidos como A0, A1, etc. As exceções são os pinos A6 e A7 das placas Arduino Nano, Pro Mini, e Mini, que podem ser usadas apenas como entradas analógicas.
Ver Também
EXEMPLO Descrição dos pinos digitais (em inglês)
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
            >  Digital io
            > Digitalwrite
          
digitalWrite()
          [Digital I/O]
          
Descrição
Aciona um valor HIGH ou LOW em um pino digital.
Descrição
Aciona um valor HIGH ou LOW em um pino digital.
Se o pino for configurado como saída (OUTPUT) com a função pinMode(), sua tensão será acionada para o valor correspondente: 5V (ou 3.3V em placas alimentadas com 3.3V como o DUE) para o valor HIGH, 0V (ou ground) para LOW.
Se o pino for configurado como entrada (INPUT), a função digitalWrite() irá ativar (HIGH) ou desativar (LOW) o resistor interno de pull-up no pino de entrada. É recomendado configurar pinMode() com INPUT_PULLUP para ativar o resistor interno de pull-up. Veja o tutorial sobre pinos digitais para mais informações.
Se você não configurar o pino com pinMode() e OUTPUT, e conectar um LED ao pino, quando chamar digitalWrite(HIGH), o LED pode aparecer um pouco apagado. Sem configurar explicitamente pinMode(), digitalWrite() irá apenas ativar o resistor de pull-up interno, que age como um grande resistor limitador de corrente.
Sintaxe
digitalWrite(pino, valor)
Parâmetros
pino: o número do pino do Arduino
valor: HIGH ou LOW
Retorna
Nada
Código de Exemplo
The código configura o pino digital 13 como OUTPUT e troca seu estado entre HIGH e LOW
void setup() {
  pinMode(13, OUTPUT);    // configura o pino digital 13 como saída
}
void loop() {
  digitalWrite(13, HIGH); // ativa o pino digital 13
digitalWrite(13, HIGH); // ativa o pino digital 13
  delay(1000);            // espera por um segundo
  digitalWrite(13, LOW);  // desativa o pino digital 13
  delay(1000);            // espera por um segundo
}
Notas e Advertências
Os pinos de entrada analógica podem ser também usados como pinos digitais, referidos como A0, A1, etc. As exceções são os pinos A6 e A7 das placas Arduino Nano, Pro Mini, e Mini, que podem ser usadas apenas como entradas analógicas.
Ver Também
EXEMPLO Descrição dos pinos digitais (em inglês)
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
            >  Digital io
            > Pinmode
          
pinMode()
          [Digital I/O]
          
Descrição
pinMode()
          [Digital I/O]
          
Descrição
Configura o pino especificado para funcionar como uma entrada ou saída. Veja a descrição dos pinos digitais (em Inglês) para mais detalhes sobre a funcionalidade dos pinos.
Desde a versão 1.0.1, é possível ativar os resistores internos de pull-up como o modo INPUT_PULLUP. Adicionalmente, o modo INPUT explicitamente desativa os resistores pull-up internos.
Sintaxe
pinMode(pino, modo)
Parâmetros
pino: the número do pino do Arduino no qual se quer configurar o modo
modo: o modo do pino. Este pode ser INPUT, OUTPUT ou INPUT_PULLUP; que correspondem respectivamente a entrada, saída e entrada com pull-up ativado.
Retorna
Nada
Código de Exemplo