I made a fairy story with GenAI! 

Generative Artificial Intelligence, GenAI, is really cool! It helps me create stories, pictures, and animations—it’s like magic!

My Story Idea:

In my story, Adventures of Bella, Bella explores the enchanted forest. A wise owl gives her a map to hidden treasure!

How I Did It:

🌲 I imagined an enchanted forest.

🦉 I added Bella, an owl, and treasure.

✨ GenAI made pictures for my story!

Have you ever seen robots that help move boxes in big warehouses? Now, you can build a mini version! This little robot will follow a black line on the ground to move from one place to another, just like real robots in factories and warehouses. It’s a fun way to learn how robots follow paths!

We can enhance our robot by adding an ultrasonic sensor to detect obstacles and stop automatically, and by controlling it with an IR remote for manual operation

Components Needed

1. ATmega328P-ELF Mainboard (The brain of the robot)
2. Double-way Line-following Sensor (To detect and follow the black line)
3. Motors & Wheels (To move the robot)
4. USB Cable (To connect to the laptop for programming)
5. Ultrasonic Sensor (Optional – To detect obstacles and stop automatically)
6. IR Receiver & IR Remote Control (Optional – For manual operation and control)

Pseudo Code:

# Initialize Libraries and Components
Initialize line-following sensor
Initialize ultrasonic sensor
Initialize motors and wheels
Initialize IR receiver (optional)
Initialize IR remote (optional)

# Start the robot movement
While robot is running:
    Read line-following sensor data
    If sensor detects line:
        Move robot forward
    Else:
        Turn robot to stay on the line
    
    # Obstacle detection
    If ultrasonic sensor detects obstacle:
        Stop robot
        Wait for 1 second
        Avoid obstacle (turn or move back)
    
    # Optional: Manual control via IR remote
    If IR receiver receives signal:
        Follow manual control commands from remote

# Initialize Libraries and Components
Initialize line-following sensor
Initialize ultrasonic sensor
Initialize motors and wheels
Initialize IR receiver (optional)
Initialize IR remote (optional)

# Start the robot movement
While robot is running:
    Read line-following sensor data
    If sensor detects line:
        Move robot forward
    Else:
        Turn robot to stay on the line
    
    # Obstacle detection
    If ultrasonic sensor detects obstacle:
        Stop robot
        Wait for 1 second
        Avoid obstacle (turn or move back)
    
    # Optional: Manual control via IR remote
    If IR receiver receives signal:
        Follow manual control commands from remote

Have you ever played a game where someone gives hints like “cold” or “hot” to help you find something? Now, you can play it on Scratch!

How to Play:

Move your mouse to search for the hidden ball. The game will give you hints:
Cold – You’re far away.
Warm – You’re getting closer.
Hot – You’re very close!

Once you find the ball, kick it to score points! You can add fun sounds, colorful effects, and even a timer to challenge yourself.

Can you find and kick the ball the fastest? Let’s play!

Project Link: https://scratch.mit.edu/projects/983042559

We play Rock-Paper-Scissor( RPS)  in classrooms, on the playground, on the school bus, or at home —  anytime and anywhere! Sometimes we even use it to decide who goes first in other games. Do you know we could play RPS with a computer too?

We can build an RPS game using Scratch block coding. To make it fun, we can add colorful costumes, backgrounds, messages, sound effects and a scoreboard.

We can enhance the game by adding a timer so that the players have to select their move within the given time and declare the winner as the first to score 10 points

Project Link:  https://scratch.mit.edu/projects/1136468065

We all love our pets! They are our best friends, bringing joy and happiness into our lives. In this project, we will create a Pet Profile Page using HTML & CSS to share our pets’ pictures and stories.

You can enhance the project by adding a gallery, interactive features like a ‘Like’ button, or even an option to download images.

Technologies Used:

• HTML – To structure the webpage.
• CSS – To style and enhance the page layout.
• IDE: EduBlocks HTML

1. Set up the Page

