Device.h

Go to the documentation of this file.

/***************************************************/
#ifndef DEVICE_H
#define DEVICE_H

#include <vector>
#include <string>
#include "common/buses/Bus.h"
#include "common/buses/BusFamily.h"
#include "common/buses/DeviceLocatorInterface.h"
#include "common/features/Feature.h"
#include "common/features/FeatureFamily.h"
#include "common/protocols/Protocol.h"


// usb endpoints are associated with a particular device.
typedef enum usbEndpointType 
{ 
    kEndpointTypePrimaryOut, // slow speed
    kEndpointTypePrimaryIn,  // slow speed
    kEndpointTypeSecondaryOut, // could be high speed
    kEndpointTypeSecondaryIn,  // could be high speed
    kEndpointTypeSecondaryIn2  // generally high speed
} usbEndpointType;
            
namespace seabreeze {

    class Device {
    public:
        Device();
        virtual ~Device();
        std::vector<Bus *> &getBuses();
        std::vector<Feature *> &getFeatures();
        std::vector<Protocol *> &getProtocols();
        std::string &getName();
        
        // get the usb endpoints, according to the endpointType enumerator, 
        //  if the endpoint type is not used, a 0 is returned
        // TODO: this should be delegated down into a Bus instance
        // (e.g. found by getBusesByFamily()) for USB.  It is inappropriate here.
        unsigned char getEndpoint(int *errorCode, usbEndpointType endpointType);

        /* This will allow the driver to probe the device and initialize itself
         * based on what it finds there.  This should be called shortly after
         * open().  The Device instance should use the indicated Bus instance to
         * communicate with the hardware and get everything set up.  It can
         * use any appropriate protocol or protocols that are valid for the Bus.
         */
        virtual bool initialize(const Bus &bus);

        /* Each instance of a device is assumed to be associated with a unique
         * location on a bus.  If the device is connected via multiple buses, then
         * a special DeviceLocator and TransferHelper will have to hide those
         * details.  Otherwise, each connection to the device will be considered
         * independent of all others.
         */
        virtual DeviceLocatorInterface *getLocation();
        virtual void setLocation(const DeviceLocatorInterface &loc);

        virtual int open();

        virtual void close();

        virtual std::vector<Bus *> getBusesByFamily(BusFamily &family);

        virtual seabreeze::ProtocolFamily getSupportedProtocol(
                seabreeze::FeatureFamily family, BusFamily bus) = 0;

        virtual std::vector<Protocol *> getProtocolsByFamily(
                seabreeze::ProtocolFamily &family);

        virtual Bus *getOpenedBus();

    protected:
        std::vector<Bus *> buses;
        std::vector<Feature *> features;
        std::vector<Protocol *> protocols;

        std::string name;
        unsigned char usbEndpoint_primary_out;
        unsigned char usbEndpoint_primary_in;
        unsigned char usbEndpoint_secondary_out;
        unsigned char usbEndpoint_secondary_in;
        unsigned char usbEndpoint_secondary_in2; 
        

        DeviceLocatorInterface *location;
        Bus *openedBus;
    };

}

#endif /* DEVICE_H */