Question

I’m trying to establish a SerialPort connection which transfers 16 bit data packages at a rate of 10-20 kHz. Im programming this in C++/CLI. The sender just enters an infinte while-loop after recieving the letter “s” and constantly sends 2 bytes with the data.

A Problem with the sending side is very unlikely, since a more simple approach works perfectly but too slow (in this approach, the reciever sends always an “a” first, and then gets 1 package consisting of 2 bytes. It leads to a speed of around 500Hz).
Here is the important part of this working but slow approach:

public: SerialPort^ port;

in main:
Parity p = (Parity)Enum::Parse(Parity::typeid, "None");
StopBits s = (StopBits)Enum::Parse(StopBits::typeid, "1");
port = gcnew SerialPort("COM16",384000,p,8,s);
port->Open();

and then doing as often as wanted:
port->Write("a");
int i = port->ReadByte();
int j = port->ReadByte();

This is now the actual approach im working with:

static int values[1000000];
static int counter = 0;

void reader(void)
    {
        SerialPort^ port;
        Parity p = (Parity)Enum::Parse(Parity::typeid, "None");
        StopBits s = (StopBits)Enum::Parse(StopBits::typeid, "1");
        port = gcnew SerialPort("COM16",384000,p,8,s);
        port->Open();
        unsigned int i = 0;
        unsigned int j = 0;
        port->Write("s"); //with this command, the sender starts to send constantly
        while(true)
        {
            i = port->ReadByte();
            j = port->ReadByte();
            values[counter] = j + (i*256);
            counter++;
        }
    }

in main:
Thread^ readThread = gcnew Thread(gcnew ThreadStart(reader));
readThread->Start();

The counter increases (much more) rapidly at a rate of 18472 packages/s, but the values are somehow wrong.
Here is an example:
The value should look like this, with the last 4 bits changing randomly (its a signal of an analogue-digital converter):

111111001100111 

Here are some values of the threaded solution given in the code:

1110011001100111 
1110011000100111 
1110011000100111 
1110011000100111

So it looks like the connection reads the data in the middle of the package (to be exact: 3 bits too late). What can i do? I want to avoid a solution where this error is fixed later in the code while reading the packages like this, because I don’t know if the the shifting error gets worse when I edit the reading code later, which I will do most likely.

Thanks in advance,

Nikolas

PS: If this helps, here is the code of the sender-side (an AtMega168), written in C.

uint8_t activate = 0;

void uart_puti16(uint16_t val) //function that writes the data to serial port
{

    while ( !( UCSR0A & (1<<UDRE0)) ) //wait until serial port is ready
            nop(); // wait 1 cycle
            UDR0 = val >> 8; //write first byte to sending register
    while ( !( UCSR0A & (1<<UDRE0)) ) //wait until serial port is ready
            nop(); // wait 1 cycle
            UDR0 = val & 0xFF; //write second byte to sending register
}

in main:
while(1)
{
        if(active == 1)
        {   
            uart_puti16(read()); //read is the function that gives a 16bit data set
        }               
}

ISR(USART_RX_vect) //interrupt-handler for a recieved byte
{
        if(UDR0 == 'a') //if only 1 single data package is requested
        {
            uart_puti16(read());
        }
        if(UDR0 == 's') //for activating constant sending
        {
            active = 1;
        }
        if(UDR0 == 'e') //for deactivating constant sending
        {
            active = 0;
        }
}

Answer 1

At the given bit rate of 384,000 you should get 38,400 bytes of data (8 bits of real data plus 2 framing bits) per second, or 19,200 two-byte values per second.

How fast is counter increasing in both instances? I would expect any modern computer to keep up with that rate whether using events or directly polling.

You do not show your simpler approach which is stated to work. I suggest you post that.

Also, set a breakpoint at the line

values[counter] = j + (i*256);

There, inspect i and j. Share the values you see for those variables on the very first iteration through the loop.