Master the process of sending and receiving serial communication protocols

(3), send order. Low starting. (4), baud rate. The time that a data bit (0 or 1) agreed by the transmitting and receiving parties is maintained on the data transmission line. It can also be understood as the number of bits that can be transmitted per second. Commonly used baud rates are 300bit/s, 600bit/s, 2400bit/s, 4800bit/s, and 9600bit/s. (5) The starting signal of communication. The sender should set Tx to 1 when no data is being sent. When sending, first set Tx to 0 and keep 1 bit. The receiver continuously detects Rx. If it is found that Rx is suddenly pulled low (set to 0), it is considered that the sender will send data and start its own timer quickly, thus ensuring the transceiver timer. Synchronization timing.

(6) Stop signal. When the sender sends the last valid bit, it must hold Tx for 1 bit, which is the stop bit.

Ok, the theory is here for the time being, now we have to do an experiment, send a byte from the 51 MCU to the computer serial port debugging assistant. The purpose of this experiment is to master the process of sending and receiving serial communication protocols.

Virtual serial port

Experiment 1, virtual serial port experiment

General-purpose single-chip microcomputers have special serial port pins, 51 are P3.0 and P3.1 respectively. These pins have serial port hardware circuits, so they do not need to set the signal transmission stop. In order to master the protocol, we use other pins to simulate the serial port, so it is also called virtual serial port. Here we choose P1.0, but notice that our 51 MCU needs to send data to the computer, it must go through a serial port to USB device (that is, TTL level is converted to RS232 level), and only limited to our development board P3.0 and P3 .1 is connected to the serial to USB device, so we can short P1.0 to P3.1. The figure below is the schematic of this serial to USB.

Ok, let's go directly to the code.

[cpp]view plaincopy

#include "reg51.h"

/*

Virtualize P1.0 into serial port send pin TX

Send data out at a bit rate of 9600 bit/s

Because the baud rate is 9600bit/s

So the time that me sends one bit is t=1000000us/9600=104us

*/

Sbit TX=P3^1; //P1^0 output TTL signal, need to transfer to rs232 signal, can be connected to P3^1

#define u16 unsigned int // macro definition

#define u8 unsigned char

U8 sbuf;

Bit ti=0;

Void delay(u16 x)

{

While(x--);

}

Void Timer0_Init()

{

TMOD |= 0x01;

TH0=65440/256;

TH0=65440%256;

TR0=0;

}

Void Isr_Init()

{

EA=1;

ET0=1;

}

Void Send_Byte(u8 dat)

{

Sbuf=dat;// By adding the global variable sbuf, you can save the formal parameter dat

TX=0; //A start bit

TR0=1;

While(ti==0); //waiting to send complete

Ti=0; //Clear the send completion flag

}

Void TF0_isr() interrupt 1 //Enter an interrupt every 104us

{

Static u8 i; //record the number of interruptions

TH0=65440/256;

TL0=65440%256;

i++;

If(i>=1 && i<=8)

{

If((sbuf&(1<<(i-1))))==0) // (sbuf&(1<<(i-1)))))

{

TX=0;

}

Else

{

TX=1;

}

}

If(i==9) //stop bit

{

TX=1;

}

If(i==10)

{

TR0=0;

i=0;

Ti=1; //send completed

}

}

Void main()

{

TX=1; // Make TX idle

Timer0_Init();

Isr_Init();

While(1)

{

Send_Byte(65); //0x41

Delay(60000);

}

}

The experiment introduced Timer 0 to control the hold time of each bit on the transmit line. First, the main function enters, and TX is set to 1 to make the transmission line idle. At this time, both the sender and the receiver are idle. Next, initialize timer 0, and set TR0 to 0 to start timer 0. The system is then interrupted and the interrupt system is turned on. Enter the while loop, advanced Send_Byte () function, pass 65 to the formal parameter dat, dat then assign 65 to sbuf, ready to work here. Then TX is set to 0. This is the start bit. Keep this start bit 104us. Then the start timer TR0 is set to 1, and the timer starts counting. When the first time overflowed, it was 104us, and the interrupt was entered. At the same time, the receiver also detected the signal that was suddenly pulled low, so it quickly started its own timer. After entering the interrupt sub-function, first reload the initial value of the timer, then add 1 to i, that is, when i=1, the lowest bit of the data should be sent, a total of 8 bits of data, so use the conditional statement if(i> =1 && i<=8) to determine whether the data bit has been sent. Then send the stop bit through if(i==9), and finally when i=10, that is, the transmission is finished. At this time, the timer should be turned off (the program is also), and i is set to 0 and ti is set to 1 (in order to Jump out of the while (ti==0) loop), and finally set ti to 0 to ensure that the program stays at the next time (whi==0).

On-chip serial port

The above is the virtual serial port. In the above, the pins P3.0 and P3.1 related to the serial port are mentioned. In fact, the 51 MCU comes with the on-chip serial port. How should the serial port be used?

