MSOxxxx.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//
//  Package    : MSOxxxx
//
//  Description:
//
//  Author(s)  : Joan Mauricio
//  Date       : 2014/06/05
//
//------------------------------------------------------------------------------

// local include file
#include "MSOxxxx.h"

//Constructor
MSOxxxx::MSOxxxx()
{
    setType("MSOxxxx");
    setId(0);

    add(Attrib::ELEMENT); add (Attrib::HARDWARE);
    debug("MSOxxxx built.","MSOxxxx::MSOxxxx");

    ipAddress   = DEFAULT_IP_ADDRESS;                                   //We configure a default IP here. User can change it afterwards.
    portNumber  =   DEFAULT_PORT;
    debugMode       = DEBUG_MODE;

}


void MSOxxxx::configTCPIP(string ip, int port)          //IP and TCP port configuration.
{
    if(ip!= "DEFAULT")                                                              //IP is only changed when the input string is different to "DEFAULT".
        ipAddress = ip;  
    if(port > 0)                                                                            //Port is only changed when the input value is greater than 0.
        portNumber = port;
}

StatusCode MSOxxxx::open()
{
    struct hostent *server;
    struct sockaddr_in servAddr;

    info("IP address / TCP Port: " + ipAddress + " / " + itos(portNumber),"MSOxxxx::open");

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) 
    {
        error("ERROR opening socket","MSOxxxx::open");
        return StatusCode::FAILURE;
    }
    else
    {
        server = gethostbyname(ipAddress.c_str());
        if (server == NULL)
        {
            error("No such host.","MSOxxxx::open");
            return StatusCode::FAILURE;
        }
        else
        {
            bzero((char *) &servAddr, sizeof(servAddr));
            servAddr.sin_family = AF_INET;
            bcopy((char *)server->h_addr, (char *)&servAddr.sin_addr.s_addr, server->h_length);
            servAddr.sin_port = htons(portNumber);

            if (connect(sockfd,(struct sockaddr *) &servAddr,sizeof(servAddr)) < 0) //Socket is opened here.
            {
                error("Connection could not be established.","MSOxxxx::open");
                return StatusCode::FAILURE;
            }
            else 
                info("Connection established.","MSOxxxx::open");
                return StatusCode::SUCCESS;
        }
    }
}

//Sends the message to the oscilloscope. If something goes wrong, it will report it.
bool MSOxxxx::send(string msg)          
{
    if(debugMode)
        info(msg,"MSOxxxx::send");

    int n = write(sockfd,msg.c_str(),msg.length());
    if (n < 0)
    {
        error("Socket write error.","MSOxxxx::send");
        return false;
    }
    else return true;
}

int MSOxxxx::recv(string *msgItems, string spacer=",")
{
    string rxMsg;
    int nRead, nItems, buffPos=0;
    bool endData=false;

    do          //Data is stored in 'rxBuffer', a 1-MByte private char*.
    {
        nRead = read(sockfd,rxBuffer+buffPos,MAX_LEN);  //Data is appended to 'rxBuffer'
        buffPos += nRead;
        if(nRead > 0)                                                                       //until '\n' is found, or error.
        {
            if(rxBuffer[buffPos-1] == '\n') endData = true;
        }
        else endData = true;
    }
    while(!endData); 

    if(nRead == -1)                                                                     //Error handling.
    {
        error("Socket read error.","MSOxxxx::recv");
        return -1;
    }
    else                                                                                    //The char* is converted to an array of strings.
    {
        rxBuffer[buffPos-1] = '\0';                                 //IMPORTANT!!! char* delimiter!!!
        rxMsg = string(rxBuffer);                                       //To string.
        nItems = split(rxMsg,msgItems,spacer);          //To an array of strings.

        if(debugMode)
            info(rxMsg,"MSOxxxx::recv");

        return nItems;
    }
}


