Overview of 8051 Interrupts

The 8051 microcontroller has five interrupt sources:

1. External Interrupt 0 (INT0): Triggered by a signal on pin P3.2.
2. Timer 0 Overflow Interrupt (TF0): Triggered when Timer 0 overflows.
3. External Interrupt 1 (INT1): Triggered by a signal on pin P3.3.
4. Timer 1 Overflow Interrupt (TF1): Triggered when Timer 1 overflows.
5. Serial Communication Interrupt (RI/TI): Triggered by the completion of data reception or transmission.

Interrupt Vector Table

Each interrupt has a specific location in the memory where its service routine begins. This is called the interrupt vector address.

Enabling Interrupts

The 8051 uses the Interrupt Enable (IE) and Interrupt Priority (IP) registers to control interrupt behavior.

• IE Register: Enables or disables specific interrupts.
  • EA: Global enable/disable.
  • ET0: Enable Timer 0 interrupt.
  • EX0: Enable External Interrupt 0.
  • ET1: Enable Timer 1 interrupt.
  • EX1: Enable External Interrupt 1.
  • ES: Enable Serial interrupt.
• IP Register: Sets priority levels for interrupts.
  • PT0: Priority for Timer 0.
  • PX0: Priority for External Interrupt 0.
  • PT1: Priority for Timer 1.
  • PX1: Priority for External Interrupt 1.
  • PS: Priority for Serial interrupt.

Writing an Interrupt Service Routine (ISR)

An ISR is a special function that executes when an interrupt occurs. In C, the interrupt keyword is used to define an ISR, followed by the interrupt vector number.

void timer0_ISR(void) interrupt 1 {
    // Code to execute when Timer 0 overflows
}

Example: Blinking an LED Using Timer 0 Interrupt

In this example, we use Timer 0's interrupt to toggle an LED every 50 milliseconds.

#include <reg51.h>  // Include 8051 header file

void timer0_ISR(void) interrupt 1;

void main() {
    TMOD = 0x01;       // Timer 0 in Mode 1 (16-bit mode)
    TH0 = 0xFC;        // Load high byte for 50ms delay at 12 MHz
    TL0 = 0x66;        // Load low byte for 50ms delay at 12 MHz
    ET0 = 1;           // Enable Timer 0 interrupt
    EA = 1;            // Enable global interrupts
    TR0 = 1;           // Start Timer 0

    while (1) {
        // Main loop doing other tasks
    }
}

void timer0_ISR(void) interrupt 1 {
    P1 = ~P1;          // Toggle Port 1
    TH0 = 0xFC;        // Reload high byte
    TL0 = 0x66;        // Reload low byte
}

Explanation of the Code

1. Timer Initialization: Timer 0 is configured in Mode 1 (16-bit timer mode) using the TMOD register.
2. Interrupt Enabling: The ET0 bit enables the Timer 0 interrupt, and the EA bit enables global interrupts.
3. ISR: The timer0_ISR function toggles Port 1 every time Timer 0 overflows.
4. Reloading Timer: The timer registers (TH0 and TL0) are reloaded in the ISR to maintain consistent timing.

External Interrupt Example

Here’s an example of using External Interrupt 0 to turn an LED on or off based on a button press.

#include <REGX51.H>

void external0_ISR(void) interrupt 0;

void main() {
    IT0 = 1;          // Configure INT0 for edge-triggered mode
    EX0 = 1;          // Enable External Interrupt 0
    EA = 1;           // Enable global interrupts
    P1 = 0x00;        // Initialize Port 1 to OFF

    while (1) {
        // Main loop doing other tasks
    }
}

void external0_ISR(void) interrupt 0 {
  P1 = ~P1;         // Toggle Port 1
}

Applications of Interrupts

Interrupts allow microcontrollers to respond to real-time events efficiently. Common applications include:

1. Real-Time Clock: Generating periodic interrupts for timekeeping.
2. Input Event Handling: Responding to button presses or sensor signals.
3. Communication: Handling data transmission and reception.
4. Multitasking: Managing concurrent tasks in embedded systems.

Conclusion

Interrupt programming is a cornerstone of embedded system development. By understanding how to configure and use interrupts in the 8051, you can create responsive and efficient applications. Practice using different interrupt sources and experiment with priority settings to master this essential skill.

The post Interrupt Programming in 8051 appeared first on Teach Me Microcontrollers!.

