Radio Control – Use the Flysky FS-I6X with Arduino & Build an RC Car

Inexpensive radio controls are an ideal way to add reliable, long-distance remote control capability to your project. Today we’ll see how easy this is to accomplish.

These controllers have a wealth of features and can be used both with or without a microcontroller.

Introduction

Radio Control units, or RC Controllers, have been used by model airplane, helicopter, rover and boating enthusiasts for years. Indeed, many of these hobbies would not exist if it were not for the availability of inexpensive yet reliable radio control devices.

But these controllers are not limited to hobby vehicle control. They are equally suitable for use in controlling any electronic project that requires a full-featured wireless remote control.

Today, I’ll show you how to take a very common and inexpensive RC Controller and use it for a variety of purposes, both with and without a microcontroller.  But before we get started, it would be a good idea to learn a little about RC Controllers and the terminology that is associated with them.

Radio Control Basics

Radio controllers typically consist of both a transmitter and receiver, and they generally operate on a radio frequency that does not require licensing for low-power transmitters. This frequency can vary depending on which country they are certified for use in.

Older transmitter/receiver combinations used frequencies in the MHz band, such as the 72MHz band for model aircraft and the 75MHz band for surface vehicles. Each of these frequency bands was divided into individual channels, and you needed to find an unused one to operate your aircraft or vehicle.

Nowadays, it is more common to use “spread-spectrum” radios in the 2.4GHz band. The use of spread-spectrum technology eliminates the need to select a channel.

Channels

Not to be confused with the individual RF frequency channels used in older devices, in this context “channels” refers to control channels.  Each of these channels is tied to two things:

• A switch, joystick, potentiometer, or display on the RC Controller.
• An output or input on the receiver.

So a “6-channel” remote will have six corresponding outputs or inputs on the receiver, each one mapped to an element on the controller.

TX Modes

You’ll see this term used when describing an RC transmitter. The term “mode” generally applies to using the transmitter with an airplane, and it refers to how the transmitter is configured to control the airplane, i.e. which sticks operate which controls on the plane.

A standard transmitter has two sticks, each capable of both horizontal and vertical movement. Each stick, therefore, has two channels, one for horizontal movements and another for vertical ones.

There are four TX modes in total:

• Mode 1 – Left stick operates elevator & rudder, right stick operates throttle & ailerons.
• Mode 2 – Left stick operates throttle & rudder, right stick operates elevator & ailerons.
• Mode 3 – Left stick operates elevator & ailerons, right stick operates throttle & rudder.
• Mode 4 – Left stick operates throttle & ailerons, right stick operates elevator & rudder.

The most common configuration is Mode 2, and most new transmitters are configured this way.

Most transmitters have the facility to change modes. This is usually a pretty involved process that requires you to disassemble the transmitter and move the stick controls.

For our purposes, using the transmitter to control our projects, the mode is usually irrelevant.

Receivers

Of course, the other end of this remote control system is the receiver.

In most cases, the receiver is made by the same company that manufactured the transmitter, and it is often included with the transmitter. You can usually buy additional receivers, so you can use the same transmitter with a number of different projects.

In order for the receiver and transmitter to interact with one another, you’ll need to “bind” them. This is usually a pretty simple procedure, I’ll show you in a bit how to do it with the transmitter-receiver combination that I have.   When you purchase a new transmitter with a receiver, they are usually bound to one another already.

Physically, the receiver is a small, lightweight box that has one or two wire antenna leads. The outputs are generally 3-pin connectors, which can be used directly with servo motors or electronic speed controls (ESC’s).

Many receivers also have additional outputs for a unique type of serial bus. Some receivers also have input connections, so you can monitor various aspects of your remote controlled vehicle.

RX Protocols

Once again, we have a term that can be used for two different aspects of the radio control system. While a “protocol” can refer to the method used to exchange data between the transmitter and receiver, in this context it refers to the ports on the receiver..

The most common protocol used on the receiver side is PWM (Pulse Width Modulation), and this is used almost universally to control servo motors and ESC’s.

Many receivers also have a serial interface, this allows the connection of several devices without a lot of cabling.  The protocol used on this port varies between manufacturers.

Here is a partial list of the protocols used in some popular receivers:

