The mikroC PRO for PIC32 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
sbit MANRXPIN at RF0_bit;
sbit MANRXPIN_Direction at TRISF0s_bit;
...
if (Man_Receive_Init() == 0) {
...
}

Man_Receive

unsigned int data = 0, error = 0;
...
data = Man_Receive(&error);
if (error)
  { /* error handling */ }

Man_Send_Init

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

Man_Send

unsigned int msg;
...
Man_Send(msg);

Man_Synchro

unsigned int man__half_bit_len;
...
man__half_bit_len = Man_Synchro();

Man_Break

char data1, error, counter = 0;

void Timer1Int() org IVT_ADDR_T1INTERRUPT {

  if (counter >= 20) {
    Man_Break();
    counter = 0;                // reset counter
  }
  
  else
    counter++;                  // increment counter

  T1IF_bit = 0;                 // Clear Timer1 overflow interrupt flag
}

void main() {

  ...

  if (Man_Receive_Init() == 0) {
  ...
  }

  ...

  // try Man_Receive with blocking prevention mechanism
  IPC0   = IPC0 | 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
}

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

// LCD module connections
sbit LCD_RS at LATB2_bit;
sbit LCD_EN at LATB3_bit;

sbit LCD_D4 at LATB4_bit;
sbit LCD_D5 at LATB5_bit;
sbit LCD_D6 at LATB6_bit;
sbit LCD_D7 at LATB7_bit;

sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;

sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
// End LCD module connections

// Manchester module connections
sbit MANRXPIN at RF0_bit;
sbit MANRXPIN_Direction at TRISF0_bit;
sbit MANTXPIN at LATF1_bit;
sbit MANTXPIN_Direction at TRISF1_bit;
// End Manchester module connections

unsigned int error;
char ErrorCount, chr_counter, byte_rcvd;

void main() {

  ErrorCount = 0;
  chr_counter = 0;
  CHECON = 0x32;
  AD1PCFG = 0xFFFF;                               // Configure AN pins as digital I/O
  TRISB = 0;
  LATB = 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
        byte_rcvd = Man_Receive(&error);          // Attempt byte receive
        if (byte_rcvd == 0x0B)                    // "Start" byte, see Transmitter example
          break;                                  // We got the starting sequence
        if (error)                                // Exit so we do not loop forever
          break;
        }

      do
        {
          byte_rcvd = 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
              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 (byte_rcvd != 0x0E) {              // If "End" byte was received(see Transmitter example)
                                                  // do not write anymore received byte on LCD
              Lcd_Chr_CP(byte_rcvd);              // else write character on LCD
              chr_counter++;                      // Counts how many chars have been written on LCD
              if (chr_counter == 25) {            // If there were more then 25 characters
                                                  // synchronization is off
                Lcd_Cmd(_LCD_CLEAR);              // Clear the LCD of garbled communication
                Man_Synchro();                    // Try to synchronize again
              }
            }
            else
              chr_counter = 0;                    // reset chr_counter
          }

          Delay_ms(25);
        }
      while (byte_rcvd != 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 Library for transmitting data:

Copy Code To Clipboard

// Manchester module connections
sbit MANRXPIN at RF0_bit;
sbit MANRXPIN_Direction at TRISF0_bit;
sbit MANTXPIN at LATF1_bit;
sbit MANTXPIN_Direction at TRISF1_bit;
// End Manchester module connections

char index, character;
char s1[] = "mikroElektronika";

void main() {
  CHECON = 0x32;
  AD1PCFG = 0xFFFF;                 // Configure AN pins as digital I/O
  TRISB = 0;
  LATB = 0;

  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);
  }
}

Connection Example

Simple Transmitter connection

Simple Receiver connection

Want more examples and libraries? 
Find them on