9-bit serial port communication

[shyub]

I encountered a device whose communication protocol uses 9 data bits. After transmitting each 9-bit packet, the device responds with a packet containing a start bit, 9 data bits, and 2 stop bits.
The TComPort component provides the ability to add a 9th bit (the Parity.Bits:=prMark or prSpace property). How can I determine the state of the 9th bit when receiving data?

[MarkMLl]

Do the original devices contain PC-compatible serial ports, or something like the SCC which might (note that I've not checked this) be more flexible on account of their support for SDLC etc.? Or are they bit-banging it, or perverting SPI hardware?

I can't speak for TComPort and the rest, but I've just checked serial.pp (to which I was the most recent contributor) and there's no immediately-obvious way to do it, and I suspect that you'll be getting very heavily OS-dependent.

On reception, I think you'll need to look for a parity error on each symbol: which could get messed up by buffering.

On transmission, I think you'll need to set the top bit explicitly to mark or space: which might not work properly if symbols are already queued for transmission.

MarkMLl

[shyub]

No, the exchange works like this: I transmit a byte (consisting of 9 bits) and substitute the desired value for the 9th bit (it works). The device responds. I can transmit the next byte with a delay long enough for me to check the parity.
The problem is, I can't determine whether there's a parity error when receiving.
I tried using the "OnError" and "OnRxFlag" events, but they never fire. Maybe I'm doing something wrong...

[LeP]

You can start from here: https://stackoverflow.com/questions/14212660/how-to-access-my-9-data-bit-serial-port-on-a-pc

But I'm pretty sure that is not possible without an appropriate hardware.

[MarkMLl]

You can start from here: https://stackoverflow.com/questions/14212660/how-to-access-my-9-data-bit-serial-port-on-a-pc

But I'm pretty sure that is not possible without an appropriate hardware.

Any attempt to do this is- as I've said- likely to be heavily OS-dependent. Even if the hardware supports it.

I agree that link's useful, and there's discussion elsewhere in the context of AVR processors (i.e. as used in Arduinos but not necessarily using the Arduino libraries) where apparently their U(S)ARTS /can/ handle 9 bits.

My own feeling is that the OS- unless it specifically supports it- is going to get in the way: it will either make reliable bit setting and recovery impossible, or it will enforce sufficiently-long delays that communications will be glacial. That's particularly going to be the case if the comms hardware is interfaced via USB where several layers of packetisation must be considered: I've previously discussed related latency with FTDI who could offer no solution.

And off-the-shelf hardware is very likely to use counterfeit chips, at which point all bets are off.

MarkMLl

[avra]

AVR solutions:

https://github.com/jorticus/Arduino-Serial9b
https://github.com/CalvoM/9-bit-tranmission-UART-AVR
https://github.com/chopin1998/avr-mdb-interface


Quick search shows some cards with 16950 UART:

https://www.startech.com/en-us/cards-adapters/pci2s950
https://www.startech.com/en-us/cards-adapters/pex2s953
https://www.siig.com/2-port-rs232-serial-pcie-with-16950-uart.html

Many cards are discontinued, so eBay and similar could be a good source. Make sure that you get a driver for your OS.

[MarkMLl]

Just a mo. Looking at OP's "pretty picture"... I accept that that 9th bit isn't simple parity but are you absolutely sure that it isn't something CRC-like?

Noting Avra's agreement that some AVR chips can handle 9 bits of data, I think it might be worth using one of those on an Arduino-like board to monitor the comms line for an extended period and count the number of 9-bit symbol values encountered.

If, out of the 2^9 = 512 possibilities you actually see only around 256 then the 9th bit can- initially- be ignored: simply drop the parity.

Later on, either have an external device based on an AVR or similar chip which returns each 9-bit symbol as a 16-bit integer, or learn how to implement a USART in an FPGA >:-)

MarkMLl