• PWM (universal)
• PPM or CPPM (universal)
• SBUS (Futaba, Frsky)
• IBUS (Flysky)
• XBUS (JR)
• MSP (Multiwii)
• CRSF (TBS Crossfire)
• SPEKTRUM1024 (Spektrum DSM2)
• SPEKTRUM2048 (Spektrum DSMX)
• FPort (Frsky)
• SPI_RX (universal)

The above list came from information on Oscar Liang’s excellent website, one of the best resources on the internet for radio control information.

Flysky FS-I6X

The transmitter/receiver I selected for my experiments is the popular Flysky FS-I6X. This is a 6-channel device that can be converted into a 10-channel unit with a firmware update.

This unit operates on the 2.4GHz band and permits bidirectional communication between transmitter and receiver.  It uses “multi-channel hopping” to switch between 16 available channels between 2.408 and 2.475GHz.

It also supports the Flysky implementation of iBUS for both sending and receiving multi-channel data.

Receiver

The receiver included with the Flysky FS-I6X is a 6-channel unit, the FS-IA6B. 

This device has two small wire antennas, seven 3-pin connectors for input/output devices, plus two additional 3-pin connectors used for the iBUS transmit and receive connections.

One of the seven 3-pin connectors on the side of the unit is used for both the power input and for binding the receiver to the transmitter. In normal operation, you apply 4-8 volts to the VCC and GND pins on this connector. When binding the receiver, you need to short the “signal” pin to ground.

Flysky provides a jumper that can be used to accomplish this.

Using an RC Controller on its own

By themselves, a receiver and transmitter pair is all you need to control a number of basic devices, such as servo motors and ESC’s.

If you’re using the Flysky FS-I6X, you will need to be sure that you power up the receiver AFTER the transmitter, this is true for many other RC Controllers as well.  You’ll also need to have all the switches in the up position and the throttle control (left stick) down all the way. Both of these requirements are safety precautions to avoid an uncontrolled vehicle or one that starts with the motors running.

By default, the outputs of the transmitter are set as follows:

• Channel 1 – Right Stick, Left/Right
• Channel 2 – Right Stick, Up/Down
• Channel 3 – Left Stick, Up/Down
• Channel 4 – Left Stick, Left/Right
• Channel 5 – Control VRA
• Channel 6 – Control VRB

So, by connecting devices to these receiver channel outputs, you may control them with their associated control on the transmitter.

Give it a try. Hook it up as follows. You can use servo motors, continuous servo motors or ESC’s.

Now try moving the sticks and the two potentiometers to see how they can control each device.

If all you need for your project is a few servo motors, you might be able to get away without even using a microcontroller. However, by adding a microcontroller like an Arduino to the project you’ll be able to greatly expand upon the capabilities of your system

Using an RC Controller with a Microcontroller

While you can use just about any microcontroller with the remote receiver you do need to keep in mind that the outputs are at a 5-volt logic level, so if you use a microcontroller whose inputs are not 5-volt tolerant you’ll need to add in a level-converter.

Although adding a level-converter is pretty simple, I decided to just use older Arduino AVR boards, which use 5-volt logic. 

I’ll show you two ways of using the receiver with a microcontroller:

• Using the PWM outputs as microcontroller inputs.
• Using the Flysky iBus output.

Before we get started, however, you’ll need to make a slight configuration change to your controller. Well technically you don’t need to make any changes, this “suggested” change will let you demonstrate the use of both the controls and switches on the Flysky controller.

Mapping a Switch to an Output

We have already looked at the default setup of the Flysky remote controller, all six channels are mapped to either a potentiometer or one aspect of a joystick. They all, therefore, give out a variable reading that is proportional to the position of the control.

But there are also four switches on the controller that, by default, are not mapped to any channel. So in order to use one of the switches, we will need to remove the mapping to one of the variable controls and then map that channel to one of the switches.

In my case, I decided to map switch SWA (the leftmost switch) to controller channel 6, which is normally used for the right potentiometer.

Here is how I did that with the Flysky FS-I6X:

