Arduino Tutorial - IR Universal Remote Control

Introduction: Arduino Tutorial - IR Universal Remote Control

About: Este é um canal para homemakers e DIY onde vai encontrar tutoriais úteis acerca de Electrónica, Arduíno, Robótica e Impressão 3D. Estes têm explicações simples e práticas que podem ser utilizadas para concre...

Olá pessoal bem vindos a mais um tutorial sobre o Arduino, desta vez vamos explicar o funcionamento e as características de um tipo de Arduino ainda não discutido nos nossos tutoriais. O Arduino MEGA é um dos Arduino com mais pinos de sinal digital e analógico o que o torna bastante versátil e essencial em grandes projectos.

Neste tutorial apesar de não utilizar-mos todo o potencial do Arduino MEGA, vamos explicar uma montagem onde será possível copiar as funcionalidades de vários controlos remotos, para assim criar um controlo remoto universal. Tudo isto utilizando um módulo receptor e emissor IR, já o Arduino MEGA terá a função de copiar e guardar na sua memória interna os códigos IR enviados pelos controlos remotos, para assim posteriormente utiliza-los para controlar os nossos vários equipamentos, como a TV, leitores DVD ou até mesmo ar condicionado com apenas um controlo remoto.

A placa de Arduino MEGA é constituído por:

Um micro-controlador ATmega2560, que dispõem de 256Kb de "FLASH Memory" ou EEPROM e 8Kb de RAM.

Uma ligação USB com a função de ligar o Arduino ao computador, servindo tanto para carregar o código como para alimentar electricamente a própria placa.

Uma ligação de alimentação exterior e vários pinos de alimentação que permite distribuir diversos valores de tensão, podendo estes serem utilizados para alimentar electricamente os componentes dos nossos projectos.

Tem também 54 pinos de sinal digital que podem ser programados como entradas ou saídas, onde 15 destes podem ter a funcionalidade de PWM "Pulse Width Modulation", já o pino 13 está ligado um pequeno LED designado por L (Ver imagem acima).

Alem deste tipo de pinos o Arduino MEGA contem mais 16 pinos de entrada de sinal analógico, que podem ser programados para receber informação de vários tipos de sensores de sinal analógico.

Por fim na placa encontra-se instalado um pequeno botão de pressão designado de "Reset", tendo a função de reiniciar o equipamento.

Modulo emissor e receptor IR:

O módulo emissor IR utilizado na montagem é constituído por um LED muito idêntico fisicamente a um LED comum, no entanto, este não imite luz visível mas sim luz Infravermelha ou IR, sendo este tipo de LED muito utilizado em placas de controlo remoto dos equipamentos, podendo ser facilmente visíveis na parte frontal desses controles remotos (Ver imagem acima).

Já o módulo receptor IR utiliza um sensor que também pode ter uma aparência idêntica a um LED comum, no entanto, a principal diferença física é o facto deste ter 3 contactos e não apenas 2 como o LED. Isto porque o seu funcionamento é muito idêntico a um transístor, permitindo a passagem de corrente entre o pinos de entrada e o de saída, apenas se estiver a receber sinais IR. (Ver imagem acima).

Hoje em dia os controles remotos por Infravermelhos estão em toda parte, basta procurar-los pela casa principalmente na sala onde utilizamos os vários equipamentos de vídeo, de áudio, sistemas de climatização e sistemas de iluminação.

Como o controle remoto por IR funciona?

Muito provavelmente, possui-mos algum controlo remoto que já não utilizamos e mesmo aqueles que ainda têm utilização possuem vários botões que não sem qualquer função, pois foram criados apenas para controlar equipamentos adicionais que nem sequer possuímos.

Desta forma podemos utilizar esses controles remotos ou apenas os seus botões sem funcionalidade, de forma a controlar pequenos projectos constituídos por um Arduino e um módulo receptor IR, este ultimo componente permite descodificar o sinal IR emitido pelos controlos remotos sendo assim possível atribuída uma qualquer funcionalidade ao código IR atribuído.

Alem disto também podemos criar o nosso próprio controlo remoto personalizado, ou seja, um controle remoto mais simples e que permita controlar mais que um equipamento. Para isso também será necessário um Arduino, um módulo receptor, mas agora também será necessário um módulo emissor IR para voltar a emitir essa funcionalidade para os equipamentos.

Com este tipo de montagem será então possível copiar e guardar os códigos IR recebidos dos vários controlos remotos na memória interna do Arduino, atribuindo depois em cada um dos botões do novo controlo remoto um desses código de funcionalidade guardados, sendo depois novamente emitido controlando finalmente o equipamento desejado.