StatusCode MSOxxxx::channelScale(int ch, double value)
{
    bool ok = send(":CHANNEL" + itos(ch) + ":SCALE " + ftos(value) + "\n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE;
}

StatusCode MSOxxxx::channelOffset(int ch, double value)
{
    bool ok = send(":CHANNEL" + itos(ch) + ":OFFSET " + ftos(value) + "\n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE;
}

StatusCode MSOxxxx::channelDisplay(int ch, bool display)
{
    bool ok;
    if(display)     
        ok = send(":CHANNEL" + itos(ch) + ":DISPLAY ON \n");
    else
        ok = send(":CHANNEL" + itos(ch) + ":DISPLAY OFF \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

StatusCode MSOxxxx::channelDisplayName(int ch, string name)
{
    bool ok = send(":CHANNEL" + itos(ch) + ":LABEL \"" + name + "\" \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}


StatusCode MSOxxxx::timeBaseScale(double secsPerDiv)
{
    bool ok = send(":TIMEBASE:SCALE " + ftos(secsPerDiv) + " \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

StatusCode MSOxxxx::timeBaseOffset(double seconds)
{
    bool ok = send(":TIMEBASE:POSITION " + ftos(seconds) + " \n");  
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

bool MSOxxxx::getTimeBase(double *xInc, double *xOrg)
{
    bool ok;
    int nRxItems;

    ok = send(":WAVeform:XINCrement?\n");
    nRxItems = recv(rxItems);
    if(ok && nRxItems > 0)
    {
        *xInc = atof(rxItems[0].c_str());
        send(":WAVeform:XORigin?\n");       
        nRxItems = recv(rxItems);

        if(ok && nRxItems > 0)
        {
            *xOrg = atof(rxItems[0].c_str());
            return true;
        }
        else return false;
    }
    else return false;
}


StatusCode MSOxxxx::triggerAuto()
{
    bool ok = send(":TRIGger:SWEep AUTO\n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

StatusCode MSOxxxx::triggerConfig(bool slope, int ch, double level)
{
    bool ok;

    if(slope) ok  = send(":TRIGger:EDGE:SLOpe POSitive\n");
    else            ok  = send(":TRIGger:EDGE:SLOpe NEGative\n");
                        ok |= send(":TRIGger:EDGE:SOURce CHANnel" + itos(ch) + " \n");
                        ok |= send(":TRIGger:LEVel CHANnel" + itos(ch) + "," + ftos(level) + " \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}


//Configures Jitter measurement.
StatusCode MSOxxxx::setupJitter(int ch)
{   
    bool ok;
    //Previous measures are cleared, and period measurement in statistics mode is configured.
    ok  = send(":MEASure:CLEar\n");
    ok |= send(":SYSTem:HEADer OFF\n");    
    ok |= send(":MEASure:STATistics ON\n");
    ok |= send(":MEASure:PERiod CHAnnel"+itos(ch)+"\n");

    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

//Configures delta time measurement.
StatusCode MSOxxxx::setupDeltaTime(int chA,int chB,int edge)
{ 
    bool ok;
    ok  = send(":MEASure:CLEar\n");
    ok |=   send(":MEASure:DELTatime:DEFine RISing,1,MIDDle,RISing,"+itos(edge)+",MIDDle\n");
    ok |= send(":MEASure:STATistics ON\n");
    ok |= send(":MEASure:DELTatime CHANNel"+itos(chA)+",CHANNel"+itos(chB)+"\n");

    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

//Configures Average voltage measurement.
StatusCode MSOxxxx::setupAvgVoltage(int ch)
{
    bool ok;
    ok  = send(":MEASure:CLEar\n");
    ok |=   send(":SYSTem:HEADer OFF\n");    
    ok |=   send(":MEASure:STATistics ON\n");
    ok |=   send(":MEASURE:VAVERAGE DISPLAY,CHANNEL"+itos(ch)+"\n");

    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}

PyObject* MSOxxxx::waveformCapture(int ch)
{
    PyObject* waveform = PyList_New(0);
    double xOrigin, xIncrement;
    int nRxItems, iItems;
    bool ok;

    ok  = getTimeBase(&xIncrement, &xOrigin);
    ok |= send(":RUN \n");                                                                  //We get sure that oscilloscope is in RUN mode.
    ok |= send(":DIGitize CHANnel"+itos(ch)+"\n");                  //Select channel
    ok |= send(":CHANnel"+itos(ch)+":DISPlay ON\n");                //Enable display of channel
    ok |= send(":WAVeform:FORMat ASCii\n");                                 //Setup transfer format
    ok |= send(":WAVeform:BYTeorder LSBFirst\n");
    ok |= send(":WAVeform:SOURce CHANnel"+itos(ch)+"\n");   //Waveform data source channel
    ok |= send(":WAVeform:STReaming 1\n");                                  //Turn on waveform streaming of data
    ok |= send(":WAVeform:DATA?\n");                                                //Retrieves data.

    nRxItems = recv(rxItems);                                                               //Data is received here.
    ok |= send(":RUN \n");                                                                  //Once done, let's push 'run' button again.

    if(ok)
    {
        for(iItems=0 ; iItems<nRxItems-1 ; iItems++)
        {
            //Pair list items are timestamps.
            //Odd  list items are amplitude values.
            PyList_Append(waveform, PyFloat_FromDouble(((double)iItems * xIncrement) + xOrigin));
            PyList_Append(waveform, PyFloat_FromDouble(atof(rxItems[iItems].c_str())));
        }
    }
    return waveform;
}

//Returns a list with the min, max, mean and stedev of 'nMinMeas' measured samples.
PyObject* MSOxxxx::getStatistics(int nMinMeas)
{   
    bool            ok = true;
    int             nRxItems=7, nMeas=0;
    PyObject* statistics = PyList_New(0);

    //We do that until we have enough statistics and everything is ok.
    while(ok && nRxItems == 7 && nMeas < nMinMeas)
    {
        sleep(1);                                                                   //Wait 1 second...
        ok |= send(":MEASure:Results?\n");              //Ask for the statistics.
        nRxItems = recv(rxItems);                                   //Statistics are received.
        nMeas = (int) atof(rxItems[6].c_str());     //The last item contains #Measurements.
    }
    if(!ok || nRxItems != 7)                                        //The number of Rx params is incorrect or read error.
    {
        error("Malformed packet. Try it again!","MSOxxxx::getJitter");
    }
    else            //At this point everything is ok. Let's return a Python list with all the statistics.
    {
        PyList_Append(statistics, PyFloat_FromDouble(atof(rxItems[2].c_str())));        //Min
        PyList_Append(statistics, PyFloat_FromDouble(atof(rxItems[3].c_str())));        //Max
        PyList_Append(statistics, PyFloat_FromDouble(atof(rxItems[4].c_str())));        //Mean
        PyList_Append(statistics, PyFloat_FromDouble(atof(rxItems[5].c_str())));        //Stdev
    }
    return statistics;
}














StatusCode MSOxxxx::labelDisplay(bool display)
{
    bool ok;
    if(display)     
        ok = send(":DISPLAY:LABEL ON \n");
    else
        ok = send(":DISPLAY:LABEL OFF \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE; 
}


PyObject* MSOxxxx::id()
{   
    bool ok;
    int nRxItems;
    PyObject* idList = PyList_New(0);
    
    ok = send("*IDN? \n");
    if(ok)  nRxItems = recv(rxItems);
    if(ok && nRxItems == 4)
    {
        info("Oscilloscope : " + rxItems[0],"MSOxxxx::id");
        info("Model        : " + rxItems[1],"MSOxxxx::id");
        info("Serial Number: " + rxItems[2],"MSOxxxx::id");
        info("SW Version   : " + rxItems[3],"MSOxxxx::id");
        for(int i=0; i<4; i++)
            PyList_Append(idList, PyString_FromString(rxItems[i].c_str()));
    }
    return idList;
}

StatusCode MSOxxxx::run()
{
    bool ok = send(":RUN \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE;
}

StatusCode MSOxxxx::stop()
{
    bool ok = send(":STOP \n");
    if(ok)  return StatusCode::SUCCESS;
    else        return StatusCode::FAILURE;
}

//Splits a string into small strings accorgint to 'delimiter'
int MSOxxxx::split(string str, string *splitStr, string delimiter)
{
    unsigned int delimPos = str.find(delimiter);
    int nStrings = 0;

    while(delimPos != string::npos)     //While there is a "," , "." , " " or whatever...
    {
        splitStr[nStrings++] = str.substr(0,delimPos);      //We put the previous characters to the delimiter to a string array.
        str = str.substr(delimPos+1,string::npos);              //We remove that characters and the delimiter.
        delimPos = str.find(delimiter);                                     //The new position of the delimiter in the string.
    }
    splitStr[nStrings++] = str;         //The last string (with no more delimitters) are put to the last string array.
    return nStrings;
}

string MSOxxxx::ftos(double f)
{
    std::ostringstream buffer;
    buffer << std::setprecision(7) << std::scientific << f;
    return buffer.str();
}

void MSOxxxx::reset()
{

}