Published April 25, 2025 © MIT

App Controlled Robot

On your fingertips

AdvancedFull instructions provided5 hours56

Things used in this project

Hardware components

Espressif ESP32

Texas Instruments Dual H-Bridge motor drivers L293D

DFRobot Devastator Tank Mobile Robot Platform

Software apps and online services

Arduino IDE

MIT App Inventor

Hand tools and fabrication machines

Soldering iron (generic)

Story

Ever wanted to build your app-controlled robot car from scratch?

In this video, I’ll show you how I designed the PCB using Altium Designer, ordered PCBs from NextPCB, assembled the chassis, built a custom mobile app, and finally tested the robot — all powered by an ESP32 and a bit of creativity.

Whether you’re into robotics, IoT, or just love cool DIY projects, this one packs it all — hardware, coding, app development, and real-world testing.

In this article, there is a surprise for you. You can get 500 USD support for your next ESP32-S3 project. Watch this video till the end to learn more.

Let’s jump into it — step by step — and build the ultimate Wi-Fi-controlled robot car!

Step 1: Designing the PCB

The first step in building our app-controlled robot car was designing a custom PCB, and for that, I used Altium Designer, the industry standard in PCB design.

Altium made the process effortless, from schematic design to layout and even 3D visualization. Its real-time error checking and powerful routing tools helped me create a clean and compact board without wasting time troubleshooting.

And with Altium 365, I could store my design files online, making collaboration and feedback from my team seamless. Whether I was at the desk or on the go, I could access, review, and share my project from anywhere.

Get a free trial of Altium Designer with 365 and 25% off your purchase: https://www.altium.com/yt/robocircuits

At the core of the PCB is the ESP32 module, ideal for Bluetooth and Wi-Fi-based control. I also included two L298N motor drivers, though we’ll only be using one in this project. And to manage power, there’s a voltage regulator to safely step down the input voltage for the ESP32.

Once I finalized the design, I exported the Gerber files and sent them to NextPCB. They delivered high-quality boards with a professional finish and fast turnaround time. I also found an interesting event. NextPCB launched a free sample event for ESP32-S3 chips. They can sponsor 5 PCBs + 2 SMTs, up to 500 USD. As long as it is an original and high-quality IOT project, you can give it a try. Click the link below to learn more.

https://www.nextpcb.com/blog/esp32-s3-free-pcba-prototypes-nextpcb-accelerator

For the assembly, I used solder paste and a heat gun to mount the ESP32 and voltage regulator.

The motor driver and connectors were soldered using a regular soldering iron. With Altium’s organized layout, the assembly was quick and clean.

Step 2: Assembling the Chassis

With the PCB ready, it was time to bring the robot to life, starting with the chassis.

For this build, I used a metal chassis kit from DFRobot. It’s lightweight, sturdy, and incredibly easy to assemble — perfect for quick prototyping or educational projects.

The kit comes with everything you need — motors, wheels, nuts, bolts, and the metal frame. I started by mounting the SideFrame in the slots provided, then attached the wheels and secured everything with screws. Then I mounted the motors and other parts.

Once the base was ready, I placed the custom PCB right on top, ensuring easy access to the connectors and making the wiring super clean. I also made sure the battery holder was mounted securely at the center for proper weight distribution.

Within minutes, the entire setup was done and looking solid. It’s always satisfying to see the hardware coming together!

Step 3: Making the App

Now let’s build the brain behind the robot — the controller app.

Instead of using Bluetooth, I took it a step further and used Wi-Fi to control the robot. The ESP32 creates its hotspot, and the mobile phone connects directly to it — no internet or external router needed.

Once connected, the app sends control commands over HTTP requests to the ESP32’s web server. For example, when you press the forward button, the app sends a GET request like /F, and the ESP32 reads this and moves the robot forward.

The app was made using MIT App Inventor, which is perfect for quick development. I created a simple layout with directional controls — forward, backward, left, right, and stop. Each button triggers a different command via a web request.

This method gives us faster and more reliable communication than Bluetooth, and it’s scalable too, perfect for adding camera control or telemetry later.

Once the app was done, I connected to the ESP32’s Wi-Fi and started testing right away

Step 4: Uploading the Code

With everything assembled and the app ready, it was time to upload the code to the ESP32 using the Arduino IDE.

I connected the ESP32 to my PC via a USB cable and selected the correct board and port from the Tools menu. Since I’m using a custom PCB, I double-checked the boot and enable pins to make sure flashing goes smoothly.

The code I wrote sets up the ESP32 as a Wi-Fi access point, hosts a simple web server, and listens for incoming HTTP requests from the app—like/F for forward, /B for backward, and so on.

Once the code was compiled and uploaded, the ESP32 immediately started broadcasting its Wi-Fi network.

A quick check on my phone confirmed that the hotspot was live, and we were ready to test the robot in action!

Conclusion

“With the code uploaded using the Arduino IDE, the ESP32 booted up and started broadcasting its own Wi-Fi network. I connected my phone, opened the app I made in MIT App Inventor, and it was time for the moment of truth.

I tapped the forward button, and the robot moved. Then left, right, backward — every command was received over Wi-Fi, and the robot responded in real-time.

The ESP32 handled the web server perfectly, the motor driver did its job, and the whole system ran smoothly off the regulated power supply on the custom PCB.

It’s always so satisfying to see hardware, code, and app all work together flawlessly. This wasn’t just a fun project — it was a great learning experience in electronics, networking, and app development.

And shoutout to Altium Designer and NextPCB for sponsoring this video — I designed the entire PCB in Altium, and its powerful tools made the process smooth and professional. You can find the link to try it out down in the description.