Como os controlos remotos utilizam um sistema de comunicação por infravermelhos típico são necessários um emissor e um receptor de radiação infravermelha. Essa radiação infravermelha é uma forma de luz idêntica à luz visíveis que temos em nosso redor, isto deve-se ao facto de estas terem uma frequência ou comprimento de onda diferentes.

Esta característica torna difícil visualizar e verificar se o nosso controle remoto está a funcionar, no entanto existem formas simples de o fazer bastando ligar a câmara do nosso "Smartphone" e aponta-la para o seu emissor IR enquanto este está a emitir.

Sendo a este tipo de comunicação através de luz é condição essencial que o receptor esteja em linha directa de visão com o emissor, não sendo possível comunicar através de paredes ou outro tipo material, como por exemplo os sistema de rádio, Wi-Fi ou Bluetooth. Desta forma tanto o LED emissor como o receptor são facilmente encontrados na parte frontal dos equipamentos podendo por vezes estarem dissimulados por motivos estéticos(Ver imagem acima).

A forma de estes enviarem informação através de sinais de luz infravermelha é através de um conjunto de pulsos, este pulsos serão recebido então pelo dispositivo receptor que se encontra no equipamento que queremos controlar, por exemplo uma TV. Esta forma de enviar informação através pulsos é muito importante, pois de outra forma não seria possível controlar as tantas funcionalidades através dos vários botões dos nossos controlos remotos.

Assim sempre que carregamos num dos seus botões do controlo remoto este envia um padrão único de pulsos que ao ser recebido é descodificado e decifrada a sua funcionalidade, sendo assim realizada essa funcionalidade pelo equipamento, como por exemplo aumentar ou baixar o volume ou simplesmente mudar de canal.

A luz solar ou a iluminação interna da nossa casa também são uma fonte de emissão de luz infravermelha e isto pode interferir com o controlo dos nossos equipamentos, dificultando assim o seu funcionamento. Uma das formas de diminuir essa interferência é utilizando dispositivos de emissão e recepção de infravermelhos nos equipamentos que utilizam apenas uma faixa da frequência dos infravermelhos tendo esta normalmente uma modulação de 38kHz. Desta forma os receptores de infravermelho apenas reagem à luz infravermelha com essa modulação ignorando a restante.

A radiação infravermelha cobre uma gama no espectro de luz entre os 700nm e os 10000nm, no entanto, a maioria dos equipamentos opera numa pequena faixa dessa gama, entre os 850nm a 940nm, logo a probabilidade de interferências será muito menor (Ver Imagem acima).

Outra forma de diminuir as interferências é a utilização do tais conjuntos de pulsos, que quando descodificados produzem um código especifico. Cada fabricante deste tipo de equipamentos podem utilizar códigos diferentes para seus controlos remotos como também códigos diferentes para cada tipo de equipamento dentro do mesmo fabricante.

Para que possa ser mais fácil seleccionar os códigos, estes normalmente são compartilhados entre os fabricantes, portanto pode existir a possibilidade de 2 controlos remotos entrarem em conflito um com o outro.

Para podermos encontrar esses códigos de fabricante poderemos utilizar a página IRDB, sendo este um óptimo recurso, aqui encontra-se uma grande base de dados com os códigos para a maioria dos equipamentos que utilizamos.

Caso queiram saber mais sobre o emissor ou o sensor receptor IR, vejam as suas respectivas datasheet (Ver ficheiros abaixo) e alem destes vejam também as especificações detalhadas do Arduino MEGA, através da seguinte ligação https://store.arduino.cc/mega-2560-r3.

Teacher Notes

Teachers! Did you use this instructable in your classroom?
Add a Teacher Note to share how you incorporated it into your lesson.

Step 1: Montagem

Vamos então começar como sempre pela "Breadboard" e o Arduino MEGA onde serão colocados todos os restantes componentes e ligações necessárias à nossa montagem (Ver montagem acima).

Material necessário:

  • 1x Arduino MEGA;
  • 1x Cabo USB;
  • 1x Breadboard;
  • 1x Modulo Emissor IR KY-005;
  • 1x Modulo Receptor IR KY-002 ;
  • 3x Botão (Push Button);
  • 3x Resistência 1KΩ;
  • 1x TV;
  • 1x Controle remoto.

Instalação dos módulos emissor e receptor IR:

