Raspberry Pi GPIO LED Control: Python Circuit Tutorial

To control LED brightness, use analogWrite(pin, value) where the value ranges from 0 to 255 (8-bit resolution). This function controls the brightness of LEDs or the speed of motors through PWM (Pulse Width Modulation). Higher values result in higher brightness or speed. For example, analogWrite(13, 1) produces minimum brightness, while analogWrite(13, 255) produces maximum brightness.

This video teaches how to implement Software PWM (Pulse Width Modulation) on microcontrollers like PIC and AVR to control LED brightness. The core principle is that power delivery depends on the duty cycle (ratio of pulse width to total cycle time), measured in percentages. The implementation uses a counter that increments from 0 to 255, turning the output ON when the counter equals 0 and OFF when it reaches the brightness threshold value. Buttons can increase or decrease the brightness threshold, allowing users to adjust LED intensity. This software approach replicates hardware PWM functionality using basic programming constructs like counters, variables, and conditional statements.

Implementing PWM requires configuring channels using ledcSetup() with channel, frequency, and resolution parameters, then assigning pins using ledcAttachPin(). LED brightness is controlled by writing values (0-255 for 8-bit resolution) to the PWM channel, where higher values produce higher duty cycles and brighter LEDs. A fade-in effect is created by incrementing a variable from 0 to 255 and writing each value to the channel every 15 milliseconds. A fade-out effect is created by decrementing from 255 to 0. When the variable reaches 0, the fade-in process restarts, creating a continuous breathing effect that demonstrates PWM's ability to smoothly control LED intensity.

PWM (Pulse Width Modulation) is an energy-efficient technique for controlling the intensity of LEDs and the speed of DC motors by rapidly switching the power on and off, where the duty cycle (ratio of on-time to total cycle time) determines the average power delivered without dissipating energy as heat, unlike traditional potentiometer-based control methods.

PWM controls LED brightness by varying duty cycle from 0-255, with ADC values (0-1.023) requiring conversion to PWM range. PWM controls motor speed proportionally to duty cycle. LCD displays show both raw PWM values (0-255) and percentage (0-100%). Two examples demonstrate: (1) potentiometer controls LED brightness via PWM1, (2) potentiometer controls both motor speed (PWM1) and LED brightness (PWM2) simultaneously.

This segment explains why polling mode with delays is inadequate for hardware devices operating at high speeds (e.g., 400 megabits per second). The presenter demonstrates the transition from polling to interrupt-based systems, explaining that interrupts provide more efficient and responsive hardware interaction. The segment emphasizes that interrupt-based systems are essential for real-time applications and complex embedded projects, setting the foundation for the next major topic in the video series.

Programmed I/O uses status registers that default to 'not ready'; when data is available, the register flips to 'ready'. The CPU repeatedly checks (polls) this register until it sees readiness, then interacts with the device. This is simple but inefficient as the CPU wastes cycles checking status flags. Interrupt-driven I/O uses a special wire to send interrupt signals when devices are ready. The interrupt pauses the CPU's current task and jumps to an interrupt handler containing device-specific code. This makes systems more responsive without wasting time polling.

Polling is a method where the CPU repeatedly checks devices for data, like a child constantly asking 'Are we there yet?' This wastes CPU energy. USB uses polling because each interrupt requires its own conductor, and USB cables only have four conductors—insufficient for 20+ devices. Interrupts literally interrupt the CPU's five-stage execution path (fetch, decode, execute, memory, write back). When an interrupt occurs, the CPU saves all current state and loads interrupt handler code. Hardware-wise, interrupts work like an AND gate that stops execution when triggered. The trade-off is that interrupts are expensive (saving state) but allow immediate response to events.

Two approaches exist for CPU-device communication: interrupt-driven and polling. In interrupt-driven I/O, devices signal the CPU when data is ready, allowing the CPU to handle other tasks in between. In polling, the CPU constantly checks devices for data, which wastes processing power. The video explains that while polling can work as a workaround for timing issues, it creates significant performance penalties because the CPU must continuously check multiple drives, similar to having a courier visit every hour instead of scheduling pickups only when needed.

