Embedded, IoT, PLC & PCB Courses in Salem

Hardware: Embedded system blocks, Arduino UNO architecture, breadboard, resistor and LED basics.

Software: Arduino IDE installation, board/port selection, setup() and loop() program structure.

Practical: LED blinking and traffic-light sequence.

Duration: 2 Hours

Hardware: Push button, switches, digital pins, pull-up and pull-down connections.

Software: Variables, data types, operators and if/else conditions.

Practical: Push-button LED control and toggle operation.

Duration: 2 Hours

Hardware: Potentiometer, LDR and analog sensor interfacing.

Software: analogRead(), ADC values, Serial Monitor and serial debugging.

Practical: Read and display potentiometer and LDR values.

Duration: 2 Hours

Hardware: PWM pins, LED brightness control and buzzer interfacing.

Software: analogWrite(), map(), loops and timing functions.

Practical: LED dimmer and variable buzzer tone.

Duration: 2 Hours

Hardware: DHT11 temperature/humidity sensor and ultrasonic sensor connections.

Software: Library installation, functions and distance calculation.

Practical: Temperature monitoring and distance measurement.

Duration: 2 Hours

Hardware: 16x2 I2C LCD and OLED display wiring.

Software: Display libraries, text formatting and live sensor-value display.

Practical: Show temperature and distance values on LCD.

Duration: 2 Hours

Hardware: Relay module, transistor driver, flyback diode and DC motor interface.

Software: Output control and non-blocking timing using millis().

Practical: Relay appliance control and DC motor operation.

Duration: 2 Hours

Hardware: UART, I2C and SPI hardware connections.

Software: Serial data transmission and protocol programming basics.

Practical: Arduino-to-Arduino serial communication.

Duration: 2 Hours

Hardware: NodeMCU/ESP32 GPIO, Wi-Fi connection and relay interface.

Software: Wi-Fi programming, HTTP requests and embedded web server.

Practical: Mobile web-based LED or relay control.

Duration: 2 Hours

Hardware: Complete sensor, display, relay and controller hardware integration.

Software: Program integration, debugging, testing and documentation.

Practical: Final embedded/IoT mini-project demonstration.

Duration: 2 Hours

Hardware: jjniik

Software: jninin

Practical: jbjnjn

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