Arduino - Guia rápido

Arduino é uma plataforma de protótipo (código-fonte aberto) baseada em um hardware e software fácil de usar. Ele consiste em uma placa de circuito, que pode ser programada (chamada de microcontrolador) e um software pronto chamado Arduino IDE (Integrated Development Environment), que é usado para escrever e fazer upload do código do computador para a placa física.

Os principais recursos são -

• As placas Arduino são capazes de ler sinais de entrada analógicos ou digitais de diferentes sensores e transformá-los em uma saída, como ativar um motor, ligar / desligar o LED, conectar-se à nuvem e muitas outras ações.

• Você pode controlar as funções da placa enviando um conjunto de instruções para o microcontrolador na placa via Arduino IDE (conhecido como software de upload).

• Ao contrário da maioria das placas de circuito programáveis ​​anteriores, o Arduino não precisa de uma peça extra de hardware (chamada de programador) para carregar um novo código na placa. Você pode simplesmente usar um cabo USB.

• Além disso, o Arduino IDE usa uma versão simplificada do C ++, tornando mais fácil aprender a programar.

• Finalmente, o Arduino fornece um formato padrão que divide as funções do microcontrolador em um pacote mais acessível.

Tipos de placa

Vários tipos de placas Arduino estão disponíveis, dependendo dos diferentes microcontroladores usados. No entanto, todas as placas Arduino têm uma coisa em comum: elas são programadas por meio do IDE do Arduino.

As diferenças são baseadas no número de entradas e saídas (o número de sensores, LEDs e botões que você pode usar em uma única placa), velocidade, tensão operacional, fator de forma, etc. Algumas placas são projetadas para serem incorporadas e não têm programação interface (hardware), que você precisa comprar separadamente. Alguns podem funcionar diretamente com uma bateria de 3,7 V, outros precisam de pelo menos 5 V.

Aqui está uma lista de diferentes placas Arduino disponíveis.

Arduino boards based on ATMEGA328 microcontroller

Nome do Conselho	Volt operacional	Velocidade do relógio	I / o digital	Entradas Analógicas	PWM	UART	Interface de Programação
Arduino Uno R3	5V	16MHz	14	6	6	1	USB via ATMega16U2
Arduino Uno R3 SMD	5V	16MHz	14	6	6	1	USB via ATMega16U2
Quadro Vermelho	5V	16MHz	14	6	6	1	USB via FTDI
Arduino Pro 3.3v / 8 MHz	3,3 V	8MHz	14	6	6	1	Cabeçalho compatível com FTDI
Arduino Pro 5V / 16MHz	5V	16MHz	14	6	6	1	Cabeçalho compatível com FTDI
Arduino mini 05	5V	16MHz	14	8	6	1	Cabeçalho compatível com FTDI
Arduino Pro mini 3.3v / 8mhz	3,3 V	8MHz	14	8	6	1	Cabeçalho compatível com FTDI
Arduino Pro mini 5v / 16mhz	5V	16MHz	14	8	6	1	Cabeçalho compatível com FTDI
Arduino Ethernet	5V	16MHz	14	6	6	1	Cabeçalho compatível com FTDI
Arduino Fio	3,3 V	8MHz	14	8	6	1	Cabeçalho compatível com FTDI
LilyPad Arduino 328 placa principal	3,3 V	8MHz	14	6	6	1	Cabeçalho compatível com FTDI
LilyPad Arduino placa simples	3,3 V	8MHz	9	4	5	0	Cabeçalho compatível com FTDI

Arduino boards based on ATMEGA32u4 microcontroller

Nome do Conselho	Volt operacional	Velocidade do relógio	I / o digital	Entradas Analógicas	PWM	UART	Interface de Programação
Arduino Leonardo	5V	16MHz	20	12	7	1	USB nativo
Pro micro 5V / 16MHz	5V	16MHz	14	6	6	1	USB nativo
Pro micro 3,3 V / 8 MHz	5V	16MHz	14	6	6	1	USB nativo
LilyPad Arduino USB	3,3 V	8MHz	14	6	6	1	USB nativo

Arduino boards based on ATMEGA2560 microcontroller

Nome do Conselho	Volt operacional	Velocidade do relógio	I / o digital	Entradas Analógicas	PWM	UART	Interface de Programação
Arduino Mega 2560 R3	5V	16MHz	54	16	14	4	USB via ATMega16U2B
Mega Pro 3.3V	3,3 V	8MHz	54	16	14	4	Cabeçalho compatível com FTDI
Mega Pro 5V	5V	16MHz	54	16	14	4	Cabeçalho compatível com FTDI
Mega Pro Mini 3.3V	3,3 V	8MHz	54	16	14	4	Cabeçalho compatível com FTDI

Arduino boards based on AT91SAM3X8E microcontroller

Nome do Conselho	Volt operacional	Velocidade do relógio	I / o digital	Entradas Analógicas	PWM	UART	Interface de Programação
Arduino Mega 2560 R3	3,3 V	84 MHz	54	12	12	4	Nativo USB

Neste capítulo, aprenderemos sobre os diferentes componentes da placa Arduino. Vamos estudar a placa Arduino UNO porque é a placa mais popular da família de placas Arduino. Além disso, é a melhor placa para começar com eletrônica e codificação. Algumas placas parecem um pouco diferentes da fornecida abaixo, mas a maioria dos Arduinos tem a maioria desses componentes em comum.

	Power USB A placa Arduino pode ser alimentada usando o cabo USB do seu computador. Tudo o que você precisa fazer é conectar o cabo USB à conexão USB (1).
	Power (Barrel Jack) As placas Arduino podem ser alimentadas diretamente da fonte de alimentação CA conectando-a ao Barrel Jack (2).
	Voltage Regulator A função do regulador de tensão é controlar a tensão fornecida à placa Arduino e estabilizar as tensões CC usadas pelo processador e outros elementos.
	Crystal Oscillator O oscilador de cristal ajuda o Arduino a lidar com os problemas de tempo. Como o Arduino calcula o tempo? A resposta é, usando o oscilador de cristal. O número impresso na parte superior do cristal do Arduino é 16.000H9H. Isso nos diz que a frequência é 16.000.000 Hertz ou 16 MHz.
	Arduino Reset Você pode redefinir sua placa Arduino, ou seja, iniciar seu programa desde o início. Você pode reinicializar a placa UNO de duas maneiras. Primeiro, usando o botão de reset (17) na placa. Em segundo lugar, você pode conectar um botão de reset externo ao pino do Arduino denominado RESET (5).
	Pins (3.3, 5, GND, Vin) 3,3 V (6) - Fornece 3,3 volt de saída 5 V (7) - Fornece 5 volt de saída A maioria dos componentes usados ​​com a placa Arduino funciona bem com 3,3 volts e 5 volts. GND (8) (Terra) - Existem vários pinos GND no Arduino, qualquer um dos quais pode ser usado para aterrar seu circuito. Vin (9) - Este pino também pode ser usado para alimentar a placa Arduino a partir de uma fonte de alimentação externa, como uma fonte de alimentação CA.
	Analog pins A placa Arduino UNO tem seis pinos de entrada analógica A0 a A5. Esses pinos podem ler o sinal de um sensor analógico como o sensor de umidade ou sensor de temperatura e convertê-lo em um valor digital que pode ser lido pelo microprocessador.
	Main microcontroller Cada placa Arduino possui seu próprio microcontrolador (11). Você pode assumi-lo como o cérebro do seu conselho. O IC principal (circuito integrado) no Arduino é um pouco diferente de placa para placa. Os microcontroladores são geralmente da empresa ATMEL. Você deve saber o que IC sua placa tem antes de carregar um novo programa do IDE do Arduino. Essas informações estão disponíveis na parte superior do CI. Para mais detalhes sobre a construção e funções do IC, você pode consultar a folha de dados.
	ICSP pin Principalmente, ICSP (12) é um AVR, um pequeno cabeçalho de programação para o Arduino que consiste em MOSI, MISO, SCK, RESET, VCC e GND. É frequentemente referido como SPI (Interface Periférica Serial), o que pode ser considerado uma "expansão" da saída. Na verdade, você está escravizando o dispositivo de saída ao mestre do barramento SPI.
	Power LED indicator Este LED deve acender quando você conecta seu Arduino a uma fonte de alimentação para indicar que sua placa está ligada corretamente. Se esta luz não acender, há algo errado com a conexão.
	TX and RX LEDs Em sua placa, você encontrará duas etiquetas: TX (transmitir) e RX (receber). Eles aparecem em dois lugares na placa do Arduino UNO. Primeiramente, nos pinos digitais 0 e 1, para indicar os pinos responsáveis ​​pela comunicação serial. Em segundo lugar, o led TX e RX (13). O led TX pisca com velocidade diferente durante o envio dos dados seriais. A velocidade de piscar depende da taxa de transmissão usada pela placa. RX pisca durante o processo de recebimento.
	Digital I/O A placa Arduino UNO tem 14 pinos de E / S digitais (15) (dos quais 6 fornecem saída PWM (Modulação por largura de pulso). Esses pinos podem ser configurados para funcionar como pinos digitais de entrada para ler valores lógicos (0 ou 1) ou como digitais pinos de saída para acionar módulos diferentes, como LEDs, relés, etc. Os pinos marcados com “~” podem ser usados ​​para gerar PWM.
	AREF AREF significa Referência Analógica. Às vezes, é usado para definir uma tensão de referência externa (entre 0 e 5 Volts) como o limite superior para os pinos de entrada analógica.

Depois de aprender sobre as principais partes da placa Arduino UNO, estamos prontos para aprender como configurar o IDE do Arduino. Assim que aprendermos isso, estaremos prontos para carregar nosso programa na placa Arduino.

Nesta seção, aprenderemos em etapas fáceis como configurar o IDE Arduino em nosso computador e preparar a placa para receber o programa via cabo USB.

Step 1- Primeiro você deve ter sua placa Arduino (você pode escolher sua placa favorita) e um cabo USB. Caso você use Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 ou Diecimila, você precisará de um cabo USB padrão (plugue A para plugue B), do tipo que você conectaria a uma impressora USB, conforme mostrado na imagem a seguir.

Caso você use o Arduino Nano, precisará de um cabo A para Mini-B, conforme mostrado na imagem a seguir.

Step 2 − Download Arduino IDE Software.

Você pode obter diferentes versões do Arduino IDE na página de download no site oficial do Arduino. Você deve selecionar seu software, que seja compatível com seu sistema operacional (Windows, IOS ou Linux). Após a conclusão do download do arquivo, descompacte o arquivo.

Step 3 − Power up your board.

O Arduino Uno, Mega, Duemilanove e Arduino Nano extraem energia automaticamente de qualquer uma das conexões USB para o computador ou de uma fonte de alimentação externa. Se você estiver usando um Arduino Diecimila, certifique-se de que a placa esteja configurada para extrair energia da conexão USB. A fonte de alimentação é selecionada com um jumper, um pequeno pedaço de plástico que se encaixa em dois dos três pinos entre o USB e os conectores de alimentação. Verifique se ele está nos dois pinos mais próximos da porta USB.

Conecte a placa Arduino ao seu computador usando o cabo USB. O LED verde de alimentação (identificado como PWR) deve acender.

Step 4 − Launch Arduino IDE.

Após o download do software Arduino IDE, você precisa descompactar a pasta. Dentro da pasta, você pode encontrar o ícone do aplicativo com um rótulo infinito (application.exe). Clique duas vezes no ícone para iniciar o IDE.

Step 5 − Open your first project.

Depois que o software é iniciado, você tem duas opções -

• Crie um novo projeto.
• Abra um exemplo de projeto existente.

Para criar um novo projeto, selecione Arquivo → New.

Para abrir um exemplo de projeto existente, selecione Arquivo → Exemplo → Básico → Piscar.

Aqui, estamos selecionando apenas um dos exemplos com o nome Blink. Ele liga e desliga o LED com algum atraso. Você pode selecionar qualquer outro exemplo da lista.

Step 6 − Select your Arduino board.

Para evitar qualquer erro ao carregar seu programa para a placa, você deve selecionar o nome correto da placa Arduino, que corresponde ao da placa conectada ao seu computador.

Vá para Ferramentas → Quadro e selecione seu quadro.

Aqui, selecionamos a placa Arduino Uno de acordo com nosso tutorial, mas você deve selecionar o nome correspondente à placa que está usando.

Step 7 − Select your serial port.

Selecione o dispositivo serial da placa Arduino. Vamos paraTools → Serial Portcardápio. É provável que seja COM3 ou superior (COM1 e COM2 são geralmente reservados para portas seriais de hardware). Para descobrir, você pode desconectar sua placa Arduino e reabrir o menu, a entrada que desaparece deve ser da placa Arduino. Reconecte a placa e selecione essa porta serial.

Step 8 − Upload the program to your board.

Antes de explicar como podemos enviar nosso programa para a placa, devemos demonstrar a função de cada símbolo que aparece na barra de ferramentas do IDE do Arduino.

A - Usado para verificar se há algum erro de compilação.

B - Usado para fazer upload de um programa para a placa Arduino.

C - Atalho usado para criar um novo esboço.

D - Usado para abrir diretamente um dos esboços de exemplo.

E - Usado para salvar seu esboço.

F - Monitor serial usado para receber dados seriais da placa e enviar os dados seriais para a placa.

Agora, basta clicar no botão “Upload” no ambiente. Aguarde alguns segundos; você verá os LEDs RX e TX na placa piscando. Se o upload for bem-sucedido, a mensagem "Upload concluído" aparecerá na barra de status.

Note - Se você tiver um Arduino Mini, NG ou outra placa, será necessário pressionar o botão reset fisicamente na placa, imediatamente antes de clicar no botão de upload no software Arduino.

Neste capítulo, estudaremos em profundidade a estrutura do programa Arduino e aprenderemos mais novas terminologias usadas no mundo Arduino. O software Arduino é de código aberto. O código-fonte para o ambiente Java é lançado sob a GPL e as bibliotecas de microcontroladores C / C ++ estão sob a LGPL.

Sketch - A primeira nova terminologia é o programa Arduino chamado “sketch”.

Estrutura

Os programas Arduino podem ser divididos em três partes principais: Structure, Values (variáveis ​​e constantes), e Functions. Neste tutorial, aprenderemos sobre o programa de software Arduino, passo a passo, e como podemos escrever o programa sem qualquer sintaxe ou erro de compilação.

Vamos começar com o Structure. A estrutura do software consiste em duas funções principais -

• Função de configuração ()
• Função Loop ()

Void setup ( ) {

}

• PURPOSE - o setup()função é chamada quando um esboço começa. Use-o para inicializar as variáveis, modos de pin, começar a usar bibliotecas, etc. A função de configuração será executada apenas uma vez, após cada inicialização ou reinicialização da placa Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Void Loop ( ) {

}

• PURPOSE - Depois de criar um setup() função, que inicializa e define os valores iniciais, o loop()A função faz exatamente o que seu nome sugere e faz loops consecutivamente, permitindo que seu programa mude e responda. Use-o para controlar ativamente a placa Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Os tipos de dados em C referem-se a um sistema extenso usado para declarar variáveis ​​ou funções de diferentes tipos. O tipo de uma variável determina quanto espaço ela ocupa no armazenamento e como o padrão de bits armazenado é interpretado.

A tabela a seguir fornece todos os tipos de dados que você usará durante a programação do Arduino.

vazio	boleano	Caracteres	Caracter não identifcado	byte	int	Int sem sinal	palavra
grandes	Longo sem sinal	baixo	flutuador	em dobro	matriz	Matriz String-char	String-object

vazio

A palavra-chave void é usada apenas em declarações de função. Indica que se espera que a função não retorne nenhuma informação para a função da qual foi chamada.

Exemplo

Void Loop ( ) {
   // rest of the code
}

boleano

Um booleano contém um de dois valores, verdadeiro ou falso. Cada variável booleana ocupa um byte de memória.

Exemplo

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

Caracteres

Um tipo de dados que ocupa um byte de memória que armazena um valor de caractere. Literais de caracteres são escritos entre aspas simples como: 'A' e para vários caracteres, as strings usam aspas duplas: "ABC".

No entanto, os caracteres são armazenados como números. Você pode ver a codificação específica no gráfico ASCII . Isso significa que é possível fazer operações aritméticas em caracteres, nas quais o valor ASCII do caractere é usado. Por exemplo, 'A' + 1 tem o valor 66, já que o valor ASCII da letra maiúscula A é 65.

Exemplo

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

caracter não identifcado

Unsigned charé um tipo de dados sem sinal que ocupa um byte de memória. O tipo de dados unsigned char codifica números de 0 a 255.

Exemplo

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

byte

Um byte armazena um número sem sinal de 8 bits, de 0 a 255.

Exemplo

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Inteiros são o tipo de dados primário para armazenamento de números. int armazena um valor de 16 bits (2 bytes). Isso resulta em um intervalo de -32.768 a 32.767 (valor mínimo de -2 ^ 15 e um valor máximo de (2 ^ 15) -1).

o into tamanho varia de placa para placa. No Arduino Due, por exemplo, umintarmazena um valor de 32 bits (4 bytes). Isso resulta em um intervalo de -2.147.483.648 a 2.147.483.647 (valor mínimo de -2 ^ 31 e um valor máximo de (2 ^ 31) - 1).

Exemplo

int counter = 32 ;// declaration of variable with type int and initialize it with 32

Int sem sinal

Ints sem sinal (inteiros sem sinal) são iguais a int no sentido de que armazenam um valor de 2 bytes. Em vez de armazenar números negativos, no entanto, eles armazenam apenas valores positivos, produzindo um intervalo útil de 0 a 65.535 (2 ^ 16) - 1). O Devido armazena um valor de 4 bytes (32 bits), variando de 0 a 4.294.967.295 (2 ^ 32 - 1).

Exemplo

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

Palavra

No Uno e em outras placas baseadas em ATMEGA, uma palavra armazena um número sem sinal de 16 bits. No vencimento e no zero, ele armazena um número sem sinal de 32 bits.

