• 1 Fire Alarm Control Panel (FACP): The central component that monitors inputs and controls outputs based on those inputs.
• 4 Zones of Detection: Each zone can consist of several smoke detectors, heat detectors, and manual call points.
  • Smoke Detectors
  • Heat Detectors
  • Manual Call Points
• 1 Sounder: To alert in case of an alarm condition.
• End of Line Resistors (EOLR): For supervising the integrity of the circuit. The value depends on the FACP's specifications; a typical value is 4.7kΩ.
• Power Supply: Ensure it matches the requirements for your FACP and devices in terms of voltage and current.

1. Zones Connection:
   • Each zone would have its detectors and call points connected in series. The start of each zone connects to a separate zone input on the FACP.
   • At the end of each zone, you'd typically place an End of Line Resistor (EOLR) to monitor the integrity of the wiring. This way, the FACP can detect if there's a break in the circuit.
   • Example: Connect Smoke Detector Zone 1 to Manual Call Point Zone 1, then end the zone with EOLR, then back to the FACP Zone 1 input.
2. Sounder Connection:
   • The sounder can be connected to the sounder output on the FACP. You might need to check if you require a relay or if it can be directly connected based on your FACP and sounder specifications.
   • Connect Sounder: + to FACP: Sounder Output +, and Sounder: - to FACP: Sounder Output -.
3. Power Supply:
   • Connect the power supply to the FACP as per the manufacturer's instructions. Ensure it can also power the sounder and has enough capacity for all devices.
   • It's also critical to follow any local regulations and standards related to fire alarm systems, such as NFPA 72 in the United States.

• You might need additional components like relays or battery backup, depending on specific requirements.
• Ensure all connections conform to the requirements of the fire detection and alarm system standards applicable in your area.

• Microcontroller (MCU): Acts as the brain of the control panel. You can use something like an Arduino or an STM32, depending on your preference for programmability and complexity.
• 4 Fire Sensors (Smoke or Heat sensors): For detecting fire conditions in the vending machine.
• 4 Input Ports/Channels on the MCU: To connect each sensor to a separate input.
• Indicators (LEDs) or Display: For indicating which zone has been triggered.
• Power Supply: Ensure it matches your MCU and sensors' requirements.

1. Microcontroller Selection:
   • Choose an MCU with at least 4 GPIO (General Purpose Input/Output) pins available for the sensors, plus additional pins for indicators or a display. For example, an Arduino Uno could work well for a simple implementation.
2. Sensor Connection:
   • Assign each sensor to a dedicated GPIO pin on the MCU as an input.
   • Example connection setup:
     • Connect Sensor 1 to MCU: Digital Pin 2.
     • Connect Sensor 2 to MCU: Digital Pin 3.
     • Connect Sensor 3 to MCU: Digital Pin 4.
     • Connect Sensor 4 to MCU: Digital Pin 5.
   • Note: Ensure each sensor's output is compatible with the MCU's input voltage levels.
3. Indicator/Display Connection:
   • For LEDs: Assign an LED to each sensor to indicate activation.
     • Connect LED for Zone 1 to MCU: Digital Pin 6, and so on for each zone.
   • For Displays: Utilize SPI or I2C interface to connect an LCD/OLED display to show the activated zone(s).
4. Programming Logic:
   • Write a program that continuously polls each input pin connected to the sensors.
   • Upon detecting a signal (e.g., going HIGH), the program should identify which zone (sensor) was triggered and activate the corresponding LED or display a message on the display.
5. Power Supply Connection:
   • Make sure the power supply is capable of powering the MCU, sensors, and any display or LEDs you're using.

C
void setup() {
  // Initialize sensor input pins
  pinMode(2, INPUT);
  pinMode(3, INPUT);
  pinMode(4, INPUT);
  pinMode(5, INPUT);

  // Initialize LED output pins
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
}

void loop() {
  // Read each sensor and activate corresponding LED if triggered
  if(digitalRead(2) == HIGH) digitalWrite(6, HIGH);
  if(digitalRead(3) == HIGH) digitalWrite(7, HIGH);
  if(digitalRead(4) == HIGH) digitalWrite(8, HIGH);
  if(digitalRead(5) == HIGH) digitalWrite(9, HIGH);

  // Add delay to prevent bouncing
  delay(100);
}

