⚡ РЕЛЕ И СИЛОВАЯ ЭЛЕКТРОНИКА. КИЛОВАТТЫ В ТВОИХ РУКАХ! ВЫСОКОЕ НАПРЯЖЕНИЕ!

1🚨 DANGER: HIGH VOLTAGE! 🚨
2
3ЭТОТ СПРИНТ РАБОТАЕТ С ОПАСНЫМИ НАПРЯЖЕНИЯМИ!
4• 220V AC может быть СМЕРТЕЛЬНЫМ!
5• Только под СТРОГИМ надзором учителя!
6• ОБЯЗАТЕЛЬНЫЕ защитные средства!
7• Никаких экспериментов БЕЗ разрешения!
8
9SAFETY FIRST - ВСЕГДА И ВЕЗДЕ!

 1⚡ ЭЛЕКТРОМЕХАНИЧЕСКОЕ РЕЛЕ = ЭЛЕКТРОМАГНИТНЫЙ ПЕРЕКЛЮЧАТЕЛЬ
 2
 3АНАТОМИЯ РЕЛЕ:
 4┌─────────────────┐
 5│ Coil (катушка)  │ ← Управляющий электромагнит (12V DC)
 6│ Armature        │ ← Подвижный якорь
 7│ Contacts        │ ← Силовые контакты (220V AC, 10A)
 8│ Spring          │ ← Возвратная пружина
 9└─────────────────┘
10
11КАК РАБОТАЕТ МАГИЯ:
121. 12V подается на катушку
132. Электромагнит притягивает якорь
143. Якорь замыкает/размыкает контакты
154. Контакты коммутируют 220V нагрузку
165. Убираем 12V → пружина возвращает якорь
17
18ТИПЫ КОНТАКТОВ:
19🔘 NO (Normally Open):
20   • Покой: контакт РАЗОМКНУТ
21   • Активация: контакт ЗАМЫКАЕТСЯ
22   • Использование: включение нагрузки
23
24🔘 NC (Normally Closed):  
25   • Покой: контакт ЗАМКНУТ
26   • Активация: контакт РАЗМЫКАЕТСЯ
27   • Использование: аварийное отключение
28
29🔘 CHANGEOVER (переключающий):
30   • Один общий + два переключаемых
31   • Common → NO или Common → NC
32   • Использование: переключение между нагрузками
33
34ХАРАКТЕРИСТИКИ РЕЛЕ:
35⚡ COIL VOLTAGE: 5V, 12V, 24V (управление)
36⚡ CONTACT RATING: 250V AC, 10A (нагрузка)
37⚡ SWITCHING TIME: 5-15ms (механическая инерция)
38⚡ LIFETIME: 100,000 - 10,000,000 операций
39⚡ ISOLATION: 4000V между катушкой и контактами
40
41ПРЕИМУЩЕСТВА:
42✅ ВЫСОКАЯ изоляция (гальваническая развязка)
43✅ Любые типы нагрузок (AC, DC, индуктивные)
44✅ ДЕШЕВЫЕ ($1-5)
45✅ Простое управление
46
47НЕДОСТАТКИ:
48❌ ШУМНЫЕ (механический щелчок)
49❌ Медленные (миллисекунды)
50❌ Износ контактов
51❌ Искрение при коммутации
52❌ Electromagnetic interference (EMI)
53
54ПРИМЕНЕНИЯ:
55🏠 Home: освещение, отопление, кондиционеры
56🏭 Industrial: моторы, насосы, конвейеры
57🚗 Automotive: стартер, фары, сигналы
58🔌 Power: автоматические выключатели, контакторы

 1🥷 SOLID STATE RELAY (SSR) = ЭЛЕКТРОННЫЙ ПЕРЕКЛЮЧАТЕЛЬ
 2
 3АНАТОМИЯ SSR:
 4┌─────────────────┐
 5│ LED (input)     │ ← Управляющий светодиод (3-32V DC)
 6│ Optocoupler     │ ← Оптическая изоляция  
 7│ TRIAC/MOSFET    │ ← Силовой ключ (220V AC, 25A)
 8│ Zero crossing   │ ← Детектор перехода через ноль
 9└─────────────────┘
10
11ПРИНЦИП РАБОТЫ:
121. Управляющий сигнал → LED светится
132. Фототранзистор принимает свет
143. Драйвер открывает TRIAC/MOSFET
154. Силовая цепь замыкается
165. Zero crossing обеспечивает плавную коммутацию
17
18ТИПЫ SSR:
19🔄 AC SSR (TRIAC based):
20   • Для переменного тока
21   • Управление нагревателями, лампами
22   • Zero crossing switching (мягкая коммутация)
23
24⚡ DC SSR (MOSFET based):
25   • Для постоянного тока  
26   • Управление DC моторами, LED лентами
27   • Быстрая коммутация (микросекунды)
28
29🎛️ PHASE CONTROL SSR:
30   • Управление фазой синусоиды
31   • Плавное регулирование мощности
32   • Диммеры для ламп накаливания
33
34ХАРАКТЕРИСТИКИ SSR:
35⚡ INPUT: 3-32V DC, 5-25mA
36⚡ OUTPUT: 24-480V AC, до 100A
37⚡ SWITCHING TIME: 0.5-10ms
38⚡ ISOLATION: 2500V AC
39⚡ LIFETIME: неограниченный (нет износа)
40⚡ TEMPERATURE: требует радиатора при больших токах
41
42ПРЕИМУЩЕСТВА:
43✅ АБСОЛЮТНАЯ тишина
44✅ Быстрая коммутация
45✅ Долговечность
46✅ Нет искрения
47✅ Высокая частота переключений
48✅ Точное управление мощностью
49
50НЕДОСТАТКИ:
51❌ ДОРОГИЕ ($10-50)
52❌ Нагрев при больших токах
53❌ Только одного типа тока (AC или DC)
54❌ Сложная схемотехника
55❌ Чувствительность к перенапряжениям
56
57🆕 ADVANCED SSR FEATURES:
58
59ZERO CROSSING DETECTION:
60• Включение только в момент перехода AC через ноль
61• Минимизация помех и искрения
62• Защита от бросков тока
63
64SNUBBER CIRCUITS:
65• RC цепочки для подавления переходных процессов
66• Защита от паразитных срабатываний
67• Увеличение срока службы
68
69THERMAL PROTECTION:
70• Встроенная температурная защита
71• Автоматическое отключение при перегреве
72• Индикация состояния

 1🏭 ПРОМЫШЛЕННЫЕ СИЛОВЫЕ СИСТЕМЫ
 2
 3КОНТАКТОРЫ - ТЯЖЕЛАЯ АРТИЛЛЕРИЯ:
 4💪 Characteristics:
 5   • 25A - 1000A коммутируемый ток
 6   • 220V - 10kV рабочее напряжение
 7   • Механическая блокировка
 8   • Auxiliary contacts для индикации
 9
