MCU Universal Simulation Serial Port C Program

    //------------------------------------------------ -----------------------

　　// UART.C

　　// General simulation serial port program

　　// Resource requirements: one hardware counter, two I/O ports

　　// Set the hardware counter's count time to three times the baud rate

　　// Define two I/O ports for sending and receiving, used in receive() and transmit(char) respectively

　　// Set up a dedicated receive buffer to store received data

　　// Note: The timer must be set according to the baud rate;

　　// Each time communication starts, the initialization function init_uart() must be called

　　//------------------------------------------------ -------------------------------------------------- ---------------

　　//----------------------------------Pin definition, library function declaration-------------------------------------------------

　　#include

　　#include

　　//Port definition

　　sbit RXD3=P1^0;

　　sbit TXD3=P1^1;

　　//----------------------------------------------Variable declaration-----------------------------------------------------

　　#define IN_BUF_SIZE 10 //Input buffer length definition

　　#define TRUE 1

　　#define FALSE 0

　　static unsigned char inbuf[IN_BUF_SIZE]; //input buffer

　　static unsigned char qin = 0;

　　static unsigned char qout = 0;

　　static char flag_rx_waiting_for_stop_bit;

　　static char flag_rx_off;

　　static char rx_mask;

　　static char flag_rx_ready;

　　static char flag_tx_ready;

　　static char timer_rx_ctr;

　　static char timer_tx_ctr;

　　static char bits_left_in_rx;

　　static char bits_left_in_tx;

　　static char rx_num_of_bits;

　　static char tx_num_of_bits;

　　static char internal_rx_buffer;

　　static char internal_tx_buffer;

　　static char user_tx_buffer;

　　//----------------------------------Hardware related function declarations------------------------------------------------

　　bit get_rx_pin_status(); //1. Returns the value returned by the receive pin (0 or 1)

　　void set_tx_pin_high(void); //2. Set the transmit pin high, output 1

　　void set_tx_pin_low(); //3. Set the transmit pin to low, output 0

　　void timer_set(); //4. Set the timer value to three times the baud rate

　　void set_timer_interrupt(); //5. Enable timer interrupt

　　void idle(); //6. Execute while waiting for port input, modify according to specific application

　　//-----------------------------------Declare hardware-independent functions-------------------------------------------

　　void flush_input_buffer( void ); // Clear the receive buffer

　　char kbhit( void ); // Determine whether the data is received normally

　　char get_char( void ); // Read a data from the receive buffer

　　void turn_rx_on( void ); // Start receiving function

　　void turn_rx_off( void ); // End receiving function

　　extern void put_char( char ); // Send a data to the sender.

　　void timer_isr(void); //interrupt processing function

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: set_tx_pin_high

　　// Function description: Set the serial port sending port to high, which is related to the hardware

　　//------------------------------------------------ -------------------------------------------------- ------

　　void set_tx_pin_high( void )

