1. Hardware Setup:
2. Connect the 8051 development board's serial port (TxD - P3.1, RxD - P3.0) to the PC via a USB-to-Serial converter. Ensure correct RxD-TxD cross-connection (TxD of 8051 to RxD of PC, RxD of 8051 to TxD of PC).
3. Power on the 8051 board.
4. Software Setup (PC):
5. Open a terminal emulator (e.g., PuTTY).
6. Configure the serial port settings:
7. Serial line: Select the COM port assigned to your USB-to-Serial converter (check Device Manager).
8. Speed (Baud): Set to 9600 (or desired baud rate).
9. Data bits: 8
10. Stop bits: 1
11. Parity: None
12. Flow control: None.

1. C Program for Serial Communication (Transmit & Receive Loopback):
2. Aim: Transmit a string 'Hello from 8051!' and then echo back any character received from the PC.
3. Microcontroller: 8051
4. Crystal Frequency: 11.0592 MHz (for accurate baud rate)
5. Baud Rate: 9600 bps
6. C Code (using Keil C51 syntax):

#include 
#include 
void delay_ms(unsigned int ms) {
    unsigned int i, j;
    for(i = 0; i < ms; i++) {
        for(j = 0; j < 120; j++); // Approx. 1ms delay for 11.0592MHz
    }
}
void UART_Init() {
    TMOD = 0x20; // Timer 1, Mode 2 (8-bit auto-reload) for baud rate
    TH1 = 0xFD; // Reload value for 9600 baud rate
    SCON = 0x50; // Serial Mode 1 (8-bit UART, variable baud rate), REN = 1 (Enable Rx)
    TR1 = 1; // Start Timer 1
    PCON &= 0x7F; // Clear SMOD bit
}
void UART_TxChar(char ch) {
    SBUF = ch; // Load data to SBUF for transmission
    while (TI == 0); // Wait until transmit interrupt flag is set
    TI = 0; // Clear TI flag for next transmission
}
char UART_RxChar() {
    while (RI == 0); // Wait until receive interrupt flag is set
    RI = 0; // Clear RI flag for next reception
    return SBUF; // Return received data
}
void main() {
    char message[] = 'Hello from 8051!\\r\\n'; // Message to send
    char received_char;
    UART_Init(); // Initialize UART
    // Transmit initial message
    for (int i = 0; i < strlen(message); i++) {
        UART_TxChar(message[i]);
        delay_ms(10); // Small delay between characters
    }
    while(1) {
        received_char = UART_RxChar(); // Receive character from PC
        UART_TxChar(received_char); // Echo back character
    }
}

1. Compilation and Flashing:
2. Compile the C code using Keil uVision. Resolve any errors.
3. Flash the generated .hex file to the 8051 microcontroller using your programmer.
4. Execution and Observation:
5. Open the terminal emulator.
6. Reset the 8051 board.
7. Observe the 'Hello from 8051!' message appearing on the terminal.
8. Type characters on your PC's keyboard within the terminal. Observe if the 8051 echoes back the characters you type.

1. Hardware Setup:
2. Connect a push button to the overlineINT0 pin (P3.2) of the 8051. Connect the other end of the button to ground. Use a pull-up resistor (e.g., 10k Ohm) for P3.2 if the internal pull-up is not strong enough or disabled.
3. Connect an LED with a current-limiting resistor (e.g., 220 Ohm) to a general-purpose I/O pin (e.g., P1.0).

1. C Program for External Interrupt:
2. Aim: Toggle an LED connected to P1.0 every time a button connected to overlineINT0 (P3.2) is pressed.
3. Microcontroller: 8051
4. C Code (using Keil C51 syntax):

#include 
sbit LED = P1^0; // Assign P1.0 to LED
void External_Int0_ISR() interrupt 0 // Interrupt Vector 0 for INT0
{
    LED = ~LED; // Toggle the LED
}
void main() {
    IT0 = 1; // Configure INT0 for falling edge triggered
    EX0 = 1; // Enable External Interrupt 0
    EA = 1; // Enable Global Interrupt
    LED = 0; // Initialize LED to OFF state
    while(1) {
        // Main program can do other tasks or simply wait
    }
}

