Embedded, IoT, PLC & PCB Courses in Salem

Hardware: Embedded product examples, development boards and block diagrams.

Software: Embedded system characteristics, applications and the development life cycle.

Practical: Identify the input, controller, output and power blocks of common products.

Duration: 2 Hours

Hardware: PPE, breadboard, bench supply, multimeter and insulated tools.

Software: Safe voltage/current limits, polarity, grounding and ESD precautions.

Practical: Perform safe continuity, voltage and resistance measurements.

Duration: 2 Hours

Hardware: Resistors, LEDs, DC source and multimeter.

Software: Ohm's law, Kirchhoff basics, series/parallel circuits and power calculations.

Practical: Build and verify series and parallel resistor circuits.

Duration: 2 Hours

Hardware: Resistors, capacitors, diodes, LEDs, switches and connectors.

Software: Ratings, tolerance, polarity, package identification and datasheet reading.

Practical: Identify components and select correct values from datasheets.

Duration: 2 Hours

Hardware: Potentiometer, switches, LEDs and signal source.

Software: Logic levels, noise margin, analog range, sampling and signal conditioning basics.

Practical: Observe and compare analog and digital signals using a meter or oscilloscope.

Duration: 2 Hours

Hardware: Breadboard, jumper wires, resistors, LEDs and switches.

Software: Breadboard internal connections, schematic reading and neat wiring practice.

Practical: Convert a simple schematic into a working breadboard circuit.

Duration: 2 Hours

Hardware: 7805, AMS1117, buck converter, capacitors and DC adapter.

Software: Linear and switching regulation, dropout, ripple, heat and protection.

Practical: Build and test regulated 5 V and 3.3 V supplies.

Duration: 2 Hours

Hardware: BC547, logic-level MOSFET, diode, motor and lamp.

Software: Biasing, switching regions, gate/base resistors and flyback protection.

Practical: Drive a higher-current load from a logic-level input.

Duration: 2 Hours

Hardware: Relay module, optocoupler, transistor driver and isolated load.

Software: NO/NC contacts, galvanic isolation and safe interface design.

Practical: Control a relay through an optocoupler and verify isolation.

Duration: 2 Hours

Hardware: Soldering station, flux, desoldering tools and sample PCB.

Software: Good solder joints, continuity tracing, short detection and fault isolation.

Practical: Solder a small circuit and diagnose intentional faults.

Duration: 2 Hours

Hardware: Computer and sample embedded problem statements.

Software: Algorithm design, flowcharts, pseudocode and state-based thinking.

Practical: Create algorithms for traffic light and tank-level control.

Duration: 2 Hours

Hardware: Computer with C compiler or microcontroller IDE.

Software: Headers, main function, statements, comments, compilation and linking.

Practical: Write, compile and test a structured C program.

Duration: 2 Hours

Hardware: Compiler/IDE and serial console.

Software: Integer, character, floating point, signedness, range and const usage.

Practical: Select suitable data types for sensor and timer values.

Duration: 2 Hours

Hardware: IDE and binary-value exercises.

Software: Arithmetic, relational, logical, shift, mask, set, clear and toggle operations.

Practical: Manipulate individual bits in an 8-bit register.

Duration: 2 Hours

Hardware: IDE and simulated input values.

Software: if, else-if, nested conditions and switch-case design.

Practical: Create low, normal and high range decisions.

Duration: 2 Hours

Hardware: IDE and output console.

Software: for, while, do-while, loop control and finite repetitions.

Practical: Generate LED and numeric patterns using loops.

Duration: 2 Hours

Hardware: IDE and serial console.

Software: One-dimensional arrays, character arrays, indexing and string functions.

Practical: Store, search and display multiple sensor samples.

Duration: 2 Hours

Hardware: IDE and reusable code exercises.

Software: Function declaration, arguments, return values, local/global scope and recursion limits.

Practical: Create reusable functions for conversion and output control.

Duration: 2 Hours

Hardware: IDE and structured-data examples.

Software: Addresses, pointers, structures, unions, typedef and enum-based states.

Practical: Model a sensor record and machine state using structures and enums.

Duration: 2 Hours

Hardware: IDE, serial terminal and sample multi-file project.

Software: Header/source separation, error handling, logging and coding standards.

Practical: Split an application into drivers, logic and main program files.

Duration: 2 Hours

Hardware: Arduino UNO board and ATmega328P pin map.

Software: CPU, memory, clock, GPIO, peripherals and bootloader overview.

Practical: Identify board sections and map Arduino pins to MCU ports.

Duration: 2 Hours

Hardware: Arduino UNO, USB cable, LED and resistor.

Software: Board/port selection, setup(), loop(), pinMode() and digitalWrite().

Practical: Program LED blinking and a traffic-light sequence.

Duration: 2 Hours

Hardware: Push buttons, switches, LEDs and Arduino UNO.

Software: digitalRead(), internal pull-up, active-low logic and software debounce.

Practical: Build push-button toggle and long-press control.

Duration: 2 Hours

Hardware: Potentiometer, Arduino UNO and multimeter.

Software: 10-bit ADC, reference voltage, sampling and analogRead().

Practical: Read, scale and display potentiometer voltage.

Duration: 2 Hours

Hardware: PWM LED circuit and Arduino UNO.

Software: Duty cycle, frequency, analogWrite() and value mapping.

Practical: Create a smooth LED dimmer controlled by a potentiometer.

Duration: 2 Hours

Hardware: Arduino UNO, multiple LEDs and buttons.

Software: Blocking versus non-blocking timing, elapsed-time checks and task scheduling.

Practical: Run multiple LED and button tasks without delay().

Duration: 2 Hours

Hardware: Arduino UNO, push button or pulse sensor.

Software: Interrupt pins, ISR rules, volatile variables and edge selection.

Practical: Count pulses reliably using an external interrupt.

Duration: 2 Hours

Hardware: Arduino UNO and push buttons.

Software: EEPROM read/write/update, address planning and write-cycle limitations.

Practical: Store and restore a user-set threshold after power reset.

Duration: 2 Hours

Hardware: Arduino UNO, USB serial and optional UART converter.

Software: Baud rate, framing, Serial functions, parsing and debugging messages.

Practical: Build a serial command menu to control outputs.

Duration: 2 Hours

Hardware: Arduino UNO and I2C device/module.

Software: SDA/SCL, addressing, pull-ups, master/slave operation and Wire library.

Practical: Scan the I2C bus and exchange data with a peripheral.

Duration: 2 Hours

Hardware: Arduino UNO and SPI peripheral.

Software: MOSI, MISO, SCK, chip select, modes and transaction basics.

Practical: Read or write data using an SPI device.

Duration: 2 Hours

Hardware: 16x2 LCD, potentiometer and Arduino UNO.

Software: LCD commands, initialization, cursor control and LiquidCrystal library.

Practical: Display text, counters and live values on the LCD.

Duration: 2 Hours

Hardware: 16x2 I2C LCD and Arduino UNO.

Software: I2C address, backpack mapping and formatted display updates.

Practical: Create a two-line live sensor dashboard.

Duration: 2 Hours

Hardware: 4x4 matrix keypad and Arduino UNO.