Os módulos emissor e receptor IR são muito fáceis de instalar na nossa montagem, pois apenas têm cada um 3 pinos de ligação, 2 dos quais são os pinos de alimentação VCC e GND, por ultimo o pino de saída e entrada de sinal.

A diferença entre estes 2 módulos é o seu funcionamento, pois um tem como função receber o sinal eléctrico vindo do Arduino e converte-lo em sinais infravermelhos, este módulo será então o módulo emissor podendo ser encontrado em todos os nosso controlos remotos.

Já o módulo receptor tem uma função inversa do módulo anterior, pois este irá captar os sinais infravermelhos e converte-los novamente em sinais eléctricos, para que isto aconteça é necessário um receptor adequado, sendo normalmente utilizado o sensor TL1838 (Ver datasheet acima).

Para controlar vários dos equipamentos electrónicos de nossa casa teremos que utilizar mais que apenas estes módulos, assim será necessário também um Arduino MEGA que será programado de forma a que seja possível descodificar os códigos IR utilizados em cada um dos nossos equipamentos, não esquecendo que cada um destes equipamentos tem inúmeras funcionalidades, como também que cada um destes equipamentos poderá utilizar uma modulação de sinal especifica.

Para facilitar essa programação será utilizada a biblioteca IRremote.h, esta biblioteca utiliza apenas os pinos de sinal digital do Arduino, permitindo assim escolher qual o pino que irá receber a informação vinda do módulo receptor IR da nossa montagem.

No entanto, isto já não é possível para o pino que irá enviar a informação para o módulo emissor IR, sendo este sempre um pino especifico e não alterável. Alem desta particularidade este pino pode ser diferente nos vários modelos de Arduino, entre os já falados nos nossos tutoriais estão o Arduino UNO e Arduino NANO sendo esta função no pino D3, já no Arduino MEGA que é o Arduino que estamos a utilizar nesta montagem será o pino D9, por ultimo o Arduino MICRO não tem esta função em nenhum dos seus pinos não sendo possível assim realizar esta montagem (Ver imagem acima).

Instalação dos Push Button:

Depois da montagem dos módulos emissor e receptor colocamos na "Breadboard" 3 botões do tipo "Push Button" e as respectivas resistências de 1KΩ criando assim um muito simples controlo remoto, estes botões são todos ligados aos pinos de sinal digital do Arduino nomeadamente D11, D12 e D13.

Porém um destes botões terá uma função especial ficando designado com a letra M, que indica a função de memorização ou gravação do código IR na memória do Arduino. Assim este ao ser premido irá ler o código IR enviado pelo controlo remoto a clonar através do módulo receptor e de seguida guarda-lo na memória interna do Arduino MEGA, realizando assim uma cópia da funcionalidade do botão desse controlo remoto.

Já os outros 2 botões terão o símbolo da respectiva funcionalidade que iremos clonar, que neste caso será o símbolo (+) e (–) , pois terão as funcionalidades de aumentar e diminuir o volume de som da nossa TV. Estes serão ligados também aos pinos de sinal digital ficando o botão (+) ligado no pino D12 e o botão (–) no pino D11.

Step 2: Codigo

Como para criar o nosso controlo remoto é necessário modular o sinal infravermelho, teremos de ter um sistema codificador que converte as funcionalidades de cada um dos seus botões em códigos binários que irão ser emitidos através no módulo emissor IR. Estes códigos IR ao serem recebidos pelo módulo receptor IR irão então converter esses códigos binários na activação da funcionalidade seleccionada.

Utilizando a nossa montagem também poderemos testar cada passo deste processo, assim podemos carregar um pequeno código que permite receber o sinal infravermelho de um qualquer controlo remoto e verificar os códigos IR utilizados. Este código utiliza a mesma biblioteca IRremote.h que irá descodificar esse sinal representando no Monitor Serial o seu respectivo código, isto através da função Serial.print() (Ver ficheiro abaixo).

Este código poderá ser representado de várias formas através da função Serial.print() alterando apenas o formato da informação, assim o mesmo código IR pode ser representado em binário (BIN), octal (OCT), hexadecimal (HEX) e decimal ( ), sem indicação do formato. Estes códigos IR são originalmente como em todos os circuitos electrónicos representados em binário, mas está convencionado neste tipo de sistemas a representação hexadecimal para que seja mais facilmente compreendido (Ver imagem acima).

#include <IRremote.h>	//Importar a IRremote library.

