BO Motor Wheels (4 pcs) Documentation

Component Name

BO Motor Wheels (4 pcs)

Description

The BO Motor Wheels (4 pcs) is a set of four high-quality motorized wheels designed for robotics, automation, and IoT projects. These wheels are specifically engineered to provide reliable and efficient motion control, making them an ideal choice for a wide range of applications, from robotics and mechatronics to DIY projects and prototypes.

Functionality

The BO Motor Wheels (4 pcs) are designed to work in conjunction with DC motors or stepper motors to provide precise control over movement and rotation. Each wheel is equipped with a built-in DC motor or stepper motor, which enables the wheel to rotate independently and accurately. The wheels can be controlled using a microcontroller or a dedicated motor driver, allowing for precise speed and direction control.

Key Features

High-Quality Construction: The BO Motor Wheels (4 pcs) are built with durable materials and feature a robust design, ensuring reliable performance and long lifespan.
Independent Motor Control: Each wheel has its own motor, enabling independent control over rotation and movement.
Precise Speed Control: The wheels can be precisely controlled for speed and direction, making them suitable for applications that require accurate motion control.
Interchangeable Wheels: The wheels are designed to be easily replaceable, allowing for quick maintenance and customization.
Compact Design: The BO Motor Wheels (4 pcs) have a compact design, making them ideal for projects with limited space constraints.
Easy Integration: The wheels are compatible with a wide range of motor drivers and microcontrollers, making integration into existing projects straightforward.
Adjustable Motor Mount: The motor mount is adjustable, allowing for easy alignment and secure attachment to the motor.
High-Grip Tires: The wheels feature high-grip tires, providing excellent traction and stability on various surfaces.

Motor Type

DC motor or stepper motor (dependent on configuration)

Motor Power

12V (dependent on configuration)

Speed Range

0-100 RPM (dependent on configuration)

Torque

10 kg-cm (dependent on configuration)

Wheel Diameter

60 mm

Wheel Width

20 mm

Material

Durable ABS plastic

Weight

150 g per wheel

Applications

Robotics and mechatronics projects

IoT automation systems

DIY projects and prototypes

Autonomous vehicles and drones

Industrial automation and manufacturing

Packing Includes

4 x BO Motor Wheels

4 x Motor mounting screws

1 x User manual

Warranty

The BO Motor Wheels (4 pcs) come with a 6-month warranty against manufacturing defects and faulty materials. For more information, please refer to the warranty documentation provided with the product.

Pin Configuration

BO Motor Wheels (4 pcs) Documentation
Overview
The BO Motor Wheels (4 pcs) are a set of motorized wheels designed for robotics and IoT projects. Each wheel consists of a DC motor, gearbox, and wheel assembly, offering a reliable and efficient solution for movement and navigation. This documentation provides a detailed explanation of the pins on each wheel and guides on how to connect them.
Pin Description
Each BO Motor Wheel has 6 pins, labeled as follows:
VCC (Pin 1): Power supply voltage ( typically 5V or 6V)
GND (Pin 2): Ground connection
INA (Pin 3): Input A (direction control)
INB (Pin 4): Input B (direction control)
ENA (Pin 5): Enable (PWM speed control)
ENC (Pin 6): Encoder output (optional, for speed and direction feedback)
Pin Connection Guide
To connect the BO Motor Wheels, follow these steps:
1. Power Connection
Connect VCC (Pin 1) to the positive terminal of your power source (e.g., a 5V or 6V battery or power supply).
Connect GND (Pin 2) to the negative terminal of your power source.
2. Motor Direction Control
Connect INA (Pin 3) and INB (Pin 4) to the digital output pins of your microcontroller (e.g., Arduino, Raspberry Pi, or ESP32).
Configure your microcontroller to set the direction of the motor by sending a logical high (1) or low (0) signal to INA and INB.
| INA | INB | Motor Direction |
| --- | --- | --- |
| 0 | 0 | Brake (Coast) |
| 0 | 1 | Clockwise |
| 1 | 0 | Counterclockwise |
| 1 | 1 | Brake (Coast) |
3. Speed Control
Connect ENA (Pin 5) to a PWM (Pulse Width Modulation) output pin of your microcontroller.
Configure your microcontroller to generate a PWM signal on ENA to control the motor speed.
4. Encoder Output (Optional)
If you want to use the built-in encoder for speed and direction feedback, connect ENC (Pin 6) to an interrupt-capable digital input pin on your microcontroller.
Configure your microcontroller to read the encoder output and process the data accordingly.
Important Notes
Make sure to use the correct power supply voltage and current rating for your motor wheels.
Use suitable connectors and wires to connect the pins, ensuring a secure and reliable connection.
Follow proper motor control and safety guidelines when working with the BO Motor Wheels.
By following these guidelines, you should be able to successfully connect and utilize the BO Motor Wheels (4 pcs) in your robotics or IoT projects.

Code Examples

BO Motor Wheels (4 pcs) Documentation

Overview

