loop to discard spurious variable input from stdin, Linux C++

Question

I am trying to write a c++ program for my linux machine that can interact with some instrumentation that responds to simple ascii commands. The problem I'm running into, I would think, would be a fairly common request but my searches of various forums came up with nothing quite the same.

My problem is this: When I connect to the instrument, due to some communication issues, it often pukes up a bunch of data of varying length that I don't want. The data the machine prints has line endings with '\r'. I have been trying to write a simple loop what will keep reading and ignoring data until the machine is quiet for two seconds, then carry on to perform some data requests once the storm is over.

When searching forums, I found gobs and gobs of threads about cin.ignore, cin.sync, getline and cin.getline. These all seemed quite useful but when I attempted to implement them in a way that should be simple, they never behaved quite as I expected them to.

I apologize in advance if this is a duplicate post as I would have thought I wasn't the first person to want to throw away garbage input but I have found no such post.

The code I have been trying a few different arrangements of looks something like this:

sleep(2);
cin.clear();
while ( cin.peek() != char_traits<char>::eof()) {
    //cin.sync();
    //cin.ignore(numeric_limits<streamsize>::max(),char_traits<char>::eof());
    cin.clear();
    char tmp[1];
    while ( cin.getline(tmp,80,'\r') ) {}
    cin.clear();
    sleep(2);
}

I understand from my searches that doing some sort of while(!cin.eof()) is bad practice but tried it anyway for grins as well as while(getline(cin,str,'\r')) and while(cin.ignore()). I am at a loss here as there is clearly something I'm missing.

Thoughts?

EDIT: --final code--

Alright! This did it! Thanks for point me to termios @MatsPetersson! I wound up stealing quite a lot of your code, but I'm glad I had the opportunity to figure out what was going on. This website helped me make sense of the tcassert manual page: http://en.wikibooks.org/wiki/Serial_Programming/termios

#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <limits>
#include <termios.h>
#include <errno.h>
#include <cassert>

using namespace std;
const int STDIN_HANDLE=fileno(stdin);
int main()
{
    string str;

    //Configuring terminal behavior
    termios tios, original;
    assert( tcgetattr(STDIN_HANDLE, &tios)==0 );
    original = tios;

    tios.c_lflag &= ~ICANON;   // Don't read a whole line at a time. 
    tios.c_cc[VTIME] = 20;   // 0.5 second timeout. 
    tios.c_cc[VMIN]  = 0;   // Read single character at a time.

    assert( tcsetattr(STDIN_HANDLE, TCSAFLUSH, &tios)==0 );

    const int size=999; //numeric_limits<streamsize>::max() turns out to be too big.
    char tmp[size];
    int res;
    cerr << "---------------STDIN_HANDLE=" << STDIN_HANDLE << endl;
    cerr << "---------------enter loop" << endl;
    while ( res=read(STDIN_HANDLE, tmp, sizeof(tmp)) ) {
        cerr << "----read: " << tmp << endl;
    }
    cerr << "--------------exit loop" << endl;

    cout << "END";
    assert( tcsetattr(STDIN_HANDLE, TCSANOW, &original)==0 );
    return 0;
}

That wasn't as bad as I began to fear it would be! Works perfectly! Obviously all the cerr << -- lines are not necessary. As well as some of the #include's but I'll use them in the full program so I left them in for my own purposes.

Well... It mostly works anyway. It works fine so long as I don't redirect the stdio for the program to a tcp-ip address using socat. Then it gives me a "Not a Typewriter" error which is what I guess happens when it attempts to control something that isn't a tty. That sounds like a different question though, so I'll have to leave it here and start again I guess.

Thanks folks!

Answer 1

Here's a quick sample of how to do console input (and can easily be adapted to do input from another input source, such as a serial port).

Note that it's hard to "type fast enough" for this to read more than one character at a time, but if you copy'n'paste, it will indeed read 256 characters at once, so assuming your machine that you are connecting to is indeed feeding out a large amount of stuff, it should work just fine to read large-ish chunks - I tested it by marking a region in one window, and middle-button-clicking in the window running this code.

I have added SOME comments, but for FULL details, you need to do man tcsetattr - there are a whole lot of settings that may or may not help you. This is configured to read data of "any" kind, and exit if you hit escape (it also exits if you hit an arrow-key or similar, because those translate to an ESC-something sequence, and thus will trigger the "exit" functionality. It's a good idea to not crash out of, or set up some handler to restore the terminal behaviour, as if you do accidentally exit before you've restored to original setting, the console will act a tad weird.

#include <termios.h>
#include <unistd.h>
#include <cassert>
#include <iostream>

const int STDIN_HANDLE = 0;

int main()
{
    termios tios, original;
    int     status;

    status = tcgetattr(STDIN_HANDLE, &tios);
    assert(status >= 0);

    original = tios;

    // Set some input flags
    tios.c_iflag &= ~IXOFF;   // Turn off XON/XOFF... 
    tios.c_iflag &= ~INLCR;   // Don't translate NL to CR.

    // Set some output flags
    // tios.c_oflag = ... // not needed, I think. 

    // Local modes flags.
    tios.c_lflag &= ~ISIG;    // Don't signal on CTRL-C, CTRL-Z, etc.
    tios.c_lflag &= ~ICANON;   // Don't read a whole line at a time. 
    tios.c_lflag &= ~(ECHO | ECHOE | ECHOK);    // Don't show the input. 

    // Set some other parameters
    tios.c_cc[VTIME] = 5;   // 0.5 second timeout. 
    tios.c_cc[VMIN]  = 0;   // Read single character at a time.

    status = tcsetattr(STDIN_HANDLE, TCSANOW, &tios);
    assert(status >= 0);

    char buffer[256];
    int tocount = 0;

    for(;;)
    {
    int count = read(STDIN_HANDLE, buffer, sizeof(buffer));
    if (count < 0)
    {
        std::cout << "Error..." << std::endl;
        break;
    }
    if (count == 0)
    {
        // No input for VTIME * 0.1s. 
        tocount++;
        if (tocount > 5)
        {
        std::cout << "Hmmm. No input for a bit..." << std::endl;
        tocount = 0;
        }
    }
    else
    {
        tocount = 0;
        if (buffer[0]== 27)  // Escape
        {
        break;
        }
        for(int i = 0; i < count; i++)
        {
        std::cout << std::hex << (unsigned)buffer[i] << " ";
        if (!(i % 16))
        {
            std::cout << std::endl;
        }
        }

    std::cout << std::endl;
    }
    }
    status = tcsetattr(STDIN_HANDLE, TCSANOW, &original);
    return 0;
}

Answer 2

If your instrumentation offers a stream interface, and assuming that it would wait before returning whenever no input is available, I'd suggest to simply use :

cin.ignore(numeric_limits<streamsize>::max(),'\r'); // ignore everything until '\r'

Another alternative could be to use poll, which provides a mechanism for multiplexing (and waiting for) input/output over a set of file descriptors. This has the advantage of letting you read several instrumentation devices if you'd need.