Exemplo

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Grandes

Variáveis ​​longas são variáveis ​​de tamanho estendido para armazenamento de números e armazenam 32 bits (4 bytes), de -2.147.483.648 a 2.147.483.647.

Exemplo

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

longo sem sinal

Variáveis ​​longas sem sinal são variáveis ​​de tamanho estendido para armazenamento de números e armazenamento de 32 bits (4 bytes). Ao contrário dos comprados padrão, os comprados sem sinal não armazenarão números negativos, fazendo seu intervalo de 0 a 4.294.967.295 (2 ^ 32 - 1).

Exemplo

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

baixo

Um curto é um tipo de dados de 16 bits. Em todos os Arduinos (baseados em ATMega e ARM), um short armazena um valor de 16 bits (2 bytes). Isso resulta em um intervalo de -32.768 a 32.767 (valor mínimo de -2 ^ 15 e um valor máximo de (2 ^ 15) -1).

Exemplo

short val = 13 ;//declaration of variable with type short and initialize it with 13

flutuador

O tipo de dados para número de ponto flutuante é um número que possui um ponto decimal. Os números de ponto flutuante são freqüentemente usados ​​para aproximar os valores analógicos e contínuos porque eles têm uma resolução maior que os inteiros.

Os números de ponto flutuante podem ser tão grandes quanto 3,4028235E + 38 e tão baixos quanto -3,4028235E + 38. Eles são armazenados como 32 bits (4 bytes) de informação.

Exemplo

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

em dobro

No Uno e em outras placas baseadas em ATMEGA, o número de ponto flutuante de precisão dupla ocupa quatro bytes. Ou seja, a implementação dupla é exatamente igual ao float, sem ganho de precisão. No Arduino Due, os duplos têm precisão de 8 bytes (64 bits).

Exemplo

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

Antes de começarmos a explicar os tipos de variáveis, um assunto muito importante que precisamos ter certeza de que você entende perfeitamente é chamado de variable scope.

O que é escopo variável?

As variáveis ​​na linguagem de programação C, que o Arduino usa, têm uma propriedade chamada escopo. Um escopo é uma região do programa e há três lugares onde as variáveis ​​podem ser declaradas. Eles são -

• Dentro de uma função ou bloco, que é chamado local variables.
• Na definição dos parâmetros da função, que é chamada formal parameters.
• Fora de todas as funções, o que é chamado global variables.

Variáveis ​​Locais

Variáveis ​​declaradas dentro de uma função ou bloco são variáveis ​​locais. Eles podem ser usados ​​apenas pelas instruções que estão dentro dessa função ou bloco de código. As variáveis ​​locais não funcionam fora das suas próprias. A seguir está o exemplo usando variáveis ​​locais -

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Variáveis ​​globais

Variáveis ​​globais são definidas fora de todas as funções, geralmente no topo do programa. As variáveis ​​globais manterão seu valor ao longo da vida útil de seu programa.

Uma variável global pode ser acessada por qualquer função. Ou seja, uma variável global está disponível para uso em todo o programa após sua declaração.

O exemplo a seguir usa variáveis ​​globais e locais -

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Um operador é um símbolo que informa ao compilador para executar funções matemáticas ou lógicas específicas. A linguagem C é rica em operadores integrados e fornece os seguintes tipos de operadores -

• Operadores aritméticos
• Operadores de comparação
• Operadores booleanos
• Operadores bit a bit
• Operadores compostos

Operadores aritméticos

Suponha que a variável A tenha 10 e a variável B tenha 20, então -

Mostrar exemplo

Nome do operador	Operador simples	Descrição	Exemplo
operador de atribuição	=	Armazena o valor à direita do sinal de igual na variável à esquerda do sinal de igual.	A = B
Adição	+	Adiciona dois operandos	A + B dará 30
subtração	-	Subtrai o segundo operando do primeiro	A - B dará -10
multiplicação	*	Multiplique os dois operandos	A * B dará 200
divisão	/	Divida o numerador pelo denominador	B / A dará 2
modulo	%	Operador de Módulo e o restante após uma divisão inteira	B% A dará 0

Operadores de comparação

Suponha que a variável A tenha 10 e a variável B tenha 20, então -

Mostrar exemplo

Nome do operador	Operador simples	Descrição	Exemplo
igual a	==	Verifica se o valor de dois operandos é igual ou não, se sim a condição torna-se verdadeira.	(A == B) não é verdade
não é igual a	! =	Verifica se o valor de dois operandos é igual ou não, se os valores não são iguais a condição torna-se verdadeira.	(A! = B) é verdade
Menor que	<	Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(A <B) é verdade
Maior que	>	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim então a condição torna-se verdadeira.	(A> B) não é verdade
menos que ou igual a	<=	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito; em caso afirmativo, a condição torna-se verdadeira.	(A <= B) é verdadeiro
Melhor que ou igual a	> =	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(A> = B) não é verdade

Operadores booleanos

Suponha que a variável A tenha 10 e a variável B tenha 20, então -

Mostrar exemplo

Nome do operador	Operador simples	Descrição	Exemplo
e	&&	Operador lógico chamado AND. Se ambos os operandos forem diferentes de zero, a condição se torna verdadeira.	(A && B) é verdade
ou	||	Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(A || B) é verdade
não	!	Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador NOT lógico tornará falso.	! (A && B) é falso

Operadores bit a bit

Suponha que a variável A tenha 60 e a variável B tenha 13, então -

Mostrar exemplo

Nome do operador	Operador simples	Descrição	Exemplo
e	E	O operador Binário AND copia um bit para o resultado se ele existir em ambos os operandos.	(A e B) dará 12, que é 0000 1100
ou	|	O operador binário OR copia um bit se existir em qualquer operando	(A | B) dará 61, que é 0011 1101
xor	^	O operador binário XOR copia o bit se estiver definido em um operando, mas não em ambos.	(A ^ B) dará 49, que é 0011 0001
não	~	O operador de complemento binários é unário e tem o efeito de 'inverter' bits.	(~ A) dará -60 que é 1100 0011
deslocar para a esquerda	<<	Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita.	Um << 2 dará 240, que é 1111 0000
mudar para a direita	>>	Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita.	Um >> 2 dará 15, que é 0000 1111

Operadores compostos

Suponha que a variável A tenha 10 e a variável B tenha 20, então -

Mostrar exemplo

Nome do operador	Operador simples	Descrição	Exemplo
incremento	++	Operador de incremento, aumenta o valor inteiro em um	A ++ dará 11
decremento	-	Operador de decremento, diminui o valor inteiro em um	A-- dará 9
adição de composto	+ =	Adicionar operador de atribuição AND. Ele adiciona o operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo	B + = A é equivalente a B = B + A
subtração composta	- =	Subtraia o operador de atribuição. Ele subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo	B - = A é equivalente a B = B - A
multiplicação composta	* =	Operador de atribuição Multiply AND. Ele multiplica o operando direito com o operando esquerdo e atribui o resultado ao operando esquerdo	B * = A é equivalente a B = B * A
divisão composta	/ =	Operador de divisão AND atribuição. Ele divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo	B / = A é equivalente a B = B / A
módulo composto	% =	Módulo E operador de atribuição. Leva o módulo usando dois operandos e atribui o resultado ao operando esquerdo	B% = A é equivalente a B = B% A
composto bit a bit ou	| =	OR inclusivo bit a bit e operador de atribuição	A | = 2 é igual a A = A | 2
composto bit a bit e	& =	Operador de atribuição AND bit a bit	A & = 2 é igual a A = A & 2

As estruturas de tomada de decisão requerem que o programador especifique uma ou mais condições a serem avaliadas ou testadas pelo programa. Deve estar junto com uma declaração ou declarações a serem executadas se a condição for determinada como verdadeira e, opcionalmente, outras declarações a serem executadas se a condição for considerada falsa.

A seguir está a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

As declarações de controle são elementos no código-fonte que controlam o fluxo de execução do programa. Eles são -

S.NO.	Declaração de controle e descrição
1	Declaração If Leva uma expressão entre parênteses e uma declaração ou bloco de declarações. Se a expressão for verdadeira, a instrução ou bloco de instruções será executado, caso contrário, essas instruções serão ignoradas.
2	Declaração If ... else A if instrução pode ser seguida por uma instrução else opcional, que é executada quando a expressão é falsa.
3	Instrução If ... else if ... else o if declaração pode ser seguida por um opcional else if...else , que é muito útil para testar várias condições usando uma única instrução if ... else if.
4	switch case Semelhante às declarações if, switch...case controla o fluxo de programas permitindo que os programadores especifiquem diferentes códigos que devem ser executados em várias condições.
5	Operador condicional? : O operador condicional? : é o único operador ternário em C.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes e a seguir está a forma geral de uma instrução de loop na maioria das linguagens de programação -

A linguagem de programação C fornece os seguintes tipos de loops para lidar com os requisitos de loop.

S.NO.	Loop e descrição
1	loop while os loops while farão um loop contínuo e infinito, até que a expressão entre parênteses, () se torne falsa. Algo deve mudar a variável testada, ou o loop while nunca sairá.
2	fazer ... loop while o do…whileloop é semelhante ao loop while. No loop while, a condição de continuação do loop é testada no início do loop antes de executar o corpo do loop.
3	para loop UMA for loopexecuta instruções um número predeterminado de vezes. A expressão de controle para o loop é inicializada, testada e manipulada inteiramente dentro dos parênteses do loop for.
4	Loop aninhado A linguagem C permite que você use um loop dentro de outro loop. O exemplo a seguir ilustra o conceito.
5	Loop infinito É o loop sem condição de término, então o loop se torna infinito.

As funções permitem estruturar os programas em segmentos de código para realizar tarefas individuais. O caso típico de criação de uma função é quando é necessário realizar a mesma ação várias vezes em um programa.

Padronizar fragmentos de código em funções tem várias vantagens -

• As funções ajudam o programador a se manter organizado. Freqüentemente, isso ajuda a conceituar o programa.

• As funções codificam uma ação em um lugar, de forma que a função só precise ser pensada e depurada uma vez.

• Isso também reduz as chances de erros na modificação, se o código precisar ser alterado.

• As funções tornam todo o esboço menor e mais compacto porque as seções do código são reutilizadas muitas vezes.

• Eles tornam mais fácil reutilizar o código em outros programas, tornando-o modular, e o uso de funções geralmente torna o código mais legível.

Existem duas funções necessárias em um esboço do Arduino ou um programa, ou seja, setup () e loop (). Outras funções devem ser criadas fora dos colchetes dessas duas funções.

A sintaxe mais comum para definir uma função é -

Declaração de Função

Uma função é declarada fora de qualquer outra função, acima ou abaixo da função de loop.

Podemos declarar a função de duas maneiras diferentes -

A primeira maneira é apenas escrever a parte da função chamada a function prototype acima da função de loop, que consiste em -

• Tipo de retorno de função
• Nome da função
• Tipo de argumento da função, sem necessidade de escrever o nome do argumento

O protótipo da função deve ser seguido por um ponto e vírgula (;).

O exemplo a seguir mostra a demonstração da declaração da função usando o primeiro método.

Exemplo

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

A segunda parte, que é chamada de definição ou declaração de função, deve ser declarada abaixo da função de loop, que consiste em -

• Tipo de retorno de função
• Nome da função
• Tipo de argumento da função, aqui você deve adicionar o nome do argumento
• O corpo da função (instruções dentro da função em execução quando a função é chamada)

O exemplo a seguir demonstra a declaração de função usando o segundo método.

Exemplo

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

O segundo método apenas declara a função acima da função de loop.

Strings são usados ​​para armazenar texto. Eles podem ser usados ​​para exibir texto em um LCD ou na janela do Arduino IDE Serial Monitor. Strings também são úteis para armazenar a entrada do usuário. Por exemplo, os caracteres que um usuário digita em um teclado conectado ao Arduino.

Existem dois tipos de strings na programação do Arduino -

• Matrizes de caracteres, que são iguais às strings usadas na programação C.
• O Arduino String, que nos permite usar um objeto string em um esboço.

Neste capítulo, aprenderemos Strings, objetos e o uso de strings nos esboços do Arduino. No final do capítulo, você aprenderá que tipo de corda usar em um esboço.

Matrizes de caracteres de string

O primeiro tipo de string que vamos aprender é a string que é uma série de caracteres do tipo char. No capítulo anterior, aprendemos o que é um array; uma série consecutiva do mesmo tipo de variável armazenada na memória. Uma string é uma matriz de variáveis ​​char.

Uma string é uma matriz especial que possui um elemento extra no final da string, que sempre tem o valor 0 (zero). Isso é conhecido como "string terminada em nulo".

Exemplo de matriz de caracteres de string

Este exemplo mostrará como fazer uma string e imprimi-la na janela do monitor serial.

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

O exemplo a seguir mostra do que uma string é composta; uma matriz de caracteres com caracteres imprimíveis e 0 como o último elemento da matriz para mostrar que é aqui que a string termina. A string pode ser impressa na janela Arduino IDE Serial Monitor usandoSerial.println() e passando o nome da string.

Este mesmo exemplo pode ser escrito de uma forma mais conveniente, conforme mostrado abaixo -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

Neste esboço, o compilador calcula o tamanho da matriz da string e também automaticamente termina a string com zero. Uma matriz com seis elementos de comprimento e cinco caracteres seguidos por um zero é criada exatamente da mesma maneira que no esboço anterior.

Manipulando matrizes de cordas

Podemos alterar uma matriz de string dentro de um esboço, conforme mostrado no esboço a seguir.

Exemplo

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

Resultado

I like coffee and cake
I like coffee
I like coffee and tea

O esboço funciona da seguinte maneira.

Criação e impressão da string

No esboço fornecido acima, uma nova string é criada e impressa para exibição na janela Serial Monitor.

Encurtando a corda

A string é encurtada pela substituição do 14º caractere por um zero (2) de terminação nulo. Este é o elemento número 13 na matriz de string, contando a partir de 0.

Quando a string é impressa, todos os caracteres são impressos até o novo zero de terminação nulo. Os outros personagens não desaparecem; eles ainda existem na memória e a matriz de string ainda é do mesmo tamanho. A única diferença é que qualquer função que funcione com strings verá apenas a string até o primeiro terminador nulo.

Mudando uma palavra na string

Por fim, o esboço substitui a palavra "bolo" por "chá" (3). Primeiro, ele precisa substituir o terminador nulo em como [13] por um espaço para que a string seja restaurada ao formato originalmente criado.

Novos caracteres substituem "bolo" da palavra "bolo" pela palavra "chá". Isso é feito sobrescrevendo caracteres individuais. O 'e' de "bolo" é substituído por um novo caractere de terminação nulo. O resultado é que a string termina com dois caracteres nulos, o original no final da string e o novo que substitui o 'e' em "bolo". Isso não faz diferença quando a nova string é impressa, porque a função que imprime a string para de imprimir os caracteres da string quando encontra o primeiro terminador nulo.

Funções para manipular matrizes de string

O esboço anterior manipulou a sequência de forma manual, acessando caracteres individuais na sequência. Para facilitar a manipulação de matrizes de string, você pode escrever suas próprias funções para fazer isso ou usar algumas das funções de string doC biblioteca de linguagem.

Dada a seguir está a lista de funções para manipular matrizes de strings

S.No.	Funções e descrição
1	String() A classe String, parte do núcleo a partir da versão 0019, permite que você use e manipule strings de texto de maneiras mais complexas do que as matrizes de caracteres. Você pode concatenar Strings, anexá-las, pesquisar e substituir substrings e muito mais. Requer mais memória do que uma simples matriz de caracteres, mas também é mais útil. Para referência, as matrizes de caracteres são referidas como strings com um 's' minúsculo, e as instâncias da classe String são chamadas de Strings com S maiúsculo. Observe que as strings constantes, especificadas em "aspas duplas" são tratadas como matrizes de caracteres, não instâncias da classe String
2	charAt() Acesse um caractere específico da String.
3	compareTo() Compara duas Strings, testando se uma vem antes ou depois da outra, ou se são iguais. As strings são comparadas caractere por caractere, usando os valores ASCII dos caracteres. Isso significa, por exemplo, 'a' vem antes de 'b', mas depois de 'A'. Os números vêm antes das letras.
4	concat() Anexa o parâmetro a uma String.
5	c_str() Converte o conteúdo de uma string como uma string terminada em nulo no estilo C. Observe que isso fornece acesso direto ao buffer interno do String e deve ser usado com cuidado. Em particular, você nunca deve modificar a string por meio do ponteiro retornado. Quando você modifica o objeto String, ou quando ele é destruído, qualquer ponteiro retornado anteriormente por c_str () se torna inválido e não deve ser mais usado.
6	endsWith() Testa se uma String termina ou não com os caracteres de outra String.
7	equals() Compara duas strings para igualdade. A comparação diferencia maiúsculas de minúsculas, o que significa que a String "hello" não é igual à String "HELLO".
8	equalsIgnoreCase() Compara duas strings para igualdade. A comparação não diferencia maiúsculas de minúsculas, o que significa que a String ("hello") é igual à String ("HELLO").
9	getBytes() Copia os caracteres da string para o buffer fornecido.
10	indexOf() Localiza um caractere ou String dentro de outra String. Por padrão, ele pesquisa desde o início da String, mas também pode iniciar a partir de um determinado índice, permitindo localizar todas as instâncias do caractere ou String.
11	lastIndexOf() Localiza um caractere ou String dentro de outra String. Por padrão, ele pesquisa a partir do final da String, mas também pode trabalhar para trás a partir de um determinado índice, permitindo localizar todas as instâncias do caractere ou String.
12	length() Retorna o comprimento da String, em caracteres. (Observe que isso não inclui um caractere nulo final.)
13	remove() Modifique no local, uma string removendo caracteres do índice fornecido para o final da string ou do índice fornecido para o índice mais contagem.
14	replace() A função String replace () permite que você substitua todas as instâncias de um determinado caractere por outro caractere. Você também pode usar substituir para substituir substrings de uma string por uma substring diferente.
15	reserve() A função String reserve () permite que você aloque um buffer na memória para manipular strings.
16	setCharAt() Define um caractere da String. Não tem efeito em índices fora do comprimento existente da String.
17	startsWith() Testa se uma String começa ou não com os caracteres de outra String.
18	toCharArray() Copia os caracteres da string para o buffer fornecido.
19	substring() Obtenha uma substring de uma String. O índice inicial é inclusivo (o caractere correspondente é incluído na substring), mas o índice final opcional é exclusivo (o caractere correspondente não está incluído na substring). Se o índice final for omitido, a substring continua até o final da String.
20	toInt() Converte uma String válida em um inteiro. A string de entrada deve começar com um número inteiro. Se a string contiver números não inteiros, a função interromperá a conversão.
21	toFloat() Converte uma String válida em um float. A string de entrada deve começar com um dígito. Se a string contiver caracteres não-dígitos, a função irá parar de realizar a conversão. Por exemplo, as strings "123,45", "123" e "123fish" são convertidas em 123,45, 123,00 e 123,00 respectivamente. Observe que "123,456" é aproximado de 123,46. Observe também que os flutuadores têm apenas 6 a 7 dígitos decimais de precisão e que strings mais longas podem ser truncadas.
22	toLowerCase() Obtenha uma versão em minúsculas de uma String. A partir de 1.0, toLowerCase () modifica a string no lugar em vez de retornar uma nova.
23	toUpperCase() Obtenha uma versão em maiúsculas de uma String. A partir de 1.0, toUpperCase () modifica a string no lugar em vez de retornar uma nova.
24	trim() Obtenha uma versão da String com todos os espaços em branco à esquerda e à direita removidos. A partir de 1.0, trim () modifica a string no lugar em vez de retornar uma nova.

