edtCamera.hpp

Go to the documentation of this file.

/** \file edtCamera.hpp
 * \brief EDT framegrabber interface
 *
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 * \ingroup app_files
 */
 
#ifndef edtCamera_hpp
#define edtCamera_hpp
 
#ifndef MAGAOX_NOEDT
 
    #include <edtinc.h>
 
    #include "../../common/paths.hpp"
 
    #include "ioDevice.hpp"
 
    #include "stdCamera.hpp"
 
namespace MagAOX
{
namespace app
{
namespace dev
{
 
/// MagAO-X EDT framegrabber interface
/** Implements an interface to the EDT PDV SDK
 *
 * The derived class `derivedT` must be a MagAOXApp<true>, and must declare this class a friend like so:
 * \code
 * friend class dev::dssShutter<derivedT>;
 * \endcode
 *
 * A static configuration variable must be defined in derivedT as
 * \code
 * static constexpr bool c_edtCamera_relativeConfigPath = true; //or: false
 * \endcode
 * which determines whether or not the EDT config path is relative to the MagAO-X config path (true) or absolute
 * (false).
 *
 * In addition, `derivedT` should be `dev::frameGrabber` or equivalent, with an `m_reconfig` member, and calls
 * to this class's `pdvStartAcquisition`, `pdvAcquire`, and `pdvReconfig` in the relevant `dev::frameGrabber`
 * implementation functions.
 *
 * Calls to this class's `setupConfig`, `loadConfig`, `appStartup`, `appLogic`, `appShutdown`
 * `onPowerOff`, and `whilePowerOff`,  must be placed in the derived class's functions of the same name.
 *
 * \ingroup appdev
 */
template <class derivedT>
class edtCamera : public ioDevice
{
 
  public:
  protected:
    /** \name Configurable Parameters
     * @{
     */
    // Framegrabber:
    int m_unit{ 0 };     ///< EDT PDV board unit number
    int m_channel{ 0 };  ///< EDT PDV board channel number
    int m_numBuffs{ 4 }; ///< EDT PDV DMA buffer size, indicating number of images.
 
    // cameraConfigMap derived().m_cameraModes; ///< Map holding the possible camera mode configurations
 
    // std::string derived().m_startupMode; ///< The camera mode to load during first init after a power-on.
 
    ///@}
 
    PdvDev *m_pdv{ nullptr }; ///< The EDT PDV device handle
 
    u_char *m_image_p{ nullptr }; ///< The image data grabbed
 
    // std::string m_modeName; ///< The current mode name
 
    // std::string derived().m_nextMode; ///< The mode to be set by the next reconfiguration
 
    int         m_raw_height{ 0 }; ///< The height of the frame, according to the framegrabber
    int         m_raw_width{ 0 };  ///< The width of the frame, according to the framegrabber
    int         m_raw_depth{ 0 };  ///< The bit-depth of the frame, according to the framegrabber
    std::string m_cameraType;      ///< The camera type according to the framegrabber
 
  public:
    /// C'tor, sets up stdCamera
    edtCamera();
 
    /// Destructor, destroys the PdvDev structure
    ~edtCamera() noexcept;
 
    /// Send a serial command over cameralink and retrieve the response
    int pdvSerialWriteRead( std::string       &response,        ///< [out] the response to the command from the device
                            const std::string &command,         /**< [in] the command to send to the device */
                            bool               logErrors = true /**< [in] log serial transport failures when true */
    );
 
    /// Configure the EDT framegrabber
    int pdvConfig( std::string &cfgname /**< [in] The configuration name for the mode to set */ );
 
    /// Setup the configuration system
    /**
      * This should be called in `derivedT::setupConfig` as
      * \code
        edtCamera<derivedT>::setupConfig(config);
        \endcode
      * with appropriate error checking.
      */
    void setupConfig( mx::app::appConfigurator &config /**< [out] the derived classes configurator*/ );
 
    /// load the configuration system results
    /**
      * This should be called in `derivedT::loadConfig` as
      * \code
        edtCamera<derivedT>::loadConfig(config);
        \endcode
      * with appropriate error checking.
      */
    void loadConfig( mx::app::appConfigurator &config /**< [in] the derived classes configurator*/ );
 