Overview of 8051 Timers

The 8051 microcontroller has two timers, Timer 0 and Timer 1. Both timers are 16-bit registers, meaning they can count from 0 to 65,535. They can operate in several modes, allowing for different functionalities:

• Mode 0: 13-bit timer/counter.
• Mode 1: 16-bit timer/counter.
• Mode 2: 8-bit auto-reload timer/counter.
• Mode 3: Split timer mode (Timer 0 only).

Timer Registers

Each timer has the following associated registers:

• THx: High byte of the timer.
• TLx: Low byte of the timer.
• TMOD: Timer Mode register for selecting the mode of operation.
• TCON: Timer Control register for starting, stopping, and monitoring the timer.

Configuring the Timer

The steps to use a timer in 8051 are as follows:

1. Select the Mode: Use the TMOD register to configure the desired mode for the timer.
   • When selecting a timer mode, avoid directly overwriting the TMOD register, as it controls both Timer 0 and Timer 1. Instead, use a bitwise operation to preserve the settings of the other timer. For example, to set Timer 0 to Mode 1 without affecting Timer 1:
     

     TMOD = (TMOD & 0xF0) | 0x01; // Set Timer 0 to Mode 1

     Here:

     • (TMOD & 0xF0) clears the lower 4 bits (related to Timer 0) while retaining the upper 4 bits (related to Timer 1).
     • | 0x01 sets Timer 0 to Mode 1.
2. Load Initial Value: Load the initial count value into the THx and TLx registers.
3. Start the Timer: Set the appropriate bit in the TCON register to start the timer.
4. Monitor or Interrupt: Poll the timer overflow flag or use an interrupt to handle the overflow event.

Example: Creating a Delay Using Timer 0

In this example, we’ll create a delay of approximately 1 millisecond using Timer 0 in Mode 1.

#include <reg51.h>  // Include 8051 header file

void delay_ms(unsigned int ms); // this will be a new delay function using timer

void main() {
    while (1) {
        P1 = 0xFF;  // Turn ON all LEDs connected to Port 1
        delay_ms(1000);  // 1-second delay
        P1 = 0x00;  // Turn OFF all LEDs connected to Port 1
        delay_ms(1000);  // 1-second delay
    }
}

void delay_ms(unsigned int ms) {
    unsigned int i;
    for (i = 0; i < ms; i++) {
        TMOD = (TMOD & 0xF0) | 0x01;  // Timer 0 in Mode 1 (16-bit mode)
        TH0 = 0xFC;   // Load high byte (for 1 ms delay at 12 MHz)
        TL0 = 0x66;   // Load low byte (for 1 ms delay at 12 MHz)
        TR0 = 1;      // Start Timer 0
        while (TF0 == 0);  // Wait for overflow flag
        TR0 = 0;      // Stop Timer 0
        TF0 = 0;      // Clear overflow flag
    }
}

Explanation of the Code

• Timer Mode Selection: The TMOD register is set using bitwise operations to select Timer 0 in Mode 1 (16-bit timer mode) without affecting Timer 1.
• Timer Initialization: The values 0xFC66 are loaded into TH0 and TL0, respectively. This corresponds to a delay of 1 millisecond at a 12 MHz clock frequency.
• Starting and Stopping the Timer: The TR0 bit in the TCON register is used to start and stop Timer 0.
• Overflow Flag: The TF0 flag in the TCON register is polled to check when the timer overflows.

Applications of Timers

Timers in the 8051 can be used for:

1. Creating Time Delays: As demonstrated in the example above.
2. Pulse Width Modulation (PWM): Generating variable-width pulses for motor control or LED dimming.
3. Event Counting: Counting external events when configured in counter mode.
4. Baud Rate Generation: Used in conjunction with serial communication for baud rate control.

Timer Modes in Detail

1. Mode 0: A 13-bit timer that counts from 0x0000 to 0x1FFF.
2. Mode 1: A full 16-bit timer that counts from 0x0000 to 0xFFFF.
3. Mode 2: An 8-bit timer with auto-reload. The value in THx is reloaded into TLx after overflow.
4. Mode 3: Splits Timer 0 into two 8-bit timers. Timer 1 remains inactive in this mode.

Conclusion

