Electronics Projects

This video presents the end-to-end development of an electronic speed controller for a DC motor, using the KiCad EDA suite. It covers project setup, schematic capture, PCB layout (including copper zones), and 3D rendering to verify component placement.

• KiCad Project Setup: Creation of the “Variateur de Vitesse” project, organizing schematic and PCB files within KiCad’s project manager.
• Schematic Design: Integration of an ATmega328P microcontroller (with 16 MHz crystal and bypass capacitors), a 7805 voltage regulator, MOSFET H-bridge drivers (IRF540N) for PWM motor control, push-button inputs (Reset, Speed Up, Speed Down), and LED indicators for speed levels.
• PCB Layout: Component placement and routing in KiCad’s PCB editor, defining appropriate trace widths, via sizes, and clearances to handle motor currents and control signals.
• Copper Zone Configuration: Definition of GND and VCC copper pours with thermal reliefs, 0.5 mm clearance, hatched fill style, and a 10 mm² minimum island removal.
• 3D Visualization: Use of KiCad’s 3D viewer to render the assembled board, verify mechanical clearances, and inspect component alignment before fabrication.

This project demonstrates proficiency in electronic CAD design using KiCad, from schematic capture and PCB layout to copper zone management and 3D verification, culminating in a functional DC motor speed controller prototype.

This project demonstrates the design and Proteus-based simulation of a secure door access control system using an Arduino UNO. Users enter a 4-digit PIN on a matrix keypad, with prompts and feedback displayed on a 4×20 LCD. LED indicators and a buzzer provide real-time status, while a servo‐driven latch (on D9) locks or unlocks the door according to the authentication result and a configurable time limit.

• Schematic Capture: Complete front-panel and circuit diagram in Proteus 8, including custom enclosure outline, 4×3 keypad, LM044L LCD, LEDs, buzzer, and Simulino UNO SMD component.
• Firmware Integration: Compilation and loading of the Arduino .hex firmware via the Proteus component editor, handling keypad scanning, code validation, timing constraints, and control logic.
• User Interface: LCD prompts (“ENTER CODE TO OPEN!”, countdown messages, success/error notifications), visual LED cues (green for granted, red for denied), and audible alerts using a virtual buzzer.
• Security Logic: 4-digit PIN entry with masked display (“****”), incorrect-code rejection with retry timer, and automatic lock-out when time expires.
• Actuator Control: Servo (or DC-motor latch) driven from digital pin 9 to physically simulate door unlocking on correct code, and re-locking on timeout or incorrect attempts.
• Simulation & Animation: Interactive Proteus animation showing real-time key presses, LCD updates, LED/buzzer responses, and servo movement, enabling full verification before hardware implementation.

This project highlights end-to-end PCB-level design and embedded firmware validation in a virtual environment, providing a robust prototype for secure access applications.

This project enables remote control and monitoring of a water reservoir using an Arduino board, an HC-05 Bluetooth module, and a Qt-based desktop interface. A water pump is managed based on ultrasonic distance measurements and Bluetooth commands, providing real-time supervision of the filling process.

• Hardware & Firmware (Arduino): • HC-SR04 ultrasonic sensor connected to pins 9 (TRIG) and 10 (ECHO). • Pump controlled via L298N driver (IN1: D4, IN2: D5, ENA: D3). • Pump starts only if Bluetooth authorization is active and the tank level is below 4 cm. • Serial messages sent include fill percentage and motor state.
• Desktop Application (Qt/C++): • UI designed with Qt Designer (.ui file). • Serial communication over Bluetooth COM port using QSerialPort. • Buttons for manual pump activation/deactivation and progress bar indicating fill level (%). • Label shows motor status based on real-time Arduino feedback.
• Bluetooth Integration: • HC-05 paired with PC and exposed as a virtual serial port. • User selects the COM port and connects via a button. • One-way control and two-way feedback for status and safety.
• Smart Control Logic: • Manual activation is overridden if the reservoir is already considered full (≤ 4 cm). • Fill percentage dynamically calculated from configurable empty/full distances. • Pump stops automatically when target level is reached.

This project demonstrates effective integration of Bluetooth communication, embedded sensor control, and real-time UI visualization using Qt. It offers a practical framework for intelligent water or liquid tank management systems.

