Are Controls for Radio Controlled Cars Programmed? Understanding RC Car Programming

Radio controlled (RC) cars are more than just toys; they are intricate pieces of engineering that bring the thrill of driving and customization right to your fingertips. A common question among enthusiasts, especially those new to the hobby or interested in modifying their vehicles, is: Are Controls For Radio Controlled Cars Programmed? The answer is a resounding yes! Modern RC cars, particularly hobby-grade models, rely heavily on programmed controls to operate and offer a range of customizable features.

To understand how this programming works, let’s delve into the electronic heart of an RC car and how commands from your transmitter are translated into actions on the vehicle.

Decoding the Control System of an RC Car

At the core of an RC car’s control system are several key components working in harmony:

• Transmitter (or Radio): This is the handheld device you use to control your RC car. It sends radio signals encoded with your commands.
• Receiver: Located inside the RC car, the receiver picks up the signals from the transmitter.
• Electronic Speed Controller (ESC): The ESC interprets signals from the receiver to regulate the power flow to the motor, controlling the car’s speed and braking.
• Servo(s): Servos are responsible for steering the car. They receive signals from the receiver to adjust the wheels’ direction.
• Microcontroller (often integrated into the receiver or ESC): This is the “brain” of the RC car. It processes the signals and manages various functions, especially in more advanced models.

The programming aspect comes into play in how these components communicate and respond to inputs. Let’s consider how the signal travels from your transmitter to the car’s motor and steering.

Pulse Width Modulation (PWM) and Control Signals

Many RC systems, especially entry-level and sport models, utilize Pulse Width Modulation (PWM) to transmit control signals. Think of PWM as a series of pulses where the width of each pulse dictates the command.

When you operate the controls on your transmitter – for example, pushing the throttle forward – the transmitter encodes this command into a PWM signal. This signal is then broadcast via radio waves to the receiver in your RC car.

The receiver, equipped with a microcontroller, is programmed to interpret these PWM signals. It measures the pulse width and translates it into specific instructions. For instance:

• Throttle Control: A shorter pulse width might correspond to “brake” or “reverse,” a mid-range pulse width to “neutral” or “stop,” and a longer pulse width to “forward throttle,” with varying degrees of pulse width dictating the amount of throttle.
• Steering Control: Similarly, different pulse widths are used to command the servo to turn the wheels left, right, or stay centered.

Arduino and Customizing RC Car Controls

For hobbyists looking to go beyond the standard functionalities, platforms like Arduino offer a powerful way to further program and customize RC car controls. The original forum post you provided is a perfect example of this. The user is using an Arduino Nano to intercept the PWM signal from the RC receiver and modify the output to control LED lights on their RC car.

Let’s break down the user’s code and the questions they raised to understand the programming concepts involved:

// Variables won't change:
const int PWMinput=2;          //Arduino PWM signal input pin
const int LED = 13;            // pin that the LED is attached to

// Variables will change:
int ch1 = 0;

void setup() {
  Serial.begin(9600);
  // Set PWM input pin as an input
  pinMode(PWMinput, INPUT);
  pinMode(LED, OUTPUT);
}

void loop() {
  ch1 = pulseIn (PWMinput,HIGH);  //Read and store channel 1
  Serial.print ("Ch1:");          //Display text string on Serial Monitor
  Serial.println (ch1);          //Print the value of ch1

  if (ch1 > 1500 && ch1 < 2100) { // Transmitter switch ON (High PWM)
    digitalWrite(LED, HIGH);     // LED ON
    delay (100);                 // Short delay for flash effect
    digitalWrite(LED, LOW);      // LED OFF
    delay (100);                 // Short delay for flash effect
    digitalWrite(LED, HIGH);     // LED ON
    delay (100);                 // Short delay for flash effect
    digitalWrite(LED, LOW);      // LED OFF
    delay (1000);                // Longer delay before repeat
  } else if (ch1 > 1000 && ch1 < 1500) { // Transmitter switch OFF (Low PWM)
    digitalWrite(LED, LOW);      // LED OFF - Normal operation
  } else {                             // Signal Loss or Error
    digitalWrite(LED, HIGH);     // LED ON - Indicate signal loss
    delay (500);                 // Medium delay for flash effect
    digitalWrite(LED, LOW);      // LED OFF
    delay (500);                 // Medium delay for flash effect
  }
}

Explanation of the Code:

• const int PWMinput=2; and const int LED = 13;: These lines define constants for the Arduino pins. PWMinput (pin 2) is set as the input pin to read the PWM signal from the RC receiver, and LED (pin 13, the built-in LED on many Arduino boards) is set as the output pin to control the LED light.
• int ch1 = 0;: This declares an integer variable ch1 to store the pulse width value read from the receiver.
• void setup() { ... }: This function runs once at the beginning.
  • Serial.begin(9600);: Initializes serial communication for debugging and monitoring data.
  • pinMode(PWMinput, INPUT);: Configures pin 2 as an input to receive the PWM signal.
  • pinMode(LED, OUTPUT);: Configures pin 13 as an output to control the LED.
