Introducing my old Kenwood KR-V7080 Receiver rack system, well minus the double tape deck player and the turntable which didn’t quite survived the test of time. This stereo system has been with me for almost 25 years I think. But over the years as I settled down, it more or less took a backseat. And as the family grew, I eventually moved it into the garage where it sat for the last few years collecting dust.
However, we are going to breath new life into this rack system again. This blog post is going to be the first in a series of posts where we will try to connect it to the internet and maybe control it via some app. Ok I know, many of you will ask why? Well because we can (just kidding 😉, but seriously though, we are doing it because I think we will learn so much for doing it).
As some of you might have guessed from this post’s title already, we are going to tinker a little bit with IR communication. We are going to simulate the Kenwood receiver’s remote, so that whatever we can do with the remote, we should be able to do with an Arduino.
Infrared
Below is a diagram of the electromagnetic spectrum.
The diagram shows the types of electromagnetic waves and it’s real-world application along the x-axis with respect to the waves energy (frequency) from left to right. If we look at the rainbow in the middle of the diagram, that’s the visible spectrum and is what our eyes can see. And if we think back to our high school physics, red sits at the bottom of the visible spectrum (based on the wave’s energy) while blue sits at the top of the visible spectrum. To the left of the visible spectrum we have the infrared spectrum (which has lower energy than red, hence the name infra red). If you want to learn more about waves and how they relates to colours and light, definitely check out this article Waves and Energy and also the concept of Black Body Radiation.
Infrared Communication
Infrared (IR) communication is a form of wireless communication between two devices using infrared light. It is widely used in consumer electronics where the equipment is controlled via a remote control such as:
- TVs
- Stereos
- Heatpumps
- Medical devices
These are often referred to as consumer infrared (CIR).
Infrared communication is a very common and inexpensive communication technology. The communication consists of a transmitting device which sends data by emitting bursts of infrared light via an infrared LED. As infrared is outside the visible spectrum, these bursts of light will not be detectable by the human eye. On the receiving device, a photodiode is used to detect these bursts of light and convert them into an electrical current.
Receiving Data Using An IR Receiver Module
In this section we are going to look at using an IR receiver module in combination with an Arduino Uno to capture the signals emitting from the Kenwood KR-V7080 remote. The goal is to map all of the buttons on the remote to a list of key-value pairs.
The IR receiver module we will be using comes with a breakout board as shown below:
Next we will hook up it up to an Arduino Uno. How they are wired together is as follow:
Actual wiring:
Now let’s head over to VS Code and initialise a new Arduino sketch to interact with the IR receiver module, we will need to give the sketch a name so let’s go with IrReceiverModuleDemo.ino. If you are not familiar with working with Arduino in VS Code, have a look at my blog post Arduino + Visual Studio Code to get you started.
To help us decode the IR signals, we will be using an open source library called IRremote. As of writing, the latest version and the one we are using is version 3.6.2. The sketch is implemented as follow:
/*
* IrReceiverModuleDemo: Simple sketch to interact with the IR receiver module to
* intercept IR signals.
*
* Copyright Chris Dinh 2022
*/
#include <IRremote.h>
#define RECV_PIN 11 // IR receiver signal pin
void setup()
{
Serial.begin(115200);
IrReceiver.begin(RECV_PIN, ENABLE_LED_FEEDBACK);
}
void loop()
{
if (IrReceiver.decode())
{
Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
IrReceiver.resume();
}
}
This is the remote control that comes with Kenwood KR-V7080 receiver (as I have mentioned, it’s been sitting in the garage for the last few years collecting dust):
We are going to point this remote at the IR receiver module and go through and presses each button on the remote. The idea is to decode the Hexadecimal value being transmitted for each button so that later on we can simulate these button presses by sending these Hexadecimal values using an IR transmitter module. Below is a demo of what was being decoded as each numeric button was pressed (1 - 9, and lastly 0).
Remote Control Unit (RC-R0803) Code Summary
So I have been tinkering with the RC-R0803 Remote and the KR-V7080 Receiver and there were a couple of things I have learnt:
- The RC-R0803 Remote is a universal remote controller, what this mean is that depending what device we are trying to control at the time the button that is pressed may send a different command (e.g. the demo above shows the codes being transmitted when
Video 1was selected on the remote). - Some buttons depend on the context the remote control is in, if the remote is not in the appropriate context, pressing a button may not send any command at all.
- The RC-R0803 Remote is using the
NECIR protocol to transmit the infrared commands. If you want to dig a bit deeper into the NEC IR protocol, check out NEC IR Remote Control Interface with 8051.
Given we are only interested in controlling the KR-V7080 Receiver, the following table describes how the RC-R0803 Remote interacts with the KR-V7080 Receiver.
Button IR Code Notes
------ ------- -----
Power 629D47B8 Toggles power on/off.
0 7F8047B8 Numbers can be used to select radio presets.
1 7E8147B8
2 7D8247B8
3 7C8347B8
4 7B8447B8
5 7A8547B8
6 798647B8
7 788747B8
8 778847B8
9 768947B8
+10 F20D47B8 Select radio presets 10 or greater.
Volume Up 649B47B8
Volume Down 659A47B8
Mute 639C47B8 Toggle mute.
Input 33CC01B8 Iterate through input types (Radio, Phono, CD, Video2, Video1, Tape1).
Stereo 28D747B8 Stereo mode.
Surround Mode 20DF47B8 Iterate through surround mode (Dolby Pro Logic, Dolby 3 Stereo, DSP Logic, DSP Arena).
Audio 639C02B8 Iterate through audio settings (Bass, Trebble, Sub Woofer, Balance).
Surround 629D02B8 Iterate through surround settings (Rear, Delay, Center).
Up AA5501B8 Used to control audio/surround settings.
Down AB5401B8 Used to control audio/surround settings.
Sending Data Using An IR Transmitter Module
In this section we are going to look at using an IR transmitter module in combination with an Arduino Uno to send IR coded signals to the KR-V7080 Receiver. The goal is to simulate the RC-R0803 Remote using the table above.
The IR transmitter module we will be using comes with a breakout board as shown below:
Next we will hook up it up to an Arduino Uno. How they are wired together is as follow:
Actual wiring:
Again let’s head over to VS Code and initialise a new Arduino sketch to interact with the IR transmitter module, we will need to give the sketch a name so let’s go with IrTransmitterModuleDemo.ino.
So instead of using the remote, the plan is to have the Arduino Uno listens for IR commands over the serial connection and forward it to the stereo receiver using the IR transmitter module.
/*
* IrTransmitterModuleDemo_v2: Simple sketch to interact with the IR transmitter module to
* send IR signals.
*
* Copyright Chris Dinh 2022
*/
/* INCLUDES */
#include "Arduino.h"
#include <IRremote.h>
#include <string.h>
/* DEFINITIONS */
#define COMMAND_STRING_MAX_LENGTH 15U
#define COMMAND_VALUE_MASK 0xFF0000
#define COMMAND_VALUE_OFFSET 16U
#define ADDRESS_VALUE_MASK 0xFFFF
#define LINE_FEED_VALUE 10U
#define CARRIAGE_RETURN_VALUE 13U
#define IR_SEND_PIN 13U
/* Remote Control R0803 Button Code */
#define BUTTON_CODE_POWER_TOGGLE 0x629D47B8 // Toggles power on/off
#define BUTTON_CODE_0 0x7F8047B8 // Numbers can be used to select radio presets
#define BUTTON_CODE_1 0x7E8147B8
#define BUTTON_CODE_2 0x7D8247B8
#define BUTTON_CODE_3 0x7C8347B8
#define BUTTON_CODE_4 0x7B8447B8
#define BUTTON_CODE_5 0x7A8547B8
#define BUTTON_CODE_6 0x798647B8
#define BUTTON_CODE_7 0x788747B8
#define BUTTON_CODE_8 0x778847B8
#define BUTTON_CODE_9 0x768947B8
#define BUTTON_CODE_10X 0xF20D47B8 // Selects radio presets 10 or greater
#define BUTTON_CODE_VOLUME_UP 0x649B47B8
#define BUTTON_CODE_VOLUME_DOWN 0x659A47B8
#define BUTTON_CODE_MUTE 0x639C47B8 // Toggle mute
#define BUTTON_CODE_INPUT 0x33CC01B8 // Iterate through input types (Radio, Phono, CD, Video2, Video1, Tape1)
#define BUTTON_CODE_STEREO 0x28D747B8 // Stereo mode
#define BUTTON_CODE_SURROUND_MODE 0x20DF47B8 // Iterate through surround mode (Dolby Pro Logic, Dolby 3 Stereo, DSP Logic, DSP Arena)
#define BUTTON_CODE_AUDIO 0x639C02B8 // Iterate through audio settings (Bass, Trebble, Sub Woofer, Balance)
#define BUTTON_CODE_SURROUND 0x629D02B8 // Iterate through surround settings (Rear, Delay, Center)
#define BUTTON_CODE_UP 0xAA5501B8 // Used to control audio/surround settings
#define BUTTON_CODE_DOWN 0xAB5401B8 // Used to control audio/surround settings
/* VARIABLES */
static char commandString[COMMAND_STRING_MAX_LENGTH];
static uint8_t commandStringLength;
/* PRIVATE FUNCTIONS */
static void ResetCommandString(void)
{
memset(commandString, 0, sizeof(commandString[0]) * COMMAND_STRING_MAX_LENGTH);
commandStringLength = 0;
}
static void sendNecCommand(uint32_t buttonCode, uint8_t repeats)
{
uint16_t address = (buttonCode & ADDRESS_VALUE_MASK);
uint8_t command = (buttonCode & COMMAND_VALUE_MASK) >> COMMAND_VALUE_OFFSET;
IrSender.sendNEC(address, command, repeats);
Serial.println("Command sent");
}
static void processCommandString(const char *command)
{
if (strcmp(command, "power") == 0)
{
sendNecCommand(BUTTON_CODE_POWER_TOGGLE, 0);
return;
}
if (strcmp(command, "vol+") == 0)
{
/* Must be in volume context already to change volume. Otherwise the first
"vol+" will only put receiver in volume context. */
sendNecCommand(BUTTON_CODE_VOLUME_UP, 0);
return;
}
if (strcmp(command, "vol-") == 0)
{
/* Must be in volume context already to change volume. Otherwise the first
"vol-" will only put receiver in volume context. */
sendNecCommand(BUTTON_CODE_VOLUME_DOWN, 0);
return;
}
if (strcmp(command, "mute") == 0)
{
sendNecCommand(BUTTON_CODE_MUTE, 0);
return;
}
}
/* PUBLIC FUNCTIONS */
void setup()
{
ResetCommandString();
IrSender.begin(IR_SEND_PIN, true, LED_BUILTIN);
Serial.begin(115200); // opens serial port
Serial.println("Begin IrTransmitterModuleDemo_v2");
}
void loop()
{
/* If there are no data to read, do nothing */
if (!Serial.available())
{
return;
}
char c = Serial.read();
if (c == LINE_FEED_VALUE || c == CARRIAGE_RETURN_VALUE)
{
/* When receiving data over the serial connection, we will treat LF and CR as command termination. */
processCommandString(commandString);
ResetCommandString();
}
else if (commandStringLength > COMMAND_STRING_MAX_LENGTH)
{
/* Command length exceeded, start again. */
ResetCommandString();
}
else
{
/* Carry on retrieving current command. */
commandString[commandStringLength] = c;
commandStringLength++;
}
}
Ok let’s summarise the sketch above.
In the setup() function we initialises a couple of things:
- Clear the command buffer
- Set which GPIO pin the IR transmit module’s signal line is connected to
- Use the built-in LED to provide some visual feedback when transmitting
- Set serial baud rate to listen to
In the loop() function we continuously listen to the serial port for incoming data:
- Whatever comes through will be added to a buffer
- A line feed and carriage return is use to indicate full command has been received and command can be processed
- Commands assumed to be no more than 15 characters long and it is exceeded, the buffer will be cleared and we start over
- The commands are mapped to IR code which will then be transmitted
Below is a demo of the above sketch in action. In the foreground we have the Arduino Uno connected to a laptop via a USB serial cable, while in the background we have the Kenwood stereo receiver. As you can see, when we issue some commands on the laptop, these get sent to the Arduino Uno which are then forwarded to the receiver via the IR transmit module.