Serial Port Protocol

Serial Port Protocol Windows
List Of Serial Protocols
Bluetooth Serial Port Protocol

-->

Serial communications can be done via either direct to physical serial port connected to the computer or via a USB to serial converter interface. If the device do require a serial port and your computer don’t have any, you can make use of such converters easily. Free Serial Protocol Analyzer Monitoring Window Click to See Full Screenshot. Get Related Free Protocol Analyzers. Free USB Analyzer Monitor and Analyze USB Data Flows; Free Network Analyzer Monitor and Analyze Network Data Flows. Get Related Free Products. Free Virtual Serial Ports Create Virtual Serial Ports and Null-Modem Cables. Implement a serial port read loop and dispatch to a Protocol instance (like the asyncio.Protocol) but do it with threads. Calls to close will close the serial port but it is also possible to just stop this thread and continue to use the serial port instance otherwise. init (serialinstance, protocolfactory) ¶. A male D-subminiature connector used for a serial port on an IBM PC compatible computer along with the serial port symbol. In computing, a serial port is a serial communication interface through which information transfers in or out one bit at a time (in contrast to a parallel port).

Stratus Engineering's EZ-Tap Pro hardware module RS232 sniffer is a sophisticated protocol analyzer and bus analyzer hardware solution that overcomes latency and time-tagging problems associated with traditional dual COM port monitoring solutions. EZ-Tap Pro features state-of-the art electronics that provides extended functionality. Exact hardware microsecond time tagging of all RS232 data.
RS232 is a standard protocol used for serial communication, it is used for connecting computer and its peripheral devices to allow serial data exchange between them. As it obtains the voltage for the path used for the data exchange between the devices. It is used in serial communication up to 50 feet with the rate of 1.492kbps.
The term UART actually refers to the onboard hardware that manages the packaging and translation of serial data. For a device to be able to communicate via the UART protocol, it must have this hardware! On the Arduino Uno, there is one serial port dedicated for communication with the computer the Arduino is connected to.

This topic describes how to use My.Computer.Ports to receive strings from the computer's serial ports in Visual Basic.

To receive strings from the serial port

Initialize the return string.
Determine which serial port should provide the strings. This example assumes it is COM1.
Use the My.Computer.Ports.OpenSerialPort method to obtain a reference to the port. For more information, see OpenSerialPort.
The Try...Catch...Finally block allows the application to close the serial port even if it generates an exception. All code that manipulates the serial port should appear within this block.
Create a Do loop for reading lines of text until no more lines are available.
Use the ReadLine() method to read the next available line of text from the serial port.
Use an If statement to determine if the ReadLine() method returns Nothing (which means no more text is available). If it does return Nothing, exit the Do loop.
Add an Else block to the If statement to handle the case if the string is actually read. The block appends the string from the serial port to the return string.
Return the string.

Example

This code example is also available as an IntelliSense code snippet. In the code snippet picker, it is located in Connectivity and Networking. For more information, see Code Snippets.

Compiling the Code

This example assumes the computer is using COM1.

Robust Programming

This example assumes the computer is using COM1. For more flexibility, the code should allow the user to select the desired serial port from a list of available ports. For more information, see How to: Show Available Serial Ports.

This example uses a Try...Catch...Finally block to make sure that the application closes the port and to catch any timeout exceptions. For more information, see Try...Catch...Finally Statement.

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.4k9 gold badges30 silver badges47 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:

How will the baud rate between the two devices be determined? Autobuad? Predefined, or set explicate?
Will you do flow control in software or hardware or both? Note, if you use hardware flow control then you must make sure, that the cables are built correctly.
Speaking of cables, this is a huge pain with RS233. Depending on the device, you may need to use a straight through cable, or a cross over cable, or a variant.
Using a software based flow control mechanism can be effective as it allows the most simple cable to be used - just three wired (TX, RX, and common).
Do you pick a 7 or 8 bit word?
HW parity or software error checking.

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,1154 gold badges26 silver badges30 bronze badges

There are some good answers in here, here are some useful pointers:

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.

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,3101 gold badge19 silver badges22 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

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.

You can have a look at Telemetry and its associated desktop implementation in python Pytelemetry

Main 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 and be notified on the other end on that topic.

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

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

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.

hlovdal