Synchronous serial line - Revision history

Jnc: New cat, +/* See also */

2022-05-23T13:06:58Z

New cat, +See also

← Older revision		Revision as of 13:06, 23 May 2022
Line 5:		Line 5:
	The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', in order for the line to function. This is done by sending a special [[sync character]] or bit pattern (the details differ, depending on the exact protocol in use) every so often.		The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', in order for the line to function. This is done by sending a special [[sync character]] or bit pattern (the details differ, depending on the exact protocol in use) every so often.

	This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.		This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped' (perhaps via [[bit stuffing]]).

	[[Category: ~~Communication Basics~~]]		==See also==

			* [[SDLC]]
			* [[HDLC]]

			[[Category: Serial Lines]]

Jnc: +link

2019-09-16T21:06:11Z

+link

← Older revision		Revision as of 21:06, 16 September 2019
Line 3:		Line 3:
	Although more complex to work with, this allows the data to be packed more densely, making more efficient use of the line. There are two main classes of synchronous serial line [[protocol]]s; '''bit-oriented''' and '''byte-oriented'''; the latter handle the data as a stream of bits, without imposing any division into larger units (e.g. bytes).		Although more complex to work with, this allows the data to be packed more densely, making more efficient use of the line. There are two main classes of synchronous serial line [[protocol]]s; '''bit-oriented''' and '''byte-oriented'''; the latter handle the data as a stream of bits, without imposing any division into larger units (e.g. bytes).

	The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', in order for the line to function. This is done by sending a special 'sync' character or bit pattern (the details differ, depending on the exact protocol in use) every so often.		The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', in order for the line to function. This is done by sending a special [[sync character]] or bit pattern (the details differ, depending on the exact protocol in use) every so often.

	This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.		This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.

	[[Category: Communication Basics]]		[[Category: Communication Basics]]

Jnc: better cat

2018-12-13T18:57:42Z

better cat

← Older revision		Revision as of 18:57, 13 December 2018
Line 7:		Line 7:
	This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.		This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.

	[[Category: ~~Device Basics‎‎~~]]		[[Category: Communication Basics]]

Jnc: +cat

2018-12-13T15:13:14Z

+cat

← Older revision		Revision as of 15:13, 13 December 2018
Line 6:		Line 6:

	This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.		This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.

			[[Category: Device Basics‎‎]]

Jnc: Mention no start/stop bits

2017-10-15T17:11:52Z

Mention no start/stop bits

← Older revision		Revision as of 17:11, 15 October 2017
Line 1:		Line 1:
	A '''synchronous serial line''' is one which is not self-clocking; i.e. the position of the start and end of bits and bytes cannot be determined simply from examining the data stream~~. Although more complex to work with~~, ~~this allows the data to be packed more densely, making more efficient use~~ of ~~the~~ line.		A '''synchronous serial line''' is one which is not self-clocking; i.e. the position of the start and end of bits and bytes cannot be determined simply from examining a short stretch of the data stream, which does not have start and end bits like those of an [[asynchronous serial line]].

	There are two main classes of synchronous serial line [[protocol]]s; '''bit-oriented''' and '''byte-oriented'''; the latter handle the data as a stream of bits, without imposing any division into larger units (e.g. bytes).		Although more complex to work with, this allows the data to be packed more densely, making more efficient use of the line. There are two main classes of synchronous serial line [[protocol]]s; '''bit-oriented''' and '''byte-oriented'''; the latter handle the data as a stream of bits, without imposing any division into larger units (e.g. bytes).

	The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', for the line to function. This is done by sending a special 'sync' character or bit pattern (the details differ, depending on the exact protocol in use) every so often.		The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', in order for the line to function. This is done by sending a special 'sync' character or bit pattern (the details differ, depending on the exact protocol in use) every so often.

	This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.		This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.

Jnc: An OK start

2017-10-15T16:42:06Z

An OK start

New page

A '''synchronous serial line''' is one which is not self-clocking; i.e. the position of the start and end of bits and bytes cannot be determined simply from examining the data stream. Although more complex to work with, this allows the data to be packed more densely, making more efficient use of the line.

There are two main classes of synchronous serial line [[protocol]]s; '''bit-oriented''' and '''byte-oriented'''; the latter handle the data as a stream of bits, without imposing any division into larger units (e.g. bytes).

The bit clocks on each end of a synchronous serial line are also generally independent; thus both the clocks and the byte boundary locations must be periodically 're-synchronized', for the line to function. This is done by sending a special 'sync' character or bit pattern (the details differ, depending on the exact protocol in use) every so often.

This is easy to do when the line is idle; when it is constantly busy, the sync pattern has to be inserted in the middle of a data block; any actual data that might look like a sync pattern has to be 'escaped'.