O próximo esboço usa algumas funções de string C.

Exemplo

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

Resultado

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

O esboço funciona da seguinte maneira.

Imprima o String

A string recém-criada é impressa na janela Serial Monitor como feito nos esboços anteriores.

Obtenha o comprimento da corda

A função strlen () é usada para obter o comprimento da string. O comprimento da string é apenas para caracteres imprimíveis e não inclui o terminador nulo.

A string contém 17 caracteres, portanto vemos 17 impressos na janela Serial Monitor.

Obtenha o comprimento da matriz

O operador sizeof () é usado para obter o comprimento do array que contém a string. O comprimento inclui o terminador nulo, portanto, o comprimento é um a mais do que o comprimento da string.

sizeof () parece uma função, mas tecnicamente é um operador. Não faz parte da biblioteca de strings C, mas foi usado no esboço para mostrar a diferença entre o tamanho da matriz e o tamanho da string (ou comprimento da string).

Copie uma String

A função strcpy () é usada para copiar a string str [] para o array out_num []. A função strcpy () copia a segunda string passada para ela na primeira string. Uma cópia da string agora existe no array out_num [], mas ocupa apenas 18 elementos do array, então ainda temos 22 elementos char livres no array. Esses elementos livres são encontrados após a string na memória.

A string foi copiada para a matriz para que tivéssemos algum espaço extra na matriz para usar na próxima parte do esboço, que é adicionar uma string ao final de uma string.

Anexar uma string a uma string (concatenar)

O esboço une uma string a outra, o que é conhecido como concatenação. Isso é feito usando a função strcat (). A função strcat () coloca a segunda string passada a ela no final da primeira string passada a ela.

Após a concatenação, o comprimento da string é impresso para mostrar o novo comprimento da string. O comprimento do array é então impresso para mostrar que temos uma string de 25 caracteres em um array de 40 elementos.

Lembre-se de que a sequência de 25 caracteres, na verdade, ocupa 26 caracteres da matriz por causa do zero de terminação nulo.

Array Bounds

Ao trabalhar com strings e arrays, é muito importante trabalhar dentro dos limites de strings ou arrays. No esboço do exemplo, foi criada uma matriz, de 40 caracteres, para alocar a memória que poderia ser usada para manipular strings.

Se o array for muito pequeno e tentarmos copiar uma string maior do que o array para ele, o string será copiado no final do array. A memória além do final da matriz pode conter outros dados importantes usados ​​no esboço, que seriam substituídos por nossa string. Se a memória além do final da string estiver sobrecarregada, isso pode travar o esboço ou causar um comportamento inesperado.

O segundo tipo de string usado na programação do Arduino é o String Object.

O que é um objeto?

Um objeto é uma construção que contém dados e funções. Um objeto String pode ser criado como uma variável e receber um valor ou string. O objeto String contém funções (chamadas de "métodos" na programação orientada a objetos (OOP)) que operam nos dados de string contidos no objeto String.

O esboço e a explicação a seguir deixarão claro o que é um objeto e como o objeto String é usado.

Exemplo

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

Resultado

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

Um objeto string é criado e recebe um valor (ou string) na parte superior do esboço.

String my_str = "This is my string." ;

Isso cria um objeto String com o nome my_str e atribui a ele o valor "Esta é minha string.".

Isso pode ser comparado a criar uma variável e atribuir um valor a ela, como um inteiro -

int my_var = 102;

O esboço funciona da seguinte maneira.

Imprimindo a corda

A string pode ser impressa na janela Serial Monitor como uma string de array de caracteres.

Converta a string em maiúsculas

O objeto string my_str que foi criado possui várias funções ou métodos que podem ser operados nele. Esses métodos são chamados usando o nome do objeto seguido pelo operador ponto (.) E, a seguir, o nome da função a ser usada.

my_str.toUpperCase();

o toUpperCase() função opera na string contida no my_strobjeto que é do tipo String e converte os dados da string (ou texto) que o objeto contém em caracteres em maiúsculas. Uma lista das funções que a classe String contém pode ser encontrada na referência Arduino String. Tecnicamente, String é chamada de classe e é usada para criar objetos String.

Sobrescrever uma String

O operador de atribuição é usado para atribuir uma nova string ao my_str objeto que substitui a string antiga

my_str = "My new string." ;

O operador de atribuição não pode ser usado em strings de matriz de caracteres, mas funciona apenas em objetos String.

Substituindo uma palavra na string

A função replace () é usada para substituir a primeira string passada a ela pela segunda string passada a ela. replace () é outra função que é construída na classe String e, portanto, está disponível para uso no objeto String my_str.

Obtendo o comprimento da corda

Obter o comprimento da string é facilmente feito usando length (). No esboço de exemplo, o resultado retornado por length () é passado diretamente para Serial.println () sem usar uma variável intermediária.

Quando usar um objeto String

Um objeto String é muito mais fácil de usar do que uma matriz de caracteres de string. O objeto possui funções integradas que podem realizar várias operações em strings.

A principal desvantagem de usar o objeto String é que ele usa muita memória e pode rapidamente usar a memória RAM do Arduinos, o que pode fazer com que o Arduino trave, trave ou se comporte de maneira inesperada. Se um esboço em um Arduino for pequeno e limitar o uso de objetos, não deverá haver problemas.

As strings de array de caracteres são mais difíceis de usar e você pode precisar escrever suas próprias funções para operar nesses tipos de strings. A vantagem é que você tem controle sobre o tamanho das matrizes de string que cria, de modo que pode manter as matrizes pequenas para economizar memória.

Você precisa ter certeza de não escrever além do final dos limites do array com arrays de string. O objeto String não tem esse problema e cuidará dos limites da string para você, desde que haja memória suficiente para operar. O objeto String pode tentar gravar na memória que não existe quando ficar sem memória, mas nunca gravará no final da string em que está operando.

Onde Strings são usados

Neste capítulo, estudamos sobre as strings, como elas se comportam na memória e suas operações.

Os usos práticos das strings serão cobertos na próxima parte deste curso, quando estudarmos como obter a entrada do usuário na janela Serial Monitor e salvar a entrada em uma string.

O Arduino oferece quatro funções diferentes de manipulação de tempo. Eles são -

S.No.	Descrição da função
1	função delay () A forma como delay()função funciona é muito simples. Ele aceita um único argumento inteiro (ou número). Este número representa o tempo (medido em milissegundos).
2	função delayMicroseconds () o delayMicroseconds()função aceita um único argumento inteiro (ou número). Existem mil microssegundos em um milissegundo e um milhão de microssegundos em um segundo.
3	função millis () Esta função é usada para retornar o número de milissegundos no momento em que a placa Arduino começa a executar o programa atual.
4	função micros () A função micros () retorna o número de microssegundos a partir do momento em que a placa Arduino começa a executar o programa atual. Este número transborda, ou seja, volta a zero após aproximadamente 70 minutos.

Uma matriz é um grupo consecutivo de locais de memória que são do mesmo tipo. Para fazer referência a um determinado local ou elemento na matriz, especificamos o nome da matriz e o número da posição do elemento específico na matriz.

A ilustração a seguir mostra uma matriz de inteiros chamada C que contém 11 elementos. Você se refere a qualquer um desses elementos fornecendo o nome da matriz seguido pelo número da posição do elemento específico entre colchetes ([]). O número da posição é mais formalmente chamado de subscrito ou índice (este número especifica o número de elementos desde o início da matriz). O primeiro elemento tem o subscrito 0 (zero) e às vezes é chamado de elemento zeros.

Assim, os elementos da matriz C são C [0] (pronuncia-se “C sub zero”), C [1], C [2] e assim por diante. O maior subscrito na matriz C é 10, que é 1 a menos que o número de elementos na matriz (11). Os nomes das matrizes seguem as mesmas convenções de outros nomes de variáveis.

Um subscrito deve ser uma expressão inteira ou inteira (usando qualquer tipo integral). Se um programa usa uma expressão como subscrito, o programa avalia a expressão para determinar o subscrito. Por exemplo, se assumirmos que a variável a é igual a 5 e que a variável b é igual a 6, então a instrução adiciona 2 ao elemento C do array [11].

Um nome de array subscrito é um lvalue, ele pode ser usado no lado esquerdo de uma atribuição, assim como os nomes de variáveis ​​que não são de array.

Vamos examinar a matriz C na figura fornecida, mais de perto. O nome de todo o array é C. Seus 11 elementos são referidos como C [0] a C [10]. O valor de C [0] é -45, o valor de C [1] é 6, o valor de C [2] é 0, o valor de C [7] é 62 e o valor de C [10] é 78

Para imprimir a soma dos valores contidos nos três primeiros elementos da matriz C, escreveríamos -

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

Para dividir o valor de C [6] por 2 e atribuir o resultado à variável x, escreveríamos -

x = C[ 6 ] / 2;

Declaração de matrizes

Os arrays ocupam espaço na memória. Para especificar o tipo dos elementos e o número de elementos exigidos por uma matriz, use uma declaração do formulário -

type arrayName [ arraySize ] ;

O compilador reserva a quantidade apropriada de memória. (Lembre-se de que uma declaração que reserva memória é mais apropriadamente conhecida como definição). O arraySize deve ser uma constante inteira maior que zero. Por exemplo, para dizer ao compilador para reservar 11 elementos para o array inteiro C, use a declaração -

int C[ 12 ]; // C is an array of 12 integers

Os arrays podem ser declarados como contendo valores de qualquer tipo de dados sem referência. Por exemplo, uma matriz de tipo string pode ser usada para armazenar strings de caracteres.

Exemplos de uso de matrizes

Esta seção fornece muitos exemplos que demonstram como declarar, inicializar e manipular matrizes.

Exemplo 1: Declarando um Array e usando um Loop para inicializar os elementos do Array

O programa declara uma matriz inteira de 10 elementos n. As linhas a – b usam aFordeclaração para inicializar os elementos da matriz para zeros. Como outras variáveis ​​automáticas, os arrays automáticos não são inicializados implicitamente com zero. A primeira instrução de saída (linha c) exibe os títulos das colunas impressas na instrução for subsequente (linhas d – e), que imprime a matriz em formato tabular.

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Isso produzirá o seguinte resultado -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
 
        
 
       
      

Exemplo 2: inicializando uma matriz em uma declaração com uma lista de inicializadores

Os elementos de uma matriz também podem ser inicializados na declaração da matriz, seguindo o nome da matriz com um sinal de igual e uma lista de inicializadores separados por vírgula delimitada por chaves. O programa usa uma lista de inicializadores para inicializar um array inteiro com 10 valores (linha a) e imprime o array em formato tabular (linhas b – c).

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Isso produzirá o seguinte resultado -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37
 
 
        
 
       
      

Exemplo 3: Somando os Elementos de um Array

Freqüentemente, os elementos de uma matriz representam uma série de valores a serem usados ​​em um cálculo. Por exemplo, se os elementos de uma matriz representam notas de exames, um professor pode desejar totalizar os elementos da matriz e usar essa soma para calcular a média da classe para o exame. O programa soma os valores contidos na matriz de inteiros de 10 elementosa.

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - Isso produzirá o seguinte resultado -

Total of array elements: 849

Os arrays são importantes para o Arduino e precisam de muito mais atenção. Os seguintes conceitos importantes relacionados ao array devem ser claros para um Arduino -

S.NO.	Conceito e descrição
1	Passando Arrays para Funções Para passar um argumento de matriz para uma função, especifique o nome da matriz sem colchetes.
2	Matrizes multidimensionais Matrizes com duas dimensões (ou seja, subscritos) geralmente representam tabelas de valores que consistem em informações organizadas em linhas e colunas.

Os pinos na placa Arduino podem ser configurados como entradas ou saídas. Explicaremos o funcionamento dos pinos nesses modos. É importante observar que a maioria dos pinos analógicos do Arduino pode ser configurada e usada exatamente da mesma maneira que os pinos digitais.

Pinos configurados como INPUT

Os pinos do Arduino são configurados por padrão como entradas, portanto, não precisam ser declarados explicitamente como entradas com pinMode()quando você os usa como entradas. Os pinos configurados dessa maneira estão em um estado de alta impedância. Pinos de entrada fazem demandas extremamente pequenas no circuito que eles estão testando, equivalente a um resistor em série de 100 megaohm na frente do pino.

Isso significa que é necessária muito pouca corrente para mudar o pino de entrada de um estado para outro. Isso torna os pinos úteis para tarefas como implementar um sensor de toque capacitivo ou ler um LED como fotodiodo.

Pinos configurados como pinMode (pin, INPUT) sem nada conectado a eles, ou com fios conectados a eles que não estão conectados a outros circuitos, relatam mudanças aparentemente aleatórias no estado do pino, captando ruído elétrico do ambiente ou acoplando capacitivamente o estado de um alfinete próximo.

Resistores pull-up

Os resistores pull-up são frequentemente úteis para direcionar um pino de entrada a um estado conhecido se nenhuma entrada estiver presente. Isso pode ser feito adicionando um resistor pull-up (para + 5V) ou um resistor pull-down (resistor para aterramento) na entrada. Um resistor de 10K é um bom valor para um resistor pull-up ou pull-down.

Usando resistor pull-up integrado com pinos configurados como entrada

Existem 20.000 resistores pull-up embutidos no chip Atmega que podem ser acessados ​​a partir do software. Esses resistores pull-up integrados são acessados ​​definindo opinMode()como INPUT_PULLUP. Isso efetivamente inverte o comportamento do modo INPUT, onde HIGH significa que o sensor está DESLIGADO e LOW significa que o sensor está LIGADO. O valor deste pull-up depende do microcontrolador usado. Na maioria das placas baseadas em AVR, o valor é garantido entre 20kΩ e 50kΩ. No Arduino Due, está entre 50kΩ e 150kΩ. Para o valor exato, consulte a ficha técnica do microcontrolador da sua placa.

Ao conectar um sensor a um pino configurado com INPUT_PULLUP, a outra extremidade deve ser conectada ao terra. No caso de uma chave simples, isso faz com que a leitura do pino seja HIGH quando a chave estiver aberta e LOW quando a chave for pressionada. Os resistores pull-up fornecem corrente suficiente para acender um LED fracamente conectado a um pino configurado como uma entrada. Se os LEDs em um projeto parecem estar funcionando, mas muito fracamente, é provavelmente o que está acontecendo.

Os mesmos registros (localizações de memória do chip interno) que controlam se um pino é HIGH ou LOW controlam os resistores pull-up. Consequentemente, um pino que é configurado para ter resistores pull-up ligados quando o pino está no modo INPUT, terá o pino configurado como HIGH se o pino for então comutado para um modo OUTPUT com pinMode (). Isso funciona na outra direção também, e um pino de saída que é deixado em um estado HIGH terá o resistor pull-up definido se for comutado para uma entrada com pinMode ().

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

Pinos configurados como OUTPUT

Pinos configurados como OUTPUT com pinMode () são considerados em um estado de baixa impedância. Isso significa que eles podem fornecer uma quantidade substancial de corrente para outros circuitos. Pinos Atmega podem fornecer (fornecer corrente positiva) ou drenar (fornecer corrente negativa) até 40 mA (miliamperes) de corrente para outros dispositivos / circuitos. Esta é a corrente suficiente para acender intensamente um LED (não se esqueça do resistor em série) ou executar muitos sensores, mas não corrente suficiente para operar relés, solenóides ou motores.

A tentativa de executar dispositivos de alta corrente nos pinos de saída pode danificar ou destruir os transistores de saída no pino ou danificar todo o chip Atmega. Freqüentemente, isso resulta em um pino "morto" no microcontrolador, mas os chips restantes ainda funcionam adequadamente. Por esse motivo, é uma boa ideia conectar os pinos de SAÍDA a outros dispositivos por meio de resistores de 470Ω ou 1k, a menos que a corrente máxima retirada dos pinos seja necessária para uma aplicação específica.

Função pinMode ()

A função pinMode () é usada para configurar um pino específico para se comportar como uma entrada ou uma saída. É possível habilitar os resistores pull-up internos com o modo INPUT_PULLUP. Além disso, o modo INPUT desabilita explicitamente os pull-ups internos.

Sintaxe da função pinMode ()

Void setup () {
   pinMode (pin , mode);
}

• pin - o número do pino cujo modo você deseja definir

