AI & IoT Training Camp

Distribute one Arduino UNO board and one Sensor Shield V5.0 per group (6 people). Have participants mount the Sensor Shield directly onto the Arduino UNO by aligning the pins and pressing firmly until seated. The shield provides organized 3-pin (V/G/S) headers for every Arduino pin.

Explain the three-pin architecture on the Shield. Each pin header has three connections: V (VCC) = 5V power supply (red wire), G (GND) = Ground/negative terminal (black wire), S (Signal) = Data pin that communicates with the Arduino (green/yellow wire). This eliminates the need for complex breadboard wiring.

Connect the Arduino UNO to the computer using a USB cable. Open PictoBlox (desktop version). In the top menu, go to Board → Arduino Uno. Click Connect and select the correct port (COM port on Windows, /dev/tty on Mac). The connection icon will turn green when successful.

Assign group roles: Team Leader (coordination & presentation), Hardware Specialist (wiring & calibration), Software/AI Specialist (model training & block coding), Tester (debugging & quality assurance). Remaining members rotate between roles. Record roles on the Group Card template.

In PictoBlox, go to Files → Open ML Environment. Click "Create New Project". Enter a project name (e.g., "Safety Detector") and select "Image Classifier" as the model type. Click "Create Project". Two default class cards will appear.

Rename the classes by clicking the edit icon on each card. Create three classes: "Dangerous_Object", "Safe_Object", and "Background". To add a third class, click the "Add Class" button. Use names without spaces (underscores are fine) — this will be the exact label used in block coding later.

For each class, click the "Webcam" icon on the class card. Your camera will activate. Press and hold the "Hold to Record" button while showing the relevant object to the camera. Show the object from multiple angles (front, left, right, top) and under varying lighting conditions. Collect at least 200 samples per class. For the "Background" class, record with an empty desk/background only.

Once all classes have sufficient data, click "Train Model". Monitor the Accuracy and Loss graphs during training. Accuracy should approach 1.0 (100%), and Loss should approach 0. After training completes, switch to the "Test" tab and verify the model by showing objects to the webcam in real time. Check that the correct class is predicted with a confidence score above 80%.

Connect the SG90 Servo Motor to the Shield. Align the 3-pin connector: Brown wire → G (GND), Red wire → V (5V), Orange wire → S (Signal). Plug into the Pin 9 header on the Shield. Pin 9 is a PWM-capable pin required for servo control.

Connect the Active Buzzer Module to the Shield on Pin 10. The buzzer module typically has two pins: S (Signal) → Pin 10 S and GND → Pin 10 G. Some modules have 3 pins (VCC is also needed — connect to Pin 10 V).

In PictoBlox, ensure Arduino Uno is connected. Switch to Stage Mode (toggle in the top-right area). Click "Upload Firmware" to enable real-time communication between PictoBlox and the Arduino. Test the servo by dragging a set servo on pin (9) to (90) degrees block from the Actuators palette and clicking it — the servo should rotate to 90°.

Go back to the ML Environment, click "Export Model" to load your trained model into the block coding environment. New ML blocks will appear in the left palette. Drag a turn video on stage with (0)% transparency block, followed by analyze image from (webcam) inside a forever loop. Run the script (click green flag) to verify the camera feed and classification work in Stage Mode.

Create the main script. Start with when green flag clicked from Events palette. Add turn video on stage with (0)% transparency to activate the camera. Then add a forever loop from Control palette.

Inside the forever loop, add analyze image from (webcam) from the Machine Learning palette. This block processes each video frame through your trained model. Below it, add an if-else block from Control.

Set the If condition: drag is identified class (Dangerous_Object) from the ML palette into the hexagonal condition slot. Inside the IF branch: add set servo on pin (9) to (180) degrees and set digital pin (10) output as (HIGH) (buzzer ON). Inside the ELSE branch: add set servo on pin (9) to (0) degrees and set digital pin (10) output as (LOW) (buzzer OFF).

Click the green flag to run the system. Show different objects to the camera and verify: Dangerous object → servo rotates to 180°, buzzer sounds. Safe object or background → servo at 0°, buzzer silent. If false positives occur (wrong classification), return to the ML Environment, add more training data for the problematic scenario, retrain the model, and export again.

In PictoBlox, go to Files → Open ML Environment → Create New Project. Enter a project name and select "Audio Classifier". Click "Create Project". The Audio Classifier interface opens with two default class cards.

Rename the first class to "Background". With the room quiet (or at normal ambient noise level), click the "Microphone" button and record for at least 20–30 seconds. The recording is automatically split into 1-second segments and displayed as spectrograms. This teaches the model what "silence" or "ambient noise" sounds like.

Add two more classes: "Water" and "Stop". For each class, have group members take turns speaking the command clearly into the microphone. Vary: tone (loud, soft), speed (fast, slow), distance (close, farther), and speakers (different voices). Aim for at least 40 samples per command class. Each sample appears as a spectrogram strip.