10ПРИМЕНЕНИЕ:
11🏭 Трехфазные электродвигатели
12🏭 Промышленные нагреватели  
13🏭 Сварочное оборудование
14🏭 Силовые трансформаторы
15
16АВТОМАТИЧЕСКИЕ ВЫКЛЮЧАТЕЛИ:
17🛡️ Circuit Breakers:
18   • Защита от перегрузки и КЗ
19   • Автоматическое отключение
20   • Manual reset
21   • Дифференциальная защита (УЗО)
22
23ДИММЕРЫ И РЕГУЛЯТОРЫ МОЩНОСТИ:
24🎛️ TRIAC Dimmers:
25   • Phase angle control
26   • 0-100% регулирование мощности
27   • Для резистивных нагрузок (лампы, нагреватели)
28
29🎛️ PWM Power Controllers:
30   • Для индуктивных нагрузок (моторы)
31   • Высокочастотная коммутация
32   • Меньше гармоник в сети
33
34🆕 СИСТЕМЫ БЕЗОПАСНОСТИ:
35
36EMERGENCY STOP SYSTEMS:
37• Категория безопасности SIL 1-3
38• Dual channel redundancy
39• Automatic testing
40• Fail-safe operation
41
42LOCKOUT/TAGOUT (LOTO):
43• Физическая блокировка выключателей
44• Процедуры безопасного обслуживания
45• Personal safety locks
46• Authorized personnel only
47
48ELECTRICAL SAFETY STANDARDS:
49📋 IEC 61511 - Functional Safety
50📋 IEC 60947 - Low Voltage Switchgear  
51📋 NFPA 70E - Electrical Safety in Workplace
52📋 NEC - National Electrical Code
53
54ARC FLASH PROTECTION:
55⚡ Incident Energy Calculations
56⚡ Personal Protective Equipment (PPE)
57⚡ Arc-resistant switchgear
58⚡ Remote operation capabilities
59
60ISOLATION AND EARTHING:
61🔌 Galvanic isolation requirements
62🔌 Protective earthing systems
63🔌 Equipotential bonding
64🔌 Surge protection devices
65
66🆕 SMART POWER DISTRIBUTION:
67
68INTELLIGENT SWITCHGEAR:
69• Ethernet/Modbus communication
70• Real-time power monitoring
71• Predictive maintenance
72• Remote diagnostics
73
74ENERGY MANAGEMENT:
75• Load shedding algorithms
76• Peak demand control
77• Power factor correction
78• Renewable energy integration
79
80CYBERSECURITY FOR POWER SYSTEMS:
81🔒 Network segmentation
82🔒 Industrial firewalls
83🔒 Encrypted communications
84🔒 Security auditing

  1💡 HARDWARE SETUP:
  2• ESP32 (WiFi для удаленного управления)
  3• 4-channel relay module (10A, 250V AC)
  4• 4x лампочки накаливания (100W каждая)
  5• Current sensors (ACS712-20A)
  6• Emergency stop button (большая красная!)
  7• OLED display для status
  8• Protective enclosure
  9
 10⚠️ КРИТИЧЕСКАЯ БЕЗОПАСНОСТЬ:
 11• НИКОГДА не касаться оголенных проводов!
 12• Подключение только при отключенном питании!
 13• Учитель проверяет ВСЕ соединения!
 14• Protective enclosure ОБЯЗАТЕЛЬНО!
 15
 16ПОДКЛЮЧЕНИЕ ОСВЕЩЕНИЯ:
 17Relay Module → ESP32:
 18├── VCC → 5V
 19├── GND → GND  
 20├── IN1 → GPIO16 (Light Zone 1)
 21├── IN2 → GPIO17 (Light Zone 2)
 22├── IN3 → GPIO18 (Light Zone 3)
 23└── IN4 → GPIO19 (Light Zone 4)
 24
 25Current Sensors → ESP32:
 26├── Sensor1 → GPIO34 (ADC)
 27├── Sensor2 → GPIO35 (ADC)
 28├── Sensor3 → GPIO32 (ADC)
 29└── Sensor4 → GPIO33 (ADC)
 30
 31Emergency Stop → GPIO21 (высший приоритет!)
 32
 33#include <WiFi.h>
 34#include <PubSubClient.h>
 35#include <ArduinoJson.h>
 36
 37// Relay control pins
 38const int RELAY_PINS[4] = {16, 17, 18, 19};
 39const int CURRENT_PINS[4] = {34, 35, 32, 33};
 40const int EMERGENCY_STOP = 21;
 41
 42// Safety state
 43bool emergencyStopActive = false;
 44bool systemSafeToOperate = true;
 45
 46struct LightZone {
 47  bool state;           // ON/OFF
 48  int brightness;       // 0-100% (if dimmer available)
 49  float current;        // Actual current consumption
 50  float power;          // Calculated power
 51  unsigned long onTime; // Time when turned on
 52  bool fault;           // Fault condition detected
 53};
 54
 55LightZone zones[4];
 56
 57void setup() {
 58  Serial.begin(115200);
 59  
 60  // Initialize relay pins as outputs  
 61  for (int i = 0; i < 4; i++) {
 62    pinMode(RELAY_PINS[i], OUTPUT);
 63    digitalWrite(RELAY_PINS[i], HIGH); // Relay OFF (active low)
 64  }
 65  
 66  // Emergency stop as input with pullup
 67  pinMode(EMERGENCY_STOP, INPUT_PULLUP);
 68  attachInterrupt(digitalPinToInterrupt(EMERGENCY_STOP), emergencyStopISR, FALLING);
 69  
 70  // WiFi and MQTT setup
 71  setupWiFi();
 72  setupMQTT();
 73  
 74  // Safety self-test
 75  performSafetyTest();
 76  
 77  Serial.println("Smart Lighting System READY");
 78  Serial.println("SAFETY: Emergency stop armed");
 79}
 80
 81// 🚨 EMERGENCY STOP INTERRUPT (HIGHEST PRIORITY!)
 82void IRAM_ATTR emergencyStopISR() {
 83  emergencyStopActive = true;
 84  
 85  // IMMEDIATELY turn off ALL relays
 86  for (int i = 0; i < 4; i++) {
 87    digitalWrite(RELAY_PINS[i], HIGH); // OFF
 88    zones[i].state = false;
 89  }
 90}
 91
 92void loop() {
 93  // SAFETY CHECK - highest priority
 94  if (emergencyStopActive) {
 95    handleEmergencyStop();
 96    return; // Don't execute anything else!
 97  }
 98  
 99  // Monitor current consumption
100  for (int i = 0; i < 4; i++) {
101    zones[i].current = readCurrent(CURRENT_PINS[i]);
102    zones[i].power = zones[i].current * 220.0; // P = UI (220V nominal)
103    
104    // OVERCURRENT PROTECTION
105    if (zones[i].current > 12.0) { // 12A limit for 10A relay
106      Serial.printf("OVERCURRENT Zone %d: %.2fA - EMERGENCY SHUTDOWN!\n", i+1, zones[i].current);
107      emergencyShutdownZone(i);
108    }
109    
110    // FAULT DETECTION: Current without relay activation
111    if (!zones[i].state && zones[i].current > 0.1) {
112      Serial.printf("FAULT Zone %d: Current detected but relay OFF!\n", i+1);
113      zones[i].fault = true;
114    }
115  }
116  
117  // MQTT command processing
118  if (mqttClient.connected()) {
119    mqttClient.loop();
120  }
121  
122  // Status reporting
123  publishSystemStatus();
124  
125  // Energy monitoring
126  calculateEnergyConsumption();
127  
128  delay(100); // 10 Hz monitoring
129}
130
131void controlLight(int zone, bool state) {
132  // SAFETY CHECKS before any operation
133  if (emergencyStopActive) {
134    Serial.println("BLOCKED: Emergency stop active!");
135    return;
136  }
137  
138  if (zone < 0 || zone > 3) {
139    Serial.println("ERROR: Invalid zone!");
140    return;
141  }
142  
143  if (zones[zone].fault) {
144    Serial.printf("BLOCKED: Zone %d has fault condition!\n", zone+1);
145    return;
146  }
147  
148  // Execute command
149  digitalWrite(RELAY_PINS[zone], state ? LOW : HIGH); // Active low relay
150  zones[zone].state = state;
151  zones[zone].onTime = state ? millis() : 0;
152  
153  Serial.printf("Zone %d: %s\n", zone+1, state ? "ON" : "OFF");
154  
155  // Log to MQTT
156  publishZoneStatus(zone);
157}
158
159// 🆕 Advanced lighting features
160void dimmerControl(int zone, int brightness) {
161  // For future SSR dimmer integration
162  if (brightness < 0) brightness = 0;
163  if (brightness > 100) brightness = 100;
164  
165  zones[zone].brightness = brightness;
166  
167  // Convert brightness to phase angle for TRIAC control
168  int phaseAngle = map(brightness, 0, 100, 140, 10); // degrees
169  
170  // This would control SSR dimmer module
171  // setPhaseAngle(zone, phaseAngle);
172  
173  Serial.printf("Zone %d dimmed to %d%%\n", zone+1, brightness);
174}
175
176void sceneLighting(String scene) {
177  if (scene == "evening") {
178    controlLight(0, true);   // Living room
179    controlLight(1, true);   // Kitchen  
180    controlLight(2, false);  // Bedroom
181    controlLight(3, false);  // Bathroom
182  }
183  else if (scene == "night") {
184    controlLight(0, false);  // All off except...
185    controlLight(1, false);
186    controlLight(2, false);
187    controlLight(3, true);   // Bathroom only
188  }
189  else if (scene == "party") {
190    for (int i = 0; i < 4; i++) {
191      controlLight(i, true); // All zones ON
192    }
193  }
194  else if (scene == "away") {
195    for (int i = 0; i < 4; i++) {
196      controlLight(i, false); // All zones OFF
197    }
198  }
199  
200  Serial.println("Scene activated: " + scene);
201}
202
203// MQTT command handler
204void onMqttMessage(char* topic, byte* payload, unsigned int length) {
205  String message = String((char*)payload, length);
206  StaticJsonDocument<200> doc;
207  deserializeJson(doc, message);
208  
209  if (String(topic) == "lighting/zone/command") {
210    int zone = doc["zone"];
211    bool state = doc["state"];
212    controlLight(zone - 1, state); // Convert to 0-based
213  }
214  
215  else if (String(topic) == "lighting/scene/command") {
216    String scene = doc["scene"];
217    sceneLighting(scene);
218  }
219  
220  else if (String(topic) == "lighting/dimmer/command") {
221    int zone = doc["zone"];
222    int brightness = doc["brightness"];
223    dimmerControl(zone - 1, brightness);
224  }
225  
226  else if (String(topic) == "lighting/emergency/stop") {
227    emergencyStopActive = true;
228    emergencyStopISR(); // Trigger emergency stop
229  }
230}
231
232ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
233✓ Управление 4 зонами освещения через MQTT
234✓ Monitoring энергопотребления в real-time  
235✓ Scene control (evening, night, party, away)
236✓ Overcurrent protection и fault detection
237✓ Emergency stop ВСЕГДА работает
238✓ Energy usage statistics и reporting

  1🔥 HARDWARE SETUP:
  2• Arduino Mega (больше GPIO для complex control)
  3• SSR modules (25A) для heating elements
  4• Temperature sensors (DS18B20) waterproof
  5• Flow sensors для circulation pumps
  6• Pressure sensors для system monitoring
  7• LCD display с кнопками для local control
  8• Watchdog timer module
  9
 10🔥 ПОДКЛЮЧЕНИЕ ОТОПЛЕНИЯ:
 11SSR Heaters → Arduino:
 12├── Heater1 (3kW) → Pin 22 + SSR1
 13├── Heater2 (3kW) → Pin 24 + SSR2  
 14├── Pump1 → Pin 26 + SSR3
 15└── Pump2 → Pin 28 + SSR4
 16
 17Temperature Sensors:
 18├── Supply → Pin 2 (OneWire bus)
 19├── Return → Pin 2 (OneWire bus)
 20├── Outdoor → Pin 2 (OneWire bus)  
 21└── Tank → Pin 2 (OneWire bus)
 22
 23#include <OneWire.h>
 24#include <DallasTemperature.h>
 25#include <PID_v1.h>
 26
 27// Heating zones
 28struct HeatingZone {
 29  String name;
 30  int ssrPin;
 31  double currentTemp;
 32  double targetTemp;
 33  double output;
 34  PID* controller;
 35  bool enabled;
 36  unsigned long heatingTime; // Total heating time
 37  double energyUsed;         // kWh consumed
 38};
 39
 40// PID controllers для каждой зоны
 41PID heater1PID(&zones[0].currentTemp, &zones[0].output, &zones[0].targetTemp, 2, 5, 1, DIRECT);
 42PID heater2PID(&zones[1].currentTemp, &zones[1].output, &zones[1].targetTemp, 2, 5, 1, DIRECT);
 43
 44HeatingZone zones[2] = {
 45  {"Living Room", 22, 0, 21.0, 0, &heater1PID, true, 0, 0},
 46  {"Bedroom", 24, 0, 19.0, 0, &heater2PID, true, 0, 0}
 47};
 48
 49void setup() {
 50  Serial.begin(115200);
 51  
 52  // Initialize SSR pins
 53  for (int i = 0; i < 2; i++) {
 54    pinMode(zones[i].ssrPin, OUTPUT);
 55    digitalWrite(zones[i].ssrPin, LOW); // SSR OFF
 56    
 57    // Configure PID
 58    zones[i].controller->SetMode(AUTOMATIC);
 59    zones[i].controller->SetOutputLimits(0, 255);
 60    zones[i].controller->SetSampleTime(10000); // 10 second intervals
 61  }
 62  
 63  Serial.println("Heating Control System READY");
 64}
 65
 66void loop() {
 67  // Read all temperatures
 68  readTemperatures();
 69  
 70  // Update each heating zone
 71  for (int i = 0; i < 2; i++) {
 72    updateHeatingZone(i);
 73  }
 74  
 75  // Safety checks
 76  performSafetyChecks();
 77  
 78  // Energy monitoring
 79  calculateEnergyUsage();
 80  
 81  // Status reporting
 82  publishHeatingStatus();
 83  
 84  delay(1000); // 1 Hz main loop
 85}
 86
 87void updateHeatingZone(int zone) {
 88  // Update PID controller
 89  zones[zone].controller->Compute();
 90  
 91  // Convert PID output to PWM для SSR
 92  // SSR with zero-crossing можно использовать PWM для power control
 93  analogWrite(zones[zone].ssrPin, zones[zone].output);
 94  
 95  // Track heating time и energy
 96  if (zones[zone].output > 0) {
 97    zones[zone].heatingTime += 1000; // 1 second
 98    
 99    // Energy calculation: Power * time * duty cycle
100    double dutyCycle = zones[zone].output / 255.0;
101    double powerKW = 3.0; // 3kW heater
102    double energyIncrement = powerKW * dutyCycle * (1.0/3600.0); // kWh
103    zones[zone].energyUsed += energyIncrement;
104  }
105  
106  Serial.printf("Zone %s: %.1f°C → %.1f°C (Output: %.0f%%)\n", 
107                zones[zone].name.c_str(),
108                zones[zone].currentTemp,
109                zones[zone].targetTemp, 
110                (zones[zone].output/255.0)*100);
111}
112
113// 🆕 Advanced heating features
114void weatherCompensation() {
115  double outdoorTemp = getOutdoorTemperature();
116  
117  // Adjust target temperatures based on outdoor conditions
118  for (int i = 0; i < 2; i++) {
119    double baseTarget = (zones[i].name == "Living Room") ? 21.0 : 19.0;
120    
121    if (outdoorTemp < -10) {
122      zones[i].targetTemp = baseTarget + 1.0; // Warmer inside when very cold
123    } else if (outdoorTemp > 15) {
124      zones[i].targetTemp = baseTarget - 1.0; // Cooler inside when mild outside
125    } else {
126      zones[i].targetTemp = baseTarget;
127    }
128  }
129}
130
131void loadBalancing() {
132  // Don't run both 3kW heaters simultaneously to avoid overload
133  static bool alternateHeaters = false;
134  
135  if (zones[0].output > 200 && zones[1].output > 200) {
136    if (alternateHeaters) {
137      zones[0].output = 255; // Full power zone 0
138      zones[1].output = 100; // Reduced power zone 1
139    } else {
140      zones[0].output = 100; // Reduced power zone 0  
141      zones[1].output = 255; // Full power zone 1
142    }
143    
144    alternateHeaters = !alternateHeaters; // Switch every cycle
145    Serial.println("Load balancing: Alternating heater priority");
146  }
147}
148
149ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
150✓ Dual-zone heating control с PID regulation
151✓ Weather compensation algorithm
152✓ Load balancing для power management
153✓ Energy consumption tracking
154✓ Safety overtemperature protection
155✓ MQTT integration для remote control

  1🎛️ HARDWARE SETUP:
  2• ESP32 (fast PWM capabilities)
  3• AC dimmer modules (TRIAC-based)
  4• Zero-crossing detection circuits
  5• Phase angle control
  6• Current/voltage monitoring
  7• Touch panel interface
  8• Music sync capability (звук → свет)
  9
 10🎛️ ПОДКЛЮЧЕНИЕ ДИММЕРОВ:
 11AC Dimmer Modules → ESP32:
 12├── Dimmer1 → GPIO25 (PWM output)
 13├── Dimmer2 → GPIO26 (PWM output)  
 14├── Dimmer3 → GPIO27 (PWM output)
 15├── Zero-Cross → GPIO35 (interrupt input)
 16└── Current Sense → GPIO34 (ADC input)
 17
 18#include "driver/ledc.h"
 19
 20// TRIAC dimmer control
 21struct DimmerChannel {
 22  int pin;
 23  int channel;
 24  int brightness;      // 0-100%
 25  int phaseAngle;      // 0-180 degrees
 26  bool enabled;
 27  String name;
 28  float currentLoad;   // Measured current
 29};
 30
 31DimmerChannel dimmers[3] = {
 32  {25, 0, 0, 180, false, "Main Lights", 0},
 33  {26, 1, 0, 180, false, "Accent Lights", 0},
 34  {27, 2, 0, 180, false, "Mood Lights", 0}
 35};
 36
 37volatile bool zeroCrossingDetected = false;
 38volatile unsigned long lastZeroCrossing = 0;
 39
 40void IRAM_ATTR zeroCrossingISR() {
 41  zeroCrossingDetected = true;
 42  lastZeroCrossing = micros();
 43}
 44
 45void setup() {
 46  Serial.begin(115200);
 47  
 48  // Configure zero-crossing interrupt
 49  pinMode(35, INPUT_PULLUP);
 50  attachInterrupt(digitalPinToInterrupt(35), zeroCrossingISR, RISING);
 51  
 52  // Configure PWM channels для phase control
 53  for (int i = 0; i < 3; i++) {
 54    ledcSetup(dimmers[i].channel, 5000, 8); // 5kHz, 8-bit resolution
 55    ledcAttachPin(dimmers[i].pin, dimmers[i].channel);
 56    ledcWrite(dimmers[i].channel, 0); // Start with 0% brightness
 57  }
 58  
 59  Serial.println("Smart Dimmer System READY");
 60}
 61
 62void loop() {
 63  // Phase angle control based on zero-crossing
 64  if (zeroCrossingDetected) {
 65    zeroCrossingDetected = false;
 66    updatePhaseControl();
 67  }
 68  
 69  // Monitor current для каждого dimmer
 70  monitorCurrentConsumption();
 71  
 72  // Process dimming commands
 73  processDimmerCommands();
 74  
 75  // Special effects
 76  handleSpecialEffects();
 77  
 78  delay(10); // 100 Hz control loop
 79}
 80
 81void updatePhaseControl() {
 82  for (int i = 0; i < 3; i++) {
 83    if (dimmers[i].enabled && dimmers[i].brightness > 0) {
 84      
 85      // Convert brightness (0-100%) to phase angle (10-170°)
 86      dimmers[i].phaseAngle = map(dimmers[i].brightness, 0, 100, 170, 10);
 87      
 88      // Calculate delay from zero-crossing
 89      // 50Hz AC = 10ms half-cycle = 180°
 90      unsigned long delayMicros = map(dimmers[i].phaseAngle, 0, 180, 0, 10000);
 91      
 92      // Schedule TRIAC trigger
 93      scheduleTRIACTrigger(i, delayMicros);
 94    } else {
 95      // Turn off completely
 96      ledcWrite(dimmers[i].channel, 0);
 97    }
 98  }
 99}