Timers are versatile peripherals that greatly enhance the functionality of the 8051 microcontroller. Whether you're creating delays, measuring time intervals, or generating pulses, understanding how to configure and use timers is essential for embedded development. Experiment with different timer modes and applications to fully harness the power of the 8051 microcontroller!

The post Using Timers in 8051 appeared first on Teach Me Microcontrollers!.

Here, I will be skipping the basics of serial communications and proceed directly on how to use it with 8051 and the C language. In particular, we will be focusing on the RS-232 protocol.

8051 Registers for Hardware UART

8051 contains a number of registers that give the microcontroller a certain feature. This is also true with other MCUs like PIC, STM32, and AVR (Arduino). To be able to use the 8051’s serial port, we need to use a number of registers.

Serial Port Control

The first register is the SCON or Serial Port Control Register. It is an 8-bit register with each bit having their own use:

The important bits here are SM0 and SM1 as they set the serial mode of 8051. There are four modes as shown above (NOTE 1).

For this example, we will be using Mode 1 and leave the rest of the bits as clear. However, take special note of bit T1 as we will be also using that later.

Timer/Counter Mode Control

Serial communication requires that both transmitter and receiver are in sync. For the RS232 protocol, the only way to sync is that both TX and RX have the same baud rate. The 8051 has its own baud rate generator and requires the use of one of the two timer modules.

And so, the next register that we need is the TMOD or Timer/Counter Mode Control register. Here are the bits of this register:

The register is divided into two parts, depending on which timer we will use. For this tutorial, we will be using Timer 1. Hence, our concern is only the high byte of TMOD. We are selecting Mode 2; we set bit M1, and clear bit M0. More on this mode later below.

Power Control Register

Next, we have the PCON register. We only have one bit to use here and that’s the SMOD bit:

When SMOD is 1, the baud rate is doubled. Otherwise, the baud rate stays the same.

Timer/Counter Control Register

Since the serial port relies on Timer 1, we need to enable it by setting the TR1 bit of the TCON register:

Other Registers

Finally, we have registers TH0, TL0, TH1, and TL1. These registers represent the high byte and low byte of 16-bit timers 0 and 1. Recall that we choose Timer 1 via TMOD register. Moreover, we choose Mode 2: 8-bit auto-reload. This mode allows us to modify only TH1 since TL1 is loaded from TH1 at the beginning of each cycle.

Baud Rate Calculation

The 8051 baud rate formula is:

Where FOSC is the 8051's crystal oscillator and TH1 the high byte value of Timer 1. What we want is to specify the value of TH1 for our target baud rate. So, reversing the formula:

For example, to achieve a baud rate of 2400 with a 12 MHz crystal, your TH1 value should be (SMOD=0):

Remember that TH1 is an 8-bit register and holds integers only.

The actual baud rate is then:

It’s not exactly 2400 but with just 0.16% of deviation, it works.

C Code for 8051 Serial Interfacing

Here’s a C code that prints out Hello World! through the serial port at 2400 baud:

#include <reg51.h>
#include <stdio.h>

#define FOSC 12000000

void serial_init(unsigned long int baud)
{
  unsigned long int divisor = 256 - (FOSC/(384*baud));
  SCON = 0x40;                      
  TMOD = 0x20;                           /* TMOD: timer 1, mode 2, 8-bit reload      */
  TH1 = divisor;			 /* load divisor to Timer 1 High Byte (TH1)  */
  TR1   = 1;                             /* TR1:  timer 1 run                        */
  TI    = 1;                             /* TI:   set TI to send first char of UART  */
}
	
void main (void)
{
  serial_init(2400);
  while(1)
  {
    printf("Hello world!\n");
  }
}

Here we define a function that initializes the hardware UART:

void serial_init(unsigned long int baud) 
{ 
  unsigned long int divisor = 256 - (FOSC/(384*baud)); 
  SCON = 0x40; 
  TMOD = 0x20;       /* TMOD: timer 1, mode 2, 8-bit reload */ 
  TH1 = divisor;     /* load divisor to Timer 1 High Byte (TH1) */ 
  TR1 = 1;           /* TR1: timer 1 run */ 
  TI = 1;            /* TI: set TI to send first char of UART */ 
}

This function is called in main() where its parameter is the desired baud rate:

void main (void) 
{ 
   serial_init(2400);
   while(1) 
   {
       printf("Hello world!\n"); 
   } 
}