Software: Row/column scanning, key mapping, debounce and password logic.

Practical: Build a four-digit password entry system.

Duration: 2 Hours

Hardware: DS3231 RTC, backup cell and Arduino UNO.

Software: BCD/time representation, RTC library, alarms and date formatting.

Practical: Create a clock and scheduled relay controller.

Duration: 2 Hours

Hardware: LM35, Arduino UNO and LCD.

Software: Voltage-to-temperature conversion, calibration and averaging.

Practical: Measure and display temperature with high-temperature alarm.

Duration: 2 Hours

Hardware: LDR divider, IR obstacle sensor and Arduino UNO.

Software: Threshold selection, calibration and digital/analog sensor behavior.

Practical: Build automatic lighting and object-detection exercises.

Duration: 2 Hours

Hardware: HC-SR04 and Arduino UNO.

Software: Trigger/echo timing, sound-speed calculation and filtering.

Practical: Measure distance and create a parking alert.

Duration: 2 Hours

Hardware: DHT11/DHT22 and Arduino UNO.

Software: Digital sensor timing, library use, validation and heat-index basics.

Practical: Display temperature and humidity with limit indication.

Duration: 2 Hours

Hardware: MPU6050 module and Arduino UNO.

Software: Accelerometer, gyroscope, I2C registers, offsets and angle estimation.

Practical: Read motion values and detect tilt/orientation.

Duration: 2 Hours

Hardware: ACS712, voltage-divider module and controlled DC load.

Software: Sensor offset, scaling, RMS/basic averaging and calibration.

Practical: Measure load voltage/current and calculate power.

Duration: 2 Hours

Hardware: Servo motor, suitable supply and Arduino UNO.

Software: PWM pulse positioning, angle limits and power considerations.

Practical: Control servo position using potentiometer and keypad.

Duration: 2 Hours

Hardware: DC motor, L293D/L298N driver and Arduino UNO.

Software: H-bridge operation, direction control, PWM speed and back-EMF protection.

Practical: Implement forward, reverse, stop and variable-speed control.

Duration: 2 Hours

Hardware: Stepper motor, ULN2003/A4988 driver and Arduino UNO.

Software: Step sequence, step angle, speed, direction and acceleration basics.

Practical: Move a stepper to selected positions.

Duration: 2 Hours

Hardware: Relay module, lamp/demo load and Arduino UNO.

Software: Active-high/low relays, interlocking and fail-safe output states.

Practical: Create timed and sensor-based appliance control.

Duration: 2 Hours

Hardware: Active/passive buzzer and Arduino UNO.

Software: Tone frequency, duration, alert patterns and non-blocking beeps.

Practical: Generate status, warning and alarm sound patterns.

Duration: 2 Hours

Hardware: Single/multiplexed seven-segment display and driver resistors.

Software: Segment encoding, common anode/cathode and multiplexing.

Practical: Display digits and build a two-digit counter.

Duration: 2 Hours

Hardware: 0.96-inch I2C OLED and Arduino UNO.

Software: Pixel coordinates, fonts, icons, buffers and display refresh.

Practical: Create a compact graphical sensor screen.

Duration: 2 Hours

Hardware: MicroSD module, SD card and Arduino UNO.

Software: FAT file operations, chip select, CSV logging and safe file handling.

Practical: Log time-stamped sensor readings to a CSV file.

Duration: 2 Hours

Hardware: SIM800L, regulated supply, GPS module and UART interface.

Software: AT commands, SMS, network registration, NMEA data and coordinate parsing.

Practical: Send sensor status by SMS and display GPS location data.

Duration: 2 Hours

Hardware: PIC16F877A trainer board, pin diagram and crystal circuit.

Software: Harvard architecture, memory, ports, configuration bits and reset circuit.

Practical: Identify pins and prepare the minimum controller circuit.

Duration: 2 Hours

Hardware: PICkit programmer, PIC board and computer.

Software: Project creation, device selection, compiler settings and HEX programming.

Practical: Compile and program a first PIC LED application.

Duration: 2 Hours

Hardware: PIC16F877A, LEDs and push buttons.

Software: PORT/TRIS configuration, digital input/output and active-low design.

Practical: Program LED patterns and button-controlled outputs.

Duration: 2 Hours

Hardware: PIC16F877A trainer and LED bank.

Software: Register access, bit masks, macros and direct port manipulation.

Practical: Set, clear, toggle and test individual port bits.

Duration: 2 Hours

Hardware: PIC16F877A, LM35 and potentiometer.

Software: ADC channels, reference, acquisition time and CCS ADC functions.

Practical: Read LM35 temperature and verify ADC conversion.

Duration: 2 Hours

Hardware: PIC16F877A and 16x2 LCD.

Software: LCD 8-bit/4-bit interface, driver configuration and formatting.

Practical: Display messages, ADC values and temperature.

Duration: 2 Hours

Hardware: PIC16F877A and pulse/button source.

Software: Timer0/Timer1 prescalers, overflow, counter mode and timing calculations.

Practical: Generate periodic timing and count external pulses.

Duration: 2 Hours

Hardware: PIC16F877A, push button and timer source.

Software: Interrupt flags, enables, ISR structure and priority considerations.

Practical: Handle external and timer interrupts safely.

Duration: 2 Hours

Hardware: PIC16F877A, keypad/buttons and LCD.

Software: Internal EEPROM addressing, read/write and data validation.

Practical: Save and restore settings with a simple checksum.

Duration: 2 Hours

Hardware: PIC16F877A, UART converter and serial peripherals.

Software: CCS communication directives, master operation and protocol debugging.

Practical: Transmit serial data and interface one I2C/SPI device.

Duration: 2 Hours

Hardware: STM32F103C8T6 Blue Pill and reference pinout.

Software: ARM Cortex-M3 core, clocks, memory, GPIO and peripheral overview.

Practical: Identify board resources and map pins for a project.

Duration: 2 Hours

Hardware: Blue Pill, ST-LINK V2 and computer.

Software: CubeMX configuration, HAL project generation, build, flash and debug.

Practical: Create and program an STM32 LED blink project.

Duration: 2 Hours

Hardware: STM32 board, LEDs and resistors.

Software: GPIO modes, speed, output type and HAL GPIO functions.

Practical: Generate LED patterns using configured GPIO outputs.

Duration: 2 Hours

Hardware: STM32 board, push buttons and LEDs.

Software: Pull-up/pull-down, input reading, debounce and state-change detection.

Practical: Build a button toggle and mode selector.

Duration: 2 Hours

Hardware: Potentiometer/sensor and STM32 board.

Software: ADC resolution, channels, sampling time, calibration and DMA transfer.

Practical: Continuously sample and average an analog signal.

Duration: 2 Hours

Hardware: STM32 timer channel, LED or motor driver.

Software: Timer clock, prescaler, period, compare value and PWM configuration.

Practical: Control brightness or motor speed with PWM.

Duration: 2 Hours

Hardware: STM32 board and output indicators.

Software: Basic/general-purpose timers, overflow interrupts and input timing.

Practical: Generate precise periodic events without blocking.

Duration: 2 Hours

Hardware: STM32 board and external push button/sensor.

Software: EXTI lines, edge selection, priorities and interrupt callbacks.

