ControllerFtd2xx.hpp

Go to the documentation of this file.

#ifndef SPIDAR_CONTROLLER_FTD2XX_HPP
#define SPIDAR_CONTROLLER_FTD2XX_HPP

#include <cstdint>

#include <string>
#include <fstream>

namespace Spidar
{
namespace Controller
{
class ControllerFtd2xx
{
public:
    static const size_t MOTOR_COUNT = 8;

    ControllerFtd2xx(void);
    ~ControllerFtd2xx(void);

    bool        initialized(void) const     {   return initialized_;        }           
    bool        enabled(void) const         {   return enabled_;            }           
    uint32_t    deviceID(void) const        {   return deviceID_;           }           
    uint32_t    serialNumber(void) const    {   return serialNumber_;       }           
    uint32_t    firmwareVersion(void) const {   return firmwareVersion_;    }           

    uint16_t    maxPulseWidth(void) const       {  return maxPulseWidth_;       }       
    uint32_t    controlFrequency(void) const    {  return controlFrequency_;    }       
    uint32_t    pwmFrequency(void) const        {  return pwmFrequency_;        }       
    uint32_t    cascadeFrequency(void) const    {  return cascadeFrequency_;    }       
    uint32_t    qeiFrequency(void) const        {  return qeiFrequency_;        }       

    int16_t     velocityGain(size_t i) const    { return velocityGain_[i];      }       
    uint16_t    velocityFilterGain(void) const  { return velocityFilterGain_;   }       
    uint16_t    forceFilterGain(void) const     { return forceFilterGain_;      }       
    uint16_t    pulseWidthLimit(size_t i) const { return pulseWidthLimit_[i];   }       

    uint8_t     gpioValue(void) const           {  return gpioValue_;           }       

    bool    initialize(uint32_t serialNumber);
    bool    terminate(void);

    bool    enableMotorControl(void);
    bool    disableMotorControl(void);

    bool    writePulseWidth(const uint16_t(&pulseWidth)[MOTOR_COUNT]);
    bool    writeDutyCycle(const double(&dutyCycle)[MOTOR_COUNT]);

    bool    writePulseWidth(const uint16_t(&pulseWidth)[MOTOR_COUNT], const int16_t(&springK)[MOTOR_COUNT], const uint16_t ratioKB);
    bool    writeDutyCycle(const double(&dutyCycle)[MOTOR_COUNT], const int16_t(&springK)[MOTOR_COUNT], const uint16_t ratioKB);

    bool    readEncoderCount(int32_t(&count)[MOTOR_COUNT]);
    bool    clearEncoderCount(void);

    bool    readFirmwareVersion(void);
    bool    blink(void);

    bool    readMaxPulseWidth(void);
    bool    readPwmFrequency(void);
    bool    readCascadeFrequency(void);
    bool    readQeiFrequency(void);
    bool    readVelocityGain(void);
    bool    readVelocityFilterGain(void);
    bool    readForceFilterGain(void);
    bool    readPulseWidthLimit(void);

    bool    writePwmFrequency(uint32_t frequency);
    bool    writeCascadeFrequency(uint32_t frequency);
    bool    writeQeiFrequency(uint32_t frequency);
    bool    writeVelocityGain(int16_t(&gain)[MOTOR_COUNT]);
    bool    writeVelocityFilterGain(uint16_t gain);
    bool    writeForceFilterGain(uint16_t gain);
    bool    writePulseWidthLimit(const uint16_t(&pulseWidth)[MOTOR_COUNT]);

    void    lastError(std::string& message) const   {   message = lastError_;   }

private:
    void    setLastError(std::string message);

    bool        initialized_;                   
    bool        enabled_;                       
    uint32_t    deviceID_;                      
    uint32_t    serialNumber_;                  
    uint32_t    firmwareVersion_;               

    uint16_t    maxPulseWidth_;                 
    uint32_t    controlFrequency_;              
    uint32_t    pwmFrequency_;                  
    uint32_t    cascadeFrequency_;              
    uint32_t    qeiFrequency_;                  

    int16_t     velocityGain_[MOTOR_COUNT];     
    uint16_t    velocityFilterGain_;            
    uint16_t    forceFilterGain_;               
    uint16_t    pulseWidthLimit_[MOTOR_COUNT];  

    uint8_t     gpioValue_;                     

    void*       deviceHandle_;                  
    std::string lastError_;                     
    
    std::string logFilename_;                   

    std::ofstream fout_;                        

}; // end of class ControllerFtd2xx.

} // end of namespace Controller.
} // end of namespace Spidar.

#endif // SPIDAR_CONTROLLER_FTD2XX_HPP

// end of file.