Embedded C Based Automated Guided Vehicle for Industrial Automation

The ATmega328P is an 8-bit RISC microcontroller with 28 pins, 131 instructions, and 32 general-purpose 8-bit registers. It operates at up to 20 MHz with Harvard architecture enabling pipelining. Memory includes 32KB flash for programs, EEPROM for data (100K write cycles), and RAM for variables. The memory map reserves the first 32 addresses for register mapping. Peripherals include 23 I/O pins across three ports, 12 8-bit timers (two 16-bit), 16 PWM channels, 8-channel 10-bit ADC, and three serial protocols (I2C, SPI, UART). Clock sources include internal RC oscillator (up to 8 MHz), external crystal (up to 20 MHz), or external clock. All peripherals require clock signals and can be configured through frequency multiplication or division.

The AVR microcontroller architecture features two distinct memory spaces—program memory and data memory—which is fundamentally different from architectures like Intel or ARM that use a unified address space. This separation explains why variables and functions can share the same numerical address but belong to different memory spaces. For GPIO control, each port (B, C, D) has three key registers: DDRxn (Data Direction Register) to configure pins as input or output, PORTxn to set output values or toggle pins, and PINxn to read input values or trigger toggles. Writing logic 1 to PINxn toggles the corresponding PORTxn bit regardless of DDRxn settings. External interrupts are managed through registers like EIMSK and EICRA, with ISRs defined using the ISR() macro. Timers count clock cycles and generate interrupts on overflow, enabling precise timing applications.

Microcontrollers from different manufacturers share fundamental working principles, making understanding internal architecture essential before programming. The ATmega328P is an 8-bit microcontroller with 131 instructions, operating up to 20 MHz. It includes 32KB flash memory (10,000 write cycles), 1KB EEPROM (1,000 write cycles), and 2KB RAM. Key peripherals include two 8-bit timers, one 16-bit timer, 10-bit ADC, USART, SPI, and I2C interfaces. Memory is organized using hexadecimal addressing with four types: Flash program memory (read-only), Working Registers (temporary processing), RAM (volatile data), and EEPROM (non-volatile storage). Clock systems use crystal oscillators measured in Hertz, with options including internal RC oscillators (128 kHz, 8 MHz) and external crystals. Internal RC oscillators vary with temperature and voltage, making external crystals preferable for precise timing.

The AT Mega 328P is an 8-bit AVR microcontroller featuring a CPU with ALU, Control Unit, and 32 general-purpose registers, three types of memory (SRAM for data processing, EEPROM for non-volatile data storage, and Flash for program storage), and various peripheral modules for external communication including timers, ADC, and I/O ports. It operates at frequencies up to 16-20 MHz with a 5V power supply and is commonly used in Arduino Uno boards for embedded system development.

GPIO (General Purpose Input Output) is the fundamental MCU function enabling signal exchange with external devices. ATmega328P organizes GPIO into three ports: Port B (8 pins), Port C (7 pins), and Port D (8 pins). Pins have special functions: PC6 as reset, PB0-PB2 for SPI SCLK, RXD/TXD for UART, INT0/INT1 for interrupts, AIN0/AIN1 for comparators, and ADC0-ADC5 for conversion. However, ATmega328P has only one ADC handling one conversion at a time. Configuration is achieved through register manipulation, with MCUCR at 0x55 containing control bits for interrupt vectors and brown-out detection.

UART (Universal Asynchronous Receiver Transmitter) is a fundamental serial communication protocol used extensively in embedded systems. It enables communication between microcontrollers and various peripheral devices such as GPS modules, GSM modules, Bluetooth modules, RFID modules, PLCs, and CNC machines. UART operates asynchronously without a shared clock signal between devices, using a frame structure that includes start bits, stop bits, and data bits (typically 8-bit ASCII characters). The protocol uses TX and RX pins for full-duplex communication where one device transmits while the other receives. UART is particularly valuable for debugging purposes, allowing engineers to monitor sensor data collected by microcontrollers on a personal computer through USB-to-serial adapters and terminal software.