• Create a new HTML project.
• Use the HTML block to add <html>, <head>, and <body>.

2. Create the Pet Profile

• Add a <h1> tag for the title: “My Pet’s Story”.
• Use an <img> tag to insert the pet’s picture (use a URL or upload).
• Add <p> tags for pet details (Name, Age, Breed).
• Write the pet’s story inside another <p> tag.

3. Style with CSS

• Use a <style> tag inside <head>.
• Set background-color, font-size, and text-align.
• Apply border-radius and box-shadow to images for a neat look.

4. Optional Enhancements

• Add a <button> below the profile for a “Like” feature.
• Use multiple <img> tags to create a simple gallery.

We use many apps and websites everyday for school, work, research , personal use or just for fun! Most of these require us to register /sign- up with a username and password. It’s important to have a strong password to protect our private information.

This project helps you to check the strength of your password and even helps you in generating a stronger one.

You can also enhance the project by providing a “Copy to Clipboard” option and tips for creating strong passwords.

Required Libraries:

• Python (3.x or later): The programming language for this project.
• Tkinter: For creating the graphical user interface (GUI).
• Random: To generate random characters for passwords.
• String: For handling letters, digits, and symbols in passwords.

Key Programming Steps:

1. Initialize:
   • Import Python libraries (Tkinter, Random, String).
   • Set up the GUI window using Tkinter.
   • Create input fields for entering and displaying passwords.
2. Password Strength Detection:
   • Check the password length, presence of numbers, uppercase letters, and special characters.
   • Display password strength (Weak, Medium, Strong) based on these factors.
3. Password Generator:
   • Generate a random password using letters, numbers, and special characters when the “Generate Password” button is clicked.
   • Display the generated password in the input field.
4. User Feedback:
   • Display password strength immediately after entering or generating the password.
   • Provide tips for improving password strength (e.g., adding uppercase letters, numbers).
5. Optional Enhancements:
   • Add a “Copy to Clipboard” button for easy copying of the generated password.
   • Display a message or suggestion for creating strong passwords.

Pseudo Code:

Import necessary libraries (tkinter, random, string)

Define function to check password strength:

    Set initial strength as "Weak"

    If password length >= 8:

        If password contains digits, uppercase letters, and special characters:

            Set strength to "Strong"

        Else if password contains digits or uppercase letters:

            Set strength to "Medium"

    Return strength

Define function to generate a random strong password:

    While loop to generate a password:

        Create password by selecting random characters from letters, digits, and special symbols

        Check password strength

        If strength is "Strong":

            Exit the loop

    Return password

Define function to check the entered password's strength:

    Get password from input field

    Call function to check strength and display result

Set up GUI window (Tkinter):

    Create label with instructions for entering or generating password

    Create input field for password

    Create label to display strength of password

    Create button to check strength

    Create button to generate a strong password

Run the main event loop to display GUI

Quake-Ready is a smart application that uses an IoT device (Python STEM Board)  with a 3-axis accelerometer to detect ground vibrations and sound sensors to find trapped individuals. It provides real-time alerts with visual and sound notifications. The app also shows resource data (hospitals, camps, population) to help with response planning and coordination

Components Needed

1. Python STEM Board (ESP-WROOM-32)
2. 3-Axis Accelerometer (for detecting ground vibrations)
3. Sound Sensors (for detecting trapped individuals)
4. OLED Screen (for displaying alerts)
5. RGB LEDs (for visual notifications)
6. Buzzer (for sound notifications)
7. Wi-Fi Module (for internet connectivity)
8. MQTTX (for real-time data communication)
9. USB Cable (for connecting the board to the computer)

STEM Python Board 
Initialize mPython, Wi-Fi, MQTT, sensors
Display message on OLED
While True:
    Read and publish sound and accelerometer data
    If sound > threshold:
        Display "ALERT: High sound" and trigger notifications
    If acceleration > threshold:
        Display "ALERT: Earthquake" and trigger notifications
    Plot sound and acceleration data with color-coded severity
    Wait for a few  seconds