• Microcontroller (MCU) with ample GPIO pins, I2C support, and enough memory or an interface for an external memory module. An MCU with more advanced capabilities compared to Arduino Uno, such as an ESP32, could be more suitable due to its built-in Wi-Fi module, higher processing power, and memory capacity.
• EEPROM or SD Card Module: To log the last 50 activities. EEPROM can be simple for smaller data logs, but an SD card could provide much more space for detailed logs.
• I2C Interface for Communication: To connect to the main PC or a module with I2C capability that can be interfaced with the PC.
• 4 Fire Sensors: As initially planned.
• Indicator LEDs or a small OLED/LCD Screen: For basic indication or to show more detailed status directly on the device. An OLED/LCD can be beneficial for displaying detailed logs or statuses.

1. Sensor to MCU Connection:
   • Similar to the initial design, each sensor connects to a distinct GPIO pin.
2. Memory Module:
   • Interface the EEPROM/SD Card module with the MCU through SPI or I2C (depending on the module). Use this to record timestamps, sensor IDs, or statuses each time an activity is detected.
3. I2C Communication:
   • Utilize the I2C interface for communication with the main PC. The MCU can act as an I2C slave device. Ensure the data structure sent over I2C can be easily parsed by the PC software for forwarding alerts via web/SMS.
4. Indication Mechanism:
   • Use LEDs for simple active/inactive status indicators. For detailed interfacing or troubleshooting directly on the device, consider an OLED/LCD screen connected via SPI or I2C, displaying more detailed information.
5. Software Logic:
   • Implement a logging mechanism that records each sensor activation with timestamps into the memory module.
   • Program an I2C communication protocol that allows the PC to request the log data, and then the ESP32 sends the requested data back.
   • Implement a mechanism to roll over the logs after 50 entries to ensure only the latest 50 activities are kept.
6. Interfacing with the PC:
   • The PC needs software capable of initiating I2C communication with the MCU, reading log data, and parsing this data for web/SMS alerting. This might involve a dedicated application or script that interfaces with I2C and utilizes internet/SMS gateways.

C
// Log event example
void logEvent(int sensorId) {
  // Retrieve current time (implement RTC or use NTP for ESP32)
  // Write sensorId and timestamp to EEPROM/SD card
}

// Manage log size to keep the latest 50 entries
void manageLogSize() {
  // Implement logic to check log size
  // If exceeding limits, delete the oldest entry
}

C
void setup() {
  // Initialize I2C as slave
}

void loop() {
  // Check for I2C request from PC
  // On request, send the latest log data
}

• 2 Push Buttons: One for muting the siren and another for resetting the system.

1. Button Connections:
   • Connect each button to a separate GPIO pin on the MCU. You’ll also need pull-up or pull-down resistors to ensure stable button states unless you’re using internal pull-up/down resistors provided by the MCU.
   • For the Mute Button, assume it's connected to MCU: GPIO X.
   • For the Reset Button, assume it's connected to MCU: GPIO Y.
2. Software Logic:
   • Update your software to include debounced button press detection for both the mute and reset functionalities. Debouncing is essential to ensure that the button press is detected accurately without interference from the physical bouncing of the button contacts.
   • When the mute button is pressed, disable the siren if it is currently active.
   • When the reset button is pressed, clear any active alarms, reset the system to its initial state, and prepare to detect new activities.

C
void setup() {
  pinMode(X, INPUT_PULLUP); // Mute Button
  pinMode(Y, INPUT_PULLUP); // Reset Button
  
  // Other setup code...
}

void loop() {
  checkButtons();
  
  // Rest of your loop code...
}