Also notice that we use the function printf() which belongs to the stdio library, hence the added definition at the top of the code. Remember bit TI in SCON? The printf() function uses that bit to determine when to start or stop sending characters on the serial port. If TI is not set, the print() function will not work.

While we were able to make it work at 2400 baud, other baud rates may not work.

For example, choosing 9600 baud will generate the following value for TH1:

Calculating the actual baud rate using this TH1 value:

That’s an 8.5% difference from the desired baud rate of 9600! Your options for this one would be to try changing the crystal oscillator, use a different timer and/or apply the SMOD bit.

You could try Keil’s baud rate generator to determine the best oscillator value for your target baud rate. For example, using 11.0952 MHz at mode 2 and SMOD = 0 generates a rate of 9,631.25 which is at 0.33% deviation for the standard 9600 baud.

That's it for this tutorial! See you in the next part of this 8051 series.

The post 8051 Serial Interface Tutorial appeared first on Teach Me Microcontrollers!.

Review on Seven Segment Displays

A seven-segment display consists of LEDs in parallel. This way, each LED or "segment" can be turned on or off. Recall that an LED emits light when the anode voltage is more positive than the cathode voltage.

In a common cathode seven-segment display, each anode of the LEDs is accessible while all LED cathodes connect into one pin. The anode pins are given labels A to G. The opposite is true for a common anode display. Here, we will limit ourselves to common cathode displays.

To display a number in a seven-segment display, the correct LEDs should light up. Hence if each anode connects to a pin in the 8051 microcontroller, digits 0 to 9 corresponds to an 8-bit value of a port.

Here’s a table showing all 8-bit values for digits 0 to 9, assuming segment A wires to the port’s LSB.

Based on the table above, we create a function that accepts a digit as a parameter and returns the corresponding 8-bit value.

int toSevenSeg(int num)
{
  switch(num){
    case 0:
        return 0x3F;
        break;
    case 1:
        return 0x06;
        break;
    case 2:
        return 0x5B;
        break;
    case 3:
        return 0x4F;
        break;
    case 4:
        return 0x66;
        break;
    case 5:
        return 0x6D;
        break;
    case 6:
        return 0x7C;
        break;
    case 7:
        return 0x07;
        break;
    case 8: 
        return 0x7F;
        break;
   case 9:
        return 0x67;
        break;
   default:
        return 0x64; //return dash if invalid
   }
}

The function returns an integer and so we can pass it directly to any port.

P2 = toSevenSeg(x);

8051 Code for Interfacing with One Display

The example code below shows the digits 0 to 9 in succession with a second interval in between.

#include<reg51.h>           // special function register declarations
                            // for the intended 8051 derivative

// delay subroutine
void DELAY_ms(unsigned int ms_Count)
{
    unsigned int i,j;
    for(i=0;i<ms_Count;i++)
    {
        for(j=0;j<100;j++);
    }
}

// seven-segment converter routine
int toSevenSeg(int num)
{
  switch(num){
    case 0:
        return 0x3F;
        break;
    case 1:
        return 0x06;
        break;
    case 2:
        return 0x5B;
        break;
    case 3:
        return 0x4F;
        break;
    case 4:
        return 0x66;
        break;
    case 5:
        return 0x6D;
        break;
    case 6:
        return 0x7C;
        break;
    case 7:
        return 0x07;
        break;
    case 8: 
        return 0x7F;
        break;
   case 9:
        return 0x67;
        break;
   default:
        return 0x64; //return dash if invalid
   }
}
// main routine
int main() 
{
    unsigned int x;
    while(1)
    {
        //display digits 0 to 9 with 1 second interval
        for(x=0;x<10;x++)
        {
	    P2 = toSevenSeg(x);
	    DELAY_ms(1000);
	}
    }
    return (0);
}

8051 Code for Interfacing with Multiple Displays

We can use multiple seven-segment displays by connecting the common cathode pin to a microcontroller pin. This way, we can multiplex the displays using the common cathode pin as the switch. The switching should be fast enough to trick our eyes that all displays are on simultaneously instead of alternating. This is also called persistence of vision.

Here is a code that uses two seven-segment displays to count from 00 to 99.

#include<reg51.h>           // special function register declarations
                            // for the intended 8051 derivative
sbit SW1 = P3^0;
sbit SW2 = P3^1;

