Working Model of Chandrayaan-3 Pragyan Lunar Rover

The Pragyan rover is the six-wheeled lunar rover from India’s Chandrayaan-3 mission, designed to traverse the Moon’s surface with a rocker-bogie suspension system. In this project, we’ll build a working miniature model of the Pragyan rover. This DIY rover will be able to drive around, demonstrating the same six-wheel drive and suspension concept that allows the real Pragyan to handle rough terrain. Building this model is a fun way to celebrate the Chandrayaan-3 mission and learn about robotics and engineering. By following this guide, you will learn how to construct the chassis, assemble a rocker-bogie mechanism, integrate motors and electronics, and remotely control your own small-scale rover. The rover’s small size and simple design make it affordable, easy to build, and easy to operate, even for beginners.

Control system components

1. Arduino uno
2. L293D Motor driver shield
3. 6 DC motors
4. 6 tyres (3d printed)
5. Mainbody+links (3 printed)
6. 2 servo motors
7. Various attachments (3d printed)
8. 5mm,4mm,3mm and 2mm screws
9. Self-locking nuts 4mm and 5mm
10. 7V power supply

Network control components

1. Raspberry Pi
2. USB webcam(for video streaming and recording)
3. Pi camera (for still images)
4. 5V power supply

The first step is to prepare the rover’s chassis, which is the main body that will hold the electronics and serve as the attachment point for the suspension. If you have a 3D-printed chassis design (for example, from the video’s provided files), print it out and skip to mounting components. Otherwise, you can improvise: for example, use a small plastic lunch box or a sturdy rectangular container as the rover body. Ensure the chassis is big enough to fit your Arduino, battery, and motor driver inside, and long enough to space out the wheel pairs (the real Pragyan rover is about 90 cm long, but your model could be around 30 cm long – use a size that fits your components).

If using a custom box or plate, mark and drill holes or cut notches where the suspension arms and motors will attach. Typically, you’ll need:

1. Front/Rear Suspension Mounts: Two points on each side of the chassis to attach the rocker-bogie arms (one toward the front, one toward the rear). These can be bolts, brackets or printed pegs that the arms will pivot on. Make sure these points are aligned and at the same height on both sides.
2. Electronics Mounting: Drill small holes or use standoffs inside the chassis to mount the Arduino board and motor driver securely. You can also use adhesive Velcro or double-sided tape to stick down the boards and battery for now.
3. Access: If your chassis is enclosed (like a box), consider cutting an opening or door to access the inside, so you can adjust wiring or remove the battery to charge.

Tip: Keep the chassis light but sturdy. If using a thin plastic box, reinforce areas where motors or arms attach (for example, add an extra piece of plastic or wood inside as backing for a screw). A lighter rover will drive easier, but it should be strong enough not to flex too much when the suspension moves.

The rocker-bogie mechanism is what gives the rover its ability to climb over uneven terrain with all wheels on the ground. It consists of two “rocker” arms (one on each side of the rover) and two smaller “bogie” links on each side connecting the wheels. Here’s how to build it:

1. Prepare the Arms: If you have 3D-printed suspension arms and links (often provided in the project files), gather those pieces. Otherwise, you can make the arms from PVC pipe or thick cardboard
2. You will need:
3. Rockers: Two long arms (left and right) that will connect the front wheel assembly to the rear wheel. Each rocker will pivot roughly at the middle (where it attaches to the chassis mount).
4. Bogie links: Four shorter link pieces (two per side) that connect the front wheel to the middle wheel on each side. In a classic rocker-bogie, the bogie is hinged to the rocker near the front wheel.
5. Attach Bogie to Rocker: On each side, attach a bogie link to the front end of the rocker arm using a bolt or axle that allows it to pivot. This joint should be snug but freely rotating. The other end of the bogie will later hold the front and middle wheel motors. For now, ensure the rocker and bogie can swing relative to each other. Repeat for both sides.
6. Mount Rockers to Chassis: Now attach each rocker arm to the chassis at the pivot point you prepared (toward the middle of the arm). This is the main suspension hinge where the arm rocks. Use a bolt or shaft through the chassis wall so the rocker can rotate up and down. It’s important that the left and right rockers are mounted at the same height and position on each side of the chassis, so the rover sits level. If using a single rod through the chassis linking both rockers, that can act as a simple differential bar to keep them coupled; otherwise you can leave them independent for simplicity.
7. Check Motion: At this stage, the rocker-bogie suspension on each side should resemble a triangle of links: the rocker attached to the chassis, and a bogie link hinged at the rocker’s front end. When you lift one end of the rocker, the bogie and chassis should pivot accordingly. This mimics how the rover will keep its wheels on the ground when going over obstacles. Make sure all pivot joints move smoothly. You can add a drop of oil or graphite to metal hinge points if needed.

With the suspension in place, it’s time to attach the six wheels and motors that will drive the rover:

