# 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="https://1077748559-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LuxEcL3mxZNc5Aa92N6%2Fuploads%2Fzqg1fHfaquKq9RiercXQ%2FEdu%20Kit%20Isometric.jpg?alt=media&#x26;token=839c25dc-cf8e-4bff-b575-ee6b64eccf9d" alt=""><figcaption><p>Education Kit</p></figcaption></figure>

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

```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="<https://1077748559-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LuxEcL3mxZNc5Aa92N6%2Fuploads%2FBZw9NphPQGQYqppe7aN9%2FEducation%20Kit%20Connection%20Setup.pdf?alt=media&token=f3b98d42-78f5-49ef-a26c-6b7f94b4072d>" %}

## 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 %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.acrome.net/smd-kits/education-kit.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.