Practical: Count events and respond to an emergency input.

Duration: 2 Hours

Hardware: STM32 board and CP2102 UART converter.

Software: UART configuration, polling, interrupt/DMA reception and parsing.

Practical: Create a serial command interface for STM32.

Duration: 2 Hours

Hardware: STM32 board and I2C sensor/LCD.

Software: HAL I2C addressing, transmit/receive, register access and error handling.

Practical: Read an I2C sensor and show values on a display.

Duration: 2 Hours

Hardware: STM32 board and SPI display/SD module.

Software: SPI modes, chip select, full-duplex transfer and timing.

Practical: Communicate with an SPI peripheral and verify data.

Duration: 2 Hours

Hardware: STM32 board, RTC source and current meter.

Software: RTC calendar, backup domain, sleep, stop, standby and wake-up sources.

Practical: Build a time-based low-power data logger.

Duration: 2 Hours

Hardware: NodeMCU ESP8266, USB cable, LED and sensor.

Software: Board installation, GPIO limitations, boot pins and serial upload.

Practical: Read a sensor and control an output on NodeMCU.

Duration: 2 Hours

Hardware: ESP32 development board and pinout.

Software: Dual-core MCU, ADC, DAC, touch, PWM, Bluetooth and GPIO restrictions.

Practical: Test ESP32 GPIO, ADC and touch input.

Duration: 2 Hours

Hardware: ESP8266/ESP32 and Wi-Fi router.

Software: Station, access point, credentials, IP addressing and reconnection handling.

Practical: Connect to Wi-Fi and display network status.

Duration: 2 Hours

Hardware: ESP8266/ESP32, relay/LED and local Wi-Fi.

Software: HTTP requests, routes, HTML response and responsive control pages.

Practical: Build a mobile-friendly local web control panel.

Duration: 2 Hours

Hardware: ESP board, sensor and internet/local API.

Software: GET/POST, status codes, JSON serialization and secure request basics.

Practical: Send sensor data to an API and parse its response.

Duration: 2 Hours

Hardware: ESP8266/ESP32 and MQTT broker.

Software: Publish/subscribe, topics, QoS, retained messages and reconnect logic.

Practical: Control an output and publish live sensor values through MQTT.

Duration: 2 Hours

Hardware: ESP board, sensors and cloud account.

Software: Authentication basics, database paths, reads/writes and timestamps.

Practical: Upload sensor data and read a remote command.

Duration: 2 Hours

Hardware: ESP board, multiple sensors and relay.

Software: Dashboard widgets, live values, device state and command synchronization.

Practical: Create a complete monitoring and control dashboard.

Duration: 2 Hours

Hardware: ESP8266/ESP32 and Wi-Fi network.

Software: OTA workflow, firmware versioning, validation and safe rollback concepts.

Practical: Update device firmware over Wi-Fi.

Duration: 2 Hours

Hardware: Two or more ESP32/ESP8266 boards.

Software: Peer addressing, packets, callbacks, range and Wi-Fi coexistence.

Practical: Exchange sensor and command data without a router.

Duration: 2 Hours

Hardware: ESP32 or STM32 development board.

Software: Tasks, scheduler, priorities, delays and real-time design principles.

Practical: Run sensor, display and communication as separate tasks.

Duration: 2 Hours

Hardware: RTOS-capable board with sensor and output.

Software: Queues, semaphores, mutexes, events and shared-resource protection.

Practical: Transfer sensor data safely between concurrent tasks.

Duration: 2 Hours

Hardware: Microcontroller board, current meter and fault-test setup.

Software: Watchdog timers, brownout, reset cause, sleep strategies and recovery states.

Practical: Recover from a simulated software hang and measure sleep current.

Duration: 2 Hours

Hardware: Circuit schematic, component datasheets and PCB software.

Software: Schematic capture, footprints, routing, design rules and Gerber outputs.

Practical: Design a small microcontroller sensor/relay PCB.

Duration: 2 Hours

Hardware: Decoupling capacitors, filters, TVS/fuse examples and PCB layouts.

Software: Grounding, decoupling, noise paths, reverse polarity, surge and ESD protection.

Practical: Review and improve an embedded board power/protection design.

Duration: 2 Hours

Hardware: Multimeter, oscilloscope/logic analyzer, debugger and test firmware.

Software: Test plans, boundary cases, serial logs, breakpoints and protocol analysis.

Practical: Diagnose hardware, firmware and communication faults systematically.

Duration: 2 Hours

Hardware: Selected controller, sensors, display, actuator and power supply.

Software: Requirement breakdown, architecture, modular firmware and version control basics.

Practical: Build and demonstrate a working embedded mini project.

Duration: 2 Hours

Hardware: Complete prototype, enclosure/PCB option and test checklist.

Software: Validation, code cleanup, user manual, BOM, report and presentation structure.

Practical: Complete, test, document and present an industry-style embedded project.

Duration: 2 Hours

Hardware: IoT architecture, sensors, controllers, communication networks and cloud blocks.

Software: IoT terminology, device-to-cloud data flow and common application models.

Practical: Identify the blocks of a smart home, agriculture and industrial IoT system.

Duration: 2 Hours

Hardware: Voltage, current, resistance, breadboard, resistor, LED and safe power connections.

Software: Ohm’s law calculations and selecting component values for controller pins.

Practical: Build and test an LED circuit using a breadboard and multimeter.

Duration: 2 Hours

Hardware: NodeMCU board, ESP8266 chip, GPIO, ADC, power pins and boot-sensitive pins.

Software: Board pin mapping, logic levels and choosing safe GPIO pins.

Practical: Identify D0–D8 pins and verify 3.3 V supply and GPIO output.

Duration: 2 Hours

Hardware: USB cable, driver and NodeMCU development board.

Software: Install Arduino IDE, ESP8266 board package, libraries and select COM port.

Practical: Upload the Blink program and verify Serial Monitor output.

Duration: 2 Hours

Hardware: LED, resistor and NodeMCU digital output connection.

Software: pinMode(), digitalWrite(), delay() and active-HIGH/active-LOW logic.

Practical: Control the built-in LED and an external LED.

Duration: 2 Hours

Hardware: Push button, pull-up/pull-down resistor and GPIO input wiring.

Software: digitalRead(), INPUT_PULLUP, debouncing and state detection.

Practical: Create press-to-ON and toggle LED switch programs.

Duration: 2 Hours

Hardware: Potentiometer, LDR divider and ESP8266 A0 input range.

Software: analogRead(), ADC scaling, map() and voltage conversion.

Practical: Read a potentiometer and display percentage and voltage.

Duration: 2 Hours

Hardware: LED, buzzer and PWM-capable GPIO connection.

Software: analogWrite(), PWM range, frequency and duty-cycle control.

Practical: Build an LED dimmer and variable buzzer output.

Duration: 2 Hours

Hardware: USB serial interface and optional UART device connection.

Software: Serial.begin(), print formatting, baud rate and debugging methods.

Practical: Print sensor values and diagnose wiring/program errors.

Duration: 2 Hours

Hardware: LED and button test circuit.

Software: User functions, millis(), state machines and avoiding long delays.

Practical: Run two timed outputs independently without delay().