1. Mount the Motors: Each wheel is powered by a small DC gear motor. Typically, the front and middle wheels on each side attach to the ends of the bogie link, and the rear wheel attaches to the end of the rocker arm. If you 3D-printed the suspension, there will be brackets or slots for the motors. Otherwise, you may need to fabricate mounts: for example, drill holes in the pipe or cardboard link and use zip-ties or clamps to hold the motor in place (ensure the wheel axle is roughly perpendicular to the ground). Mount all six motors — three on each side of the rover. The orientation should be such that the wheels will sit evenly on the ground and the rover’s chassis is roughly level when all wheels touch the ground.
2. Attach Wheels: Push each wheel onto the shaft of its motor. Many TT gear motors come with press-fit wheels. Make sure they are secure on the shafts. If you 3D-printed custom wheels, you may need a small screw to lock the wheel to the motor shaft. Tip: If using custom wheels, consider adding rubber bands or O-rings around the rim for better traction, as plastic wheels can slip.
3. Secure Wiring Positions: As you mount the motors, take note of the motor wires. It’s best to route the wires along the suspension arms toward the chassis, leaving slack for the movement. You can tape or hot-glue the wires along the arm so they don’t tangle with the wheels. Later, these wires will connect to the motor driver inside the chassis.
4. Test Suspension with Wheels: Gently set the rover on a flat surface to see how it rests on its six wheels. The weight of the chassis should be supported by all wheels fairly evenly. Press down on the chassis on one side to simulate an obstacle — the rocker-bogie should allow one wheel to rise while the others stay on the ground. If something feels loose or wobbly, tighten the joints or add supports as needed.

At this point, the mechanical build is complete: you have a rolling chassis with a functional suspension and wheels. Now we’ll move on to the electronics to make it actually drive.

Now it’s time to bring the rover to life by wiring up the motors, battery, and control electronics. We will use the Arduino as the controller and the L298N (or L293D) driver to handle the motor power. The Bluetooth module will allow us to control the rover wirelessly.

1. Motor Driver Wiring: The L298N motor driver typically has two channels (able to control 4 motors forward/backward). We have six motors, so we will pair motors on each side. Connect the three left-side motors in parallel to the driver’s Channel A outputs, and the three right-side motors in parallel to Channel B. In practice, you can wire the front, middle, and rear left motors together (all red wires join, all black wires join) to the two output terminals of Channel A. Do the same for the right motors on Channel. (This means all left wheels will always turn together, likewise for all right wheels.) Ensure your connections are secure (solder or tightly screw into the driver terminals). If your driver is an L293D IC, you may need two ICs or a custom wiring – in that case, it might be easier to only use four motors or get a dual-channel driver board for six motors.
2. Arduino Connections: Connect the Arduino’s digital output pins to the motor driver inputs. For an L298N, there are typically four input pins (IN1, IN2 for Channel A and IN3, IN4 for Channel B) plus enable pins. For example, you could use:
3. Arduino D8 -> IN1
4. Arduino D9 -> IN2 (these two will control left motors’ direction)
5. Arduino D10 -> IN3
6. Arduino D11 -> IN4 (these control right motors)
7. Arduino D5 and D6 -> ENA and ENB (the enable PWM pins for speed control, if your driver has them; otherwise tie ENA/ENB jumpers to enable).
8. Also connect the driver’s ground to Arduino GND, and driver’s +V (motor power) to your battery positive. Do not power the motors from the Arduino’s 5V output – use the external battery (through the driver) for the motors.
9. Bluetooth Module: Connect the HC-05 Bluetooth module to the Arduino. Typically: HC-05 TX -> Arduino RX (e.g. pin 6 if using SoftwareSerial), HC-05 RX -> Arduino TX (pin 7 with voltage divider if 5V Arduino), and Vcc -> 5V, GND -> GND. This will allow the Arduino to receive commands from your phone. (Ensure the communication pins match the code you’ll use – in the example code, SoftwareSerial on pins 6 and 7 was used.)
10. Sensors/Servos (Optional): If you are adding an ultrasonic sensor, mount it at the front of the rover (perhaps on the chassis or on a servo to allow scanning). Connect its Trig and Echo pins to Arduino (e.g. A0 and A1 as in our code). If using servos for an extra mechanism (like a moving solar panel or instrument arm), mount those on the rover and connect their control wires to two Arduino PWM pins (e.g. D4 and D5 as in code). In the demonstration project, two servos were used to raise and lower an attachment on the rover. This is optional, but you can get creative here.
11. Power Connections: Connect your battery pack to the motor driver’s power input. If your Arduino is running from the same battery, you can either supply the Arduino via its VIN pin or a separate 5V regulator. For example, a 7.4V battery can go to VIN on the Arduino (which has an onboard regulator). Important: Make sure the grounds of all systems (battery, Arduino, motor driver, Bluetooth, etc.) are common. A common ground is necessary for the control signals to reference correctly. Also, if using a separate power source for logic vs. motors, connect the grounds together.
12. Safety Check: Double-check all wiring before powering up. Ensure that the motor driver’s outputs are wired to motors (not accidentally shorted), the polarity of power is correct (battery + to VIN, – to GND), and that the Bluetooth module is connected correctly (the HC-05’s RX should not get 5V directly – use a voltage divider or a dedicated level shifter if needed, as it expects 3.3V on RX pin).

