CBoardENoses.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */

#include "hwdrivers-precomp.h"  // Precompiled headers

#include <mrpt/system/os.h>
#include <mrpt/hwdrivers/CBoardENoses.h>
#include <mrpt/serialization/CMessage.h>
#include <mrpt/math/ops_vectors.h>
#include <iostream>
#include <thread>

using namespace mrpt::math;
using namespace mrpt::obs;
using namespace mrpt::poses;
using namespace mrpt::hwdrivers;
using namespace mrpt::io;
using namespace std;

IMPLEMENTS_GENERIC_SENSOR(CBoardENoses, mrpt::hwdrivers)

/*-------------------------------------------------------------
                    CBoardENoses
-------------------------------------------------------------*/
CBoardENoses::CBoardENoses()
    : m_usbSerialNumber("ENOSE001"), m_COM_port(), m_COM_baud(115200)
{
    m_sensorLabel = "ENOSE";
    first_reading = true;
}

/*-------------------------------------------------------------
                    loadConfig_sensorSpecific
-------------------------------------------------------------*/
void CBoardENoses::loadConfig_sensorSpecific(
    const mrpt::config::CConfigFileBase& configSource,
    const std::string& iniSection)
{
    MRPT_START

    m_usbSerialNumber =
        configSource.read_string(iniSection, "USB_serialname", "", false);

#ifdef _WIN32
    m_COM_port =
        configSource.read_string(iniSection, "COM_port_WIN", m_COM_port);
#else
    m_COM_port =
        configSource.read_string(iniSection, "COM_port_LIN", m_COM_port);
#endif
    m_COM_baud =
        configSource.read_uint64_t(iniSection, "COM_baudRate", m_COM_baud);

    configSource.read_vector(
        iniSection, "enose_poses_x", vector<float>(0), enose_poses_x, true);
    configSource.read_vector(
        iniSection, "enose_poses_y", vector<float>(0), enose_poses_y, true);
    configSource.read_vector(
        iniSection, "enose_poses_z", vector<float>(0), enose_poses_z, true);

    configSource.read_vector(
        iniSection, "enose_poses_yaw", vector<float>(0), enose_poses_yaw, true);
    configSource.read_vector(
        iniSection, "enose_poses_pitch", vector<float>(0), enose_poses_pitch,
        true);
    configSource.read_vector(
        iniSection, "enose_poses_roll", vector<float>(0), enose_poses_roll,
        true);

    ASSERT_(enose_poses_x.size() == enose_poses_y.size());
    ASSERT_(enose_poses_x.size() == enose_poses_z.size());
    ASSERT_(enose_poses_x.size() == enose_poses_yaw.size());
    ASSERT_(enose_poses_x.size() == enose_poses_pitch.size());
    ASSERT_(enose_poses_x.size() == enose_poses_roll.size());

    // Pass angles to radians:
    enose_poses_yaw *= M_PIf / 180.0f;
    enose_poses_pitch *= M_PIf / 180.0f;
    enose_poses_roll *= M_PIf / 180.0f;

    MRPT_END
}

/*-------------------------------------------------------------
                    queryFirmwareVersion
-------------------------------------------------------------*/
bool CBoardENoses::queryFirmwareVersion(string& out_firmwareVersion)
{
    try
    {
        mrpt::serialization::CMessage msg, msgRx;

        // Try to connect to the device:
        CStream* comms = checkConnectionAndConnect();
        if (!comms) return false;
        auto arch = mrpt::serialization::archiveFrom(*comms);

        msg.type = 0x10;
        arch.sendMessage(msg);

        if (arch.receiveMessage(msgRx))
        {
            msgRx.getContentAsString(out_firmwareVersion);
            return true;
        }
        else
            return false;
    }
    catch (...)
    {
        // Close everything and start again:
        m_stream_SERIAL.reset();
        m_stream_FTDI.reset();
        return false;
    }
}

