Introduction to UART Communication. In UART communication, two UARTs communicate directly with each other. The transmitting UART converts parallel data from a controlling device like a CPU into serial form, transmits it in serial to the receiving UART, which then converts the serial data back into parallel data for the receiving device. All the data packets are composed of 8-bit bytes (or multiples of 8-bit bytes, depending on the supported bitrate), where the LSB or Least Significant Bit is transmitted first. If you are building an embedded system that involves USB, make sure you use a USB protocol analyzer to monitor the data on the bus. Uses of the USB Protocol.
Parallel versus serial communication.
In telecommunication and data transmission, serial communication is the process of sending data one bit at a time, sequentially, over a communication channel or computer bus. This is in contrast to parallel communication, where several bits are sent as a whole, on a link with several parallel channels.
Serial communication is used for all long-haul communication and most computer networks, where the cost of cable and synchronization difficulties make parallel communication impractical. Serial computer buses are becoming more common even at shorter distances, as improved signal integrity and transmission speeds in newer serial technologies have begun to outweigh the parallel bus's advantage of simplicity (no need for serializer and deserializer, or SerDes) and to outstrip its disadvantages (clock skew, interconnect density). The migration from PCI to PCI Express is an example.
Cables[edit]
Many serial communication systems were originally designed to transfer data over relatively large distances through some sort of data cable.
Practically all long-distance communication transmits data one bit at a time, rather than in parallel, because it reduces the cost of the cable. The cables that carry this data (other than 'the' serial cable) and the computer ports they plug into are usually referred to with a more specific name, to reduce confusion.
Keyboard and mouse cables and ports are almost invariably serial—such as PS/2 port, Apple Desktop Bus and USB.
The cables that carry digital video are almost invariably serial—such as coax cable plugged into a HD-SDI port, a webcam plugged into a USB port or Firewire port, Ethernet cable connecting an IP camera to a Power over Ethernet port, FPD-Link, etc.
Other such cables and ports, transmitting data one bit at a time, include Serial ATA, Serial SCSI, Ethernet cable plugged into Ethernet ports, the Display Data Channel using previously reserved pins of the VGA connector or the DVI port or the HDMI port.
Serial buses[edit]
RS-232 connector.
Many communication systems were generally designed to connect two integrated circuits on the same printed circuit board, connected by signal traces on that board (rather than external cables).
Integrated circuits are more expensive when they have more pins. To reduce the number of pins in a package, many ICs use a serial bus to transfer data when speed is not important. Some examples of such low-cost serial buses include RS-232, SPI, I²C, DC-BUS, UNI/O, 1-Wire and PCI Express. In IC, serial bus may be typically implemented by using multiplexer (which utilizes technique called multiplexing).[1]
Serial versus parallel[edit]
The communication links, across which computers (or parts of computers) talk to one another, may be either serial or parallel. A parallel link transmits several streams of data simultaneously along multiple channels (e.g., wires, printed circuit tracks, or optical fibers); whereas, a serial link transmits only a single stream of data.
Although a serial link may seem inferior to a parallel one, since it can transmit less data per clock cycle, it is often the case that serial links can be clocked considerably faster than parallel links in order to achieve a higher data rate. Several factors allow serial to be clocked at a higher rate:
In many cases, serial is cheaper to implement than parallel. Many ICs have serial interfaces, as opposed to parallel ones, so that they have fewer pins and are therefore less expensive.
Examples of architectures[edit]
See also[edit]
References[edit]
External links[edit]
Retrieved from 'https://en.wikipedia.org/w/index.php?title=Serial_communication&oldid=915430359'
Active3 years, 7 months ago
I need a simple communication protocol between two devices (a PC and a microcontroller). The PC must send some commands and parameters to the micro. The micro must transmit an array of bytes (data from sensor).
The data must be noise protected (besides parity checking, I think I need some other data correction method).
Is there any standard solution to do this? (I need only an idea, not the complete solution).
P.S. Any advice is appreciated. P.P.S Sorry for any grammar mistakes, I hope you understand.
Edit 1. I have not decided whether it will be master/slave protocol or both sides can initiate communication. The PC must know when micro have done a job and can send data. It can continuously poll the micro if data is ready, or the micro can send data, when a job is done. I don't know which is better and simpler.
Edit 2.Hardware and physical layer protocol. Since RS-232C serial standard used in the PC, I will use asynchronous communication. I will use only RxD, TxD and GND signals. I can't use additional wires because the microcontroller AFAIK doesn't support them. BTW I'm using the AVR ATmega128 chip.
So I will use fixed baud rate, 8 bits of data, 2 stop bits without parity checking (or with?).
Data link protocol. That's what my question primarily concerned about. Thanks for suggesting HDLC, PPP and Modbus protocols. I will research on it.
12 Answers
I would use HDLC. I have had good luck with it in the past. I would for a point to point serial just use the Asynchronous framing and forget about all of the other control stuff as it would probably be overkill.
In addition to using HDLC for the framing of the packet. I format my packet like the following. This is how options are passed using 802.11
The total size of each command packet is len +2
You then define commands like
The other advantage is that you can add new commands and if you design your parser correctly to ignore undefined commands then you will have some backwards compatibility.
So putting it all together the packet would look like the following.
The system will then monitor the serial stream for the flag 0x7e and when it is there you check the length to see if it is pklen >= 4 and pklen=len+4 and that the crc is valid. Note do not rely on just crc for small packets you will get a lot of false positives also check length. If the length or crc does not match just reset the length and crc and start with decoding the new frame. If it is a match then copy the packet to a new buffer and pass it to your command processing function. Always reset length and crc when a flag is received.
For your command processing function grab the cmd and len and then use a switch to handle each type of command. I also require that a certain events send a response so the system behaves like a remote procedure call that is event driven.
So for example the sensor device can have a timer or respond to a command to take a reading. It then would format a packet and send it to the PC and the PC would respond that it received the packet. If not then the sensor device could resend on a timeout.
Also when you are doing a network transfer you should design it as a network stack like the OSI modle as Foredecker points don't forget about the physical layer stuff. My post with the HDLC is the data link layer and the RPC and command handling is the Application Layer.
Community♦
Rex LoganRex Logan
17.4k99 gold badges3030 silver badges4747 bronze badges
RS232 protocols are tricky. The suggestion to use HDLC, is a good one, but its not the entire solution. There are other things you need to decide:
I suggest you go with 8 data bits, no hardware parity, 1 stop bit, and use software based flow control. You should use autobaud if your hardware supports it. If not, then autobaud is devilishly difficult to do in software.
ForedeckerForedecker
7,11544 gold badges2626 silver badges3030 bronze badges
There are some good answers in here, here are some useful pointers:
Arduino Serial Data Protocol
Even if your packets are not time-separated, the sync byte is an essential way of reducing the number of places you need to attempt to construct a packet from. Your devices will often have to deal with a bunch of junk data (i.e the end of a packet in flight when they turned on, or result of a hardware collision). Without a sync byte you will have to try to make a packet out of every byte you receive. The sync byte means that only 1/255 bytes of random noise could be the first byte of your packet. Also FANTASTIC when you want to snoop on your protocol.
Having an address on your packets or even just a bit saying master / slave or pc / device is useful when you look at the packets via a snoop tool of some type or another. You might do this by having a different sync byte for the PC than the DEVICE. Also, this will mean a device will not respond to its own echo.
You might want to look into error correction (such as Hamming). You package 8 bit of data into a 12 bit protected byte. Any one of those 12 bits can be flipped en-route and the original 8 bits retrieved. Useful for data storage (used on CDs) or where the device can't re-send easily (satellite links, one-way rf).
Packet numbers make life easier. A packet sent carries a number, responses carry the same number an a flag saying 'response'. This means that packets that never arrived (sync corrupted say) are easily detected by the sender and in full-duplex mode with a slow link, two commands can be sent before the first response is received. This also makes protocol analysis easier (A third party can understand which packets were received with no knowledge of the underlying protocol)
Having a single master is an awesome simplification. That said, in a full-duplex environment it does not matter much at all. Suffice to say you should always do it unless you are trying to save power or you are doing something event driven at the device end (input state changed, sample ready).
My suggestion is modbus. It's an efficient and easy standard protocol for communication with devices that has sensors and parameters (for example a PLC). You can get the specifications at http://www.modbus.org. It’s been around since 1979 and is gaining in popularity, you will have no problem finding examples and libraries.
Martin LiesénMartin Liesén
I read this question a few months back, having exactly the same issue, and didn't really find anything efficient enough for a tiny 8-bit micro with tiny amounts of RAM. So inspired by CAN and LIN I built something to do the job. I called it MIN (Microcontroller Interconnect Network) and I've uploaded it to GitHub here:
There are two implementations there: one in embedded C, one in Python for a PC. Plus a little 'hello world' test program where the PC sends commands and the firmware lights an LED. I blogged about getting this up and running on an Arduino board here:
MIN is pretty simple. I fixed the layer 0 representation (8 data bits, 1 stop bit, no parity) but left the baud rate open. Each frame starts with three 0xAA bytes which in binary is 1010101010, a nice pulsetrain to do autobaud rate detection if one end wants to dynamically adapt to the other. Frames are 0-15 bytes of payload, with a 16-bit Fletcher's checksum as well as a control byte and an 8-bit identifier (to tell the application what the payload data contains).
The protocol uses character stuffing so that 0xAA 0xAA 0xAA always indicates start-of-frame. This means that if a device comes out of reset it always syncs with the start of the next frame (a design goal for MIN was never to pass up an incomplete or incorrect frame). This also means there's no need to have specific inter-byte and inter-frame timing constraints. Full details of the protocol are in the GitHub repo wiki.
There's room for future improvements with MIN. I've left some hooks in there for block message passing (4 bits of the control byte are reserved) and for higher-level negotiation of capabilities (identifier 0xFF is reserved) so there's plenty of scope for adding support for commonly required functionality.
Adobe rgb test. Here's an alternative protocol:
Use RS232/UART, as the PC (serial port) and the processor (UART) can already handle that with minimum fuss (just need a MAX232 chip or similar to do the level shifting).
And using RS232/UART, you don't have to worry about master/slave if it's not relevant. Flow control is available if necessary.
Suggested PC software: either write your own, or Docklight for simple monitoring and control (evaluation version is free).
For greater error checking, simplest is parity checking, or if you need something more powerful, maybe convolutional coding.
In any case, whatever you do: keep it simple!
EDIT: Using RS232 with a PC is even easier than it used to be, as you can now get USB to RS232/TTL converters. One end goes into your PC's USB socket, and appears as a normal serial port; the other comes out to 5 V or 3.3 V signals that can be connected directly to your processor, with no level-shifting required.
We've used TTL-232R-3V3 from FDTI Chip, which works perfectly for this kind of application.
Steve MelnikoffSteve Melnikoff
2,31011 gold badge1919 silver badges2222 bronze badges
My only suggestion is if you need noise-resistant you might want to use full-duplex RS-422/485. You can use an IC similar to this on the AVR side, then an RS-232->RS-422 converter on the PC side like the 485PTBR here. If you can find or make a shielded cable (two twisted shielded pairs) then you'll have even more protection. And all of this is invisible to the micro and PC - no software changes.
Whatever you do make sure that you are using a full-duplex system and make sure the read/write enable lines are asserted on the IC.
Stephen FriederichsStephen Friederichs
You can have a look at
Telemetry and its associated desktop implementation in python Pytelemetry
Serial Data Protocol AnalyzerMain features
It is a PubSub-based protocol, but unlike MQTT it is a point-to-point protocol, no broker.
As any pubsub protocol, you can publish from one end on a
topic Torrent clients for windows 10. and be notified on the other end on that topic.
Serial Data Cable
On the embedded side, publishing to a topic is as simple as :
For numbers:
This way of sending variables may seem limited, but the next milestone intends to add extra meaning to the topic's parsing by doing things like this :
This is good if you need to send arrays, complex data structures, etc.
Also, the PubSub pattern is great because of its flexibility. You can build master/slave applications, device to device, etc.
C library![]()
The C library is very simple to add on any new device as long as you have a decent UART library on it.
You just have to instanciate a data structure called
TM_transport (defined by Telemetry ), and assign the 4 function pointers read readable write writeable .
To use Telemetry, you just have to add the following code
Python library
On the desktop side, there is the
pytelemetry module that implements the protocol.
If you know python, the following code connects to a serial port, publishes once on topic
foo , prints all received topics during 3 seconds then terminates.
If you don't know python, you can use the command line interface
Pytelemetry CLI
The command line can be started with
Then you can
connect , ls (list) received topics, print data received on a topic, pub (publish) on a topic, or open a plot on a topic to display received data in real-time
Regarding parity checks (as it's come up a few times here):
They're mostly useless. If you're concerned that a single bit may be changed in error, then it's highly likely that a second bit may also change and you'll get a false positive from the parity check.
Use something lightweight like CRC16 with a lookup table - it can be calculated as each byte is received and is basically just an XOR. Steve Melnikoff's suggestion is great for small micros.
I would also suggest transmitting human readable data, rather than raw binary (if performance is not your first priority). It will make debugging and log files much more pleasant.
Flarm Serial Data Protocol
You do not specify exactly how the microcontroller behaves, but will everything transmitted from the micro be a direct response to a command from the PC? If do then it seems like you can use a master/slave protocol of some kind (this will typically be the simplest solution). If both sides can initiate communication, you need a more general data link layer protocol. HDLC is a classic protocol for this. Although the full protocol probably is a overkill for your needs, you could for instance at least use the same frame format. You might also have a look at PPP to see if there are something useful parts.
hlovdalhlovdal
20.1k99 gold badges6868 silver badges138138 bronze badges
maybe this question can be completely stupid but has anyone considered use of one of X/Y/Z MODEM protocols?
The main benefit of using one of above protocols is great availability of ready-to-use implementations in various programming environments.
Serial Data Communication Protocols
SLIP and UDP. Seriously.
All PC's and similar devices speak it.
There is a good book and examples from TCP Lean
Jeremy Bentham has sneakily got a PIC doing working TCP/IP. An AVR is as good as a PIC right ?
I'd recommend UDP instead, it's pretty darn easy.
Serial Data ProtocolsSerial Data Protocol EthernetNot the answer you're looking for? Browse other questions tagged embeddedserial-portprotocols or ask your own question.Comments are closed.
|
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |