Manchester Code Library

mikroBasic 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).

Manchester signal format

  Important :

External dependencies of Manchester Code Library

The following variables must be defined in all projects using Manchester Code Library: Description: Example:
dim MANRXPIN as sbit sfr external Receive line. dim MANRXPIN as sbit at RF0_bit
dim MANTXPIN as sbit sfr external Transmit line. dim MANTXPIN as sbit at LATF1_bit
dim MANRXPIN_Direction as sbit sfr external Direction of the Receive pin. dim MANRXPIN_Direction as sbit at TRISF0_bit
dim MANTXPIN_Direction as sbit sfr external Direction of the Transmit pin. dim MANTXPIN_Direction as sbit at TRISF1_bit

Library Routines

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

Man_Receive_Init

Prototype

sub function Man_Receive_Init() as word

Description

The function configures Receiver pin. After that, the function performs synchronization procedure in order to retrieve baud rate out of the incoming signal.

Parameters

None.

Returns

  • 0 - if initialization and synchronization were successful.
  • 1 - upon unsuccessful synchronization.
  • 255 - upon user abort.

Requires Global variables :
  • MANRXPIN : Receive line
  • MANRXPIN_Direction : Direction of the receive pin
must be defined before using this function.
Example
' Initialize Receiver
dim MANRXPIN as sbit at RF0_bit
dim MANRXPIN_Direction as sbit at TRISF0_bit
...
Man_Receive_Init()
Notes

In case of multiple persistent errors on reception, the user should call this routine once again or Man_Synchro routine to enable synchronization.

Man_Receive

Prototype

sub function Man_Receive(dim byref error as word) as byte

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.
Returns

A byte read from the incoming signal.

Requires

To use this function, the user must prepare the MCU for receiving. See Man_Receive_Init routines.

Example
dim data_, error as word
...
error = 0
data_ = 0
data_ = Man_Receive(error)
if (error <> 0) then
    ' error handling 
end if
Notes

None.

Man_Send_Init

Prototype

sub procedure Man_Send_Init()

Description

The function configures Transmitter pin.

Parameters

None.

Returns

Nothing.

Requires Global variables :
  • MANTXPIN : Transmit line
  • MANTXPIN_Direction : Direction of the transmit pin
must be defined before using this function.
Example
' Initialize Transmitter:
dim MANTXPIN as sbit at LATF1_bit
dim MANTXPIN_Direction as sbit at TRISF1_bit
...
Man_Send_Init()
Notes

None.

Man_Send

Prototype

sub procedure Man_Send(dim data as byte)

Description

Sends one byte.

Parameters
  • tr_data: data to be sent
Returns

Nothing.

Requires

To use this function, the user must prepare the MCU for sending. See Man_Send_Init routine.

Example
dim msg as byte
...
Man_Send(msg)
Notes

Baud rate used is 500 bps.

Man_Synchro

Prototype

sub function Man_Synchro() as word

Description

Measures half of the manchester bit length with 10us resolution.

Parameters

None.

Returns
  • 0 - if synchronization was not successful.
  • Half of the manchester bit length, given in multiples of 10us - upon successful synchronization.
Requires

To use this function, you must first prepare the MCU for receiving. See Man_Receive_Init.

Example
dim man__half_bit_len as word
...
man__half_bit_len = Man_Synchro()
Notes

None.

Man_Break

Prototype

sub procedure Man_Break()

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.

Parameters

None.

Returns

Nothing.

Requires

Nothing.

Example
dim data1, error, counter as byte

sub procedure Timer1Int() org IVT_ADDR_T1INTERRUPT
  counter = 0
  if (counter >= 20) then
    Man_Break()
    counter = 0                ' reset counter
  else
    Inc(counter)               ' increment counter
  end if

  T1IF_bit = 0                 ' Clear Timer1 overflow interrupt flag
end sub

main:

  ...

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

  ...

  ' 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.
Notes

Interrupts should be disabled before using Manchester routines again (see note at the top of this page).

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 ClipboardCopy Code To Clipboard
program Manchester_Receiver

' LCD module connections
dim LCD_RS as sbit at LATD0_bit
    LCD_EN as sbit at LATD1_bit
    LCD_D4 as sbit at LATB0_bit
    LCD_D5 as sbit at LATB1_bit
    LCD_D6 as sbit at LATB2_bit
    LCD_D7 as sbit at LATB3_bit

dim LCD_RS_Direction as sbit at TRISD0_bit
    LCD_EN_Direction as sbit at TRISD1_bit
    LCD_D4_Direction as sbit at TRISB0_bit
    LCD_D5_Direction as sbit at TRISB1_bit
    LCD_D6_Direction as sbit at TRISB2_bit
    LCD_D7_Direction as sbit at TRISB3_bit
' End LCD module connections


' Manchester module connections
dim MANRXPIN as sbit at RF0_bit
    MANRXPIN_Direction as sbit at TRISF0_bit
    MANTXPIN as sbit at LATF1_bit
    MANTXPIN_Direction as sbit at TRISF1_bit
' End Manchester module connections


dim error_flag, ErrorCount, counter, temp as byte

main:
  ErrorCount = 0
  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                            ' Endless loop
    Lcd_Cmd(_LCD_FIRST_ROW)             ' Move cursor to the 1st row

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

    do
      temp = Man_Receive(error_flag)    ' Attempt byte receive
      if (error_flag <> 0) then         ' If error occured
        Lcd_Chr_CP("?")                 ' Write question mark on LCD
        Inc(ErrorCount)                 ' Update error counter
        if (ErrorCount > 20) then       ' 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
        end if
      else                              ' No error occured
        if (temp <> 0x0E) then          ' If "End" byte was received(see Transmitter example)
                                        ' 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
                                        ' synchronization is off
            Lcd_Cmd(_LCD_CLEAR)         ' Clear the Lcd of garbled communication
            temp = Man_Synchro()        ' Try to synchronize again
          end if
        else
          counter = 0                   ' reset counter
        end if
        Delay_ms(25)
      end if
    loop until ( temp = 0x0E )
  wend                                  ' 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 ClipboardCopy Code To Clipboard
program Manchester_Transmitter

' Manchester module connections
dim MANRXPIN as sbit at RF0_bit
    MANRXPIN_Direction as sbit at TRISF0_bit
    MANTXPIN as sbit at LATF1_bit
    MANTXPIN_Direction as sbit at TRISF1_bit
' End Manchester module connections

dim index, character as byte
    s1 as char[17]

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

  Man_Send_Init()              ' Initialize transmitter

  while TRUE                   ' 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 <> 0)     ' String ends with zero
      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
    wend
    Man_Send(0x0E)             ' Send "end" byte
    Delay_ms(1000)
  wend
end.

Connection Example

Simple Transmitter connection

Simple Transmitter connection


Simple Receiver connection

Simple Receiver connection

Copyright (c) 2002-2012 mikroElektronika. All rights reserved.
What do you think about this topic ? Send us feedback!
Want more examples and libraries? 
Find them on LibStock - A place for the code