　　{

　　TXD3=1;

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: set_tx_pin_low

　　// Function description: Set the serial port sending port to low, which is related to the hardware

　　//------------------------------------------------ -------------------------------------------------- ------

　　void set_tx_pin_low( void )

　　{

　　TXD3=0;

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: get_rx_pin_status

　　// Function description: Returns the status of the receiving port, high is 1, low is 0, related to the hardware

　　//------------------------------------------------ -------------------------------------------------- ------

　　bit get_rx_pin_status()

　　{

　　return(RXD3);

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: timer_set

　　// Function description: Set the timer working status, related to the hardware

　　//------------------------------------------------ -------------------------------------------------- ------

　　void timer_set()

　　{

　　TMOD=0x22; //Timer 1 is working mode 2 (8-bit automatic reload), 0 is mode 2 (8-bit automatic reload)

　　PCON=0x00;

　　TR0=0; //Start using when sending or receiving

　　TF0=0;

　　TH0=(256-96); //9600bps is 1000000/9600=104.167 microseconds. The timer to be executed is

　　//104.167*11.0592/12= 96

　　TL0=TH0;

　　ET0=1;

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: set_timer_interrupt

　　// Function description: Enable timer interrupt, related to hardware

　　//------------------------------------------------ -------------------------------------------------- ------

　　void set_timer_interrupt()

　　{

　　EA=1;

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: IntTimer0

　　// Function description: Timer interrupt function, related to hardware, but no processing is done, directly call the general interrupt processing function

　　//------------------------------------------------ -------------------------------------------------- ------

　　void IntTimer0() interrupt 1

　　{

　　timer_isr(); //Call interrupt processing function

　　}[page]

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: idle

　　// Function description: The execution program when waiting for the timer interrupt is related to the specific application

　　//------------------------------------------------ -------------------------------------------------- ------

　　void idle()

　　{

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: timer_isr

　　// Function description: Interrupt processing function, hardware-independent, general function

　　//------------------------------------------------ -------------------------------------------------- ------

　　void timer_isr(void) /*interrupt service routine*/

　　{

　　char mask, start_bit, flag_in;

　　//Sending program

　　if ( flag_tx_ready )

　　{

　　if ( --timer_tx_ctr<=0 )

　　{

　　mask = internal_tx_buffer&1;

　　internal_tx_buffer >>= 1;

　　if ( mask )

　　{

　　set_tx_pin_high();

　　}

　　else

　　{

　　set_tx_pin_low();

　　}

　　timer_tx_ctr = 3;

　　if ( --bits_left_in_tx<=0 )

　　{

　　flag_tx_ready = FALSE;

　　}

　　}

　　}

　　// Receiving procedure

　　if ( flag_rx_off == FALSE )

　　{

　　if (flag_rx_waiting_for_stop_bit)

　　{

　　if ( --timer_rx_ctr<=0 )

　　{

　　flag_rx_waiting_for_stop_bit = FALSE;

　　flag_rx_ready = FALSE;

　　internal_rx_buffer &= 0xFF;

　　if (internal_rx_buffer!=0xC2)

　　{

　　inbuf[qin] = internal_rx_buffer;

　　if ( ++qin>=IN_BUF_SIZE )

　　{

　　qin = 0;

　　}

　　}

　　}

　　}

　　else // rx_test_busy receiving busy

　　{

　　if ( flag_rx_ready == FALSE )

　　{

　　start_bit = get_rx_pin_status();

　　// Determine the starting position

　　if ( start_bit == 0 )

　　{

　　flag_rx_ready = TRUE;

　　internal_rx_buffer = 0;

　　timer_rx_ctr = 4;

　　bits_left_in_rx =

　　rx_num_of_bits;

　　rx_mask = 1;

　　}

　　}

　　else

　　{

　　if ( --timer_rx_ctr<=0 )

　　{

　　timer_rx_ctr = 3;

　　flag_in =

　　get_rx_pin_status();

　　if ( flag_in )

　　{

　　internal_rx_buffer |= rx_mask;

　　}

　　rx_mask <<= 1;

　　if ( --bits_left_in_rx<=0 )

　　{

　　flag_rx_waiting_for_stop_bit = TRUE;

　　}

　　}

　　}

　　}

　　}

　　}[page]

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: init_uart

　　// Function description: Initialize the asynchronous serial port, independent of hardware, general function

　　//------------------------------------------------ -------------------------------------------------- ------

　　void init_uart( void )

　　{

　　flag_tx_ready = FALSE;

　　flag_rx_ready = FALSE;

　　flag_rx_waiting_for_stop_bit = FALSE;

　　flag_rx_off = FALSE;

　　rx_num_of_bits = 10;

　　tx_num_of_bits = 10;

　　set_tx_pin_low();

　　timer_set();

　　set_timer_interrupt(); // Enable timer interrupt

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: get_char

　　// Input parameters: None

　　// Output parameter: ch, receive data

　　// Function description: Receive a byte, regardless of hardware, general function

　　//------------------------------------------------ -------------------------------------------------- ------

　　char get_char( void )

　　{

　　char ch;

　　do

　　{

　　while ( qout==qin )

　　{

　　idle();

　　}

　　ch = inbuf[qout] & 0xFF;

　　if ( ++qout>=IN_BUF_SIZE )

　　{

　　qout = 0;

　　}

　　}

　　while ( ch==0x0A || ch==0xC2 );

　　return( ch );

　　}

　　//------------------------------------------------ ----------------------------------------

　　// Function name: put_char

　　// Function description: Receive a byte, regardless of hardware, general function

　　//------------------------------------------------ ----------------------------------------

　　void put_char( char ch )

　　{

　　while ( flag_tx_ready );

　　user_tx_buffer = ch;

　　//Wake up the serial port

　　timer_tx_ctr = 3;

　　bits_left_in_tx = tx_num_of_bits;

　　internal_tx_buffer = (user_tx_buffer<<1) | 0x200;

　　flag_tx_ready = TRUE;

　　}

　　//------------------------------------------------ -------------------------------------------------- -----

　　// Function name: flush_input_buffer

　　// Function description: Initialize the buffer, independent of hardware, general function

　　//------------------------------------------------ -------------------------------------------------- ------

　　void flush_input_buffer(void)

　　{

　　qin = 0;

　　qout = 0;

　　}

　　//------------------------------------------------ ----------------------------------------

　　// Function name: kbhit

　　// Function description: Determine whether the receiving pointer is equal to the sending pointer. It has nothing to do with the hardware. It is a general function.

　　//------------------------------------------------ ----------------------------------------

　　char kbhit( void )

　　{

　　return( qin!=qout );

　　}

　　//------------------------------------------------ ----------------------------------------

　　// Function name: turn_rx_on

　　// Function description: Start receiving, independent of hardware, general function

　　//------------------------------------------------ ----------------------------------------

　　void turn_rx_on( void )

　　{

　　flag_rx_off = FALSE;

　　}

　　//------------------------------------------------ ----------------------------------------

　　// Function name: turn_rx_off

　　// Function description: Stop receiving, not related to hardware, general function

　　//------------------------------------------------ ----------------------------------------

　　void turn_rx_off( void )

　　{

　　flag_rx_off = TRUE;

　　}

　　;****************************************************** ***********