• void loop() { ... }: This function runs continuously in a loop.
  • ch1 = pulseIn (PWMinput,HIGH);: This is the core command. pulseIn() function measures the duration of a HIGH pulse on the PWMinput pin. This duration represents the pulse width of the PWM signal from the RC receiver and is stored in the ch1 variable.
  • Serial.print ("Ch1:"); and Serial.println (ch1);: These lines print the value of ch1 to the serial monitor, useful for debugging and understanding the PWM signal values.
  • if (ch1 > 1500 && ch1 < 2100) { ... }: This if statement checks if the pulse width ch1 is within the range of 1500 to 2100 microseconds. This range, according to the user, corresponds to when the transmitter switch is ON. If true, it executes a flashing LED sequence.
  • else if (ch1 > 1000 && ch1 < 1500) { ... }: This else if statement checks if ch1 is within the range of 1000 to 1500 microseconds, representing the transmitter switch being OFF. In this case, the LED is turned off.
  • else { ... }: This else block handles cases where the ch1 value is outside the expected ranges (likely signal loss or errors). It implements a different flashing sequence to indicate a problem.
  • digitalWrite(LED, HIGH); and digitalWrite(LED, LOW);: These commands control the LED by setting the output pin HIGH (turning the LED on) or LOW (turning it off).
  • delay(milliseconds);: This function pauses the program execution for the specified number of milliseconds, creating the flashing effect.

Addressing the User’s Questions:

The original poster had some excellent questions about their code:

1. “What’s the reason for the ‘delay for stability’ and is it necessary?”

   There is no explicitly mentioned “delay for stability” in the provided code. The delay() functions are used to control the timing of the LED flashes, not for general stability in this specific code context. However, in some Arduino contexts, delays might be used to allow sensors to stabilize or to prevent reading values too rapidly. In this code, the delay() functions are purely for creating the visual flashing effect. Are they necessary for the LED flashing effect? Yes. Are they necessary for the code to function in terms of reading the PWM signal? No, not in this basic example.

2. “My code runs the flash sequence once before then looking to see if it should turn itself off. … is there a better way of maybe using nested loops, FOR loops or even the switch/case statement?”

   The current code structure within the if block is a sequence. It turns the LED on and off with delays. To repeat this sequence multiple times while the transmitter switch is ON, you would indeed use loops. A for loop or while loop could be used to repeat the flash pattern without writing digitalWrite and delay repeatedly.

   For example, the flashing sequence could be made more concise and repeatable using a for loop:

   if (ch1 > 1500 && ch1 < 2100) {
     for (int i = 0; i < 2; i++) { // Flash twice
       digitalWrite(LED, HIGH);
       delay(100);
       digitalWrite(LED, LOW);
       delay(100);
     }
     delay(1000); // Longer delay after the sequence
   }

   switch/case is generally more suited for selecting different actions based on distinct values of a variable, rather than ranges like in this PWM example. While you could use switch/case by discretizing the PWM ranges, if/else if/else is more readable and natural for range-based conditions. Nested loops are not directly relevant to choosing between different actions based on PWM, but as shown above, a for loop can enhance the flashing sequence itself.

3. “One example I found added a time-out to the pulseIn but this seemed to return results of 0 every other line so I removed this. Is there a benefit to this?”

   The pulseIn() function does have an optional timeout parameter. pulseIn(pin, state, timeout_us). If no pulse is detected within the timeout_us (microseconds), it returns 0. Using a timeout is beneficial in preventing the code from getting stuck indefinitely if a pulse is never received (e.g., signal loss or wiring issue). If you were getting 0 every other line when using a timeout, it might indicate that the timeout was too short, or there was some noise or interference in the signal causing intermittent readings. A properly set timeout is generally good practice for robustness.

4. “I have used an if, elseif and then an else. Would it be acceptable to just miss off the ELSE if it’s not required or does that cause problems?”

   Yes, it is perfectly acceptable to omit the else block if it’s not needed. If you only want to take action under specific if and else if conditions and do nothing otherwise, you can simply leave off the else. Not having an else doesn’t cause problems; it just means that if none of the if or else if conditions are met, no code within those blocks will execute. In the original code, the else is used to handle signal loss, so removing it would mean no special action would be taken if the signal is out of range.

5. “I also came across a few different baud rates in use. Does it matter?”

   Yes, the baud rate in Serial.begin(baudRate) matters, but it must match the baud rate setting in your Serial Monitor on your computer. The baud rate defines the speed of serial communication in bits per second. If the baud rates don’t match, the data received on the Serial Monitor will be garbled and unreadable. Common baud rates like 9600, 115200 are frequently used. As long as the Arduino code and the Serial Monitor are set to the same baud rate, communication will work correctly. For basic serial printing like in the example code, 9600 is often sufficient. Higher baud rates are needed for transmitting larger amounts of data quickly.

Conclusion: Programming Opens Up RC Car Possibilities

In conclusion, the controls for radio controlled cars are indeed programmed. From the basic PWM signals interpreting transmitter inputs to more advanced microcontrollers managing complex functions, programming is fundamental to how modern RC cars operate. For enthusiasts, understanding and even modifying this programming, as demonstrated with Arduino, opens up a world of customization – from controlling lights to implementing autonomous features and beyond. Exploring the code and experimenting with modifications is a fantastic way to deepen your understanding of both electronics and the exciting world of RC vehicles.