void checkButtons() {
  static unsigned long lastDebounceTimeMute = 0;
  static unsigned long lastDebounceTimeReset = 0;
  unsigned long debounceDelay = 50; // 50ms debounce time
  
  // Check the mute button
  if ((millis() - lastDebounceTimeMute) > debounceDelay) {
    if (digitalRead(X) == LOW) { // Assuming LOW when pressed
      muteSiren();
      lastDebounceTimeMute = millis();
    }
  }
  
  // Check the reset button
  if ((millis() - lastDebounceTimeReset) > debounceDelay) {
    if (digitalRead(Y) == LOW) { // Assuming LOW when pressed
      resetSystem();
      lastDebounceTimeReset = millis();
    }
  }
}

void muteSiren() {
  // Implement siren muting logic
}

void resetSystem() {
  // Implement system reset logic
}

• Mute Siren: Implement respective logic to mute or disable the siren sound. This could involve setting a GPIO pin LOW that controls a relay or transistor switch for the siren.
• Reset System: This should include clearing any logs representing active alarms, resetting detection states, and possibly sending a status update over I2C to notify the PC of the system reset.

• Dual-Core Processor: Provides ample processing power to handle sensor data management, logging, and communication tasks smoothly.
• Rich Set of Peripherals: Includes numerous GPIO pins, I2C interfaces, SPI ports, and more, allowing for easy connection of sensors, buttons, memory modules, and displays.
• Integrated Wi-Fi and Bluetooth: This feature can be instrumental for future project enhancements, like direct web connectivity for SMS alerts or remote system status monitoring, without requiring a PC as an intermediary.
• Ample Memory: Offers sufficient RAM and flash memory for complex programs and temporary data storage. If more data storage space for logs is needed, interfacing with an external SD card is straightforward.
• Low Power Consumption Modes: Enables power-saving modes, which can be beneficial for battery-operated versions of the project.

• Cortex-M3 Core: Good balance of processing power for handling data from multiple sensors and performing system control operations.
• Multiple Communication Interfaces: Includes I2C, SPI, USART, which are useful for interfacing with various peripherals and external modules.
• Moderate GPIO Count: While fewer than the ESP32, there are generally enough GPIOs for sensor inputs, buttons, and LEDs.
• External Memory Interface: For projects requiring more data storage than the internal flash and RAM offer, you can connect an external memory module.
• Energy Efficiency: The STM32 series is known for its efficiency, which is valuable for power-sensitive applications.

• For Connectivity and Complex Applications: Choose the ESP32. Its integrated Wi-Fi, higher RAM, and processing power make it suitable for comprehensive projects where future expansions into web connectivity or Bluetooth features might be considered.
• For Simplicity and Cost-Effectiveness: The STM32F103C8T6 (Blue Pill) is a strong candidate. It offers the necessary features at a lower cost, with the trade-off being the need for external modules for Wi-Fi connectivity and potentially a slightly more involved development environment setup.

• Optocoupler Selection: For interfacing with 24V signals, ensure the optocoupler you choose can handle the input side voltage. A common choice is the PC817, which is widely used and offers reliable performance.
• Circuit Design:
  • Input Side: Connect the anode of the optocoupler's LED to the 24V sensor output through a current-limiting resistor, and the cathode to the ground of the sensor's power supply.
  • Output Side: Connect the transistor side of the optocoupler to a GPIO pin on the STM32. Typically, the collector connects through a pull-up resistor to 3.3V, and the emitter connects to the ground of the MCU's power supply. When the sensor is triggered, the optocoupler closes this circuit, pulling the GPIO pin to ground, which can be read as a LOW state by the MCU.
• Current-Limiting Resistor Calculation for the LED side: To ensure you're within the safe operating range of the LED inside the optocoupler, calculate the resistor value using Ohm's law. Assuming a forward voltage of 1.2V for the LED and a forward current of 10mA, the resistor value can be calculated as follows:
  $$R = \frac{V_{source} - V_{forward}}{I_{forward}} = \frac{24V - 1.2V}{10mA} = 2.28k\Omega$$
  A standard value of 2.2kΩ can be used.

• SWDIO: Serial Wire Debug Data I/O
• SWCLK: Serial Wire Debug Clock
• NRST: Optional but recommended for resetting the device during programming.
• VDD and GND: Power supply connections are necessary for powering the MCU during programming.