    /// Startup function
    /**
      * This should be called in `derivedT::appStartup` as
      * \code
        edtCamera<derivedT>::appStartup();
        \endcode
      * with appropriate error checking.
      *
      * \returns 0 on success
      * \returns -1 on error, which is logged.
      */
    int appStartup();
 
    /// Application logic
    /** Checks the edtCamera thread
      *
      * This should be called from the derived's appLogic() as in
      * \code
        edtCamera<derivedT>::appLogic();
        \endcode
      * with appropriate error checking.
      *
      * \returns 0 on success
      * \returns -1 on error, which is logged.
      */
    int appLogic();
 
    /// Actions on power off
    /**
      * This should be called from the derived's onPowerOff() as in
      * \code
        edtCamera<derivedT>::onPowerOff();
        \endcode
      * with appropriate error checking.
      *
      * \returns 0 on success
      * \returns -1 on error, which is logged.
      */
    int onPowerOff();
 
    /// Actions while powered off
    /**
      * This should be called from the derived's whilePowerOff() as in
      * \code
        edtCamera<derivedT>::whilePowerOff();
        \endcode
      * with appropriate error checking.
      *
      * \returns 0 on success
      * \returns -1 on error, which is logged.
      */
    int whilePowerOff();
 
    /// Application the shutdown
    /** Shuts down the edtCamera thread
      *
      * \code
        edtCamera<derivedT>::appShutdown();
        \endcode
      * with appropriate error checking.
      *
      * \returns 0 on success
      * \returns -1 on error, which is logged.
      */
    int appShutdown();
 
    int pdvStartAcquisition();
 
    int pdvAcquire( timespec &currImageTimestamp );
 
    int pdvReconfig();
 
  protected:
    /** \name INDI
     *
     *@{
     */
  protected:
    // declare our properties
 
  public:
    /// The static callback function to be registered for the channel properties.
    /**
     * \returns 0 on success.
     * \returns -1 on error.
     */
    // static int st_newCallBack_mode( void * app, ///< [in] a pointer to this, will be static_cast-ed to derivedT.
    //                                   const pcf::IndiProperty &ipRecv ///< [in] the INDI property sent with the the
    //                                   new property request.
    //                               );
 
    /// The callback called by the static version, to actually process the new request.
    /**
     * \returns 0 on success.
     * \returns -1 on error.
     */
    // int newCallBack_mode( const pcf::IndiProperty &ipRecv /**< [in] the INDI property sent with the the new property
    // request.*/);
 
    /// Update the INDI properties for this device controller
    /** You should call this once per main loop.
     * It is not called automatically.
     *
     * \returns 0 on success.
     * \returns -1 on error.
     */
    int updateINDI();
 
    ///@}
 
  private:
    derivedT &derived()
    {
        return *static_cast<derivedT *>( this );
    }
};
 
template <class derivedT>
edtCamera<derivedT>::edtCamera()
{
}
 
template <class derivedT>
edtCamera<derivedT>::~edtCamera() noexcept
{
    if( m_pdv )
        pdv_close( m_pdv );
 
    return;
}
 