End loop

APPLICATION LOGIC

Initialize MQTT client and connect to broker
Subscribe to sound and accelerometer topics
Define thresholds for sound and acceleration
Set up data storage (sound_data, acceleration_data)
Define on_connect callback to subscribe to topics
Define on_message callback to process incoming data and store in respective queues
Define function to plot sound data:
    Plot sound as bar chart with color based on severity (green, yellow, red)
Define function to plot accelerometer data:
    Plot acceleration as bar chart with color based on severity (yellow, orange, red)
Run a loop (e.g., 10 times):
    Plot sound and accelerometer data
    Pause for 5 seconds before repeating

STEM Python Board 
Initialize mPython, Wi-Fi, MQTT, sensors
Display message on OLED
While True:
    Read and publish sound and accelerometer data
    If sound > threshold:
        Display "ALERT: High sound" and trigger notifications
    If acceleration > threshold:
        Display "ALERT: Earthquake" and trigger notifications
    Plot sound and acceleration data with color-coded severity
    Wait for a few  seconds
End loop

APPLICATION LOGIC

Initialize MQTT client and connect to broker
Subscribe to sound and accelerometer topics
Define thresholds for sound and acceleration
Set up data storage (sound_data, acceleration_data)
Define on_connect callback to subscribe to topics
Define on_message callback to process incoming data and store in respective queues
Define function to plot sound data:
    Plot sound as bar chart with color based on severity (green, yellow, red)
Define function to plot accelerometer data:
    Plot acceleration as bar chart with color based on severity (yellow, orange, red)
Run a loop (e.g., 10 times):
    Plot sound and accelerometer data
    Pause for 5 seconds before repeating

This is a fun game where we control a Beetle through a maze using hand gestures! Using Scratch Machine Learning tools, we’ll train a Hand Gesture Classifier to recognize five gestures: Forward, Backward, Left, Right, and Stop. These gestures will control the Beetle, helping it avoid obstacles in the maze. Let’s get started and make the game interactive with our own hands!

Steps:

1. Set up the ML environment in the Scratch AI platform.
2. Collect hand gestures (e.g., palm facing forward for Forward, back of the palm for Backward, etc.).
3. Train the model using data captured from the webcam.
4. Test the model with real-time hand gestures.
5. Export the trained model for use in the game.
6. Create Scratch AI scripts to map the gestures to the Beetle’s movement.

1. Open Scratch AI Platform and load the "Beetle in the Maze" project.

   > Project loaded successfully.

2. Create a new project and select the "Hand Gesture Classifier" extension.

   > New project created and Hand Gesture Classifier extension added.

3. Upload hand gesture data (Forward, Backward, Left, Right, Stop).

   > Data uploaded: Forward, Backward, Left, Right, Stop.

4. Train the model with 20+ samples for each gesture.

   > Training in progress... 20+ samples for each gesture added.

5. Test the model with the webcam for real-time recognition.

   > Model testing... Real-time gesture recognition is successful.

6. Export the trained model to Scratch AI Platform.

   > Model exported successfully.

7. In the Block Coding environment:

   - Use blocks to open the recognition window.

   - Use blocks to analyze gestures from the webcam.

   - Assign corresponding Beetle actions (e.g., move forward on "Forward").

   > Blocks created and configured.

8. Run the game with hand gestures controlling the Beetle.

   > Game running... Beetle controlled via hand gestures.

1. Open Scratch AI Platform and load the "Beetle in the Maze" project.

   > Project loaded successfully.

2. Create a new project and select the "Hand Gesture Classifier" extension.

   > New project created and Hand Gesture Classifier extension added.

3. Upload hand gesture data (Forward, Backward, Left, Right, Stop).

   > Data uploaded: Forward, Backward, Left, Right, Stop.

4. Train the model with 20+ samples for each gesture.

   > Training in progress... 20+ samples for each gesture added.

5. Test the model with the webcam for real-time recognition.

   > Model testing... Real-time gesture recognition is successful.

