src/master/cdm_link.cpp

/*
    File: cdm_Link.c
    Data from/to HOST management (sending,...)
    Angel Perles. May 2009. May 2010.
    Version for qt (depends on qextserialport project)

*/

#define MAX_RECEIVE_BUFFER  10000
#define TIMEOUT_MS          1000    // timout for message reception


#include <cdm_link.h>

#include <qextserialport.h>
#include <string.h>

#ifdef Q_OS_UNIX
#include <unistd.h>     /*  *nix sleep() */
#endif

static bool serial_ready = false;
static QextSerialPort *port = 0; // pointer to the serial port handler



/****************************************************************************/
/* Module initilization                                                     */
/* in this implementation, "params" will be de serial port identifier                */
cdm_Error cdm_LinkInit(const char *params) {

    // test if serial port handler has been created and create it if necessary
    if (port == 0) {
        port = new QextSerialPort();
        port->setQueryMode(QextSerialPort::Polling);  // modo mas sencillo
        serial_ready = false;
    }

    // if port is open, then close it
    if (serial_ready) {
        port->close();
        serial_ready = false;
    }

    // configure port parameters
    port->setPortName(params);
    port->setBaudRate (BAUD9600);
    port->setDataBits(DATA_8);
    port->setStopBits(STOP_1);
    port->setParity(PAR_NONE);
    port->setFlowControl(FLOW_OFF);

    if (!port->open(QextSerialPort::ReadWrite)) {
        return (CD_Error_UnableToOpenLink);
    }

    serial_ready = true;
    return(CD_Error_NoError);
}

/****************************************************************************/
/* Module initilization                                                     */
/* in this implementation, "params" will be de serial port identifier                */
cdm_Error cdm_LinkClose(void) {

    // test if serial port handler has been created and create it if necessary
    if (port != 0) {
        port->close();
        serial_ready = false;
    }
    return(CD_Error_NoError);
}


/****************************************************************************/
/* implementation of the low level link data reception         */
cdm_Error cdm_LinkRXStr(char *receive_buffer, int max_bytes, int *received_bytes) {

    int bytes_available;

    if (!serial_ready) {
        return(CD_Error_LinkNotReady);
    }

    bytes_available = port->bytesAvailable();
    if (bytes_available < 0) {
        return(CD_Error_LinkNotReady);
    }

    if (bytes_available > 0) {
        if (bytes_available > max_bytes) {
            bytes_available = max_bytes;
        }
        port->read(receive_buffer, bytes_available);
        *received_bytes = bytes_available;
    } else {
        *received_bytes = 0;
    }

    return(CD_Error_NoError);
}



/****************************************************************************/
/* str to be transfered                                                     */
cdm_Error cdm_LinkTXStr(const char *msg) {

    if (!serial_ready) {
        return(CD_Error_LinkNotReady);
    }

    port->write(msg);

    return(CD_Error_NoError);
}



/* reception buffer */
static char receive_buffer[MAX_RECEIVE_BUFFER]="";

/****************************************************************************/
/* clears the reception buffer */
void cdm_LinkRXClearBuffer(void) {
    receive_buffer[0]='\0';
}

/****************************************************************************/
/* waits until a valid CheapDAQ slave mesage has been received               */
/* and returns the stripped message or timeout                               */
cdm_Error cdm_LinkRXMessage(char *message) {

    int tmout = TIMEOUT_MS;
    int received_bytes;
    int len;
    cdm_Error cdm_result;

    bool end_found;
    int end_msg;
    bool start_found;
    int start_msg;


    do {
        /* receive data from the link */
        len = strlen((const char*)receive_buffer);
        cdm_result = cdm_LinkRXStr(receive_buffer+len,MAX_RECEIVE_BUFFER-len-1,&received_bytes);
        if (cdm_result != CD_Error_NoError) {
            return(cdm_result);
        }

        /* wait if nothing received */
        if (received_bytes == 0) {
            #ifdef Q_OS_WIN
            Sleep(1);
            #else
            usleep(1000);   // el manual d'unix recomana nanosleep()
            #endif
            tmout--;
        } else {
            // terminate string
            receive_buffer[strlen((const char*)receive_buffer)+received_bytes] = '\0';
            // search end of the message
            end_found = false;
            for (unsigned int i=0;i<strlen((const char*)receive_buffer);i++) {
                if (receive_buffer[i] == MSG_END_CHAR) {    // end of message found!
                    end_msg = i;
                    end_found = true;
                    break;
                }
            }
            // search start of message, and process it if found
            if (end_found) {
                start_found = false;
                for (int i=0;i<end_msg;i++) {
                    if (receive_buffer[i] == MSG_START_CHAR) {    // start of message found!
                        start_msg = i;
                        start_found = true;
                        break;
                    }
                }

                if (start_found) {
                    // message found, return it to caller
                    strncpy(message,receive_buffer+start_msg+1,end_msg-start_msg-1);
                    message[end_msg-start_msg-1] = '\0';
                    strcpy(receive_buffer,(const char *)(receive_buffer+end_msg+1));
                    return (CD_Error_NoError);
                } else {
                    // clear "noise" and continue working
                    strcpy(receive_buffer,(const char*)(receive_buffer+end_msg+1));
                }
            }

        }


    } while (tmout);

    return(CD_Error_Timeout);
}


/* End of file */

---