Polling is a simple device driver approach where the CPU continuously checks device status registers until operations complete. This busy waiting wastes CPU cycles, especially for slow devices. Interrupt-driven IO addresses this by allowing the CPU to perform other tasks while waiting for IO completion. When devices finish, they generate interrupts that notify the CPU. Hardware interrupts are asynchronous (can occur anytime), while software interrupts (traps) are synchronous (caused by program execution).

This webinar explores three essential serial communication protocols used in embedded systems: UART (Universal Asynchronous Receiver Transmitter) for basic microcontroller-to-computer or sensor communication using TX/RX pins; I2C (Inter-Integrated Circuit) for multi-device communication over two wires (SDA/SCL) with unique slave addresses, commonly used for sensors and memories; and SPI (Serial Peripheral Interface) for high-speed full-duplex communication using four wires (MOSI/MISO/SS/SCK), ideal for displays and memory devices. The presenter emphasizes that understanding these protocols is fundamental for embedded systems development, as they enable microcontrollers to communicate with sensors, displays, and other peripherals in industrial applications like PLCs, CNC machines, and IoT devices.

This video explains three fundamental serial communication protocols used in microcontroller applications: UART (Universal Asynchronous Receiver Transmitter) uses two wires (TX/RX) with start/stop bits and a shared clock, requiring configuration of baud rate and data format; I2C (Inter-Integrated Circuit) uses two wires (SDA/SCL) with a clock line for synchronization and slave addressing, allowing multiple devices on one bus; SPI (Serial Peripheral Interface) uses four wires (MOSI/MISO/SCK/CS) for full-duplex communication without slave addressing, offering higher speed and lower power consumption but limited range. Each protocol balances trade-offs between connection count, speed, complexity, and range.

Serial transmission sends data one bit at a time over a shared bus, offering advantages over parallel transmission including longer distances, higher throughput, and support for more nodes; three common low-speed serial protocols are UART (asynchronous, two-wire, uses start/stop bits and optional parity for framing data), I2C (synchronous, two-wire, master-slave architecture with address-based communication and acknowledgment bits), and SPI (synchronous, four-wire, full-duplex with separate chip select lines for addressing slaves); each protocol defines how bits are formatted into messages and the rules for exchanging data between devices.

Arduino uses three primary communication protocols for connecting with external devices: UART (Universal Asynchronous Receiver/Transmitter) is a serial communication protocol using pins 0 and 1 for full-duplex data transmission with a maximum baud rate of 15202; I2C (Inter-Integrated Circuit) is a two-wire protocol using SDA and SCL pins for half-duplex communication supporting multiple devices with speeds ranging from 100 kbps to 5 Mbps; and SPI (Serial Peripheral Interface) is a four-wire protocol using MOSI, MISO, SCK, and SS pins for full-duplex communication at 10 Mbps, enabling faster data transfer but increasing complexity when connecting multiple sensors.

This video explains three fundamental communication protocols used in embedded systems: UART (Universal Asynchronous Receiver/Transmitter) uses two wires for one-to-one master-slave communication with a frame format including start bits, data bits, parity bits, and stop bits, achieving speeds up to 5 Mbps; SPI (Serial Peripheral Interface) is a four-wire protocol supporting one master with multiple slaves using MOSI, MISO, SCLK, and SS pins, capable of full-duplex communication at speeds up to 60 Mbps; I2C (Inter-Integrated Circuit) is a two-wire multi-master/multi-slave protocol invented by Philips in 1982, supporting up to 128 devices with 7-bit addressing and built-in acknowledgment bits, achieving speeds up to 3.4 Mbps. Each protocol has distinct advantages and trade-offs in terms of speed, complexity, and application suitability.