/*-------------------------------------------------------------
                    checkConnectionAndConnect
-------------------------------------------------------------*/
CStream* CBoardENoses::checkConnectionAndConnect()
{
    // Make sure one of the two possible pipes is open:
    if (!m_stream_FTDI && !m_stream_SERIAL)
    {
        if (!m_COM_port.empty())
            m_stream_SERIAL.reset(new mrpt::comms::CSerialPort);
        else
            m_stream_FTDI.reset(new mrpt::comms::CInterfaceFTDI);
    }

    if (m_stream_FTDI)
    {  // FTDI pipe ==================
        if (m_stream_FTDI->isOpen()) return m_stream_FTDI.get();
        try
        {
            m_stream_FTDI->OpenBySerialNumber(m_usbSerialNumber);
            std::this_thread::sleep_for(10ms);
            m_stream_FTDI->Purge();
            std::this_thread::sleep_for(10ms);
            m_stream_FTDI->SetLatencyTimer(1);
            m_stream_FTDI->SetTimeouts(10, 100);
            return m_stream_FTDI.get();
        }
        catch (...)
        {  // Error opening device:
            m_stream_FTDI->Close();
            return nullptr;
        }
    }
    else
    {  // Serial pipe ==================
        ASSERT_(m_stream_SERIAL);
        if (m_stream_SERIAL->isOpen()) return m_stream_SERIAL.get();
        try
        {
            m_stream_SERIAL->open(m_COM_port);
            m_stream_SERIAL->setConfig(m_COM_baud);
            std::this_thread::sleep_for(10ms);
            m_stream_SERIAL->purgeBuffers();
            std::this_thread::sleep_for(10ms);
            // m_stream_SERIAL->setTimeouts(25,1,100, 1,20);
            m_stream_SERIAL->setTimeouts(50, 1, 100, 1, 20);
            return m_stream_SERIAL.get();
        }
        catch (...)
        {  // Error opening device:
            m_stream_SERIAL->close();
            return nullptr;
        }
    }
}

/*-------------------------------------------------------------
                    getObservation
-------------------------------------------------------------*/
bool CBoardENoses::getObservation(mrpt::obs::CObservationGasSensors& obs)
{
    try
    {
        // Connected?
        CStream* comms = checkConnectionAndConnect();

        if (!comms) return false;

        mrpt::serialization::CMessage msg;
        CObservationGasSensors::TObservationENose newRead;

        obs.m_readings.clear();

        //// Send request:
        // msg.type = 0x11;
        // msg.content.clear();
        // comms->sendMessage( msg );

        //----------------------------MCE-nose
        // FRAME--------------------------------------------------
        // Wait for e-nose frame:   <0x69><0x91><lenght><body><0x96> "Bytes"
        // Where <body> = [Numchamber, Activechamber, N sensors*M chambers*2, 2
        // timestamp] of uint16_t
        // MCE-nose provides a 136B body lenght which makes 140B total frame
        // lenght

        auto arch = mrpt::serialization::archiveFrom(*comms);
        if (!arch.receiveMessage(msg))
        {
            return false;
        }

        // m_state = ssWorking;

        // Copy to "uint16_t":
        ASSERT_((msg.content.size() % 2) == 0);

        vector<uint16_t> readings(
            msg.content.size() /
            2);  // divide by 2 to pass from byte to word. 136B/2 = 68 Words

        if (msg.content.size() > 0)
        {
            // Copy to a vector of 16bit integers:
            memcpy(
                &readings[0], &msg.content[0],
                msg.content.size() * sizeof(msg.content[0]));

            // HEADER Frame [ Nº of chambers/enoses (16b) , Active Chamber
            // (16b)]
            size_t NumberOfChambers = (size_t)readings[0];
            size_t ActiveChamber = (size_t)readings[1];

            // Sensors readings info
            ASSERT_(((readings.size() - 4) % NumberOfChambers) == 0);
            size_t wordsPereNose = (readings.size() - 4) / NumberOfChambers;

            // Process each chamber
            for (size_t i = 0; i < NumberOfChambers; i++)
            {
                // ----------------------------------------------------------------------
                // Each "i" comprises a complete Enose reading: Gas sensors +
                // temperature
                // ----------------------------------------------------------------------

                // Do we have the sensor position?
                if (i < enose_poses_x.size())
                {
                    newRead.eNosePoseOnTheRobot = TPose3D(
                        enose_poses_x[i], enose_poses_y[i], enose_poses_z[i],
                        enose_poses_yaw[i], enose_poses_pitch[i],
                        enose_poses_roll[i]);
                }
                else
                    newRead.eNosePoseOnTheRobot = TPose3D(0, 0, 0, 0, 0, 0);

                // Process the sensor codes:
                newRead.sensorTypes.clear();
                newRead.readingsVoltage.clear();
                newRead.hasTemperature = false;
                newRead.isActive = false;

                // check if active chamber
                if (i == (ActiveChamber)) newRead.isActive = true;

                // process each sensor on this chamber "i"
                for (size_t idx = 0; idx < wordsPereNose / 2; idx++)
                {
                    if (readings[i * wordsPereNose + 2 * idx + 2] !=
                        0x0000)  // not empty slot
                    {
                        // Is temperature?
                        if (readings[i * wordsPereNose + 2 * idx + 2] == 0xFFFF)
                        {
                            newRead.hasTemperature = true;
                            newRead.temperature =
                                ((int16_t)readings
                                     [i * wordsPereNose + 2 * idx + 3]) /
                                32.0f;
                        }
                        else  // Is a gas sensors
                        {
                            // It is not a null code: There is a valid measure:
                            newRead.sensorTypes.push_back(
                                readings[i * wordsPereNose + 2 * idx + 2]);

                            // Pass from ADC value[12bits] to [0-2.5] volt
                            // range:
                            newRead.readingsVoltage.push_back(
                                (readings[i * wordsPereNose + 2 * idx + 3] *
                                 5.0f) /
                                4096.0f);
                        }
                    }
                }  // end for each sensor on this eNose

                // Add to observations:
                if (!newRead.sensorTypes.empty())
                    obs.m_readings.push_back(newRead);

            }  // end for each i'th eNose

            obs.sensorLabel = m_sensorLabel;

            // Set Timestamp
            uint16_t* p =
                (uint16_t*)&readings[readings.size() - 2];  // Get readings time
            // from frame
            // (always last 2
            // words)
            obs.timestamp =
                mrpt::system::time_tToTimestamp(((double)*p) / 1000);

            if (first_reading)
            {
                initial_timestamp =
                    mrpt::system::getCurrentTime() - obs.timestamp;
                first_reading = false;
            }
            obs.timestamp = obs.timestamp + initial_timestamp;

        }  // end if message has data

        // CONTROL
        bool correct = true;

        if (obs.m_readings.size() != 4)
            correct = false;
        else
        {
            for (size_t ch = 0; ch < obs.m_readings.size(); ch++)
            {
                if ((obs.m_readings[ch].sensorTypes.size() != 7) ||
                    (obs.m_readings[ch].readingsVoltage.size() != 7))
                    correct = false;
                else
                {
                }
            }
        }

        if (!correct) printf("Error en la observacion");  // For debug

        return !obs.m_readings.empty();  // Done OK!
    }
    catch (exception& e)
    {
        cerr << "[CBoardENoses::getObservation] Returning false due to "
                "exception: "
             << endl;
        cerr << e.what() << endl;
        return false;
    }
    catch (...)
    {
        return false;
    }
}