• mode - INPUT, OUTPUT ou INPUT_PULLUP.

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

Função digitalWrite ()

o digitalWrite()A função é usada para escrever um valor ALTO ou BAIXO em um pino digital. Se o pino foi configurado como uma SAÍDA com pinMode () , sua tensão será configurada para o valor correspondente: 5 V (ou 3,3 V em placas de 3,3 V) para ALTO, 0 V (terra) para BAIXO. Se o pino estiver configurado como INPUT, digitalWrite () habilitará (HIGH) ou desabilitará (LOW) o pullup interno no pino de entrada. Recomenda-se definir pinMode () para INPUT_PULLUP para habilitar o resistor pull-up interno.

Se você não definir o pinMode () para OUTPUT e conectar um LED a um pino, ao chamar digitalWrite (HIGH), o LED pode parecer fraco. Sem definir explicitamente pinMode (), digitalWrite () terá habilitado o resistor pull-up interno, que atua como um grande resistor limitador de corrente.

Sintaxe da função digitalWrite ()

Void loop() {
   digitalWrite (pin ,value);
}

• pin - o número do pino cujo modo você deseja definir

• value - ALTO ou BAIXO.

Example

int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

função analogRead ()

O Arduino é capaz de detectar se há uma tensão aplicada a um de seus pinos e relatá-la por meio da função digitalRead (). Existe uma diferença entre um sensor liga / desliga (que detecta a presença de um objeto) e um sensor analógico, cujo valor muda continuamente. Para ler este tipo de sensor, precisamos de um tipo diferente de pino.

Na parte inferior direita da placa Arduino, você verá seis pinos marcados como “Analog In”. Esses pinos especiais não apenas informam se há uma tensão aplicada a eles, mas também seu valor. Usando oanalogRead() função, podemos ler a tensão aplicada a um dos pinos.

Esta função retorna um número entre 0 e 1023, que representa tensões entre 0 e 5 volts. Por exemplo, se houver uma tensão de 2,5 V aplicada ao pino número 0, analogRead (0) retorna 512.

Sintaxe da função analogRead ()

analogRead(pin);

• pin - o número do pino de entrada analógica para leitura (0 a 5 na maioria das placas, 0 a 7 no Mini e Nano, 0 a 15 no Mega)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

void setup() {
   Serial.begin(9600); // setup serial
} 

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

Neste capítulo, aprenderemos algumas funções avançadas de entrada e saída.

Função analogReference ()

Configura a tensão de referência usada para entrada analógica (ou seja, o valor usado como o topo da faixa de entrada). As opções são -

• DEFAULT - A referência analógica padrão de 5 volts (em placas Arduino de 5 V) ou 3,3 volts (em placas Arduino de 3,3 V)

• INTERNAL - Uma referência integrada, igual a 1,1 volts no ATmega168 ou ATmega328 e 2,56 volts no ATmega8 (não disponível no Arduino Mega)

• INTERNAL1V1 - Uma referência de 1.1 V integrada (apenas Arduino Mega)

• INTERNAL2V56 - Uma referência embutida de 2,56 V (apenas Arduino Mega)

• EXTERNAL - A tensão aplicada ao pino AREF (0 a 5V apenas) é usada como referência

Sintaxe da função analogReference ()

analogReference (type);

type - pode usar qualquer tipo dos seguintes (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXTERNAL)

Não use nada menos que 0 V ou mais que 5 V para tensão de referência externa no pino AREF. Se você estiver usando uma referência externa no pino AREF, você deve definir a referência analógica para EXTERNA antes de chamar oanalogRead()função. Caso contrário, você causará um curto na tensão de referência ativa (gerada internamente) e no pino AREF, possivelmente danificando o microcontrolador em sua placa Arduino.

Como alternativa, você pode conectar a tensão de referência externa ao pino AREF por meio de um resistor de 5K, permitindo alternar entre as tensões de referência externa e interna.

Observe que o resistor irá alterar a tensão que é usada como referência porque há um resistor interno de 32K no pino AREF. Os dois atuam como um divisor de tensão. Por exemplo, 2,5 V aplicado através do resistor produzirá 2,5 * 32 / (32 + 5) = ~ 2,2 V no pino AREF.

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

Todos os dados são inseridos em computadores como caracteres, o que inclui letras, dígitos e vários símbolos especiais. Nesta seção, discutimos os recursos do C ++ para examinar e manipular caracteres individuais.

A biblioteca de manipulação de caracteres inclui várias funções que realizam testes úteis e manipulações de dados de caracteres. Cada função recebe um caractere, representado como um int, ou EOF como um argumento. Os caracteres são freqüentemente manipulados como inteiros.

Lembre-se de que EOF normalmente tem o valor –1 e que algumas arquiteturas de hardware não permitem que valores negativos sejam armazenados em variáveis ​​char. Portanto, as funções de tratamento de caracteres manipulam os caracteres como inteiros.

A tabela a seguir resume as funções da biblioteca de tratamento de caracteres. Ao usar funções da biblioteca de manipulação de caracteres, inclua o<cctype> cabeçalho.

S.No.	Protótipo e Descrição
1	int isdigit( int c ) Retorna 1 se c for um dígito e 0 caso contrário.
2	int isalpha( int c ) Retorna 1 se c for uma letra e 0 caso contrário.
3	int isalnum( int c ) Retorna 1 se c for um dígito ou letra e 0 caso contrário.
4	int isxdigit( int c ) Retorna 1 se c for um caractere de dígito hexadecimal e 0 caso contrário. (Consulte o Apêndice D, Sistemas Numéricos, para uma explicação detalhada dos números binários, octais, decimais e hexadecimais.)
5	int islower( int c ) Retorna 1 se c for uma letra minúscula e 0 caso contrário.
6	int isupper( int c ) Retorna 1 se c for uma letra maiúscula; 0 caso contrário.
7	int isspace( int c ) Retorna 1 se c for um caractere de espaço em branco - nova linha ('\ n'), espaço (''), avanço de formulário ('\ f'), retorno de carro ('\ r'), guia horizontal ('\ t') ou guia vertical ('\ v') - e 0 caso contrário.
8	int iscntrl( int c ) Retorna 1 se c for um caractere de controle, como nova linha ('\ n'), avanço de formulário ('\ f'), retorno de carro ('\ r'), guia horizontal ('\ t'), guia vertical (' \ v '), alert (' \ a ') ou backspace (' \ b ') - e 0 caso contrário.
9	int ispunct( int c ) Retorna 1 se c for um caractere de impressão diferente de um espaço, um dígito ou uma letra e 0 caso contrário.
10	int isprint( int c ) Retorna 1 se c for um caractere de impressão incluindo espaço ('') e 0 caso contrário.
11	int isgraph( int c ) Retorna 1 se c for um caractere de impressão diferente de espaço ('') e 0 caso contrário.

Exemplos

O exemplo a seguir demonstra o uso das funções isdigit, isalpha, isalnum e isxdigit. Funçãoisdigitdetermina se seu argumento é um dígito (0–9). A funçãoisalphadetermina se seu argumento é uma letra maiúscula (AZ) ou uma letra minúscula (a – z). A funçãoisalnumdetermina se seu argumento é uma letra maiúscula, uma letra minúscula ou um dígito. Funçãoisxdigit determina se seu argumento é um dígito hexadecimal (A – F, a – f, 0–9).

Exemplo 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

Resultado

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

Usamos o operador condicional (?:)com cada função para determinar se a string "é um" ou a string "não é um" deve ser impressa na saída para cada caractere testado. Por exemplo, linhaa indica que se '8' é um dígito - ou seja, se isdigitretorna um valor verdadeiro (diferente de zero) - a string "8 é um" é impressa. Se '8' não for um dígito (ou seja, seisdigit retorna 0), a string "8 não é um" é impressa.

Exemplo 2

O exemplo a seguir demonstra o uso das funções islower e isupper. A funçãoislowerdetermina se seu argumento é uma letra minúscula (a – z). Funçãoisupper determina se seu argumento é uma letra maiúscula (A – Z).

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

Resultado

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

Exemplo 3

O exemplo a seguir demonstra o uso de funções isspace, iscntrl, ispunct, isprint e isgraph.

• A função isspace determina se seu argumento é um caractere de espaço em branco, como espaço (''), alimentação de formulário ('\ f'), nova linha ('\ n'), retorno de carro ('\ r'), tabulação horizontal ('\ t ') ou guia vertical (' \ v ').

• A função iscntrl determina se seu argumento é um caractere de controle, como tabulação horizontal ('\ t'), tabulação vertical ('\ v'), alimentação de formulário ('\ f'), alerta ('\ a'), backspace ('\ b '), retorno de carro (' \ r ') ou nova linha (' \ n ').

• A função ispunct determina se seu argumento é um caractere de impressão diferente de um espaço, dígito ou letra, como $, #, (,), [,], {,},;,: ou%.

• A função isprint determina se seu argumento é um caractere que pode ser exibido na tela (incluindo o caractere de espaço).

• A função isgraph testa os mesmos caracteres que isprint, mas o caractere de espaço não é incluído.

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

Resultado

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

A biblioteca Arduino Math (math.h) inclui uma série de funções matemáticas úteis para manipular números de ponto flutuante.

Macros de biblioteca

A seguir estão as macros definidas no cabeçalho math.h -

A seguir está a lista de macros definidas no cabeçalho math.h

Macros	Valor	Descrição
MIM	2.7182818284590452354	A constante e.
M_LOG2E	1.4426950408889634074 / * log_2 e * /	O logaritmo do e para a base 2
M_1_PI	0,31830988618379067154 / * 1 / pi * /	A constante 1 / pi
M_2_PI	0,63661977236758134308 / * 2 / pi * /	A constante 2 / pi
M_2_SQRTPI	1.12837916709551257390 / * 2 / sqrt (pi) * /	A constante 2 / sqrt (pi)
M_LN10	2,30258509299404568402 / * log_e 10 * /	O logaritmo natural do 10
M_LN2	0,69314718055994530942 / * log_e 2 * /	O logaritmo natural do 2
M_LOG10E	0,43429448190325182765 / * log_10 e * /	O logaritmo do e para a base 10
M_PI	3,14159265358979323846 / * pi * /	O pi constante
M_PI_2	3.3V1.57079632679489661923 / * pi / 2 * /	A constante pi / 2
M_PI_4	0,78539816339744830962 / * pi / 4 * /	A constante pi / 4
M_SQRT1_2	0,70710678118654752440 / * 1 / sqrt (2) * /	A constante 1 / sqrt (2)
M_SQRT2	1.41421356237309504880 / * sqrt (2) * /	A raiz quadrada de 2
acosf	-	O alias da função acos ()
asinf	-	O alias da função asin ()
atan2f	-	O alias da função atan2 ()
cbrtf	-	O alias da função cbrt ()
Ceilf	-	O alias da função ceil ()
copysignf	-	O alias da função copysign ()
Coshf	-	O alias da função cosh ()
expf	-	O alias da função exp ()
fabsf	-	O alias da função fabs ()
fdimf	-	O alias da função fdim ()
chão	-	O alias da função floor ()
fmaxf	-	O alias da função fmax ()
fminf	-	O alias da função fmin ()
fmodf	-	O alias da função fmod ()
frexpf	-	O alias da função frexp ()
hipotf	-	O alias para a função hypot ()
INFINIDADE	-	INFINITY constante
isfinitef	-	O alias da função isfinite ()
isinff	-	O alias da função isinf ()
isnanf	-	O alias da função isnan ()
ldexpf	-	O alias da função ldexp ()
log10f	-	O alias da função log10 ()
logf	-	O alias da função log ()
lrintf	-	O alias da função lrint ()
lroundf	-	O alias da função lround ()

Funções de biblioteca

As seguintes funções são definidas no cabeçalho math.h -

A seguir está a lista de funções definidas no cabeçalho math.h