1. Compilation and Flashing: Compile and flash the code to the 8051.
2. Execution and Observation:
3. Press the button connected to P3.2.
4. Observe the LED connected to P1.0. Each press (falling edge) should toggle the LED's state (ON to OFF, OFF to ON).

1. Hardware Setup:
2. Connect an LCD (e.g., 16x2 LCD) to the 8051's ports (typically P2 for data, and some P0/P1 pins for control RS, RW, E). (Assume LCD interfacing is already familiar or use a pre-wired setup on the trainer kit).
3. (No additional external components specific to timer interrupt for this task, as the LCD updates are internal).

1. C Program for Timer Interrupt and LCD Update:
2. Aim: Use Timer 0 interrupt to update a counter on an LCD display every 100 milliseconds.
3. Microcontroller: 8051
4. Crystal Frequency: 11.0592 MHz
5. Timer 0 Mode: Mode 1 (16-bit timer)
6. C Code (using Keil C51 syntax):

#include 
#include 
// LCD control pins - adjust according to your hardware
sbit RS = P2^0; // Register Select
sbit EN = P2^1; // Enable
#define LCD_DATA P2 // Assuming D4-D7 for data (4-bit mode)
unsigned int timer_count = 0;
char lcd_buffer[16]; // Buffer for LCD display
void LCD_Cmd(unsigned char cmd) {
    LCD_DATA = cmd & 0xF0; // Higher nibble
    RS = 0; EN = 1; delay_ms(1); EN = 0; delay_ms(1);
    LCD_DATA = (cmd << 4) & 0xF0; // Lower nibble
    RS = 0; EN = 1; delay_ms(1); EN = 0; delay_ms(1);
}
void LCD_Char(unsigned char dat) {
    LCD_DATA = dat & 0xF0; // Higher nibble
    RS = 1; EN = 1; delay_ms(1); EN = 0; delay_ms(1);
    LCD_DATA = (dat << 4) & 0xF0; // Lower nibble
    RS = 1; EN = 1; delay_ms(1); EN = 0; delay_ms(1);
}
void LCD_Init() {
    delay_ms(20);
    LCD_Cmd(0x02); // Return Home (for 4-bit init)
    LCD_Cmd(0x28); // 4-bit mode, 2 lines, 5x7 dots
    LCD_Cmd(0x0C); // Display ON, Cursor OFF
    LCD_Cmd(0x06); // Increment cursor, No shift
    LCD_Cmd(0x01); // Clear display
    delay_ms(2);
}
void LCD_String(char *str) {
    while (*str) {
        LCD_Char(*str++);
    }
}
void Timer0_ISR() interrupt 1 // Interrupt Vector 1 for Timer 0
{
    TH0 = 0x4C; // Reload TH0 for 100ms
    TL0 = 0x00; // Reload TL0 for 100ms
    timer_count++; // Increment counter on each 100ms interrupt
}
void main() {
    LCD_Init(); // Initialize LCD
    // Configure Timer 0
    TMOD = 0x01; // Timer 0, Mode 1 (16-bit timer)
    TH0 = 0x4C; // Load initial value for 100ms delay
    TL0 = 0x00; // (0x4C00 = 19456 decimal)
    ET0 = 1; // Enable Timer 0 interrupt
    EA = 1; // Enable Global Interrupt
    TR0 = 1; // Start Timer 0
    LCD_String('Counter: '); // Display static text
    while(1) {
        sprintf(lcd_buffer, '%u', timer_count); // Convert integer to string
        LCD_Cmd(0xC0); // Go to second line
        LCD_String(lcd_buffer);
        delay_ms(50);
    }
}

1. Compilation and Flashing: Compile and flash the code to the 8051.
2. Execution and Observation:
3. Observe the LCD display. A counter should be incrementing approximately every 100 milliseconds.
4. Verify the periodicity of updates. If an oscilloscope is available, you could toggle an unused pin in the ISR to visually confirm the interrupt frequency.