The on-chip serial port supports synchronous mode and asynchronous mode. Simply speaking, synchronous mode means that there is a clock line, while asynchronous mode has no clock line. The clock line here refers to the special transmission of the clock signal by a line during synchronous communication, and this signal is used to keep synchronization with each bit to be transmitted, thus avoiding the time introduced by the timer, for example, in asynchronous communication. error.

The on-chip serial port also supports 8-bit mode and 9-bit mode. As shown below

Where D0-D7 is 8 bits of one byte. The 9-bit mode is just one more bit TB8. This TB8 is used for parity or multi-machine communication. The parity principle is not analyzed. For multi-machine communication, for example, the host only sends data to a device with address 0x02 in the network. At this time, let TB8 be 1, first D0-D7 is address 0x02, then let TB8 be 0, the front D0 -D7 is the data.

The mode of the on-chip serial port is set above, and the baud rate of the serial port is also set.

The baud rate of the on-chip serial port is equal to the 32-divided rate of the overflow rate when Timer 1 is operating in Mode 2. If Timer 1 is to be operated in Mode 2, then TMOD = 0x20. Also be sure to divide by 32, we must also set the initial value of the counter. If the crystal oscillator is 11.0592Mhz, the count pulse of the timer is F=f/12, and the time for each pulse counted by the timer is T=12/f. Let the start of the counter be x, then the number of pulses to be counted once is (256-x). Therefore, when the counting start point is x, the time of overflowing once is t=12/f*(256-x). Then the corresponding overflow rate is 1/t=f/(12*(256-x)). The corresponding baud rate is b=f/(384*(256-x)).

x=256-f/(384*b)

Where f is the crystal frequency, b is the desired baud rate, and x is the value of the count start point TH1 of the timer.

For example, when the crystal oscillator is 11.0592M and the desired baud rate is 9600 bit/s, then TH1=253. Off-topic, we can also calculate that TH1 is always an integer in other common baud rates. Here also explains why the 51.1.0M crystal is used instead of 12M, which ensures that the serial port timing is more accurate, although the accuracy of the timer is sacrificed.

In the second experiment, the off-chip serial port sends one byte.

Ok, let's start our experimental journey now. Look at the code directly.

[cpp]view plaincopy

#include "reg51.h"

#define u16 unsigned int

#define u8 unsigned char

Void delay(u16 x)

{

While(x--);

}

Void Uart_Init () / / serial port initialization

{

SCON=0x50; //8-bit asynchronous mode

TMOD|=0x20; //Timer 1 works 2

TH1=253;//9600bit/s

TR1=1;

}

Void Send_Byte(u8 dat)

{

SBUF=dat; //Start the transmission, only need to send the content to the SBUF register

While(TI==0); //waiting for transmission to complete, because TI is 1 to indicate that the stop bit is being sent

TI=0;

}

Void main()

{

Uart_Init();

While(1)

{

Send_Byte('m');

Delay(60000);

}

}

Experiment 2 Compared with Experiment 1, the code is reduced a lot, and there is no need to consider the cumbersome bit transmission timing. Only need to understand the usage of the various registers SCON, TMOD, TCON, SBUF. TI is the first bit in SCON to send an interrupt request flag. In this mode, the internal hardware is set when the stop bit starts transmitting, and the TI must be cleared by software after the interrupt is interrupted.

Experiment 3, the on-chip serial port sends a string

The above describes how to send a byte, how to send a string or even text? Here we first introduce the concept of the string.

String: Starting from an address in the memory, consecutively store the ASCII code of multiple characters, and store a 0 after the last character. This continuous memory space is called a string, and the last 0 is called the end of the string. symbol. Note that the 0 here and the single quoted 0 are not a concept, and the single quoted 0 refers to the 0 ASCII code.

The relationship between an array and a string: A string is a special case of an array. An array can be used as a string under certain conditions. The C language uses a double quote to describe a string, such as "abcd".

Let's use an experiment to show how to send a string. The goal of our experiment was to print the string "Hello World! First!" to the printer. Directly on the code.

[cpp]view plaincopy

#include "reg51.h"

#define u16 unsigned int

#define u8 unsigned char

Void delay(u16 x)

{

While(x--);

}

Void Uart_Init () / / serial port initialization

{

SCON=0x50; //8-bit asynchronous mode

TMOD|=0x20; //Timer 1 works 2

TH1=253;//9600bit/s

TR1=1;

}

Void Send_Byte(u8 dat) //Serial port sends a byte

{

SBUF=dat; //Start the transmission, only need to send the content to the SBUF register

While(TI==0); //waiting for transmission to complete, because TI is 1 to indicate that the stop bit is being sent

TI=0;

}

Void Send_String(u8 *str) //Send a string *str is the address of the first character of the string

{

Abc: // label

If(*str != 0)

{

Send_Byte(*str);

Str++;

Goto abc;

}

}

Void main()

{

Uart_Init();

While(1)

{

Send_String("Hello World! first!");

Send_Byte(10);

Delay(60000);

Delay(60000);

}

}

Experimental effect