int Pino_Receptor = 8;	//Variável para o pino do receptor IR.
IRrecv Receptor_IR(Pino_Receptor);	//Definir o pino de recepção de sinal.
decode_results Leitura_Codigo;	//Variável para representar o código do sinal.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
	//Iniciar a  Communication Serial a 9600b/s:
	Serial.begin(9600);

	//Iniciar a função de recepção de sinal IR:
	Receptor_IR.enableIRIn();
	//Escreve no Monitor Serial:
	Serial.println("Recepção de sinal IR iniciada...");
}
//Correr a função LOOP repetidamente:
void loop() {
	//Verifica se o receptor IR capta sinal:
	if (Receptor_IR.decode(&Leitura_Codigo)) {
		//Escreve no Monitor Serial a representação do código em hexadecimal:
		Serial.println(Leitura_Codigo.value, HEX);
		//Termina a captação de sinal IR.
		Receptor_IR.resume();
	}
	//Tempo decorrido entre leituras.
	delay(100);
}

Como cada um dos fabricantes adopta códigos de sinal já convencionados e estabelecidos podem existir mesmo assim alguns conflitos entre equipamento, logo os fabricantes separaram os equipamentos em classes ou tipos, escolhendo modulações de sinal diferentes para cada classe ou tipo de equipamento, sendo assim mais difícil que os nossos equipamento entrem em conflito (Ver imagem acima).

Devido a isto, alem de termos de saber qual o código IR especifico para uma funcionalidade do controlo remoto, também será necessário saber qual o tipo de modulação está a ser utilizada. Para visualizar e verificar esta modulação basta carregar este pequeno código no Arduino da montagem, ficando assim representado o código da funcionalidade como também o tipo de modulação utilizada, No entanto, teremos de ter em concideração que a biblioteca IRremote.h apenas tem na sua base de dados 15 tipos de modulação (Ver ficheiro abaixo).

#include <IRremote.h>	//Importar a IRremote library.

int Pino_Receptor = 8;	//Variável para o pino do receptor IR.
IRrecv Receptor_IR(Pino_Receptor);	//Definir o pino de recepção de sinal.
decode_results Leitura_Codigo;	//Variável para representar o código do sinal.
//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){
	//Iniciar a  Communication Serial a 9600b/s:
	Serial.begin(9600);
	
	//Iniciar a função de recepção de sinal IR:
	Receptor_IR.enableIRIn();
	//Escreve no Monitor Serial:
	Serial.println("Recepção de sinal IR iniciada...");
}
//Correr a função LOOP repetidamente:
void loop() {
	//Verifica se o receptor IR capta sinal:
	if (Receptor_IR.decode(&Leitura_Codigo)) {
		//Escreve no Monitor Serial a representação do código em hexadecimal:
		Serial.println(Leitura_Codigo.value, HEX);
		
		//Define e indica qual o protocolo IR recebido:
		switch (Leitura_Codigo.decode_type) {
		case NEC:
			//Escreve no Monitor Serial:
			Serial.println("NEC");
			break;
		case SONY:
			//Escreve no Monitor Serial:
			Serial.println("SONY");
			break;
		case RC5:
			//Escreve no Monitor Serial:
			Serial.println("RC5");
			break;
		case RC6:
			//Escreve no Monitor Serial:
			Serial.println("RC6");
			break;
		case DISH:
			//Escreve no Monitor Serial:
			Serial.println("DISH");
			break;
		case SHARP:
			//Escreve no Monitor Serial:
			Serial.println("SHARP");
			break;
		case JVC:
			//Escreve no Monitor Serial:
			Serial.println("JVC");
			break;
		case SANYO:
			//Escreve no Monitor Serial:
			Serial.println("SANYO");
			break;
		case MITSUBISHI:
			//Escreve no Monitor Serial:
			Serial.println("MITSUBISHI");
			break;
		case SAMSUNG:
			//Escreve no Monitor Serial:
			Serial.println("SAMSUNG");
			break;
		case LG:
			//Escreve no Monitor Serial:
			Serial.println("LG");
			break;
		case WHYNTER:
			//Escreve no Monitor Serial:
			Serial.println("WHYNTER");
			break;
		case AIWA_RC_T501:
			//Escreve no Monitor Serial:
			Serial.println("AIWA_RC_T501");
			break;
		case PANASONIC:
			//Escreve no Monitor Serial:
			Serial.println("PANASONIC");
			break;
		case DENON:
			//Escreve no Monitor Serial:
			Serial.println("DENON");
			break;
		default:
		case UNKNOWN:
			//Escreve no Monitor Serial:
			Serial.println("UNKNOWN");
			break;
		}
	//Termina a captação de sinal IR.
	Receptor_IR.resume();
	}
}

