Wired remote control ballu on arduino. Transmitting data in the infrared range using Arduino. We control the LED using the IR remote control

The issue of remote or remote control of electrical equipment has always been and will be relevant, regardless of whether there are automation tools in the system or not. To organize remote control, it does not matter whether it is needed; it all depends on the necessary functions assigned to the controlled device. From this article you will learn general information about methods of remote control of a microcontroller.

Kinds

There are two main types of remote communication:

Wired. When control of actuators located in one room (or not in one room) is carried out from a dispatch console or from a push-button station located in another place. In this case, an electrical wire connection is provided between control circuits and actuators (relays, contactors that turn on mechanisms such as motors or systems, for example, lighting).

Wireless. This option does not require electrical connection of control and executive circuits. In wireless circuits there are two devices: a transmitter or remote control (RC) and a receiver, which is part of the controlled circuit. Wireless control in turn, it is distributed in two versions:

By optical signal. There are such systems in every home, so you control the operation of the TV, air conditioner and other household appliances.

By radio signal. There are already a number of options: Bluetooth, ZigBee, Wi-Fi, 433 MHz receivers and transmitters and other variations on this theme.

It is worth noting that with modern technical means you can control the microcontroller both from a remote control and via the Internet local network or with access from anywhere in the world.

IR remote control

Let's start with the simplest and most classic version. Control the device by transmitting a code from a sequence of flickering IR LEDs to an opto-receiver installed on the device. It is worth noting that the IR spectrum is not visible to the human eye, but most photo and video cameras see it.

Since most cameras see IR radiation, you can check. To do this, simply point the remote control so that the emitter faces the camera and press the buttons. Typically, a white glow with a purple tint is visible on the screen.

This type of control has an obvious drawback - you must point the remote control towards the receiver. And if the batteries in the remote control are dead, then you still have to aim, since the activations become less and less frequent.

The advantages are simplicity, high maintainability, both transmitter and receiver. You can find parts by disassembling broken remote controls and TVs in order to use them in your own projects.

A typical sensor looks like this. Since an optical signal is being received, it is necessary to exclude triggers from extraneous light sources, such as the sun, lighting lamps, and others. It is also worth noting that the IR signal is received mainly at a frequency of 38 kHz.

Here are the characteristics of one of the IR sensors:

carrier frequency: 38 kHz;

supply voltage: 2.7 - 5.5 V;

current consumption: 50 µA.

And its connection diagram:

Any remote control with a similar operating principle can be used; remote controls from:

TVs;

DVD players;

radio tape recorder;

from modern lighting devices, such as smart chandeliers and LED strips And so on.

Here is an example of using such a sensor:

In order for the microcontroller, in our case Arduino, to understand the signal from the sensor, you need to use the IRremote.h library. For an example of how to read a signal from a sensor, we provide code for recognizing them by reading the microcontroller serial port from the environment Arduino IDE:

#include "IRremote.h" // connect the library for working with the IR signal.

decode_results results;

Serial.begin(9600); // set the speed of the COM port

Serial.println(results.value, HEX); // print data

As a result, when you flash the Arduino and start shining the remote control at the receiver, we will see the following picture in the serial port monitor:

These are the codes that the buttons send in hexadecimal. This way, you can find out which button on the remote control sends which code, so there are no specific requirements for the remote control you use, because you can recognize and bind any one. By the way, this is an idea for a project for a learning universal remote control; these were sold before. But now, in the age of the Internet, the amount of equipment controlled in this way is decreasing every year.

And using this code you can recognize signals and control the load:

#include "IRremote.h"

IRrecv irrecv(2); // indicate the pin to which the receiver is connected

decode_results results;

irrecv.enableIRIn(); // start receiving