S.No.	Função e descrição da biblioteca
1	double acos (double __x) A função acos () calcula o valor principal do arco cosseno de __x. O valor retornado está no intervalo [0, pi] radianos. Um erro de domínio ocorre para argumentos fora do intervalo [-1, +1].
2	double asin (double __x) A função asin () calcula o valor principal do arco seno de __x. O valor retornado está no intervalo [-pi / 2, pi / 2] radianos. Um erro de domínio ocorre para argumentos fora do intervalo [-1, +1].
3	double atan (double __x) A função atan () calcula o valor principal do arco tangente de __x. O valor retornado está no intervalo [-pi / 2, pi / 2] radianos.
4	double atan2 (double __y, double __x) A função atan2 () calcula o valor principal do arco tangente de __y / __x, usando os sinais de ambos os argumentos para determinar o quadrante do valor de retorno. O valor retornado está no intervalo [-pi, + pi] radianos.
5	double cbrt (double __x) A função cbrt () retorna a raiz cúbica de __x.
6	double ceil (double __x) A função ceil () retorna o menor valor integral maior ou igual a __x, expresso como um número de ponto flutuante.
7	static double copysign (double __x, double __y) A função copysign () retorna __x mas com o sinal de __y. Eles funcionam mesmo se __x ou __y forem NaN ou zero.
8	double cos(double __x) A função cos () retorna o cosseno de __x, medido em radianos.
9	double cosh (double __x) A função cosh () retorna o cosseno hiperbólico de __x.
10	double exp (double __x) A função exp () retorna o valor exponencial de __x.
11	double fabs (double __x) A função fabs () calcula o valor absoluto de um número de ponto flutuante __x.
12	double fdim (double __x, double __y) A função fdim () retorna max (__ x - __y, 0). Se __x ou __y ou ambos forem NaN, NaN será retornado.
13	double floor (double __x) A função floor () retorna o maior valor integral menor ou igual a __x, expresso como um número de ponto flutuante.
14	double fma (double __x, double __y, double __z) A função fma () executa multiplicação-adição de ponto flutuante. Esta é a operação (__x * __y) + __z, mas o resultado intermediário não é arredondado para o tipo de destino. Às vezes, isso pode melhorar a precisão de um cálculo.
15	double fmax (double __x, double __y) A função fmax () retorna o maior dos dois valores __x e __y. Se um argumento for NaN, o outro argumento será retornado. Se ambos os argumentos forem NaN, NaN será retornado.
16	double fmin (double __x, double __y) A função fmin () retorna o menor dos dois valores __x e __y. Se um argumento for NaN, o outro argumento será retornado. Se ambos os argumentos forem NaN, NaN será retornado.
17	double fmod (double __x, double__y) A função fmod () retorna o resto de ponto flutuante de __x / __y.
18	double frexp (double __x, int * __pexp) A função frexp () divide um número de ponto flutuante em uma fração normalizada e uma potência integral de 2. Ela armazena o inteiro no objeto int apontado por __pexp. Se __x é um número de ponto flutuante normal, a função frexp () retorna o valor v, de forma que v tenha uma magnitude no intervalo [1/2, 1) ou zero, e __x é igual a v vezes 2 elevado à potência __pexp. Se __x for zero, ambas as partes do resultado serão zero. Se __x não for um número finito, o frexp () retorna __x como está e armazena 0 por __pexp. Note - Esta implementação permite um ponteiro zero como uma diretiva para pular o armazenamento do expoente.
19	double hypot (double __x, double__y) A função hypot () retorna sqrt (__ x * __ x + __y * __ y). Este é o comprimento da hipotenusa de um triângulo retângulo com lados de comprimento __x e __y, ou a distância do ponto (__x, __y) da origem. Usar esta função em vez da fórmula direta é sábio, pois o erro é muito menor. Sem underflow com pequenos __x e __y. Sem estouro se o resultado estiver dentro do intervalo.
20	static int isfinite (double __x) A função isfinite () retorna um valor diferente de zero se __x for finito: não mais ou menos infinito, e não NaN.
21	int isinf (double __x) A função isinf () retorna 1 se o argumento __x for infinito positivo, -1 se __x for infinito negativo e 0 caso contrário. Note - O GCC 4.3 pode substituir esta função pelo código embutido que retorna o valor 1 para ambos os infinitos (bug do gcc # 35509).
22	int isnan (double __x) A função isnan () retorna 1 se o argumento __x representa um "não-um-número" (NaN) objeto, caso contrário, 0.
23	double ldexp (double __x, int __exp ) A função ldexp () multiplica um número de ponto flutuante por uma potência integral de 2. Ela retorna o valor de __x vezes 2 elevado à potência __exp.
24	double log (double __x) A função log () retorna o logaritmo natural do argumento __x.
25	double log10(double __x) A função log10 () retorna o logaritmo do argumento __x para a base 10.
26	long lrint (double __x) A função lrint () arredonda __x para o inteiro mais próximo, arredondando os casos intermediários para a direção do inteiro par. (Isso é 1,5 e 2,5 valores são arredondados para 2). Esta função é semelhante à função rint (), mas difere no tipo de valor de retorno e em que um estouro é possível. Returns O valor inteiro longo arredondado. Se __x não for um número finito ou um estouro, essa realização retornará o valor LONG_MIN (0x80000000).
27	long lround (double __x) A função lround () arredonda __x para o inteiro mais próximo, mas arredonda os casos intermediários para longe de zero (em vez de para o inteiro par mais próximo). Esta função é semelhante à função round (), mas difere no tipo de valor de retorno e em que um estouro é possível. Returns O valor inteiro longo arredondado. Se __x não for um número finito ou se houver um estouro, essa realização retornará o valor LONG_MIN (0x80000000).
28	double modf (double __x, double * __iptr ) A função modf () divide o argumento __x em partes inteiras e fracionárias, cada uma com o mesmo sinal do argumento. Ele armazena a parte integral como um duplo no objeto apontado por __iptr. A função modf () retorna a parte fracionária com sinal de __x. Note- Esta implementação pula a escrita pelo ponteiro zero. No entanto, o GCC 4.3 pode substituir esta função por código embutido que não permite o uso de endereço NULL para evitar o armazenamento.
29	float modff (float __x, float * __iptr) O alias para modf ().
30	double pow (double __x, double __y) A função pow () retorna o valor de __x para o expoente __y.
31	double round (double __x) A função round () arredonda __x para o inteiro mais próximo, mas arredonda os casos intermediários para longe de zero (em vez de para o inteiro par mais próximo). O estouro é impossível. Returns O valor arredondado. Se __x for integral ou infinito, o próprio __x será retornado. Se __x forNaN, então NaN é devolvido.
32	int signbit (double __x) A função signbit () retorna um valor diferente de zero se o valor de __x tiver seu bit de sinal definido. Isso não é o mesmo que `__x <0,0 ', porque o ponto flutuante IEEE 754 permite que zero seja assinado. A comparação `-0,0 <0,0 'é falsa, mas` signbit (-0,0)' retornará um valor diferente de zero.
33	double sin (double __x) A função sin () retorna o seno de __x, medido em radianos.
34	double sinh (double __x) A função sinh () retorna o seno hiperbólico de __x.
35	double sqrt (double __x) A função sqrt () retorna a raiz quadrada não negativa de __x.
36	double square (double __x) A função square () retorna __x * __x. Note - Esta função não pertence à definição padrão C.
37	double tan (double __x) A função tan () retorna a tangente de __x, medida em radianos.
38	double tanh ( double __x) A função tanh () retorna a tangente hiperbólica de __x.
39	double trunc (double __x) A função trunc () arredonda __x para o inteiro mais próximo não maior em valor absoluto.

Exemplo

O exemplo a seguir mostra como usar as funções de biblioteca math.h mais comuns -

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

Resultado

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

Você precisa usar trigonometria praticamente como calcular a distância para o objeto em movimento ou velocidade angular. O Arduino fornece funções trigonométricas tradicionais (sin, cos, tan, asin, acos, atan) que podem ser resumidas escrevendo seus protótipos. Math.h contém o protótipo da função trigonometria.

Sintaxe exata trigonométrica

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

Exemplo

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

O Arduino Due é uma placa microcontrolada baseada na CPU Atmel SAM3X8E ARM Cortex-M3. É a primeira placa Arduino baseada em um microcontrolador de núcleo ARM de 32 bits.

Recursos importantes -

• Possui 54 pinos de entrada / saída digital (dos quais 12 podem ser usados ​​como saídas PWM)
• 12 entradas analógicas
• 4 UARTs (portas seriais de hardware)
• Relógio de 84 MHz, uma conexão USB com capacidade OTG
• 2 DAC (digital para analógico), 2 TWI, um conector de alimentação, um conector SPI, um conector JTAG
• Botão de reset e um botão de apagar

Características da placa devida do Arduino

Volt de operação	Velocidade da cpu	Entrada / saída analógica	Digital IO / PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 Volt	84 Mhz	12/2	54/12	-	96	512	2 micro	4

Comunicação

• 4 UARTs de hardware
• 2 I2C
• 1 Interface CAN (protocolo de comunicação automotivo)
• 1 SPI
• 1 Interface JTAG (10 pinos)
• 1 host USB (como Leonardo)
• 1 porta de programação

Ao contrário da maioria das placas Arduino, a placa Arduino Due funciona a 3,3V. A tensão máxima que os pinos de E / S podem tolerar é 3,3V. Aplicar tensões superiores a 3,3 V a qualquer pino de E / S pode danificar a placa.

A placa contém tudo o que é necessário para suportar o microcontrolador. Você pode simplesmente conectá-lo a um computador com um cabo micro-USB ou alimentá-lo com um adaptador CA para CC ou bateria para começar. O Due é compatível com todos os shields do Arduino que funcionam a 3,3V.

Arduino Zero

O Zero é uma extensão simples e poderosa de 32 bits da plataforma estabelecida pelo UNO. A placa Zero expande a família, proporcionando maior desempenho, permitindo uma variedade de oportunidades de projeto para dispositivos e atua como uma ótima ferramenta educacional para aprender sobre o desenvolvimento de aplicativos de 32 bits.

Recursos importantes são -

• As aplicações Zero abrangem desde dispositivos IoT inteligentes, tecnologia vestível, automação de alta tecnologia até robótica maluca.

• A placa é alimentada por SAMD21 MCU da Atmel, que possui um núcleo ARM Cortex® M0 + de 32 bits.

• Um de seus recursos mais importantes é o Embedded Debugger (EDBG) da Atmel, que fornece uma interface de depuração completa sem a necessidade de hardware adicional, aumentando significativamente a facilidade de uso para depuração de software.

• EDBG também oferece suporte a uma porta COM virtual que pode ser usada para a programação do dispositivo e do carregador de inicialização.

Características da placa Arduino Zero

Volt de operação	Velocidade da cpu	Entrada / saída analógica	Digital IO / PWM	EEPROM [KB]	SRAM [KB]	Flash [KB]	USB	UART
3,3 Volt	48 Mhz	6/1	14/10	-	32	256	2 micro	2

Ao contrário da maioria das placas Arduino e Genuino, o Zero funciona a 3,3V. A tensão máxima que os pinos de E / S podem tolerar é 3,3V. Aplicar tensões superiores a 3,3 V a qualquer pino de E / S pode danificar a placa.

A placa contém tudo o que é necessário para suportar o microcontrolador. Você pode simplesmente conectá-lo a um computador com um cabo micro-USB ou alimentá-lo com um adaptador CA para CC ou uma bateria para começar. O Zero é compatível com todas as blindagens que funcionam a 3,3V.

A modulação por largura de pulso ou PWM é uma técnica comum usada para variar a largura dos pulsos em uma seqüência de pulsos. O PWM tem muitas aplicações, como controle de servos e controladores de velocidade, limitando a potência efetiva de motores e LEDs.

Princípio básico de PWM

A modulação por largura de pulso é basicamente uma onda quadrada com tempos altos e baixos variando. Um sinal PWM básico é mostrado na figura a seguir.

Existem vários termos associados ao PWM -

• On-Time - A duração do sinal horário é alta.

• Off-Time - A duração do sinal horário é baixa.

• Period - É representado como a soma do tempo on-time e off-time do sinal PWM.

• Duty Cycle - É representado como a porcentagem do sinal de tempo que permanece ligado durante o período do sinal PWM.

Período

Conforme mostrado na figura, T _on denota o tempo de ativação e T _off denota o tempo de desativação do sinal. O período é a soma dos tempos de ativação e desativação e é calculado conforme mostrado na seguinte equação -

Ciclo de Trabalho

O ciclo de trabalho é calculado como o tempo de execução do período. Usando o período calculado acima, o ciclo de trabalho é calculado como -

Função analogWrite ()

o analogWrite()função grava um valor analógico (onda PWM) em um pino. Ele pode ser usado para acender um LED com brilho variável ou acionar um motor em várias velocidades. Depois de uma chamada da função analogWrite (), o pino irá gerar uma onda quadrada constante do ciclo de trabalho especificado até a próxima chamada para analogWrite () ou uma chamada para digitalRead () ou digitalWrite () no mesmo pino. A frequência do sinal PWM na maioria dos pinos é de aproximadamente 490 Hz. Nas placas Uno e semelhantes, os pinos 5 e 6 têm uma frequência de aproximadamente 980 Hz. Os pinos 3 e 11 no Leonardo também funcionam a 980 Hz.

Na maioria das placas Arduino (aquelas com o ATmega168 ou ATmega328), essa função funciona nos pinos 3, 5, 6, 9, 10 e 11. No Arduino Mega, ela funciona nos pinos 2 - 13 e 44 - 46. Arduino mais antigo placas com suporte apenas ATmega8 analogWrite() nos pinos 9, 10 e 11.

O Arduino Due suporta analogWrite()nos pinos 2 a 13 e nos pinos DAC0 e DAC1. Ao contrário dos pinos PWM, DAC0 e DAC1 são conversores Digital para Analógico e atuam como verdadeiras saídas analógicas.

Você não precisa chamar pinMode () para definir o pino como uma saída antes de chamar analogWrite ().

Sintaxe da função analogWrite ()

analogWrite ( pin , value ) ;

value - o ciclo de trabalho: entre 0 (sempre desligado) e 255 (sempre ligado).

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

Para gerar números aleatórios, você pode usar as funções de números aleatórios do Arduino. Temos duas funções -

• randomSeed(seed)
• random()

randomSeed (seed)

A função randomSeed (seed) redefine o gerador de números pseudo-aleatórios do Arduino. Embora a distribuição dos números retornados por random () seja essencialmente aleatória, a sequência é previsível. Você deve redefinir o gerador para algum valor aleatório. Se você tiver um pino analógico não conectado, ele pode captar ruídos aleatórios do ambiente ao redor. Podem ser ondas de rádio, raios cósmicos, interferência eletromagnética de telefones celulares, luzes fluorescentes e assim por diante.

Exemplo

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

aleatória( )

A função aleatória gera números pseudo-aleatórios. A seguir está a sintaxe.

Sintaxe de instruções random ()

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

Exemplo

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

Vamos agora atualizar nosso conhecimento sobre alguns dos conceitos básicos, como bits e bytes.

Bits

Um bit é apenas um dígito binário.

• O sistema binário usa dois dígitos, 0 e 1.

• Semelhante ao sistema de numeração decimal, em que os dígitos de um número não têm o mesmo valor, o 'significado' de um bit depende de sua posição no número binário. Por exemplo, os dígitos no número decimal 666 são iguais, mas têm valores diferentes.

Bytes

Um byte consiste em oito bits.

• Se um bit é um dígito, é lógico que bytes representem números.

• Todas as operações matemáticas podem ser realizadas sobre eles.

• Os dígitos em um byte também não têm o mesmo significado.

• O bit mais à esquerda tem o maior valor denominado Bit Mais Significativo (MSB).

• O bit mais à direita tem o menor valor e, portanto, é chamado de bit menos significativo (LSB).

• Como oito zeros e uns de um byte podem ser combinados de 256 maneiras diferentes, o maior número decimal que pode ser representado por um byte é 255 (uma combinação representa um zero).

As interrupções param o trabalho atual do Arduino para que algum outro trabalho possa ser feito.

Suponha que você esteja sentado em casa, conversando com alguém. De repente, o telefone toca. Você para de bater papo e pega o telefone para falar com a pessoa que ligou. Ao terminar a conversa telefônica, você volta a conversar com a pessoa antes que o telefone toque.

Da mesma forma, você pode pensar na rotina principal como conversar com alguém, o telefone tocando faz com que você pare de conversar. A rotina do serviço de interrupção é o processo de falar ao telefone. Quando a conversa telefônica termina, você volta à sua rotina principal de bate-papo. Este exemplo explica exatamente como uma interrupção faz com que um processador aja.

O programa principal está sendo executado e executando alguma função em um circuito. No entanto, quando ocorre uma interrupção, o programa principal é interrompido enquanto outra rotina é executada. Quando essa rotina termina, o processador volta à rotina principal novamente.

Caracteristicas importantes

Aqui estão alguns recursos importantes sobre interrupções -

• As interrupções podem vir de várias fontes. Nesse caso, estamos usando uma interrupção de hardware que é acionada por uma mudança de estado em um dos pinos digitais.

• A maioria dos designs do Arduino tem duas interrupções de hardware (conhecidas como "interrupção 0" e "interrupção 1") conectadas aos pinos de E / S digital 2 e 3, respectivamente.

• O Arduino Mega tem seis interrupções de hardware, incluindo as interrupções adicionais ("interrupt2" a "interrupt5") nos pinos 21, 20, 19 e 18.

• Você pode definir uma rotina usando uma função especial chamada de “Rotina de Serviço de Interrupção” (geralmente conhecida como ISR).

• Você pode definir a rotina e especificar as condições na borda ascendente, na borda descendente ou em ambas. Nessas condições específicas, a interrupção seria atendida.

• É possível que essa função seja executada automaticamente, cada vez que um evento acontecer em um pino de entrada.

Tipos de interrupções

Existem dois tipos de interrupções -

• Hardware Interrupts - Eles ocorrem em resposta a um evento externo, como um pino de interrupção externa ficando alto ou baixo.

• Software Interrupts- Eles ocorrem em resposta a uma instrução enviada no software. O único tipo de interrupção que a “linguagem Arduino” suporta é a função attachInterrupt ().

Usando interrupções no Arduino

As interrupções são muito úteis em programas Arduino, pois ajudam a resolver problemas de temporização. Uma boa aplicação de uma interrupção é ler um codificador rotativo ou observar uma entrada do usuário. Geralmente, um ISR deve ser o mais curto e rápido possível. Se o seu esboço usa vários ISRs, apenas um pode ser executado por vez. Outras interrupções serão executadas após o término da atual em uma ordem que depende da prioridade que elas têm.

Normalmente, as variáveis ​​globais são usadas para passar dados entre um ISR e o programa principal. Para garantir que as variáveis ​​compartilhadas entre um ISR e o programa principal sejam atualizadas corretamente, declare-as como voláteis.

sintaxe da instrução attachInterrupt

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

As três constantes a seguir são predefinidas como valores válidos -

• LOW para acionar a interrupção sempre que o pino estiver baixo.

• CHANGE para acionar a interrupção sempre que o valor do pino for alterado.

• FALLING sempre que o pino vai de alto para baixo.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

Centenas de protocolos de comunicação foram definidos para alcançar essa troca de dados. Cada protocolo pode ser categorizado em uma das duas categorias: paralelo ou serial.

Comunicação Paralela

A conexão paralela entre o Arduino e os periféricos via portas de entrada / saída é a solução ideal para distâncias mais curtas de até vários metros. Porém, em outros casos, quando é necessário estabelecer a comunicação entre dois dispositivos para distâncias maiores, não é possível usar a conexão paralela. As interfaces paralelas transferem vários bits ao mesmo tempo. Eles geralmente requerem barramentos de dados - transmitindo através de oito, dezesseis ou mais fios. Os dados são transferidos em ondas gigantescas de 1 e 0.

Vantagens e desvantagens da comunicação paralela

A comunicação paralela certamente tem suas vantagens. É mais rápido do que serial, direto e relativamente fácil de implementar. No entanto, ele requer muitas portas e linhas de entrada / saída (E / S). Se você já teve que mover um projeto de um Arduino Uno básico para um Mega, sabe que as linhas de E / S em um microprocessador podem ser preciosas e poucas. Portanto, preferimos a comunicação serial, sacrificando a velocidade potencial para o espaço do pino.

Módulos de comunicação serial

Hoje, a maioria das placas Arduino são construídas com vários sistemas diferentes para comunicação serial como equipamento padrão.

Qual desses sistemas são usados ​​depende dos seguintes fatores -

• Com quantos dispositivos o microcontrolador deve trocar dados?
• Quão rápido deve ser a troca de dados?
• Qual é a distância entre esses dispositivos?
• É necessário enviar e receber dados simultaneamente?

Uma das coisas mais importantes em relação à comunicação serial é o Protocol, que deve ser estritamente observado. É um conjunto de regras que devem ser aplicadas para que os dispositivos possam interpretar corretamente os dados que trocam entre si. Felizmente, o Arduino automaticamente cuida disso, de forma que o trabalho do programador / usuário é reduzido a uma simples escrita (dados a serem enviados) e leitura (dados recebidos).

Tipos de comunicações seriais

A comunicação serial pode ser ainda classificada como -

• Synchronous - Dispositivos que são sincronizados usam o mesmo relógio e seu tempo está sincronizado entre si.

• Asynchronous - Dispositivos assíncronos têm seus próprios relógios e são acionados pela saída do estado anterior.

É fácil descobrir se um dispositivo é síncrono ou não. Se o mesmo relógio for fornecido a todos os dispositivos conectados, eles serão síncronos. Se não houver linha do relógio, é assíncrono.

Por exemplo, o módulo UART (Universal Asynchronous Receiver Transmitter) é assíncrono.

O protocolo serial assíncrono possui várias regras integradas. Essas regras nada mais são do que mecanismos que ajudam a garantir transferências de dados robustas e sem erros. Esses mecanismos, que obtemos para evitar o sinal do relógio externo, são -

• Bits de sincronização
• Bits de dados
• Bits de paridade
• Taxa de transmissão

Bits de sincronização

Os bits de sincronização são dois ou três bits especiais transferidos com cada pacote de dados. Eles são o bit de início e o (s) bit (s) de parada. Fiel ao seu nome, esses bits marcam o início e o fim de um pacote, respectivamente.

Sempre há apenas um bit de início, mas o número de bits de parada é configurável para um ou dois (embora normalmente seja deixado em um).

O bit inicial é sempre indicado por uma linha de dados ociosa indo de 1 a 0, enquanto o (s) bit (s) de parada farão a transição de volta ao estado ocioso mantendo a linha em 1.

Bits de dados

A quantidade de dados em cada pacote pode ser definida para qualquer tamanho de 5 a 9 bits. Certamente, o tamanho de dados padrão é o byte básico de 8 bits, mas outros tamanhos têm seus usos. Um pacote de dados de 7 bits pode ser mais eficiente do que 8, especialmente se você estiver apenas transferindo caracteres ASCII de 7 bits.

Bits de paridade

O usuário pode selecionar se deve haver um bit de paridade ou não e, em caso afirmativo, se a paridade deve ser ímpar ou par. O bit de paridade é 0 se o número de 1 entre os bits de dados for par. A paridade ímpar é exatamente o oposto.

Taxa de transmissão

O termo taxa de transmissão é usado para denotar o número de bits transferidos por segundo [bps]. Observe que se refere a bits, não bytes. Normalmente, o protocolo exige que cada byte seja transferido junto com vários bits de controle. Isso significa que um byte no fluxo de dados serial pode consistir em 11 bits. Por exemplo, se a taxa de transmissão for 300 bps, no máximo 37 e no mínimo 27 bytes podem ser transferidos por segundo.

Arduino UART

O código a seguir fará com que o Arduino mande um hello world quando for inicializado.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

Após o esboço do Arduino ter sido carregado para o Arduino, abra o monitor Serial

na seção superior direita do IDE do Arduino.

Digite qualquer coisa na caixa superior do Monitor Serial e pressione Enviar ou Enter no teclado. Isso enviará uma série de bytes para o Arduino.

O código a seguir retorna tudo o que recebe como entrada.

O código a seguir fará com que o Arduino forneça saída, dependendo da entrada fornecida.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

Notar que Serial.print e Serial.println irá enviar de volta o código ASCII real, enquanto Serial.writeirá enviar de volta o texto real. Consulte os códigos ASCII para obter mais informações.

Circuito Inter-integrado (I2C) é um sistema de troca serial de dados entre os microcontroladores e circuitos integrados especializados de nova geração. É usado quando a distância entre eles é curta (o receptor e o transmissor geralmente estão na mesma placa impressa). A conexão é estabelecida por meio de dois condutores. Um é usado para transferência de dados e o outro é usado para sincronização (sinal de relógio).

Conforme visto na figura a seguir, um dispositivo é sempre um mestre. Ele executa o endereçamento de um chip escravo antes do início da comunicação. Desta forma, um microcontrolador pode se comunicar com 112 dispositivos diferentes. A taxa de transmissão é geralmente de 100 Kb / s (modo padrão) ou 10 Kb / s (modo de taxa de transmissão lenta). Recentemente, surgiram sistemas com taxa de transmissão de 3,4 Mb / s. A distância entre os dispositivos que se comunicam em um barramento I2C é limitada a vários metros.

Pinos I2C da placa

O barramento I2C consiste em dois sinais - SCL e SDA. SCL é o sinal de clock e SDA é o sinal de dados. O barramento mestre atual sempre gera o sinal de clock. Alguns dispositivos escravos podem forçar o clock baixo às vezes para atrasar o envio de mais dados pelo mestre (ou para exigir mais tempo para preparar os dados antes que o mestre tente fazer o clock out). Isso é conhecido como “alongamento do relógio”.

A seguir estão os pinos para diferentes placas Arduino -

• Uno, Pro Mini A4 (SDA), A5 (SCL)
• Mega, Devido 20 (SDA), 21 (SCL)
• Leonardo, Yun 2 (SDA), 3 (SCL)

Arduino I2C

Temos dois modos - código mestre e código escravo - para conectar duas placas Arduino usando I2C. Eles são -

• Transmissor Mestre / Receptor Escravo
• Receptor mestre / transmissor escravo

Transmissor Mestre / Receptor Escravo

Vamos agora ver o que é transmissor mestre e receptor escravo.

Transmissor Mestre

As funções a seguir são usadas para inicializar a biblioteca Wire e ingressar no barramento I2C como mestre ou escravo. Normalmente, é chamado apenas uma vez.

• Wire.begin(address) - O endereço é o endereço do escravo de 7 bits em nosso caso, pois o mestre não é especificado e entrará no barramento como mestre.

• Wire.beginTransmission(address) - Comece uma transmissão para o dispositivo escravo I2C com o endereço fornecido.

• Wire.write(value) - Fila os bytes para transmissão de um dispositivo mestre para o escravo (entre chamadas para beginTransmission () e endTransmission ()).

• Wire.endTransmission() - Termina uma transmissão para um dispositivo escravo que foi iniciada por beginTransmission () e transmite os bytes que foram enfileirados por wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Slave Receiver

As seguintes funções são usadas -

• Wire.begin(address) - O endereço é o endereço do escravo de 7 bits.

• Wire.onReceive(received data handler) - Função a ser chamada quando um dispositivo escravo recebe dados do mestre.

• Wire.available() - Retorna o número de bytes disponíveis para recuperação com Wire.read (). Isso deve ser chamado dentro do manipulador Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Receptor mestre / transmissor escravo

Vamos agora ver o que é receptor mestre e transmissor escravo.

Receptor Mestre

O Master é programado para solicitar e então ler bytes de dados que são enviados do Slave Arduino endereçado exclusivamente.

A seguinte função é usada -

Wire.requestFrom(address,number of bytes)- Usado pelo mestre para solicitar bytes de um dispositivo escravo. Os bytes podem então ser recuperados com as funções wire.available () e wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Transmissor escravo

A seguinte função é usada.

Wire.onRequest(handler) - Uma função é chamada quando um mestre solicita dados deste dispositivo escravo.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

Um barramento de interface periférica serial (SPI) é um sistema para comunicação serial que usa até quatro condutores, geralmente três. Um condutor é usado para receber dados, um para enviar dados, um para sincronização e um alternativamente para selecionar um dispositivo com o qual se comunicar. É uma conexão full duplex, o que significa que os dados são enviados e recebidos simultaneamente. A taxa de transmissão máxima é maior do que no sistema de comunicação I2C.

Pinos SPI da placa

SPI usa os seguintes quatro fios -

• SCK - Este é o relógio serial acionado pelo mestre.

• MOSI - Esta é a saída mestre / entrada escrava conduzida pelo mestre.

• MISO - Esta é a entrada mestre / saída escrava acionada pelo mestre.

• SS - Este é o fio de seleção do escravo.

As seguintes funções são usadas. Você tem que incluir o SPI.h.

• SPI.begin() - Inicializa o barramento SPI configurando SCK, MOSI e SS para saídas, puxando SCK e MOSI para baixo e SS para alto.

• SPI.setClockDivider(divider)- Para definir o divisor de relógio SPI em relação ao relógio do sistema. Em placas baseadas em AVR, os divisores disponíveis são 2, 4, 8, 16, 32, 64 ou 128. A configuração padrão é SPI_CLOCK_DIV4, que define o relógio SPI para um quarto da frequência do relógio do sistema (5 Mhz para placas a 20 MHz).

• Divider - Pode ser (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128).

• SPI.transfer(val) - A transferência SPI é baseada em um envio e recebimento simultâneos: os dados recebidos são retornados em receivedVal.

• SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum é o relógio, dataOrder (MSBFIRST ou LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 ou SPI_MODE3).

Temos quatro modos de operação no SPI como segue -

• Mode 0 (the default) - O clock é normalmente baixo (CPOL = 0) e os dados são amostrados na transição de baixo para alto (borda de ataque) (CPHA = 0).

• Mode 1 - O clock é normalmente baixo (CPOL = 0) e os dados são amostrados na transição de alto para baixo (borda de fuga) (CPHA = 1).

• Mode 2 - O clock é normalmente alto (CPOL = 1) e os dados são amostrados na transição de alto para baixo (borda de ataque) (CPHA = 0).

• Mode 3 - O clock é normalmente alto (CPOL = 1) e os dados são amostrados na transição de baixo para alto (borda de fuga) (CPHA = 1).

• SPI.attachInterrupt(handler) - Função a ser chamada quando um dispositivo escravo recebe dados do mestre.

Agora, conectaremos duas placas Arduino UNO; um como mestre e o outro como escravo.

• (SS): pino 10
• (MOSI): pino 11
• (MISO): pino 12
• (SCK): pino 13

O terreno é comum. A seguir está a representação esquemática da conexão entre as duas placas -

Vejamos exemplos de SPI como Master e SPI como Slave.

SPI como MASTER

Exemplo

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SPI como SLAVE

Exemplo

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

LEDs são luzes pequenas e potentes usadas em muitas aplicações diferentes. Para começar, vamos trabalhar para piscar um LED, o Hello World dos microcontroladores. É tão simples quanto acender e apagar uma luz. Estabelecer essa importante linha de base fornecerá a você uma base sólida à medida que trabalhamos em experimentos mais complexos.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × LED
• 1 × 330Ω Resistor
• 2 × Jumper

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Note- Para descobrir a polaridade de um LED, observe-o de perto. A mais curta das duas pernas, em direção à borda plana da lâmpada, indica o terminal negativo.

Componentes como resistores precisam ter seus terminais dobrados em ângulos de 90 ° para se encaixar nos soquetes da placa de ensaio corretamente. Você também pode cortar os terminais mais curtos.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra o novo arquivo de esboço clicando em Novo.

Código Arduino

/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

Código a ser anotado

pinMode(2, OUTPUT)- Antes de usar um dos pinos do Arduino, você precisa informar ao Arduino Uno R3 se é uma ENTRADA ou SAÍDA. Usamos uma “função” integrada chamada pinMode () para fazer isso.

digitalWrite(2, HIGH) - Quando você está usando um pino como uma SAÍDA, você pode comandá-lo para ser HIGH (saída 5 volts) ou BAIXO (saída 0 volts).

Resultado

Você deverá ver o seu LED acender e apagar. Se a saída necessária não for vista, certifique-se de ter montado o circuito corretamente e verificado e carregado o código em sua placa.

Este exemplo demonstra o uso da função analogWrite () para diminuir o apagamento de um LED. AnalogWrite usa modulação de largura de pulso (PWM), ligando e desligando um pino digital muito rapidamente com diferentes relações entre ligado e desligado, para criar um efeito de desvanecimento.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × LED
• 1 × 330Ω Resistor
• 2 × Jumper

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Note- Para descobrir a polaridade de um LED, observe-o de perto. A mais curta das duas pernas, em direção à borda plana da lâmpada, indica o terminal negativo.

Componentes como resistores precisam ter seus terminais dobrados em ângulos de 90 ° para se encaixar nos soquetes da placa de ensaio corretamente. Você também pode cortar os terminais mais curtos.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra o novo arquivo de esboço clicando em Novo.

Código Arduino

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

Código a ser anotado

Depois de declarar o pino 9 como o pino do LED, não há nada a fazer na função setup () do seu código. A função analogWrite () que você usará no loop principal de seu código requer dois argumentos: Um, informando a função em qual pino escrever e o outro indicando qual valor PWM escrever.

Para apagar e acender o LED gradualmente, aumente gradualmente os valores de PWM de 0 (totalmente apagado) a 255 (totalmente aceso) e, em seguida, de volta a 0, para concluir o ciclo. No esboço fornecido acima, o valor PWM é definido usando uma variável chamada brilho. Cada vez que passa pelo loop, aumenta o valor da variávelfadeAmount.

Se o brilho estiver em qualquer um dos extremos de seu valor (0 ou 255), então fadeAmount será alterado para negativo. Em outras palavras, se fadeAmount for 5, ele será definido como -5. Se for -5, será definido como 5. Na próxima vez no loop, essa alteração fará com que o brilho também mude de direção.

analogWrite()pode alterar o valor de PWM muito rápido, portanto, o atraso no final do esboço controla a velocidade do esmaecimento. Tente alterar o valor do atraso e veja como ele altera o efeito de esmaecimento.

Resultado

Você deve ver o brilho do LED mudar gradualmente.

Este exemplo mostrará como ler uma entrada analógica no pino analógico 0. A entrada é convertida de analogRead () em tensão e impressa no monitor serial do software Arduino (IDE).

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × resistor variável 5K (potenciômetro)
• 2 × Jumper

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Potenciômetro

Um potenciômetro (ou potenciômetro) é um transdutor eletromecânico simples. Ele converte o movimento rotativo ou linear do operador de entrada em uma mudança de resistência. Essa mudança é (ou pode ser) usada para controlar qualquer coisa, desde o volume de um sistema de alta fidelidade até a direção de um enorme navio de contêineres.

O pote como o conhecemos era originalmente conhecido como reostato (essencialmente um resistor de fio enrolado variável). A variedade de potes disponíveis agora é bastante surpreendente e pode ser muito difícil para o iniciante (em particular) descobrir que tipo é adequado para uma determinada tarefa. Alguns tipos de potes diferentes, que podem ser usados ​​para a mesma tarefa, tornam o trabalho mais difícil.

A imagem à esquerda mostra o símbolo esquemático padrão de um pote. A imagem à direita é o potenciômetro.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

Código a ser anotado

No programa ou esboço dado abaixo, a primeira coisa que você faz na função de configuração é iniciar as comunicações seriais, a 9600 bits por segundo, entre sua placa e seu computador com a linha -

Serial.begin(9600);

No loop principal do seu código, você precisa estabelecer uma variável para armazenar o valor da resistência (que estará entre 0 e 1023, perfeito para um tipo de dados int) proveniente do seu potenciômetro -

int sensorValue = analogRead(A0);

Para alterar os valores de 0-1023 para um intervalo que corresponda à tensão, o pino está lendo, você precisa criar outra variável, um flutuador, e fazer alguns cálculos. Para dimensionar os números entre 0,0 e 5,0, divida 5,0 por 1023,0 e multiplique por sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

Finalmente, você precisa imprimir essas informações em sua janela serial. Você pode fazer isso com o comando Serial.println () em sua última linha de código -

Serial.println(voltage)

Agora, abra o Serial Monitor no Arduino IDE clicando no ícone no lado direito da barra verde superior ou pressionando Ctrl + Shift + M.

Resultado

Você verá um fluxo constante de números variando de 0,0 a 5,0. Conforme você gira o potenciômetro, os valores mudam, correspondendo à tensão no pino A0.

Este exemplo mostra como ler uma entrada analógica no pino 0 analógico, converter os valores de analogRead () em tensão e imprimi-lo no monitor serial do software Arduino (IDE).

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × 5k ohm resistor variável (potenciômetro)
• 2 × Jumper
• 8 × LED ou você pode usar (exibição de gráfico de barras LED como mostrado na imagem abaixo)

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Gráfico de barras de LED de 10 segmentos

Esses LEDs de gráfico de barras de 10 segmentos têm muitos usos. Com um tamanho compacto e conexão simples, eles são fáceis para protótipos ou produtos acabados. Essencialmente, são 10 LEDs azuis individuais alojados juntos, cada um com uma conexão de ânodo e cátodo individual.

Eles também estão disponíveis nas cores amarela, vermelha e verde.

Note- O pino desses gráficos de barras pode ser diferente do que está listado na folha de dados. Girar o dispositivo 180 graus corrigirá a alteração, tornando o pino 11 o primeiro pino da linha.

Código Arduino

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

Código a ser anotado

O esboço funciona assim: primeiro, você lê a entrada. Você mapeia o valor de entrada para a faixa de saída, neste caso dez LEDs. Então você configura umfor-looppara iterar sobre as saídas. Se o número da saída na série for inferior ao intervalo de entrada mapeado, você o liga. Se não, você o desliga.

Resultado

Você verá o LED acender um a um quando o valor da leitura analógica aumentar e apagar um por um enquanto a leitura estiver diminuindo.

Este exemplo usa a biblioteca do teclado para fazer o logout da sessão do usuário no computador quando o pino 2 do ARDUINO UNO é colocado no chão. O esboço simula o pressionamento de tecla em sequência de duas ou três teclas ao mesmo tempo e, após um pequeno atraso, ele as libera.

Warning - Quando você usa o Keyboard.print()comando, o Arduino assume o teclado do seu computador. Para garantir que você não perca o controle do computador ao executar um esboço com esta função, configure um sistema de controle confiável antes de chamar Keyboard.print (). Este esboço é projetado para enviar um comando de teclado apenas após um pino ter sido puxado para o solo.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Leonardo, Micro ou placa de vencimento
• 1 × botão de pressão
• 1 × Jumper

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Para este exemplo, você precisa usar o Arduino IDE 1.6.7

Note- Você deve incluir a biblioteca de teclado em seu arquivo de biblioteca do Arduino. Copie e cole o arquivo de biblioteca do teclado numérico dentro do arquivo com os nomes de bibliotecas (realçados), conforme mostrado na captura de tela a seguir.

Código Arduino

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

Código a ser anotado

Antes de fazer o upload do programa para sua placa, certifique-se de atribuir o SO correto que está usando atualmente à variável de plataforma.

Enquanto o esboço está em execução, pressionar o botão conectará o pino 2 ao solo e a placa enviará a sequência de logout ao PC conectado via USB.

Resultado

Quando você conecta o pino 2 ao solo, ele executa uma operação de logout.

Ele usa as seguintes combinações de teclado para sair -

• Em Windows, CTRL-ALT-DEL seguido por ALT-l

• Em Ubuntu, CTRL-ALT-DEL e ENTER

• Em OSX, CMD-SHIFT-q

Neste exemplo, quando o botão é pressionado, uma string de texto é enviada ao computador como entrada do teclado. A string informa o número de vezes que o botão é pressionado. Depois de ter o Leonardo programado e conectado, abra seu editor de texto favorito para ver os resultados.

Warning - Quando você usa o Keyboard.print()comando, o Arduino assume o teclado do seu computador. Para garantir que você não perca o controle de seu computador ao executar um esboço com esta função, configure um sistema de controle confiável antes de ligarKeyboard.print(). Este esboço inclui um botão de pressão para alternar o teclado, de modo que ele só funcione após o botão ser pressionado.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Leonardo, Micro ou placa de vencimento
• 1 × botão momentâneo
• 1 × resistor de 10k ohm

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

Código a ser anotado

Conecte um terminal do botão de pressão ao pino 4 no Arduino. Conecte o outro pino a 5V. Use o resistor como pull-down, fornecendo uma referência ao terra, conectando-o do pino 4 ao solo.

Depois de programar sua placa, desconecte o cabo USB, abra um editor de texto e coloque o cursor de texto na área de digitação. Conecte a placa ao seu computador via USB novamente e pressione o botão para escrever no documento.

Resultado

Ao usar qualquer editor de texto, ele exibirá o texto enviado via Arduino.

Usando a biblioteca Mouse, você pode controlar o cursor na tela de um computador com um Arduino Leonardo, Micro ou Due.

Este exemplo específico usa cinco botões para mover o cursor na tela. Quatro dos botões são direcionais (para cima, para baixo, para a esquerda, para a direita) e um é para o clique esquerdo do mouse. O movimento do cursor do Arduino é sempre relativo. Cada vez que uma entrada é lida, a posição do cursor é atualizada em relação à sua posição atual.

Sempre que um dos botões direcionais é pressionado, o Arduino move o mouse, mapeando uma entrada HIGH para um intervalo de 5 na direção apropriada.

O quinto botão serve para controlar o clique esquerdo do mouse. Quando o botão for liberado, o computador reconhecerá o evento.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Leonardo, Micro ou placa devido
• 5 × 10k ohm resistor
• 5 × botões momentâneos

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Para este exemplo, você precisa usar o Arduino IDE 1.6.7

Código Arduino

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

Código a ser anotado

Conecte sua placa ao computador com um cabo micro-USB. Os botões são conectados às entradas digitais dos pinos 2 a 6. Certifique-se de usar resistores pull-down de 10k.

Este exemplo escuta um byte vindo da porta serial. Quando recebida, a placa envia um pressionamento de tecla de volta ao computador. O pressionamento de tecla enviado é um maior do que o recebido, portanto, se você enviar um "a" do monitor serial, receberá um "b" da placa conectada ao computador. Um "1" retornará um "2" e assim por diante.

Warning - Quando você usa o Keyboard.print()comando, a placa Leonardo, Micro ou Due assume o teclado do seu computador. Para garantir que você não perca o controle do computador ao executar um esboço com esta função, configure um sistema de controle confiável antes de chamar Keyboard.print (). Este esboço é projetado para enviar um comando de teclado apenas depois que a placa recebeu um byte pela porta serial.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × Arduino Leonardo, Micro ou placa de vencimento

Procedimento

Basta conectar sua placa ao computador usando um cabo USB.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Notes- Você deve incluir a biblioteca do teclado em seu arquivo de biblioteca do Arduino. Copie e cole o arquivo da biblioteca do teclado dentro do arquivo com o nome 'bibliotecas' destacado em amarelo.

Código Arduino

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

Código a ser anotado

Uma vez programado, abra seu monitor serial e envie um byte. O quadro responderá com um toque de tecla, ou seja, um número a mais.

Resultado

A placa responderá com um pressionamento de tecla um número a mais no monitor serial IDE do Arduino quando você enviar um byte.

Nesta seção, aprenderemos como fazer a interface de nossa placa Arduino com diferentes sensores. Discutiremos os seguintes sensores -

• Sensor de umidade (DHT22)
• Sensor de temperatura (LM35)
• Sensor detector de água (Simple Water Trigger)
• SENSOR PIR
• SENSOR ULTRASÔNICO
• GPS

Sensor de umidade (DHT22)

O DHT-22 (também denominado AM2302) é um sensor de saída digital, umidade relativa e temperatura. Ele usa um sensor capacitivo de umidade e um termistor para medir o ar circundante e envia um sinal digital no pino de dados.

Neste exemplo, você aprenderá como usar este sensor com o Arduino UNO. A temperatura e a umidade da sala serão impressas no monitor serial.

O Sensor DHT-22

As conexões são simples. O primeiro pino à esquerda para alimentação de 3-5 V, o segundo pino para o pino de entrada de dados e o pino mais à direita para o aterramento.

Detalhes técnicos

• Power - 3-5V

• Max Current - 2,5mA

• Humidity - 0-100%, precisão de 2-5%

• Temperature - 40 a 80 ° C, precisão de ± 0,5 ° C

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × DHT22
• 1 × 10K ohm resistor

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

Código a ser anotado

O sensor DHT22 tem quatro terminais (V _cc , DATA, NC, GND), que são conectados à placa da seguinte forma -

• Pino de dados para o pino número 2 do Arduino
• Pino V _cc para 5 volts da placa Arduino
• Pino GND ao solo da placa Arduino
• Precisamos conectar o resistor de 10k ohm (pull up resistor) entre o DATA e o pino V _cc

Assim que as conexões de hardware forem feitas, você precisa adicionar a biblioteca DHT22 ao seu arquivo de biblioteca do Arduino conforme descrito anteriormente.

Resultado

Você verá a tela de temperatura e umidade no monitor da porta serial, que é atualizado a cada 2 segundos.

Os sensores de temperatura da série LM35 são dispositivos de temperatura de circuito integrado de precisão com uma tensão de saída linearmente proporcional à temperatura centígrada.

O dispositivo LM35 tem uma vantagem sobre os sensores de temperatura linear calibrados em Kelvin, já que o usuário não precisa subtrair uma grande tensão constante da saída para obter uma escala Centígrada conveniente. O dispositivo LM35 não requer nenhuma calibração externa ou ajuste para fornecer precisões típicas de ± ¼ ° C em temperatura ambiente e ± ¾ ° C em uma faixa de temperatura completa de −55 ° C a 150 ° C.

Especificações técnicas

• Calibrado diretamente em Celsius (Centígrados)
• Linear + fator de escala 10-mV / ° C
• Precisão garantida de 0,5 ° C (a 25 ° C)
• Avaliado para faixa completa de −55 ° C a 150 ° C
• Adequado para aplicações remotas

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × sensor LM35

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

float temp;
int tempPin = 0;

void setup() {
   Serial.begin(9600);
}

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

Código a ser anotado

O sensor LM35 possui três terminais - V _s , V _out e GND. Vamos conectar o sensor da seguinte forma -

• Conecte os + V _s a + 5v na placa Arduino.
• Conecte a _saída V para Analog0 ou A0 na placa Arduino.
• Conecte GND com GND no Arduino.

O conversor analógico para digital (ADC) converte valores analógicos em uma aproximação digital com base na fórmula Valor ADC = amostra * 1024 / tensão de referência (+ 5v). Portanto, com uma referência de +5 volts, a aproximação digital será igual à tensão de entrada * 205.

Resultado

Você verá o display de temperatura no monitor da porta serial que é atualizado a cada segundo.

O bloco do sensor de água é projetado para detecção de água, que pode ser amplamente utilizado para detectar chuvas, nível de água e até vazamento de líquido.

Conectar um sensor de água a um Arduino é uma ótima maneira de detectar um vazamento, derramamento, inundação, chuva, etc. Ele pode ser usado para detectar a presença, o nível, o volume e / ou a ausência de água. Embora isso possa ser usado para lembrá-lo de regar suas plantas, existe um sensor Grove melhor para isso. O sensor possui uma série de traços expostos, que indicam BAIXA quando a água é detectada.

Neste capítulo, conectaremos o sensor de água ao pino digital 8 no Arduino e contaremos com o LED muito prático para ajudar a identificar quando o sensor de água entra em contato com uma fonte de água.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × sensor de água
• 1 × led
• 1 × 330 ohm resistor

Procedimento

Siga o diagrama do circuito e conecte os componentes na placa de ensaio, conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

Código a ser anotado

O sensor de água tem três terminais - S, V _saída (+) e GND (-). Conecte o sensor da seguinte forma -

• Conecte os + V _s a + 5v na placa Arduino.
• Conecte S ao pino digital número 8 na placa Arduino.
• Conecte GND com GND no Arduino.
• Conecte o LED ao pino digital número 9 na placa Arduino.

Quando o sensor detecta água, o pino 8 no Arduino fica BAIXO e o LED no Arduino é LIGADO.

Resultado

Você verá o LED de indicação acender quando o sensor detectar água.

Os sensores PIR permitem sentir o movimento. Eles são usados ​​para detectar se um humano entrou ou saiu do alcance do sensor. Eles são comumente encontrados em eletrodomésticos e aparelhos usados ​​em casa ou para empresas. Eles são freqüentemente referidos como sensores PIR, "infravermelho passivo", "piroelétrico" ou "movimento infravermelho".

A seguir estão as vantagens dos sensores PIR -

• Tamanho pequeno
• Grande alcance de lente
• Fácil de interface
• Inexpensive
• Low-power
• Fácil de usar
• Não se desgasta

Os PIRs são feitos de sensores piroelétricos, uma lata de metal redonda com um cristal retangular no centro, que pode detectar níveis de radiação infravermelha. Tudo emite radiação de baixo nível, e quanto mais quente alguma coisa, mais radiação é emitida. O sensor em um detector de movimento é dividido em duas metades. Isso é para detectar movimento (mudança) e não os níveis médios de IR. As duas metades estão conectadas de modo que se cancelem. Se metade vê mais ou menos radiação IV do que a outra, a saída oscila para cima ou para baixo.

Os PIRs têm configurações ajustáveis ​​e têm um cabeçalho instalado nos blocos de aterramento / saída / alimentação de 3 pinos.

Para muitos projetos ou produtos básicos que precisam detectar quando uma pessoa saiu ou entrou na área, os sensores PIR são ótimos. Observe que os PIRs não informam o número de pessoas ao redor ou sua proximidade do sensor. A lente é frequentemente fixada a uma certa distância e às vezes são acionadas pelos animais de estimação da casa.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × Sensor PIR (MQ3)

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

Código a ser anotado

O sensor PIR possui três terminais - V _cc , OUT e GND. Conecte o sensor da seguinte forma -

• Conecte o + V _cc a + 5v na placa Arduino.
• Conecte OUT ao pino digital 2 na placa Arduino.
• Conecte GND com GND no Arduino.

Você pode ajustar a sensibilidade do sensor e o tempo de atraso por meio de dois resistores variáveis ​​localizados na parte inferior da placa do sensor.

Assim que o sensor detectar qualquer movimento, o Arduino enviará uma mensagem pela porta serial para dizer que um movimento foi detectado. O movimento de detecção PIR irá atrasar um certo tempo para verificar se há um novo movimento. Se nenhum movimento for detectado, o Arduino enviará uma nova mensagem dizendo que o movimento foi encerrado.

Resultado

Você verá uma mensagem na sua porta serial se um movimento for detectado e outra mensagem quando o movimento parar.

O sensor ultrassônico HC-SR04 usa SONAR para determinar a distância de um objeto, assim como os morcegos fazem. Ele oferece excelente detecção de alcance sem contato com alta precisão e leituras estáveis ​​em um pacote fácil de usar de 2 cm a 400 cm ou 1 ”a 13 pés.

A operação não é afetada pela luz solar ou material preto, embora acusticamente, materiais macios como pano podem ser difíceis de detectar. Ele vem completo com transmissor ultrassônico e módulo receptor.

Especificações técnicas

• Fonte de alimentação - + 5V DC
• Corrente Quiescente - <2mA
• Corrente de Trabalho - 15mA
• Ângulo Efetivo - <15 °
• Distância de alcance - 2 cm - 400 cm / 1 ″ - 13 pés
• Resolução - 0,3 cm
• Ângulo de medição - 30 graus

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × breadboard
• 1 × Arduino Uno R3
• 1 × Sensor ULTRASSÔNICO (HC-SR04)

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

Código a ser anotado

O sensor ultrassônico tem quatro terminais - + 5V, Trigger, Echo e GND conectados da seguinte forma -

• Conecte o pino de + 5 V a + 5 V em sua placa Arduino.
• Conecte o gatilho ao pino digital 7 em sua placa Arduino.
• Conecte o Echo ao pino digital 6 em sua placa Arduino.
• Conecte GND com GND no Arduino.

Em nosso programa, exibimos a distância medida pelo sensor em polegadas e cm através da porta serial.

Resultado

Você verá a distância medida pelo sensor em polegadas e cm no monitor serial Arduino.

Botões de pressão ou interruptores conectam dois terminais abertos em um circuito. Este exemplo liga o LED no pino 2 quando você pressiona o botão de pressão conectado ao pino 8.

Resistor pull-down

Resistores pull-down são usados ​​em circuitos lógicos eletrônicos para garantir que as entradas para o Arduino se estabilizem nos níveis lógicos esperados se os dispositivos externos forem desconectados ou estiverem em alta impedância. Como nada está conectado a um pino de entrada, isso não significa que seja um zero lógico. Os resistores pull down são conectados entre o aterramento e o pino apropriado no dispositivo.

Um exemplo de um resistor pull-down em um circuito digital é mostrado na figura a seguir. Um interruptor de botão é conectado entre a tensão de alimentação e um pino do microcontrolador. Em tal circuito, quando a chave está fechada, a entrada do microcontrolador está em um valor alto lógico, mas quando a chave está aberta, o resistor pull-down puxa a tensão de entrada para o solo (valor lógico zero), evitando um estado indefinido na entrada.

O resistor pull-down deve ter uma resistência maior do que a impedância do circuito lógico, ou então ele pode puxar a tensão muito para baixo e a tensão de entrada no pino permaneceria em um valor lógico baixo constante, independentemente da posição da chave.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × placa Arduino UNO
• 1 × 330 ohm resistor
• 1 × resistor de 4,7 K ohm (puxar para baixo)
• 1 × LED

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

Código a ser anotado

Quando a chave está aberta (o botão não está pressionado), não há conexão entre os dois terminais do botão, então o pino é conectado ao aterramento (através do resistor pull-down) e lemos um LOW. Quando a chave é fechada (botão pressionado), ele faz uma conexão entre seus dois terminais, conectando o pino a 5 volts, para que possamos ler um ALTO.

Resultado

O LED é LIGADO quando o botão é pressionado e DESLIGADO quando é liberado.

Neste capítulo, faremos a interface de diferentes tipos de motores com a placa Arduino (UNO) e mostraremos como conectar o motor e acioná-lo a partir de sua placa.

Existem três tipos diferentes de motores -

• motor DC
• Servo motor
• Motor de passo

Um motor DC (motor de corrente contínua) é o tipo mais comum de motor. Os motores DC normalmente têm apenas dois terminais, um positivo e um negativo. Se você conectar esses dois cabos diretamente a uma bateria, o motor irá girar. Se você trocar os cabos, o motor girará na direção oposta.

Warning- Não dirija o motor diretamente dos pinos da placa Arduino. Isso pode danificar a placa. Use um circuito de driver ou um IC.

Vamos dividir este capítulo em três partes -

• Basta fazer seu motor girar
• Controle de velocidade do motor
• Controle a direção do giro do motor DC

Componentes necessários

Você precisará dos seguintes componentes -

• 1x placa Arduino UNO
• 1x PN2222 Transistor
• 1x motor pequeno 6V DC
• 1x diodo 1N4001
• 1x resistor 270 Ω

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Precauções

Tome as seguintes precauções ao fazer as conexões.

• Primeiro, certifique-se de que o transistor está conectado da maneira correta. O lado plano do transistor deve ficar de frente para a placa Arduino, conforme mostrado no arranjo.

• Em segundo lugar, a extremidade listrada do diodo deve estar voltada para a linha de alimentação de + 5 V de acordo com o arranjo mostrado na imagem.

Código Spin ControlArduino

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

Código a ser anotado

O transistor atua como uma chave, controlando a energia do motor. O pino 3 do Arduino é usado para ligar e desligar o transistor e recebe o nome de 'motorPin' no esboço.

Resultado

O motor girará em velocidade total quando o pino número 3 do Arduino ficar alto.

Controle de velocidade do motor

A seguir está o diagrama esquemático de um motor DC, conectado à placa Arduino.

Código Arduino

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

Código a ser anotado

O transistor atua como uma chave, controlando a potência do motor. O pino 3 do Arduino é usado para ligar e desligar o transistor e recebe o nome de 'motorPin' no esboço.

Quando o programa é iniciado, ele solicita que você forneça os valores para controlar a velocidade do motor. Você precisa inserir um valor entre 0 e 255 no Monitor Serial.

Na função 'loop', o comando 'Serial.parseInt' é usado para ler o número inserido como texto no Monitor Serial e convertê-lo em um 'int'. Você pode digitar qualquer número aqui. A instrução 'if' na próxima linha simplesmente faz uma gravação analógica com este número, se o número estiver entre 0 e 255.

Resultado

O motor DC girará com velocidades diferentes de acordo com o valor (0 a 250) recebido pela porta serial.

Controle de direção de giro

Para controlar a direção do giro do motor DC, sem trocar os fios, você pode usar um circuito chamado H-Bridge. Uma ponte H é um circuito eletrônico que pode acionar o motor em ambas as direções. As pontes H são usadas em muitas aplicações diferentes. Uma das aplicações mais comuns é o controle de motores em robôs. É chamada de ponte H porque usa quatro transistores conectados de forma que o diagrama esquemático se parece com um "H".

Estaremos usando o IC L298 H-Bridge aqui. O L298 pode controlar a velocidade e a direção de motores CC e motores de passo, e pode controlar dois motores simultaneamente. Sua classificação atual é 2A para cada motor. Nessas correntes, porém, você precisará usar dissipadores de calor.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × L298 ponte IC
• 1 × motor DC
• 1 × Arduino UNO
• 1 × breadboard
• 10 × fios de jumper

Procedimento

A seguir está o diagrama esquemático da interface do motor DC para a placa Arduino Uno.

O diagrama acima mostra como conectar o L298 IC para controlar dois motores. Existem três pinos de entrada para cada motor, Entrada1 (IN1), Entrada2 (IN2) e Ativar1 (EN1) para Motor1 e Entrada3, Entrada4 e Ativar2 para Motor2.

Como controlaremos apenas um motor neste exemplo, conectaremos o Arduino a IN1 (pino 5), IN2 (pino 7) e Enable1 (pino 6) do IC L298. Os pinos 5 e 7 são digitais, ou seja, entradas ON ou OFF, enquanto o pino 6 precisa de um sinal modulado por largura de pulso (PWM) para controlar a velocidade do motor.

A tabela a seguir mostra em qual direção o motor girará com base nos valores digitais de IN1 e IN2.

EM 1	EM 2	Comportamento Motor
		FREIO
1		FRENTE
	1	PARA TRÁS
1	1	FREIO

O pino IN1 do IC L298 está conectado ao pino 8 do Arduino, enquanto o IN2 está conectado ao pino 9. Esses dois pinos digitais do Arduino controlam a direção do motor. O pino EN A do IC é conectado ao pino 2 do PWM do Arduino. Isso controlará a velocidade do motor.

Para definir os valores dos pinos 8 e 9 do Arduino, usamos a função digitalWrite (), e para definir o valor do pino 2, temos que usar a função analogWrite ().

Etapas de conexão

• Conecte 5V e o aterramento do IC a 5V e o aterramento do Arduino, respectivamente.
• Conecte o motor aos pinos 2 e 3 do IC.
• Conecte IN1 do IC ao pino 8 do Arduino.
• Conecte IN2 do IC ao pino 9 do Arduino.
• Conecte EN1 do IC ao pino 2 do Arduino.
• Conecte o pino SENS A do IC ao aterramento.
• Conecte o Arduino usando o cabo USB do Arduino e carregue o programa no Arduino usando o software Arduino IDE.
• Fornece energia para a placa Arduino usando fonte de alimentação, bateria ou cabo USB.

Código Arduino

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

Resultado

O motor funcionará primeiro no sentido horário (CW) por 3 segundos e depois no sentido anti-horário (CCW) por 3 segundos.

Um servo motor é um pequeno dispositivo que possui um eixo de saída. Este eixo pode ser posicionado em posições angulares específicas, enviando ao servo um sinal codificado. Enquanto o sinal codificado existir na linha de entrada, o servo manterá a posição angular do eixo. Se o sinal codificado muda, a posição angular do eixo muda. Na prática, os servos são usados ​​em aviões controlados por rádio para posicionar superfícies de controle como elevadores e lemes. Eles também são usados ​​em carros controlados por rádio, fantoches e, claro, robôs.

Servos são extremamente úteis em robótica. Os motores são pequenos, têm circuitos de controle embutidos e são extremamente poderosos para seu tamanho. Um servo padrão como o Futaba S-148 tem 42 oz / polegadas de torque, o que é forte para seu tamanho. Ele também consome energia proporcional à carga mecânica. Um servo com carga leve, portanto, não consome muita energia.

As entranhas de um servo motor são mostradas na imagem a seguir. Você pode ver os circuitos de controle, o motor, um conjunto de engrenagens e a caixa. Você também pode ver os 3 fios que se conectam ao mundo exterior. Um é para alimentação (+ 5 volts), aterramento e o fio branco é o fio de controle.

Funcionamento de um servo motor

O servo motor tem alguns circuitos de controle e um potenciômetro (um resistor variável, também conhecido como potenciômetro) conectado ao eixo de saída. Na foto acima, o potenciômetro pode ser visto do lado direito da placa de circuito. Este potenciômetro permite que o circuito de controle monitore o ângulo atual do servo motor.

Se o eixo estiver no ângulo correto, o motor é desligado. Se o circuito descobrir que o ângulo não está correto, ele girará o motor até que esteja no ângulo desejado. O eixo de saída do servo é capaz de viajar em torno de 180 graus. Normalmente, está em algum lugar na faixa de 210 graus, no entanto, varia dependendo do fabricante. Um servo normal é usado para controlar um movimento angular de 0 a 180 graus. Ele não é mecanicamente capaz de girar mais longe devido a uma parada mecânica embutida na engrenagem de saída principal.

A potência aplicada ao motor é proporcional à distância que ele precisa percorrer. Portanto, se o eixo precisar girar em uma grande distância, o motor funcionará a toda velocidade. Se precisar girar apenas um pouco, o motor funcionará a uma velocidade mais lenta. Isso é chamadoproportional control.

Como você comunica o ângulo em que o servo deve girar?

O fio de controle é usado para comunicar o ângulo. O ângulo é determinado pela duração de um pulso que é aplicado ao fio de controle. Isso é chamadoPulse Coded Modulation. O servo espera ver um pulso a cada 20 milissegundos (0,02 segundos). A duração do pulso determinará até que ponto o motor gira. Um pulso de 1,5 milissegundo, por exemplo, fará o motor girar para a posição de 90 graus (geralmente chamada de posição neutra). Se o pulso for menor que 1,5 milissegundos, o motor girará o eixo para mais perto de 0 grau. Se o pulso for maior que 1,5 milissegundos, o eixo gira mais perto de 180 graus.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × placa Arduino UNO
• 1 × servo motor
• 1 × ULN2003 conduzindo IC
• 1 × 10 KΩ Resistor

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

Código a ser anotado

Os servo motores têm três terminais - alimentação, aterramento e sinal. O fio de alimentação é normalmente vermelho e deve ser conectado ao pino de 5 V no Arduino. O fio terra é normalmente preto ou marrom e deve ser conectado a um terminal do IC ULN2003 (10 -16). Para proteger sua placa Arduino de danos, você precisará de alguns drivers IC para fazer isso. Aqui, usamos ULN2003 IC para acionar o servo motor. O pino de sinal é geralmente amarelo ou laranja e deve ser conectado ao pino número 9 do Arduino.

Conectando o potenciômetro

Um divisor de tensão / divisor de potencial são resistores em um circuito em série que escalam a tensão de saída para uma relação específica da tensão de entrada aplicada. A seguir está o diagrama do circuito -

$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

V _out é o potencial de saída, que depende da tensão de entrada aplicada (V _in ) e dos resistores (R ₁ e R ₂ ) na série. Isso significa que a corrente que flui por R ₁ também fluirá por R ₂ sem ser dividida. Na equação acima, à medida que o valor de R ₂ muda, o V _{out é} dimensionado de acordo com a tensão de entrada, V _in .

Normalmente, um potenciômetro é um divisor de potencial, que pode dimensionar a tensão de saída do circuito com base no valor do resistor variável, que é dimensionado usando o botão giratório. Ele tem três pinos: GND, Sinal e + 5V, conforme mostrado no diagrama abaixo -

Resultado

Ao alterar a posição NOP do potenciômetro, o servo motor mudará seu ângulo.

Um motor de passo ou motor de passo é um motor síncrono sem escova, que divide uma rotação completa em várias etapas. Ao contrário de um motor DC sem escovas, que gira continuamente quando uma tensão DC fixa é aplicada a ele, um motor de passo gira em ângulos de passo discretos.

Os motores de passo, portanto, são fabricados com passos por rotação de 12, 24, 72, 144, 180 e 200, resultando em ângulos de passo de 30, 15, 5, 2,5, 2 e 1,8 graus por passo. O motor de passo pode ser controlado com ou sem feedback.

Imagine um motor em um avião RC. O motor gira muito rápido em uma direção ou outra. Você pode variar a velocidade com a quantidade de potência fornecida ao motor, mas não pode dizer à hélice para parar em uma posição específica.

Agora imagine uma impressora. Existem muitas peças móveis dentro de uma impressora, incluindo motores. Um desses motores atua como alimentador de papel, girando rolos que movem o pedaço de papel conforme a tinta é impressa nele. Este motor precisa ser capaz de mover o papel a uma distância exata para poder imprimir a próxima linha de texto ou a próxima linha de uma imagem.

Há outro motor conectado a uma haste roscada que move a cabeça de impressão para frente e para trás. Novamente, essa haste roscada precisa ser movida uma quantidade exata para imprimir uma letra após a outra. É aqui que os motores de passo são úteis.

Como funciona um motor de passo?

Um motor DC normal gira apenas na direção, enquanto um motor de passo pode girar em incrementos precisos.

Os motores de passo podem girar em uma quantidade exata de graus (ou etapas) conforme desejado. Isso dá a você controle total sobre o motor, permitindo movê-lo para um local exato e mantê-lo nessa posição. Ele faz isso alimentando as bobinas dentro do motor por curtos períodos de tempo. A desvantagem é que você precisa alimentar o motor o tempo todo para mantê-lo na posição desejada.

Por ora, tudo o que você precisa saber é que, para mover um motor de passo, você diz a ele para mover um certo número de passos em uma direção ou em outra e a velocidade com que pisar nessa direção. Existem inúmeras variedades de motores de passo. Os métodos descritos aqui podem ser usados ​​para inferir como usar outros motores e drivers que não são mencionados neste tutorial. No entanto, é sempre recomendável consultar as fichas técnicas e guias dos motores e drivers específicos para os modelos que possui.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × placa Arduino UNO
• 1 × motor de passo bipolar pequeno, conforme mostrado na imagem abaixo
• 1 × LM298 IC de condução

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Código Arduino

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

Código a ser anotado

Este programa aciona um motor de passo unipolar ou bipolar. O motor é conectado aos pinos digitais 8 - 11 do Arduino.

Resultado

O motor dará uma volta em uma direção, depois uma volta na outra direção.

Neste capítulo, usaremos a Biblioteca de tons do Arduino. Não é nada além de uma biblioteca Arduino, que produz ondas quadradas de uma frequência especificada (e ciclo de trabalho de 50%) em qualquer pino Arduino. Uma duração pode ser especificada opcionalmente, caso contrário, a onda continua até que a função stop () seja chamada. O pino pode ser conectado a uma campainha piezoelétrica ou um alto-falante para reproduzir os tons.

Warning- Não conecte o pino diretamente a nenhuma entrada de áudio. A tensão é consideravelmente mais alta do que as tensões de nível de linha padrão e pode danificar as entradas da placa de som, etc. Você pode usar um divisor de tensão para reduzir a tensão.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × alto-falante de 8 ohms
• 1 × 1k resistor
• 1 × placa Arduino UNO

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Para fazer o arquivo pitches.h, clique no botão logo abaixo do ícone do monitor serial e escolha "Nova Aba", ou use Ctrl + Shift + N.

Em seguida, cole o seguinte código -

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

Salve o código fornecido acima como pitches.h

Código Arduino

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

Código a ser anotado

O código usa um arquivo extra, pitches.h. Este arquivo contém todos os valores de pitch para notas típicas. Por exemplo, NOTE_C4 é o C. NOTE_FS4 é F sustenido e assim por diante. Esta tabela de notas foi originalmente escrita por Brett Hagman, em cujo trabalho o comando tone () foi baseado. Você pode achar isso útil sempre que quiser fazer notas musicais.

Resultado

Você ouvirá as notas musicais salvas nos pitches.h. Arquivo.

Os módulos transmissor e receptor sem fio funcionam a 315 MHz. Eles podem caber facilmente em uma placa de ensaio e funcionar bem com microcontroladores para criar um link de dados sem fio muito simples. Com um par de transmissor e receptor, os módulos funcionarão apenas comunicando dados unilateral, entretanto, você precisaria de dois pares (de frequências diferentes) para atuar como um par transmissor / receptor.

Note- Esses módulos são indiscriminados e recebem bastante ruído. Tanto o transmissor quanto o receptor funcionam em frequências comuns e não possuem IDs.

Especificações do módulo receptor

• Modelo do produto - MX-05V
• Tensão de operação - DC5V
• Corrente Quiescente - 4mA
• Freqüência de recepção - 315Mhz
• Sensibilidade do receptor - -105DB
• Tamanho - 30 * 14 * 7 mm

Especificações do módulo transmissor

• Modelo do produto - MX-FS-03V
• Distância de lançamento - 20-200 metros (tensão diferente, resultados diferentes)
• Tensão de operação - 3,5-12V
• Dimensões - 19 * 19 mm
• Modo de operação - AM
• Taxa de transferência - 4KB / S
• Potência de transmissão - 10mW
• Frequência de transmissão - 315Mhz
• Uma antena externa - linha comum multi-core ou single-core de 25 cm
• Pinagem da esquerda → direita - (DADOS; V _CC ; GND)

Componentes necessários

Você precisará dos seguintes componentes -

• 2 × placa Arduino UNO
• 1 × transmissor de link Rf
• 1 × receptor Rf link

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

Esboço

Abra o software Arduino IDE em seu computador. A codificação na linguagem Arduino controlará seu circuito. Abra um novo arquivo de esboço clicando em Novo.

Note- Você deve incluir a biblioteca do teclado em seu arquivo de biblioteca do Arduino. Copie e cole o arquivo VirtualWire.lib na pasta de bibliotecas, conforme destacado na captura de tela abaixo.

Código Arduino para transmissor

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

Código a ser anotado

Este é um código simples. Primeiro, ele enviará o caractere '1' e depois de dois segundos ele enviará o caractere '0' e assim por diante.

Código Arduino para receptor

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

Código a ser anotado

O LED conectado ao pino número 5 na placa Arduino é ligado quando o caractere '1' é recebido e desligado quando o caractere '0' é recebido.

O módulo WiFi CC3000 da Texas Instruments é um pequeno pacote prateado, que finalmente traz funcionalidade WiFi acessível e fácil de usar para seus projetos do Arduino.

Ele usa SPI para comunicação (não UART!) Para que você possa enviar dados tão rápido quanto quiser ou tão devagar quanto quiser. Ele tem um sistema de interrupção adequado com pino IRQ para que você possa ter conexões assíncronas. Suporta 802.11b / g, segurança open / WEP / WPA / WPA2, TKIP e AES. Uma pilha TCP / IP embutida com uma interface "socket BSD" suporta TCP e UDP tanto no modo cliente quanto no modo servidor.

Componentes necessários

Você precisará dos seguintes componentes -

• 1 × Arduino Uno
• 1 × placa de breakout Adafruit CC3000
• Relé 1 × 5V
• 1 × diodo retificador
• 1 × LED
• 1 × 220 Ohm resistor
• 1 × placa de ensaio e alguns fios de jumper

Para este projeto, você só precisa do Arduino IDE usual, da biblioteca CC3000 da Adafruit e da biblioteca MDNS CC3000. Também usaremos a biblioteca aREST para enviar comandos para o relé via WiFi.

Procedimento

Siga o diagrama do circuito e faça as conexões conforme mostrado na imagem abaixo.

A configuração do hardware para este projeto é muito fácil.

• Conecte o pino IRQ da placa CC3000 ao pino número 3 da placa Arduino.
• VBAT para o pino 5 e CS para o pino 10.
• Conecte os pinos SPI à placa Arduino: MOSI, MISO e CLK aos pinos 11, 12 e 13, respectivamente.
• V _in está conectado ao Arduino 5V e GND ao GND.

Vamos agora conectar o relé.

Depois de colocar o relé na placa de ensaio, você pode começar a identificar as duas partes importantes em seu relé: a parte da bobina que comanda o relé e a parte da chave onde conectaremos o LED.

• Primeiro, conecte o pino número 8 da placa Arduino a um pino da bobina.
• Conecte o outro pino ao aterramento da placa Arduino.

Você também deve colocar o diodo retificador (ânodo conectado ao pino de aterramento) sobre os pinos da bobina para proteger seu circuito quando o relé estiver alternando.

• Conecte o + 5V da placa Arduino ao pino comum da chave do relé.

• Por fim, conecte um dos outros pinos da chave (geralmente, aquele que não está conectado quando o relé está desligado) ao LED em série com o resistor de 220 Ohm e conecte o outro lado do LED ao aterramento do Arduino borda.

Testando componentes individuais

Você pode testar o relé com o seguinte esboço -

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

Código a ser anotado

O código é autoexplicativo. Você pode simplesmente carregá-lo para a placa e o relé mudará de estado a cada segundo, e o LED ligará e desligará de acordo.

Adicionando conectividade WiFi

Vamos agora controlar o relé sem fio usando o chip WiFi CC3000. O software para este projeto é baseado no protocolo TCP. No entanto, para este projeto, a placa Arduino estará executando um pequeno servidor web, para que possamos “escutar” os comandos vindos do computador. Primeiro cuidaremos do esboço do Arduino e, em seguida, veremos como escrever o código do lado do servidor e criar uma interface agradável.

Primeiro, o esboço do Arduino. O objetivo aqui é conectar-se à sua rede WiFi, criar um servidor web, verificar se há conexões TCP de entrada e, em seguida, alterar o estado do relé de acordo.

Partes importantes do código

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Você precisa definir dentro do código o que é específico para sua configuração, ou seja, o nome e a senha do Wi-Fi e a porta para comunicações TCP (usamos 80 aqui).

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

Podemos então criar a instância CC3000, servidor e instância aREST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

Na parte setup () do sketch, podemos agora conectar o chip CC3000 à rede -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

Como o computador saberá para onde enviar os dados? Uma maneira seria executar o esboço uma vez, obter o endereço IP da placa CC3000 e modificar o código do servidor novamente. No entanto, podemos fazer melhor, e é aí que entra a biblioteca CC3000 MDNS. Iremos atribuir um nome fixo à nossa placa CC3000 com esta biblioteca, para que possamos escrever esse nome diretamente no código do servidor.

Isso é feito com o seguinte trecho de código -

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

Também precisamos ouvir as conexões de entrada.

restServer.begin();

A seguir, codificaremos a função loop () do esboço que será executada continuamente. Primeiro, temos que atualizar o servidor mDNS.

mdns.update();

O servidor em execução na placa Arduino aguardará as conexões de entrada e tratará das solicitações.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Agora é muito fácil testar os projetos via WiFi. Certifique-se de atualizar o esboço com seu próprio nome de WiFi e senha e carregue o esboço para a placa Arduino. Abra seu monitor serial IDE Arduino e procure o endereço IP de sua placa.

Vamos supor para o resto aqui que é algo como 192.168.1.103.

Em seguida, basta ir para o seu navegador favorito e digitar -

192.168.1.103/digital/8/1

Você deve ver que o seu relé liga automaticamente.

Construindo a Interface de Relé

Agora iremos codificar a interface do projeto. Haverá duas partes aqui: um arquivo HTML contendo a interface e um arquivo Javascript do lado do cliente para lidar com os cliques na interface. A interface aqui é baseada noaREST.js projeto, que foi feito para controlar facilmente dispositivos Wi-Fi de seu computador.

Vamos primeiro ver o arquivo HTML, chamado interface.html. A primeira parte consiste em importar todas as bibliotecas necessárias para a interface -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

Em seguida, definimos dois botões dentro da interface, um para ligar o relé e outro para desligá-lo novamente.

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

Agora, também precisamos de um arquivo Javascript do lado do cliente para lidar com os cliques nos botões. Também criaremos um dispositivo que vincularemos ao nome mDNS de nosso dispositivo Arduino. Se você alterou isso no código do Arduino, também precisará modificá-lo aqui.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

O código completo para este projeto pode ser encontrado no GitHubrepositório. Vá para a pasta de interface e simplesmente abra o arquivo HTML com seu navegador favorito. Você deve ver algo semelhante dentro do seu navegador -

Tente clicar em um botão na interface da web; deve mudar o estado do relé quase instantaneamente.

Se você conseguiu fazer funcionar, bravo! Você acabou de construir um interruptor de luz controlado por Wi-Fi. Claro, você pode controlar muito mais do que luzes com este projeto. Apenas certifique-se de que seu relé suporta a energia necessária para o dispositivo que você deseja controlar e você está pronto para prosseguir.