The Acrome Education Kit is designed to provide students, educators, and robotics enthusiasts with a hands-on learning experience in motion control, automation, and embedded systems. This kit simplifies the learning process for beginners while offering advanced features for researchers and industry professionals.
With a structured hardware-software ecosystem, users can explore concepts in robotics, mechatronics, programming, and real-time control, making it a perfect choice for STEM education, university labs, and prototyping projects.
The Education Kit has all on three combined . It allows the users to interact with all the sensors that is available on the add-on modules and understand their working principle through experience. This kit is ideally created for educational purposes.
Who Is It For?
High school and university educators
Engineering lab coordinators
Technical training programs
STEM-focused classrooms
What’s Included?
The Education Kit includes a comprehensive selection of components designed to teach students fundamental and advanced robotics concepts:
All necessary RJ-45 cables and connectors
Pre-configured power supply and mounting hardware
Key Learning Outcomes
With this kit, students will:
Understand core principles of robotics and motion control
Gain hands-on experience with PID algorithms and sensor integration
Learn modular design and how to build reconfigurable robots
Develop real-world problem-solving and programming skills
Apply theoretical knowledge in physics, math, and computer science
How to Use the Acrome Education Kit?
The Education Kit supports a step-by-step learning process, making it accessible for beginners, educators, and advanced users.
-Beginner Level: Drag & Drop Programming (Blockly UI)
Blockly-based visual programming allows users to control motors and sensors without writing code.
Ideal for high school students and first-time robotics learners.
Example: Move a motor forward for 5 seconds using Blockly.
-Intermediate Level: Python API for Robotics Control
Write Python scripts to control motors, read sensors, and perform automated tasks.
Great for university projects, mechatronics coursework, and industrial training.
Example:
set_motor_speed(left_motor=50, right_motor=50) # Move forward
time.sleep(2) # Wait for 2 seconds
stop_motors() # Stop movement
-Advanced Level: AI, IoT & Industry 4.0 Applications
Implement PID control algorithms for smooth motion.
Integrate AI-based object tracking, real-time data logging, and IoT connectivity.
Example: Use machine learning for autonomous robot navigation.
Real-World Applications
The Acrome Education Kit is designed for academic learning, research, and prototyping, with applications in:
STEM Education & University Labs – Robotics, automation, and programming courses.
Industrial Training – Understanding servo motors, stepper motors, and real-time control.
AI & Machine Learning – Develop autonomous robots with sensor fusion.
IoT & Smart Automation – Create smart home systems and automated machinery.
Assembly Guide
A detailed step-by-step assembly guide is available as a PDF document:
Codes:
from smd.red import *
import os
import sys
from serial.tools.list_ports import comports
from platform import system
from colorama import Fore, Style
from tabulate import tabulate
from random import randint
id = 0
module_id = 1
def USB_Port():
ports = list(comports())
usb_names = {
"Windows": ["USB Serial Port"],
"Linux": ["/dev/ttyUSB"],
"Darwin": [
"/dev/tty.usbserial",
"/dev/tty.usbmodem",
"/dev/tty.SLAB_USBtoUART",
"/dev/tty.wchusbserial",
"/dev/cu.usbserial",
"/dev/cu.usbmodem",
"/dev/cu.SLAB_USBtoUART",
"/dev/cu.wchusbserial",
]
}
os_name = system()
if ports:
for port, desc, hwid in sorted(ports):
if any(name in port or name in desc for name in usb_names.get(os_name, [])):
return port
print("Current ports:")
for port, desc, hwid in ports:
print(f"Port: {port}, Description: {desc}, Hardware ID: {hwid}")
else:
print("No port found")
return None
port = USB_Port()
m = Master(port)
m.attach(Red(id))
try:
print("Scanning process is starting...")
connected_modules = m.scan_modules(id)
except serial.serialutil.PortNotOpenError:
print("Please check the USB Gateway. If it's plugged, unplug and plug again.")
input("\nPress enter to exit.")
if system() == "Windows":
os.system('cls')
else:
os.system('clear')
print(connected_modules)
def colorize_str(str, boolean):
return f"{Fore.GREEN}{str} found!{Style.RESET_ALL}" if boolean else f"{Fore.RED}{str} not found.{Style.RESET_ALL}"
############### Module Test Functions ###############
########################################################################################################################
## Global variables ##
motor_speed = 0
servo_position = 0
old_pot = 0
new_pot = 0
latency = 0
######################
data = m.get_variables(id, [Index.Button_1, Index.Buzzer_1, Index.Distance_1, Index.IMU_1, Index.Joystick_1, Index.Light_1, Index.Pot_1, Index.RGB_1, Index.Servo_1, Index.QTR_1])
######################
def button_test(check:bool, button_state):
if check:
button_state = m.get_button(id, module_id)
if button_state:
R = randint(0,255)
G = randint(0,255)
B = randint(0,255)
m.set_rgb(id, module_id, R, G, B)
return button_state
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def buzzer_test(check:bool, button_state):
if check:
if button_state:
freq = randint(100,4000)
m.set_buzzer(id, module_id, freq)
return f"Buzzer Frequency: {freq} Hz"
else:
return "Button is not pressed"
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def distance_test(check:bool, distance):
if check:
if distance > 30:
distance = 0
elif 20 <= distance <= 30 and distance != 0:
R = 0
G = 255
B = 0
m.set_rgb(id, module_id, int(R), int(G), int(B))
m.set_buzzer(id, module_id, 400)
elif 10 <= distance < 20 and distance != 0:
R = 255
G = 55
B = 0
m.set_rgb(id, module_id, int(R), int(G), int(B))
m.set_buzzer(id, module_id, 800)
elif 0 <= distance < 10 and distance != 0:
R = 255
G = 0
B = 0
m.set_rgb(id, module_id, int(R), int(G), int(B))
m.set_buzzer(id, module_id, 1200)
return distance
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def imu_test(check:bool, imu):
if check:
return imu
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def joystick_test(check:bool, joystick_data):
if check:
global motor_speed
if joystick_data[0] > 10 or joystick_data[0] < -10:
m.set_duty_cycle(id, joystick_data[0])
motor_speed = joystick_data[0]
elif 0 <= joystick_data[0] < 10 or 0 >= joystick_data[0] > -10:
m.set_duty_cycle(id, 0)
motor_speed = joystick_data[0]
return f"X: {joystick_data[0]} Y: {joystick_data[1]} Button: {joystick_data[2]} Motor Speed: {motor_speed}"
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def light_test(check:bool, ambient_light):
if check:
ambient_light = m.get_light(id, module_id)
if ambient_light < 150:
m.set_rgb(id, module_id, 255, 255, 255)
elif ambient_light > 300:
m.set_rgb(id, module_id, 0, 0, 0)
return ambient_light
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def pot_test(check:bool, pot):
if check:
global old_pot
global new_pot
old_pot = new_pot
potentiometer_data = pot
new_pot = potentiometer_data
delta_pot = abs(new_pot - old_pot)
if potentiometer_data <= 180 and delta_pot > 5:
m.set_servo(id, module_id, potentiometer_data)
elif potentiometer_data > 180 and delta_pot > 5:
m.set_servo(id, module_id, 180)
return potentiometer_data
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def rgb_test(check:bool, button_data):
if check:
button_data = m.get_button(id, module_id)
if button_data:
R = randint(0,255)
G = randint(0,255)
B = randint(0,255)
m.set_rgb(id, module_id, R, G, B)
time.sleep(0.02)
return f"R: {R} G: {G} B: {B}"
else:
return "Button is not pressed"
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def servo_test(check:bool, imu_data):
if check:
global servo_position
try:
imu_data = imu_data[0]
servo_position = (((imu_data + 90) * 180) / 180)
if imu_data > 5 or imu_data < -5:
m.set_servo(id, module_id, int(servo_position))
except:
pass
return servo_position
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
def qtr_test(check:bool, qtr_data):
if check:
if qtr_data[0] < 50:
m.set_buzzer(id, module_id, 262) # C4
elif qtr_data[1] < 50:
m.set_buzzer(id, module_id, 294) # D4
elif qtr_data[2] < 50:
m.set_buzzer(id, module_id, 330) # E4
else:
m.set_buzzer(id, module_id, 0) # Empty note
return qtr_data
else:
return f"{Fore.RED}Not Connected{Style.RESET_ALL}"
########################################################################################################################
############### Module Connection Check ###############
########################################################################################################################
BUTTON_check = False
BUZZER_check = False
DISTANCE_check = False
IMU_check = False
JOYSTICK_check = False
LIGHT_check = False
POT_check = False
RGB_check = False
SERVO_check = False
QTR_check = False
try:
if ("Button_" + str(module_id)) in connected_modules:
BUTTON_check = True
if ("Buzzer_" + str(module_id)) in connected_modules:
BUZZER_check = True
if ("Distance_" + str(module_id)) in connected_modules:
DISTANCE_check = True
if ("IMU_" + str(module_id)) in connected_modules:
IMU_check = True
if ("Joystick_" + str(module_id)) in connected_modules:
JOYSTICK_check = True
if ("Light_" + str(module_id)) in connected_modules:
LIGHT_check = True
if ("Pot_" + str(module_id)) in connected_modules:
POT_check = True
if ("RGB_" + str(module_id)) in connected_modules:
RGB_check = True
if ("Servo_" + str(module_id)) in connected_modules:
SERVO_check = True
if ("QTR_" + str(module_id)) in connected_modules:
QTR_check = True
except:
print("\nNO MODULES CONNECTED!\n")
module_check_data = [["Button module", colorize_str("Button module", BUTTON_check)],
["Buzzer module", colorize_str("Buzzer module", BUZZER_check)],
["Distance module", colorize_str("Distance module", DISTANCE_check)],
["IMU module", colorize_str("IMU module", IMU_check)],
["Joystick module", colorize_str("Joystick module", JOYSTICK_check)],
["Light module", colorize_str("Light module", LIGHT_check)],
["Potentiometer module", colorize_str("Pot module", POT_check)],
["RGB module", colorize_str("RGB module", RGB_check)],
["Servo module", colorize_str("Servo module", SERVO_check)],
["QTR module", colorize_str("QTR module", QTR_check)]]
module_check_table = tabulate(module_check_data, headers=['Modules', 'States'], tablefmt="rounded_grid")
print(module_check_table)
########################################################################################################################
test_input = str(input("Press enter to start the test, write 'exit' to close the program: "))
if test_input == "exit":
sys.exit()
else:
m.set_operation_mode(id, 0)
m.enable_torque(id, 1)
pass
while True:
data = m.get_variables(id, [Index.Button_1, Index.Distance_1, Index.IMU_1, Index.Joystick_1, Index.Light_1, Index.Pot_1, Index.QTR_1])
test_result = [ ["Button module", button_test(BUTTON_check, data[0])],
["Buzzer module", buzzer_test(BUZZER_check, data[0])],
["Distance module", distance_test(DISTANCE_check, data[1])],
["IMU module", imu_test(IMU_check, data[2])],
["Joystick module", joystick_test(JOYSTICK_check, data[3])],
["Light module", light_test(LIGHT_check, data[4])],
["Potentiometer module", pot_test(POT_check, data[5])],
["RGB module", rgb_test(RGB_check, data[0])],
["Servo module", servo_test(SERVO_check, data[2])],
["QTR module", qtr_test(QTR_check, data[6])]]
test_table = tabulate(test_result, headers=["Modules", "Results"], tablefmt="rounded_grid")
if system() == "Windows":
os.system('cls')
else:
os.system('clear')
print(test_table)
#include "Acrome-SMD.h"
#define ID 0
#define BAUDRATE 115200
#define MODULE_ID 1
#define MAX_DISTANCE 30
#define JOYSTICK_DEADZONE 10
#define LIGHT_THRESHOLD_LOW 150
#define LIGHT_THRESHOLD_HIGH 300
#define MAX_SERVO_ANGLE 180
#define POT_DELTA_THRESHOLD 5
Red master(ID, Serial, BAUDRATE);
int servo_position = 0;
int old_pot = 0;
int new_pot = 0;
bool BUTTON_check = true;
bool BUZZER_check = true;
bool DISTANCE_check = true;
bool IMU_check = true;
bool JOYSTICK_check = true;
bool LIGHT_check = true;
bool POT_check = true;
bool RGB_check = true;
bool SERVO_check = true;
bool QTR_check = false;
void setup() {
master.begin();
}
void loop() {
// Button and RGB Test
if (BUTTON_check && RGB_check) {
if (master.getButton(MODULE_ID)) {
master.setRGB(MODULE_ID, random(256), random(256), random(256));
}
}
// Buzzer Test
if (BUZZER_check) {
if (master.getButton(MODULE_ID)) {
master.setBuzzer(MODULE_ID, random(100, 4000));
} else {
master.setBuzzer(MODULE_ID, 0);
}
}
// Distance Test
if (DISTANCE_check) {
int distance = master.getDistance(MODULE_ID);
if (distance <= MAX_DISTANCE) {
if (distance > 20) {
master.setRGB(MODULE_ID, 0, 255, 0);
master.setBuzzer(MODULE_ID, 400);
} else if (distance > 10) {
master.setRGB(MODULE_ID, 255, 55, 0);
master.setBuzzer(MODULE_ID, 800);
} else {
master.setRGB(MODULE_ID, 255, 0, 0);
master.setBuzzer(MODULE_ID, 1200);
}
}
}
// IMU and Servo Test
if (IMU_check && SERVO_check) {
float roll = master.getRollAngle(MODULE_ID);
if (abs(roll) > 5) {
servo_position = ((roll + 90) * 180) / 180;
master.setServo(MODULE_ID, servo_position);
}
}
// Joystick Test
if (JOYSTICK_check) {
int joystickX = master.getJoystickX(MODULE_ID);
master.setOperationMode(0);
master.torqueEnable(1);
if (abs(joystickX) > JOYSTICK_DEADZONE) {
master.setpoint(0,float(joystickX));
} else {
master.setpoint(0,0);
}
}
// Light Test
if (LIGHT_check && RGB_check) {
int lightLevel = master.getLight(MODULE_ID);
if (lightLevel < LIGHT_THRESHOLD_LOW) {
master.setRGB(MODULE_ID, 255, 255, 255);
} else if (lightLevel > LIGHT_THRESHOLD_HIGH) {
master.setRGB(MODULE_ID, 0, 0, 0);
}
}
// Potentiometer and Servo Test
if (POT_check && SERVO_check) {
old_pot = new_pot;
new_pot = master.getPotentiometer(MODULE_ID);
if (abs(new_pot - old_pot) > POT_DELTA_THRESHOLD) {
master.setServo(MODULE_ID, min(new_pot, MAX_SERVO_ANGLE));
}
}
// QTR Test
if (QTR_check && BUZZER_check) {
QTRValues qtrData = master.getQTR(MODULE_ID);
if (qtrData.LeftValue < 50) {
master.setBuzzer(MODULE_ID, 262);
} else if (qtrData.MiddleValue < 50) {
master.setBuzzer(MODULE_ID, 294);
} else if (qtrData.RightValue < 50) {
master.setBuzzer(MODULE_ID, 330);
} else {
master.setBuzzer(MODULE_ID, 0);
}
}
delay(10);
}
1x Smart Brushed Motor Driver with Speed, Position and Current Control Modes