Component Documentation: 2 Set Smart Car Robot Chassis Wheel
The 2 Set Smart Car Robot Chassis Wheel is a versatile and durable wheel set designed for robotics and IoT projects. This component is ideal for building smart cars, robots, and autonomous vehicles. The wheel set consists of two wheels with rubber tires, metal hubs, and encoders for tracking speed and direction.
Wheel diameter: 65mm
Wheel width: 25mm
Encoder resolution: 18 pulses per revolution
Motor compatibility: DC motors (not included)
Material: Metal hub, rubber tire
Connection type: 3-pin JST connector
Example 1: Arduino-Based Obstacle Avoidance Robot
In this example, we will demonstrate how to use the 2 Set Smart Car Robot Chassis Wheel with an Arduino Uno board to build a basic obstacle avoidance robot.
1 x Arduino Uno board
1 x 2 Set Smart Car Robot Chassis Wheel
1 x L298N motor driver
1 x Ultrasonic sensor (HC-SR04)
1 x Breadboard
Jumper wires
Arduino IDE (version 1.8.x or later)
Code Example
```cpp
#include <Arduino.h>
// Define motor pins
const int leftMotorForward = 2;
const int leftMotorBackward = 3;
const int rightMotorForward = 4;
const int rightMotorBackward = 5;
// Define ultrasonic sensor pins
const int trigPin = 6;
const int echoPin = 7;
// Define wheel encoder pins
const int leftEncoderA = 8;
const int leftEncoderB = 9;
const int rightEncoderA = 10;
const int rightEncoderB = 11;
void setup() {
// Initialize motor pins as outputs
pinMode(leftMotorForward, OUTPUT);
pinMode(leftMotorBackward, OUTPUT);
pinMode(rightMotorForward, OUTPUT);
pinMode(rightMotorBackward, OUTPUT);
// Initialize ultrasonic sensor pins
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// Initialize wheel encoder pins as inputs
pinMode(leftEncoderA, INPUT);
pinMode(leftEncoderB, INPUT);
pinMode(rightEncoderA, INPUT);
pinMode(rightEncoderB, INPUT);
}
void loop() {
// Read ultrasonic sensor data
int distance = readUltrasonicDistance();
// Avoid obstacles
if (distance < 20) {
stopMotors();
delay(500);
reverseMotors();
delay(500);
} else {
forwardMotors();
}
// Read wheel encoder data
int leftEncoderCount = readEncoder(leftEncoderA, leftEncoderB);
int rightEncoderCount = readEncoder(rightEncoderA, rightEncoderB);
// Print encoder data to serial monitor
Serial.print("Left encoder count: ");
Serial.println(leftEncoderCount);
Serial.print("Right encoder count: ");
Serial.println(rightEncoderCount);
}
int readUltrasonicDistance() {
// Ultrasonic sensor code omitted for brevity
}
void forwardMotors() {
digitalWrite(leftMotorForward, HIGH);
digitalWrite(rightMotorForward, HIGH);
}
void reverseMotors() {
digitalWrite(leftMotorBackward, HIGH);
digitalWrite(rightMotorBackward, HIGH);
}
void stopMotors() {
digitalWrite(leftMotorForward, LOW);
digitalWrite(leftMotorBackward, LOW);
digitalWrite(rightMotorForward, LOW);
digitalWrite(rightMotorBackward, LOW);
}
int readEncoder(int encoderA, int encoderB) {
// Encoder code omitted for brevity
}
```
Example 2: Raspberry Pi-Based Autonomous Vehicle
In this example, we will demonstrate how to use the 2 Set Smart Car Robot Chassis Wheel with a Raspberry Pi board to build a more advanced autonomous vehicle using computer vision and machine learning.
1 x Raspberry Pi 4 board
1 x 2 Set Smart Car Robot Chassis Wheel
1 x L298N motor driver
1 x Raspberry Pi Camera Module
1 x Breadboard
Jumper wires
Raspbian OS (version 10 or later)
OpenCV library (version 4.x or later)
Python 3.x (version 3.7 or later)
Code Example
```python
import cv2
import numpy as np
import RPi.GPIO as GPIO
# Define motor pins
leftMotorForward = 17
leftMotorBackward = 23
rightMotorForward = 24
rightMotorBackward = 25
# Define wheel encoder pins
leftEncoderA = 12
leftEncoderB = 16
rightEncoderA = 20
rightEncoderB = 21
# Initialize GPIO library
GPIO.setmode(GPIO.BCM)
# Initialize motor pins as outputs
GPIO.setup(leftMotorForward, GPIO.OUT)
GPIO.setup(leftMotorBackward, GPIO.OUT)
GPIO.setup(rightMotorForward, GPIO.OUT)
GPIO.setup(rightMotorBackward, GPIO.OUT)
# Initialize wheel encoder pins as inputs
GPIO.setup(leftEncoderA, GPIO.IN)
GPIO.setup(leftEncoderB, GPIO.IN)
GPIO.setup(rightEncoderA, GPIO.IN)
GPIO.setup(rightEncoderB, GPIO.IN)
# Define camera capture object
cap = cv2.VideoCapture(0)
while True:
# Capture frame from camera
ret, frame = cap.read()
# Process frame using OpenCV
# (Code omitted for brevity)
# Read wheel encoder data
leftEncoderCount = read_encoder(leftEncoderA, leftEncoderB)
rightEncoderCount = read_encoder(rightEncoderA, rightEncoderB)
# Control motors based on computer vision output
if (leftEncoderCount > 100 and rightEncoderCount > 100):
forward_motors()
elif (leftEncoderCount < -100 and rightEncoderCount < -100):
reverse_motors()
else:
stop_motors()
# Print encoder data to console
print("Left encoder count:", leftEncoderCount)
print("Right encoder count:", rightEncoderCount)
def read_encoder(encoderA, encoderB):
# Encoder code omitted for brevity
pass
def forward_motors():
GPIO.output(leftMotorForward, GPIO.HIGH)
GPIO.output(rightMotorForward, GPIO.HIGH)
def reverse_motors():
GPIO.output(leftMotorBackward, GPIO.HIGH)
GPIO.output(rightMotorBackward, GPIO.HIGH)
def stop_motors():
GPIO.output(leftMotorForward, GPIO.LOW)
GPIO.output(leftMotorBackward, GPIO.LOW)
GPIO.output(rightMotorForward, GPIO.LOW)
GPIO.output(rightMotorBackward, GPIO.LOW)
```
Note: The code examples provided are simplified and may require additional libraries, dependencies, and calibration for optimal performance.