6. Export the trained model to Scratch AI Platform.

   > Model exported successfully.

7. In the Block Coding environment:

   - Use blocks to open the recognition window.

   - Use blocks to analyze gestures from the webcam.

   - Assign corresponding Beetle actions (e.g., move forward on "Forward").

   > Blocks created and configured.

8. Run the game with hand gestures controlling the Beetle.

   > Game running... Beetle controlled via hand gestures.

Pseudo Code:

1. Open Scratch AI Platform and load the “Beetle in the Maze” project.

   > Project loaded successfully.

2. Create a new project and select the “Hand Gesture Classifier” extension.

   > New project created and Hand Gesture Classifier extension added.

3. Upload hand gesture data (Forward, Backward, Left, Right, Stop).

   > Data uploaded: Forward, Backward, Left, Right, Stop.

4. Train the model with 20+ samples for each gesture.

   > Training in progress… 20+ samples for each gesture added.

5. Test the model with the webcam for real-time recognition.

   > Model testing… Real-time gesture recognition is successful.

6. Export the trained model to Scratch AI Platform.

   > Model exported successfully.

7. In the Block Coding environment:

   – Use blocks to open the recognition window.

   – Use blocks to analyze gestures from the webcam.

   – Assign corresponding Beetle actions (e.g., move forward on “Forward”).

   > Blocks created and configured.

8. Run the game with hand gestures controlling the Beetle.

   > Game running… Beetle controlled via hand gestures.

Have you ever thought of having your own digital locker to protect the things you treasure? Like a digital locker for your treasure box, yes, it’s possible! When you enter the correct password in the digital locker’s touchpad, the box gets opened; otherwise, it’s kept closed, and your things are safe.

You could build a digital locker using a Python STEM Board, which has a cool touchpad LED screen and more,  this board could be programmed using Micro-Python.

You can also enhance the locker by adding lights and sound effects and you could even set an alarm for entering the wrong password!

Components Needed

1. ESP-WROOM-32 dual-core Python Board (The main component we will use)
2. USB cable (For connecting it to the computer)
3. Computer (For coding)
4. OLED screen (To show the output on the board)
5. Touchpads (To enter the password)
6. RGB LEDs and Buzzer (Optional, for light sound effects and alarm)

The Key Programming-Steps

1. Initialize:

• Import mPython libraries.
• Set up touchpads, OLED screen, RGB LEDs, and buzzer.
• Define password (e.g., [“N”, “O”, “H”, “T”, “Y”, “P”]).

2. Display Instructions:

• Show “Enter your password” and placeholders * * * * * * on OLED.

3. Input Detection:

• Loop through each password character:
  • Wait for the touchpad press.
  • Compare input with the password character.

4. Password Attempts:

• Track failed attempts (e.g., limit to 3 attempts).
• If max attempts are reached, lock the system temporarily and display a message.

5. Feedback:

• If correct: Show “Device Unlocked” on OLED, turn RGB LEDs green.
• If incorrect: Show “Wrong Password” on OLED, turn LEDs red, play buzzer sound.

6. Optional Enhancements:

• Password Change: Allow users to change the password after successful login.
• Buzzer: Sound buzzer for wrong password attempts.
• Max Attempts: Limit the number of attempts before locking the system.

Initialize mPython libraries

Initialize touchpads, OLED, RGB LEDs

Display instructions on OLED: "Enter your password" and "using Touchpad"

Define password as ["Y", "N", "P", "T", "H", "O"]

Set i to 0 (index of password)

While i < 6:

    Check if any touchpad is pressed

    If touchpad pressed, compare input with the password at position i

        If wrong, exit loop (wrong password)

    If correct, increment i

    Wait for 1 second

If i < 6 (wrong password):

    Set RGB LEDs to red

    Display "WRONG PASSWORD" on OLED

Else (password correct):

    Set RGB LEDs to yellow

    Display "Device unlocked!!!" on OLED