Duration: 2 Hours

Hardware: DHT11/DHT22 sensor and pull-up connection.

Software: DHT library, error checking and formatted temperature/humidity values.

Practical: Display live room temperature and humidity in Serial Monitor.

Duration: 2 Hours

Hardware: LDR, resistor divider and optional BH1750 light sensor.

Software: ADC conversion, threshold setting and lux reading basics.

Practical: Create automatic lamp control based on ambient light.

Duration: 2 Hours

Hardware: HC-SR04 sensor, voltage divider for Echo and NodeMCU pins.

Software: Trigger pulse generation, pulseIn(), distance calculation and filtering.

Practical: Measure tank level or object distance with alarm limits.

Duration: 2 Hours

Hardware: PIR motion sensor and IR obstacle sensor modules.

Software: Digital event detection, hold time and false-trigger reduction.

Practical: Create motion detection with LED and buzzer indication.

Duration: 2 Hours

Hardware: MQ-series sensor module, safe supply and analog output interface.

Software: Warm-up time, threshold calibration and alarm logic.

Practical: Build a gas leakage warning demonstration.

Duration: 2 Hours

Hardware: Capacitive soil sensor and rain sensor interface.

Software: ADC calibration, dry/wet mapping and corrosion-aware sampling.

Practical: Control a pump indicator based on soil moisture.

Duration: 2 Hours

Hardware: Voltage divider, ACS712/current sensor and isolation precautions.

Software: Offset calibration, RMS/basic averaging and engineering-unit conversion.

Practical: Measure a low-voltage DC load voltage and current.

Duration: 2 Hours

Hardware: I2C sensor/display, SDA, SCL and pull-up connections.

Software: Wire library, I2C addresses and address-scanner program.

Practical: Scan the bus and communicate with an I2C module.

Duration: 2 Hours

Hardware: 16x2 I2C LCD and SSD1306 OLED wiring.

Software: Display libraries, text layout, refresh control and custom symbols.

Practical: Show multiple live sensor values on a display.

Duration: 2 Hours

Hardware: Single-channel relay, transistor-isolated input and separate load supply.

Software: Relay ON/OFF logic, active-LOW handling and safe startup state.

Practical: Control a low-voltage lamp/load using a NodeMCU.

Duration: 2 Hours

Hardware: BC547/MOSFET driver, gate/base resistor and flyback diode.

Software: Selecting driver components and switching inductive DC loads.

Practical: Drive a buzzer, solenoid or DC load safely.

Duration: 2 Hours

Hardware: L293D/L298N or MOSFET motor driver and DC motor connections.

Software: Direction control, PWM speed control and interlocking.

Practical: Run a motor forward/reverse with adjustable speed.

Duration: 2 Hours

Hardware: Servo motor, external 5 V supply and common ground.

Software: Servo library, angle mapping and smooth movement.

Practical: Control servo angle using a potentiometer.

Duration: 2 Hours

Hardware: 4x4 keypad and buzzer wiring.

Software: Keypad scanning, password logic and tone generation.

Practical: Build a simple access-control keypad alarm.

Duration: 2 Hours

Hardware: NodeMCU connected to a Wi-Fi router.

Software: ESP8266WiFi library, SSID/password connection and status checks.

Practical: Connect to Wi-Fi and display IP address and RSSI.

Duration: 2 Hours

Hardware: NodeMCU configured as a local access point.

Software: SoftAP configuration, local IP and captive-control concepts.

Practical: Create a standalone Wi-Fi network for local device control.

Duration: 2 Hours

Hardware: Relay/LED output and local Wi-Fi network.

Software: HTTP server routes, HTML response and URL command handling.

Practical: Control an LED from a mobile browser.

Duration: 2 Hours

Hardware: NodeMCU, internet connection and test API endpoint.

Software: HTTPClient, request headers, status codes and payload handling.

Practical: Send sensor data to a web API and read the response.

Duration: 2 Hours

Hardware: Sensor setup and network connection.

Software: ArduinoJson objects, serialization, deserialization and validation.

Practical: Create and parse a JSON sensor packet.

Duration: 2 Hours

Hardware: Relay output and REST-capable server.

Software: REST endpoints, command polling, state response and error handling.

Practical: Control a relay and report its actual state through an API.

Duration: 2 Hours

Hardware: NodeMCU and Blynk Cloud account/device.

Software: Create template, device, datastreams and authentication token.

Practical: Connect NodeMCU to Blynk and verify online status.

Duration: 2 Hours

Hardware: Built-in LED or relay connected to a safe GPIO.

Software: BLYNK_WRITE(), Virtual Pin V0, switch values and active-LOW output.

Practical: Operate the ESP8266 built-in LED from the Blynk app.

Duration: 2 Hours

Hardware: Temperature/light sensor and Blynk gauges/charts.

Software: Blynk.virtualWrite(), timer-based uploads and dashboard widgets.

Practical: Display live sensor data without blocking Blynk.run().

Duration: 2 Hours

Hardware: Sensor threshold and Blynk event configuration.

Software: Events, notifications, limits and automation rules.

Practical: Send an alert when a sensor crosses a safe threshold.

Duration: 2 Hours

Hardware: NodeMCU and public/local MQTT broker.

Software: Broker, topic, publish, subscribe, QoS and retained messages.

Practical: Plan MQTT topics for sensors, commands and status.

Duration: 2 Hours

Hardware: Sensor and relay connected to NodeMCU.

Software: PubSubClient connection, callbacks, reconnect and JSON payloads.

Practical: Publish sensor data and subscribe to relay commands.

Duration: 2 Hours

Hardware: Computer/Raspberry Pi with Node-RED and MQTT broker.

Software: Nodes, flows, dashboard widgets and data formatting.

Practical: Build a dashboard to monitor a sensor and control an output.

Duration: 2 Hours

Hardware: Sensor and ThingSpeak channel/API key.

Software: Cloud channel fields, timed uploads and chart visualization.

Practical: Log temperature and humidity to ThingSpeak.

Duration: 2 Hours

Hardware: NodeMCU and PHP-enabled web hosting/server.

Software: GET/POST API design, input validation and JSON responses.

Practical: Send device readings to a PHP endpoint.

Duration: 2 Hours

Hardware: PHP API, MySQL database and sensor device.

Software: Database table design, prepared statements and timestamped storage.

Practical: Store and view IoT readings from the database.

Duration: 2 Hours

Hardware: NodeMCU with server-issued device ID and token.

Software: API authentication, token validation and basic access control.

Practical: Reject unauthorized device requests and accept valid devices.

Duration: 2 Hours

Hardware: NodeMCU on Wi-Fi and Arduino OTA/server firmware file.

Software: OTA concepts, version checking, update process and rollback precautions.

Practical: Upload firmware wirelessly and verify the new version.

Duration: 2 Hours

Hardware: NodeMCU internet connection and optional RTC module.

Software: NTP synchronization, timezone offset and timestamp formatting.

Practical: Add accurate date/time to sensor records.

Duration: 2 Hours

Hardware: ESP8266 deep-sleep wiring, battery and regulator considerations.

Software: Sleep/wake cycle, power budget and periodic data upload.

Practical: Build a low-power sensor node that wakes and reports data.