100
101void scheduleTRIACTrigger(int dimmer, unsigned long delayMicros) {
102  // This would ideally use hardware timer для precise timing
103  // For demo, we use simple delay (не ideal для production!)
104  
105  delayMicroseconds(delayMicros);
106  
107  // Short pulse to trigger TRIAC
108  ledcWrite(dimmers[dimmer].channel, 255); // Trigger pulse
109  delayMicroseconds(100);                  // 100µs pulse width
110  ledcWrite(dimmers[dimmer].channel, 0);   // End pulse
111}
112
113// 🆕 Special effects
114void effectFadeInOut(int dimmer, int duration) {
115  // Smooth fade from 0 to 100% and back
116  for (int brightness = 0; brightness <= 100; brightness += 2) {
117    dimmers[dimmer].brightness = brightness;
118    delay(duration / 100);
119  }
120  
121  for (int brightness = 100; brightness >= 0; brightness -= 2) {
122    dimmers[dimmer].brightness = brightness;
123    delay(duration / 100);
124  }
125}
126
127void effectColorTemperature(int warmDimmer, int coolDimmer, int temperature) {
128  // Temperature: 2700K (warm) to 6500K (cool)
129  int warmBrightness = map(temperature, 2700, 6500, 100, 0);
130  int coolBrightness = map(temperature, 2700, 6500, 0, 100);
131  
132  dimmers[warmDimmer].brightness = warmBrightness;
133  dimmers[coolDimmer].brightness = coolBrightness;
134  
135  Serial.printf("Color temp: %dK (Warm: %d%%, Cool: %d%%)\n", 
136                temperature, warmBrightness, coolBrightness);
137}
138
139void effectMusicSync() {
140  // Read audio input (microphone or line-in)
141  int audioLevel = analogRead(A0);
142  
143  // Convert audio level to brightness
144  int brightness = map(audioLevel, 0, 4095, 0, 100);
145  
146  // Apply to all dimmers with different sensitivities
147  dimmers[0].brightness = brightness;           // Direct response
148  dimmers[1].brightness = brightness * 0.7;    // 70% response
149  dimmers[2].brightness = brightness * 0.4;    // 40% response
150  
151  // Bass emphasis (low-pass filter)
152  static int bassLevel = 0;
153  bassLevel = (bassLevel * 0.8) + (brightness * 0.2);
154  dimmers[2].brightness = bassLevel; // Bass-driven mood lighting
155}
156
157// MQTT command handler
158void onMqttMessage(char* topic, byte* payload, unsigned int length) {
159  String message = String((char*)payload, length);
160  StaticJsonDocument<200> doc;
161  deserializeJson(doc, message);
162  
163  if (String(topic) == "dimmer/channel/set") {
164    int channel = doc["channel"];
165    int brightness = doc["brightness"];
166    
167    if (channel >= 0 && channel < 3) {
168      dimmers[channel].brightness = constrain(brightness, 0, 100);
169      dimmers[channel].enabled = (brightness > 0);
170    }
171  }
172  
173  else if (String(topic) == "dimmer/effect/start") {
174    String effect = doc["effect"];
175    
176    if (effect == "fade") {
177      int channel = doc["channel"];
178      int duration = doc["duration"];
179      effectFadeInOut(channel, duration);
180    }
181    else if (effect == "music_sync") {
182      // Enable music sync mode
183      enableMusicSync();
184    }
185    else if (effect == "color_temp") {
186      int temperature = doc["temperature"];
187      effectColorTemperature(0, 1, temperature);
188    }
189  }
190}
191
192ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
193✓ 3-channel AC dimming с phase control
194✓ Zero-crossing detection для smooth operation
195✓ Special effects: fade, color temperature, music sync
196✓ Current monitoring и overload protection
197✓ MQTT control interface
198✓ Touch panel local control

  1🏭 HARDWARE SETUP:
  2• PLC-style controller (Arduino Industrial)
  3• Multiple contactor modules (25A, 3-phase)
  4• Industrial sensors (proximity, photoelectric)
  5• Motor starters с overload protection
  6• HMI touch panel
  7• Emergency stop circuits (Category 3 safety)
  8• 24V DC industrial power supply
  9
 10🏭 ПОДКЛЮЧЕНИЕ ПРОМЫШЛЕННОЙ СИСТЕМЫ:
 11Contactors → Industrial Controller:
 12├── Motor1 Contactor → Output 1
 13├── Motor2 Contactor → Output 2
 14├── Conveyor Contactor → Output 3
 15├── Heater Contactor → Output 4
 16├── Cooling Fan → Output 5
 17└── Emergency Systems → Hardwired safety
 18
 19Sensors → Controller:
 20├── Part Present → Input 1
 21├── Position Sensor → Input 2  
 22├── Safety Door → Input 3
 23├── Pressure Switch → Input 4
 24└── Temperature → Analog Input 1
 25
 26#include <ModbusRTU.h>
 27#include <HMI_Display.h>
 28
 29// Industrial I/O mapping
 30struct IndustrialIO {
 31  // Digital outputs (contactors/relays)
 32  bool motor1Running;
 33  bool motor2Running; 
 34  bool conveyorRunning;
 35  bool heaterEnabled;
 36  bool coolingFanRunning;
 37  
 38  // Digital inputs (sensors)
 39  bool partPresent;
 40  bool positionSensor;
 41  bool safetyDoorClosed;
 42  bool pressureOK;
 43  
 44  // Analog inputs
 45  float temperature;
 46  float pressure;
 47  float vibration;
 48  
 49  // System status
 50  bool systemReady;
 51  bool emergencyStop;
 52  bool faultCondition;
 53};
 54
 55IndustrialIO io;
 56
 57// Production sequence states
 58enum ProductionState {
 59  IDLE,
 60  PART_LOADING,
 61  PROCESSING,
 62  QUALITY_CHECK,
 63  PART_UNLOADING,
 64  FAULT
 65};
 66
 67ProductionState currentState = IDLE;
 68unsigned long stateStartTime = 0;
 69
 70void setup() {
 71  Serial.begin(115200);
 72  
 73  // Initialize industrial I/O
 74  initializeIndustrialIO();
 75  
 76  // Setup Modbus communication
 77  setupModbus();
 78  
 79  // Initialize HMI
 80  setupHMI();
 81  
 82  // Safety system self-test
 83  performSafetyTest();
 84  
 85  Serial.println("Industrial Automation Cell READY");
 86}
 87
 88void loop() {
 89  // HIGHEST PRIORITY: Safety monitoring
 90  monitorSafetySystems();
 91  
 92  if (io.emergencyStop || io.faultCondition) {
 93    handleEmergencyState();
 94    return;
 95  }
 96  
 97  // Read all sensors
 98  updateInputs();
 99  
100  // Main production sequence
101  runProductionSequence();
102  
103  // Update outputs
104  updateOutputs();
105  
106  // Process Modbus communications
107  processModbus();
108  
109  // Update HMI display
110  updateHMI();
111  
112  // Data logging
113  logProductionData();
114  
115  delay(50); // 20 Hz industrial control loop
116}
117
118void runProductionSequence() {
119  switch (currentState) {
120    
121    case IDLE:
122      // Wait for part и safety conditions
123      if (io.partPresent && io.safetyDoorClosed && io.pressureOK) {
124        Serial.println("Production: Starting cycle");
125        changeState(PART_LOADING);
126      }
127      break;
128      
129    case PART_LOADING:
130      // Start conveyor to position part
131      io.conveyorRunning = true;
132      
133      if (io.positionSensor) {
134        Serial.println("Production: Part positioned");
135        io.conveyorRunning = false;
136        changeState(PROCESSING);
137      }
138      
139      // Timeout protection
140      if (getStateTime() > 10000) { // 10 seconds max
141        Serial.println("ERROR: Part loading timeout");
142        changeState(FAULT);
143      }
144      break;
145      
146    case PROCESSING:
147      // Start motors и heater для processing
148      io.motor1Running = true;
149      io.motor2Running = true;
150      io.heaterEnabled = true;
151      
152      // Wait for temperature и processing time
153      if (io.temperature > 80.0 && getStateTime() > 15000) {
154        Serial.println("Production: Processing complete");
155        changeState(QUALITY_CHECK);
156      }
157      
158      // Fault detection
159      if (io.temperature > 120.0) {
160        Serial.println("ERROR: Overtemperature");
161        changeState(FAULT);
162      }
163      break;
164      
165    case QUALITY_CHECK:
166      // Stop heating, start cooling
167      io.heaterEnabled = false;
168      io.coolingFanRunning = true;
169      
170      // Check quality parameters
171      if (checkQualityParameters()) {
172        Serial.println("Production: Quality OK");
173        changeState(PART_UNLOADING);
174      } else {
175        Serial.println("ERROR: Quality failure");
176        changeState(FAULT);
177      }
178      break;
179      
180    case PART_UNLOADING:
181      // Move part out
182      io.conveyorRunning = true;
183      
184      if (!io.partPresent) {
185        Serial.println("Production: Cycle complete");
186        allOutputsOff();
187        changeState(IDLE);
188      }
189      break;
190      
191    case FAULT:
192      // All outputs OFF, wait for reset
193      allOutputsOff();
194      
195      if (getFaultResetCommand()) {
196        Serial.println("Production: Fault reset");
197        changeState(IDLE);
198      }
199      break;
200  }
201}
202
203// 🆕 Predictive maintenance
204void predictiveMaintenance() {
205  // Vibration analysis
206  if (io.vibration > VIBRATION_WARNING_LEVEL) {
207    sendMaintenanceAlert("High vibration detected on Motor1");
208  }
209  
210  // Temperature trending
211  static float tempHistory[100];
212  static int tempIndex = 0;
213  
214  tempHistory[tempIndex] = io.temperature;
215  tempIndex = (tempIndex + 1) % 100;
216  
217  // Calculate temperature trend
218  float tempTrend = calculateTrend(tempHistory, 100);
219  if (tempTrend > 0.5) { // Rising trend
220    sendMaintenanceAlert("Temperature trending upward - check cooling system");
221  }
222  
223  // Runtime hours tracking
224  static unsigned long motorRuntime = 0;
225  if (io.motor1Running) {
226    motorRuntime += 50; // 50ms loop time
227  }
228  
229  if (motorRuntime > MOTOR_MAINTENANCE_INTERVAL) {
230    sendMaintenanceAlert("Motor1 due for maintenance - " + String(motorRuntime/3600000) + " hours");
231  }
232}
233
234// 🆕 Energy optimization
235void energyOptimization() {
236  // Load shedding during peak demand
237  if (getPeakDemandSignal()) {
238    if (!isCriticalProduction()) {
239      // Temporarily reduce non-essential loads
240      io.coolingFanRunning = false;
241      io.heaterEnabled = false;
242      
243      scheduleRestart(5 * 60 * 1000); // Resume in 5 minutes
244    }
245  }
246  
247  // Power factor optimization
248  if (getPowerFactor() < 0.85) {
249    activateCapacitorBank();
250  }
251  
252  // Variable speed drive optimization
253  adjustMotorSpeed(calculateOptimalSpeed());
254}
255
256ПЕРВАЯ БОЕВАЯ ЗАДАЧА:
257✓ Complete production sequence automation
258✓ Multi-state machine operation
259✓ Industrial safety systems
260✓ Predictive maintenance algorithms
261✓ Energy optimization features
262✓ Modbus communication
263✓ HMI operator interface

  1// 🌐 SMART GRID COORDINATION SYSTEM
  2#include <WiFi.h>
  3#include <PubSubClient.h>
  4#include <ArduinoJson.h>
  5#include <ModbusIP.h>
  6
  7// Global grid state
  8struct GridNode {
  9  String nodeId;
 10  String nodeType;        // "lighting", "heating", "industrial"
 11  float powerConsumption; // Current power draw (kW)
 12  float maxCapacity;      // Maximum rated power (kW)
 13  int priority;           // 1=critical, 5=optional
 14  bool canShed;           // Can this load be temporarily disconnected?
 15  bool isOnline;
 16  unsigned long lastUpdate;
 17};
 18
 19std::vector<GridNode> gridNodes;
 20float totalGridLoad = 0;
 21float gridCapacity = 50.0; // 50kW total grid capacity
 22bool peakDemandMode = false;
 23
 24// 🔋 ENERGY STORAGE SYSTEM
 25struct BatterySystem {
 26  float capacity;         // Total capacity (kWh)
 27  float currentCharge;    // Current stored energy (kWh)
 28  float chargeRate;       // Current charging rate (kW)
 29  float dischargeRate;    // Current discharge rate (kW)
 30  bool charging;
 31  bool discharging;
 32  float efficiency;       // Round-trip efficiency (0.85 = 85%)
 33};
 34
 35BatterySystem battery = {100.0, 50.0, 0, 0, false, false, 0.85};
 36
 37void setup() {
 38  Serial.begin(115200);
 39  
 40  // Initialize grid communication
 41  setupGridCommunication();
 42  
 43  // Register this node
 44  registerGridNode();
 45  
 46  // Start grid monitoring
 47  startGridMonitoring();
 48  
 49  Serial.println("Smart Grid Controller READY");
 50}
 51
 52void loop() {
 53  // Update grid status
 54  updateGridStatus();
 55  
 56  // Load balancing decisions
 57  performLoadBalancing();
 58  
 59  // Energy storage management
 60  manageBatterySystem();
 61  
 62  // Renewable energy integration
 63  manageRenewableEnergy();
 64  
 65  // Grid optimization
 66  optimizeGridOperation();
 67  
 68  // Emergency response
 69  handleGridEmergencies();
 70  
 71  delay(1000); // 1 Hz grid management
 72}
 73
 74// 🎯 INTELLIGENT LOAD BALANCING
 75void performLoadBalancing() {
 76  // Calculate total current load
 77  totalGridLoad = 0;
 78  for (auto& node : gridNodes) {
 79    if (node.isOnline) {
 80      totalGridLoad += node.powerConsumption;
 81    }
 82  }
 83  
 84  // Check if approaching capacity limit
 85  float loadPercentage = (totalGridLoad / gridCapacity) * 100;
 86  
 87  if (loadPercentage > 95) {
 88    Serial.println("CRITICAL: Grid approaching capacity limit!");
 89    initiateLoadShedding();
 90  }
 91  else if (loadPercentage > 85) {
 92    Serial.println("WARNING: High grid load - optimizing");
 93    optimizeNonCriticalLoads();
 94  }
 95  else if (loadPercentage < 30 && battery.currentCharge < battery.capacity * 0.8) {
 96    // Low load - good time to charge batteries
 97    startBatteryCharging();
 98  }
 99  
100  Serial.printf("Grid Load: %.1fkW / %.1fkW (%.1f%%)\n", 
101                totalGridLoad, gridCapacity, loadPercentage);
102}
103
104void initiateLoadShedding() {
105  Serial.println("Initiating emergency load shedding...");
106  
107  // Sort nodes by priority (shed lowest priority first)
108  std::sort(gridNodes.begin(), gridNodes.end(), 
109           [](const GridNode& a, const GridNode& b) {
110             return a.priority > b.priority;
111           });
112  
113  float targetReduction = totalGridLoad - (gridCapacity * 0.90); // Target 90% load
114  float actualReduction = 0;
115  
116  for (auto& node : gridNodes) {
117    if (node.canShed && actualReduction < targetReduction) {
118      // Send load shed command
119      shedLoad(node.nodeId, node.powerConsumption);
120      actualReduction += node.powerConsumption;
121      
122      Serial.printf("SHED: %s (%.1fkW) - Priority %d\n", 
123                    node.nodeId.c_str(), node.powerConsumption, node.priority);
124    }
125  }
126  
127  // Log load shedding event
128  logGridEvent("LOAD_SHED", actualReduction, "Emergency capacity protection");
129}
130
131// 🌞 RENEWABLE ENERGY INTEGRATION
132void manageRenewableEnergy() {
133  static float solarGeneration = 0;
134  static float windGeneration = 0;
135  
136  // Simulate renewable energy sources (в real system - actual sensors)
137  solarGeneration = calculateSolarGeneration();
138  windGeneration = calculateWindGeneration();
139  
140  float totalRenewable = solarGeneration + windGeneration;
141  
142  Serial.printf("Renewable: Solar %.1fkW, Wind %.1fkW, Total %.1fkW\n",
143                solarGeneration, windGeneration, totalRenewable);
144  
145  // Grid feed-in decision
146  if (totalRenewable > totalGridLoad) {
147    // Excess renewable energy
148    float excess = totalRenewable - totalGridLoad;
149    
150    if (battery.currentCharge < battery.capacity * 0.95) {
151      // Charge batteries with excess
152      battery.chargeRate = min(excess, 10.0); // Max 10kW charge rate
153      battery.charging = true;
154      battery.discharging = false;
155      
156      Serial.printf("Charging battery with %.1fkW excess renewable\n", battery.chargeRate);
157    } else {
158      // Sell excess to grid или curtail production
159      sellExcessToGrid(excess);
160    }
161  }
162  else if (totalRenewable < totalGridLoad * 0.8) {
163    // Low renewable generation - may need grid power или battery
164    float shortfall = totalGridLoad - totalRenewable;
165    
166    if (battery.currentCharge > battery.capacity * 0.2) {
167      // Use battery to supplement
168      battery.dischargeRate = min(shortfall, battery.currentCharge * 0.1); // Max 10% per hour
169      battery.charging = false;
170      battery.discharging = true;
171      
172      Serial.printf("Supplementing with %.1fkW from battery\n", battery.dischargeRate);
173    } else {
174      // Need grid power
175      purchaseGridPower(shortfall);
176    }
177  }
178}
179
180// 🔋 BATTERY MANAGEMENT SYSTEM
181void manageBatterySystem() {
182  static unsigned long lastBatteryUpdate = 0;
183  
184  if (millis() - lastBatteryUpdate >= 1000) { // Update every second
185    
186    if (battery.charging && battery.chargeRate > 0) {
187      // Add energy to battery (accounting for efficiency)
188      float energyAdded = (battery.chargeRate * battery.efficiency) / 3600.0; // kWh per second
189      battery.currentCharge += energyAdded;
190      
191      if (battery.currentCharge >= battery.capacity) {
192        battery.currentCharge = battery.capacity;
193        battery.charging = false;
194        battery.chargeRate = 0;
195        Serial.println("Battery fully charged");
196      }
197    }
198    
199    if (battery.discharging && battery.dischargeRate > 0) {
200      // Remove energy from battery
201      float energyUsed = battery.dischargeRate / 3600.0; // kWh per second
202      battery.currentCharge -= energyUsed;
203      
204      if (battery.currentCharge <= 0) {
205        battery.currentCharge = 0;
206        battery.discharging = false;
207        battery.dischargeRate = 0;
208        Serial.println("Battery depleted");
209      }
210    }
211    
212    lastBatteryUpdate = millis();
213  }
214  
215  // Battery health monitoring
216  float stateOfCharge = (battery.currentCharge / battery.capacity) * 100;
217  
218  if (stateOfCharge < 10) {
219    Serial.println("WARNING: Battery critically low");
220    // Initiate controlled load shedding to preserve critical systems
221  }
222  else if (stateOfCharge > 95) {
223    Serial.println("INFO: Battery near full capacity");
224    // Good time для high-energy activities
225  }
226  
227  // Publish battery status
228  publishBatteryStatus(stateOfCharge, battery.charging, battery.discharging);
229}
230
231// 🚨 GRID EMERGENCY RESPONSE
232void handleGridEmergencies() {
233  // Monitor для grid anomalies
234  
235  // Frequency monitoring (50Hz nominal)
236  float gridFrequency = measureGridFrequency();
237  if (gridFrequency < 49.5 || gridFrequency > 50.5) {
238    Serial.printf("ALERT: Grid frequency anomaly: %.2fHz\n", gridFrequency);
239    
240    if (gridFrequency < 49.0) {
241      // Under-frequency load shedding
242      initiateUFLS();
243    }
244  }
245  
246  // Voltage monitoring
247  float gridVoltage = measureGridVoltage();
248  if (gridVoltage < 207 || gridVoltage > 253) { // ±10% of 230V
249    Serial.printf("ALERT: Grid voltage anomaly: %.1fV\n", gridVoltage);
250    
251    if (gridVoltage < 190) {
252      // Critical under-voltage - disconnect sensitive loads
253      protectSensitiveLoads();
254    }
255  }
256  
257  // Communication loss detection
258  unsigned long now = millis();
259  for (auto& node : gridNodes) {
260    if (now - node.lastUpdate > 30000) { // 30 seconds timeout
261      Serial.printf("WARNING: Lost communication with %s\n", node.nodeId.c_str());
262      node.isOnline = false;
263      
264      // Assume worst-case load для safety
265      node.powerConsumption = node.maxCapacity;
266    }
267  }
268}
269
270// 📊 GRID ANALYTICS AND OPTIMIZATION
271void optimizeGridOperation() {
272  // Peak demand prediction
273  float predictedPeak = predictPeakDemand();
274  
275  if (predictedPeak > gridCapacity * 0.9) {
276    // Prepare для peak demand
277    Serial.println("Preparing for predicted peak demand");
278    
279    // Pre-charge batteries
280    if (battery.currentCharge < battery.capacity * 0.8) {
281      startBatteryCharging();
282    }
283    
284    // Pre-heat/cool buildings to reduce peak load
285    sendPreConditioningCommands();
286    
287    // Schedule non-critical loads для off-peak times
288    scheduleFlexibleLoads();
289  }
290  
291  // Power quality optimization
292  optimizePowerQuality();
293  
294  // Economic dispatch
295  economicDispatch();
296}
297
298// MQTT Grid Communication
299void onGridMqttMessage(char* topic, byte* payload, unsigned int length) {
300  String message = String((char*)payload, length);
301  StaticJsonDocument<300> doc;
302  deserializeJson(doc, message);
303  
304  if (String(topic) == "grid/node/status") {
305    updateNodeStatus(doc["nodeId"], doc["power"], doc["status"]);
306  }
307  
308  else if (String(topic) == "grid/emergency/command") {
309    String command = doc["command"];
310    
311    if (command == "load_shed") {
312      float targetReduction = doc["amount"];
313      initiateLoadShedding();
314    }
315    else if (command == "islanding") {
316      initiateIslandMode();
317    }
318  }
319  
320  else if (String(topic) == "grid/pricing/update") {
321    float currentPrice = doc["price"];
322    updateEnergyPricing(currentPrice);
323  }
324}