Depois de sabermos quais os códigos IR recebidos e qual a sua modulação vamos agora testar o envio destes através da montagem controlando assim os nossos equipamentos. Para isso carregamos agora o código seguinte na nossa montagem, onde colocamos o código IR recebido correspondente à funcionalidade que desejamos controlar no equipamento e seleccionamos a sua modulação entre as possíveis que esta biblioteca possui. (Ver ficheiro abaixo).

Agora teremos de ter em atenção a 2 factores importantes, em primeiro lugar é na variável Codigo que iremos colocar o respectivo código IR, este terá de ser copiado do Monitor Serial utilizando um dos códigos anteriores explicados. Esta variável Codigo terá de ser obrigatoriamente do tipo long unsigned int, pois não é possível colocar códigos como tantos bits na nossa já conhecida variável do tipo int, pois esta apenas permite colocar valores até 16bits, no entanto, se utilizarmos uma variável do tipo long unsigned int já será possível carregar valores até 32bits.

Estes códigos IR poderá ter mais ou menos bits consoante o tipo de modulação utilizada, assim depois na condição para o controlo dos botões da montagem teremos de ter atenção ao numero de bits que esta comporta.

#include <IRremote.h>	//Importar a IRremote library.

long unsigned int Codigo = 0xFFFFFFFF;	//<<< Substituir código aqui.
//Colocar um código com um destes formatos relativamente ao tipo de protocolo:
                  //32bits - 0xFFFFFFFF;
                  //20bits - 0xFFFFF
                  //16bits - 0xFFFF
                  //15bits - 0xFFF
                  //12bits - 0xFFF

int Botao = 11; //Variável para selecção do pino de entrada.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
  //Definição do tipo de pino (Saída ou Entrada):
  pinMode(Botao, INPUT);
}
//Correr a função LOOP repetidamente:
void loop() {
	//Condição para envio do código:
	if (digitalRead(Botao) == HIGH) {
		//Escolher qual o tipo de protocolo que queremos utilizar na lista:
    			//Emissor_IR.sendNEC(Codigo, 32);
			//Emissor_IR.sendSony(Codigo, 12);
			//Emissor_IR.sendRC5(Codigo, 12);
			//Emissor_IR.sendRC6(Codigo, 20);
			//Emissor_IR.sendDISH(Codigo, 16);
			//Emissor_IR.sendSharp(Codigo, 15);
			//Emissor_IR.sendSAMSUNG(Codigo, 32);
			//Emissor_IR.sendLG(Codigo, 28);
			//Emissor_IR.sendWhynter(Codigo, 32);
			//Emissor_IR.sendDenon(Codigo, 32);
		
		//Emissão do sinal IR:
		Emissor_IR.sendNEC(Codigo, 32);
		//Tempo entre repetição do envio de sinal IR.
		delay(150);
	}
	//Pausa entre a emissão de sinal IR.
	delay(1000);
}

Como descrito na introdução a este tutorial, o objectivo da montagem será gravar na EEPROM do Arduino tantos os códigos IR como as suas modulações. Isto permitirá que seja apenas necessário copiar uma única vez estas informações, ou seja, mesmo que o Arduino seja desligado ou realizado um "Reset" este manterá estas informações na sua memoria e prontas a serem utilizadas.

Contudo a memória dos Arduino como já mencionado em outros tutoriais, apenas permite armazenar até 8bits de informação em cada um dos seus endereços e como os códigos de funcionalidade podem ser modulados entre 12bits e 32bits, sendo substancialmente informação a mais para guardar em apenas um endereço.

Assim será necessário utilizar uma forma de fragmentar os nossos códigos IR em partes de 8bits, para isso utilizamos 4 variáveis do tipo byte. Este tipo de variável é o mais indicado para a gravação na EEPROM do Arduino ficando cada fragmento de 8bits numa dessas variáveis.

Para seleccionar cada um desses fragmentos vamos utilizar os operadores Bitwise, este tipo de operadores são operadores de deslocamento Left Shift (<<) e Right Shift(>>) e permitem o deslocamento da leitura dos bits para a esquerda ou direita respectivamente, dependendo do numero de posições especificado.

Logo utilizando o operador Left shift << no valor da variável Codigo e colocando nas variáveis do tipo byte os valores de 8bits (0xFF) os valores obtidos das posições seleccionadas de 24, 16, 8 e 0, obtemos então os 4 fragmentos do código IR prontos a serem gravados na EEPROM (Ver cálculos acima).

