Education Kit

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 SMD Add-on Modules on three combined 11x19 Plate. 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 Inside the Box?

The Education Kit includes a comprehensive selection of components designed to teach students fundamental and advanced robotics concepts:

1x SMD RED Smart Brushed Motor Driver with Speed, Position and Current Control Modes
1x USB Gateway Module
1x 100 RPM DC motors with encoders
1x Ultrasonic distance sensor module
1x servo module with servo motor
1x Ambient Light Sensor Module
1x RGB LED module
1x Button Module
1x Joystick Module
1x Buzzer Module
1x IMU Module
1x Potentiometer Module
1x Reflectance Sensor Module
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:

73MB

Education Kit Connection Setup.pdf

PDF

Open

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);
}

PreviousWhat You Can Build NextWhat You Can Build

Last updated 5 months ago