This tutorial is part of: Servo Motors
All videos related to servo motors that are related, listed here. Links to other videos are below this article.
Controlling Servo Motors Using an Infrared Remote with Arduino
```html
Controlling Servo Motors with an Infrared Remote and Arduino
This project demonstrates how to control a servo motor using an infrared (IR) remote and an Arduino. This setup allows for wireless control of the servo's position, making it ideal for various applications.
Here are some project ideas using this setup:
- Remotely adjusting a camera's pan and tilt.
- Controlling a robotic arm's movements.
- Automating window blinds or curtains.
- Creating interactive art installations.
- Building a remote-controlled car or vehicle.
Hardware/Components
- Arduino board (e.g., Uno, Nano)
- Servo motor
- IR remote control (any standard remote will work, but the code is configured for specific remotes)
- IR receiver module (e.g., TSOP1838)
- Jumper wires
- Breadboard (optional)
Wiring Guide
The servo motor has three wires: ground (usually brown or black), power (typically red), and signal (often orange or white). The IR receiver also has three wires: ground, power (VCC), and signal.
(in video at 01:46)
- Servo Ground to Arduino Ground
- Servo Power to Arduino 5V
- Servo Signal to Arduino Pin 8 (in video at 02:23)
- IR Receiver Ground to Arduino Ground
- IR Receiver VCC to Arduino 5V
- IR Receiver Signal to Arduino Pin 11 (in video at 02:38)
Code Explanation
The code begins by including necessary libraries for IR communication and servo control. (in video at 03:16)
#include <IRremote.h>
#include <Servo.h>
Next, essential variables are defined. You'll need to configure these based on your specific setup. (in video at 03:44)
const char type = 'B'; // 'W' for white remote, 'B' for black remote
const boolean PCB = 0; // 1 if the IR receiver has a PCB, 0 if it's a bare module
const int SERVO_PIN = 8; // The pin connected to the servo's signal wire
int angleStep = 10; // How many degrees the servo moves per button press
const int ANGLE_CENTRE = 90; // The center/reset position of the servo
(in video at 05:06)
The most crucial configuration step is matching the remote control buttons to specific actions. The code includes arrays for different remote types (white/black, PCB/non-PCB) and their corresponding button codes. You'll need to identify the correct codes for your remote and assign them to the desired actions (right, left, center). (in video at 05:16)
const String RIGHT = ">"; // Replace with the code for your "right" button
const String LEFT = "<"; // Replace with the code for your "left" button
const String CENTRE = "OK"; // Replace with the code for your "center" button
(in video at 08:12)
The servoAction() function handles the servo movement based on the received IR signal. It checks the received command and adjusts the servo angle accordingly. The angleStep variable controls the increment or decrement of the servo's position. (in video at 08:06)
Live Project/Demonstration
(in video at 09:56)
The video demonstrates how to control the servo using different remotes. It shows how to adjust the code for various remote types and receiver modules. The demonstration also covers how to capture IR codes from your own remotes and integrate them into the code. (in video at 12:48)
Chapters
- [00:00] Introduction and Project Overview
- [00:36] Components and Materials
- [01:46] Wiring Instructions
- [03:16] Code Explanation
- [09:56] Project Demonstration
- [12:48] Using Your Own Remote
```
Images
IR remote receiver VS1838B pins
SG90_servo_motor-1
remote
IR_remote_servo_wring
This tutorial is part of: Servo Motors
- Controlling a Servo with Push Buttons Using Arduino
- Control a Servo Motor with a Push Button: Move Servo and Return SPB-1
- Control a Servo Motor with a Push Button: Move Servo in One Direction SPB-2
- Controlling a Servo Motor with a Push Button: Move Servo While Button Is Pressed (SPB-3)
- Controlling a Servo with a Potentiometer Using Arduino
- Controlling a Servo with Potentiometer and LCD1602 using Arduino
- Arduino Servo Motor Control Using a Potentiometer
- Controlling Servo Position with Hand Gestures for Arduino
- Controlling Two or More Servos with Potentiometers Using an Arduino
- How to Control a 360° Servo with Three Push-Button Switches
- How to Use Continuous 360° Servo with Arduino
- Arduino Code and Video for PCA9685 16-Channel 12-Bit Servo Controller V1
- Build an Arduino Servo Toggle Switch with a Push Button
139-Source for controlling a servo motor with an IR remote controller using Arduino
Language: C++
/*
* Original library from - http://arcfn.com
*
* This Arduino code controls a servo motor with an IR remote controller or any TV remote.
*
* You have to select the type of your remote as Black or White in the code below
* and also select your receiver 1838 as either a PCB or bare module. See video for details.
*
* You have to watch this video: https://youtu.be/muAkBQb24NI
* before proceeding with this code.
*
* Modified/Written by Ahmad Shamshiri
* on August 02, 2018 at 20:35 in Ajax, Ontario, Canada
* for Robojax.com
* Watch video instructions for this code: https://youtu.be/Wp7hX9UErSQ
* Get other Arduino codes from Robojax.com
*
*/
#include <IRremote.h>
int RECV_PIN = 11;
const char type ='B';// W for white, B for black. Must keep single quotes like 'B' or 'W'
const boolean PCB = 0;// if receiver is PCB set to 1, if not set to 0. See video for details
boolean displayCode = true;// to display remote code. if not, set to false
//***** Servo settings begins
#include <Servo.h>
Servo RJservo; // create servo object to control a servo
const int SERVO_PIN = 8; // analog pin used to connect the potentiometer
int angle =90; // initial angle for servo
int angleStep =10;
const int ANGLE_CENTRE =90;// the centre/reset angle of your servo
//**** Servo settings ends
// remote settings
const String RIGHT=">";// move servo to the right with this key on remote
const String LEFT ="<";// move servo to the left with this key on remote
const String CENTRE ="OK";// move servo to centre with this key on remote
// remote settings end
IRrecv irrecv(RECV_PIN);
// this is array holding codes for White Remote when used with PCB version of receiver
unsigned int whiteRemotePCB[] ={
0xE318261B, // CH-
0x511DBB, // CH
0xEE886D7F, // CH+
0x52A3D41F, // |<<
0xD7E84B1B, // >>|
0x20FE4DBB, // >||
0xF076C13B, // -
0xA3C8EDDB, // +
0x12CEA6E6, // EQ
0xC101E57B, // 0
0x97483BFB, // 100+
0xF0C41643, // 200+
0x9716BE3F, // 1
0x3D9AE3F7, // 2
0x6182021B, // 3
0x8C22657B, // 4
0x488F3CBB, // 5
0x449E79F, // 6
0x32C6FDF7, // 7
0x1BC0157B, // 8
0x3EC3FC1B // 9
};
// this is array holding codes for White Remote when used with non-PCB version of receiver
unsigned int whiteRemote[] ={
0xFFA25D, // CH-
0xFF629D, // CH
0xFFE21D, // CH+
0xFF22DD, // |<<
0xFF02FD, // >>|
0xFFC23D, // >||
0xFFE01F, // -
0xFFA857, // +
0xFF906F, // EQ
0xFF6897, // 0
0xFF9867, // 100+
0xFFB04F, // 200+
0xFF30CF, // 1
0xFF18E7, // 2
0xFF7A85, // 3
0xFF10EF, // 4
0xFF38C7, // 5
0xFF5AA5, // 6
0xFF42BD, // 7
0xFF4AB5, // 8
0xFF52AD // 9
};
// key lables of white remote
String whiteRemoteKey[] ={
"CH-",
"CH",
"CH+",
"|<<",
">>|",
">||",
"-",
"+",
"EQ",
"0",
"100+",
"200+",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
};
// this is array holding codes for Black Remote when used with non-PCB version of receiver
unsigned int blackRemote[] ={
0xFF629D, // ^
0xFF22DD, // <
0xFF02FD, // OK
0xFFC23D, // >
0xFFA857, // v
0xFF6897, // 1
0xFF9867, // 2
0xF0C41643, // 3
0xFF30CF, // 4
0xFF18E7, // 5
0xFF7A85, // 6
0xFF10EF, // 7
0xFF38C7, // 8
0xFF5AA5, // 9
0xFF42BD, // *
0xFF4AB5, // 0
0xFF52AD // #
};
// this is array holding codes for Black Remote when used with PCB version of receiver
unsigned int blackRemotePCB[] ={
0x511DBB, // ^
0x52A3D41F, // <
0xD7E84B1B, // OK
0x20FE4DBB, // >
0xA3C8EDDB, // v
0xC101E57B, // 1
0x97483BFB, // 2
0xF0C41643, // 3
0x9716BE3F, // 4
0x3D9AE3F7, // 5
0x6182021B, // 6
0x8C22657B, // 7
0x488F3CBB, // 8
0x449E79F, // 9
0x32C6FDF7, // *
0x1BC0157B, // 0
0x3EC3FC1B // #
};
// Black remote key names
String blackRemoteKey[] ={
"^",
"<",
"OK",
">",
"v",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"*",
"0",
"#"
};
decode_results results;
void setup()
{
Serial.begin(9600);
// In case the interrupt driver crashes on setup, give a clue
// to the user what's going on.
Serial.println("Robojax IR Decode");
Serial.println("Servo Control with Remote");
irrecv.enableIRIn(); // Start the receiver
RJservo.attach(SERVO_PIN); // attaches the servo on pin servoPin to the servo object
}
void loop() {
if (irrecv.decode(&results)) {
if(displayCode)Serial.println(results.value, HEX);
robojaxValidateCode(results.value);// used the "robojaxValidateCode" bellow
irrecv.resume(); // Receive the next value
}
delay(50);// 50 millisecond delay
}
/*
* function: robojaxValidateCode
* validates the remote code and prints the correct key name.
* cd is the code passed from the loop.
* Written by A. S. for Robojax
*/
void robojaxValidateCode(int cd)
{
// Robojax IR Remote decoder
int found=0;
if(type =='W' && !PCB)
{
// Robojax IR White Remote decoder
// if type is set to 'W' (white remote) and PCB=0 then check White remote code
for(int i=0; i< sizeof(whiteRemote)/sizeof(int); i++)
{
if(whiteRemote[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(whiteRemoteKey[i]);
servoAction(whiteRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else if(type =='W' && PCB){
// Robojax IR White Remote decoder
// if type is set to 'W' (white remote) and PCB=1 then check White remote code
for(int i=0; i< sizeof(whiteRemotePCB)/sizeof(int); i++)
{
if(whiteRemotePCB[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(whiteRemoteKey[i]);
servoAction(whiteRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else if(type =='B' && PCB){
// Robojax IR Black Remote decoder
// if type is set to 'B' (black remote) and PCB=1 then check Black remote code
for(int i=0; i< sizeof(blackRemotePCB)/sizeof(int); i++)
{
// Robojax IR black Remote decoder
if(blackRemotePCB[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(blackRemoteKey[i]);
servoAction(blackRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else{
// if type is set to 'B' (black remote) and PCB =0 then check Black remote code
for(int i=0; i< sizeof(blackRemote)/sizeof(int); i++)
{
// Robojax IR black Remote decoder
if(blackRemote[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(blackRemoteKey[i]);
servoAction(blackRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}// else
if(!found){
if(cd !=0xFFFFFFFF)
{
Serial.println("Key unknown");
}
}// found
}// robojaxValidateCode end
/*
*
* servoAction()
* receives string "value" as input and based on the settings,
* sends translates it to servo value and controls servo, either by:
* rotating servo to the right
* rotating servo to the left
* moving the servo to the middle
*
*/
void servoAction(String value)
{
// Servo button demo with IR remote by Robojax.com
while(value == RIGHT){
if (angle > 0 && angle <= 180) {
angle = angle - angleStep;
if(angle < 0){
angle = 0;
}else{
RJservo.write(angle); // move the servo to desired angle
Serial.print("Moved to: ");
Serial.print(angle); // print the angle
Serial.println(" degree");
}
}// if
value =".";
delay(100);
}// while for RIGHT
while(value == LEFT){
// Servo button demo with IR remote by Robojax.com
if (angle >= 0 && angle <= 180) {
angle = angle + angleStep;
if(angle >180){
angle =180;
}else{
RJservo.write(angle); // move the servo to desired angle
Serial.print("Moved to: ");
Serial.print(angle); // print the angle
Serial.println(" degree");
}
}
value =".";
delay(100);
}// while for LEFT
if(value == CENTRE)
{
angle = ANGLE_CENTRE;
RJservo.write(angle); // move the servo to centre at 90 degree angle
}
// Robojax IR Servo control
}//servoAction endThings you might need
-
Amazon
-
eBay
Resources & references
No resources yet.
Files📁
No files available.
