4WD Arduino Car Project

This is an excellent project which demonstrates how to control a 4WD Arduino Car.

However this car cannot spin but it is easy to modify the code to allow it to spin instead of just turning left and right.

 

This Arduino car has a better turning radius than cars that have steering wheels because it can spin.

If the left wheels are run forward and the right wheels are run reversed, the car will spin.

It allows the car to manoeuvre in tight spaces, but when spinning it cannot move forward at the same time.

To left or right while moving forward, just move the left wheels at a different speed from that of the right wheels.

It means that there is no need to use 4 speed controllers. Only 2 speed controllers are required. One speed controller for the left and another for the right wheels.

If we can control the speed of 3 wheels independently, we can spin the car around one wheel. I do not see much advantage out of it. 

Building a 4WD Autonomous Car with Arduino

Posted on May 6, 2016 by Daniel Wood

https://www.codemahal.com/build-a-4wd-autonomous-car-with-arduino

https://youtu.be/GxrOXzuc7C8

In this tutorial you will learn to make a 4WD robotic car with built-in obstacle avoidance. This project involves building a 4WD car with an ultrasonic sensor that can detect nearby objects and change its direction to avoid these objects. The ultrasonic sensor will be attached to a servo motor which is constantly scanning left and right looking for objects in its way.

4WD autonomous robotic car

You can extend this project by adding more sensors such as ultrasonic sensor to the rear so that the car doesn’t reverse into objects, speed detection sensors to determine speed, line following sensors, and LED brake lights. You could even add light sensors and LEDs to turn headlights on in low-light conditions or a Bluetooth connection to control the car through a mobile app.

Parts required

Here is what you will need:

• 1x Arduino Uno board
• 1x 4WD Robotic Car kit (4 wheels, 4 motors, chassis, AA battery enclosure, screws)
• 6x AA batteries
• 1x 9V battery
• 1x 9V battery power cable barrel jack connector
• 1x L298N Motor Module
• 1x Arduino Sensor Shield v5.0
• 1x HC-SR04 Ultrasonic Sensor
• 1x Servo motor (any small servo motor will do but if you don’t have one you can leave it out)
• Assorted colour wires:
  • 4x female-to-female wires for Ultrasonic Sensor
  • 8x female-to-female wires for the Motor Module to Sensor Shield
  • 8x bare-ended wires to go from the four motors to the Motor Module
  • 2x bare-ended wires to go from the Motor Module to Sensor Shield
  • 3x wires for the servo motor with female end attaching to Sensor Shield (should already be included with the servo motor)
  • 2x bare-ended wires to go from AA Battery enclosure to the motor Module (should already be included with the battery enclosure)
• Arduino IDE software – free at http://www.arduino.cc
• 1x USB cable (A male plug to B male plug)
• A computer to program with

Note: Make sure you get a range of different colours for the wires (eg. red for voltage, black for ground, etc.). Some items such as the battery enclosure, motors and servo motor may come with wires so you may not need to purchase these separately. Some motor modules or sensor shields may use different pins (eg. male or female or just bare-ended wires).
Below are images of the main components you need (apart from the wiring and batteries) – the different robot parts, shields, modules and sensors.

Click for larger image

Assembling the robotic car

The first thing to do is to assemble all the car chassis parts and attach the motors to the wheels. This is explained in detail in the video below.

Video Player

00:00

15:59

Wiring it up

Now that the chassis is assembled and the wheels and motors are attached, you will need to wire up all of the components. You can watch the video below or scroll down for the step-by-step instructions and wiring diagram.

Video Player

00:00

18:38

