CODEWITHSUNDEEP
c++.netserial-port
user1530242
user1530242

Reputation: 33

fast reading constant data stream from serial port in C++.net

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;
        }
}

Upvotes: 3

Views: 3085

Answers (2)

sarnold
sarnold

Reputation: 104090

This is a guess based entirely on reading the code at http://msdn.microsoft.com/en-us/library/system.io.ports.serialport.datareceived.aspx#Y228. With this caveat out of the way, here's my guess:

Your event handler is being called when data is available to read -- but you are only consuming two bytes of the available data. Your event handler may only be called every 1024 bytes. Or something similar. You might need to consume all the available data in the event handler for your program to continue as expected.

Try to re-write your handler to include a loop that reads until there is no more data available to consume.

Upvotes: 0

Eric J.
Eric J.

Reputation: 150208

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.

Upvotes: 2

Related Questions