• Power on the transmitter, be sure to have all the controls in their default positions.
• Hold the OK key down for a few seconds until you display a Menu
• Use the Up and Down keys to select “Functions Setup”, the mode represented by a wrench.
• Select Functions Setup using the OK key
• Use the Up and Down controls to highlight Aux Channels
• Select Aux Channels with the OK key.
• You will be able to remap channels 5 and 6. Use the controls to select a channel, then cycle through the options for the controls you can attach to that channel.
• When you find one you want, just leave it. Then hold the Cancel key down for a few seconds and release it. You will exit the channels page and be back in the Functions menu.
• Choose Aux Channels again, just to be sure your setting was saved.

Use this technique to map channel 6 to switch SWA.

Using PWM Outputs – Arduino Uno

One way to work with the Flysky receiver is to read each individual channel output from the “servo” connector.

Remember, our controller outputs PWM, which by its own nature communicates by manipulating the width of a pulse. We can use a microcontroller, like an Arduino, to measure the pulse width and interpret that data.

It’s actually pretty easy to do.

Arduino Uno Hookup

We will need an Arduino Uno, or pretty well any 5-volt Arduino, for our experiment.

The hookup is pretty straightforward, the six outputs from the Flysky receiver are connected to six inputs on the Arduino. 

We also connect the 5-volt output from the Arduino to the receiver’s VCC to power it. And, of course, we connect a Ground as well.

PWM Output Sketch

The sketch is actually pretty simple, thanks to a couple of functions I found on GitHub.  This code, written by Ricardo Paiva, simplifies getting data from the RC channels. 

All we are going to do in the sketch is read the values from each of the channels and print them on the Serial Monitor.

We begin by defining the six input connections from the receiver.  We then define five integers to represent values from the first five ports, as these are analog controls.

The logic state of channel 6 is represented with a boolean, as it is now mapped to a switch.

Now we come to the two functions, readChannel and readSwitch, that I picked up on GitHub. 

readChannel has four inputs:

• The channel input pin
• The Minimum range value
• The Maximum range value
• A Default value

The Minimum and Maximum values allow you to assign a range to each control. They can be any valid integers, including negative numbers.

The Default value is the value that will be applied if there is trouble reading data from the RC receiver.

The heart of readChannel is the pulseIn function, which measures the incoming pulse width. A valid width will be between 1000 and 2000 microseconds, and any pulse in that range will be mapped to the range defined by the Minimum and Maximum.

readSwitch performs the same function, except it uses a boolean value when reading a switch.

In Setup, we start the Serial Monitor and define all of our I/O pins as inputs.

In the Loop, we populate the channel value variables by calling readChannel for each channel. Note the minimum and maximum and default values given to each control.

We then print the values of our variables to the Serial monitor. After a short delay, we do it all over again.

PWM Test Results

Disconnect the Arduino from the computer while you power up the transmitter. 

Now connect the Arduino and open your Serial Monitor.  You should be seeing a display of all six channels.

Manipulate the controls and observe the Serial Monitor data. You should see each control has an effect on a specific channel of data.

The switch SWA will give values of 0 or 1, depending upon its position. Everything else will range between -100 and 100, with zero being the center.

Using iBus Output – Arduino Mega 2560

Another way to get data from the Flysky receiver is via the iBus serial connection. This has a few advantages, not the least being that it only requires one wire (plus power and ground).

We are going to require a second UART, or serial input, on our microcontroller, and this rules out using an Arduino Uno again. Although you can emulate a serial port with SoftwareSerial, in this case we are using a library that requires a physical UART instead.

For this reason, we are switching to an Arduino Mega 2560, it has multiple hardware UARTs.

Arduino Mega 2560 Hookup

Here is how we will hook up our circuit:

As you can see, the wiring is very minimal. Pin 19 on the Arduino Mega 2560 is the RX1, or “Receive 1”, input to one of the hardware UARTs. We will get our data here.

Once again, we will use the microcontrollers 5-volt output to power the receiver. Make sure not to omit the Ground connection.

iBus Library

To simplify working with the iBus we can take advantage of a library that does most of the “heavy lifting” for us. 

We will be using the iBusBM library, which works for Arduino as well as ESP32. You can install this inside your Arduino IDE using the Library Manager.

Open the Library Manager and filter the display by “iBus”. You will see a few libraries, many of them for the infotainment system in BMW vehicles, which is also named “iBus”.