UART (Universal Asynchronous Receiver/Transmitter) is the most basic asynchronous serial communication protocol. It uses one data wire (TX for transmitter, RX for receiver) plus ground. Three configuration parameters must match between devices: transmission speed (Baud rate, commonly 9600 bits/second), data length (typically 8 bits), and start/stop bits. The start bit (low pulse) signals the receiver to begin reading, while the stop bit (high pulse) marks the end. The receiver samples data at the middle of each bit period to ensure accurate reading. RS232 is a UART variant used by older computers with additional flow control pins (DTR, CTS) for preventing data loss.

UART (Universal Asynchronous Receiver Transmitter) is a fundamental serial communication protocol used in embedded systems. It supports three communication modes: Simplex (one-way), Half-Duplex (alternating two-way), and Full-Duplex (simultaneous two-way). The protocol uses a shift register to convert serial data to parallel format. Data detection relies on a local clock reference, with the TxD pin set to high when idle and low when transmitting. The baud rate, measured in bits per second, defines the transmission speed and is generated through an external timer. UART is commonly used for GSM modules operating at 900 MHz and 800 MHz frequencies.

GSM modules communicate via UART requiring TX, RX, and ground pins. AT commands (a set of approximately 80 standardized commands) serve as the control language for GSM modules, instructing them to perform actions like making calls or sending messages. The basic 'AT' command tests module connectivity, returning 'OK' when successful. Communication typically uses serial terminals like PuTTY or Arduino as intermediaries between the computer and GSM module. The Arduino forwards data bidirectionally between the PC and GSM module, allowing users to send commands and view responses without writing complex code.

This video demonstrates three types of electronic modules: a digital infrared thermometer (MLX90614) with I2C and PWM interfaces measuring temperatures from -70°C to +380°C with ±0.5°C accuracy at 0-50°C; an RFID reader (MFRC-522) supporting SPI, I2C, and UART interfaces for reading RFID tags; and a GSM module kit (NEOWAY M590) with SIM holder, LEDs, and resistors, controlled via UART AT commands and supporting GPRS Class 10. These modules are commonly used in electronics projects and hobbyist applications.

Ultrasonic sensors measure distance by emitting sound waves through the Trig pin and calculating the distance based on the time it takes for the Echo pin to receive the reflected signal, using the formula: distance = (speed of sound × time) / 2.

The HC-SR04 ultrasonic sensor measures distance by emitting 40kHz sound pulses and measuring the echo return time; to interface it with Arduino, connect VCC to 5V, GND to ground, trigger to a digital output pin, and echo to a digital input pin, then use the pulseIn() function to read the echo pulse width and calculate distance using the formula distance = (duration × 0.034) / 2, where duration is in microseconds and 0.034 cm/μs represents the speed of sound.

This segment explains the ultrasonic sensor trigger mechanism: setting Trig pin to LOW for 2 microseconds, then HIGH for 10 microseconds to send pulses. The Echo pin returns pulse duration using pulseIn() function. The distance calculation formula is: Distance = (Time × Speed of Sound) / 2, where speed of sound is approximately 340 m/s. The division by 2 accounts for the round-trip travel of sound waves.

This section details the complete trigger sequence for the HC-SR04 sensor. The process involves: (1) Setting TRIG_PIN to LOW and delaying 2 microseconds, (2) Setting TRIG_PIN to HIGH and delaying exactly 10 microseconds (minimum required), (3) Setting TRIG_PIN back to LOW, (4) Reading the ECHO_PIN using pulseIn() to measure the duration of the returning pulse. The pulse duration represents the time taken for the ultrasonic wave to travel to the object and return. This precise timing sequence is critical for accurate distance calculations.

This section covers the complete workflow for triggering the HC-SR04 sensor and calculating distance. To trigger the sensor, the trigger pin must be pulled high for approximately 10 microseconds using a dedicated microsecond delay function, then pulled low. The sensor emits an ultrasonic burst and waits for the echo. The distance is calculated using the pulse width measured from the echo: distance = (pulse width × speed of sound) / 2. The implementation includes periodic polling every 200 milliseconds to prevent overwhelming the system. Error handling is demonstrated, including debugging common issues like incorrect pin definitions and missing header files.