The mikroPascal PRO for PIC 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 (as shown in the figure below).

  Important :

• 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

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	function Man_Receive_Init(): word;
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	Global variables : MANRXPIN : Receive line MANRXPIN_Direction : Direction of the receive pin must be defined before using this function.
Example	// Initialize Receiver var MANRXPIN : sbit at RC0_bit; var MANRXPIN_Direction : sbit at TRISB0_bit; ... Man_Receive_Init();

Man_Receive

var data_, error : byte
...
data_ := 0
error := 0
data_ := Man_Receive(&error);

if (error <> 0) then
  begin 
	// error handling 
  end;

Man_Send_Init

// Initialize Transmitter:
var MANTXPIN : sbit at RC1_bit;
var MANTXPIN_Direction : sbit at TRISB1_bit;
...
Man_Send_Init();

Man_Send

Prototype	procedure Man_Send(tr_data: byte);
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. See Man_Send_Init.
Example	var msg : byte; ... Man_Send(msg);

Man_Synchro

var man__half_bit_len : word;
...
man__half_bit_len := Man_Synchro();

Man_Break

Prototype	procedure 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	var data1, error, counter : byte; procedure interrupt(); begin if (INTCON.T0IF <> 0) then if (counter >= 20) then begin Man_Break(); counter := 0; // reset counter end else Inc(counter); // increment counter INTCON.T0IF := 0; // Clear Timer0 overflow interrupt flag end; begin counter := 0; OPTION_REG := 0x04; // TMR0 prescaler set to 1:32 ... Man_Receive_Init(); ... // try Man_Receive with blocking prevention mechanism INTCON.GIE := 1; // Global interrupt enable INTCON.T0IE := 1; // Enable Timer0 overflow interrupt data1 := Man_Receive(error); INTCON.GIE := 0; // Global interrupt disable end.

Library Example

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

Copy Code To Clipboard

program Manchester_Receiver;

// LCD module connections
var LCD_RS : sbit at RB4_bit;
    LCD_EN : sbit at RB5_bit;
    LCD_D4 : sbit at RB0_bit;
    LCD_D5 : sbit at RB1_bit;
    LCD_D6 : sbit at RB2_bit;
    LCD_D7 : sbit at RB3_bit;

var LCD_RS_Direction : sbit at TRISB4_bit;
    LCD_EN_Direction : sbit at TRISB5_bit;
    LCD_D4_Direction : sbit at TRISB0_bit;
    LCD_D5_Direction : sbit at TRISB1_bit;
    LCD_D6_Direction : sbit at TRISB2_bit;
    LCD_D7_Direction : sbit at TRISB3_bit;
// End LCD module connections

// Manchester module connections
var MANRXPIN : sbit at RC0_bit;
    MANRXPIN_Direction : sbit at TRISC0_bit;
    MANTXPIN : sbit at RC1_bit;
    MANTXPIN_Direction : sbit at TRISC1_bit;
// End Manchester module connections

var error, ErrorCount, counter, temp : byte;

  begin
    ErrorCount := 0;
    counter := 0;
    ANSEL  := 0;                             // Configure AN pins as digital I/O
    ANSELH := 0;
    C1ON_bit := 0;                           // Disable comparators
    C2ON_bit := 0;
    TRISC5_bit := 0;
    Lcd_Init();                              // Initialize LCD
    Lcd_Cmd(_LCD_CLEAR);                     // Clear LCD display

    Man_Receive_Init();                      // Initialize Receiver

    while TRUE do                            // Endless loop
      begin
        Lcd_Cmd(_LCD_FIRST_ROW);             // Move cursor to the 1st row

        while TRUE do                        // Wait for the "start" byte
          begin
            temp := Man_Receive(error);      // Attempt byte receive
           if (temp = 0x0B) then             // "Start" byte, see Transmitter example
              break;                         // We got the starting sequence
           if (error <> 0) then              // Exit so we do not loop forever
              break;
          end;

        repeat
          begin
            temp := Man_Receive(error);      // Attempt byte receive
            if (error <> 0) then             // If error occured
              begin
                Lcd_Chr_CP('?');             // Write question mark on LCD
                Inc(ErrorCount);             // Update error counter
                if (ErrorCount > 20) then    // In case of multiple errors
                  begin
                    temp := Man_Synchro();   // Try to synchronize again
                    //Man_Receive_Init();    // Alternative, try to Initialize Receiver again
                    ErrorCount := 0;         // Reset error counter
                  end;
              end
            else                             // No error occured
              begin
                if (temp <> 0x0E) then       // If "End" byte was received(see Transmitter example)
                  begin                        // do not write anymore received byte on LCD
                    Lcd_Chr_CP(temp);          // else write character on LCD
                    Inc(counter);              // Counts how many chars have been written on LCD
                    if counter = 25 then       // If there were more then 25 characters
                      begin                    // synchronization is off
                        Lcd_Cmd(_LCD_CLEAR);   // Clear the LCD of garbled communication
                        temp := Man_Synchro(); // Try to synchronize again
                      end;
                  end
                else
                  counter := 0;                // reset counter
              end;
            Delay_ms(25);
          end;
        until ( temp = 0x0E );
      end;                                     // If "End" byte was received exit do loop
  end.

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

Copy Code To Clipboard

program Manchester_Transmitter;

// Manchester module connections
var MANRXPIN : sbit at RC0_bit;
    MANRXPIN_Direction : sbit at TRISC0_bit;
    MANTXPIN : sbit at RC1_bit;
    MANTXPIN_Direction : sbit at TRISC1_bit;
// End Manchester module connections

var index, character : byte;
    s1 : array[17] of char;

  begin
    s1 := 'mikroElektronika';
    ANSEL  := 0;                     // Configure AN pins as digital I/O
    ANSELH := 0;
    C1ON_bit := 0;                   // Disable comparators
    C2ON_bit := 0;
    
    Man_Send_Init();                 // Initialize transmitter

    while TRUE do                    // Endless loop
      begin
        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 <> 0) do    // String ends with zero
          begin
            Man_Send(character);     // Send character
            Delay_ms(90);            // Wait for a while
            Inc(index);              // Increment index variable
            character := s1[index];  // Take next char from string
          end;
        Man_Send(0x0E);              // Send "end" byte
        Delay_ms(1000);
      end;
  end.

Connection Example

Simple Transmitter connection

Simple Receiver connection

Want more examples and libraries? 
Find them on