Now your rover’s hardware is fully wired. The last step in wiring is to upload a control code to the Arduino.

1. Programming the Arduino: Write or upload an Arduino sketch that listens for commands (from Bluetooth) and drives the motors accordingly. For example, the code can use characters like 'F' for forward, 'B' for backward, 'L' for left turn, 'R' for right turn, etc., which you’ll send from a phone app. When 'F' is received, the Arduino sets both left and right motor pins to move forward (left motors and right motors both forward). For 'L' (turn left), it might stop or reverse the left side motors and forward on the right side to skid-steer. Incorporate any sensor logic if you added an ultrasonic (e.g., stop or slow down if an obstacle is too close). Ensure the code also handles the servo actions if you included them (for example, 'U' to raise a servo, 'D' to lower it).
2. Tip: If the rover’s wheels spin in the wrong direction (e.g., your forward command makes it go backward or turn opposite), simply swap the wiring of that motor pair at the driver output (or swap which Arduino pin is HIGH/LOW in code). Reversing the polarity will reverse the motor direction. It often takes a quick test to ensure your left/right assignments are correct.

Upload the code to the Arduino. With that, the electronics assembly is complete – it’s time to test and drive your rover!

For WiFi and internet control. This is a little tricky because we will use a Raspberry Pi for this. First, you need to connect to the Raspberry Pi via SSH through Remote Desktop Connection. Then run the Rovercontrol script, and it will ask you to connect to the Arduino board via Bluetooth. Once done it will open up a window, and now use the w,a,s,d keys to drive the rover and press j to stop it.

To control the camera, run the webcam script. It will start the live video to take a still picture. Use this command in the terminal window

Copy

Both cameras work independently of each other and can be used at the same time.

To set up RaspiCam, Click here

Webcam script uses OpenCV 3 running on Python 3 to set up that click here

1. Initial Test (Wheels off ground): It’s wise to do a quick motor test with the rover suspended (wheels not touching the ground). Turn on the power and use the Bluetooth app (or Serial monitor via USB cable) to send a command to the Arduino. For example, send “F” for forward. Verify that all six wheels spin in the correct direction (all forwards for “F”). Try “B” and check they all reverse. Test left and right commands – the wheels on each side should spin opposite directions for a turn. This bench test ensures the wiring and code are working before the rover drives on its own. If any wheel isn’t spinning or goes the wrong way, troubleshoot the wiring or code now.
2. Drive Test: Place the rover on the floor, ideally a flat area with some space. Using a Bluetooth RC app on your phone (there are many free apps that allow sending characters via Bluetooth, or you can use a custom interface), connect to the HC-05 module (usually it appears as “HC-05” or “HC-06” and the default PIN is 1234). Once connected, use the controls to drive the rover. It should move forward, backward, and turn left/right on command. Because it uses skid steering (differential wheel speed), turns will be in place or in an arc depending on how you program it. Practice driving and see how it responds.
3. Obstacle Handling: Try driving the rover over a small obstacle or ramp to see the suspension in action. For example, place a book or a few centimeter high object and let the rover climb over it. The rocker-bogie suspension will allow the front wheels to rise and the rear rocker to tilt, keeping the rover relatively stable. This mimics how the real Pragyan rover can handle rocks and craters by distributing weight across its wheels.
4. Troubleshooting: If the rover struggles to move or turns very slowly, your battery might be weak – ensure it’s fully charged or use a higher current source. If it veers to one side when going straight, double-check that all motors on each side are actually powered and that there’s no binding in the wheel movement. You may also adjust the code to fine-tune motor speeds (for example, if one side’s motors are slightly slower, you can compensate via PWM values).
5. Finishing Touches: Now the fun part – making it look like Pragyan! The Pragyan rover had a solar panel on top and an antenna. You can cut a small piece of cardboard or plastic to act as a solar panel (paint it black or dark blue) and glue it on top of your rover’s body. An antenna can be made from a thin rod or wire; attach it to the body, possibly connected to one of the servos if you want to make it deploy or rotate. You could also 3D-print decorative parts if you have files – for example, wheel covers or an ISRO logo. These don’t affect function, so feel free to get creative.
6. If you included servos, program some movement for the decorative parts (maybe the solar panel tilts up when the rover “powers on” or the antenna rotates). These details make your model more realistic. Just keep the added weight minimal so as not to strain the motors.
7. Safety Precautions: As you finalize the build, secure any exposed wires and sharp edges. Use electrical tape or heat-shrink on wire joints to prevent shorts. If the battery is inside the chassis, ensure it’s fixed in place (loose batteries can jostle and unplug during motion). A small on/off switch wired from the battery to the electronics is very handy so you don’t have to pull wires to power off.

At this stage, you should have a fully built and tested Pragyan rover model! It should be able to drive around via Bluetooth control, navigate small obstacles with ease, and look the part of a miniature lunar rover.