Introduction
We created an RC Car that can identify a parking space and parallel park by itself. The RC Car drives down a street searching for a parking space to its right using a distance sensor. When the car has identified a space, the car checks to see whether that space is large enough to park in. If it determines that there is sufficient space, the car will begin parallel parking into that space. It uses information from sensors placed on the front, right, and rear of the car to direct the car into the parking space. Once the car has parked, it will remain in that position until it is reset.
High Level Design
Rationale
After discussing various project ideas, we eventually stumbled onto the subject of cars. So we started brainstorming possible projects related driving. When brainstorming, we saw something in the ECE lounge that reminded us of a garage. This led us to parking. Parallel parking is something that many drivers struggle with, yet there are very few tools available to help with parallel parking. Though a few auto manufacturers have developed systems that can parallel park cars autonomously, these solutions are very expensive. We thought this would be both a fun and interesting problem to tackle using an RC Car as a proxy for a real car.
Logical Structure
Our project is broken down into two major components: the control system and the move car algorithm. The move car algorithm directs the car and the control system implements the directions of the move car algorithm.
Control System
The control system contains all the hardware and its associated software. It allows the parking and parking detection algorithms to interface with the car. The software in this module is broken up into three major sections: the Left-Right/Front-Back (LR/FB) state machines, master state machine, and distance calculations. The LR/FB state machines determines which direction to move the car based on flags set by the detect parking space and park car algorithms. Once the LR/FB state machines decides which direction to move the car, the master state machine implements this movement by sending the correct input and enable signals to the H-Bridge. The distance calculations implemented independently every millisecond.
Move Car
Move car contains the detect parking space and parallel parking algorithms. All functions in move car interface with the control module by setting movement flags. The parking space detection and parking algorithms use information from the distance sensors to set these movement flags and guide the car.
Move car works by initializing the movement flags of the car. It sets the car on a default trajectory and then calls detect parking space. Once a parking space has been detected, the parking algorithm is called. After the car has successfully parked, it idles until it is reset.
Hardware/Software Tradeoffs:
Distance Sensors
- When selecting infrared distance sensors there was always a tradeoff between the sensors ability to measure close range and long range. We tried to minimize this problem by using sensors designed for varying ranges.
- Using accurate sensors cost significant time. Every measurement from our distance sensors is approximately 40ms delayed. This affected our ability to start and stop the motors of the car at the correct times.
- We used integer calculations rather than floating point to calculate distances. We decided the increased accuracy would not significantly improve our ability to park the car because we cannot control the movement of the car with that degree of accuracy.
- Each sensor draws a maximum of 50mA. To accommodate for this, we needed to use a 5v regulator that could source up to 1A.
Batteries
- We decided to power our car using batteries rather than using a steady power source. This gave us increased mobility but was very inconsistent in the current it supplied to the motors. As the batteries wore out, they supplied less and less current to the motors. This made calibrating the velocity of the car very difficult.
- In order to best utilize the mobile power resources we have, we power the motors using four AA batteries, which are stored in the battery compartment of the RC car. These batteries supply the Supply Voltage to the H-bridge, which in turn powers the motor. We use a 9V battery to power the PCB.
Software
- 1. Our code requires the motor control software, parking algorithm software, and distance sensor software to run in parallel. However, this is not possible in the Atmega644. We got around this issue by making every important task a state machine. By breaking up each function into small pieces, we can execute one piece of function one, then one piece of function two, followed by one piece of function3, and then another piece of function one, etc. This enables us to emulate a multi-tasking architecture.
Hardware
Hardware consists of three main components:
- RC Car
- H-Bridge
- Distance Sensors
All hardware used the following color convention:
| Color | Connected To |
|---|---|
| Red | Vss |
| Green | Ground |
| Purple | Input |
| Yellow | Output |
| Orange | Enable |
RC Car
The first step of our hardware design involved fully understanding the mechanics our RC car. We took apart the car and rebuilt it multiple times to fully understand how it was built, what every part in the car is used for, and how those parts contribute to the control of the car.
After understanding the mechanics of the car, we decided the easiest way to control our car would be to directly control the inputs to the DC brush motors controlling the front and rear wheels, bypassing all of the car�s internal circuitry. To do this, we scoped the control signals of the car. We found that the control signals were very simple. There is one motor for the reverse and forward movement of the rear wheels and one motor to turn the front wheels left and right. These motors are controlled by a simple 5V DC input. A +5V turns the rear wheels forward and the front wheel to the left. A -5V input turns the rear wheels backwards and turns the front wheels to the right. To more easily control the motors we soldered wires to their plus and minus terminals. This allows us to easily apply a +/-5V without opening up the car again.
H-Bridge
We use an ST Micro L298HN H-Bridge to control the motors of the RC Car. It allows us to switch between +/-5V across the motor. It also allows us to source the power from the batteries while using the processor to control the transistors in the H-Bridge. The control algorithm turns the appropriate transistors on/off, applying the proper voltage across the brush motor. The H-Bridge is connected using the following configuration:
The first H-Bridge (to the left) is used to control the front motor of the car. This motor turns the front wheels either left or right. The second H-Bridge (the the right) is used to control the rear motor, which is used for the forward and reverse functionality of the car. The inputs and enables of the H-Bridge are connected to port B.
| Front Motor (Left/Right) | Rear Motor (Forward/Reverse) |
|---|
| Pin | Connected To | Pin | Connected To |
|---|---|---|---|
| In 1 | Port B7 | In 3 | Port B3 |
| In 2 | Port B6 | In 4 | Port B2 |
| En A | Port B5 | En B | Port B1 |
| Out 1 | + Motor Terminal | Out 3 | + Motor Terminal |
| Out 2 | – Motor Terminal | Out 4 | – Motor Terminal |
Table 2: H-Bridge Pin Configuration
In addition configuring the H-Bridge to control the motors, we also had to protect the H-Bridge from inductive spikes caused by turning the DC brush motors on and off. We used diodes on the output to protect from these spikes.
Distance Sensors
We used three Sharp infrared distance sensors to determine the distance between our car and nearby objects. We placed a sensor on the front, the right side, and the rear of the car. For the front and rear, we used 4-30cm sensors. For the right side, we used we used a 10-80cm sensor. We decided to use a sensor with a larger range for the side so that we could more easily detect a parking space. However, this made aligning the parking the car more difficult, so we rely more heavily on the front and rear sensors to park the car. To slightly improve the short distance range of our sensors, we placed the sensors as far back on the car as possible.
The challenge with using these sensors is that their voltage output is nonlinear (inverse function) and each sensor varies slightly. Therefore, we scoped the output of each sensor at various distance values, linearized the plot, curve fit the line, and implemented an analog to digital conversion so that we had reliable distance values.
Measurements and Linearization
| Distance (cm) | Front Sensor Output (V) | Rear Sensor Output (V) |
|---|---|---|
| 4 | 2.78 | 2.6 |
| 5 | 2.36 | 2.22 |
| 6 | 2.06 | 1.92 |
| 8 | 1.6 | 1.52 |
| 10 | 1.32 | 1.26 |
| 12 | 1.12 | 1.08 |
| 15 | .92 | .88 |
| 18 | .776 | .76 |
| 21 | .664 | .656 |
| 24 | .567 | .576 |
| 27 | .536 | .52 |
| 30 | .476 | .48 |
Parts List:
| Part | Number | Cost |
|---|---|---|
| RC Car | 1 | $20 |
| 10cm-80cm Sharp IR Sensor (GP2Y0A21YK) | 1 | Free (Sampled From Sharp) |
| 4cm-30cm Sharp IR Sensor (GP2D120XJ00F) | 2 | Free (Sampled From Sharp) |
| ST Micro H-Bridge (L298HN) | 1 | Free (Sampled from ST Microelectronics) |
| ATMEGA 644 | 1 | Free (Sampled from Empire Technologies) |
| Custom PC Board | 1 | $4 |
| Small Solder Board | 1 | $2 |
| 9V Battery | 1 | $2 |
| AA Battery | 4 | $2 |
| Headers | 65 | $3.25 |
| Regulator (LM340T5) | 1 | Free (In Lab) |
| Screws and Spacers | Free (In Lab) | |
| Total | $33.25 |
Tasks
Both of us contributed to all parts of the project, however we spent more time working on certain things.
- Design of Hardware: Nagappan
- Design of Control Algorithm: Both
- Design of Parking Algorithm: Prakash
- Testing of Hardware: Both
- Testing of Software: Both
- Compiling Report and Web Site: Both
Read more: Autonomous Self-parking car Using Atmega32