if (irrecv.decode(&results)) ( // if the data arrived

switch (results.value) (

digitalWrite(13, HIGH);

digitalWrite(13, LOW);

irrecv.resume(); // accept the following command

The main thing in the code is recognition through the Switch function, sometimes called a “switchcase”. It is analogous to if branches, but has a more beautiful form for perception. Case - these are options, “if such a code arrives, then...” In the code, pin 13 is controlled for certain signals. Let me remind you that the built-in LED on the ARDUINO board is connected to pin 13, i.e. the author of the code controlled the LED.

You can control anything using high or low level digital pin, through a power transistor (which we discussed in two articles earlier) with a DC load, or through a triac and driver for it with a DC load, you can also use relays and contactors, in general, a whole field of imagination.

For use with microcontrollers, transmitters with operating frequencies of 433 MHz or 315 MHz are common; there may be other frequencies, depending on the specific board, but these are the most common. The system consists of two nodes - a receiver and a transmitter, which is logical.

In the picture, the transmitter is shown at the top right, and the receiver is at the bottom left. Their search name: Radio module 433MHz, MX-05V/XD-RF-5V (receiver and transmitter).

The pinout, as is often the case in modules, is written on the board, like the transmitter:

It’s not so obvious at the receiver, because Data is on printed circuit board written above two pins, in fact one of them is not used.

As an example, we provide a diagram and code for turning on an LED from one Arduino board connected to another similar board, wirelessly. The receiver and transmitter are connected identically to both boards:

First, let's write a transmitter program:

#include

RCSwitch mySwitch = RCSwitch(); // create an object to work with front-com

void setup() (

mySwitch. enableTransmit(2); // tell the program which pin the information channel is connected to

void loop() (

mySwitch.send(B0100, 4);

delay(1000);

mySwitch.send(B1000, 4);

delay(1000);

}

The transmitter can transmit binary code, but its values ​​can be written in decimal form.

mySwitch.send(B0100, 4);

mySwitch.send(B1000, 4);

these are the transfer commands, mySwitch is the name of the transmitter that we specified at the beginning of the code, and send is the transfer command. The arguments to this function are:

Transmittername.send(value, size of a packet of pulses sent on the air);

B1000 - the symbol B means binary, it could be written as the number 8, i.e. in decimal notation. Another option was to write “1000” as a string (in quotes).

#include

RCSwitch mySwitch = RCSwitch();

pinMode(3, OUTPUT);

mySwitch.enableReceive(0);

if(mySwitch.available())(

int value = mySwitch.getReceivedValue();

if(value == B1000)

digitalWrite(3, HIGH);

else if(value == B0100)

digitalWrite(3, LOW);

mySwitch.resetAvailable();

Here we declare that the Value variable is stored accepted value in the line mySwitch.getReceivedValue(). And the fact that the receiver is connected to the 2nd pin is described here mySwiitch.enableReceive(0).

The rest of the code is elementary, if a signal of 0100 is received, then we move pin number 3 to a high state (log. one), and if 1000, then to a low state (log. zero).

Interesting:

In the line mySwitch.enableTransmit(0) we tell the program that a receiver is connected to the 2nd pin and the receiving mode is turned on. The most attentive ones have noticed that the argument of this method is not the pin number “2”, but “0”, the fact is that the enableTransmit(number) method takes not the pin number, but the interrupt number, and in atmega328, which is set to , on the second pin (PortD pin PD2) there is an interrupt with number zero. You can see this in the Atmega pinout applicable to the Arduino board; the pin numbers are written in pink squares.

This method of transmission and reception is very simple and cheap; a pair of receiver and transmitter costs about $1.5 at the time of writing.

Wi-Fi, Adruino and ESP8266

Let's begin with ESP8266 is a microcontroller with hardware Wi-Fi support, it is sold both as a separate chip and soldered on a board, like an Arduino. It has a 32-bit core and is programmable via a serial port (UART).

Boards usually have 2 or more free GPIO pins and there are always pins for firmware; this must be done via a USB to serial adapter. Controlled by AT commands, full list commands can be found on the official ESP8266 website and on github.

There are more interesting option, NodeMCU boards, they have the ability to flash firmware via USB, because The USB-UART converter is already on the board, usually made on a CP2102 chip. Node MCU is firmware, something like operating system, a project based on the Lua scripting language.

The firmware can execute Lua scripts, either by receiving them over the serial port or by reproducing algorithms stored in Flash memory.

By the way, it has its own file system, although it does not have directories, i.e. only files without folders. Not only scripts, but also various data can be stored in memory, i.e. the board can store information recorded, for example, from sensors.

The board works with the following interfaces:

It has a whole host of functions:

encryption module;

task Manager;

real time clock;

Internet clock synchronization protocol SNTP;

• ADC channel (one);

  play audio files;

  generate a PWM signal at the outputs (up to 6);

  use sockets, there is support for FatFS, that is, you can connect SD cards and so on.

Here is a short list of what the board can work with:

ADXL345 accelerometers;

magnetometers HMC5883L;

L3G4200D gyros;

temperature and humidity sensors AM2320, DHT11, DHT21, DHT22, DHT33, DHT44;

temperature, humidity sensors, atmospheric pressure BME280;

temperature, atmospheric pressure sensors BMP085;

many displays operating on I2C, SPI buses. With the ability to work with different fonts;

smart LEDs and LED controllers - WS2812, tm1829, WS2801, WS2812.

Another interesting thing is that on the website https://nodemcu-build.com/ you can assemble the firmware yourself from the necessary modules, thus you will save space by excluding unnecessary elements from it for your useful code. And you can upload this firmware to any ESP8266 board.

In addition to using the Lua language, you can program the board using the Arduino IDE.

ESP8266 board can be used as independent device, and a module for wireless communication with Arduino.

A review of all the functions and features of this board will take a whole series of articles.

So this board is great option remote control via Wi-Fi. The scope of application is colossal, for example, using a smartphone as a control panel for a homemade radio-controlled car or quadcopter, even setting up networks for the whole house and controlling every socket, lamp, etc. If only there were enough pins.

The simplest option for working with a microcontroller is to use one ESP8266 board. Below is a diagram of a simple Wi-Fi outlet.

To assemble this circuit you will need a relay module, or a regular relay connected to the pin via a transistor. To get started, you will need the RoboRemoFree smartphone program (https://www.roboremo.com/). In it you will configure the connection to the ESP and create an interface for controlling the outlet. To describe how to use it you need to write separate article, so let’s skip this material for now.

We load the following firmware into the ESP using the ESPlorer program (a program for working with the board)

WiFi AP Setup

wifi.setmode(wifi.STATIONAP)

cfg.ssid="ESPTEST"

cfg.pwd="1234567890"

wifi.ap.config(cfg)

my_pin_number = 1

Gpio.mode(my_pin_number, gpio.OUTPUT)

gpio.mode(my_pin_number, gpio.OPENDRAIN)

sv=net.createServer(net.TCP)

function receiver(sck, data)

if string.sub (data, 0, 1) == "1" then

if string.sub (data, 0, 1) == "0" then

sv:listen(333, function(conn)

conn:on("receive", receiver)

conn:send("Hello!")

Create HTTP Server

http=net.createServer(net.TCP)

function receive_http(sck, data)

local request = string.match(data,"([^\r,\n]*)[\r,\n]",1)

if request == "GET /on HTTP/1.1" then

Gpio.write(my_pin_number, gpio.HIGH)

gpio.write(my_pin_number, gpio.LOW)

if request == "GET /off HTTP/1.1" then

Gpio.write(my_pin_number, gpio.LOW)

gpio.write(my_pin_number, gpio.HIGH)

sck:on("sent", function(sck) sck:close() collectgarbage() end)

local response = "HTTP/1.0 200 OK\r\nServer: NodeMCU on ESP8266\r\nContent-Type: text/html\r\n\r\n"..

""..

"

NodeMCU on ESP8266

"On Off"..

sck:send(response)

http:listen(80, function(conn)

conn:on("receive", receive_http)

print("Started.")

Now you can control the program either from the Roboremo program, or through any web browser, to do this you need to type the board’s IP address in the address bar in the wi-fi hotspot mode 192.168.4.1.

There is a fragment in the code:

""..

"

NodeMCU on ESP8266

"On Off"..

"

"

This is a kind of response that is given to the browser when accessing the board. It contains HTML code, i.e. a simple WEB page similar to the one on which you are now reading this article.

Here is this page launched in the browser of a smartphone running Android OS. What is described above is not a complete instruction, since it would take up a huge amount of space. If you are interested in this information, write comments and we will definitely conduct a review and write an article about working with it.

An IR receiver and infrared remote control are the most common and easiest way to control electronic equipment. The infrared radiation spectrum is not visible to the human eye, but it is perfectly received by IR receivers that are built into electronic devices. Arduino ir remote modules are used to control various equipment in line of sight.

The widespread use of IR emitters has become possible due to their low cost, simplicity and ease of use. IR radiation lies in the range from 750 to 1000 microns - this is the closest part of the spectrum to visible light. In area infrared radiation may change optical properties various materials. Some glasses, for example, become opaque to IR rays, while paraffin, on the contrary, is transparent in the IR spectrum.

Radiation is recorded using special photographic materials, on the basis of which receivers are made. In addition to heated bodies (the Sun, incandescent lamps or candles), the source of infrared radiation can be solid-state devices - IR LEDs, lasers. Radiation in infrared range has a number of features that make them convenient to use in remote controls:

• Solid state emitters (IR LEDs) are cheap and compact.
• Infrared rays are not perceived or detected by the human eye.
• IR receivers are also cheap and small in size.
• Low interference since the transmitter and receiver are tuned to the same frequency.
• Absent Negative influence on human health.
• High reflectance from most materials.
• IR emitters do not affect the operation of other devices.

The remote control works as follows. When you press the button, the signal is encoded in infrared light, the receiver receives it and performs the required action. Information is encoded as a logical sequence of pulse packets with a certain frequency. The receiver receives this sequence and demodulates the data. To receive a signal, a microcircuit is used that contains a photodetector (photodiode), amplifiers, a bandpass filter, a demodulator (a detector that allows you to isolate the signal envelope) and an output transistor. It also has filters – electrical and optical. Such devices operate at a distance of up to 40 meters. The IR method of data transmission exists in many devices: household appliances, V industrial technology, computers, fiber optic lines.

IR receiver Arduino

To read the IR signal you will need the Arduino board itself, a breadboard, an IR signal receiver and jumpers. There are a huge variety of different receivers, but it is better to use TSOP312 or others suitable for Arduino. Data from the remote control to the receiver can be transmitted via the RC5 or NEC protocol.

To determine which leg belongs to what, you need to look at the sensor from the receiver side. Then on the receiver the central contact is ground, on the left is the output to the microcontroller, on the right is power.

For convenience, you can use ready-made IR receiver modules.

Connecting the IR receiver to Arduino

The IR receiver outputs are connected to the Arduino to the GND, 5V and digital input ports. The diagram for connecting the sensor to the 11th digital pin is shown below.

This is what the circuit with the infrared receiver module looks like:

Libraries for working with IR

To work with IR devices, you can use the IRremote library, which simplifies the construction of control systems. You can download the library. After downloading, copy the files to the \arduino\libraries folder. To connect to your library sketch, you need to add the header file #include .

To read information, use the IRrecvDumpV2 example from the library. If the remote control already exists in the list of recognized ones, then scanning is not required. To read the codes, you need to launch the ARduino IDE and open the IRrecvDemo example from IRremote.

There is a second library for working with IR signals - this is IRLib. It is similar in functionality to the previous one. Compared to IRremote, IRLib has an example for determining the frequency of an IR sensor. But the first library is simpler and more convenient to use.

After loading the library, you can start reading the received signals. The following code is used for this.

The decode_results operator is needed to assign the variable name results to the received signal.

In the code you need to rewrite "HEX" to "DEC".

Then, after loading the program, you need to open the serial monitor and press the buttons on the remote control. Various codes will appear on the screen. You need to make a note indicating which button the received code corresponds to. It is more convenient to record the obtained data in a table. This code can then be written into the program so that the device can be controlled. The codes are written into the memory of the Arduino EEPROM board itself, which is very convenient, since you don’t have to program the buttons every time you turn on the remote control.

It happens that when loading a program, the error “TDK2 was not declared In his scope” is displayed. To fix it, you need to go to Explorer, go to the folder in which the Arduino IDE application is installed and delete the files IRremoteTools.cpp and IRremoteTools.h. After this, you need to reload the program onto the microcontroller.

Conclusion

Using Arduino ir remote makes life easier for the user. Can act as a remote control mobile phone, tablet or computer - you just need special software for this. Using Arduino you can centralize all control. With one button on the remote control you can perform several actions at once - for example, turn on the TV and Blu-Ray at the same time.

There are many articles on the Internet about how to make your own TV remote control using Arduino, but I needed a universal remote control to control my TV and media player. The main advantage of my universal remote control is that the buttons in the Android phone application are dual-purpose, but look at the video.

The remote control is very convenient in that almost the same buttons on the screen are used to control the TV and player. One difference is that the " AV"in TV control mode changes to a button" ◻ " (stop) when switching to the player control mode. The pictures show two modes, on the left is the TV control mode, on the right is the player control mode.

Well, now I’ll tell you a little about creating such a remote control. For the device I used the remote control for the ERGO TV and the remote control for the DUNE HD TV101W media player.

To receive data from the remotes I used infrared sensor TSOP1138 (analogue of TSOP4838) at an operating frequency of 38 kHz and connected it to the Arduino board according to the scheme:

This sketch will not be needed to determine the encoding of data transmission and read the code of the remote control buttons.

In the sketch in the line int RECV_PIN = 11; indicate our pin number 4

After uploading the sketch, open the “port monitor” and, pressing the remote control buttons, look at the received data.

The picture shows an example of scanning the power button from the TV remote control and the player remote control. Now we create a table for button codes.

I got it like in the photo above. Under the inscription TV TV remote control button codes; under the inscription Player- codes from the media player remote control.

Now we disconnect our infrared signal receiver from the Arduino board and connect the HC-05 Bluetooth module and an infrared LED to it according to the diagram in the photo.

After that, we move directly to the sketch.

Sketch

#include IRsend irsend; int y = 1; void setup() ( Serial.begin(9600); ) void loop() ( if (Serial.available() > 0) ( int x = Serial.read(); if (x == 49) ( y = 1; ) if (x == 50) ( y = 2; ) if (y == 1) ( // button codes for the TV remote if (x == 97) ( irsend.sendNEC(0x807F08F7, 32); delay(40 ); ) if (x == 98) ( irsend.sendNEC(0x807FA857, 32); delay(40); ) if (x == 99) ( irsend.sendNEC(0x807F708F, 32); delay(40); ) if (x == 100) ( irsend.sendNEC(0x807FF00F, 32); delay(40); ) if (x == 101) ( irsend.sendNEC(0x807F30CF, 32); delay(40); ) if (x == 102) ( irsend.sendNEC(0x807FB04F, 32); delay(40); ) if (x == 103) ( irsend.sendNEC(0x807F9867, 32); delay(40); ) if (x == 104) ( irsend .sendNEC(0x807F58A7, 32); delay(40); ) if (x == 105) ( irsend.sendNEC(0x807FD827, 32); delay(40); ) if (x == 106) ( irsend.sendNEC(0x807F38C7 , 32); delay(40); ) if (x == 107) ( irsend.sendNEC(0x807F48B7, 32); delay(40); ) if (x == 108) ( irsend.sendNEC(0x807FB847, 32); delay(40); ) if (x == 109) ( irsend.sendNEC(0x807F6897, 32); delay(40); ) ) if (y == 2) ( //codes of the media player remote control buttons if (x == 97) ( irsend.sendNEC(0xFDC23D, 32); delay(40); ) if (x == 98) ( irsend. sendNEC(0xFDE01F, 32); delay(40); ) if (x == 99) ( irsend.sendNEC(0xFD18E7, 32); delay(40); ) if (x == 100) ( irsend.sendNEC(0xFDE817, 32); delay(40); ) if (x == 101) ( irsend.sendNEC(0xFDA857, 32); delay(40); ) if (x == 102) ( irsend.sendNEC(0xFD6897, 32); delay (40); ) if (x == 103) ( irsend.sendNEC(0xFDA857, 32); delay(40); ) if (x == 104) ( irsend.sendNEC(0xFD6897, 32); delay(40); ) if (x == 105) ( irsend.sendNEC(0xFDE817, 32); delay(40); ) if (x == 106) ( irsend.sendNEC(0xFD18E7, 32); delay(40); ) if (x == 107) ( irsend.sendNEC(0xFD9867, 32); delay(40); ) if (x == 108) ( irsend.sendNEC(0xFD28D7, 32); delay(40); ) if (x == 109) ( irsend.sendNEC(0xFD20DF, 32); delay(40); ) ) ) )

If (x == 97) ( irsend.sendNEC(0x807F08F7, 32); delay(40);
Change the value 807F08F7 to:

If (y == 1) ( //button codes for the TV remote control if (x == 97) ( irsend.sendNEC(0x12345678, 32); delay(40); )
Where 12345678 is the code for your button.

After editing the sketch using your button codes, upload the sketch to the Arduino board and proceed to installing the application on your phone.

We turn on Bluetooth in the phone, look for our device, create a pair, then launch the application Pult on the phone.

Upon startup we will have a screen with a red bluetooth icon in the lower right corner, which signals that we are not connected to our device.

After that, click on this icon. We should see a window with a list of all available bluetooth devices, where we select our device to connect.

Now we are back on the main screen and can already control the TV:

To switch to control mode we need to press the button labeled "Player". As I said earlier, our button labeled "AV" will change to a button " ◻ ":

To disconnect from our device, simply hold down the “Power” button for a few seconds.

Well, a few photos of my finished device.

It turned out quite well, it seems. I'm waiting for comments on the article.

The IR Receiver module combined with an IR remote control will allow you to easily implement remote control Arduino board.

It is nothing more than a VS1838B IR receiver with the manufacturer’s recommended harness installed on the board.

To work with this module out of the box, you need a remote control with a frequency of 38 kHz.

The advantage of this board is the push-in connector, which allows you to replace the IR receiver with another one operating at the frequency required for your project without soldering.

Main technical characteristics:

Supply voltage: 2.7 - 5.5V

Modulation frequency: 38kHz

Temperature range: - 20 ... + 80°C

Interface: Digital

Connecting to Arduino

The module is equipped with a three-pin 2.54mm connector

: connects to GND pin

: connects to +5V output

: connects to digital output(in example D2)

An example of working in the Arduino environment

To work with this module you need to install the IRRemote library

Download, unpack and put it in the libraries folder in the Arduino folder. If the Arduino IDE was open at the time of adding the library, reboot the environment.

Reading remote control buttons

To read the remote control readings, fill in the sketch below. It will output the encoding of the pressed buttons to the port.

As an example, we will use the remote control, as in the picture, because This type of remote control is included in the set

You can read about the differences in the operating logic of various remote controls in the original article from a member of our community under the nickname

Sample code: