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

- The Manchester receive routines are blocking calls (
Man_Receive_Init
andMan_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
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:
- 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 |
|
Requires |
Global variables :
|
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 |
|
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 :
|
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 |
|
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 |
|
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:
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:
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 Receiver connection
What do you think about this topic ? Send us feedback!