• Make sure to integrate debouncing (either in hardware or software) for the input from the optocouplers. Electrical noise from the sensor activation could lead to false triggering without proper debouncing.
• When designing your PCB or breadboard layout, keep the high voltage parts physically separated from the low voltage MCU and its peripherals for safety and to minimize interference.
• Before finalizing the design, check the datasheets for your specific sensors, optocouplers, and the STM32F103C8T6 to ensure all voltage levels, current ratings, and other specifications match your requirements.

1. VDD (3.3V Power Supply):
   • Connect VDD pins (24 and 36) to a 3.3V supply. This supply should be stable and capable of providing sufficient current for the MCU and connected peripherals.
2. Ground (GND):
   • Connect VSS pins (23, 35, 47) to the ground of your power supply.
3. Decoupling Capacitors:
   • Place 0.1µF ceramic capacitors as close as possible between each VDD pin and ground to stabilize the power supply. Additionally, place a 10µF electrolytic capacitor near the power supply input for bulk decoupling.

1. Sensor Side:
   • Connect a current-limiting resistor (e.g., 2.2kΩ) in series with the anode (+) of the optocoupler's LED.
   • Connect the other end of the resistor to the 24V sensor output.
   • Connect the cathode (-) of the optocoupler's LED to the sensor's ground.
2. MCU Side:
   • Connect the collector of the optocoupler's transistor to a GPIO pin on the STM32 (e.g., PA0 for Zone 1).
   • Connect the emitter of the optocoupler's transistor to the MCU's ground.
   • Optionally, connect a pull-up resistor (4.7kΩ to 10kΩ) between this GPIO pin and the MCU's 3.3V supply, if your MCU configuration does not enable internal pull-ups.

1. SWDIO: Connect to pin 34 (PA13).
2. SWCLK: Connect to pin 37 (PA14).
3. NRST: Connect to pin 7 for resetting the device; optional but recommended for debugging.
4. GND: Connect the programmer's GND to the MCU’s ground.
5. 3.3V (Optional): Some programmers provide 3.3V output to power the target MCU during programming. This can be connected to VDD if needed, but be sure not to double-power the MCU if it's already connected to a separate power supply.

• Add a Boot Mode Selection Mechanism: The STM32F103C8T6 enters different boot modes depending on the state of BOOT0 (pin 44). Connect BOOT0 to GND for normal execution from Flash memory, or to 3.3V (through a resistor) for system memory boot mode, useful for internal bootloaders and programming.
• User Buttons: For your mute and reset buttons, connect one side to a GPIO pin and the other side to GND. Configure the GPIO pins with internal or external pull-up resistors to ensure they read HIGH when not pressed and go LOW when pressed.

• Normal State: In the absence of fire, conventional detectors usually maintain a nominal, low current level on the circuit. This current is monitored by the Fire Alarm Control Panel (FACP) to ensure the circuit's integrity and the detector's operational state.
• Alarm State: When fire is detected, the device alters the current flowing through the circuit. This can be achieved by the detector effectively short-circuiting itself or changing its internal resistance, causing a substantial increase in current flow. The FACP continuously monitors the current and interprets any significant deviation from the nominal level (either an increase or a decrease beyond predefined thresholds) as an alarm condition.

• Normal State: The detectors are part of a loop with a specific end-of-line (EOL) resistor at the far end, determining a known voltage drop across the circuit when it's in its normal state.
• Alarm State: Upon detecting fire conditions, the detector modifies the circuit, often by introducing an additional resistance or by shorting, which changes the voltage drop across the loop. This change is detected by the FACP as an alarm condition.

1. Sensor Side:
   • Each sensor is part of a zone circuit operating at 24V.
   • Place an end-of-line (EOL) resistor at the last detector of each zone to maintain a known voltage level during normal operation.
   • The sensor alters the voltage across this EOL resistor when an alarm condition is detected.
2. Optocoupler Interface:
   • The anode of the optocoupler LED connects through a current-limiting resistor to a point in the circuit where the voltage change occurs during an alarm. For a voltage-based sensor circuit, this is typically on the detector side of the EOL resistor.
   • The cathode of the optocoupler LED connects to the circuit's ground.