This project, developed as part of an embedded systems assignment, implements a complete end-to-end solution for monitoring temperature and humidity in real time. It combines an Arduino-based DHT11 sensor module with a custom Qt application that visualizes sensor data over a sliding 60-second window.

• Sensor & Firmware (Arduino): • DHT11 sensor connected to digital pin 2. • Non-blocking read every 2 s using millis(). • Data formatted as “T:<temp>;H:<hum>” and sent via Serial @ 9600 baud.
• Desktop Application (Qt/C++): • UI designed with Qt Designer (.ui file). • Serial communication on COM5 via QSerialPort. • Parsing of “T:xx.x;H:yy.y” messages and updating of QLabel widgets.
• Data Visualization (QtCharts): • Real-time line chart plotting temperature (°C) and humidity (%) series. • Sliding time window (last 60 s) on the X-axis, auto-updating every second. • Customizable axes, legend, and antialiasing for clear presentation.
• Modular Design & Simulation: • Separation of concerns: sensor firmware versus GUI logic. • Easily extensible to additional sensors or alternative charting libraries. • Simulated running of the Qt app even without hardware, using dummy serial data.

This project showcases proficiency in embedded C++, desktop GUI development with Qt, serial data handling, and real-time data visualization—key skills for modern IoT and monitoring applications.

This video demonstrates the design and Proteus 8 simulation of a four-way traffic light intersection controlled by an Arduino UNO (Simulino UNO SMD). The system sequences red, yellow and green signals on each approach, coordinating traffic flow with precise timing and safety intervals while animating vehicle graphics to illustrate real-time operation.

• Embedded Controller Module: Simulino UNO SMD configured in Proteus, driving three digital outputs per arm (Red, Yellow, Green) to virtual LEDs via digitalWrite() and delay() routines.
• Intersection Topology: Four-arm road layout drawn in yellow on the Proteus grid, with static car silhouettes placed on each approach to visualize traffic halting and movement.
• State Machine Logic: Arduino firmware implementing a finite-state machine for timed phases (green → yellow → red), inter-green “all-red” clearance delays, and cyclical rotation through each direction.
• Proteus Animation & Visualization: Real-time LED color changes, logic probes, and custom device symbols animate the traffic signals; digital indicators show active pins and timing progression.
• Safety Timing: Inclusion of configurable amber durations and all-red intervals to ensure conflict-free transitions, illustrating proper traffic engineering practices.

This project highlights end-to-end virtual prototyping of traffic control algorithms, from embedded code development to interactive EDA simulation, facilitating thorough validation of timing, sequencing, and safety before moving to physical hardware.

This project demonstrates a virtual prototype of an automatic heating control system in Proteus 8. An LM35 temperature sensor measures interior temperature, an Arduino UNO (Simulino UNO SMD) processes the reading and drives a transistor–relay stage to switch a heating element—maintaining the room at a 28 °C setpoint even under simulated snowfall conditions.

• Sensor & Data Acquisition: • LM35 analog temperature sensor wired to A0. • analogRead() and linear conversion to °C every second.
• Control Logic: • Arduino C++ firmware compares measured temperature against a 28 °C threshold. • Uses digitalWrite(13, HIGH/LOW) to toggle heating.
• Power & Actuation: • BC547 transistor driver with 120 Ω base resistor (R1). • 1N4148 flyback diode (D2) across a 5 V relay coil (RL1) to switch the heating load (simulated alternator symbol).
• User Interface: • 20×4 LCD (LM044L) connected to digital pins for print() of “Temp: XX.X °C” and “CHAUFFAGE ACTIF/ETEINT” messages.
• Proteus Animation: • Custom house outline with falling “snow” graphics. • Real-time indicator of sensor voltage, LCD updates, and relay switching, validating system response to temperature changes.

This project highlights full virtual validation of an embedded temperature control system—from analog sensing and control algorithm to relay-driven actuation and human-readable feedback—before hardware implementation.

This project implements a virtual prototype of an intelligent reservoir management system in Proteus 8. Four float‐level sensors detect water at 10%, 35%, 65% and 100% heights; an Arduino UNO reads these inputs and drives a 12 V pump via transistor–relay stages to maintain safe operating levels. Real‐time status messages and alerts are displayed on a 20×4 LCD and sounded by a buzzer.