Duration: 2 Hours

Hardware: 5 V/3.3 V regulators, fuse, reverse-polarity and surge protection.

Software: Power calculations, brownout causes and supply decoupling.

Practical: Prepare a reliable power section for an IoT node.

Duration: 2 Hours

Hardware: NodeMCU connected to an unstable test network.

Software: Reconnect strategy, timeout, hardware/software watchdog and safe outputs.

Practical: Automatically recover from Wi-Fi or program lock-up.

Duration: 2 Hours

Hardware: Reference meter, sensor and repeatable test setup.

Software: Offset/gain calibration, moving average and noise rejection.

Practical: Calibrate a sensor and compare raw versus filtered readings.

Duration: 2 Hours

Hardware: NodeMCU, secure server and certificate/fingerprint setup.

Software: TLS basics, credential protection, secure updates and common risks.

Practical: Connect to an HTTPS endpoint and protect stored secrets.

Duration: 2 Hours

Hardware: Two ESP8266/ESP32 boards and sensors.

Software: Peer registration, packet structures and connectionless transfer.

Practical: Send sensor data directly between two boards without a router.

Duration: 2 Hours

Hardware: Multiple sensor nodes and one Wi-Fi gateway.

Software: Node addressing, data aggregation and gateway forwarding.

Practical: Collect data from multiple nodes and send it to the cloud.

Duration: 2 Hours

Hardware: Relay board, sensors, manual switches and safe low-voltage loads.

Software: Combined web/Blynk control, state synchronization and automation.

Practical: Build a two-load smart home controller.

Duration: 2 Hours

Hardware: Temperature, humidity, gas and light sensors with display.

Software: Multi-sensor scheduling, cloud logging and alert limits.

Practical: Create an indoor environmental monitoring station.

Duration: 2 Hours

Hardware: Soil moisture, water-level sensor, relay/pump demo and weather inputs.

Software: Irrigation rules, manual override and logging.

Practical: Build an automatic irrigation prototype.

Duration: 2 Hours

Hardware: Voltage/current, temperature or vibration sensor and isolated interface.

Software: Alarm states, equipment status, downtime records and dashboard.

Practical: Monitor a model machine and generate fault alerts.

Duration: 2 Hours

Hardware: Voltage/current sensor, protected low-voltage test load and display.

Software: Power/energy calculation, periodic accumulation and cloud reporting.

Practical: Display and log approximate DC energy consumption.

Duration: 2 Hours

Hardware: Sensor disconnection, relay feedback and emergency-stop input.

Software: Validation, fail-safe states, event logs and escalation rules.

Practical: Simulate faults and verify safe shutdown and alerts.

Duration: 2 Hours

Hardware: Terminal blocks, enclosure, labels, cable management and isolation.

Software: Installation checklist, serviceability and field-maintenance planning.

Practical: Assemble the project into a clean demonstrator enclosure.

Duration: 2 Hours

Hardware: Multimeter, serial logs, network tools and test checklist.

Software: Unit tests, API tests, edge cases and troubleshooting flow.

Practical: Test sensor, Wi-Fi, cloud, command and recovery functions.

Duration: 2 Hours

Hardware: Complete selected project hardware and power system.

Software: Integrate firmware, dashboard/database, security and recovery logic.

Practical: Build and validate the complete final project.

Duration: 2 Hours

Hardware: Finished project, block diagram and connection documentation.

Software: Code organization, user manual, results, limitations and future scope.

Practical: Demonstrate the project and submit source code and report.

Duration: 2 Hours

Hardware: PLC trainer, control panel examples, sensors, actuators and industrial machines.

Software: Automation hierarchy, open-loop/closed-loop control and PLC application areas.

Practical: Identify input, controller and output blocks in common industrial systems.

Duration: 2 Hours

Hardware: PPE, insulated tools, multimeter, MCB, fuse, earthing and emergency-stop devices.

Software: Electrical hazards, lockout/tagout, safe isolation and basic panel documentation.

Practical: Perform a safe power-off inspection and continuity check.

Duration: 2 Hours

Hardware: AC/DC sources, resistive loads, lamps and measurement instruments.

Software: Voltage, current, resistance, power, frequency and single/three-phase basics.

Practical: Measure AC/DC voltage, resistance and load current safely.

Duration: 2 Hours

Hardware: Electromagnetic relay, contactor, auxiliary contacts and overload relay.

Software: NO/NC contacts, coil ratings, electrical isolation and holding circuits.

Practical: Wire and test a relay-based lamp control circuit.

Duration: 2 Hours

Hardware: Single-phase motor, three-phase induction motor, DOL starter and overload relay.

Software: Motor nameplate data, rotation, protection and starter selection.

Practical: Study and trace a DOL motor starter control circuit.

Duration: 2 Hours

Hardware: Mechanical, inductive, capacitive, photoelectric, temperature and level sensors.

Software: Sensor classification, switching output and selection criteria.

Practical: Identify suitable sensors for conveyor, tank and machine applications.

Duration: 2 Hours

Hardware: PNP/NPN proximity sensors, metal and non-metal targets.

Software: Sensing distance, hysteresis, wiring colors and output behavior.

Practical: Connect and test inductive and capacitive sensors.

Duration: 2 Hours

Hardware: Diffuse, retro-reflective, through-beam and ultrasonic sensors.

Software: Sensing modes, alignment, blind zone and noise considerations.

Practical: Detect objects and measure distance on a small conveyor setup.

Duration: 2 Hours

Hardware: Limit switches, push buttons, selector switches, emergency stop and pilot lamps.

Software: Contact symbols, maintained/momentary operation and industrial color conventions.

Practical: Wire start, stop and indicator devices to a terminal strip.

Duration: 2 Hours

Hardware: DIN rail, terminal blocks, wire ducts, ferrules, MCB, SMPS and relays.

Software: Panel layout, wire numbering, cable sizing and schematic-to-panel translation.

Practical: Assemble and label a basic low-voltage control panel.

Duration: 2 Hours

Hardware: PLC CPU, power supply, rack, digital/analog modules and communication ports.

Software: CPU memory, firmware, scan process and module addressing.

Practical: Identify PLC hardware parts and read module specifications.

Duration: 2 Hours

Hardware: PLC trainer with digital inputs and outputs.

Software: Input scan, program execution, output update, memory bits and retentive data.

Practical: Observe input/output response and explain one complete scan.

Duration: 2 Hours

Hardware: Push buttons, sensors, PLC DI module and 24 VDC supply.

Software: Input common, field voltage, isolation and address assignment.

Practical: Wire multiple push buttons and sensors to PLC inputs.

Duration: 2 Hours

Hardware: Relay, transistor and triac output modules with lamps/contactor coils.

Software: Output common, load ratings, protection and interface relays.

Practical: Connect PLC outputs to lamps and a contactor through safe isolation.

Duration: 2 Hours

Hardware: PNP/NPN sensors and compatible PLC input modules.

Software: Current flow, sourcing/sinking concepts and wiring compatibility.

Practical: Wire both PNP and NPN examples and verify input indication.

Duration: 2 Hours

Hardware: PLC programming cable, computer and selected PLC trainer.

Software: Install programming software, drivers and communication settings.