    #define MAGAOX_PDV_SERBUFSIZE 512
 
template <class derivedT>
int edtCamera<derivedT>::pdvSerialWriteRead( std::string &response, const std::string &command, bool logErrors )
{
    char buf[MAGAOX_PDV_SERBUFSIZE + 1];
 
    // Flush the channel first.
    // This does not indicate errors, so no checks possible.
    pdv_serial_read( m_pdv, buf, MAGAOX_PDV_SERBUFSIZE );
 
    if( pdv_serial_command( m_pdv, command.c_str() ) < 0 )
    {
        if( logErrors )
        {
            derivedT::template log<software_error>( { __FILE__, __LINE__, "PDV: error sending serial command" } );
        }
        return -1;
    }
 
    int ret;
 
    ret = pdv_serial_wait( m_pdv, m_readTimeout, 1 );
 
    if( ret == 0 )
    {
        if( derived().powerState() != 1 || derived().powerStateTarget() != 1 )
            return -1;
 
        if( logErrors )
        {
            derivedT::template log<software_error>( { __FILE__, __LINE__, "PDV: timeout, no serial response" } );
        }
        return -1;
    }
 
    u_char lastbyte = 0;
    u_char waitc    = 0;
 
    response.clear();
 
    do
    {
        ret = pdv_serial_read( m_pdv, buf, MAGAOX_PDV_SERBUFSIZE );
 
        if( ret > 0 )
        {
            response.append( buf, ret );
            lastbyte = static_cast<u_char>( buf[ret - 1] );
        }
        else
        {
            lastbyte = 0;
        }
 
        if( pdv_get_waitchar( m_pdv, &waitc ) && ( lastbyte == waitc ) )
        {
            break;
        }
        else
        {
            ret = pdv_serial_wait( m_pdv, m_readTimeout / 2, 1 );
        }
    } while( ret > 0 );
 
    if( ret == 0 && response.empty() && pdv_get_waitchar( m_pdv, &waitc ) )
    {
        if( logErrors )
        {
            derivedT::template log<software_error>( { __FILE__, __LINE__, "PDV: timeout in serial response" } );
        }
        return -1;
    }
 
    // Drain any immediate trailing bytes so CR/LF endings or prompt suffixes
    // do not become the next command's apparent response.
    ret = pdv_serial_wait( m_pdv, 10, 1 );
    while( ret > 0 )
    {
        ret = pdv_serial_read( m_pdv, buf, MAGAOX_PDV_SERBUFSIZE );
 
        if( ret > 0 )
        {
            ret = pdv_serial_wait( m_pdv, 10, 1 );
        }
    }
 
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::pdvConfig( std::string &modeName )
{
    Dependent *dd_p;
    EdtDev    *edt_p = NULL;
    Edtinfo    edtinfo;
 
    // Preliminaries
    if( m_pdv )
    {
        pdv_close( m_pdv );
        m_pdv = nullptr;
    }
 
    derived().m_modeName = modeName;
 
    if( modeName == "" )
    {
        return derivedT::template log<text_log, -1>( "Empty modeName passed to pdvConfig", logPrio::LOG_ERROR );
    }
 
    if( derived().m_cameraModes.count( modeName ) != 1 )
    {
        return derivedT::template log<text_log, -1>( "No mode named " + modeName + " found.", logPrio::LOG_ERROR );
    }
 
    // Construct config file, adding relative path if configured that way
    std::string configFile;
 
    if( derivedT::c_edtCamera_relativeConfigPath )
    {
        configFile = derived().configDir() + "/";
    }
 
    configFile += derived().m_cameraModes[modeName].m_configFile;
 
    derivedT::template log<text_log>( "Loading EDT PDV config file: " + configFile );
 
    if( ( dd_p = pdv_alloc_dependent() ) == NULL )
    {
        return derivedT::template log<software_error, -1>( { __FILE__, __LINE__, "EDT PDV alloc_dependent FAILED" } );
    }
 
    if( pdv_readcfg( configFile.c_str(), dd_p, &edtinfo ) != 0 )
    {
        free( dd_p );
        return derivedT::template log<software_error, -1>( { __FILE__, __LINE__, "EDT PDV readcfg FAILED" } );
    }
 
    char edt_devname[128];
    strncpy( edt_devname, EDT_INTERFACE, sizeof( edt_devname ) );
 
    if( ( edt_p = edt_open_channel( edt_devname, m_unit, m_channel ) ) == NULL )
    {
        char errstr[256];
        edt_perror( errstr );
        free( dd_p );
        return derivedT::template log<software_error, -1>(
            { __FILE__, __LINE__, std::string( "EDT PDV edt_open_channel FAILED: " ) + errstr } );
    }
 
    char bitdir[1];
    bitdir[0] = '\0';
 
    int pdv_debug = 0;
 
    if( derived().m_log.logLevel() > logPrio::LOG_INFO )
        pdv_debug = 2;
 
    if( pdv_initcam( edt_p, dd_p, m_unit, &edtinfo, configFile.c_str(), bitdir, pdv_debug ) != 0 )
    {
        edt_close( edt_p );
        free( dd_p );
        return derivedT::template log<software_error, -1>(
            { __FILE__, __LINE__, "initcam failed. Run with '--logLevel=DBG' to see complete debugging output." } );
    }
 
    edt_close( edt_p );
    free( dd_p );
 
    // Now open the PDV device handle for talking to the camera via the EDT board.
    if( ( m_pdv = pdv_open_channel( edt_devname, m_unit, m_channel ) ) == NULL )
    {
        std::string errstr = std::string( "pdv_open_channel(" ) + edt_devname + std::to_string( m_unit ) + "_" +
                             std::to_string( m_channel ) + ")";
 
        derivedT::template log<software_error>( { __FILE__, __LINE__, errstr } );
        derivedT::template log<software_error>( { __FILE__, __LINE__, errno } );
 
        return -1;
    }
 
    pdv_flush_fifo( m_pdv );
 
    pdv_serial_read_enable( m_pdv ); // This is undocumented, don't know if it's really needed.
 
    m_raw_width  = pdv_get_width( m_pdv );
    m_raw_height = pdv_get_height( m_pdv );
    m_raw_depth  = pdv_get_depth( m_pdv );
    m_cameraType = pdv_get_cameratype( m_pdv );
 
    derivedT::template log<text_log>( "Initialized framegrabber: " + m_cameraType );
    derivedT::template log<text_log>( "WxHxD: " + std::to_string( m_raw_width ) + " X " +
                                      std::to_string( m_raw_height ) + " X " + std::to_string( m_raw_depth ) );
 
    /*
     * allocate four buffers for optimal pdv ring buffer pipeline (reduce if
     * memory is at a premium)
     */
    pdv_multibuf( m_pdv, m_numBuffs );
    derivedT::template log<text_log>( "allocated " + std::to_string( m_numBuffs ) + " buffers" );
 
    return 0;
}
 
template <class derivedT>
void edtCamera<derivedT>::setupConfig( mx::app::appConfigurator &config )
{
    config.add( "framegrabber.pdv_unit",
                "",
                "framegrabber.pdv_unit",
                argType::Required,
                "framegrabber",
                "pdv_unit",
                false,
                "int",
                "The EDT PDV framegrabber unit number.  Default is 0." );
    config.add( "framegrabber.pdv_channel",
                "",
                "framegrabber.pdv_channel",
                argType::Required,
                "framegrabber",
                "pdv_channel",
                false,
                "int",
                "The EDT PDV framegrabber channel number.  Default is 0." );
    config.add( "framegrabber.numBuffs",
                "",
                "framegrabber.numBuffs",
                argType::Required,
                "framegrabber",
                "numBuffs",
                false,
                "int",
                "The EDT PDV framegrabber DMA buffer size [images].  Default is 4." );
 
    dev::ioDevice::setupConfig( config );
}
 
template <class derivedT>
void edtCamera<derivedT>::loadConfig( mx::app::appConfigurator &config )
{
    config( m_unit, "framegrabber.pdv_unit" );
    config( m_channel, "framegrabber.pdv_channel" );
    config( m_numBuffs, "framegrabber.numBuffs" );
 
    m_readTimeout  = 1000;
    m_writeTimeout = 1000;
    dev::ioDevice::loadConfig( config );
}
 
template <class derivedT>
int edtCamera<derivedT>::appStartup()
{
    if( pdvConfig( derived().m_startupMode ) < 0 )
    {
        derivedT::template log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::appLogic()
{
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::onPowerOff()
{
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::whilePowerOff()
{
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::appShutdown()
{
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::pdvStartAcquisition()
{
    pdv_start_images( m_pdv, m_numBuffs );
 
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::pdvAcquire( timespec &currImageTimestamp )
{
 
    uint dmaTimeStamp[2];
    m_image_p = pdv_wait_last_image_timed( m_pdv, dmaTimeStamp );
    // m_image_p = pdv_wait_image_timed(m_pdv, dmaTimeStamp);
    pdv_start_image( m_pdv );
 
    currImageTimestamp.tv_sec  = dmaTimeStamp[0];
    currImageTimestamp.tv_nsec = dmaTimeStamp[1];
 
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::pdvReconfig()
{
 
    if( pdvConfig( derived().m_nextMode ) < 0 )
    {
        derivedT::template log<text_log>( "error trying to re-configure with " + derived().m_nextMode,
                                          logPrio::LOG_ERROR );
        sleep( 1 );
    }
    else
    {
        derived().m_nextMode = "";
    }
 
    return 0;
}
 
template <class derivedT>
int edtCamera<derivedT>::updateINDI()
{
    return 0;
}
 
} // namespace dev
} // namespace app
} // namespace MagAOX
 
#endif // MAGAOX_NOEDT
#endif // edtCamera_hpp