Manchester Code Library

mikroBasic PRO for ARM 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 :

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

Stellaris

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 GPIO_PORTE_DATA.B0`
`dim MANTXPIN as sbit sfr external`	Transmit line.	`dim MANTXPIN as sbit at GPIO_PORTE_DATA.B1`
`dim MANRXPIN_Direction as sbit sfr external`	Direction of the Receive pin.	`dim MANRXPIN_Direction as sbit at GPIO_PORTE_DIR.B0`
`dim MANTXPIN_Direction as sbit sfr external`	Direction of the Transmit pin.	`dim MANTXPIN_Direction as sbit at GPIO_PORTE_DIR.B1`

STM32

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 GPIOE_IDR.B8`
`dim MANTXPIN as sbit sfr external`	Transmit line.	`dim MANTXPIN as sbit at GPIOE_ODR.B9`

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

Manchester_0
Manchester_1
Manchester_Out

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	External dependencies of the library from the top of the page must be defined before using this function.
Example	Stellaris ' Manchester module connections dim MANRXPIN as sbit at GPIO_PORTE_DATA.B0 MANRXPIN_Direction as sbit at GPIO_PORTE_DIR.B0 MANTXPIN as sbit at GPIO_PORTE_DATA.B1 MANTXPIN_Direction as sbit at GPIO_PORTE_DIR.B1 ' End Manchester module connections ... Man_Receive_Init() STM32 ' Manchester module connections dim MANRXPIN as sbit at GPIOE_IDR.B8 MANTXPIN as sbit at GPIOE_ODR.B9 ' End Manchester module connections ... 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	External dependencies of the library from the top of the page must be defined before using this function.
Example	Stellaris ' Manchester module connections dim MANRXPIN as sbit at GPIO_PORTE_DATA.B0 MANRXPIN_Direction as sbit at GPIO_PORTE_DIR.B0 MANTXPIN as sbit at GPIO_PORTE_DATA.B1 MANTXPIN_Direction as sbit at GPIO_PORTE_DIR.B1 ' End Manchester module connections ... Man_Send_Init() STM32 ' Manchester module connections dim MANRXPIN as sbit at GPIOE_IDR.B8 MANTXPIN as sbit at GPIOE_ODR.B9 ' End Manchester module connections ... 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
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:

Stellaris

Copy Code To Clipboard

program Manchester_Receiver

' Manchester module connections
dim MANRXPIN  as sbit at GPIO_PORTE_DATA.B0
    MANRXPIN_Direction as sbit at GPIO_PORTE_DIR.B0
    MANTXPIN as sbit at GPIO_PORTE_DATA.B1
    MANTXPIN_Direction as sbit at GPIO_PORTE_DIR.B1
' End Manchester module connections

' Lcd module connections
dim LCD_RS as sbit at GPIO_PORTD_DATA.B2
    LCD_EN as sbit at GPIO_PORTD_DATA.B3
    LCD_D4 as sbit at GPIO_PORTD_DATA.B4
    LCD_D5 as sbit at GPIO_PORTD_DATA.B5
    LCD_D6 as sbit at GPIO_PORTD_DATA.B6
    LCD_D7 as sbit at GPIO_PORTD_DATA.B7

    LCD_RS_Direction as sbit at GPIO_PORTD_DIR.B2
    LCD_EN_Direction as sbit at GPIO_PORTD_DIR.B3
    LCD_D4_Direction as sbit at GPIO_PORTD_DIR.B4
    LCD_D5_Direction as sbit at GPIO_PORTD_DIR.B5
    LCD_D6_Direction as sbit at GPIO_PORTD_DIR.B6
    LCD_D7_Direction as sbit at GPIO_PORTD_DIR.B7
' End Lcd module connections

dim error_flag as word
dim ErrorCount, counter, temp as byte

main:
  ErrorCount = 0
  counter = 0
  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.

STM32

Copy Code To Clipboard

program Manchester_Receiver


' LCD module connections
dim LCD_RS as sbit at GPIOD_ODR.B2
dim LCD_EN as sbit at GPIOD_ODR.B3
dim LCD_D4 as sbit at GPIOD_ODR.B4
dim LCD_D5 as sbit at GPIOD_ODR.B5
dim LCD_D6 as sbit at GPIOD_ODR.B6
dim LCD_D7 as sbit at GPIOD_ODR.B7
' End LCD module connections


' Manchester module connections
dim MANRXPIN as sbit at GPIOE_IDR.B8
dim MANTXPIN as sbit at GPIOE_ODR.B9
' End Manchester module connections

dim error_flag as word
dim ErrorCount, counter, temp as byte

main:
  ErrorCount = 0
  counter = 0
  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:

Stellaris

Copy Code To Clipboard

program Manchester_Transmitter

' Manchester module connections
dim MANRXPIN  as sbit at GPIO_PORTE_DATA.B0
    MANRXPIN_Direction as sbit at GPIO_PORTE_DIR.B0
    MANTXPIN as sbit at GPIO_PORTE_DATA.B1
    MANTXPIN_Direction as sbit at GPIO_PORTE_DIR.B1
' End Manchester module connections

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

main:
    s1 = "mikroElektronika"
    
    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.

STM32

Copy Code To Clipboard

program Manchester_Transmitter

' Manchester module connections
dim MANRXPIN as sbit at GPIOE_IDR.B8
dim MANTXPIN as sbit at GPIOE_ODR.B9
' End Manchester module connections

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

main:
    s1 = "mikroElektronika"
    
    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.

Want more examples and libraries?
Find them on