id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
fecb7cd0fe8a-2
|
int b = 10;
int c = 0;
c = a / b; // A variável 'c' recebe o valor 5 depois que essa operação é executada
Notas e Advertências
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 divisão é int, então apenas a parte inteira é salva no resultado e a parte racional é perdida.
float a = 55.5;
float b = 6.6;
int c = 0;
c = a / b; // a variável 'c' armazena o valor 8 em vez do resultado esperado 8.409
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/division/index.html
|
fec10171920a-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
> Multiplication
*
[Arithmetic Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/multiplication/index.html
|
fec10171920a-1
|
*
[Arithmetic Operators]
Descrição
Multiplicação é uma das quatro operações aritméticas fundamentais. O operador * (asterisco) opera em dois operandos para produzir o produto.
Sintaxe
produto = operando1 * operando2;
Parâmetros
produto : 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/multiplication/index.html
|
fec10171920a-2
|
int b = 10;
int c = 0;
c = a * b; // A variável 'c' recebe o valor 50 depois que essa operação é executada
Notas e Advertências
O operação de multiplicação pode causar overflow se o resultado é maior que o que pode ser armazenado no tipo de dado.
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 o produto é int, então apenas a parte inteira é salva no resultado e a parte racional é perdida.
float a = 5.5;
float b = 6.6;
int c = 0;
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/multiplication/index.html
|
fec10171920a-3
|
float b = 6.6;
int c = 0;
c = a * b; // a variável 'c' armazena o valor 36 em vez do resultado esperado 36.3
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/multiplication/index.html
|
b42603d764de-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
> Subtraction
-
[Arithmetic Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/subtraction/index.html
|
b42603d764de-1
|
-
[Arithmetic Operators]
Descrição
Subtração é uma das quatro operações aritméticas fundamentais. O operador - (menos) opera em dois operandos para produzir a diferença do segundo pelo primeiro.
Sintaxe
diferença = operando1 - operando2;
Parâmetros
diferença : 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/subtraction/index.html
|
b42603d764de-2
|
int b = 10;
int c = 0;
c = a - b; // A variável 'c' recebe o valor -5 depois que essa operação é executada
Notas e Advertências
O operação de subtração pode causar overflow se o resultado é menor que o que pode ser armazenado no tipo de dado (ex. subtrair 1 de um int com valor -32,768 resulta em 32,767).
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 diferença é int, então apenas a parte inteira é salva no resultado e a parte racional é perdida.
float a = 5.5;
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/subtraction/index.html
|
b42603d764de-3
|
float a = 5.5;
float b = 6.6;
int c = 0;
c = a - b; // a variável 'c' armazena o valor -1 em vez do resultado esperado -1.1
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/arithmetic-operators/subtraction/index.html
|
5579d7dd9dbe-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
> Sketch
> Setup
setup()
[Sketch]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/sketch/setup/index.html
|
5579d7dd9dbe-1
|
> Setup
setup()
[Sketch]
Descrição
A função setup() é chamada quando um sketch inicia. Use-a para inicializar variáveis, configurar o modo dos pinos(INPUT ou OUTPUT), inicializar bibliotecas, etc. A função setup() será executada apenas uma vez, apoós a placa ser alimentada ou acontecer um reset.
Código de Exemplo
int buttonPin = 3;
void setup() {
// Inicializa a porta serial
Serial.begin(9600);
// configura o pino 3 como INPUT
pinMode(buttonPin, INPUT);
}
void loop() {
// ...
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/sketch/setup/index.html
|
fdb0d2d6fe9f-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
> Sketch
> Loop
loop()
[Sketch]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/sketch/loop/index.html
|
fdb0d2d6fe9f-1
|
> Loop
loop()
[Sketch]
Descrição
Depois de criar uma função setup(), a qual inicializa e atribui os valores iniciais, a função loop() faz precisamente o que o seu nome sugere, e repete-se consecutivamente enquanto a placa estiver ligada, permitindo o seu programa mudar e responder a essas mudanças. Use-a para controlar ativamente uma placa Arduino.
Código de Exemplo
int buttonPin = 3;
// setup inicializa a porta serial e o pino para o botão
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
// loop checa o estado do botão repetidamente, e envia
// pela serial um 'H' se este está sendo pressionado
void loop() {
|
https://www.arduino.cc/reference/pt/language/structure/sketch/loop/index.html
|
fdb0d2d6fe9f-2
|
// pela serial um 'H' se este está sendo pressionado
void loop() {
if (digitalRead(buttonPin) == HIGH) {
Serial.write('H');
}
else {
Serial.write('L');
}
delay(1000);
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/sketch/loop/index.html
|
c26f57556b1c-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
> Boolean operators
> Logicalnot
!
[Boolean Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicalnot/index.html
|
c26f57556b1c-1
|
> Logicalnot
!
[Boolean Operators]
Descrição
O NÃO lógico resulta em verdadeiro se o operando é falso, e vice-versa. Vale lembrar que condições verdadeiras e falsas na linguagem Arduino são representadas por true e false respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um laço if.
if (!x) { // se x não é true
// código a ser executado
}
Pode ser usado para inverter o valor booleano.
x = !y; // o valor booleano invertido de y é guardado em x
Notas e Advertências
O NÃO bitwise ~ (til) é muito diferente do NÃO booleano ! (ponto de exclamação), mas você ainda deve ter certeza de qual você precisa usar.
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicalnot/index.html
|
c26f57556b1c-2
|
Ver Também
LINGUAGEM ~ NÃO Bitwise
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicalnot/index.html
|
c1eb363a345f-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
> Boolean operators
> Logicaland
&&
[Boolean Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicaland/index.html
|
c1eb363a345f-1
|
> Logicaland
&&
[Boolean Operators]
Descrição
O E lógico resulta em verdadeiro, apenas se ambos os operandos são verdadeiros. Vale lembrar que condições verdadeiras e falsas na linguagem Arduino são representadas por true e false respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um laço if.
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // se AMBOS os botões estão em HIGH
// código a ser executado caso as duas condições sejam verdadeiras
}
Notas e Advertências
Tome cuidado para não confundir o operatdor booleano E, && (e comercial duplo); com operador bitwise E, & (e comercial único). Eles são usados para propósitos diferentes.
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicaland/index.html
|
c1eb363a345f-2
|
Ver Também
LINGUAGEM & (E Bitwise)
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicaland/index.html
|
8466187763bc-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
> Boolean operators
> Logicalor
||
[Boolean Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicalor/index.html
|
8466187763bc-1
|
> Logicalor
||
[Boolean Operators]
Descrição
O OU lógico resulta em verdadeiro se pelo menos um dos operandos é verdadeiro. Vale lembrar que condições verdadeiras e falsas na linguagem Arduino são representadas por true e false respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um laço if.
if (x > 0 || y > 0) { // se x ou y é maior que zero
// código a ser executado
}
Notas e Advertências
Não confunda o operador OU booleano || (pipe duplo) com o operador OU bitwise | (pipe único).
Ver Também
LINGUAGEM | OU Bitwise
|
https://www.arduino.cc/reference/pt/language/structure/boolean-operators/logicalor/index.html
|
4e3c6fc5e621-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
> Bitwise operators
> Bitwisenot
~
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisenot/index.html
|
4e3c6fc5e621-1
|
~
[Bitwise Operators]
Descrição
O operador NÃO bit-a-bit em C++ é o caractere til ~. Diferentemente de & e |, o operador bitwise NÃO é aplicado a um único operando a sua direita. O NÃO Bitwise muda cada bit para seu valor oposto: 0 se torna 1, e 1 se torna 0.
Em outras palavras:
0 1 operando1
-----
1 0 ~operando1
Código de Exemplo
int a = 103; // binário: 0000000001100111
int b = ~a; // binário: 1111111110011000 = -104
Notas e Advertências
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisenot/index.html
|
4e3c6fc5e621-2
|
Notas e Advertências
Você pode ficar surpreso ao ver um número negativo como -104 como o resultado dessa operação. Isso acontece porque o bit mais significativo de um valor int é o chamado bit de sinal. Se esse bit é 1, o número é interpretado como negativo. Essa codificação de números positivos e negativos é referido como complemento de dois. Para mais informações, veja o arquivo da Wikipédia a respeito do complemento de dois.
Um comentário adicional: é interessante notar que para qualquer inteiro x, ~x é o mesmo que -x - 1.
As vezes, o bit de sinal em uma expressão pode causar alguns efeitos indesejados, veja a página do operador de deslocamento à direita (>>), por exemplo, para mais detalhes.
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisenot/index.html
|
4e3c6fc5e621-3
|
Ver Também
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisenot/index.html
|
84528dadd450-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
> Bitwise operators
> Bitshiftright
>>
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftright/index.html
|
84528dadd450-1
|
>>
[Bitwise Operators]
Descrição
O operador de deslocamento à direita >> faz os bits do operando à esquerda do operador serem deslocados à direita pelo número de posições especificadas pelo operando à direita do operador.
Sintaxe
variável << numero_de_bits;
Parâmetros
variável: Tipos de dados permitidos: byte, int, long
numero_de_bits: um número menor ou igual 32. Tipos de dados permitidos: int
Código de Exemplo
int a = 40; // binário: 0000000000101000
int b = a >> 3; // binário: 0000000000000101, ou 5 em decimal
Notas e Advertências
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftright/index.html
|
84528dadd450-2
|
Notas e Advertências
Quando você desloca x à direita por y bits (x >> y), e o bit mais significativo em x é 1, o comportamento depende do tipo de dado de x. Se x é do tipo int, o bit mais significativo é o bit de sinal, determinando se x é negativo ou não, como pode ser visto com detalhes na página do tipo de dado int. Nesse caso, o bit de sinal é copiado para os bits menos significativos quando o valor é deslocado, por razões históricas:
int x = -16; // binário: 1111111111110000
int y = 3;
int resultado = x >> y; // binário: 1111111111111110
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftright/index.html
|
84528dadd450-3
|
int resultado = x >> y; // binário: 1111111111111110
Esse comportamento, chamado extensão do sinal, é frequentemente indesejável. Em vez disso, você pode quere que zeros sejam deslocados da esquerda. Acontece que as regras do deslocamento à direita são diferentes para expressões unsigned int, estão você pode usar casting para impedir que uns sejam copiados da esquerda:
int x = -16; // binário: 1111111111110000
int y = 3;
int resultado = (unsigned int)x >> y; // binário: 0001111111111110
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftright/index.html
|
84528dadd450-4
|
Se você for cuidadoso para evitar a extensão do sinal, você pode usar o operador de deslocamento à direita >> como uma forma de dividir por potências de 2. Por exemplo:
int x = 1000;
int y = x >> 3; // divisão inteira de 1000 por 8, resultando em y = 125.
Ver Também
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftright/index.html
|
71b144c0fee7-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
> Bitwise operators
> Bitshiftleft
<<
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftleft/index.html
|
71b144c0fee7-1
|
<<
[Bitwise Operators]
Descrição
O operador de deslocamento a esquerda << faz os bits do operando à esquerda do operador serem deslocados a esquerda pelo número de posições especificadas pelo operando à direita do operador.
Sintaxe
variável << numero_de_bits;
Parâmetros
variável: Tipos de dados permitidos: byte, int, long
numero_de_bits: um número menor ou igual 32. Tipos de dados permitidos: int
Código de Exemplo
int a = 5; // binário: 0000000000000101
int b = a << 3; // binário: 0000000000101000, ou 40 em decimal
Notas e Advertências
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftleft/index.html
|
71b144c0fee7-2
|
Notas e Advertências
Quando você desloca um valor x por y bits (x << y), os y bits mais a esquerda em x são perdidos, literalmente deslocados para fora da existência:
int x = 5; // binário: 0000000000000101
int y = 14;
int resultado = x << y; // binário: 0100000000000000 - os primeiros 1 em 101 foram descartados
Se você tem certeza que nenhum dos bits 1 em um valor serão descartados no deslocamento, uma forma simples de pensar do operador de deslocamento à esquerda é que ele multiplica o operando a esquerda por 2 elevado ao operando a direita. Por exemplo, para gerar potências de 2, as seguintes expressões podem ser utilizadas:
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftleft/index.html
|
71b144c0fee7-3
|
Operação Resultado
--------- ------
1 << 0 1
1 << 1 2
1 << 2 4
1 << 3 8
...
1 << 8 256
1 << 9 512
1 << 10 1024
...
O exemplo a seguir pode ser utilizado para imprimir um byte recebido no monitor serial, usando o operador de deslocamento à esquerda para mover 1 pelo número de bits especificado, testar o valor com o E (&), e imprimir seu valor (1 ou 0):
// Imprime o valor binário (1 ou 0) de um byte
void printOut1(int c) {
for (int bits = 7; bits > -1; bits--) {
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftleft/index.html
|
71b144c0fee7-4
|
for (int bits = 7; bits > -1; bits--) {
// Compara bits 7-0 no byte
if (c & (1 << bits)) {
Serial.print("1");
}
else {
Serial.print("0");
}
}
}
Ver Também
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitshiftleft/index.html
|
8e619673d704-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
> Bitwise operators
> Bitwiseor
|
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseor/index.html
|
8e619673d704-1
|
|
[Bitwise Operators]
Descrição
O operador bitwise OU em C++ é o caractere barra vertical, |. Da mesma forma que o operador &, | opera independentemente em cada bit dos dois operandos, mas seu propósito é diferente (duh!). O resultado da operação OU entre dois bits é 1 se qualquer um ou ambos os bits de entrada são 1, do contrário é 0.
Explicado de outra forma:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 1 (operando1 | operando2) - resultado retornado
Código de Exemplo
int a = 92; // em binário: 0000000001011100
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseor/index.html
|
8e619673d704-2
|
int b = 101; // em binário: 0000000001100101
int c = a | b; // resultado: 0000000001111101, ou 125 em decimal.
Um dos usos mais comuns do OU bit-a-bit é "setar" um ou mais bits em um valor.
// Nota: Esse código é específico para a arquitetura AVR
// configura os bits de direção para os pinos 2 a 7, deixa 0 e 1 intocados (xx | 00 == xx)
// Equivale a pinMode(pino, OUTPUT) para os pinos 2 a 7 no Arduino Uno ou Nano
DDRD = DDRD | B11111100;
// o mesmo que pinMode(pino, OUTPUT) para os pinos 2 a 7
Ver Também
LINGUAGEM || OU lógico
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseor/index.html
|
8e619673d704-3
|
Ver Também
LINGUAGEM || OU lógico
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseor/index.html
|
910f80adad27-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
> Bitwise operators
> Bitwisexor
^
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisexor/index.html
|
910f80adad27-1
|
^
[Bitwise Operators]
Descrição
Na linguagem C++ existe um operador um pouco incomum chamado de OU EXCLUSIVO, também conhecido como XOR (Em Inglês é pronunciado "eks-or"), bit-a-bit. O operador XOR bitwise é escrito usando-se o símbolo ^. Uma operação XOR bit-a-bit resulta em 1 apenas se os bits de entrada são diferentes. Se iguais, o resultado é zero.
Precisamente,
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado retornado
Código de Exemplo
int x = 12; // binário: 1100
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisexor/index.html
|
910f80adad27-2
|
int x = 12; // binário: 1100
int y = 10; // binário: 1010
int z = x ^ y; // binário: 0110, ou decimal 6
O operador ^ é frequentemente utilizado para trocar (isto é, mudar de 0 para 1, ou 1 para 0) alguns dos bits em uma expressão inteira. Em uma operação XOR se há um 1 no bit da máscara, aquele bit é invertido; se há um 0, o bit não é invertido e continua o mesmo.
// Nota: Esse código usa registradores específicos para microcontroladores AVR (Uno, Nano, Leonardo, Mega, etc.)
// Ele não irá compilar para outras arquiteturas
void setup(){
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisexor/index.html
|
910f80adad27-3
|
// Ele não irá compilar para outras arquiteturas
void setup(){
DDRB = DDRB | B00100000; // configura PB5 (pino 13 no Uno/Nano, pino 9 no Leonardo/Micro, pino 11 no Mega) como OUTPUT
Serial.begin(9600);
}
void loop(){
PORTB = PORTB ^ B00100000; // inverte PB5, deixa os outros bits intocados
delay(100);
}
Ver Também
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwisexor/index.html
|
70b2e2423cc7-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
> Bitwise operators
> Bitwiseand
&
[Bitwise Operators]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseand/index.html
|
70b2e2423cc7-1
|
&
[Bitwise Operators]
Descrição
O operador bitwise E em C++ é um único & (e comercial ou ampersand), usado entre duas expressões inteiras. O operador E bit-a-bit atua em cada bit dos operandos independentemente, de acordo com a seguinte regra: se ambas entradas são 1, a saída resultante é 1, do contrário o resultado é 0.
Outra forma de se expressão isso é:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 0 0 1 (operando1 & operando2) - resultado retornado
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseand/index.html
|
70b2e2423cc7-2
|
No Arduino, o tipo int é um valor 16-bit, então & usado entre dois operandos do tipo int causa 16 operações bit-a-bit E simultâneas.
Código de Exemplo
Em um fragmento de código do tipo:
int a = 92; // em binário: 0000000001011100
int b = 101; // em binário: 0000000001100101
int c = a & b; // resultado: 0000000001000100, ou 68 em decimal.
Cada um dos 16 bits em a e b são processados com o operador &, e todos os 16 bits resultantes são armazenados em c, resultando no valor binário 01000100, que é 68 em decimal.
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseand/index.html
|
70b2e2423cc7-3
|
Um dos usos mais comuns da operação bit-a-bit E é selecionar um bit particular (ou bits) de um valor inteiro, frequentemente chamado de masking. Veja abaixo um exemplo (específico para arquitetura AVR):
PORTD = PORTD & B00000011; // apaga os bits 2 - 7, deixando o valor dos pinos PD0 e PD1 intocados (xx & 11 == xx)
Ver Também
LINGUAGEM && E lógico
EXEMPLO Tutorial BitMath (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/bitwise-operators/bitwiseand/index.html
|
59ecd5fd3741-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
> Control structure
> Break
break
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/break/index.html
|
59ecd5fd3741-1
|
> Break
break
[Control Structure]
Descrição
break é usado usado para sair de um laço for, while ou do…while, ignorando a condição padrão do loop. Também é usada para sair do comando switch case.
Código de Exemplo
No códgo seguinte, o break quebra o loop for quando o valor do sensor excede o limiar.
int lim = 40;
for (int x = 0; x < 255; x ++) {
analogWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > lim) { // "foge" do o loop `for`
x = 0;
break;
}
delay(50);
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/break/index.html
|
2b22dabfe236-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
> Control structure
> If
if
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/if/index.html
|
2b22dabfe236-1
|
> If
if
[Control Structure]
Descrição
O comando if checa uma condição e executas o comando a seguir ou um bloco de comandos delimitados por chaves, se a condição é verdadeira ('true').
Sintaxe
if (condição) {
//comando(s)
}
Parâmetros
condição: uma expressão booleana, isto é, que pode resultar apenas em true ou false
Código de Exemplo
As chaves podem ser omitidas depois de um comando if. Se isso é feito, a próxima linha (definida pelo ponto e vírgula) é interpretada como o único comando condicional. Para mais de um comando, use as chaves para delimitar o bloco de comandos.
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/if/index.html
|
2b22dabfe236-2
|
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
if (x > 120) {
digitalWrite(pinoLED1, HIGH);
digitalWrite(pinoLED2, HIGH);
} // todas as formas acima estão corretas
Notas e Advertências
As expressões sendo testadas dentro dos parênteses geralmente requerem o uso de um ou mais dos operadores mostrados abaixo.
Operadores de comparação:
x == y (x é igual a y)
x != y (x é diferente de y)
x < y (x é menor que y)
x > y (x maior que y)
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/if/index.html
|
2b22dabfe236-3
|
x > y (x maior que y)
x <= y (x é menor ou igual a y)
x >= y (x é maior ou igual a y)
Cuidado para não usar acidentalmente o símbolo de igual simples (ex. if (x = 10) ). O símbolo de igual simples é o operador de atribuição, se atribui 10 a x (coloca o valor 10 na variável x). Em vez disso, o símbolo de igual duplo (ex. if (x == 10) ) deve ser usado, que é o operador de comparação, e testa se x é igaul a 10 ou não. O último é apenas verdadeiro se x é igual a 10, enquanto o primeiro comando mostrado sempre resultará em verdadeiro.
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/if/index.html
|
2b22dabfe236-4
|
Isso acontece porque a linguagem C++ interpreta if (x=10) da seguinte forma: 10 é atribuído a x (Lembre que o símbolo de igual simples é o (operador de atribuição)), então x agora contém 10. então o comando 'if' testa 10, o que sempre resulta true, desde que qualquer número diferente de zero resulta em true. Consequentemente, if (x = 10) irá sempre resultar em true, o que não é desejável ao se usar um comando 'if'. Além disso, a variável x irá receber o valor 10, o que também é indesejado.
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/if/index.html
|
42adfbd2c924-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
> Control structure
> Else
else
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/else/index.html
|
42adfbd2c924-1
|
> Else
else
[Control Structure]
Descrição
A combinação if…else permite maior controle sobre o fluxo de código que o comando mais básico if, por permitir múltiplos testes serem agrupados juntos. Uma cláusula else (se presente) será executada se a condição do comando if resulta em false. O else pode proceder outro teste if, tal que múltiplos, testes mutualmente exclusivos podem ser executados ao mesmo tempo.
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/else/index.html
|
42adfbd2c924-2
|
Cada teste irá proceder para o próximo até um teste que resulte em verdadeiro seja encontrado. Quando esse teste for encontrado, o bloco de código correspondente a condição é executado, e o programa então continua a partir da linha seguinte a estrutura if-else completa. Se nenhum teste resultar em verdadeiro, o bloco else padrão é executado, se um estiver presente, que dita o comportamento padrão.
Note que um bloco else if pode ser usado sem um bloco else no final e vice-versa. Um número praticamente ilimitado de blocos else if conectados é permitido.
Sintaxe
if (condição1) {
// faz coisa A
}
else if (condição2) {
// faz coisa B
}
else {
// faz coisa C
}
Código de Exemplo
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/else/index.html
|
42adfbd2c924-3
|
}
else {
// faz coisa C
}
Código de Exemplo
Abaixo um trecho de código de um sistema de controle de temperatura
if (temperatura >= 70) {
//Perigo! Desligar o sistema
}
else if (temperatura >= 60 && temperatura < 70) {
//Cuidado! Requerida a atenção do usuário
}
else {
//Seguro! Continue as tarefas usuais...
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/else/index.html
|
e9c52862b79e-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
> Control structure
> For
for
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/for/index.html
|
e9c52862b79e-1
|
> For
for
[Control Structure]
Descrição
O comando for é usado para repetir um bloco de código envolvido por chaves. Um contador de incremento é geralmente utilizado para terminar o loop. O comando for é útil para qualquer operação repetitiva, e é usado frequentemente com vetores para operar em coleções de dados ou pinos.
Sintaxe
for (inicialização; condição; incremento) {
//comando(s);
}
A inicialização ocorre primeiro e apenas uma vez. A cada repetição do loop, a condição é testada; se é verdadeira (true), o bloco de comandos, e o incremento são executados. Quando a condição se torna falsa (false), o loop termina.
Código de Exemplo
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/for/index.html
|
e9c52862b79e-2
|
Código de Exemplo
// Varia o brilho de um LED usando um pino PWM
int pinoPWM = 10; // LED em série com um resistor de 470 ohm no pino 10
void setup() {
// setup não necessário
}
void loop() {
for (int i = 0; i <= 255; i++) {
analogWrite(pinoPWM, i);
delay(10);
}
}
Notas e Advertências
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/for/index.html
|
e9c52862b79e-3
|
delay(10);
}
}
Notas e Advertências
O loop for na linguagem C é muito mais flexível que os loops `for` encontrados em outras linguagens. Quaisquer dos três elementos da sintaxe podem ser omitidos, porém os ponto e vírgula (';') são necessários. Além disso, os comandos para inicialização, condição e incremento podem ser quaisquer comandos válidos na linguagem C, mesmo com variáveis não relacionadas ao loop, e podem usar quaisquer tipos de dados da linguagem, incluindo floats. Esses tipos de comandos for incomuns podem prover soluções rápidas para alguns problemas raros de programação.
Por exemplo, usar uma multiplicação no comando de incremento irá gerar uma progressão logarítmica:
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/for/index.html
|
e9c52862b79e-4
|
for (int x = 2; x < 100; x = x * 1.5) {
println(x);
}
Gera: 2,3,4,6,9,13,19,28,42,63,94.
Outro exemplo, Aplica um efeito de fading crescente e decrescente em um LED com apenas um loop for:
void loop() {
int x = 1;
for (int i = 0; i > -1; i = i + x) {
analogWrite(pinoPWM, i);
if (i == 255) {
x = -1; // muda a direção no pico
}
delay(10);
}
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/for/index.html
|
77b042773f45-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
> Control structure
> Goto
goto
[Control Structure]
Descrição
Transfere o fluxo do programa para um ponto rotulado no código.
Sintaxe
rótulo:
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/goto/index.html
|
77b042773f45-1
|
Sintaxe
rótulo:
goto rótulo; // envia o fluxo do programa de volta para o rótulo
Código de Exemplo
O código abaixo "foge" de dentro de todos os laços caso a leitura no pino analógico 0 seja maior que 250.
for (byte r = 0; r < 255; r++) {
for (byte g = 255; g > 0; g--) {
for (byte b = 0; b < 255; b++) {
if (analogRead(0) > 250) {
goto cancelar;
}
// mais comandos ...
}
}
}
cancelar:
// mais comandos ...
Notas e Advertências
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/goto/index.html
|
77b042773f45-2
|
}
cancelar:
// mais comandos ...
Notas e Advertências
O uso do goto é desencorajado na programação em C++, e alguns autores de livros afirmam que o uso do comando goto nunca é necessário, mas se usado judiciosamente ele pode simplificar certos programas. A pela qual muitos programadores desaprovam o uso do goto é que com o uso descuidado de comando goto, é fácil criar um programa com fluxo indefinido, que não pode ser depurado.
Tendo dito isso, há algumas instâncias onde o comando goto pode ser considerado, por simplificar o código. Uma dessas situações é sair de laços for profundamente aninhados, ou blocos if, em determinada condição.
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/goto/index.html
|
b2cd16e0ee70-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
> Control structure
> Return
return
[Control Structure]
Descrição
Termina uma função e retorna um valor, caso desejado.
Sintaxe
return;
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/return/index.html
|
b2cd16e0ee70-1
|
Sintaxe
return;
return valor; // ambas as formas são válidas
Parâmetros
valor: qualquer variável ou constante de qualquer tipo de dado
Código de Exemplo
Uma função para comparar a saída de um sensor com um limiar
int checaSensor() {
if (analogRead(0) > 400) {
return 1;
}
else {
return 0;
}
}
A palavra-chave return é útil para testar uma seção de código sem ter que "comentar" grandes seções de código possivelmente cheio de erros.
void loop() {
return;
// o resto de um esboço disfuncional aqui
// este código nunca será executado
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/return/index.html
|
3aacefdeb2f5-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
> Control structure
> Dowhile
do...while
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/dowhile/index.html
|
3aacefdeb2f5-1
|
do...while
[Control Structure]
Descrição
O loop do…while funciona da mesma forma que o loop while, com a exceção de a condição ser testada no final do loop, tal que o loop será executado pelo menos uma vez.
Sintaxe
do {
// bloco de comandos
} while (condição);
A condição é uma expressão booleana que é avaliada como verdadeiro ou falso, respectivamente true ou false na linguagem Arduino.
Código de Exemplo
int x = 0;
do {
delay(50); // espera os sensores estabilizarem
x = readSensors(); // checa os sensores
} while (x < 100);
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/dowhile/index.html
|
563ec9ba27bf-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
> Control structure
> Continue
continue
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/continue/index.html
|
563ec9ba27bf-1
|
> Continue
continue
[Control Structure]
Descrição
O comando continue "pula" o resto da iteração atual de um loop (for, while, ou do…while). Esse comando continua a checar a expressão condicional do loop, e procede com qualquer iterações subsequentes.
Código de Exemplo
O código abaixo escreve o valor de 0 a 255 ao pino PWMpin, mas pula os valores no intervalo 41 a 119.
for (int x = 0; x <= 255; x ++) {
if (x > 40 && x < 120) { // cria um salto nos valores
continue;
}
analogWrite(PWMpin, x);
delay(50);
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/continue/index.html
|
1a7857589c53-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
> Control structure
> Switchcase
switch...case
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/switchcase/index.html
|
1a7857589c53-1
|
switch...case
[Control Structure]
Descrição
Da mesma forma que o comando if, o comando switch case controla o fluxo do programa permitindo ao programador especificar código diferente para ser executado em várias condições. Em particular, um comando switch compara o valor de uma variável aos valores especificados nos comandos case. Quando um comando case é encontrado cujo valor é igual ao da variável, o código para esse comando case é executado.
A palavra-chave break interrompe o comando switch, e é tipicamente usada no final de cada case. Sem um comando break, o comando switch irá continuar a executar as expressões seguintes (desnecessariamente) até encontrar um break, ou até o final do comando switch ser alcançado.
Sintaxe
switch (var) {
case valor1:
// comando(s)
break;
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/switchcase/index.html
|
1a7857589c53-2
|
case valor1:
// comando(s)
break;
case valor2:
// comando(s)
break;
default:
// comando(s)
break;
}
Parâmetros
var: uma variável para ser comparada com os vários cases. Tipos de dados permitidos: int, char
valor1, valor2: constantes. Tipos de dados permitidos: int, char
Retorna
Nada
Código de Exemplo
switch (var) {
case 1:
// faz algo quando var é igual a 1
break;
case 2:
// faz algo quando var é igual a 2
break;
default:
// Se nenhum dos anteriores, faz o caso padrão default
// default é opcional
break;
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/switchcase/index.html
|
d0004b757dee-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
> Control structure
> While
while
[Control Structure]
Descrição
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/while/index.html
|
d0004b757dee-1
|
> While
while
[Control Structure]
Descrição
Um loop while irá se repetir continuamente, e infinitamente, até a expressão dentro dos parênteses (), se torne falsa. Algo deve mudar a variável testada, ou o loop while nunca irá encerrar. Isso pode ser no seu código, por exemplo, uma variável incrementada, ou uma condição externa, como a leitura de um sensor.
Sintaxe
while (condição) {
// código a ser executado repetidamente
}
A condição é uma expressão booleana que resulta em true ou false.
Código de Exemplo
var = 0;
while (var < 200) {
// faz algo repetitivo 200 vezes
var++;
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/while/index.html
|
d0004b757dee-2
|
var++;
}
Ver Também
EXEMPLO Loop While (Em Inglês)
|
https://www.arduino.cc/reference/pt/language/structure/control-structure/while/index.html
|
28fbe11e535b-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
> Variable scope qualifiers
> Volatile
volatile
[Variable Scope & Qualifiers]
Descrição
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
28fbe11e535b-1
|
volatile
[Variable Scope & Qualifiers]
Descrição
A palavra chave volatile é conhecida como um qualificador de variáveis, e é geralmente usada antes do tipo de dado da variável, para modificar a forma com qual o compilador e o programa tratam a variável.
Declarar uma variável como volatile é uma diretiva para o compilador. O compilador é o software que traduz seu código C/C++ em linguagem de máquina, que são as instruções reais entendidas pelo chip microcontrolador na placa Arduino.
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
28fbe11e535b-2
|
Especificamente, essa diretiva faz com que o compilador carregue a variável da RAM e não de um registrador, que é uma localização temporária da memória onde variáveis do programa são guardadas e manipuladas. Sob certas circunstâncias, o valor de uma variável armazenada em registradores pode ser impreciso.
Uma variável deve ser declarada volatile quando seu valor pode ser mudado por algo além do controle da seção de código na qual ela aparece, como uma thread paralela. No Arduino, o único lugar do código onde isso pode ocorrer é em seções associadas com interrupções, chamadas de rotina de serviço de interrupção (interrupt service routine).
variáveis volatile int ou long
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
28fbe11e535b-3
|
variáveis volatile int ou long
Se a variável volatile é maior que um byte (ex. um int de 16 bits ou long de 32 bits), o microcontrolador não é capaz de lê-la em apenas um passo, porquê é um microcontrolador 8 bits. Isso significa que enquanto a seção principal do seu código (ex. seu loop) lê o primeiro ou os primeiros bytes da variável, a interrupção pode mudar os outros bytes. Isso irá produzir valores inesperados na variável.
Solução:
Enquanto a variável é lida, as interrupções são desativadas, de forma que estas não podem bagunçar as variáveis durante a leitura.
Há algumas formas de se fazer isso:
noInterrupts
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
28fbe11e535b-4
|
Há algumas formas de se fazer isso:
noInterrupts
usar a macro ATOMIC_BLOCK. Operações atômicas são operações únicas para o microcontrolador - a menor unidade possível.
Código de Exemplo
// muda o estado do LED quando o estado do botão é mudado
int pin = 13;
volatile int state = LOW;
void setup() {
pinMode(pin, OUTPUT);
attachInterrupt(digitalPinToInterrupt(2), blink, CHANGE);
}
void loop() {
digitalWrite(pin, state);
}
void blink() {
state = !state;
}
#include <util/atomic.h> // essa biblioteca inclui a macro ATOMIC_BLOCK.
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
28fbe11e535b-5
|
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
// código com interrupções bloqueadas (operações atômicas consecutivas não irão ser interrompidas)
}
Ver Também
LINGUAGEM attachInterrupt
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/volatile/index.html
|
9f63f15c0f71-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
> Variable scope qualifiers
> Const
const
[Variable Scope & Qualifiers]
Descrição
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/const/index.html
|
9f63f15c0f71-1
|
const
[Variable Scope & Qualifiers]
Descrição
A palavra-chave const é uma abreviação de constante. É um qualificador de variáveis que modifica o comportamento da variável, fazendo com que a variável seja de "apenas-leitura". Isso significa que a variável pode ser usada como qualquer outra variável de seu tipo, mas seu valor não pode ser mudado. Você terá um erro de compilação se tentar atribuir um valor a uma variável const.
Constantes definidas com a palavra chave const obedecem as regras dos escopos de variáveis que governam variáveis. Isso, e as armadilhas de se usar #define, fazem com que o modificador const um método superior de se definir constantes e é favorecido em lugar de se usar #define.
Código de Exemplo
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/const/index.html
|
9f63f15c0f71-2
|
Código de Exemplo
const float pi = 3.14;
float x;
// ....
x = pi * 2; // constantes podem ser usadas em cálculos
pi = 7; // ilegal - você não pode modificar o valor de uma constante
Notas e Advertências
#define ou const
Você pode usar ambos const ou #define para criar constantes numéricas ou strings constantes. Para vetores, você irá precisar usar const. Em geral, const é favorecido em lugar de #define ao se definir constantes.
Ver Também
LINGUAGEM #define
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/const/index.html
|
338f9994e3b0-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
> Variable scope qualifiers
> Scope
escopo
[Variable Scope & Qualifiers]
Descrição
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/scope/index.html
|
338f9994e3b0-1
|
escopo
[Variable Scope & Qualifiers]
Descrição
Variáveis na linguagem de programação C++, a qual o Arduino usa, possuem uma propriedade chamada escopo. Isso contrasta com antigas versões de linguagens como o BASIC onde toda variável era uma variável global.
Uma variável global é uma que pode ser vista por todas as funções de um programa. Diferentemente, variáveis locais são visíveis apenas às funções nas quais são declaradas. No ambiente Arduino, qualquer variável declarada fora de uma função (ex. setup(), loop(), etc. ), é uma variável _ global_.
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/scope/index.html
|
338f9994e3b0-2
|
Quando programas começam a ficar muito longos e complexos, variáveis locais são uma forma útil de garantir que apenas uma função tenha acesso as suas próprias variáveis. Isso previne erros de programação quando uma função inadvertidamente modifica variáveis usadas por outra função.
Às vezes também é vantajoso declarar e inicializar uma variável dentro de um loop for. Isso cria uma variável que pode ser acessada apenas dentro do próprio bloco do loop for.
Código de Exemplo
int gPWMval; // qualquer função poderá acessar essa variável
void setup() {
// ...
}
void loop() {
int i; // "i" é "visível" apenas dentro de "loop"
float f; // "f" é "visível" apenas dentro de "loop"
// ...
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/scope/index.html
|
338f9994e3b0-3
|
// ...
for (int j = 0; j < 100; j++) {
// a variável j pode ser acessada apenas dentro das chaves do loop for
}
}
Ver Também
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/scope/index.html
|
63965dfea3f2-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
> Variable scope qualifiers
> Static
static
[Variable Scope & Qualifiers]
Descrição
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/static/index.html
|
63965dfea3f2-1
|
static
[Variable Scope & Qualifiers]
Descrição
A palavra-chave static é usada para criar variáveis que são visíveis para apenas uma função. No entanto, diferentemente de variáveis locais, que são criadas e destruidas toda vez que uma função é chamada, variáveis static persistem entre chamadas da função, preservando seu valor.
Variáveis declaradas como static são criadas e inicializadas apenas a primeria vez que uma função é chamada.
Código de Exemplo
/* RandomWalk
Paul Badger 2007
RandomWalk wanders up and down randomly between two
endpoints. The maximum move in one loop is governed by
the parameter "stepsize".
A static variable is moved up and down a random amount.
This technique is also known as "pink noise" and "drunken walk".
*/
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/static/index.html
|
63965dfea3f2-2
|
This technique is also known as "pink noise" and "drunken walk".
*/
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;
int thisTime;
int total;
void setup() {
Serial.begin(9600);
}
void loop() {
// test randomWalk function
stepsize = 5;
thisTime = randomWalk(stepsize);
Serial.println(thisTime);
delay(10);
}
int randomWalk(int moveSize) {
static int place; // variable to store value in random walk - declared static so that it stores
// values in between function calls, but no other functions can change its value
place = place + (random(-moveSize, moveSize + 1));
if (place < randomWalkLowRange) { // check lower and upper limits
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/static/index.html
|
63965dfea3f2-3
|
if (place < randomWalkLowRange) { // check lower and upper limits
place = randomWalkLowRange + (randomWalkLowRange - place); // reflect number back in positive direction
}
else if (place > randomWalkHighRange) {
place = randomWalkHighRange - (place - randomWalkHighRange); // reflect number back in negative direction
}
return place;
}
Ver também
|
https://www.arduino.cc/reference/pt/language/variables/variable-scope-qualifiers/static/index.html
|
086d6683d6df-0
|
Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Variables
> Conversion
> Bytecast
byte()
[Conversion]
Descrição
Converte um valor para o tipo de dado byte.
Sintaxe
byte(x)
Parâmetros
|
https://www.arduino.cc/reference/pt/language/variables/conversion/bytecast/index.html
|
086d6683d6df-1
|
Sintaxe
byte(x)
Parâmetros
x: um valor de qualquer tipo
Retorna
o valor passado para a função, convertido para o tipo byte
Ver Também
LINGUAGEM byte
|
https://www.arduino.cc/reference/pt/language/variables/conversion/bytecast/index.html
|
119d7b7d1fe1-0
|
Linguagem
funções
variáveis
estrutura
Bibliotecas
IoT Cloud API
Glossário
A documentação de referência da linguagem Arduino está licenciada sob a licença Creative Commons Attribution-Share Alike 3.0.
Encontrou alguma coisa que pode ser melhorada? Sugira correções e nova documentação via GitHub.
Dúvidas sobre como usar o Github? Aprenda tudo o que precisa saber nesse tutorial.
Last Revision: Searching...
Last Build: 2023/06/30
Editar essa Página
Reference
> Language
> Variables
> Conversion
> Wordcast
word()
[Conversion]
Descrição
Converte um valor para o tipo de dado word.
Sintaxe
word(x)
word(h, l)
|
https://www.arduino.cc/reference/pt/language/variables/conversion/wordcast/index.html
|
119d7b7d1fe1-1
|
Sintaxe
word(x)
word(h, l)
Parâmetros
x: um valor de qualquer tipo
h: o byte mais significativo (mais à esquerda) da palavra
l: o byte menos significativo (mais à direita) da palavra
Retorna
O valor passado para a função, convertido para o tipo word
Ver Também
LINGUAGEM word
|
https://www.arduino.cc/reference/pt/language/variables/conversion/wordcast/index.html
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.