Practical: Connect online, detect the PLC and upload/download a test project.

Duration: 2 Hours

Hardware: PLC project, CPU model and installed I/O modules.

Software: Create project, configure rack/modules and assign addresses.

Practical: Build a hardware configuration matching the trainer panel.

Duration: 2 Hours

Hardware: PLC trainer with switches and lamps.

Software: Rails, rungs, contacts, coils, execution order and comments.

Practical: Create and download a basic input-to-output ladder program.

Duration: 2 Hours

Hardware: Start/stop buttons and indicator lamps.

Software: Examine-if-closed/open instructions and physical versus logical state.

Practical: Implement direct, inverted and fail-safe output logic.

Duration: 2 Hours

Hardware: Start/stop push buttons, contactor/relay and motor lamp.

Software: Self-holding circuit, permissive conditions and emergency stop logic.

Practical: Program a standard three-wire motor start/stop circuit.

Duration: 2 Hours

Hardware: Multiple switches, lamps and motor direction relays.

Software: AND, OR, NOT, XOR, mutual interlock and priority logic.

Practical: Develop logic-gate exercises and forward/reverse interlocking.

Duration: 2 Hours

Hardware: PLC timer instruction and output lamps.

Software: Preset, accumulated value, done bit and non-retentive timing.

Practical: Create delayed motor start and sequential lamp control.

Duration: 2 Hours

Hardware: Buttons, lamps and PLC timer instructions.

Software: TOF, pulse timer, timer reset and timing diagrams.

Practical: Build exhaust-fan delay and one-shot output applications.

Duration: 2 Hours

Hardware: Proximity sensor, push button and display/HMI tag.

Software: Up/down counters, preset, accumulator and reset logic.

Practical: Count products and stop a conveyor at a target quantity.

Duration: 2 Hours

Hardware: Analog/simulated values and output indicators.

Software: Equal, not equal, greater/less than and range comparison.

Practical: Create low, normal and high process-status indications.

Duration: 2 Hours

Hardware: PLC registers and simulated production values.

Software: Add, subtract, multiply, divide, average and overflow handling.

Practical: Calculate total production, reject percentage and process values.

Duration: 2 Hours

Hardware: PLC data registers, constants and HMI tags.

Software: MOVE, copy, fill, conversion and structured data basics.

Practical: Transfer setpoints and process values between memory locations.

Duration: 2 Hours

Hardware: Push buttons, lamps and PLC memory bits.

Software: Latch/unlatch instructions, retentive memory and safe reset design.

Practical: Create alarm acknowledgement and mode-selection logic.

Duration: 2 Hours

Hardware: Push button or fast sensor and PLC memory.

Software: Rising/falling edge detection and single-scan pulse generation.

Practical: Count one event per button press without repeated triggering.

Duration: 2 Hours

Hardware: Multi-function PLC project.

Software: Main routine, functions, function blocks, reusable code and tag naming.

Practical: Split a machine program into clear reusable sections.

Duration: 2 Hours

Hardware: PLC trainer with intentional wiring/program faults.

Software: Watch tables, force precautions, cross-reference and diagnostic buffers.

Practical: Locate and correct an input, logic and output fault.

Duration: 2 Hours

Hardware: 0–10 V and 4–20 mA simulator, PLC analog module.

Software: Analog standards, resolution, raw counts, grounding and shielding.

Practical: Wire and read a voltage and current-loop signal.

Duration: 2 Hours

Hardware: Potentiometer/current simulator and PLC analog input.

Software: Linear scaling, offset, range checking and engineering-unit conversion.

Practical: Convert raw input to temperature, pressure or tank level.

Duration: 2 Hours

Hardware: RTD, thermocouple transmitter or simulator and analog input.

Software: RTD/thermocouple principles, transmitters, cold-junction basics and filtering.

Practical: Read and display temperature with alarm limits.

Duration: 2 Hours

Hardware: Incremental encoder/proximity sensor and HSC-capable PLC.

Software: Pulse frequency, encoder A/B channels, count direction and reset.

Practical: Measure shaft position or conveyor product speed.

Duration: 2 Hours

Hardware: PLC high-speed pulse output, LED/driver or stepper interface.

Software: Pulse train, duty cycle, frequency and hardware limitations.

Practical: Generate a variable pulse/PWM output and verify it.

Duration: 2 Hours

Hardware: VFD, induction motor, MCB and control terminals.

Software: V/f control, acceleration, deceleration, frequency and protection parameters.

Practical: Enter motor data and run a motor from the VFD keypad.

Duration: 2 Hours

Hardware: VFD, motor, isolator, emergency stop and control switches.

Software: Input/output terminals, grounding, braking and safe wiring practice.

Practical: Wire a basic VFD panel and verify direction safely.

Duration: 2 Hours

Hardware: PLC outputs, VFD digital inputs and motor.

Software: Run, stop, forward, reverse and multi-speed command mapping.

Practical: Control VFD start/stop and preset speeds from PLC.

Duration: 2 Hours

Hardware: PLC analog output or signal source and VFD analog input.

Software: 0–10 V/4–20 mA speed reference, scaling and signal common.

Practical: Change motor speed from a PLC process value.

Duration: 2 Hours

Hardware: HMI panel/software and PLC connection.

Software: HMI project creation, device selection, communication and screen navigation.

Practical: Connect HMI to PLC and display a live tag.

Duration: 2 Hours

Hardware: Buttons, lamps, numeric displays and setpoint fields.

Software: Tag addressing, data types, write permissions and object properties.

Practical: Create a motor-control screen with status feedback.

Duration: 2 Hours

Hardware: HMI with simulated process values.

Software: Alarm classes, history, trend sampling, data logging and recipe basics.

Practical: Create alarm and trend screens for a tank process.

Duration: 2 Hours

Hardware: PLC, HMI and Ethernet/serial cable.

Software: IP/node settings, device drivers, timeout and address diagnostics.

Practical: Diagnose and correct a broken PLC-HMI connection.

Duration: 2 Hours

Hardware: RS-232/RS-485 converters, PLC and field device.

Software: Serial parameters, termination, biasing, shielding and multi-drop networks.

Practical: Build and test a short RS-485 network.

Duration: 2 Hours

Hardware: PLC master/slave devices or simulator.

Software: Function codes, coils/registers, slave ID and register mapping.

Practical: Read and write Modbus RTU registers from PLC.

Duration: 2 Hours

Hardware: Ethernet PLC, switch and computer/device simulator.

Software: IP addressing, subnet, ports, clients/servers and Modbus TCP frames.

Practical: Exchange process data over Modbus TCP.

Duration: 2 Hours

Hardware: PLC, remote I/O coupler and network connection.

Software: Remote rack configuration, network mapping and communication diagnostics.

Practical: Map remote digital I/O and test field signals.

Duration: 2 Hours

Hardware: Process simulator, analog input/output and PLC PID instruction.

Software: Setpoint, process value, control value, error and P/I/D actions.

Practical: Create a closed-loop level or temperature simulation.

Duration: 2 Hours

Hardware: PID simulator or small temperature/level setup.

Software: Manual tuning, overshoot, settling time, integral windup and limits.

Practical: Tune a PID loop for stable response and document results.

