BO Wheel (White) Documentation

Component Name

BO Wheel (White)

Overview

The BO Wheel (White) is a motorized wheel designed for robotics and IoT applications. It is a compact, high-performance wheel that provides precise motion control and versatility for a wide range of projects.

Functionality

The BO Wheel (White) is designed to provide efficient and precise motion control for robots, robotic arms, and other IoT devices. It features a high-torque DC motor that allows for smooth and quiet operation. The wheel is optimized for use in both forward and reverse directions, making it suitable for a variety of applications.

Key Features

High-Torque Motor: The BO Wheel (White) is equipped with a high-torque DC motor that provides rapid acceleration and deceleration. This enables the wheel to handle demanding tasks and navigate challenging terrain.
Precise Motion Control: The wheel features precise motion control capabilities, allowing for accurate speed and direction control. This makes it suitable for applications that require precise movement, such as robotic arms and autonomous vehicles.
Compact Design: The BO Wheel (White) has a compact design that makes it ideal for use in space-constrained applications. Its small size and lightweight construction enable it to be easily integrated into a variety of devices.
Durable Construction: The wheel is built with durability in mind, featuring a robust design that can withstand heavy use and harsh environments.
Easy Integration: The BO Wheel (White) is designed for easy integration into IoT projects. It features a standard mounting system and is compatible with a range of microcontrollers and single-board computers.
Adjustable Speed: The wheel's speed can be adjusted to suit specific application requirements, allowing for fine-tuned control over motor speed and direction.

Motor Type

High-torque DC motor

Motor Speed

Adjustable (up to 100 RPM)

Wheel Diameter

60 mm

Wheel Width

20 mm

Material

Durable plastic

Mounting System

Standard M3 screw mounting

Operating Voltage

6-12 V DC

Operating Current

1-2 A

Communication Protocol

UART, I2C, or SPI (dependent on microcontroller/ Single-board computer)

Applications

The BO Wheel (White) is suitable for a wide range of IoT applications, including

Robotics

Robotic arms

Autonomous vehicles

IoT devices

Smart home devices

Industrial automation

In the Box

1 x BO Wheel (White)

1 x Mounting screws (M3)

1 x User manual

Warranty

The BO Wheel (White) comes with a 1-year limited warranty. For more information, please refer to the warranty documentation provided with the product.

Pin Configuration

BO Wheel (White) Component Documentation
Pinout Description:
The BO Wheel (White) component has a total of 6 pins, which are used to connect and control the wheel's functions. Below is a detailed explanation of each pin:
Pin 1: VCC (Power Supply)
Function: Provides power to the BO Wheel (White) component
Voltage: 3.3V to 5V
Connection: Connect to a power supply or a microcontroller's VCC pin
Pin 2: GND (Ground)
Function: Provides a ground reference for the BO Wheel (White) component
Connection: Connect to a power supply or a microcontroller's GND pin
Pin 3: CLK (Clock)
Function: Used to transmit clock signals to the BO Wheel (White) component
Connection: Connect to a microcontroller's clock output pin (e.g., SCK on Arduino)
Pin 4: DIR (Direction)
Function: Controls the direction of the wheel's rotation
Logic:
+ High (H) or 1: Clockwise rotation
+ Low (L) or 0: Counterclockwise rotation
Connection: Connect to a microcontroller's digital output pin (e.g., D2 on Arduino)
Pin 5: STEP (Step Signal)
Function: Used to transmit step signals to the BO Wheel (White) component
Logic:
+ High (H) or 1: Step signal high
+ Low (L) or 0: Step signal low
Connection: Connect to a microcontroller's digital output pin (e.g., D3 on Arduino)
Pin 6: EN (Enable)
Function: Enables or disables the BO Wheel (White) component
Logic:
+ High (H) or 1: Enabled
+ Low (L) or 0: Disabled
Connection: Connect to a microcontroller's digital output pin (e.g., D4 on Arduino)
Connection Structure:
To connect the BO Wheel (White) component to a microcontroller (e.g., Arduino), follow this structure:
VCC (Pin 1) Microcontroller's VCC pin
GND (Pin 2) Microcontroller's GND pin
CLK (Pin 3) Microcontroller's clock output pin (e.g., SCK)
DIR (Pin 4) Microcontroller's digital output pin (e.g., D2)
STEP (Pin 5) Microcontroller's digital output pin (e.g., D3)
EN (Pin 6) Microcontroller's digital output pin (e.g., D4)
Note: Make sure to use appropriate pull-up or pull-down resistors, and decoupling capacitors as necessary, to ensure stable operation and prevent damage to the component.

Code Examples

BO Wheel (White) Component Documentation

Overview

The BO Wheel (White) is a rotary encoder component designed for IoT applications. It provides a responsive and precise way to measure angular displacement and rotation speed. The component is equipped with a white plastic wheel and a built-in quadrature encoder, making it an ideal choice for navigation, robotics, and other projects that require accurate rotational feedback.

Technical Specifications

Encoder Resolution: 12-bit (4096 steps per revolution)
 Rotation Range: 360
 Output Signals: Quadrature encoder output (A, B, and Index)
 Interface: 5-pin connector (VCC, GND, A, B, IDX)

Code Examples

### Example 1: Basic Rotary Encoder Reading with Arduino

In this example, we'll demonstrate how to read the BO Wheel (White) using an Arduino board.
```c++
#include <Arduino.h>

#define ENCODER_A 2  // Pin for encoder output A
#define ENCODER_B 3  // Pin for encoder output B
#define ENCODER_IDX 4  // Pin for encoder index output

volatile int encoderPos = 0;  // Variable to store the encoder position

void setup() {
  pinMode(ENCODER_A, INPUT);
  pinMode(ENCODER_B, INPUT);
  pinMode(ENCODER_IDX, INPUT);
  attachInterrupt(digitalPinToInterrupt(ENCODER_A), encoderISR, RISING);
}

void loop() {
  // Read and print the current encoder position
  Serial.print("Encoder Position: ");
  Serial.println(encoderPos);
  delay(50);
}

void encoderISR() {
  // Determine the direction of rotation based on the encoder outputs
  if (digitalRead(ENCODER_B) == HIGH) {
    encoderPos++;
  } else {
    encoderPos--;
  }
}
```
### Example 2: Using the BO Wheel with Raspberry Pi and Python

In this example, we'll demonstrate how to read the BO Wheel (White) using a Raspberry Pi and Python.
```python
import RPi.GPIO as GPIO
import time

# Set up GPIO pins for the encoder outputs
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Encoder output A
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Encoder output B
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Encoder index output

encoder_pos = 0

def encoder_callback(channel):
  global encoder_pos
  # Determine the direction of rotation based on the encoder outputs
  if GPIO.input(23) == GPIO.HIGH:
    encoder_pos += 1
  else:
    encoder_pos -= 1

GPIO.add_event_detect(17, GPIO.RISING, callback=encoder_callback, bouncetime=10)

while True:
  # Print the current encoder position
  print("Encoder Position:", encoder_pos)
  time.sleep(0.05)
```
These examples demonstrate the basic usage of the BO Wheel (White) component. You can adapt and modify the code to fit your specific IoT project requirements.