// speed between display switch
#define SWITCH_SPEED 40
// speed between counts
#define COUNT_SPEED 15

// delay subroutine
void DELAY_ms(unsigned int ms_Count)
{
    unsigned int i,j;
    for(i=0;i<ms_Count;i++)
    {
        for(j=0;j<100;j++);
    }
}

// seven-segment converter routine
int toSevenSeg(int num)
{
  switch(num){
    case 0:
        return 0x3F;
        break;
    case 1:
        return 0x06;
        break;
    case 2:
        return 0x5B;
        break;
    case 3:
        return 0x4F;
        break;
    case 4:
        return 0x66;
        break;
    case 5:
        return 0x6D;
        break;
    case 6:
        return 0x7C;
        break;
    case 7:
        return 0x07;
        break;
    case 8: 
        return 0x7F;
        break;
   case 9:
        return 0x67;
        break;
   default:
        return 0x64;  //return dash if invalid
   }
}
// main routine
int main() 
{
    unsigned int ones, tens, counter;
    ones = 0;
    tens = 0;
    counter = 0;
    while(1)
    {
	SW1 = 1;
	SW2 = 0;
	P2 = toSevenSeg(ones);
	DELAY_ms(SWITCH_SPEED);
	SW1 = 0;
	SW2 = 1;
	P2 = toSevenSeg(tens);
	DELAY_ms(SWITCH_SPEED);
	counter++;
	if(counter > COUNT_SPEED)
        {
	    ones++;
	    counter = 0;
	}
	if(ones > 9)
        { 
	    tens++;
	    ones = 0;
	}
	if(tens > 9) tens = 0;
   }
   return (0);
}

The SWITCH_SPEED and COUNT_SPEED for the code above should be chosen after testing the actual physical circuit. SWITCH_SPEED is the time interval between turning on one display and then turning on the other. COUNT_SPEED is the speed of the counting.

For questions regarding this tutorial, please drop a comment below!

The post Interfacing Seven Segment Displays with 8051 appeared first on Teach Me Microcontrollers!.

The first part of this tutorial series shows how to start programming with the 8051 using Keil's C51 compiler. Here you'll learn how to flash an LED and use a switch.

Setting Up

1. Download and install Keil for 8051
2. Open Keil, create a new project and name it. Here, we name the project Blinky.

3. At this point, you can select any 8051 derivatives. We limit ourselves to those found in Proteus ISIS. One of them is AT80C51RD2 and so we select it.

4. A dialog will ask you about including the STARTUP.A51 file which does the register aliasing for us. Naturally, choose Yes.

5. Each project requires one main.c file. To add such file, right-click on Source Group 1 folder, select Add New Item...

6. Select .c file extension and name the file main.c

7. At this point we can start coding. For first-timers, I suggest you paste the following code to main.c and save. The explanation of this code comes in the later section.

#include<reg51.h>           // special function register declarations
                            // for the intended 8051 derivative

// delay subroutine
void DELAY_ms(unsigned int ms_Count)
{
    unsigned int i,j;
    for(i=0;i<ms_Count;i++)
    {
        for(j=0;j<100;j++);
    }
}


// main routine
int main()
{
    while(1)
    {
        P2 = 0x01;                 // Turn ON LED at P2.0
        DELAY_ms(500);        // 0.5 second delay

        P2 = 0x00;                 // Turn OFF LED at P2.0
        DELAY_ms(500);        // 0.5 second delay
    }
    return (0);
}

8. Go to Project -> Options for Target.. or Alt + F7

9. Go to Output tab, check the Create HEX file checkbox and then press Ok to close.

10. Build target or Press F7

11. Look at Build Output for any errors

12. If the build is successful, the hex file will be at Project Name > Objects > Project Name.hex
13. It's time to simulate the code we just created. For us, we use Labcenter Electronics' Proteus ISIS. Open Proteus ISIS, use the component picker to find 80C51. This is one of the many equivalent models for the AT80C51RD2.
14. Right click on 80C51, on Program File field, paste the location of the .hex file

15. Press Play. Pin P2.0 should now be flashing

Flashing a LED

The I/O pins for the 8051 microcontrollers are grouped into ports similar to PICs and AVR microcontrollers. Each pin in a port can be set or clear by writing values to the port.

P2 = 0x01;            // Turn ON LED at P2.0         
DELAY_ms(500);        // 0.5 second delay         