Duration: 2 Hours

Hardware: Stepper/servo drive, motor and PLC pulse outputs.

Software: Position, speed, homing, pulse/direction and drive-enable concepts.

Practical: Run a basic indexed movement sequence.

Duration: 2 Hours

Hardware: Emergency stop, overload, door switch and alarm indicators.

Software: Fail-safe design, permissives, trips, reset and alarm priority.

Practical: Program safe shutdown and controlled restart logic.

Duration: 2 Hours

Hardware: Multiple sensors, cylinders/lamps and PLC outputs.

Software: Step sequence, transition conditions, state memory and recovery.

Practical: Program a multi-step automatic machine cycle.

Duration: 2 Hours

Hardware: PLC trainer with red, yellow and green lamps.

Software: Timed sequencing, pedestrian request and fault-safe state.

Practical: Build a two-way traffic-light controller.

Duration: 2 Hours

Hardware: Mini conveyor/simulated motor, proximity sensors and diverter outputs.

Software: Sequence, counting, sensor validation, jam timer and reject logic.

Practical: Program automatic counting and sorting by sensor condition.

Duration: 2 Hours

Hardware: Level switches/analog level simulator, pump relay and alarms.

Software: Auto/manual modes, dry-run protection, high/low limits and pump alternation.

Practical: Create a tank filling and draining control system.

Duration: 2 Hours

Hardware: Contactors/indicator simulation, overload and timer.

Software: Main/star/delta sequence, electrical/software interlocking and fault handling.

Practical: Program and test an automatic star-delta starter.

Duration: 2 Hours

Hardware: Tank level, valves, mixer motor and timer simulation.

Software: Recipe quantity, fill/mix/drain sequence, alarms and cycle count.

Practical: Develop a complete batch-mixing PLC program and HMI screen.

Duration: 2 Hours

Hardware: SCADA software/demo, PLC or communication simulator.

Software: Tags, mimic screens, alarms, trends, historian and user access.

Practical: Create a basic SCADA monitoring page for a process.

Duration: 2 Hours

Hardware: Selected PLC, HMI/VFD/sensors, panel documents and test checklist.

Software: Integrated programming, backups, I/O test, commissioning and documentation.

Practical: Complete, test and present an industry-style automation project.

Duration: 2 Hours

Hardware: PCB samples, copper layers, substrate, vias, pads and solder mask.

Software: PCB terminology, design workflow and schematic-to-manufacturing stages.

Practical: Inspect single-layer, double-layer and multilayer boards.

Duration: 2 Hours

Hardware: Basic components, multimeter and low-voltage circuits.

Software: Voltage/current/power calculations, polarity and electrical-clearance basics.

Practical: Calculate resistor power and verify safe component ratings.

Duration: 2 Hours

Hardware: THT and SMD resistors, capacitors, diodes, transistors and IC packages.

Software: Package naming, pin numbering and reading markings.

Practical: Identify common package types and measure lead/pad spacing.

Duration: 2 Hours

Hardware: Datasheets for ICs, connectors and discrete components.

Software: Pinout, absolute maximum ratings, recommended circuits and package drawings.

Practical: Extract symbol and footprint dimensions from a datasheet.

Duration: 2 Hours

Hardware: Example circuit diagrams and standard symbols.

Software: Reference designators, net naming, hierarchy and readable schematic layout.

Practical: Redraw a simple circuit using professional schematic conventions.

Duration: 2 Hours

Hardware: Computer with KiCad and project files.

Software: Install KiCad, configure libraries and understand project tools.

Practical: Create and save a new PCB design project.

Duration: 2 Hours

Hardware: Basic LED and regulator circuit components.

Software: Place, rotate, mirror and edit schematic symbols and values.

Practical: Draw a complete LED indicator schematic.

Duration: 2 Hours

Hardware: Completed basic schematic.

Software: Wire tools, junctions, labels, annotation and electrical-rules checking.

Practical: Run ERC and correct unconnected or conflicting pins.

Duration: 2 Hours

Hardware: Multi-section schematic example.

Software: Local/global labels, buses and hierarchical-sheet concepts.

Practical: Organize a controller circuit into functional blocks.

Duration: 2 Hours

Hardware: Regulator and controller schematic.

Software: Power input/output pin types, PWR_FLAG and supply naming.

Practical: Clear power-related ERC errors correctly.

Duration: 2 Hours

Hardware: Relay, BC547/transistor, diode, LED and connectors.

Software: Driver calculations, flyback protection and active logic.

Practical: Create a complete single-channel relay driver schematic.

Duration: 2 Hours

Hardware: 7805/AMS1117 regulator, capacitors and protection diode.

Software: Input/output filtering, thermal loss and regulator layout requirements.

Practical: Design a regulated low-voltage power supply schematic.

Duration: 2 Hours

Hardware: Sensor header, pull-ups, divider and filtering components.

Software: Analog/digital interface planning and connector pin assignment.

Practical: Create a protected sensor interface circuit.

Duration: 2 Hours

Hardware: Datasheet for an uncommon IC or module.

Software: Symbol editor, pin types, units and library management.

Practical: Create and validate a custom IC symbol.

Duration: 2 Hours

Hardware: Common THT/SMD component samples and datasheets.

Software: Pads, courtyard, fabrication layer, silkscreen and origin.

Practical: Compare footprints and choose the correct package.

Duration: 2 Hours

Hardware: Resistor, diode, terminal block, relay and DIP package dimensions.

Software: Drill size, annular ring, pitch and mechanical tolerance.

Practical: Create or verify a through-hole relay footprint.

Duration: 2 Hours

Hardware: 0805/0603 parts, SOT-23 and SOIC packages.

Software: Land-pattern dimensions, paste layer and hand-soldering allowances.

Practical: Create and inspect an SMD transistor footprint.

Duration: 2 Hours

Hardware: Mechanical drawing for a module or connector.

Software: Footprint editor, pad numbering, courtyard and reference/value placement.

Practical: Create a custom NodeMCU/module footprint.

Duration: 2 Hours

Hardware: Footprints with 3D models and enclosure dimensions.

Software: Assign/align 3D models and inspect board assembly.

Practical: View the PCB in 3D and correct orientation issues.

Duration: 2 Hours

Hardware: Completed annotated schematic with assigned footprints.

Software: Footprint assignment and forward annotation to PCB editor.

Practical: Transfer all circuit nets and footprints to the board.

Duration: 2 Hours

Hardware: PCB editor and manufacturer capability sheet.

Software: Copper layers, mask, silkscreen, units, grid and default rules.

Practical: Configure a two-layer board for standard manufacturing.

Duration: 2 Hours

Hardware: Mechanical drawing or target board size.

Software: Edge.Cuts rules, dimensions, slots and cut-out concepts.

Practical: Create an accurate board outline with mounting-hole locations.

Duration: 2 Hours

Hardware: Unplaced relay-driver or regulator board.

Software: Functional grouping, orientation, accessibility and shortest critical paths.

Practical: Place components for clean routing and serviceability.

Duration: 2 Hours

Hardware: Placed two-layer board.

Software: Interactive router, track corners, clearance and layer switching.

Practical: Route a small board without unrouted nets.