Click "Train Model". Monitor the accuracy graph — it should approach 1.0. After training, switch to the "Test" tab and speak commands into the microphone. The system should correctly identify each command with confidence above 80%. If "Water" is confused with "Stop", record more distinct samples and retrain.

Wire the relay module to the Arduino Shield on Pin 7: VCC → V, GND → G, IN → S. The relay's high-voltage side has three terminals: COM (Common), NO (Normally Open), NC (Normally Closed). Connect the external battery (+) to COM, and the pump (+) wire to NO. Connect the pump (−) directly to the battery (−).

Export the Audio Classifier model to the block coding environment. The ML palette will show new audio-specific blocks: open recognition window, when () is predicted, and get recognized class.

Create Script 1: drag when green flag clicked → open recognition window. This opens a small window that shows real-time spectrogram analysis. Create Script 2: drag when (Water) is predicted → set digital pin (7) output as (HIGH). This triggers the relay when the "Water" command is recognized. Create Script 3: drag when (Stop) is predicted → set digital pin (7) output as (LOW).

Ensure Arduino is in Stage Mode with firmware uploaded. Click the green flag. Say "Water" — the relay should click and the pump starts. Say "Stop" — the relay releases and the pump stops. Test multiple times with different speakers.

In PictoBlox, go to Files → Open ML Environment → Create New Project. Select "Pose Classifier". The interface activates the webcam and overlays 17 keypoints (joints) on the detected body: nose, eyes, ears, shoulders, elbows, wrists, hips, knees, ankles.

Create at least 3 classes: "Hands_Up" (both arms raised above head), "Lean_Right" (body tilted right), and "Neutral" (standing normally). For each class, stand in front of the camera in the correct pose and click "Hold to Record". Vary the position slightly between samples. Collect at least 100 samples per class.

Click "Train Model". After training, check the accuracy graph. You can optionally open "Train Advance" to adjust hyperparameters: Epochs (increase to 20–50 for better accuracy) and Batch Size (default is usually fine). Retrain if accuracy is below 90%.

Switch to the "Test" tab. Stand in front of the camera and perform each pose. The model should correctly identify the pose with high confidence. Note: The keypoint overlay should be visible on your body. If detection is poor, ensure good lighting and that your full upper body is visible in the frame.

In PictoBlox block coding, click the "Add Extension" button (bottom-left, purple icon). Search for and add the "Human Body Detection" extension. This extension provides blocks to track individual body part X/Y coordinates (different from the Pose Classifier which classifies whole poses).

Create the script: when green flag clicked → turn video on stage with (0)% transparency → forever loop containing analyze image from (webcam). This continuously tracks your body. Inside the loop, add a set [hand_y] to (y position of [right wrist]) block (create a variable called "hand_y").

The stage coordinate range is Y: −180 to +180. We need to map this to servo range 0° to 180°. Use Operators palette math blocks to create the mapping formula: set [servo_angle] to (((hand_y + 180) / 360) × 180). This converts the Y position proportionally to a servo angle.

Add set servo on pin (9) to (servo_angle) degrees inside the forever loop. Add wait (0.05) seconds to reduce servo jitter. Run the script — as you raise your right hand, the servo should smoothly rotate upward. Lower your hand and the servo returns. This demonstrates proportional (analog) control rather than simple on/off.

AI Data Collection: Open the ML Environment and create the project for their chosen classifier type (Image, Audio, or Pose). Begin collecting training samples. Target: minimum 150 samples per class for Image, 40 samples per class for Audio, 100 samples per class for Pose. More samples = better accuracy.

Hardware Wiring: Using the architecture diagram, wire all sensors and actuators. Verify each component individually before connecting everything together. Test each sensor reading independently — does the DHT11 return real values? Does the servo move? Does the buzzer sound?

Checkpoint: By the end of Sprint 1, each group should have: (A) raw training data collected for all classes, (B) all hardware wired and individually tested, (C) no hardware errors or loose connections. Flag any hardware defects to the instructor immediately.

Train the AI Model: Click "Train Model" in the ML Environment. Monitor the accuracy graph. If accuracy is below 85%, go back and add more diverse training data. Common fixes: add more "Background" class samples, ensure consistent lighting during data collection, remove blurry/low-quality samples.

Test and Iterate: Use the Test tab to verify the model in real-time. Test edge cases: What happens with partial occlusion? What about different lighting? If the model fails on certain inputs, add those specific scenarios to the training data and retrain. Repeat until satisfied.

Export the Model: Once accuracy is satisfactory, click "Export Model". The ML blocks will load into the block coding environment. Verify by checking that the ML palette shows your class names.

Physical Build: If the project has a physical enclosure (e.g., a model greenhouse, a security booth), begin construction using available materials (cardboard, tape, containers). Mount sensors in appropriate positions.

Build the Main Script: Combine the AI model blocks with the sensor reading blocks and actuator control blocks. Follow the architecture diagram: Input → Processing → Output. Ensure the forever loop includes all analysis and decision blocks in the correct order.

