Connect Transmitter Receiver module with 8051 code

The mikroC PRO for 8051 provides a library for handling Manchester coded signals. The Manchester code is a code in which data and clock signals are combined to form a single self-synchronizing data stream; each encoded bit contains a transition at the midpoint of a bit period, the direction of transition determines whether the bit is 0 or 1; the second half is the true bit value and the first half is the complement of the true bit value .

Notes:

• The Manchester receive routines are blocking calls (Man_Receive_Init and Man_Synchro). This means that MCU will wait until the task has been performed (e.g. byte is received, synchronization achieved, etc).
• Manchester code library implements time-based activities, so interrupts need to be disabled when using it.

External dependencies of Manchester Code Library

The following variables must be defined in all projects using Manchester Code Library:	Description:	Example:
extern sfr sbit bdata MANRXPIN;	Receive line.	sbit MANRXPIN at P0_0_bit;
extern sfr sbit bdata MANTXPIN;	Transmit line.	sbit MANTXPIN at P0_1_bit;

Library Routines

• Man_Receive_Init
• Man_Receive
• Man_Send_Init
• Man_Send
• Man_Synchro
• Man_Break

The following routines are for the internal use by compiler only:

• Manchester_0
• Manchester_1
• Manchester_Out

Man_Receive_Init

Prototype	unsigned int Man_Receive_Init();
Returns	0 - if initialization and synchronization were successful. 1 - upon unsuccessful synchronization. 255 - upon user abort.
Description	The function configures Receiver pin and performs synchronization procedure in order to retrieve baud rate out of the incoming signal. Note: In case of multiple persistent errors on reception, the user should call this routine once again or Man_Synchro routine to enable synchronization.
Requires	MANRXPIN variable must be defined before using this function.
Example	// Initialize Receiver sbit MANRXPIN at P0_0_bit; ... Man_Receive_Init();

Man_Receive

Prototype	unsigned char Man_Receive(unsigned char *error);
Returns	A byte read from the incoming signal.
Description	The function extracts one byte from incoming signal. Parameters : error: error flag. If signal format does not match the expected, the error flag will be set to non-zero.
Requires	To use this function, the user must prepare the MCU for receiving.
Example	unsigned char data = 0, error = 0; ... data = Man_Receive(&error); if (error)   { /* error handling */ }

Man_Send_Init

Prototype	void Man_Send_Init();
Returns	Nothing.
Description	The function configures Transmitter pin.
Requires	MANTXPIN variable must be defined before using this function.
Example	// Initialize Transmitter: sbit MANTXPIN at P0_1_bit; ... Man_Send_Init();

Man_Send

Prototype	void Man_Send(unsigned char tr_data);
Returns	Nothing.
Description	Sends one byte. Parameters : tr_data: data to be sent Note: Baud rate used is 500 bps.
Requires	To use this function, the user must prepare the MCU for sending.
Example	unsigned char msg; ... Man_Send(msg);

Man_Synchro

Prototype	unsigned char Man_Synchro();
Returns	255 - if synchronization was not successful. Half of the manchester bit length, given in multiples of 10us - upon successful synchronization.
Description	Measures half of the manchester bit length with 10us resolution.
Requires	To use this function, you must first prepare the MCU for receiving.
Example	unsigned int man__half_bit_len; ... man__half_bit_len = Man_Synchro();

Man_Break

Prototype	void Man_Break();
Returns	Nothing.
Description	Man_Receive is blocking routine and it can block the program flow. Call this routine from interrupt to unblock the program execution. This mechanism is similar to WDT. Note: Interrupts should be disabled before using Manchester routines again (see note at the top of this page).
Requires	Nothing.
Example	char data1, error, counter = 0; void Timer0Overflow_ISR() org 0x12 {   if (counter >= 20) {     Man_Break();     counter = 0;                // reset counter   }   else     counter++;                  // increment counter } void main() {   TR1_bit = 0;                  // Stop Timer1    ET1_bit = 1;                  // Enable Timer1 interrupt   TH1 = 0x00;                   // Set Timer1 high byte   TL1 = 0x00;                   // Set Timer1 low byte   TR1_bit = 1;                  // Run Timer1     EA_bit = 0;                   // Interrupt disable   ...   Man_Receive_Init();   ...     // try Man_Receive with blocking prevention mechanism   EA_bit = 1;                   // Interrupt enable   data1 = Man_Receive(&error);   EA_bit = 0;                   // Interrupt disable   ... }

Code Example

The following code is code for the Manchester receiver, it shows how to use the Manchester Code for receiving data:

// LCD module connections

sbit LCD_RS at P2_0_bit;

sbit LCD_EN at P2_1_bit;

sbit LCD_D4 at P2_2_bit;

sbit LCD_D5 at P2_3_bit;

sbit LCD_D6 at P2_4_bit;

sbit LCD_D7 at P2_5_bit;

// End LCD module connections

// Manchester module connections

sbit MANRXPIN at P0_0_bit;

sbit MANTXPIN at P0_1_bit;

// End Manchester module connections

char error, ErrorCount, temp;

void main() {

  ErrorCount = 0;

  Lcd_Init();                                     // Initialize LCD

  Lcd_Cmd(_LCD_CLEAR);                            // Clear LCD display

  Man_Receive_Init();                             // Initialize Receiver

 

  while (1) {                                     // Endless loop

      Lcd_Cmd(_LCD_FIRST_ROW);                    // Move cursor to the 1st row

      

      while (1) {                                 // Wait for the "start" byte

        temp = Man_Receive(&error);               // Attempt byte receive

        if (temp == 0x0B)                         // "Start" byte, see Transmitter example

          break;                                  // We got the starting sequence

        if (error)                                // Exit so we do not loop forever

          break;

        }

       

      do

        {

          temp = Man_Receive(&error);             // Attempt byte receive

          if (error) {                            // If error occured

            Lcd_Chr_CP('?');                      // Write question mark on LCD

            ErrorCount++;                         // Update error counter

            if (ErrorCount > 20) {                // In case of multiple errors

              temp = Man_Synchro();               // Try to synchronize again

              //Man_Receive_Init();               // Alternative, try to Initialize Receiver again

              ErrorCount = 0;                     // Reset error counter

              }

            }

          else {                                  // No error occured

            if (temp != 0x0E)                     // If "End" byte was received(see Transmitter example)

              Lcd_Chr_CP(temp);                   //   do not write received byte on LCD

              }

          Delay_ms(25);

        }

      while (temp != 0x0E) ;                      // If "End" byte was received exit do loop

   }

}

The following code is code for the Manchester transmitter, it shows how to use the Manchester Code for transmitting data:

// Manchester module connections

sbit MANRXPIN at P0_0_bit;

sbit MANTXPIN at P0_1_bit;

// End Manchester module connections

char index, character;

char s1[] = "mikroElektronika";

void main() {

  Man_Send_Init();                 // Initialize transmitter

  while (1) {                      // Endless loop

    Man_Send(0x0B);                // Send "start" byte

    Delay_ms(100);                 // Wait for a while

    character = s1[0];             // Take first char from string

    index = 0;                     // Initialize index variable 

    while (character) {            // String ends with zero

      Man_Send(character);         // Send character

      Delay_ms(90);                // Wait for a while

      index++;                     // Increment index variable

      character = s1[index];       // Take next char from string

      }

    Man_Send(0x0E);                // Send "end" byte

    Delay_ms(1000);

  }

}

Hardware Diagram