P2 = 0x00;            // Turn OFF LED at P2.0
DELAY_ms(500);        // 0.5 second delay         

Here, we write 0x01 to set P2.0 followed by a half-second delay. We then cleared that same pin by writing 0x00.

The DELAY routine is needed in order for us to see the flashing. There's no built-in delay() function unlike in Arduino or XC8 so we had to build one:

// delay subroutine
void DELAY_ms(unsigned int ms_Count)
{
    unsigned int i,j;
    for(i=0;i<ms_Count;i++)
    {
        for(j=0;j<100;j++);
    }
}

The 8051 has an instruction cycle speed of

This means for a 12 MHz oscillator (the default oscillator for 80C51 in Proteus), each instruction is executed in 1 microsecond. In the DELAY routine above, an inner loop counts for a hundred microseconds while an outer loop counts for an interval given by the user in milliseconds. For example, if ms_Count is 500, and a for loop takes about 10 cycles, then the routine will count 500 x 100 x 10 microseconds --- equivalent to half a second.

Another way is to directly set or clear the pin. To do that, we need to declare a variable representing a single pin.

sbit LED = P2^0

The sbit keyword defines a bit within a register (SFR). It may be used like any of these three:

sbit name = sfr-name ^ bit-position;
sbit name = sfr-address ^ bit-position;
sbit name = sbit-address;

Here, our SFR (special function register) is P2 and the bit position is 0.

So to set or clear a pin, we can now use:

LED = 1; 		// Turn ON LED at P2.0 
DELAY_ms(500);		// 0.5 second delay
            
LED = 0; 		// Turn OFF LED at P2.0
DELAY_ms(500);		// 0.5 second delay

To strobe LEDs, we can simply write values to the P2 register in succession.

#include <reg51.h>       // special function register declarations
                        // for the intended 8051 derivative

// delay subroutine
void DELAY_ms(unsigned int ms_Count)
{
    unsigned int i,j;
    for(i=0;i<ms_Count;i++)
    {
        for(j=0;j<100;j++);
    }
}

// main routine
int main() 
{
    while(1)
    {
        P1 = 0x01; 		// Turn ON LED at P2.0 
        DELAY_ms(500);		// 0.5 second delay
        
        P1 = 0x02; 		// Turn OFF LED at P2.0
        DELAY_ms(500);		// 0.5 second delay
			
	P1 = 0x04; 		// Turn ON LED at P2.0 
        DELAY_ms(500);		// 0.5 second delay
        
        P1 = 0x08; 		// Turn OFF LED at P2.0
        DELAY_ms(500);		// 0.5 second delay
			
	P1 = 0x10; 		// Turn ON LED at P2.0 
        DELAY_ms(500);		// 0.5 second delay
        
        P1 = 0x20; 		// Turn OFF LED at P2.0
        DELAY_ms(500);		// 0.5 second delay
			
	P1 = 0x40; 		// Turn OFF LED at P2.0
        DELAY_ms(500);		// 0.5 second delay
			
	P1 = 0x80; 				// Turn OFF LED at P2.0
        DELAY_ms(500);		// 0.5 second dela
    }
    return (0);
}

Of course, we can also use other ports by simply replacing P1 with P0, P2, or P3.

Using a Switch

Unlike other microcontrollers, the 8051 doesn't use data direction registers. Hence, you can make a pin an output or input pin directly. You can attach a switch like this:

and check its state using a simple if-else statement:

#include <reg51.h> // special function register declarations 
                   // for the intended 8051 derivative 
sbit LED = P2^0;
sbit SW = P1^0; 
// delay subroutine 
void DELAY_ms(unsigned int ms_Count) { 
  unsigned int i,j;
  for(i=0;i<ms_Count;i++) {
     for(j=0;j<100;j++); 
  } 
} 
// main routine
int main() { 
  while(1) {
    if(SW == 0){
      LED = 1; 
    }else{ 
      LED = 0; 
    } 
  } 
  return (0); 
}

Here, when the switch at P1.0 is closed, the LED at P2.0 turns on. Otherwise, the LED turns off.

That's it for a short introduction to 8051 microcontroller programming in C. On the next iteration, we'll go deeper into some registers of the 8051 and create interfacing projects using LCDs, sensors, and more!

The post Introduction to 8051 Microcontroller using C appeared first on Teach Me Microcontrollers!.