Asynchronous data reading from a barcode scanner over RS232 serial port

Question 1

/**
 * Receive responses from the decoder
 */
int DeviceRS232::receiveDecodedData(unsigned char *dataBuffer, size_t bufferSize)
{
    unsigned char recvBuffer[251];
    unsigned char *ptrChar;
    int nBytes, portStatus;
    int inputBufSize = 0;

    ChangeCTS(fdRS232, 0);
    ChangeRTS(fdRS232, 0);

    while(inputBufSize <= 0)
    {
        ioctl(fdRS232, FIONREAD, &inputBufSize);
        usleep(1);
    }


    if(inputBufSize > 0)
    {
        int decodePacketLen = 0;
        //unsigned char
        memset(recvBuffer, 0x00, sizeof(recvBuffer));
        nBytes = 0;

        //usleep(100000);
        while(nBytes < ((int)recvBuffer[0] + 2))
        {
            int index = 0;
            int recvDataLen = 0;
            if(nBytes != 0)
                index = nBytes - 1;

            recvDataLen = read(fdRS232, &recvBuffer[index], 251);
            if(recvDataLen < 0)
            {
                std::cout << "[INFO@DeviceRS232::receiveDecodedData]File read error: " << strerror(errno) << std::endl;
                //sleep(1);
            }

            nBytes += recvDataLen;
            if(nBytes == ((int)recvBuffer[0] + 2))
                break;

        }

        if(recvBuffer[1] == DECODE_DATA)
            sendCommandToDecoder(OPCODE_ACK);

        std::cout << "[INFO @ DeviceRS232::receiveDecodedData]Data Lenght (without CheckSum) : " << (int)recvBuffer[0] << std::endl;

        for(int i=0; i<nBytes; i++)
        {
            std::cout << "recvBuffer[" << i << "]: ";
            printf("%x\n", recvBuffer[i]);
        }
        std::cout << "-----------------------------------" << std::endl;

        ChangeRTS(fdRS232, 1);
        ChangeCTS(fdRS232, 1);
        //sleep(1);
    }

    //strcpy((char *)dataBuffer, (char *)recvBuffer);
    memcpy((char *)dataBuffer, recvBuffer, sizeof(recvBuffer)/sizeof(recvBuffer[0]));
    inputBufSize = 0;

    return nBytes;

}


/**
 * Send commands to the decoder.
 */
int DeviceRS232::sendCommandToDecoder(unsigned int opCode)
{
    unsigned char *commandBuffer;
    int commandLength;

    switch(opCode)
    {
    case OPCODE_ACK:
        {
            unsigned char ackString[] = {0x00, 0xD0, 0x04, 0x00};
            commandLength = sizeof(ackString);
            commandBuffer = ackString;
        }
        break;
    case OPCODE_PARAM_SEND:
        {
            unsigned char paramSendString[] = {0x00, 0xC6, 0x04, 0x08, 0x00, 0xEE, 0x01};
            commandLength = sizeof(paramSendString);
            commandBuffer = paramSendString;
        }
        break;
    default:
        break;
    }

    Message msgCommand(commandBuffer, commandLength);

    return sendDataBuffer(msgCommand.getCommandData(), msgCommand.getLen());
}

Required constants defined in DeviceRS232.h header file.

Question 2

As others have noted, one suspect area is the number of bytes you're sending. Instead of always sending 257 bytes, the barcode reader is probably expecting just the number of bytes in the command and no more.

Also, your code has a number of repeated operations for calculating the checksum at the end of the message. That suggests a class would help streamline the design. Here, then, is a Message class for that purpose:

#include <vector>
#include <numeric>
#include <string>

class Message 
{
public:
    Message(const std::basic_string<unsigned char> msg) : mymsg(msg) { 
        mymsg[0] = mymsg.length(); appendChecksum(); };
    Message(const unsigned char *msg, int msglen) : mymsg(msg, msglen) { 
        mymsg[0] = mymsg.length(); appendChecksum(); };
    const unsigned char *getData() const { return mymsg.c_str(); }
    size_t getLen() const { return mymsg.length(); }

private:
        int appendChecksum();
        std::basic_string<unsigned char> mymsg;
};


int Message::appendChecksum()
{
    int sum = -std::accumulate(mymsg.begin(), mymsg.end(), 0);
    mymsg.push_back(0xff & (sum >> 8));
    mymsg.push_back(0xff & sum);
    return sum;
}

Now within your main routine, you can eliminate several dozen lines of code and use these instead (if you're using C++11):

    Message setparams{{0x00, 0xc6, 0x04, 0x08, 0x11, 0xee, 0x01}};
    Message beep{{0x00, 0xe6, 0x04, 0x00, 0x05}};
    Message getrevision{{0x00, 0xA3, 0x04, 0x00}};
    Message ledOn{{0x00, 0xe7, 0x04, 0x00, 0x0d, 0x00}};

If you're not using C++11 (which would be a shame!) you can use this slightly less clean style instead:

unsigned char parms[] = {0x00, 0xc6, 0x04, 0x08, 0x11, 0xee, 0x01};
Message setparams(parms,sizeof(parms)/sizeof(parms[0]));

Note that the first byte is set to zero instead of the length. This is done because the constructor automatically calculates and sets the proper length in that byte just before it calculates and appends the checksum. There are other ways to do this, of course, but I'll leave that to you.

Finally, with your loop, you can now use this line:

int sizeSent = dev_rs232.sendDataBuffer(beep.getData(), beep.getLen());

That may or may not actually solve the problem, but it will assist you to have a cleaner program to start with.

Also, a few pieces of style and design advice:

get out of the habit of using namespace std
use iostream instead of printf
instead of having to call setDefaultAttributes() immediately after creating the device, have the constructor set up sane defaults
eliminate "magic numbers" such as 4096 for the receive buffer size. Instead, use named static const. It will make the program more understandable and maintainable.
consider using an existing library such as boost::asio instead of rolling your own

Good luck!

Edit: Based on your keen (and correct!) observation that the Message constructor doesn't work properly when fed a plain unsigned char *, I've added a second constructor and modified the non C++11 version of the code. Sorry for any inconvenience, and thanks for keeping me honest.