3. MCU Side:
   • The collector of the optocoupler transistor goes to a GPIO pin configured as an input.
   • The emitter goes to the MCU ground.
   • Ensure the GPIO pin is configured with an internal pull-up resistor or connect an external pull-up resistor (e.g., 10kΩ) to 3.3V. This configuration allows the pin to register a logic HIGH when no alarm is present and fall to logic LOW when the optocoupler is activated by an alarm condition.

• Alarm Condition Detection:
  • When the smoke detector in any zone is triggered, the voltage change will cause the optocoupler's LED to activate, turning on the transistor side, and pulling the associated GPIO pin to LOW. The MCU will interpret this state change as an alarm condition from the respective zone.

1. Configure GPIO Pins:
   • Initialize the designated GPIO pins connected to the optocouplers as digital inputs. Set them to use internal pull-up resistors if available.
2. Polling or Interrupts:
   • Polling: Regularly check the state of each GPIO pin to detect if any have transitioned to LOW, indicating an alarm.
   • Interrupts: Configure interrupts on the falling edge for the GPIO pins. The MCU will execute an interrupt service routine (ISR) when a pin goes LOW, facilitating immediate response to an alarm condition.

C
void setup() {
    pinMode(GPIO_Zone1, INPUT_PULLUP); // GPIO setup for Zone 1
    pinMode(GPIO_Zone2, INPUT_PULLUP); // Repeat for each zone
    // Configure interrupts or polling here
}

void loop() {
    // Example polling method
    if (digitalRead(GPIO_Zone1) == LOW) {
        // Handle alarm condition for Zone 1
    }
    // Repeat for other zones
}

• Make sure the current-limiting resistor for the optocoupler's LED side is chosen to limit the LED current safely within its specifications, taking into account the maximum voltage in alarm conditions.
• Always refer to the datasheets for specific component ratings and the smoke detector manual for detailed information on the alarm signaling characteristics. This will ensure that your interfacing circuit correctly interprets the signals from your fire detection zones.

1. 24V Power Supply Input (J5):
   • Connect the positive terminal of your 24V power source to J5, which will distribute power to each zone's sensors and optocouplers.
   • The negative terminal of your 24V source should be connected to the common ground that also ties to the STM32F103C8T6 GND and the ground of each optocoupler.
2. Zones (J1 to J4) - Sensor Side:
   • For each zone's terminal (J1 to J4), connect one terminal to the anode of the optocoupler's LED through a current-limiting resistor. This point will interface with the positive side of the sensor output in that zone.
   • Connect the other terminal directly to the common ground. This will interface with the negative side of the sensor output.
3. Optocouplers:
   • The anode of each optocoupler should connect through a current-limiting resistor to its respective zone's positive sensor output (as mentioned, this could be done via J1 to J4). The exact value of each resistor depends on the optocoupler's LED forward voltage and desired current but is generally calculated to limit the current to a safe value for the LED given a 24V supply.
   • The cathode of each optocoupler connects to the common ground.
4. Optocouplers to STM32F103C8T6:
   • The collector of each optocoupler's transistor side connects to a GPIO pin on the STM32F103C8T6 designated for that zone.
   • The emitter of each optocoupler connects to the MCU's ground.
   • Optionally, connect pull-up resistors (around 10kΩ) from the GPIO pins to 3.3V if the MCU's internal pull-ups are not used. This ensures the GPIO pins are HIGH by default and go LOW when the optocoupler is triggered.

• Verify Polarity of Connections: Ensure that the 24V and ground connections are correctly oriented, especially the 24V supply to the current-limiting resistors leading to the optocouplers' LEDs.
• Current-Limiting Resistor Values: Double-check the values of the current-limiting resistors for each optocoupler's LED to ensure they are appropriate for 24V operation.
• Common Ground: Confirm that the ground of the 24V supply, the ground side of each sensor output, the optocouplers, and the STM32F103C8T6's ground are all properly interconnected.
• GPIO Configuration: Make sure the GPIO pins connected to the optocouplers on the STM32F103C8T6 are correctly configured as inputs with pull-ups enabled (either internally or externally).
• Optocoupler Orientation: Ensure that the optocouplers are oriented correctly to function as intended when the sensors activate.