> For the complete documentation index, see [llms.txt](https://docs.acrome.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.acrome.net/smd-kits/education-kit.md).

# 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.

<figure><img src="/files/YazU6MmllAoH2RuOcudL" alt=""><figcaption><p>Education Kit</p></figcaption></figure>

The Education Kit has all [SMD Add-on Modules](/electronics/add-on-modules.md) on three combined [11x19 Plate](/mechanics/building-set/plates/11x19-plate.md). 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](/electronics/smd-red.md) Smart Brushed Motor Driver with Speed, Position and Current Control Modes
* 1x [USB Gateway Module](/electronics/gateway-modules/usb-gateway-module.md)
* 1x[ 100 RPM DC motors with encoders](/electronics/electrical-motors/brushed-dc-motors-bdc.md)
* 1x [Ultrasonic distance sensor module](/electronics/add-on-modules/ultrasonic-distance-sensor-module.md)
* 1x[ servo module](/electronics/add-on-modules/servo-module.md) with servo motor
* 1x [Ambient Light Sensor Module](/electronics/add-on-modules/ambient-light-sensor-module.md)
* 1x [RGB LED module](/electronics/add-on-modules/rgb-led-module.md)
* 1x [Button Module](/electronics/add-on-modules/button-module.md)
* 1x[ Joystick Module](/electronics/add-on-modules/joystick-module.md)
* 1x [Buzzer Module](/electronics/add-on-modules/buzzer-module.md)
* 1x[ IMU Module](/electronics/add-on-modules/imu-module.md)
* 1x [Potentiometer Module](/electronics/add-on-modules/potentiometer-module.md)
* 1x [Reflectance Sensor Module](/electronics/add-on-modules/reflectance-sensor-module.md)
* 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:

```python
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:

{% file src="/files/MmpoZGdvznKiTbGiCFn2" %}

## Codes

{% tabs %}
{% tab title="The Education Kit Project Python" %}
{% code lineNumbers="true" %}

```python
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)
    
```

{% endcode %}
{% endtab %}

{% tab title="The Education Kit Project Arduino" %}
{% code lineNumbers="true" fullWidth="true" %}

```cpp
#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);
}
```

{% endcode %}
{% endtab %}
{% endtabs %}