/*-------------------------------------------------------------
                    doProcess
-------------------------------------------------------------*/
/** This method should be called periodically (at least at 1Hz to capture ALL
 * the real-time data)
 *  It is thread safe, i.e. you can call this from one thread, then to other
 * methods from other threads.
 */
void CBoardENoses::doProcess()
{
    CObservationGasSensors::Ptr obs =
        mrpt::make_aligned_shared<CObservationGasSensors>();

    if (getObservation(*obs))
    {
        m_state = ssWorking;
        appendObservation(obs);
    }
    else
    {
        m_state = ssError;
        // THROW_EXCEPTION("No observation received from the USB board!");
    }
}

/*-------------------------------------------------------------
                    initialize
-------------------------------------------------------------*/
/** Tries to open the camera, after setting all the parameters with a call to
 * loadConfig.
 *  \exception This method must throw an exception with a descriptive message
 * if some critical error is found.
 */
void CBoardENoses::initialize()
{
    // We'll rather try it in doProcess() since it's quite usual that it fails
    //  on a first try, then works on the next ones.
    /*
    if (!checkConnectionAndConnect())
        THROW_EXCEPTION("Couldn't connect to the eNose board");
    */
}

/*-------------------------------------------------------------
                    setActiveChamber
-------------------------------------------------------------*/
/** Send to the MCE-nose the next Active Chamber */

bool CBoardENoses::setActiveChamber(unsigned char chamber)
{
    try
    {
        // Try to connect to the device:
        CStream* comms = checkConnectionAndConnect();
        if (!comms) return false;

        // Send a byte to set the Active chamber on device.
        // by default:  Byte_to_send = 10_ _ _ _10
        unsigned char buf[1];
        buf[0] = ((chamber & 15) << 2) | 130;  // 130= 10 0000 10

        comms->Write(buf, 1);  // Exceptions will be raised on errors here
        return true;
    }
    catch (...)
    {
        // Close everything and start again:
        m_stream_SERIAL.reset();
        m_stream_FTDI.reset();
        return false;
    }
}