Duration: 2 Hours

Hardware: High-current load path and low-current signal paths.

Software: Track-width calculation, copper thickness and temperature rise.

Practical: Assign suitable widths to relay contacts and logic signals.

Duration: 2 Hours

Hardware: Two-layer board requiring crossings.

Software: Via size, drill limits, stitching and layer-transition strategy.

Practical: Complete routing using minimum practical vias.

Duration: 2 Hours

Hardware: Routed controller board.

Software: Zone priority, thermal relief, clearance and refill behavior.

Practical: Add GND zones and inspect isolated copper islands.

Duration: 2 Hours

Hardware: Mixed load/control circuit.

Software: Return-current paths, star grounding and loop reduction.

Practical: Improve ground routing for relay or motor noise reduction.

Duration: 2 Hours

Hardware: Completed board with intentional errors.

Software: DRC settings, violation categories and systematic correction.

Practical: Run DRC and achieve a zero-critical-error board.

Duration: 2 Hours

Hardware: Microcontroller/IC power pins and switching loads.

Software: Decoupling placement, loop area, ferrites and noise-control practices.

Practical: Place capacitors and revise routes to reduce interference.

Duration: 2 Hours

Hardware: Mixed analog sensor and digital controller circuit.

Software: Partitioning, reference ground and sensitive-signal routing.

Practical: Lay out an analog sensor section away from noisy outputs.

Duration: 2 Hours

Hardware: Relay, terminal blocks, driver and isolation spacing.

Software: Contact-path width, coil path, creepage and low/high-voltage separation.

Practical: Lay out a production-style relay driver PCB.

Duration: 2 Hours

Hardware: Rectifier/regulator or DC-DC module circuit.

Software: High-current loops, thermal copper, capacitor placement and heat dissipation.

Practical: Lay out a low-voltage power supply board.

Duration: 2 Hours

Hardware: Op-amp/preamp circuit and connectors.

Software: Signal grounding, input/output separation and hum/noise reduction.

Practical: Place and route a simple low-noise amplifier stage.

Duration: 2 Hours

Hardware: UART, USB or differential-signal example.

Software: Controlled return path, matched length concepts and avoiding stubs.

Practical: Route a differential pair demonstration with rule constraints.

Duration: 2 Hours

Hardware: Input/output connectors, programming header and measurement nodes.

Software: Connector orientation, pin labels, protection and testability.

Practical: Add accessible test points and programming connections.

Duration: 2 Hours

Hardware: Enclosure drawing, screws and board supports.

Software: Mechanical clearance, copper keepout and component height constraints.

Practical: Add mounting holes and mechanical keepout areas.

Duration: 2 Hours

Hardware: Completed PCB layout.

Software: Readable references, polarity marks, pin-1 indicators and labels.

Practical: Prepare professional top/bottom silkscreen.

Duration: 2 Hours

Hardware: Small finished board and manufacturer panel rules.

Software: Board arrays, rails, V-score, mouse bites and tooling concepts.

Practical: Create a basic multi-board panel plan.

Duration: 2 Hours

Hardware: Fabricator capability table.

Software: Minimum track/space, drill, annular ring, mask and board constraints.

Practical: Apply realistic manufacturing constraints to board setup.

Duration: 2 Hours

Hardware: DRC-clean finished board.

Software: Plot settings, required Gerber layers and file naming.

Practical: Generate copper, mask, silkscreen and outline Gerbers.

Duration: 2 Hours

Hardware: Board with plated/non-plated holes.

Software: Excellon drill files, drill maps and fabrication notes.

Practical: Generate and inspect drill files.

Duration: 2 Hours

Hardware: Final schematic and component selections.

Software: BOM fields, manufacturer part numbers, alternates and quantities.

Practical: Export and clean a purchasing-ready BOM.

Duration: 2 Hours

Hardware: SMD board with correct footprints.

Software: Position files, rotation, board origin and assembly drawings.

Practical: Generate placement data and verify component orientation.

Duration: 2 Hours

Hardware: Gerber ZIP and independent viewer.

Software: Layer verification, drill alignment, text, clearances and board dimensions.

Practical: Perform a complete fabrication-output review.

Duration: 2 Hours

Hardware: Verified Gerbers, BOM and board specifications.

Software: Material, thickness, copper weight, finish, mask color and quantity choices.

Practical: Prepare an order specification for a PCB manufacturer.

Duration: 2 Hours

Hardware: Soldering iron, flux, wick and practice PCB.

Software: THT/SMD soldering methods, temperature control and ESD handling.

Practical: Assemble and rework components on a practice board.

Duration: 2 Hours

Hardware: Assembled PCB, multimeter and magnifier.

Software: Visual inspection, continuity, short-circuit checks and staged power-up.

Practical: Inspect and safely power a newly assembled board.

Duration: 2 Hours

Hardware: Faulty or intentionally modified PCB.

Software: Signal tracing, expected voltages and divide-and-test diagnosis.

Practical: Find and correct open, short or wrong-component faults.

Duration: 2 Hours

Hardware: Simple existing PCB and multimeter.

Software: Trace identification, net reconstruction and component documentation.

Practical: Create a partial schematic from a simple board.

Duration: 2 Hours

Hardware: Proteus software and basic circuit model.

Software: Place parts, wire circuit, set instruments and run simulation.

Practical: Simulate an LED/transistor or relay driver circuit.

Duration: 2 Hours

Hardware: Verified Proteus schematic and packages.

Software: Netlist transfer, board outline, placement, routing and design checks.

Practical: Create a simple PCB layout in Proteus.

Duration: 2 Hours

Hardware: ATmega/Arduino headers, regulator and connectors.

Software: Controller-board schematic organization and programming interface.

Practical: Design a compact Arduino-compatible trainer/shield PCB.

Duration: 2 Hours

Hardware: NodeMCU module, relay drivers, supply and terminals.

Software: GPIO selection, boot-pin precautions and modular schematic design.

Practical: Design a multi-channel NodeMCU relay PCB.

Duration: 2 Hours

Hardware: Multiple sensor connectors, protection and signal conditioning.

Software: Modular connector mapping and analog/digital separation.

Practical: Design a universal sensor interface PCB.

Duration: 2 Hours

Hardware: Switching regulator/driver reference design.

Software: High-frequency loop minimization, gate paths, snubbers and isolation safety.

Practical: Review and improve a switching-power layout example.

Duration: 2 Hours

Hardware: Completed project PCB and assembly plan.

Software: Design for manufacture, assembly, testing and repair checklist.

Practical: Perform peer review and document required corrections.

Duration: 2 Hours

Hardware: Selected application schematic, datasheets and mechanical limits.

Software: Complete schematic, libraries, placement, routing, DRC and revision control.

Practical: Finish a manufacturing-ready project PCB.

Duration: 2 Hours

Hardware: Fabricated/printed prototype or detailed output review.

Software: Bring-up plan, measurements, fault recording and engineering changes.

Practical: Validate the design and prepare revision corrections.

Duration: 2 Hours

Hardware: Final project, Gerbers, BOM and diagrams.

Software: Release package, fabrication notes, assembly guide and version history.

Practical: Submit and present the complete PCB production package.

Duration: 2 Hours