The mikroPascal PRO for dsPIC30/33 and PIC24 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

// Initialize Receiver
var MANRXPIN : sbit at RF0_bit;
var MANRXPIN_Direction : sbit at TRISF0_bit;
...
Man_Receive_Init();

Man_Receive

var data_, error : word;
...
error := 0;
data_ := 0;
data_ := Man_Receive(error);
if (error <> 0) then
begin 
	// error handling 
end;

Man_Send_Init

// Initialize Transmitter:
var MANTXPIN : sbit at LATF1_bit;
var MANTXPIN_Direction : sbit at TRISF1_bit;
...
Man_Send_Init();

Man_Send

var msg : byte;
...
Man_Send(msg);

Man_Synchro

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

Man_Break

var data1, error, counter : byte;

procedure Timer1Int(); org IVT_ADDR_T1INTERRUPT;
begin
  counter := 0;
  if (counter >= 20) then
    begin    
      Man_Break();
      counter := 0;                // reset counter
    end
  else
    Inc(counter);                  // increment counter

  T1IF_bit := 0;                 // Clear Timer1 overflow interrupt flag
end;

begin

  ...

  if (Man_Receive_Init() = 0)
    begin
    ...
    end;

  ...

  // try Man_Receive with blocking prevention mechanism
  IPC0   := IPC0 or 0x1000;       // Interrupt priority level = 1 
  T1IE_bit := 1;                 // Enable Timer1 interrupts
  T1CON := 0x8030;               // Timer1 ON, internal clock FCY, prescaler 1:256
  
  data1 := Man_Receive(@error);
  T1IE_bit := 0;                 // Disable Timer1 interrupts
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 LATD0_bit;
    LCD_EN : sbit at LATD1_bit;
    LCD_D4 : sbit at LATB0_bit;
    LCD_D5 : sbit at LATB1_bit;
    LCD_D6 : sbit at LATB2_bit;
    LCD_D7 : sbit at LATB3_bit;

var LCD_RS_Direction : sbit at TRISD0_bit;
    LCD_EN_Direction : sbit at TRISD1_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 RF0_bit;
    MANRXPIN_Direction : sbit at TRISF0_bit;
    MANTXPIN : sbit at LATF1_bit;
    MANTXPIN_Direction : sbit at TRISF1_bit;
// End Manchester module connections


var error : word;
    ErrorCount, chr_counter, byte_rcvd : byte;

  begin

  ErrorCount := 0;
  chr_counter := 0;

  ADPCFG := 0xFFFF;                          // Configure AN pins as digital I/O

  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
          byte_rcvd := Man_Receive(error);   // Attempt byte receive
          if (byte_rcvd = 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
          byte_rcvd := 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
                  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 (byte_rcvd <> 0x0E) then    // If "End" byte was received(see Transmitter example)
                begin                        // do not write anymore received byte on LCD
                  Lcd_Chr_CP(byte_rcvd);     // else write character on LCD
                  Inc(chr_counter);          // Counts how many chars have been written on LCD
                  if (chr_counter = 25) then // If there were more then 25 characters
                    begin                    // synchronization is off
                      Lcd_Cmd(_LCD_CLEAR);   // Clear the LCD of garbled communication
                      Man_Synchro();         // Try to synchronize again
                    end;
                end
              else
                chr_counter := 0;            // reset chr_counter
            end;
          Delay_ms(25);
        end;
      until (byte_rcvd = 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 RF0_bit;
    MANRXPIN_Direction : sbit at TRISF0_bit;
    MANTXPIN : sbit at LATF1_bit;
    MANTXPIN_Direction : sbit at TRISF1_bit;
// End Manchester module connections

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

  begin
    s1 := 'mikroElektronika';
    ADPCFG := 0xFFFF;                // Configure AN pins as digital I/O

    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