long unsigned int Codigo; //Variável para captação do código IR:

//Variáveis para fragmentar o código de 32bits em partes de 8bits:
byte Byte_1;
byte Byte_2;
byte Byte_3;
byte Byte_4;

//Correr a função LOOP repetidamente:
void loop() {
	//Fragmentar o código de 32bits em partes de 8bits:
	Byte_1 = (Codigo >> 24) & 0xFF;
	Byte_2 = (Codigo >> 16) & 0xFF;
	Byte_3 = (Codigo >> 8) & 0xFF;
	Byte_4 = (Codigo >> 0) & 0xFF; //ou (Codigo) & 0xFF; <<< Ambas as expressões são válidas.

	//Gravar na EEPROM um fragmento do código recebido:
	EEPROM.write(Endereco_EEPROM, Byte_1);
	
	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	//Gravar na EEPROM um fragmento do código recebido:
	EEPROM.write(Endereco_EEPROM, Byte_2);
	
	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	//Gravar na EEPROM um fragmento do código recebido:
	EEPROM.write(Endereco_EEPROM, Byte_3);
	
	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	//Gravar na EEPROM um fragmento do código recebido:
	EEPROM.write(Endereco_EEPROM, Byte_4);
}

Para voltar a juntar todos estes fragmentos formando novamente o código IR completo, teremos de utilizar o operador Bitwise mas agora com a operação inversa. Assim somamos em primeiro lugar cada um dos 4 fragmentos do código de 8bits guardados na EEPROM do Arduino através do operador Right Shift (>>), criando 2 partes do nosso código IR com 16bits, por fim voltamos a somar estas 2 partes obtendo novamente desta forma o código IR completo com até 32bits (Ver cálculos acima).

long unsigned int Codigo;	//Variável para captação do código IR:

//Variáveis para gravação e leitura do código e protocolo na EEPROM:
long unsigned int Parte_1;
long unsigned int Parte_2;
long unsigned int Final;

//Variáveis para fragmentar o código de 32bits em partes de 8bits:
byte Byte_1;
byte Byte_2;
byte Byte_3;
byte Byte_4;

//Correr a função LOOP repetidamente:
void loop() {

	//Lê da EEPROM um fragmento do código:
	Byte_1 = EEPROM.read(Endereco_EEPROM);
	
	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	
	//Lê da EEPROM um fragmento do código:
	Byte_2 = EEPROM.read(Endereco_EEPROM);
	
	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	
	//Lê da EEPROM um fragmento do código:
	Byte_3 = EEPROM.read(Endereco_EEPROM);

	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	
	//Lê da EEPROM um fragmento do código:
	Byte_4 = EEPROM.read(Endereco_EEPROM);

	//Altera o endereço da EEPROM:
	Endereco_EEPROM = ++Endereco_EEPROM;
	
	//Junta os fragmento do código de 8bits em uma parte de 16bits:
	Parte_1 = (((Byte_2 << 0) & 0xFF) + ((Byte_1 << 8) & 0xFFFF));
	//Junta os fragmento do código de 8bits em uma parte de 16bits:
	Parte_2 = (((Byte_4 << 0) & 0xFF) + ((Byte_3 << 8) & 0xFFFF));
	//Junta os fragmento do código de 16bits no código final de 32bits:
	Final = (Parte_1 << 16) + Parte_2;
}

Agora basta seleccionarmos novamente qual tipo de protocolo utilizado neste código, voltando este código a ser modulado e enviado pelo nosso módulo emissor para o equipamento através de infravermelhos através da função IR.send() da biblioteca IRremote.h.

Devido ao numero de linhas do código para o Arduino deixamos-vos em baixo o ficheiro com o código do Arduino completo para esta montagem, pois este tutorial já vai um pouco longo e sabemos como vocês querem colocar-lo na prática.

Caso queiram saber mais ou tenham dúvidas sobre estas e outras referências no código, vejam a sua explicação detalhada no site oficial do Arduino, através da ligação https://www.arduino.cc/en/Reference/HomePage.

Procurem também os nossos tutoriais acerca do Arduino, onde explicamos diversas montagens como também o funcionamento dos seus componentes e já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.

Be the First to Share

    Recommendations

    • Magnets Challenge

      Magnets Challenge
    • Raspberry Pi Contest 2020

      Raspberry Pi Contest 2020
    • Wearables Contest

      Wearables Contest

    Discussions