Introduction to the method of realizing serial port simulation by microcontroller software

The analog serial port uses the two input and output pins of 51, such as P1.0 and P1.1, to set 1 or 0 to represent high and low levels, which is the bit in serial communication. If the start bit is low level, it is set to 0, and if the stop bit is high level, it is set to 1. Various data bits and check bits are set to 1 or 0 according to the situation. As for the baud rate of serial communication, it is just the duration of each bit level. The higher the baud rate, the shorter the duration. If the baud rate is 9600BPS, the transmission time of each bit is 1000ms/9600=0.104ms, that is, the delay between bits is 0.104 milliseconds. The delay of the microcontroller is achieved by executing several instructions, because each instruction is 1-3 instruction cycles, that is, the delay is carried out through several instruction cycles. The microcontroller often uses a crystal oscillator of 11.0592M. Now I want to tell you the origin of this strange number. With this frequency, the time of each instruction cycle is (12/11.0592)us. So how many instruction cycles are needed for each bit of 9600BPS?
Instruction cycle s = (1000000/9600)/(12/11.0592) = 96, which is exactly an integer. If it is 4800BPS, it is 96x2=192, and if it is 19200BPS, it is 48. Other baud rates are not counted, and they are all exactly integer instruction cycles. Isn't it wonderful? As for
other crystal oscillator frequencies, you can calculate them by yourself.

Now let's take the 11.0592M crystal oscillator as an example to discuss three methods of simulating serial ports.

Method 1: Delay method

Through the above calculation, we know that each bit of the serial port needs a delay of 0.104 seconds, and 96 instruction cycles can be executed in the middle.
#define uchar unsigned char
sbit P1_0 = 0x90;
sbit P1_1 = 0x91;
sbit P1_2 = 0x92;
#define RXD P1_0
#define TXD P1_1
#define WRDYN 44 //Write delay
#define RDDYN 43 //Read delay

//Write a byte to the serial port
void WByte(uchar input)
{
uchar i=8;
TXD=(bit)0; //Send start
bit
Delay2cp(39);
//Send 8-bit data bit
while(i--)
{
TXD=(bit)(input&0x01); //Transmit low bit first
Delay2cp(36);
input=input>>1;
}
//Send check bit (none)
TXD=(bit)1; //Send end
bit
Delay2cp(46);
}

//Read a byte from the serial port
uchar RByte(void)
{
uchar Output=0;
uchar i=8;
uchar temp=RDDYN;
//Send 8-bit data
Delay2cp(RDDYN*1.5); //Note here, wait for the start bit
while(i--)
{
Output >>=1;
if(RXD) Output =0x80; //Receive the low bit first
Delay2cp(35); //(96-26)/2, the loop
takes up 26 instruction cycles in total
}
while(--temp) //Search for the end bit within the specified
time.
{
Delay2cp(1);
if(RXD)break; //Exit after receiving the end bit
}
return Output;
}

//Delay program*
void Delay2cp(unsigned char i)
{
while(--i); //Exactly two
instruction cycles.
} This method has certain difficulties in receiving, mainly because the sampling positioning needs to be more accurate, and the number of instruction cycles for each statement

must also be known .
This method can simulate several serial ports, and many people use it in practice. However, if you use Keil
C, I do not recommend this method. The above program has been tested on three single-chip computers: P89C52, AT89C52, and W78E52.

Method 2: Counting

method The counter of 51 increases by 1 in each instruction cycle until it overflows, and the hardware sets the overflow flag. In this way, we can
use the method of presetting the initial value to make the machine overflow once every 96 instruction cycles, and the program constantly queries the overflow flag to decide whether to
send or receive the next bit.

//Counter initialization
void S2INI(void)
{
TMOD =0x02; //Counter 0, mode 2
TH0=0xA0; //Pre-value is 256-96=140, hexadecimal A0
TL0=TH0;
TR0=1; //Start counting
TF0=0;
}

void WByte(uchar input)
{
//Send start bit
uchar i=8;
TR0=1;
TXD=(bit)0;
WaitTF0();
//Send 8-bit data
while(i--)
{
TXD=(bit)(input&0x01); //Transmit low bit first
WaitTF0();
input=input>>1;
}
//Send check bit (none)
//Send end bit
TXD=(bit)1;
WaitTF0();
TR0=0;
}
//Query counter overflow flag
void WaitTF0( void )
{
while(!TF0);
TF0=0;
}
For the receiving program, you can refer to the next method and will not write it out. I personally feel that this method is good. Both receiving and sending
are very accurate. In addition, there is no need to calculate the number of instruction cycles for each statement.

Method 3: Interrupt method The

interrupt method is similar to the counter method, except that an interrupt is generated when the counter overflows. The user can
set a flag in the interrupt program, and the program continuously queries the flag to decide whether to send or receive the next bit. Of course, the interrupt needs to be initialized in the program
, and the interrupt program is written at the same time. This program uses the Timer0 interrupt.
#define TM0_FLAG P1_2 //Set the transmission flag
//Initialize the counter and interrupt
void S2INI(void)
{
TMOD =0x02; //Counter 0, mode 2
TH0=0xA0; //Preset value is 256-96=140, hexadecimal A0
TL0=TH0;
TR0=0; //
Start using it when sending or receiving
TF0=0;
ET0=1; //Enable
timer 0 interrupt
EA=1; //Interrupt enable
master switch
}

//Receive a character
uchar RByte()
{
uchar Output=0;
uchar i=8;
TR0=1; //Start Timer0
TL0=TH0;
WaitTF0(); //Wait for the start
bit
//Send 8 data bits
while(i--)
{
Output >>=1;
if(RXD) Output =0x80; //Receive the low bit first
WaitTF0(); //Inter-bit delay
}
while(!TM0_FLAG) if(RXD) break;
TR0=0; //Stop
Timer0
return Output;
}
//Interrupt 1 handler
void IntTimer0() interrupt 1
{
TM0_FLAG=1; //Set flag.
}
//Query transmission flag
void WaitTF0( void )
{
while(!TM0_FLAG);
TM0_FLAG=0; //Clear flag
}
The interrupt method is also the method I recommend, which is similar to the counting method. The sending program refers to the counting method, which is believed to be a very easy
task.
It should also be noted that the serial port mentioned in this article is the usual three-wire asynchronous communication serial port (UART), which only uses RXD, TXD, and GND.
//****************************************************************