Thanks for watching — and let me know in the comments if you want to see this robot car upgraded with a camera or autonomous features next!

Code

App Controlled Car code

#include <WiFi.h>
#include <WebServer.h>
#include <ESP32Servo.h>


// WiFi Credentials
const char* ssid = "Robot";
const char* password = "87654321";

// Motor Control Pins
#define ENA 25  // Enable/speed motors Right
#define IN_1 2  // L298N in1 motors Right
#define IN_2 15  // L298N in2 motors Right
#define IN_3 16  // L298N in3 motors Left
#define IN_4 17  // L298N in4 motors Left
#define ENB 4   // Enable/speed motors Left
#define SERVO_PIN1 19
#define SERVO_PIN2 21
#define IN_5 34
#define IN_6 35
  
#define Light 23  // Light control pin

// Motor speed and control
String command;
int speedCar = 150;  // Default speed (0 to 255)
int speed_low = 60;

// LEDC channels for PWM
#define PWM_FREQ 1000
#define PWM_RES 8
#define PWM_CHANNEL_A 0
#define PWM_CHANNEL_B 1

WebServer server(80);
Servo myServo1;  // Single Servo Object
Servo myServo2;  // Single Servo Object
void setup() {
  Serial.begin(115200);

  // Set pin modes
  pinMode(IN_1, OUTPUT);
  pinMode(IN_2, OUTPUT);
  pinMode(IN_3, OUTPUT);
  pinMode(IN_4, OUTPUT);
  pinMode(IN_5, OUTPUT);
  pinMode(IN_6, OUTPUT);
  pinMode(Light, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(ENA, OUTPUT);
  // Configure PWM for ESP32

  // Start WiFi Access Point
  WiFi.softAP(ssid, password);
  Serial.print("AP IP address: ");
  Serial.println(WiFi.softAPIP());

  // Web server endpoints
  server.on("/", HTTP_handleRoot);
  server.onNotFound(HTTP_handleRoot);
  server.begin();

  // analogWrite(ENA,255);
  // analogWrite(ENB,255);

  // Configure PWM for ESP32
  myServo1.attach(SERVO_PIN1);
  myServo2.attach(SERVO_PIN2);

  // Set initial servo position
  myServo1.write(90);
  myServo2.write(90);
}

void loop() {
  server.handleClient();

  command = server.arg("State");
  if (command == "F") goForward();
  else if (command == "B") goBack();
  else if (command == "L") goLeft();
  else if (command == "R") goRight();
  else if (command == "I") go_up();
  else if (command == "G") go_down();
 
  else if (command == "W") digitalWrite(Light, HIGH);
  else if (command == "S") stopRobot();
  else if (command == "w") digitalWrite(Light, LOW);
  else if (command.toInt() >= 0 && command.toInt() <= 10) {
    speedCar = 0 + (command.toInt() * 25);
    Serial.print("speedCar");
    Serial.println(speedCar);
  } 
  else if (command.toInt() >= 11 && command.toInt() <= 180)
    servoWrite(command.toInt());
}

void HTTP_handleRoot() {
  if (server.hasArg("State")) {
    Serial.println(server.arg("State"));
  }
  server.send(200, "text/html", "");
}



void servoWrite(int pos) {
  myServo2.write(180-pos);
  myServo1.write(pos);
}

// Movement functions
void goForward() {
  digitalWrite(IN_1, HIGH);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, LOW);
  digitalWrite(IN_4, HIGH);
  digitalWrite(IN_5, HIGH);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar);
  // ledcWrite(PWM_CHANNEL_B, speedCar);
}

void goBack() {
  digitalWrite(IN_1, LOW);
  digitalWrite(IN_2, HIGH);
  digitalWrite(IN_3, HIGH);
  digitalWrite(IN_4, LOW);
    digitalWrite(IN_5, LOW);
  digitalWrite(IN_6, HIGH);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar);
  // ledcWrite(PWM_CHANNEL_B, speedCar);
}

void goRight() {
  digitalWrite(IN_1, LOW);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, HIGH);
  digitalWrite(IN_4, LOW);
    digitalWrite(IN_5, HIGH);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar);
  // ledcWrite(PWM_CHANNEL_B, speedCar);
}

void goLeft() {
  digitalWrite(IN_1, HIGH);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, LOW);
  digitalWrite(IN_4, LOW);
    digitalWrite(IN_5, HIGH);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar);
  // ledcWrite(PWM_CHANNEL_B, speedCar);
}

void go_up() {
  digitalWrite(IN_1, HIGH);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, LOW);
  digitalWrite(IN_4, HIGH);
    digitalWrite(IN_5, HIGH);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar - speed_low);
  // ledcWrite(PWM_CHANNEL_B, speedCar);
}

void go_down() {
  digitalWrite(IN_1, HIGH);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, LOW);
  digitalWrite(IN_4, HIGH);
   digitalWrite(IN_5, HIGH);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, speedCar);
  // ledcWrite(PWM_CHANNEL_B, speedCar - speed_low);
}





void stopRobot() {
  digitalWrite(IN_1, LOW);
  digitalWrite(IN_2, LOW);
  digitalWrite(IN_3, LOW);
  digitalWrite(IN_4, LOW);
   digitalWrite(IN_5, LOW);
  digitalWrite(IN_6, LOW);
  analogWrite(ENA, speedCar);
  analogWrite(ENB, speedCar);
  // ledcWrite(PWM_CHANNEL_A, 0);
  // ledcWrite(PWM_CHANNEL_B, 0);
}