End-to-End Testing: Run the complete system. Does the camera correctly classify? Do the sensors return valid readings? Do the actuators respond correctly to the combined decisions? Document any bugs or unexpected behaviors.

Debug and Fix: Common integration issues: (A) Servo jitter — add wait (0.1) seconds, (B) Wrong pin numbers — double-check wiring against code, (C) AI model not predicting — ensure analyze image from block is inside the loop, (D) Sensor readings are 0 — check VCC/GND connections and firmware upload.

Checkpoint: By the end of Sprint 3, the MVP (Minimum Viable Product) must be functional. The system should demonstrate the core input-processing-output loop at least once without errors.

Edge Case Handling: Test the system under non-ideal conditions. What happens when no face is visible? When the room is very noisy? When two people are in frame? Add fallback logic (else branches) for graceful degradation rather than system freezes.

Stage Feedback: Add visual feedback on the PictoBlox Stage: sprite costume changes, background color changes, or text messages that explain what the system is doing. This makes demos more visually engaging for the audience.

Prepare Presentation: Structure the 5-minute demo: (1) Problem statement — what real-world issue does your project solve? (2) System overview — show the architecture diagram. (3) Live demo — run the system and explain each step. (4) Challenges and learnings. (5) Future improvements.

Rehearse: Run through the full presentation at least twice. Test the live demo before the rehearsal — ensure all hardware is working. Assign speaking roles: who explains the AI? Who demonstrates the hardware? Who discusses the results?

Subject Mapping Discussion: Present how training activities align with STEM subjects: Science (sensors measure physical phenomena — temperature, light, gas), Technology (AI models, IoT communication, block coding), Engineering (circuit design, system architecture, troubleshooting), Mathematics (data range mapping, probability/confidence scores, analog-to-digital conversion).

Each group selects one activity from Days 1–4 and writes a 45-minute lesson plan targeting their specific subject/grade level. The plan should include: Learning Objectives, Materials Needed (simplified kit), Step-by-Step Procedure (simplified from this guide), Assessment Criteria, and Safety Notes.

Simplification Strategy: Workshop activities use multiple sensors and complex logic. For a classroom setting, focus on one concept per lesson: e.g., "Image Classifier + Servo" is one lesson; "DHT11 reading + display" is another. Do not try to combine everything into one class period.

Groups share their lesson plan drafts with the room (2 minutes each). Other groups provide peer feedback: Is it achievable in 45 minutes? Are the learning objectives clear? Is the assessment method practical? Collect all lesson plans for the final documentation package.

Presentation Format (5 min): (1) Problem statement and motivation (30 sec), (2) System architecture overview (1 min), (3) Live demo — run the system and explain the AI+sensor+actuator interaction (2 min), (4) Challenges faced and how they were solved (1 min), (5) Future improvements and real-world applications (30 sec).

Q&A (2 min): Audience and instructors ask questions. Encourage technical questions: "Why did you choose that sensor?", "What was your model's accuracy?", "What happens when X fails?" and design questions: "How would you scale this to a real building?"

Evaluation Rubric (per group): Innovation & Creativity (25%), Technical Complexity — AI + hardware integration (25%), Working Demo — does it function live? (25%), Presentation Quality — clarity, teamwork, Q&A handling (25%). Total: 100 points.

Groups 6–10 present following the same 5+2 minute format. Ensure the evaluation rubric is consistently applied by all evaluators (instructors and designated peer reviewers).

Peer Voting: After all presentations, each participant votes for their favorite project (they cannot vote for their own group). Categories: "Most Innovative", "Best Technical Implementation", "Best Presentation". Votes are collected on paper or by show of hands.

Feedback Round: Instructors provide brief collective feedback — common strengths observed across projects, recurring technical issues, and suggestions for improvement. Highlight exceptional debugging strategies or creative problem-solving approaches from specific groups.

Awards Ceremony: Announce results: (A) Top 3 Overall Projects (based on rubric scores), (B) Peer-voted awards: Most Innovative, Best Technical, Best Presentation, (C) Any special mentions (most improved team, best teamwork, creative use of sensors).

Sustainability & Next Steps: Share resources for continued learning: PictoBlox Download (thestempedia.com/product/pictoblox), STEMpedia Community Projects (ai.thestempedia.com/community-project), Codeavour Competition (codeavour.org). Discuss how to set up a school AI/IoT club.

Certificates: Distribute completion certificates to all 60 participants. Certificates should include: participant name, training title ("AI & IoT Training Camp"), dates, organizer logo, and instructor signature. Group winners receive additional award certificates.

Feedback Collection: Distribute a short feedback form (5 questions): (1) Which day was most valuable? (2) Which activity was most challenging? (3) Did you feel confident to teach these concepts in your classroom? (4) What additional topics would you like to learn? (5) Overall rating (1–5). Collect all forms before closing.