• Level Sensing & Inputs: • Four digital float sensors wired to analog pins A0–A3 via a “Reservoir_Automatique” subcircuit. • Each switch closes when water reaches its threshold.
• Control Logic & Firmware: • Arduino C++ firmware polls sensor states, classifies levels as “EMPTY”, “LOW”, “STABLE” or “FULL”. • Implements hysteresis to prevent pump chattering and error detection for sensor faults.
• Actuation & Protection: • NPN transistor (2N5551) with 1 kΩ base resistor drives a 12 V pump via a relay (RL1) with flyback diode (1N4001). • Automatic shutoff when tank is full or on sensor error.
• User Feedback: • 20×4 LCD (LM044L) shows “NIVEAU DU RESERVOIR”, percentage, pump status or error messages. • Piezo buzzer (LS1) sounds on critical low‐level or sensor failure.
• Proteus Simulation & Animation: • Simulated pump motor and relay coil animate in real time. • Level switches toggle graphically to demonstrate refill cycles and error scenarios.

This project demonstrates end-to-end virtual prototyping of an automated fluid management system, covering sensor integration, control algorithm, actuator drive, and human-machine interface validation before hardware deployment.

This project implements a real‐time parking assistance system: an HC‐SR04 ultrasonic sensor measures the distance to obstacles behind the vehicle, and an Arduino UNO processes these measurements to provide visual, audible, and text feedback. A tricolor LED bar and buzzer signal safe, caution, or stop zones, while a 20×4 character LCD displays the exact distance and guidance messages. A potentiometer allows threshold calibration for different vehicle sizes.

• Ultrasonic Sensing & Measurement: • HC‐SR04 sensor connected to digital pins 8 (TRIG) and 9 (ECHO). • Uses pulseIn() to capture echo time and compute distance in centimeters.
• LCD Interface & Calibration: • 20×4 character LCD (LM044L) in 4‐bit mode on digital pins 4–11. • Contrast trim pot (RV1) and distance‐threshold pot (RV2) for fine‐tuning display visibility and alert thresholds.
• LED Status Indicators: • Three LEDs (green, yellow, red) on digital pins 5, 6, 7 indicate “Safe” (>100 cm), “Caution” (50–100 cm), and “Stop” (<50 cm) zones respectively.
• Audible Alert: • Piezo buzzer (LS1) on digital pin 3 emits intermittent beeps in the caution zone and a continuous tone in the danger zone.
• Proteus Virtual Prototyping: • Complete schematic simulated in Proteus 8 Professional, animating sensor pings, LED transitions, buzzer output, and dynamic LCD messages to validate behavior before hardware deployment.

This project demonstrates end-to-end embedded system integration—covering sensor interfacing, analog/digital I/O, threshold calibration, real-time decision logic, and human-machine interface design—ideal for automotive safety and assistance applications.

This project enables wireless control of an LED connected to an Arduino board using a HC-05 Bluetooth module and a Qt-based desktop application. The system demonstrates seamless communication between embedded hardware and desktop software using the serial port over Bluetooth.

• Hardware & Firmware (Arduino): • HC-05 module wired to the Arduino’s hardware serial (pin 0 & 1). • LED connected to digital pin 7. • Arduino listens for single-character commands ('1' to turn on, '0' to turn off) via Serial @ 9600 baud.
• Desktop Application (Qt/C++): • GUI built with Qt Designer (.ui file). • Uses QSerialPort to communicate over Bluetooth COM port. • UI includes COM port selection and two buttons to control the LED state.
• Bluetooth Integration: • HC-05 configured for pairing with the PC and exposed as a virtual serial port. • Qt application detects and connects to this port for sending control signals. • Real-time feedback and connection status displayed in the GUI.
• Modular & Extensible Design: • Clear separation between communication logic and UI components. • Easy to extend for bidirectional communication (e.g., feedback from sensors). • Portable and suitable for integration into larger embedded control systems.

This project highlights wireless communication between Qt and Arduino, mastery of QSerialPort usage, and practical embedded control using Bluetooth—valuable skills for developing interactive IoT applications.