id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
e54b6a535d25-1 | sin()
[Trigonometry]
Beschreibung
Berechnet den Sinus eines Winkels (Im Bogenmaß). Das Ergebnis liegt zwischen -1 und 1.
Syntax
sin(rad)
Parameter
rad: Der Winkel im Bogenmaß. Erlaubte Datentypen: float.
Rückgabewert
Den Sinus des Winkels. Datentyp: double.
Siehe auch
SPRACHE float
SPRACHE double | https://www.arduino.cc/reference/de/language/functions/trigonometry/sin/index.html |
5fdc69ef3ceb-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.
Documentação de Referência da Linguagem Arduino
A linguagem de programação do Arduino pode ser dividida em três partes principais: estruturas, valores (variáveis e constantes) e funções.
Funções
Para controlar a placa Arduino e realizar computações.
Entradas e Saídas Digitais
digitalRead()
digitalWrite() | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-1 | digitalRead()
digitalWrite()
pinMode()
Entradas e Saídas Analógicas
analogRead()
analogReference()
analogWrite()
Apenas Zero, Due e Família MKR
analogReadResolution()
analogWriteResolution()
Entradas e Saídas Avançadas
noTone()
pulseIn()
pulseInLong()
shiftIn()
shiftOut()
tone()
Funções Temporizadoras
delay()
delayMicroseconds()
micros()
millis() | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-2 | micros()
millis()
Funções Matemáticas
abs()
constrain()
map()
max()
min()
pow()
sq()
sqrt()
Funções Trigonométricas
cos()
sin()
tan()
Caracteres
isAlpha()
isAlphaNumeric()
isAscii()
isControl()
isDigit()
isGraph()
isHexadecimalDigit()
isLowerCase() | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-3 | isHexadecimalDigit()
isLowerCase()
isPrintable()
isPunct()
isSpace()
isUpperCase()
isWhitespace()
Números Aleatórios
random()
randomSeed()
Bits e Bytes
bit()
bitClear()
bitRead()
bitSet()
bitWrite()
highByte()
lowByte()
Interrupções Externas
attachInterrupt()
detachInterrupt()
Interrupções
interrupts() | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-4 | Interrupções
interrupts()
noInterrupts()
Comunicação
Serial
Stream
USB
Keyboard
Mouse
Variáveis
Tipos de dados e constantes da linguagem Arduino.
Constantes
HIGH | LOW
INPUT | OUTPUT | INPUT_PULLUP
LED_BUILTIN
true | false
Constantes de Ponto Flutuante
Constantes Inteiras
Conversão
byte()
char()
float()
int()
long()
word()
Tipos de Dados
bool
boolean | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-5 | Tipos de Dados
bool
boolean
byte
char
double
float
int
long
short
size_t
string
String()
unsigned char
unsigned int
unsigned long
vetor
void
word
Escopo de Variáveis e Qualificadores
const
escopo
static
volatile
Utilitários
PROGMEM
sizeof()
Estruturas | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-6 | PROGMEM
sizeof()
Estruturas
Os elementos da linguagem Arduino (C++).
Sketch
loop()
setup()
Estruturas de Controle
break
continue
do...while
else
for
goto
if
return
switch...case
while
Outros Elementos da Sintaxe
#define
(define)
#include
(include)
/* */
(comentário em bloco)
// | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-7 | (comentário em bloco)
//
(comentário)
;
(ponto e vírgula)
{}
(chaves)
Operadores Aritméticos
%
(resto)
*
(multiplicação)
+
(adição)
-
(subtração)
/
(divisão)
=
(operador de atribuição)
Operadores de Comparação
!=
(diferente de)
< | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-8 | (diferente de)
<
(menor que)
<=
(menor que ou igual a)
==
(igual a)
>
(maior que)
>=
(maior que ou igual a)
Operadores Boleanos
!
(NÃO lógico)
&&
(E lógico)
||
(OU lógico)
Operadores para Ponteiros
&
(referência)
*
(desreferência) | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-9 | *
(desreferência)
Operadores Bitwise
&
(E)
<<
(deslocamento à esquerda)
>>
(deslocamento à direita)
^
(OU EXCLUSIVO)
|
(OU)
~
(NÃO)
Operadores de Atribuição Composta
%=
(compound remainder)
&=
(atribuição por e)
*=
(atribuição por multiplicação)
++
(incremento) | https://www.arduino.cc/reference/pt/index.html |
5fdc69ef3ceb-10 | ++
(incremento)
+=
(atribuição por adição)
--
(decremento)
-=
(atribuição por subtração)
/=
(atribuição por divisão)
^=
(atribuição por ou exclusivo)
|=
(atribuição por ou) | https://www.arduino.cc/reference/pt/index.html |
9e8e0567cb99-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
> Structure
> Further syntax
> Include
#include
[Further Syntax]
Descrição | https://www.arduino.cc/reference/pt/language/structure/further-syntax/include/index.html |
9e8e0567cb99-1 | > Include
#include
[Further Syntax]
Descrição
A diretiva #include é usada para incluir bibliotecas externas ao seu sketch. Isso dá acesso a um grande número de bibliotecas padrão da linguagem C (grupos de funções prontas), e também bibliotecas escritas especialmente para a linguagem Arduino.
A referência principal para bibliotecas C AVR C (AVR é a referência dos chips Microchip (previamente Atmel) utilizados em muitas placas Arduino) pode ser encontrada aqui.
Note que #include, similarmente a #define, não é terminada com um ponto e vírgula, e o compilador irá mostrar mensagens de erro enigmáticas se você adicionar um.
Código de Exemplo | https://www.arduino.cc/reference/pt/language/structure/further-syntax/include/index.html |
9e8e0567cb99-2 | Código de Exemplo
Esse exemplo inclui a bilbioteca Servo para que suas funções possam ser usadas para controlar um servomotor.
#include <Servo.h>
Servo meuservo; // cria um objeto do tipo Servo para controlar um servomotor
void setup() {
meuservo.attach(9); // associa o motor no pino 9 ao objeto meuservo
}
void loop() {
for (int pos = 0; pos <= 180; pos += 1) { // vai de 0 graus a 180 graus
// em passos de 1 grau
meuservo.write(pos); // diz ao servo para ir para a posição na variável 'pos'
delay(15); // espera 15ms para que o servo chegue a posição
} | https://www.arduino.cc/reference/pt/language/structure/further-syntax/include/index.html |
9e8e0567cb99-3 | }
for (int pos = 180; pos >= 0; pos -= 1) { // // vai de 180 graus a 0 graus
meuservo.write(pos); // diz ao servo para ir para a posição na variável 'pos'
delay(15); // espera 15ms para que o servo chegue a posição
}
}
Ver Também | https://www.arduino.cc/reference/pt/language/structure/further-syntax/include/index.html |
bbd3e9c1aaae-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
> Structure
> Further syntax
> Define
#define
[Further Syntax]
Descrição | https://www.arduino.cc/reference/pt/language/structure/further-syntax/define/index.html |
bbd3e9c1aaae-1 | > Define
#define
[Further Syntax]
Descrição
#define é uma diretiva muito útil da linguagem C++ que permite ao programador dar um nome a um valor constante antes de o programa ser compilado. Constantes definidas no arduino não ocupam nenhum espaço na memória de programa do chip. O compilador irá substituir referências a essas constantes pelo valor definido no tempo de compilação.
Isso pode ter alguns efeitos colaterais desagradáveis no entanto, por exemplo, se o nome de uma constante que foi definida com #defined é incluído em outra constante ou nome de uma variável. Nesse caso o texto seria trocado pelo número (ou texto) definido com #define. | https://www.arduino.cc/reference/pt/language/structure/further-syntax/define/index.html |
bbd3e9c1aaae-2 | Em geral, a palavra-chave const é recomendada para se definir constantes e deveria ser usada em vez de #define.
Sintaxe
#define nomeDaConstante valor
Note que o # é necessário.
Código de Exemplo
#define pinoLED 3
// O compilador irá substituir qualquer menção de pinoLED com o valor 3 no tempo de compilação.
Notas e Advertências
Não há ponto e vírgula após a diretiva #define. Se você incluir uma, o compilador irá acusar erros.
#define pinoLED 3; // isso é inválido
Similarmente, incluir sinal de igual após #define também resultará em erros
#define pinoLED = 3 // também é inválido
Ver Também
LINGUAGEM palavra-chave const
LINGUAGEM Constantes | https://www.arduino.cc/reference/pt/language/structure/further-syntax/define/index.html |
018cc20c5654-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
> Structure
> Further syntax
> Blockcomment
/* */
[Further Syntax]
Descrição | https://www.arduino.cc/reference/pt/language/structure/further-syntax/blockcomment/index.html |
018cc20c5654-1 | /* */
[Further Syntax]
Descrição
Comentários são textos no programa que são usadas para informar você e a outros a forma como o programa funciona. Eles são ignorados pelo compilador, e não fazem parte do arquivo gravado no chip, então não ocupam nenhum espaço na memória flash do microcontrolador. O propósito dos comentários lhe ajudar a entender (ou lembrar) como funcionam partes do seu código, ou informar a outros também como o seu programa funciona. | https://www.arduino.cc/reference/pt/language/structure/further-syntax/blockcomment/index.html |
018cc20c5654-2 | O começo de um comentário em bloco ou comentário de múltiplas linhas é marcado pelo símbolo /* e o símbolo */ marca o seu final. Esse tipo de comentário é chamado assim pois pode se estender por mais de uma linha; um vez que o compilador encontre o símbolo /*, ele ignora o texto seguinte até encontrar um */.
Código de Exemplo
/* Esse é um comentário válido */
/*
Blink
Acende um LED por um segundo, depois apaga por um segundo, repetidamente.
Esse código encontra-se um domínio público.
(outro comentário válido)
*/
/*
if (gwb == 0) { // Comentários de única linha não permitidos dentro de um comentário em bloco | https://www.arduino.cc/reference/pt/language/structure/further-syntax/blockcomment/index.html |
018cc20c5654-3 | x = 3; /* Mas outro comentário de múltiplas linhas, não. Esse comentário é inválido */
}
// Não esqueça o símbolo para "fechar" o comentário - deve estar balanceado!
*/
Notas e Advertências
Quando experimentar com código, "comentar" partes de seu programa é uma forma conveniente de remover partes problemáticas do seu código tempoariamente. Isso mantém as linhas de código, mas as transforma em comentários, se forma que o compilador apenas as ignora. Isso pode ser útil quando você estiver procurando um problema, ou quando um programa se recusa a compilar e o erro de compilação é enigmático ou inútil.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/further-syntax/blockcomment/index.html |
4284272360ca-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
> Structure
> Further syntax
> Curlybraces
{}
[Further Syntax]
Descrição | https://www.arduino.cc/reference/pt/language/structure/further-syntax/curlybraces/index.html |
4284272360ca-1 | {}
[Further Syntax]
Descrição
As chaves são uma característica importante da linguagem C++. Elas são usadas em diversas estruturas diferentes, mostradas abaixo, e isso pode as vezes ser confuso para iniciantes.
Uma chave { deve ser sempre fechada por outra chave }. Essa é uma condição que é frequentemente chamada de as chaves estarem balanceadas. A IDE Arduino inclui uma forma conveniente de checar o balanço de duas chaves. Apenas escolha uma chave, ou até mesmo clique no ponto de inserção imediatamente após a chave, se a outra chave do par será destacada. | https://www.arduino.cc/reference/pt/language/structure/further-syntax/curlybraces/index.html |
4284272360ca-2 | Chaves desbalanceadas podem frequentemente resultar em erros enigmáticos, que podem as vezes ser difíceis de se encontrar em um programa longo. Por causa de seu uso variado, as chaves são incrivelmente importantes para o programa e mover uma chave pode afetar dramaticamente o funcionamento de um programa.
Código de Exemplo
Os usos principais das chaves são listados nos exemplos abaixo.
Funções
void minhafuncao(tipo argumento) {
// comando(s)
}
Loops
while (expressão boolena) {
// comando(s)
}
do {
// comando(s)
} while (expressão boolena);
for (inicialização; condição; incremento) {
// comando(s)
}
Estruturas Condicionais
if (expressão boolena) { | https://www.arduino.cc/reference/pt/language/structure/further-syntax/curlybraces/index.html |
4284272360ca-3 | }
Estruturas Condicionais
if (expressão boolena) {
// comando(s)
}
else if (expressão boolena) {
// comando(s)
}
else {
// comando(s)
}
Ver Também | https://www.arduino.cc/reference/pt/language/structure/further-syntax/curlybraces/index.html |
bc564d5bb79e-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
> Structure
> Further syntax
> Semicolon
;
[Further Syntax]
Descrição
Usado para encerrar um comando.
Código de Exemplo
int a = 13; | https://www.arduino.cc/reference/pt/language/structure/further-syntax/semicolon/index.html |
bc564d5bb79e-1 | Código de Exemplo
int a = 13;
Notas e Advertências
Se esquecer de encerar uma linha com um ponto e vírgula irá resultar em um erro de compilação. A mensagem de erro pode ser óbvia, e mencionar a falta de um ponto e vírgula, mas pode também não mencionar a falta do mesmo. Se um erro de compilação incompreensível ou aparentemente ilógico aparecer, uma das primeiras coisas a se checar é a falta de um ponto e vírgula no código anterior a linha mencionada na mensagem de erro do compilador.
Ver também | https://www.arduino.cc/reference/pt/language/structure/further-syntax/semicolon/index.html |
527f85ac0c26-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
> Structure
> Further syntax
> Singlelinecomment
//
[Further Syntax]
Descrição | https://www.arduino.cc/reference/pt/language/structure/further-syntax/singlelinecomment/index.html |
527f85ac0c26-1 | //
[Further Syntax]
Descrição
Comentários são textos no programa que são usadas para informar você e a outros a forma como o programa funciona. Eles são ignorados pelo compilador, e não fazem parte do arquivo gravado no chip, então não ocupam nenhum espaço na memória flash do microcontrolador. O propósito dos comentários é lhe ajudar a entender (ou lembrar) como funcionam partes do seu código, ou informar a outros também como o seu programa funciona.
Um comentário de uma só linha começa com // (duas barras adjacentes). Esse tipo de comentário termina automaticamente no final da linha. O que quer que seja que estiver após // até o final da linha será ignorado pelo compilador.
Código de Exemplo
Há duas formas diferentes de se usar um comentário de uma só linha: | https://www.arduino.cc/reference/pt/language/structure/further-syntax/singlelinecomment/index.html |
527f85ac0c26-2 | Há duas formas diferentes de se usar um comentário de uma só linha:
// O pino 13 tem um LED conectado na maioria das placas Arduino.
// Dá um nome para esse LED:
int led = 13;
digitalWrite(led, HIGH); // acendo o LED (HIGH é o nível da tensão)
Notas e Advertências
Quando experimentar com código, "comentar" partes de seu programa é uma forma conveniente de remover partes problemáticas do seu código temporariamente. Isso mantém as linhas de código, mas as transforma em comentários, se forma que o compilador apenas as ignora. Isso pode ser útil quando você estiver procurando um problema, ou quando um programa se recusa a compilar e o erro de compilação é enigmático ou inútil.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/further-syntax/singlelinecomment/index.html |
09ce7f2041f1-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
> Structure
> Comparison operators
> Lessthanorequalto
<=
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthanorequalto/index.html |
09ce7f2041f1-1 | <=
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando o operando à esquerda é menor ou igual ao operando à direita. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x <= y; // é verdadeiro se x é menor ou igual a y e é falso se x é maior que y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthanorequalto/index.html |
09ce7f2041f1-2 | Código de Exemplo
if (x <= y) { // testa se x é menor que ou igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Notas e Advertências
Números positivos são maiores que números negativos.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthanorequalto/index.html |
85c536c34d79-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
> Structure
> Comparison operators
> Lessthan
<
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthan/index.html |
85c536c34d79-1 | <
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando o operando à esquerda é menor que o operando à direita. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x < y; // é verdadeiro se x é menor que y e é falso se x é igual ou maior que y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthan/index.html |
85c536c34d79-2 | Código de Exemplo
if (x < y) { // testa se x é menor que y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Notas e Advertências
Números positivos são maiores que números negativos.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/lessthan/index.html |
f5cbe0b26346-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
> Structure
> Comparison operators
> Equalto
==
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/equalto/index.html |
f5cbe0b26346-1 | > Equalto
==
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando os dois operandos são iguais. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x == y; // é verdadeiro se x é igual a y e é falso se x não é igual a y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/equalto/index.html |
f5cbe0b26346-2 | Código de Exemplo
if (x == y) { // testa se x é igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/equalto/index.html |
e0c2694fae85-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
> Structure
> Comparison operators
> Greaterthan
>
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthan/index.html |
e0c2694fae85-1 | > Greaterthan
>
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando o operando à esquerda é maior que o operando à direita. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x > y; // é verdadeiro se x é maior que y e é falso se x é igual ou menor que y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthan/index.html |
e0c2694fae85-2 | y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
if (x > y) { // testa se x é maior que y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Notas e Advertências
Números positivos são maiores que números negativos.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthan/index.html |
f30545869ca6-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
> Structure
> Comparison operators
> Greaterthanorequalto
>=
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthanorequalto/index.html |
f30545869ca6-1 | >=
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando o operando à esquerda é maior ou igual ao operando à direita. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x >= y; // é verdadeiro se x é maior ou igual a y e é falso se x é menor que y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthanorequalto/index.html |
f30545869ca6-2 | Código de Exemplo
if (x >= y) { // testa se x é maior que ou igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Notas e Advertências
Números positivos são maiores que números negativos.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/greaterthanorequalto/index.html |
823b3d239fbb-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
> Structure
> Comparison operators
> Notequalto
!=
[Comparison Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/notequalto/index.html |
823b3d239fbb-1 | !=
[Comparison Operators]
Descrição
Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro (true) quando os operandos não são iguais. Por favor note que você pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x != y; // é falso se x é igual a y e é verdadeiro se x não é igual a y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/notequalto/index.html |
823b3d239fbb-2 | Código de Exemplo
if (x != y) { // testa se x é diferente de y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Ver Também | https://www.arduino.cc/reference/pt/language/structure/comparison-operators/notequalto/index.html |
a11448815215-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
> Structure
> Pointer access operators
> Dereference
*
[Pointer Access Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/dereference/index.html |
a11448815215-1 | *
[Pointer Access Operators]
Descrição
Desreferência é uma das características da linguagem C para uso especificamente com ponteiros. O operador * (asterisco) é utilizado para esse propósito. Se p é um ponteiro, então *p representa o valor contido no endereço apontado por p.
Código de Exemplo
int *p; // declara um ponteiro para uma variável do tipo int
int i = 5;
int resultado = 0;
p = &i; // agora 'p' contém o endereço de 'i'
resultado = *p; // 'resultado' recebe o valor contido no endereço apontado por 'p'
// isto é, recebe o valor de 'i', que é 5
Notas e Advertências | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/dereference/index.html |
a11448815215-2 | Notas e Advertências
Ponteiros são um dos assuntos mais complicados para iniciantes na linguagem C aprenderem, e é possível escrever a grande maioria dos sketches Arduino sem nunca encontrar ponteiros. No entanto, para manipular certas estruturas de dados, o uso de ponteiros pode simplificar o código. O conhecimento da manipulação de ponteiros é vantajoso de se ter no seu kit de ferramentas.
Ver Também
DEFINIÇÃO Ponteiros | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/dereference/index.html |
f2b1e2c51aff-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
> Structure
> Pointer access operators
> Reference
&
[Pointer Access Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/reference/index.html |
f2b1e2c51aff-1 | > Reference
&
[Pointer Access Operators]
Descrição
Referência é uma das características da linguagem C para uso especificamente com ponteiros. O operador & ('e' comercial ou ampersand) é utilizado para esse propósito. Se x é uma variável, então &x representa o endereço da variável x.
Código de Exemplo
int *p; // declara um ponteiro para uma variável do tipo int
int i = 5, resultado = 0;
p = &i; // agora 'p' contém o endereço de 'i'
resultado = *p; // 'resultado' recebe o valor contido no endereço apontado por 'p'
// isto é, recebe o valor de 'i', que é 5
Notas e Advertências | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/reference/index.html |
f2b1e2c51aff-2 | Notas e Advertências
Ponteiros são um dos assuntos mais complicados para iniciantes na linguagem C aprenderem, e é possível escrever a grande maioria dos sketches Arduino sem nunca encontrar ponteiros. No entanto, para manipular certas estruturas de dados, o uso de ponteiros pode simplificar o código. O conhecimento da manipulação de ponteiros é vantajoso de se ter no seu kit de ferramentas.
Ver Também
DEFINIÇÃO Ponteiros | https://www.arduino.cc/reference/pt/language/structure/pointer-access-operators/reference/index.html |
b32fb948468a-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
> Structure
> Compound operators
> Compounddivision
/=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compounddivision/index.html |
b32fb948468a-1 | > Compounddivision
/=
[Compound Operators]
Descrição
Essa é uma abreviação conveniente para realizar a divisão de uma variável com outra variável ou constante.
Sintaxe
x /= y; // equivalente a expressão x = x / y;
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante diferente de zero. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
x = 2;
x /= 2; // x agora contém 1
Ver Também
LINGUAGEM Divisão comum | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compounddivision/index.html |
f33afb60b972-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
> Structure
> Compound operators
> Compoundmultiplication
*=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundmultiplication/index.html |
f33afb60b972-1 | *=
[Compound Operators]
Descrição
Essa é uma abreviação conveniente para realizar a multiplicação de uma variável com outra variável ou constante.
Sintaxe
x *= y; // equivalente a expressão x = x * y;
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
x = 2;
x *= 2; // x agora contém 4
Ver Também
LINGUAGEM Multiplicação comum | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundmultiplication/index.html |
8409d309840c-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
> Structure
> Compound operators
> Compoundremainder
%=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundremainder/index.html |
8409d309840c-1 | > Compoundremainder
%=
[Compound Operators]
Descrição
Esse é um atalho conveniente para calcular o resto quando um inteiro é dividido por outro e atribuí-lo de volta a variável na qual foi feita o cálculo.
Sintaxe
x %= divisor; // equivalente a expressão x = x % divisor;
Parâmetros
x: variável. Tipos de dados permitidos: int
divisor: variável or constante não zero. Tipos de dados permitidos: int
Código de Exemplo
int x = 7;
x %= 5; // x agora contém 2
Notas e Advertências
O operador de atribuição de resto não funciona em floats.
Se o primeiro operando é negativo, o resultado é negativo (ou zero). | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundremainder/index.html |
8409d309840c-2 | Se o primeiro operando é negativo, o resultado é negativo (ou zero).
Portanto, o resultado de x %= 10 nem sempre estará entre 0 e 9 se x pode ser negativo.
Ver Também
LANGUAGE Remainder | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundremainder/index.html |
f2db43e90383-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
> Structure
> Compound operators
> Compoundbitwiseor
|=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseor/index.html |
f2db43e90383-1 | |=
[Compound Operators]
Descrição
O operador de atribuição composta bitwise OU |= é frequentemente usado com uma variável e uma constante para "setar" (mudar pra 1) bits particulares em uma variável.
Uma revisão do operador bitwise OU |:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 1 (operando1 | operando2) - resultado retornado
Sintaxe
x |= y; // equivalente a x = x | y;
Parâmetros
x: variável. Tipos de dados permitidos: char, int, long
y: variável ou constante. Tipos de dados permitidos: char, int, long
Código de Exemplo | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseor/index.html |
f2db43e90383-2 | Código de Exemplo
Bits que são operados através do OU com 0 não são mudados, então se meuByte é uma variável byte:
meuByte | B00000000 = meuByte;
Bits que são operados através do OU com 1 são mudados para 1, então:
meuByte | B11111111 = B11111111;
Notas e Advertências
Porque estamos lidando com bits em um operador bitwise, é conveniente usar o modificador binário com constantes na representação. Os números ainda são os mesmos em outras representações, só não são tão fáceis de entender. Também, B00000000 é mostrado para claridade, mas zero em qualquer outro formato é zero. | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseor/index.html |
f2db43e90383-3 | Consequentemente - para setar os bits 0 e 1 de um variável, ao mesmo tempo deixando o resto da variável intocado, useo o operador de atribuição por bitwise OU (|=) com a constante B00000011
1 0 1 0 1 0 1 0 variável
0 0 0 0 0 0 1 1 máscara
----------------------
1 0 1 0 1 0 1 1
bits intactos
bits mudados para 1
Abaixo a mesma representação com os bits da variável substituidos pelo símbolo x
x x x x x x x x variável | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseor/index.html |
f2db43e90383-4 | x x x x x x x x variável
0 0 0 0 0 0 1 1 máscara
----------------------
x x x x x x 1 1
bits intactos
bits mudados para 1
Então:
meuByte = B10101010;
meuByte |= B00000011; // igual a B10101011;
Ver Também
LINGUAGEM | Bitwise OU | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseor/index.html |
bd8c6b08bc01-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
> Structure
> Compound operators
> Compoundbitwiseand
&=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
bd8c6b08bc01-1 | &=
[Compound Operators]
Descrição
O operador de atribuição composta E &= é frequentemente usado com uma variável e uma constante para forçar detreminados bits de uma variável para 0. Isso é frequentemente chamado de "limpar" ou "resetar" os bits.
Uma revisão do operator bitwise E &:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 0 0 1 (operando1 & operando2) - resultado retornado
Sintaxe
x &= y; // equivalente a x = x & y;
Parâmetros
x: variável. Tipos de dados permitidos: char, int, long | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
bd8c6b08bc01-2 | x: variável. Tipos de dados permitidos: char, int, long
y: variável ou constante. Tipos de dados permitidos: char, int, long
Código de Exemplo
Bits que são operados através do E com 0 são limpos, então se meuByte é uma variável byte:,
meuByte & B00000000 = 0;
Bits que são operados através do E com 1 não são mudados, então se meuByte é uma variável byte:
meuByte & B11111111 = meuByte;
Notas e Advertências | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
bd8c6b08bc01-3 | meuByte & B11111111 = meuByte;
Notas e Advertências
Porque estamos lidando com bits em um operador bitwise, é conveniente usar o modificador binário com constantes na representação. Os números ainda são os mesmos em outras representações, só não são tão fáceis de entender. Também, B00000000 é mostrado para claridade, mas zero em qualquer outro formato é zero.
Consequentemente - para limpar os bits 0 e 1 de um variável, ao mesmo tempo deixando o resto da variável intocado, useo o operador de atribuição por bitwise E (&=) com a constante B11111100
1 0 1 0 1 0 1 0 variável | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
bd8c6b08bc01-4 | 1 1 1 1 1 1 0 0 máscara
----------------------
1 0 1 0 1 0 0 0
bits intactos
bits limpos
Abaixo a mesma representação com os bits da variável substituidos pelo símbolo x
x x x x x x x x variável
1 1 1 1 1 1 0 0 máscara
----------------------
x x x x x x 0 0
bits intactos
bits limpos
Então:
myByte = B10101010;
myByte &= B11111100; // resulta em B10101000
Ver Também | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
bd8c6b08bc01-5 | Ver Também
LINGUAGEM & Bitwise E | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwiseand/index.html |
b0d5893dfcc7-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
> Structure
> Compound operators
> Increment
++
[Compound Operators]
Descrição
Incrementa o valor de uma variável em 1.
Sintaxe | https://www.arduino.cc/reference/pt/language/structure/compound-operators/increment/index.html |
b0d5893dfcc7-1 | Descrição
Incrementa o valor de uma variável em 1.
Sintaxe
x++; // incrementa x em um e retorna o valor antigo de x
++x; // incrementa x em um e retorna o novo valor de x
Parâmetros
x: variável. Tipos de dados permitidos: integer, long (possivelmente unsigned)
Retorna
O valor original ou incrementado da variável, que depende se o operador está à esquerda ou direita da variável.
Código de Exemplo
x = 2;
y = ++x; // x agora contém 3, y contém 3
y = x++; // x contém 4, mas y ainda contém 3
Ver Também | https://www.arduino.cc/reference/pt/language/structure/compound-operators/increment/index.html |
538b82f7d34f-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
> Structure
> Compound operators
> Compoundsubtraction
-=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundsubtraction/index.html |
538b82f7d34f-1 | -=
[Compound Operators]
Descrição
Essa é uma abreviação conveniente para realizar a subtração de uma variável com outra variável ou constante.
Sintaxe
x -= y; // equivalente a expressão x = x - y;
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
x = 20;
x -= 2; // x agora contém 18
Ver Também
LINGUAGEM Subtração comum | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundsubtraction/index.html |
4a19745da3ba-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
> Structure
> Compound operators
> Compoundbitwisexor
^=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwisexor/index.html |
4a19745da3ba-1 | ^=
[Compound Operators]
Descrição
O operador de atribuição composta bitwise OU EXCLUSIVO ^= é frequentemente usado com uma variável e uma constante para "inverter" (ou trocar) bits particulares de uma variável.
Uma revisão do operador bitwise OU EXCLUSIVO ^:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado retornado
Sintaxe
x ^= y; // equivalente a x = x ^ y;
Parâmetros
x: variável. Tipos de dados permitidos: char, int, long
y: variável ou constante. Tipos de dados permitidos: char, int, long | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwisexor/index.html |
4a19745da3ba-2 | Código de Exemplo
Bits que são operados através do OU OEXCLUSIVO com 0 não são mudados, então se meuByte é uma variável byte:
meuByte ^ B00000000 = meuByte;
Bits que são operados através do OU EXCLUSIVO com 1 são invertidos, então:
meuByte ^ B11111111 = ~meuByte;
Notas e Advertências
Porque estamos lidando com bits em um operador bitwise, é conveniente usar o modificador binário com constantes na representação. Os números ainda são os mesmos em outras representações, só não são tão fáceis de entender. Também, B00000000 é mostrado para claridade, mas zero em qualquer outro formato é zero. | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwisexor/index.html |
4a19745da3ba-3 | Consequentemente, para inverter os bits 0 e 1 de um variável ao mesmo tempo, deixando o resto da variável intocado, use o operador de atribuição por bitwise OU EXCLUSIVO (^=) com a constante B00000011
1 0 1 0 1 0 1 0 variável
0 0 0 0 0 0 1 1 máscara
----------------------
1 0 1 0 1 0 0 1
bits intactos
bits invertidos
Abaixo a mesma representação com os bits da variável substituidos pelo símbolo x. ~x representa o complemento de x.
x x x x x x x x variável | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwisexor/index.html |
4a19745da3ba-4 | x x x x x x x x variável
0 0 0 0 0 0 1 1 máscara
----------------------
x x x x x x ~x ~x
bits intactos
bits invertidos
Então:
myByte = B10101010;
myByte ^= B00000011 == B10101001;
Ver Também
LINGUAGEM ^ OU EXCLUSIVO Bitwise | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundbitwisexor/index.html |
4d315f4b52e0-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
> Structure
> Compound operators
> Decrement
--
[Compound Operators]
Descrição
Decrementa o valor de uma variável em 1.
Sintaxe | https://www.arduino.cc/reference/pt/language/structure/compound-operators/decrement/index.html |
4d315f4b52e0-1 | Decrementa o valor de uma variável em 1.
Sintaxe
x--; // decrementa x em um e retorna o valor antigo de x
--x; // decrementa x em um e retorna o novo valor de x
Parâmetros
x: variável. Tipos de dados permitidos: integer, long (possibly unsigned)
Retorna
O valor original ou decrementado da variável, que depende se o operador está à esquerda ou direita da variável.
Código de Exemplo
x = 2;
y = --x; // x agora contém 1, y contém 1
y = x--; // x contém 0, mas y ainda contém 1
Ver Também | https://www.arduino.cc/reference/pt/language/structure/compound-operators/decrement/index.html |
b6799f5af363-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
> Structure
> Compound operators
> Compoundaddition
+=
[Compound Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundaddition/index.html |
b6799f5af363-1 | +=
[Compound Operators]
Descrição
Essa é uma abreviação conveniente para realizar a adição de uma variável com outra variável ou constante.
Sintaxe
x += y; // equivalente a expressão x = x + y;
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
x = 2;
x += 4; // x agora contém 6
Ver Também
LINGUAGEM Adição comum | https://www.arduino.cc/reference/pt/language/structure/compound-operators/compoundaddition/index.html |
37271b860db7-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
> Structure
> Arithmetic operators
> Modulo
%
[Arithmetic Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/modulo/index.html |
37271b860db7-1 | %
[Arithmetic Operators]
Descrição
A operação resto calcula o resto da divisão de um inteiro por outro. Esse operador também pode ser chamado de módulo. Apesar do nome, não confunda o operador módulo (%) da computação com o módulo da matemática ( |x| ), que na linguagem arduino é calculado através da função abs(). Esse operador é útil para manter uma variável dentro de um intervalo (ex. o tamanho de um vetor). O símbolo % (porcentagem) é usado para realizar a operação resto.
Sintaxe
resto = dividendo % divisor;
Parâmetros
resto : variável. Tipos de dados permitidos: int, float, double
dividendo : variável ou constante. Tipos de dados permitidos: int | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/modulo/index.html |
37271b860db7-2 | dividendo : variável ou constante. Tipos de dados permitidos: int
divisor : variável ou constante diferente de zero. Tipos de dados permitidos: int
Código de Exemplo
int x = 0;
x = 7 % 5; // x agora contém 2
x = 9 % 5; // x agora contém 4
x = 5 % 5; // x agora contém 0
x = 4 % 5; // x agora contém 4
/* Atualiza um valor do vetor a cada vez em um loop */
int values[10];
int i = 0;
void setup() {}
void loop()
{
values[i] = analogRead(0); | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/modulo/index.html |
37271b860db7-3 | void loop()
{
values[i] = analogRead(0);
i = (i + 1) % 10; // o operador módulo faz a variável i "rolar" pro próximo valor
}
Notas e Advertências
O operador resto não funciona em floats.
Ver Também | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/modulo/index.html |
2fa8d6d37335-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
> Structure
> Arithmetic operators
> Addition
+
[Arithmetic Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/addition/index.html |
2fa8d6d37335-1 | > Addition
+
[Arithmetic Operators]
Descrição
Adição é uma das quatro operações ariméticas fundamentais. O operador + (mais) opera em dois operandos para produzir a soma dos mesmos.
Sintaxe
soma = operando1 + operando2;
Parâmetros
soma : variável. Tipos de dados permitidos: int, float, double, byte, short, long
operando1 : variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
operando2 : variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
int a = 5;
int b = 10;
int c = 0; | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/addition/index.html |
2fa8d6d37335-2 | int b = 10;
int c = 0;
c = a + b; // A variável 'c' recebe o valor 15 depois que essa operação é executada
Notas e Advertências
O operação de adição pode causar overflow se o resultado é maior que o que pode ser armazenado no tipo de dado (ex. adicionar 1 a um int com valor 32,767 resulta em -32,768).
Se um dos números (operandos) é do tipo float ou double, a matemática de ponto flutuante será usada no cálculo.
Se os operandos são do tipo de dado float ou double e a variável que armazena a soma é int, então apenas a parte inteira é salva no resultado e e a parte racional é perdida.
float a = 5.5;
float b = 6.6; | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/addition/index.html |
2fa8d6d37335-3 | float a = 5.5;
float b = 6.6;
int c = 0;
c = a + b; // a variável 'c' guarda o valor 12 apenas, em vez de 12.1
Ver Também | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/addition/index.html |
8d0f5b8ac138-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
> Structure
> Arithmetic operators
> Assignment
=
[Arithmetic Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/assignment/index.html |
8d0f5b8ac138-1 | > Assignment
=
[Arithmetic Operators]
Descrição
O sinal de igual = na linguagem de programação C++ é chamado operador de atribuição. Seu significado é diferente das aulas de matemática, onde ele indica uma equação ou igualdade. O operador de atribuição indica ao microcontrolador que compute qualquer valor ou expressão que estiver à direita do sinal de igual, e o armazene na variável à esquerda do sinal de igual.
Código de Exemplo
int sensVal; // declara uma variável inteira chamada sensVal
sensVal = analogRead(0); // armazena a tensão (digitalizada) do pino analógico 0 em SensVal
Notas e Advertências | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/assignment/index.html |
8d0f5b8ac138-2 | Notas e Advertências
A variável à esquerda do operador de atribuição ( sinal = ) precisa ser um tipo de dado capaz de armazenar o resultado da operação. Se ela não for grande o suficiente para guardar o valor, o resultado armazenado será incorreto. Veja os tipos de dados da linguagem Arduino para mais informações sobre seu tamanho.
Não confunda o operador de atribuição [ = ] (sinal de igual único) com o operador de comparação [ == ] (sinal de igual duplo), o qual avalia se se duas expressões são iguais.
Ver Também
LINGUAGEM if (operadores condicionais)
LINGUAGEM char
LINGUAGEM int
LINGUAGEM long | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/assignment/index.html |
fecb7cd0fe8a-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
> Structure
> Arithmetic operators
> Division
/
[Arithmetic Operators]
Descrição | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/division/index.html |
fecb7cd0fe8a-1 | > Division
/
[Arithmetic Operators]
Descrição
Divisão é uma das quatro operações aritméticas fundamentais. O operador / (barra) opera em dois operandos para produzir o resultado.
Sintaxe
resultado = numerador / denominador;
Parâmetros
resultado : variável. Tipos de dados permitidos: int, float, double, byte, short, long
numerador : variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long
denominador : variável ou constante diferente de zero. Tipos de dados permitidos: int, float, double, byte, short, long
Código de Exemplo
int a = 50;
int b = 10;
int c = 0; | https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/division/index.html |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.