As we aren’t working with BMW’s today, we will grab the iBusBM Library, which should be the first result in your filtered search.

Install the library into your Arduino IDE. You might want to explore some of the sample sketches it comes with later. 

Right now, we are going to program essentially the same sketch we did last time, so we can read the data onto the Serial Monitor.

iBus Sketch

Now that we have our iBus library installed, we can put to gather a sketch.  As we did the last time, we are just going to read the data from the six channels and display it on the serial monitor.

Here is our sketch. Between the reduced number of connections and the use of the iBus library, it is in many ways a lot simpler than the last one.

We begin by including our iBusBM library and then creating an object to represent the iBus.

Our two functions from GitHub are back, with readChannel modified to use a different method of getting data. We can now use the iBus library, which itself has its own readChannel function.

When you work with this library you’ll need to note that it numbers the channels differently,  The iBusBM library starts numbering at 0, so the first channel is 0, the second is 1 etc. etc.

In Setup, we start the serial monitor, and we bind the iBus object to the Serial1 port, where we have data coming in from the RC receiver.

The code in the Loop is pretty simple. We just cycle through the first five channels and read their values and print them to the Serial Monitor. We then read the value of our switch on channel 6, which you’ll note is called with a 5” due to the numbering scheme in the library.

After doing that, we go back to the top of the Loop and do it all again!

iBus Test Results

As one might expect, the results from the iBus experiment look identical to the results of the original experiment with the Arduino Uno. 

But one thing that is different is the simplicity of getting that data, using the iBus for a single-wire connection and a library to make reading the data a breeze.

Build an RC Controlled Robot Car

Now that we know two methods of using the radio controller with an Arduino, we can put our knowledge to work and build something. And the most obvious thing to build would be a radio-controlled car. 

So let’s put one together!

RC Car Description & Operation

We’ll be using the standard 2-wheel “robot car” base that we’ve used in many other projects. These are available on Amazon, eBay, and probably at your local electronics dealer (if you indeed have a local electronics dealer). They come in a variety of shapes and sizes, the ones I picked up on Amazon set me back about twelve US dollars each.

Most of these bases consist of an acrylic base plate and a couple of 6-volt DC motors, typically the yellow geared ones with a 90-degree shaft mount. The kits include all the mounting hardware, a couple of wheels, a castor to balance everything, and (usually) a battery holder, a switch, and perhaps some wire for the motors.

We will keep our radio controller mappings the same as earlier, with channel 6 mapped to switch SWA.  We will be using every channel except channel 4 in this design.

Car Modes

Our robot car will be able to operate in two different “modes”:

• Normal Mode – Use the two sticks to control the car’s speed and direction
• Spin Mode – The car spins on one spot, you can control the speed and direction of rotation.

The switch we mapped to channel 6, SWA, will be used to change modes. An LED on the car will indicate that we are Spin mode (although it’s usually pretty obvious). 

In Normal mode, the right stick controls the car’s direction and steering.  The left stick controls the acceleration.

In Spin mode, potentiometer VRA (the top left one), which is mapped to channel 5, controls the direction of rotation. The speed is controlled with the left stick.

RC Car Hookup

Here is how we will be hooking up our car.

Once again, we will use an Arduino Mega 2560, with the data being read from the iBus serial connector on the Flysky receiver.

The car will use a TB6612 H-Bridge controller to power the motors. This tiny wonder has several advantages over the common L298N H-Bridge, however you could substitute an L298N if you wished. If you do, you’ll likely need to increase the motor power supply voltage, as you’ll lose 1.4-volts through the L298N.

Any color of LED will work, and the dropping resistor can be anything from 150 to 470 ohms.

Follow the chart on the wiring diagram for the motor controller hookup, each channel has two inputs for direction and a PWM input to control speed. There is also a common STBY, or Standby, input that can put the motor controller to “sleep”.

Note that you may or may not have to reverse the polarity on your motors, it really depends upon how you have them mounted.  If they are 180 degrees apart, then you’ll likely want o reverse polarity, as shown in the diagram. But if they are mounted parallel to one another, then they likely need to be of the same polarity.

RC Car Sketch

Now it’s time to take a look at the sketch we’ll need to make our robot car come alive:

The sketch is a bit long, but it’s actually very easy to understand if you break it down. 

Once again, we’ll be using the iBusBM Library which we used in the last sketch, it simplifies getting data from the Flysky iBus connection.

We define some variables to hold the monitor speeds and channel data, as well as the connections to the TB6612 and the LED.

We then create a couple of functions, which themselves could probably be put into one function, to drive the motors at a specified speed and direction.  We also use the same trusty functions to get the RC controller data.

In the setup, we initialize the serial port, in case we need to debug, and also connect the Serial1 port to the iBus object.

We then define all of our connections as outputs.  As you’ve probably noted, I used pin 13 for the LED, so you could skip it and use the Mega’s onboard LED instead.

We add a short delay, with a flash of the LED, at the end of Setup. This is to allow time for the receiver to establish a connection to the transmitter.

Then we go into the loop. We start the loop by getting data from each of the channels. Note the minimum and maximum values used.  

The right stick controls each have a range of -100 to 100, they control the direction and, to some degree, speed.

The left stick’s vertical movement is mapped from 0 to 155, this is the motor speed and is added to the values from the right joystick.

The VRA control, which controls the spin direction and speed, is also set for a range of -100 to 100. It is used in conjunction with the left stick speed.

As both modes use the reading from the left stick, we get that first, from Channel 3, and assign it to the two motor speed variables.

Channel 6 is mapped to our switch, which controls mode. We examine its value now, to determine what mode we are in.

If we are in Spin mode then we use VRA (Channel 5) to determine what direction to spin the car. Positive values indicate clockwise, whereas negative ones are counter-clockwise.  We also add the value to our motor speeds, using the abs (absolute) function to get a positive number.

If we are in Normal mode we look at the value of Channel 2, the vertical movement on the right stick, to get our discretion. We also add the absolute speed values to our motor speeds.

Next, we then check the horizontal stick movement, on Channel 1, to do the steering. We then apply the correction to the motor speeds.

Before we drive the motors, we use a constrain function to ensure that the values stay between 0 and 255. Then we drive the motors using the functions we defined earlier.

Testing the RC Car

Testing out the car is a matter of manipulating the controls on the transmitter and observing the wheel movements.

If you can arrange to have the car base supported during testing, it will be a lot easier to give the car its first “check-up”. Otherwise, it will start to run away from you! I used a large circuit board holder to hold the car base, effectively putting it “up on blocks”.

Turn the transmitter on before you power up the Arduino on the car, you can keep the 6-volts to the motor connected at all times as it isn’t drawing power when the Arduino is off.

After the transmitter boots up, power up the car, observing the LED. After a few seconds, you should hear a sound from the transmitter, indicating that it is communicating with the receiver.

When the car boots up, it is in “Normal” mode, so you can use both joysticks to drive it.

Now manipulate the right stick on the transmitter and observe the wheel motions. Pull the stick all the way back, and note the direction that  the motors turn in. Now push it forward, and then side-to-side, all the time observing the motor movements.

Note the effect of the throttle, or left stick vertical movement, on the speed. 

Both motors should be spinning in the same direction while in Normal mode. If they aren’t, then reverse the polarity on one of the motors (it doesn’t matter which one). 

Now reduce the throttle to minimum and flip the switch SWA (the one on the far left). You should see the LED light up, and if the control VRA was not in the center you may also see the motors moving. 

Use VRA and note the motor movements, they will be moving in the opposite direction to one another.  By manipulating VRA you can change the direction of rotation and speed for both motors. You can also use the throttle to increase speed.

If it all checks out, then it’s time to go for an actual test drive! Find a big area if possible, remember that your radio control has a range that can approach a kilometer under the right conditions.

Now put it to the test!

Remember, by applying a firmware update to your Flysky FS-I6X you can increase its capacity to 10 channels. The Arduino Mega has oodles of I/O pins that we haven’t touched, so now that you know how to work with RC data, you could add a number of exciting features to your car.

Conclusion

Radio control transmitter/receiver pairs, like the Flysky FS-I6X, can really simplify the design of radio control projects. 

Remember, you can purchase additional receivers for most transmitter models, like the Flysky I used, so that you can create several radio-controlled devices using the same transmitter.

Now go out and control something!