Project Demonstration Video
Watch the automated gate entry, rain roof shuttering, and real-time gas alarm response in action:
noteThe demonstration video above automatically starts in muted mode. Click the volume icon on the player at any time to enable full audio playback!
Architectural Overview: Why Dual Microcontrollers?
Modern domestic automation requires both deterministic hard real-time safety and frictionless cloud internet connectivity. Attempting to run high-speed motor sequencing, safety interrupts, and gas detection on a cloud-polled device often results in delayed responses whenever WiFi lags.
To solve this, our Smart House utilizes a decoupled Dual-MCU architecture:
Arduino Source (.ino)ino
1 +---------------------------------------+
2 | SMART HOUSE HUB |
3 +-------------------+-------------------+
4 |
5 +----------------------------------+----------------------------------+
6 | |
7 v v
8 [ ARDUINO UNO SUBSYSTEM ] [ ESP32 IOT SUBSYSTEM ]
9 Real-Time Autonomous Safety Cloud Remote Control (Blynk)
10 | |
11 +-------------+-------------+ +-------------+-------------+
12 | | | | |
13 v v v v v
14 [Gas Mon] [Rain Roof] [Ultrasonic] [5V Relay] [L298N #2]
15 MQ-2 / YL-83 + HC-SR04 + Light Twin Room
16 Buzzer L298N #2 Gate & Shutter (Living Room) Fans
- Subsystem A — Arduino UNO (Deterministic Safety & Automation):
- Gas Leak Sentry: Samples the gas sensor continuously. If LPG or combustible gases breach threshold levels, an active audio alarm triggers immediately via
BUZZER_PINwithout relying on network latency. - Smart Rain Roof: Continuously monitors the
YL-83raindrop sensor with debounce verification. When rain is confirmed, it commands a motorized awning roof to slide forward, shielding outdoor areas. - Intelligent Gate & Garage Shutter: Measures ultrasonic echo times. When an approaching vehicle reaches within , it coordinates a timed garage sequence: opens the main gate, lifts the roll-up shutter, pauses for vehicle parking, and then seals both barriers.
- Subsystem B — ESP32 (Cloud IoT Control via Blynk 2.0):
- Connects to home 2.4 GHz WiFi networks using the onboard ESP-WROOM-32 transceiver.
- Subscribes to the Blynk 2.0 IoT Cloud Platform to allow smartphone remote toggling of ambient lights via a 5V relay module and speed regulation of twin room ventilation fans via a dedicated L298N H-bridge driver.
Complete Circuit Schematic & Wiring Guide
Below is the verified connection schematic illustrating both the Arduino UNO automation wiring (left side) and the ESP32 Blynk IoT control circuit (right side).
1. Arduino UNO Safety & Motor Pin Connections
| Arduino UNO Pin | Module / Sensor Pin | Description |
|---|---|---|
| Digital Pin 2 | Rain Sensor Digital Out (DO) | Active LOW rain presence signal from YL-83 comparator |
| Analog Pin A3 | MQ Gas Sensor Digital Out (DO) | Active LOW gas leak detection threshold |
| Digital Pin 4 | Active Piezo Buzzer Negative terminal | Active LOW alarm trigger (+ terminal tied to 5V) |
| Digital Pin 6 | HC-SR04 Ultrasonic TRIG | ultrasonic pulse trigger |
| Digital Pin 11 | HC-SR04 Ultrasonic ECHO | Ultrasonic flight-time pulse listener |
| Digital Pin 5 | L298N #1 GATE_ENA | PWM speed regulation for Main Gate motor |
| Digital Pin 7 | L298N #1 GATE_IN1 | Gate motor directional logic 1 |
| Digital Pin 8 | L298N #1 GATE_IN2 | Gate motor directional logic 2 |
| Digital Pin 9 | L298N #1 SHUTTER_ENB | PWM speed regulation for Garage Shutter |
| Digital Pin 10 | L298N #1 SHUTTER_IN3 | Garage Shutter directional logic 1 |
| Digital Pin 12 | L298N #1 SHUTTER_IN4 | Garage Shutter directional logic 2 |
| Digital Pin 3 | L298N #2 RAIN_ENA | PWM speed regulation for Rain Roof motor |
| Analog Pin A0 | L298N #2 RAIN_IN1 | Retractable roof directional logic 1 |
| Analog Pin A1 | L298N #2 RAIN_IN2 | Retractable roof directional logic 2 |
| 5V / GND | Sensors & Motor Logic GND | Shared reference ground and 5V sensor power bus |
2. ESP32 Blynk IoT Cloud Pin Connections
| ESP32 GPIO Pin | Module / Component Pin | Description |
|---|---|---|
| GPIO 23 | 1-Channel Relay IN | Active-LOW relay module switching main room light |
| GPIO 4 | L298N #3 FAN1_ENA | Hardware PWM speed channel for Room Fan 1 |
| GPIO 18 | L298N #3 FAN1_IN1 | Directional drive pin for Room Fan 1 |
| GPIO 5 | L298N #3 FAN1_IN2 | Ground return pin for Room Fan 1 |
| GPIO 2 | L298N #3 FAN2_ENB | Hardware PWM speed channel for Room Fan 2 |
| GPIO 16 | L298N #3 FAN2_IN3 | Directional drive pin for Room Fan 2 |
| GPIO 17 | L298N #3 FAN2_IN4 | Ground return pin for Room Fan 2 |
| GND | Battery Pack & Driver GND | Common Ground shared across battery and ESP32 |
warningCommon Ground Rule: Always bond the negative terminal (
GND) of the motor battery packs to the GND pin of the Arduino and ESP32 microcontrollers. A floating ground reference prevents logic signals from triggering the L298N optocouplers and causes erratic motor flutter!Mathematical Principle: Ultrasonic Distance Calculation
The HC-SR04 ultrasonic sensor measures time of flight for a acoustic chirp. The speed of sound through dry air at room temperature () is approximately , or .
Because the sound wave travels out to the incoming car and bounces back to the receiver, the total distance is calculated by halving the round-trip flight duration:
Where:
- is the vehicle proximity distance in centimeters ().
- is the microsecond pulse duration returned by
pulseIn(ECHO_PIN, HIGH, 30000). - A 30 ms timeout ensures that if no obstacle is detected, the function returns without blocking the microcontroller loop.
Firmware 1: Arduino UNO Autonomous Safety & Gate Controller
Save and flash this code to your Arduino UNO R3/R4 using the Arduino IDE (smart_house_arduino.ino):
Arduino Source (.ino)ino
1// =====================================================
2// SMART HOUSE AUTONOMOUS SAFETY & MOTOR CONTROLLER
3// Hardware: Arduino UNO + 2x L298N + HC-SR04 + Sensors
4// Author: Ishan Shrestha (Yan Electronics)
5// =====================================================
6
7// ---------- Rain Sensor ----------
8#define RAIN_PIN 2
9
10// ---------- Gas Sensor + Buzzer ----------
11#define GAS_PIN A3
12#define BUZZER_PIN 4 // Buzzer + to 5V, - to D4 (Active LOW)
13
14// ---------- Ultrasonic ----------
15#define TRIG_PIN 6
16#define ECHO_PIN 11
17
18// ---------- L298N #1: Gate + Shutter ----------
19#define GATE_ENA 5
20#define GATE_IN1 7
21#define GATE_IN2 8
22
23#define SHUTTER_ENB 9
24#define SHUTTER_IN3 10
25#define SHUTTER_IN4 12
26
27// ---------- L298N #2: Rain Motor ----------
28#define RAIN_ENA 3
29#define RAIN_IN1 A0
30#define RAIN_IN2 A1
31
32// ---------- Speed Configuration (PWM 0-255) ----------
33int rainSpeed = 50;
34int gateSpeed = 160;
35int shutterSpeed = 100;
36
37// ---------- Timing (Milliseconds) ----------
38int rainMoveTime = 1500;
39int rainConfirmDelay = 2000;
40
41int detectDistance = 15; // Centimeters threshold
42int gateMoveTime = 1000;
43int shutterMoveTime = 3500;
44int stayOpenTime = 4000;
45
46bool rainClosed = false;
47
48// Forward declaration of smart delay
49void smartDelay(int ms);
50long getDistance();
51void checkGas();
52void checkRain();
53void checkGateAndShutter();
54void openGate();
55void closeGate();
56void stopGate();
57void openShutter();
58void closeShutter();
59void stopShutter();
60void rainForward();
61void rainBackward();
62void stopRainMotor();
63void stopAllMotors();
64
65void setup() {
66 Serial.begin(9600);
67
68 pinMode(RAIN_PIN, INPUT);
69 pinMode(GAS_PIN, INPUT);
70 pinMode(BUZZER_PIN, OUTPUT);
71
72 pinMode(TRIG_PIN, OUTPUT);
73 pinMode(ECHO_PIN, INPUT);
74
75 pinMode(GATE_ENA, OUTPUT);
76 pinMode(GATE_IN1, OUTPUT);
77 pinMode(GATE_IN2, OUTPUT);
78
79 pinMode(SHUTTER_ENB, OUTPUT);
80 pinMode(SHUTTER_IN3, OUTPUT);
81 pinMode(SHUTTER_IN4, OUTPUT);
82
83 pinMode(RAIN_ENA, OUTPUT);
84 pinMode(RAIN_IN1, OUTPUT);
85 pinMode(RAIN_IN2, OUTPUT);
86
87 digitalWrite(BUZZER_PIN, HIGH); // Buzzer OFF (Active LOW)
88
89 stopAllMotors();
90
91 Serial.println(F("Smart Home Autonomous System Started"));
92}
93
94void loop() {
95 checkGas();
96 checkRain();
97 checkGateAndShutter();
98
99 delay(300);
100}
101
102// ---------- GAS MONITORING & ALARM ----------
103void checkGas() {
104 int gas = digitalRead(GAS_PIN);
105
106 if (gas == LOW) {
107 Serial.println(F("ALERT: GAS DETECTED! Sounding Buzzer..."));
108 digitalWrite(BUZZER_PIN, LOW); // Buzzer ON
109 } else {
110 digitalWrite(BUZZER_PIN, HIGH); // Buzzer OFF
111 }
112}
113
114// ---------- AUTOMATED RETRACTABLE RAIN ROOF ----------
115void checkRain() {
116 int rain = digitalRead(RAIN_PIN);
117
118 if (rain == LOW && rainClosed == false) {
119 Serial.println(F("Rain sensor triggered. Awaiting confirmation delay..."));
120 smartDelay(rainConfirmDelay);
121
122 // Double check sensor after delay to prevent false positives
123 if (digitalRead(RAIN_PIN) == LOW) {
124 Serial.println(F("Confirmed rain event! Closing rain roof canopy..."));
125 rainForward();
126 smartDelay(rainMoveTime);
127 stopRainMotor();
128
129 rainClosed = true;
130 Serial.println(F("Rain roof locked in closed state."));
131 }
132 }
133 else if (rain == HIGH && rainClosed == true) {
134 Serial.println(F("Rain sensor cleared. Awaiting dry confirmation..."));
135 smartDelay(rainConfirmDelay);
136
137 if (digitalRead(RAIN_PIN) == HIGH) {
138 Serial.println(F("Confirmed dry weather! Retracting rain roof canopy..."));
139 rainBackward();
140 smartDelay(rainMoveTime);
141 stopRainMotor();
142
143 rainClosed = false;
144 Serial.println(F("Rain roof opened to ambient air."));
145 }
146 }
147}
148
149// ---------- VEHICLE DETECTION, GATE & GARAGE SHUTTER SEQUENCE ----------
150void checkGateAndShutter() {
151 long distance = getDistance();
152
153 if (distance > 0 && distance < detectDistance) {
154 Serial.print(F("Vehicle detected at "));
155 Serial.print(distance);
156 Serial.println(F(" cm. Initiating welcoming entry sequence..."));
157
158 // Step 1: Swing open the front perimeter gate
159 Serial.println(F("Opening main perimeter gate..."));
160 openGate();
161 smartDelay(gateMoveTime);
162 stopGate();
163
164 smartDelay(2000);
165
166 // Step 2: Roll up the garage roll-up shutter
167 Serial.println(F("Rolling up garage shutter..."));
168 openShutter();
169 smartDelay(shutterMoveTime);
170 stopShutter();
171
172 Serial.println(F("Gate and shutter open. Vehicle docking window active."));
173 smartDelay(stayOpenTime);
174
175 // Step 3: Lower garage shutter to secure vehicle
176 Serial.println(F("Lowering garage shutter..."));
177 closeShutter();
178 smartDelay(shutterMoveTime);
179 stopShutter();
180
181 smartDelay(1000);
182
183 // Step 4: Swing closed main perimeter gate
184 Serial.println(F("Closing main perimeter gate..."));
185 closeGate();
186 smartDelay(1000);
187 stopGate();
188
189 Serial.println(F("Gate and garage shutter fully secured."));
190 smartDelay(3000);
191 }
192}
193
194// ---------- HC-SR04 DISTANCE COMPUTATION ----------
195long getDistance() {
196 digitalWrite(TRIG_PIN, LOW);
197 delayMicroseconds(2);
198
199 digitalWrite(TRIG_PIN, HIGH);
200 delayMicroseconds(10);
201 digitalWrite(TRIG_PIN, LOW);
202
203 long duration = pulseIn(ECHO_PIN, HIGH, 30000); // 30ms timeout
204
205 if (duration == 0) return -1;
206
207 return duration * 0.034 / 2;
208}
209
210// ---------- L298N GATE ACTUATOR CONTROLS ----------
211void openGate() {
212 digitalWrite(GATE_IN1, HIGH);
213 digitalWrite(GATE_IN2, LOW);
214 analogWrite(GATE_ENA, gateSpeed);
215}
216
217void closeGate() {
218 digitalWrite(GATE_IN1, LOW);
219 digitalWrite(GATE_IN2, HIGH);
220 analogWrite(GATE_ENA, 180);
221}
222
223void stopGate() {
224 digitalWrite(GATE_IN1, LOW);
225 digitalWrite(GATE_IN2, LOW);
226 analogWrite(GATE_ENA, 0);
227}
228
229// ---------- L298N GARAGE SHUTTER ACTUATOR CONTROLS ----------
230void openShutter() {
231 digitalWrite(SHUTTER_IN3, HIGH);
232 digitalWrite(SHUTTER_IN4, LOW);
233 analogWrite(SHUTTER_ENB, shutterSpeed);
234}
235
236void closeShutter() {
237 digitalWrite(SHUTTER_IN3, LOW);
238 digitalWrite(SHUTTER_IN4, HIGH);
239 analogWrite(SHUTTER_ENB, shutterSpeed);
240}
241
242void stopShutter() {
243 digitalWrite(SHUTTER_IN3, LOW);
244 digitalWrite(SHUTTER_IN4, LOW);
245 analogWrite(SHUTTER_ENB, 0);
246}
247
248// ---------- L298N RETRACTABLE ROOF MOTOR CONTROLS ----------
249void rainForward() {
250 digitalWrite(RAIN_IN1, HIGH);
251 digitalWrite(RAIN_IN2, LOW);
252 analogWrite(RAIN_ENA, rainSpeed);
253}
254
255void rainBackward() {
256 digitalWrite(RAIN_IN1, LOW);
257 digitalWrite(RAIN_IN2, HIGH);
258 analogWrite(RAIN_ENA, rainSpeed);
259}
260
261void stopRainMotor() {
262 digitalWrite(RAIN_IN1, LOW);
263 digitalWrite(RAIN_IN2, LOW);
264 analogWrite(RAIN_ENA, 0);
265}
266
267void stopAllMotors() {
268 stopGate();
269 stopShutter();
270 stopRainMotor();
271}
272
273// Non-blocking smart delay that checks gas leak alarm continuously
274void smartDelay(int ms) {
275 unsigned long start = millis();
276
277 while (millis() - start < (unsigned long)ms) {
278 checkGas();
279 delay(200);
280 }
281}
Firmware 2: ESP32 Blynk IoT Cloud Firmware
Flash this code to your ESP32 DevKit board to connect your home lighting and twin ventilation fans to the Blynk IoT app (smart_house_esp32_blynk.ino):
Arduino Source (.ino)ino
1// =====================================================
2// SMART HOUSE ESP32 BLYNK IOT APPLIANCE CONTROLLER
3// Hardware: ESP32 NodeMCU + 5V Relay + L298N (Twin Fans)
4// Author: Ishan Shrestha (Yan Electronics)
5// =====================================================
6
7// Step 1: Paste your Template ID & Name from the Blynk Console
8#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
9#define BLYNK_TEMPLATE_NAME "Smart House IoT"
10#define BLYNK_AUTH_TOKEN "Your_Blynk_Auth_Token_Here"
11
12#define BLYNK_PRINT Serial
13#include <WiFi.h>
14#include <WiFiClient.h>
15#include <BlynkSimpleEsp32.h>
16
17// Step 2: Configure your 2.4 GHz WiFi credentials
18char ssid[] = "Your_WiFi_SSID";
19char pass[] = "Your_WiFi_PASSWORD";
20
21// ---------- Hardware GPIO Assignments ----------
22// 1-Channel Relay Module (Room Light - Active LOW)
23#define RELAY_LIGHT_PIN 23
24
25// L298N Driver for Twin Room Fans
26// Fan 1 (Living Room / Bedroom)
27#define FAN1_IN1 18
28#define FAN1_IN2 5
29#define FAN1_ENA 4
30
31// Fan 2 (Kitchen / Study Room)
32#define FAN2_IN3 16
33#define FAN2_IN4 17
34#define FAN2_ENB 2
35
36// ---------- Hardware PWM Configuration ----------
37const int pwmFreq = 1000; // 1 kHz frequency
38const int pwmResolution = 8; // 8-bit resolution (0 - 255)
39const int fan1PwmChannel = 0;
40const int fan2PwmChannel = 1;
41
42bool lightState = false;
43int fan1Speed = 0;
44int fan2Speed = 0;
45
46BlynkTimer timer;
47
48// Forward helper declarations
49void setFan1(int speed);
50void setFan2(int speed);
51
52// ---------- BLYNK VIRTUAL PIN LISTENERS ----------
53
54// Virtual Pin V1: Room Light Toggle Switch
55BLYNK_WRITE(V1) {
56 int value = param.asInt();
57 lightState = (value == 1);
58
59 // Active-LOW relay module: LOW = Energized (ON), HIGH = Cutoff (OFF)
60 digitalWrite(RELAY_LIGHT_PIN, lightState ? LOW : HIGH);
61
62 Serial.print(F("[Blynk] Room Light: "));
63 Serial.println(lightState ? F("ACTIVATED (ON)") : F("DEACTIVATED (OFF)"));
64}
65
66// Virtual Pin V2: Fan 1 Speed Slider (0 - 255)
67BLYNK_WRITE(V2) {
68 fan1Speed = param.asInt();
69 setFan1(fan1Speed);
70
71 Serial.print(F("[Blynk] Room Fan 1 Speed updated: "));
72 Serial.println(fan1Speed);
73}
74
75// Virtual Pin V3: Fan 2 Speed Slider (0 - 255)
76BLYNK_WRITE(V3) {
77 fan2Speed = param.asInt();
78 setFan2(fan2Speed);
79
80 Serial.print(F("[Blynk] Room Fan 2 Speed updated: "));
81 Serial.println(fan2Speed);
82}
83
84// Virtual Pin V4: Master "Leaving Home" / All OFF Emergency Switch
85BLYNK_WRITE(V4) {
86 int value = param.asInt();
87 if (value == 1) {
88 Serial.println(F("[Blynk] Master Cutoff Triggered: Shutting down all appliances..."));
89 lightState = false;
90 fan1Speed = 0;
91 fan2Speed = 0;
92
93 digitalWrite(RELAY_LIGHT_PIN, HIGH); // Turn light OFF
94 setFan1(0); // Stop Fan 1
95 setFan2(0); // Stop Fan 2
96
97 // Feedback state update back to Blynk mobile widgets
98 Blynk.virtualWrite(V1, 0);
99 Blynk.virtualWrite(V2, 0);
100 Blynk.virtualWrite(V3, 0);
101 Blynk.virtualWrite(V4, 0);
102 }
103}
104
105// ---------- MOTOR DRIVER HELPER ROUTINES ----------
106
107void setFan1(int speed) {
108 if (speed <= 0) {
109 digitalWrite(FAN1_IN1, LOW);
110 digitalWrite(FAN1_IN2, LOW);
111 ledcWrite(fan1PwmChannel, 0);
112 } else {
113 digitalWrite(FAN1_IN1, HIGH);
114 digitalWrite(FAN1_IN2, LOW);
115 ledcWrite(fan1PwmChannel, constrain(speed, 0, 255));
116 }
117}
118
119void setFan2(int speed) {
120 if (speed <= 0) {
121 digitalWrite(FAN2_IN3, LOW);
122 digitalWrite(FAN2_IN4, LOW);
123 ledcWrite(fan2PwmChannel, 0);
124 } else {
125 digitalWrite(FAN2_IN3, HIGH);
126 digitalWrite(FAN2_IN4, LOW);
127 ledcWrite(fan2PwmChannel, constrain(speed, 0, 255));
128 }
129}
130
131// Telemetry heartbeat function to report WiFi RSSI
132void reportTelemetry() {
133 if (Blynk.connected()) {
134 int rssi = WiFi.RSSI();
135 Blynk.virtualWrite(V5, rssi); // Send signal strength to V5
136 }
137}
138
139// ---------- SETUP ----------
140void setup() {
141 Serial.begin(115200);
142 delay(100);
143
144 Serial.println(F("
145=========================================="));
146 Serial.println(F(" SMART HOUSE ESP32 BLYNK IOT GATEWAY "));
147 Serial.println(F("=========================================="));
148
149 // 1. Initialize Relay Control Pin
150 pinMode(RELAY_LIGHT_PIN, OUTPUT);
151 digitalWrite(RELAY_LIGHT_PIN, HIGH); // Default OFF on boot
152
153 // 2. Initialize Fan Direction Control Pins
154 pinMode(FAN1_IN1, OUTPUT);
155 pinMode(FAN1_IN2, OUTPUT);
156 pinMode(FAN2_IN3, OUTPUT);
157 pinMode(FAN2_IN4, OUTPUT);
158
159 // 3. Configure ESP32 Hardware LEDC PWM Timers for Fans
160 ledcSetup(fan1PwmChannel, pwmFreq, pwmResolution);
161 ledcAttachPin(FAN1_ENA, fan1PwmChannel);
162
163 ledcSetup(fan2PwmChannel, pwmFreq, pwmResolution);
164 ledcAttachPin(FAN2_ENB, fan2PwmChannel);
165
166 setFan1(0);
167 setFan2(0);
168
169 // 4. Connect to Blynk IoT Cloud Platform
170 Serial.print(F("Connecting to WiFi: "));
171 Serial.println(ssid);
172 Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
173
174 // Schedule periodic RSSI heartbeat every 10 seconds
175 timer.setInterval(10000L, reportTelemetry);
176
177 Serial.println(F("ESP32 IoT Hub initialized successfully!"));
178}
179
180// ---------- MAIN LOOP ----------
181void loop() {
182 Blynk.run();
183 timer.run();
184}
Blynk IoT App Setup Guide
To control your lights and fans from your iOS or Android smartphone:
- Create Blynk 2.0 Template:
- Sign in at blynk.cloud and navigate to Templates → New Template.
- Set Hardware to
ESP32, Connection Type toWiFi.
- Configure Datastreams:
- V1 (Room Light): Data Type
Integer, Min0, Max1. - V2 (Fan 1 Speed): Data Type
Integer, Min0, Max255. - V3 (Fan 2 Speed): Data Type
Integer, Min0, Max255. - V4 (Master Cutoff): Data Type
Integer, Min0, Max1. - V5 (WiFi RSSI Signal): Data Type
Integer, UnitdBm.
- Build the Mobile Dashboard:
- Open the Blynk IoT app on your phone.
- Add a Button Widget bound to
V1(Mode: Switch) for the Main Room Light. - Add two Slider Widgets bound to
V2andV3(Range: 0ā255) for Fans 1 and 2. - Add a Push Button Widget bound to
V4for the Master "Leaving Home" shutoff.
Testing & Calibration Checklist
- [ ] Gas Sensor Warmup: MQ-2 gas sensors need approximately 30ā60 seconds of heater preheat time before their analog readings stabilize.
- [ ] Common Ground Check: Ensure the black GND wires from both battery holders, the Arduino UNO, and the ESP32 are all joined into a common GND rail on the breadboard.
- [ ] Ultrasonic Sightline: Mount the HC-SR04 sensor angled directly towards the driveway without reflecting off side walls to prevent premature gate triggering.
- [ ] Relay Polarity: If the light turns ON when Blynk displays OFF, flip the logic state in
BLYNK_WRITE(V1)to match your relay module's trigger polarity.