1. Connect the red wire (voltage) from the battery enclosure to VCC on the L298N Motor Module.
2. Connect the black wire (ground) from the battery enclosure to GND on the Motor Module.
3. Connect the red wire from Motor A1 (rear left) and the red wire from Motor A2 (front left) to OUT1 on the Motor Module (both wires can be twisted together and will go into OUT1 – the wiring diagram further down this page shows how to do this).
4. Connect the black wire from Motor A1 (rear left) and the black wire from Motor A2 (front left) to OUT2 on the Motor Module.
5. Connect the red wire from Motor B1 (rear right) and the red wire from Motor B2 (front right) to OUT3 on the Motor Module.
6. Connect the black wire from Motor B1 (rear right) and the black wire from Motor B2 (front right) to OUT4 on the Motor Module.
7. Connect a female-to-female end wire from ENA (Engine A) on the Motor Module to signal pin 1 on the Sensor Shield (the #2 pin in the S row. There are three rows – S stands for Signal, V for Voltage and G for Ground).
8. Connect a female-to-female end wire from 5V (next to ENA) on the Motor Module to voltage pin 1 on the Sensor Shield (it doesn’t really matter which pin for voltage as long as it is in the V row).
9. Connect a female-to-female end wire from IN1 on the Motor Module to signal pin 2 on the Sensor Shield.
10. Connect a female-to-female end wire from IN2 on the Motor Module to signal pin 3 on the Sensor Shield.
11. Connect a female-to-female end wire from IN3 on the Motor Module to signal pin 4 on the Sensor Shield.
12. Connect a female-to-female end wire from IN4 on the Motor Module to signal pin 5 on the Sensor Shield.
13. Connect a female-to-female end wire from 5V (next to ENB) on the Motor Module to voltage pin 6 on the Sensor Shield (it doesn’t really matter which pin for voltage as long as it is in the V row).
14. Connect a female-to-female end wire from ENB (Engine B) on the Motor Module to signal pin 6 on the Sensor Shield.
15. Connect the signal wire from the servo motor to signal (S) pin 7 on the Sensor Shield, the voltage wire from the servo motor to the voltage (V) pin 7 on the Sensor Shield, and the ground wire from the servo motor to the GND (G) pin 7 on the Sensor Shield.
16. Attach the Ultrasonic Sensor to the servo motor and then attach the servo motor to the front of the car so that it can scan left and right looking for objects in its path.
    You can use sticky tape, blu-tack, glue or a 3D printed/laser cut mount or whatever you like to attach everything, as long as everything is firmly mounted.
17. Use female-to-female end plugs to connect the Ultrasonic sensor to the Sensor Shield. Firstly, attach the TRIG pin from the Ultrasonic sensor to signal (S) pin 8 on the Sensor Shield. Attach the ECHO pin from the ultrasonic sensor to signal (S) pin 9 on the Sensor Shield. Attach the VCC pin from the Ultrasonic Sensor to the voltage (V) pin 10 on the Sensor Shield. Lastly, attach the GND pin from the Ultrasonic Sensor to the GND (G) pin 11 on the Sensor Shield.
18. Now attach the Sensor Shield on top of the Arduino Uno board making sure to not bend any pins. Connect a 9V Battery Barrel Jack Connector to a 9V battery and then plug this in to the Arduino’s barrel jack (see diagram below).
19. That’s it! Now all you need is batteries and the code!

Please note: There are several variations of the sensors and modules and several different ways to wire this up. For example, you can add a charging component to charge batteries and you can also add different switches. There may be other better methods to use, but I have gone for the simplest way I know of to set this up.

Wiring diagram

Click for larger image

Writing the code

Here is the code to get your robot moving. The code is written in C language and is written in the Arduino IDE software. The code for a robot with a servo motor and the code for a robot without a servo motor is shown below. If you don’t have an ultrasonic sensor and just want to use Bluetooth control via a phone app, then you can just extract the parts of the code that you need and then add the Bluetooth code.

Code to use with a servo motor

1. // Setup the servo motor
2. #include <Servo.h>
3. Servo myservo;
4. int servposnum = 0;
5. int servpos = 0;
6. 
   
7. // Setup Motor A (front and rear) pins
8. int enableA = 1;
9. int pinA1 = 3;
10. int pinA2 = 2;
11. 
    
12. // Setup Motor B (front and rear) pins
13. int enableB = 6;
14. int pinB1 = 5;
15. int pinB2 = 4;
16. 
    
17. // Setup Ultrasonic Sensor pins
18. #define trigPin 8
19. #define echoPin 9
20. 
    
21. 
    
22. void setup() {
23. // The setup code goes here and runs once only
24. // Configure the pin modes for each drive motor
25. pinMode (enableA, OUTPUT);
26. pinMode (pinA1, OUTPUT);
27. pinMode (pinA2, OUTPUT);
28. 
    
29. pinMode (enableB, OUTPUT);
30. pinMode (pinB1, OUTPUT);
31. pinMode (pinB2, OUTPUT);
32. 
    
33. // Configure the pin modes for the Ultrasonic Sensor
34. pinMode(trigPin, OUTPUT);
35. pinMode(echoPin, INPUT);
36. 
    
37. // Turn pin into servo driver. Calls pinMode. Returns 0 on failure.
38. myservo.attach(7);
39. }
40. 
    
41. void loop() {
42. // Main code goes here and will run repeatedly:
43. 
    
44. car(); // function keeps moving car forward while distance > 15cm
45. avoid(); // function makes car go back, turn slightly right to move forward in new direction
47. }
48. 
    
49. // Create motor functions
50. void motorAforward() {
51. digitalWrite (pinA1, HIGH);
52. digitalWrite (pinA2, LOW);
53. }
54. void motorBforward() {
55. digitalWrite (pinB1, LOW);
56. digitalWrite (pinB2, HIGH);
57. }
58. void motorAbackward() {
59. digitalWrite (pinA1, LOW);
60. digitalWrite (pinA2, HIGH);
61. }
62. void motorBbackward() {
63. digitalWrite (pinB1, HIGH);
64. digitalWrite (pinB2, LOW);
65. }
66. void motorAstop() {
67. digitalWrite (pinA1, HIGH);
68. digitalWrite (pinA2, HIGH);
69. }
70. void motorBstop() {
71. digitalWrite (pinB1, HIGH);
72. digitalWrite (pinB2, HIGH);
73. }
74. void motorAcoast() {
75. digitalWrite (pinA1, LOW);
76. digitalWrite (pinA2, LOW);
77. }
78. void motorBcoast() {
79. digitalWrite (pinB1, LOW);
80. digitalWrite (pinB2, LOW);
81. }
82. void motorAon() {
83. digitalWrite (enableA, HIGH);
84. }
85. void motorBon() {
86. digitalWrite (enableB, HIGH);
87. }
88. void motorAoff() {
89. digitalWrite (enableA, LOW);
90. }
91. void motorBoff() {
92. digitalWrite (enableB, LOW);
93. }
94. 
    
95. // Setup movement functions
96. void forward (int duration) {
97. motorAforward();
98. motorBforward();
99. delay (duration);
100. }
101. void backward (int duration) {
102. motorAbackward();
103. motorBbackward();
104. delay (duration);
105. }
106. void right (int duration) {
107. motorAbackward();
108. motorBforward();
109. delay (duration);
110. }
111. void left (int duration) {
112. motorAforward();
113. motorBbackward();
114. delay (duration);
115. }
116. void coast (int duration) {
117. motorAcoast();
118. motorBcoast();
119. delay (duration);
120. }
121. void breakRobot (int duration) {
122. motorAstop();
123. motorBstop();
124. delay (duration);
125. }
126. void disableMotors() {
127. motorAoff();
128. motorBoff();
129. }
130. void enableMotors() {
131. motorAon();
132. motorBon();
133. }
134. 
     
135. // Setup Ultrasonic Sensor distance measuring
136. int distance() {
137. int duration, distance;
138. digitalWrite(trigPin, HIGH);
139. delayMicroseconds(1000);
140. digitalWrite(trigPin, LOW);
141. duration = pulseIn(echoPin, HIGH);
142. distance = (duration/2) / 29.1;
143. return distance;
144. }
145. 
     
146. // Setup the main car function
147. void car() {
148. int distance_0;
149. distance_0 = distance();
150. // Keep moving forward in a straight line while distance of objects > 15cm
151. while(distance_0 > 15)
152. {
153. // Keep moving servo motor back and forth to scan surroundings
154. // This allows the ultrasonic sensor to see more to its left and right
155. if(servposnum == 0)
156. {
157. myservo.writeMicroseconds (1900);
158. servposnum = 1;
159. delay(100);
160. }
161. else if(servposnum == 1)
162. {
163. myservo.writeMicroseconds (2200);
164. servposnum = 2;
165. delay(100);
166. }
167. else if(servposnum == 2)
168. {
169. myservo.writeMicroseconds (1900);
170. servposnum = 3;
171. delay(100);
172. }
173. else if(servposnum == 3)
174. {
175. myservo.writeMicroseconds (1600);
176. servposnum = 1;
177. delay(100);
178. }
179. motorAon();
180. motorBon();
181. forward(1);
182. distance_0 = distance();
184. }
185. breakRobot(0);
186. 
     
187. }
188. void avoid()
189. {
190. // Go back and turn slightly right to move car in new direction if object detected < 15cm away
191. backward(500);
192. right(360);
193. }

Code to use without a servo motor

1. // Setup Motor A (front and rear) pins
2. int enableA = 1;
3. int pinA1 = 3;
4. int pinA2 = 2;
5. 
   
6. // Setup Motor B (front and rear) pins
7. int enableB = 6;
8. int pinB1 = 5;
9. int pinB2 = 4;
10. 
    
11. // Setup Ultrasonic Sensor pins
12. #define trigPin 8
13. #define echoPin 9
14. 
    
15. void setup() {
16. // The setup code goes here and runs once only
17. // Configure the pin modes for each drive motor
18. pinMode (enableA, OUTPUT);
19. pinMode (pinA1, OUTPUT);
20. pinMode (pinA2, OUTPUT);
21. 
    
22. pinMode (enableB, OUTPUT);
23. pinMode (pinB1, OUTPUT);
24. pinMode (pinB2, OUTPUT);
25. 
    
26. // Configure the pin modes for the Ultrasonic Sensor
27. pinMode(trigPin, OUTPUT);
28. pinMode(echoPin, INPUT);
29. }
30. 
    
31. void loop() {
32. // Main code goes here and will run repeatedly:
33. car(); // function keeps moving car forward while distance of objects in front are > 15cm away
34. avoid(); // function makes car go back, turn slightly right to move forward in new direction
35. }
36. 
    
37. // Create motor functions
38. void motorAforward() {
39. digitalWrite (pinA1, HIGH);
40. digitalWrite (pinA2, LOW);
41. }
42. void motorBforward() {
43. digitalWrite (pinB1, LOW);
44. digitalWrite (pinB2, HIGH);
45. }
46. void motorAbackward() {
47. digitalWrite (pinA1, LOW);
48. digitalWrite (pinA2, HIGH);
49. }
50. void motorBbackward() {
51. digitalWrite (pinB1, HIGH);
52. digitalWrite (pinB2, LOW);
53. }
54. void motorAstop() {
55. digitalWrite (pinA1, HIGH);
56. digitalWrite (pinA2, HIGH);
57. }
58. void motorBstop() {
59. digitalWrite (pinB1, HIGH);
60. digitalWrite (pinB2, HIGH);
61. }
62. void motorAcoast() {
63. digitalWrite (pinA1, LOW);
64. digitalWrite (pinA2, LOW);
65. }
66. void motorBcoast() {
67. digitalWrite (pinB1, LOW);
68. digitalWrite (pinB2, LOW);
69. }
70. void motorAon() {
71. digitalWrite (enableA, HIGH);
72. }
73. void motorBon() {
74. digitalWrite (enableB, HIGH);
75. }
76. void motorAoff() {
77. digitalWrite (enableA, LOW);
78. }
79. void motorBoff() {
80. digitalWrite (enableB, LOW);
81. }
82. 
    
83. // Setup movement functions
84. void forward (int duration) {
85. motorAforward();
86. motorBforward();
87. delay (duration);
88. }
89. void backward (int duration) {
90. motorAbackward();
91. motorBbackward();
92. delay (duration);
93. }
94. void right (int duration) {
95. motorAbackward();
96. motorBforward();
97. delay (duration);
98. }
99. void left (int duration) {
100. motorAforward();
101. motorBbackward();
102. delay (duration);
103. }
104. void coast (int duration) {
105. motorAcoast();
106. motorBcoast();
107. delay (duration);
108. }
109. void breakRobot (int duration) {
110. motorAstop();
111. motorBstop();
112. delay (duration);
113. }
114. void disableMotors() {
115. motorAoff();
116. motorBoff();
117. }
118. void enableMotors() {
119. motorAon();
120. motorBon();
121. }
122. 
     
123. // Setup Ultrasonic Sensor distance measuring
124. int distance() {
125. int duration, distance;
126. digitalWrite(trigPin, HIGH);
127. delayMicroseconds(1000);
128. digitalWrite(trigPin, LOW);
129. duration = pulseIn(echoPin, HIGH);
130. distance = (duration/2) / 29.1;
131. return distance;
132. }
133. 
     
134. // Setup the main car function
135. void car() {
136. int distance_0;
137. distance_0 = distance();
138. // Keep moving forward in a straight line while distance of objects in front > 15cm away
139. while(distance_0 > 15)
140. {
141. motorAon();
142. motorBon();
143. forward(1);
144. distance_0 = distance();
145. }
146. breakRobot(0);
147. 
     
148. }
149. 
     
150. // Go back and turn slightly right to move car in new direction
151. // This function only runs if an obstacle within 15cm is detected
152. void avoid()
153. {
154. backward(500);
155. right(360);
156. }

Finishing up

Once you have the code you will need to verify it and then upload it to your Arduino Uno board. Make sure you have either the Arduino disconnected from the Sensor Shield or all batteries disconnected when uploading the code to prevent any errors while uploading. Make sure to also arrange the different components carefully in the chassis to prevent any short circuits.
And that’s it! There is so much more that can be done with this project. Try extending your project by adding the following features:

• Line following
• Low-light activated headlights (using light sensors and LEDs)
• Brake lights
• Speed measuring
• Bluetooth/mobile app control
• More ultrasonic sensors to avoid reversing into objects or falling off edges

The video below shows a demo of the 4WD autonomous car using an Arduino and the ultrasonic sensor attache to a servo motor. Six AA batteries power the motors while the Arduino board is powered using a separate 9V battery.

Video Player

00:00

00:21

More photos