# Lab: Invisible Guardian - IR Beam Break Security System ## **Objective** Create a simple IR beam break detection system using TK63 Infrared Transmitter and TK64 Infrared Receiver. When the IR beam is blocked (receiver goes LOW), activate TK36 buzzer and TK01 LED as an alarm system. ## **Required Components**  1. **Lonely Binary UNO R3** - Main Arduino board 2. **TinkerBlock UNO R3 Shield** - Expansion shield that plugs onto the UNO R3 3. **TinkerBlock TK63** - Infrared Transmitter Module 4. **TinkerBlock TK64** - Infrared Receiver Module 5. **TinkerBlock TK36** - Active Buzzer Module 6. **TinkerBlock TK01** - LED Module ## **Theory** ### **IR Beam Break Detection** - **TK63 Transmitter**: Continuously sends IR signal - **TK64 Receiver**: Detects IR signal (HIGH when receiving, LOW when blocked) - **Beam Break**: When object blocks IR path, receiver goes LOW - **Alarm System**: Buzzer and LED activate when beam is broken ### **Simple Operation** - **Normal State**: IR beam reaches receiver → Receiver HIGH → No alarm - **Beam Broken**: Object blocks IR → Receiver LOW → Alarm ON - **Beam Restored**: Object removed → Receiver HIGH → Alarm OFF ## **Wiring Instructions** ### **TK63 Infrared Transmitter Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D5 ### **TK64 Infrared Receiver Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D7 ### **TK36 Active Buzzer Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D9 ### **TK01 LED Module Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D3 ### **Connection Diagram**  ``` UNO R3 + Shield ├── Digital Pin D5 ──→ TK63 Signal (IR Transmitter) ├── Digital Pin D7 ──→ TK64 Signal (IR Receiver) ├── Digital Pin D9 ──→ TK36 Signal (Buzzer) └── Digital Pin D3 ──→ TK01 Signal (LED) ``` ## **Basic IR Beam Break Detection Code** ```cpp // Simple IR Beam Break Detection System // Pin definitions #define IR_TX_PIN 5 // TK63 Infrared Transmitter on D5 #define IR_RX_PIN 7 // TK64 Infrared Receiver on D7 #define BUZZER_PIN 9 // TK36 Active Buzzer on D9 #define LED_PIN 3 // TK01 LED on D3 // Variables bool beamBroken = false; // Current beam status bool lastBeamStatus = false; // Previous beam status int breakCount = 0; // Number of beam breaks detected unsigned long lastBreakTime = 0; // Time of last beam break unsigned long alarmStartTime = 0; // Time when alarm started bool alarmActive = false; // Whether alarm is currently active void setup() { // Initialize serial communication Serial.begin(9600); Serial.println("Simple IR Beam Break Detection System"); Serial.println("====================================="); // Initialize pins pinMode(IR_TX_PIN, OUTPUT); // IR Transmitter pinMode(IR_RX_PIN, INPUT); // IR Receiver pinMode(BUZZER_PIN, OUTPUT); // Buzzer pinMode(LED_PIN, OUTPUT); // LED // Start with everything off digitalWrite(BUZZER_PIN, LOW); digitalWrite(LED_PIN, LOW); // Turn on IR transmitter digitalWrite(IR_TX_PIN, HIGH); delay(1000); Serial.println("System initialized!"); Serial.println("TK63 IR Transmitter: D5"); Serial.println("TK64 IR Receiver: D7"); Serial.println("TK36 Buzzer: D9"); Serial.println("TK01 LED: D3"); Serial.println(); Serial.println("Place object between transmitter and receiver to test"); Serial.println(); } void loop() { // Read IR receiver status bool irSignal = digitalRead(IR_RX_PIN); // Determine beam status beamBroken = !irSignal; // Beam is broken when receiver is LOW // Check for status change if (beamBroken != lastBeamStatus) { if (beamBroken) { // Beam just broken beamBreakDetected(); } else { // Beam just restored beamRestored(); } lastBeamStatus = beamBroken; } // Update alarm status updateAlarm(); // Check if alarm should auto-stop after 2 seconds if (alarmActive && (millis() - alarmStartTime > 2000)) { alarmActive = false; digitalWrite(LED_PIN, LOW); digitalWrite(BUZZER_PIN, LOW); Serial.println("Alarm auto-stopped after 2 seconds"); } // Small delay for stability delay(100); } void beamBreakDetected() { breakCount++; lastBreakTime = millis(); Serial.println("*** BEAM BROKEN ***"); Serial.print("Break #"); Serial.println(breakCount); Serial.print("Time: "); Serial.print(lastBreakTime / 1000); Serial.println(" seconds"); Serial.println(); } void beamRestored() { Serial.println("*** BEAM RESTORED ***"); Serial.print("Break duration: "); Serial.print((millis() - lastBreakTime) / 1000); Serial.println(" seconds"); Serial.println(); } void updateAlarm() { if (beamBroken && !alarmActive) { // Beam is broken and alarm not already active - start alarm alarmActive = true; alarmStartTime = millis(); digitalWrite(LED_PIN, HIGH); digitalWrite(BUZZER_PIN, HIGH); Serial.println("Alarm activated!"); } // Note: Alarm will auto-stop after 2 seconds in main loop } ``` ## **Code Explanation** ### **System Architecture Overview** The Invisible Guardian uses an **IR beam break detection system** with a simple but effective architecture. It consists of an IR transmitter-receiver pair that creates an invisible security beam, with immediate alarm activation when the beam is interrupted. ### **Core Components Analysis** #### **1. Pin Configuration & Hardware Interface** ```cpp #define IR_TX_PIN 5 // TK63 Infrared Transmitter on D5 #define IR_RX_PIN 7 // TK64 Infrared Receiver on D7 #define BUZZER_PIN 9 // TK36 Active Buzzer on D9 #define LED_PIN 3 // TK01 LED on D3 ``` - **Digital Output (D5)**: Controls IR transmitter (continuously ON) - **Digital Input (D7)**: Reads IR receiver status (HIGH = beam intact, LOW = beam broken) - **Digital Output (D9)**: Controls active buzzer for alarm sounds - **Digital Output (D3)**: Controls status LED for visual feedback #### **2. System Variables & State Management** ```cpp bool beamBroken = false; // Current beam status bool lastBeamStatus = false; // Previous beam status int breakCount = 0; // Number of beam breaks detected unsigned long lastBreakTime = 0; // Time of last beam break unsigned long alarmStartTime = 0; // Time when alarm started bool alarmActive = false; // Whether alarm is currently active ``` - **State Tracking**: Monitors current and previous beam status for edge detection - **Event Counting**: Tracks total number of beam breaks - **Timing Control**: Manages alarm duration and timing - **Alarm State**: Prevents multiple alarm triggers ### **Key Functions Deep Dive** #### **1. IR Beam Detection Algorithm** ```cpp void loop() { // Read IR receiver status bool irSignal = digitalRead(IR_RX_PIN); // Determine beam status beamBroken = !irSignal; // Beam is broken when receiver is LOW // Check for status change if (beamBroken != lastBeamStatus) { if (beamBroken) { // Beam just broken beamBreakDetected(); } else { // Beam just restored beamRestored(); } lastBeamStatus = beamBroken; } } ``` **How it works:** - **Signal Inversion**: `!irSignal` converts receiver logic (HIGH = intact, LOW = broken) - **Edge Detection**: Compares current vs. previous status to detect changes - **Event Handling**: Triggers appropriate functions for break/restore events - **State Protection**: Prevents multiple triggers for same event #### **2. Alarm Management System** ```cpp void updateAlarm() { if (beamBroken && !alarmActive) { // Beam is broken and alarm not already active - start alarm alarmActive = true; alarmStartTime = millis(); digitalWrite(LED_PIN, HIGH); digitalWrite(BUZZER_PIN, HIGH); Serial.println("Alarm activated!"); } // Note: Alarm will auto-stop after 2 seconds in main loop } ``` **Key Features:** - **Conditional Activation**: Only starts alarm if not already active - **Timing Control**: Records start time for duration management - **Dual Output**: Simultaneous LED and buzzer activation - **Auto-Stop Logic**: Integrated with main loop timing #### **3. Auto-Stop Timer Implementation** ```cpp // Check if alarm should auto-stop after 2 seconds if (alarmActive && (millis() - alarmStartTime > 2000)) { alarmActive = false; digitalWrite(LED_PIN, LOW); digitalWrite(BUZZER_PIN, LOW); Serial.println("Alarm auto-stopped after 2 seconds"); } ``` **Timer Features:** - **Non-blocking**: Uses `millis()` for precise timing without delays - **Automatic Reset**: Clears alarm state after timeout - **Dual Deactivation**: Turns off both LED and buzzer - **User Feedback**: Serial notification of auto-stop #### **4. Event Logging System** ```cpp void beamBreakDetected() { breakCount++; lastBreakTime = millis(); Serial.println("*** BEAM BROKEN ***"); Serial.print("Break #"); Serial.println(breakCount); Serial.print("Time: "); Serial.print(lastBreakTime / 1000); Serial.println(" seconds"); Serial.println(); } void beamRestored() { Serial.println("*** BEAM RESTORED ***"); Serial.print("Break duration: "); Serial.print((millis() - lastBreakTime) / 1000); Serial.println(" seconds"); Serial.println(); } ``` **Logging Features:** - **Event Counter**: Tracks total number of beam breaks - **Timing Information**: Records when breaks occur and their duration - **Serial Output**: Real-time status updates for debugging - **Duration Calculation**: Measures how long beam was broken ### **IR Technology Deep Dive** #### **1. Infrared Communication** - **Wavelength**: 940nm infrared light (invisible to human eye) - **Transmission**: Continuous signal from TK63 transmitter - **Reception**: TK64 receiver detects IR light presence - **Digital Logic**: Simple HIGH/LOW detection (no analog processing) #### **2. Beam Break Detection** - **Normal State**: IR beam reaches receiver → Receiver HIGH → No alarm - **Beam Broken**: Object blocks IR → Receiver LOW → Alarm triggered - **Beam Restored**: Object removed → Receiver HIGH → Status logged #### **3. Environmental Considerations** - **Distance**: Effective range typically 10-30cm - **Alignment**: Transmitter and receiver must be properly aligned - **Interference**: Ambient light can affect detection - **Obstacles**: Any opaque object will break the beam ### **Performance Optimizations** #### **1. Non-Blocking Design** - **No delay() calls**: System remains responsive to beam changes - **millis() timing**: Precise timing without blocking operations - **Fast response**: 100ms loop cycle for quick detection #### **2. State Management** - **Edge Detection**: Only responds to actual state changes - **Alarm Protection**: Prevents multiple alarm triggers - **Memory Efficiency**: Minimal variable usage #### **3. User Experience** - **2-Second Alarm**: Short enough to be noticeable, not annoying - **Auto-Reset**: No manual intervention required - **Clear Feedback**: Both visual (LED) and audio (buzzer) alerts ### **Error Handling & Reliability** #### **1. Signal Stability** - **Debouncing**: 100ms delay prevents false triggers - **State Comparison**: Only acts on actual changes - **Conditional Logic**: Prevents alarm re-triggering #### **2. System Robustness** - **Auto-Stop Safety**: Prevents infinite alarms - **State Consistency**: Maintains proper alarm state - **Serial Debugging**: Real-time status monitoring #### **3. Hardware Protection** - **Proper Pin Configuration**: Correct input/output setup - **Initial State**: All outputs start in known state - **Power Management**: Efficient IR transmitter control ### **Integration with TinkerBlock Modules** #### **1. TK63 Infrared Transmitter** - **Digital Control**: Simple HIGH/LOW operation - **Continuous Output**: Sends constant IR signal - **Low Power**: Efficient operation for security applications #### **2. TK64 Infrared Receiver** - **Digital Output**: Simple HIGH/LOW detection - **Fast Response**: Quick detection of beam breaks - **Reliable Detection**: Consistent performance in various conditions #### **3. TK36 Active Buzzer** - **Digital Control**: Simple on/off operation - **Loud Output**: Effective alarm sound - **Low Power**: Efficient operation #### **4. TK01 LED Module** - **Digital Control**: Simple on/off operation - **Visual Feedback**: Clear status indication - **PWM Capable**: Can be extended for dimming effects ### **Advanced Applications & Extensions** #### **1. Multi-Zone Security** - **Multiple Pairs**: Add more transmitter-receiver pairs - **Zone Identification**: Different alarms for different areas - **Sequential Detection**: Track movement through zones #### **2. Enhanced Features** - **Wireless Communication**: Add Bluetooth/WiFi for remote monitoring - **Data Logging**: Record all beam break events with timestamps - **Mobile Interface**: Smartphone app for system control - **Email Alerts**: Send notifications via internet #### **3. Advanced Algorithms** - **Pattern Recognition**: Distinguish between different types of interruptions - **Machine Learning**: Adaptive sensitivity based on environment - **False Alarm Reduction**: Filter out environmental interference #### **4. Commercial Applications** - **Retail Security**: Monitor store entrances and exits - **Industrial Safety**: Protect dangerous machinery areas - **Home Automation**: Integrate with smart home systems - **Pet Monitoring**: Track pet movement in restricted areas ### **Troubleshooting Guide** #### **1. IR Detection Issues** - **Check Alignment**: Ensure transmitter and receiver face each other - **Verify Distance**: Keep within 10-30cm range - **Test with Card**: Use opaque object to test beam break - **Check Wiring**: Verify D5 and D7 connections #### **2. Alarm Issues** - **Buzzer Wiring**: Check D9 connection and power - **LED Wiring**: Verify D3 connection - **Power Supply**: Ensure stable 5V power - **Serial Monitor**: Check for error messages #### **3. False Triggers** - **Ambient Light**: Reduce bright light interference - **Distance Adjustment**: Move modules closer together - **Alignment Fine-tuning**: Adjust angle for optimal detection - **Environmental Factors**: Check for reflective surfaces This modular design provides a solid foundation for understanding IR-based security systems and can be easily extended for more complex applications.