The BO Motor Wheels (4 pcs) is a set of four motor wheels designed for robotics, automation, and IoT projects. Each wheel is equipped with a brushed DC motor and a gear system, allowing for precise control and movement. This component is ideal for building robots, autonomous vehicles, and other mobile platforms.

Technical Specifications

Motor Type: Brushed DC Motor
 Motor Speed: 100 RPM
 Gear Ratio: 1:48
 Power Supply: 3.7V - 6V DC
 Current Consumption: 500mA (max)
 Wheel Diameter: 65mm
 Wheel Width: 20mm
 Communication Protocol: PWM (Pulse Width Modulation)

Code Examples

### Example 1: Basic Motor Control using Arduino

In this example, we will demonstrate how to control the BO Motor Wheels using an Arduino board.

Hardware Requirements

Arduino Uno or compatible board
 BO Motor Wheels (4 pcs)
 Jumper wires
 Breadboard
 Power source (3.7V - 6V DC)

Software Requirements

Arduino IDE (version 1.8.x or later)

Code
```c++
// Define the motor pins
#define MOTOR_LF 2 // Left Front motor
#define MOTOR_LR 3 // Left Rear motor
#define MOTOR_RF 4 // Right Front motor
#define MOTOR_RR 5 // Right Rear motor

void setup() {
  // Set the motor pins as outputs
  pinMode(MOTOR_LF, OUTPUT);
  pinMode(MOTOR_LR, OUTPUT);
  pinMode(MOTOR_RF, OUTPUT);
  pinMode(MOTOR_RR, OUTPUT);
}

void loop() {
  // Move forward
  analogWrite(MOTOR_LF, 255);
  analogWrite(MOTOR_LR, 255);
  analogWrite(MOTOR_RF, 255);
  analogWrite(MOTOR_RR, 255);
  delay(1000);

// Move backward
  analogWrite(MOTOR_LF, -255);
  analogWrite(MOTOR_LR, -255);
  analogWrite(MOTOR_RF, -255);
  analogWrite(MOTOR_RR, -255);
  delay(1000);

// Stop
  analogWrite(MOTOR_LF, 0);
  analogWrite(MOTOR_LR, 0);
  analogWrite(MOTOR_RF, 0);
  analogWrite(MOTOR_RR, 0);
  delay(1000);
}
```
Explanation

In this example, we define the motor pins as outputs and use the `analogWrite()` function to set the motor speeds. A value of 255 corresponds to maximum speed, while a value of -255 corresponds to maximum speed in reverse. The `delay()` function is used to pause the program for a specified amount of time.

### Example 2: Motor Control using Raspberry Pi and Python

In this example, we will demonstrate how to control the BO Motor Wheels using a Raspberry Pi and Python.

Hardware Requirements

Raspberry Pi 3B+ or later
 BO Motor Wheels (4 pcs)
 Jumper wires
 Breadboard
 Power source (3.7V - 6V DC)

Software Requirements

Raspbian OS (latest version)
 Python 3.x

Code
```python
import RPi.GPIO as GPIO
import time

# Set up the GPIO library
GPIO.setmode(GPIO.BCM)

# Define the motor pins
MOTOR_LF = 17
MOTOR_LR = 23
MOTOR_RF = 24
MOTOR_RR = 25

# Set the motor pins as outputs
GPIO.setup(MOTOR_LF, GPIO.OUT)
GPIO.setup(MOTOR_LR, GPIO.OUT)
GPIO.setup(MOTOR_RF, GPIO.OUT)
GPIO.setup(MOTOR_RR, GPIO.OUT)

while True:
    # Move forward
    GPIO.output(MOTOR_LF, GPIO.HIGH)
    GPIO.output(MOTOR_LR, GPIO.HIGH)
    GPIO.output(MOTOR_RF, GPIO.HIGH)
    GPIO.output(MOTOR_RR, GPIO.HIGH)
    time.sleep(1)

# Move backward
    GPIO.output(MOTOR_LF, GPIO.LOW)
    GPIO.output(MOTOR_LR, GPIO.LOW)
    GPIO.output(MOTOR_RF, GPIO.LOW)
    GPIO.output(MOTOR_RR, GPIO.LOW)
    time.sleep(1)

# Stop
    GPIO.output(MOTOR_LF, GPIO.LOW)
    GPIO.output(MOTOR_LR, GPIO.LOW)
    GPIO.output(MOTOR_RF, GPIO.LOW)
    GPIO.output(MOTOR_RR, GPIO.LOW)
    time.sleep(1)
```
Explanation

In this example, we use the RPi.GPIO library to control the motor pins. We define the motor pins as outputs and use the `GPIO.output()` function to set the motor states. A value of `GPIO.HIGH` corresponds to maximum speed, while a value of `GPIO.LOW` corresponds to maximum speed in reverse. The `time.sleep()` function is used to pause the program for a specified amount of time.

Note: These code examples are for demonstration purposes only and may require modifications to suit your specific project requirements. Ensure you follow proper safety precautions and protocols when working with electrical components.