vrpn_Analog.h

#ifndef VRPN_ANALOG_H
#define VRPN_ANALOG_H

#include <stddef.h> // for NULL

#include "vrpn_BaseClass.h"  // for vrpn_Callback_List, etc
#include "vrpn_Configure.h"  // for VRPN_API, VRPN_CALLBACK
#include "vrpn_Connection.h" // for vrpn_CONNECTION_LOW_LATENCY, etc
#include "vrpn_Shared.h"     // for timeval
#include "vrpn_Types.h"      // for vrpn_int32, vrpn_float64, etc

#ifndef VRPN_CLIENT_ONLY
#include "vrpn_Serial.h" // for ::vrpn_SER_PARITY_NONE, etc
#endif

#define vrpn_CHANNEL_MAX 128

// analog status flags
const int vrpn_ANALOG_SYNCING = (2);
const int vrpn_ANALOG_REPORT_READY = (1);
const int vrpn_ANALOG_PARTIAL = (0);
const int vrpn_ANALOG_RESETTING = (-1);
const int vrpn_ANALOG_FAIL = (-2);

// Analog time value meaning "go find out what time it is right now"
const struct timeval vrpn_ANALOG_NOW = {0, 0};

class VRPN_API vrpn_Analog : public vrpn_BaseClass {
public:
    vrpn_Analog(const char *name, vrpn_Connection *c = NULL);

    // Print the status of the analog device
    void print(void);

    vrpn_int32 getNumChannels(void) const;

protected:
    vrpn_float64 channel[vrpn_CHANNEL_MAX];
    vrpn_float64 last[vrpn_CHANNEL_MAX];
    vrpn_int32 num_channel;
    struct timeval timestamp;
    vrpn_int32 channel_m_id; //< channel message id (message from server)
    int status;

    virtual int register_types(void);

    //------------------------------------------------------------------
    // Routines used to send data from the server
    virtual vrpn_int32 encode_to(char *buf);
    /// Send a report only if something has changed (for servers)
    /// Optionally, tell what time to stamp the value with
    virtual void
    report_changes(vrpn_uint32 class_of_service = vrpn_CONNECTION_LOW_LATENCY,
                   const struct timeval time = vrpn_ANALOG_NOW);
    /// Send a report whether something has changed or not (for servers)
    /// Optionally, tell what time to stamp the value with
    virtual void
    report(vrpn_uint32 class_of_service = vrpn_CONNECTION_LOW_LATENCY,
           const struct timeval time = vrpn_ANALOG_NOW);
};

#ifndef VRPN_CLIENT_ONLY
class VRPN_API vrpn_Serial_Analog : public vrpn_Analog {
public:
    vrpn_Serial_Analog(const char *name, vrpn_Connection *connection,
                       const char *port, int baud = 9600, int bits = 8,
                       vrpn_SER_PARITY parity = vrpn_SER_PARITY_NONE,
                       bool rts_flow = false);
    ~vrpn_Serial_Analog();

protected:
    int serial_fd;
    char portname[1024];
    int baudrate;
    unsigned char buffer[1024];
    int bufcounter;

    int read_available_characters(char *buffer, int bytes);
};
#endif

// vrpn_Analog_Server
// Tom Hudson, March 1999
//
// A *Sample* Analog server.  Use this or derive your own from vrpn_Analog with
// this as a guide.
//
// Write whatever values you want into channels(), then call report()
// or report_changes().  (Original spec only called for report_changes(),
// but vrpn_Analog's assumption that "no new data = same data" doesn't
// match the BLT stripchart assumption  of "no intervening data = ramp".
//
// For a sample application, see server_src/sample_analog.C

class VRPN_API vrpn_Analog_Server : public vrpn_Analog {

public:
    vrpn_Analog_Server(const char *name, vrpn_Connection *c,
                       vrpn_int32 numChannels = vrpn_CHANNEL_MAX);

    /// Makes public the protected base class function
    virtual void
    report_changes(vrpn_uint32 class_of_service = vrpn_CONNECTION_LOW_LATENCY,
                   const struct timeval time = vrpn_ANALOG_NOW);

    /// Makes public the protected base class function
    virtual void
    report(vrpn_uint32 class_of_service = vrpn_CONNECTION_LOW_LATENCY,
           const struct timeval time = vrpn_ANALOG_NOW);

    /// For this server, the user must normally call report() or
    /// report_changes() directly.  This mainloop() only takes
    /// care of the things any server object should do.
    virtual void mainloop() { server_mainloop(); };

    /// Exposes an array of values for the user to write into.
    vrpn_float64 *channels(void) { return channel; }

    /// Sets the size of the array;  returns the size actually set.
    /// (May be clamped to vrpn_CHANNEL_MAX)
    /// This should be used before mainloop is ever called.
    vrpn_int32 setNumChannels(vrpn_int32 sizeRequested);
};

/// Analog server that can scale and clip its range to -1..1.
// This is useful for joysticks, to allow them to be centered and
// scaled to cover the whole range.  Rather than writing directly
// into the channels array, call the setChannel() method.

class VRPN_API vrpn_Clipping_Analog_Server : public vrpn_Analog_Server {
public:
    vrpn_Clipping_Analog_Server(const char *name, vrpn_Connection *c,
                                vrpn_int32 numChannels = vrpn_CHANNEL_MAX);

    /// Set the clipping values for the specified channel.
    /// min maps to -1, values between lowzero and highzero map to 0,
    /// max maps to 1.  Values less than min map to -1, values larger
    /// than max map to 1. Default for each channel is -1,0,0,1
    /// It is possible to compress the range to [0..1] by setting the
    /// minimum equal to the lowzero.
    /// Returns 0 on success, -1 on failure.
    int setClipValues(int channel, double min, double lowzero, double highzero,
                      double max);

    /// This method should be used to set the value of a channel.
    /// It will be scaled and clipped as described in setClipValues.
    /// It returns 0 on success and -1 on failure.
    int setChannelValue(int channel, double value);

protected:
    typedef struct {
        double minimum_val; // Value mapped to -1
        double lower_zero;  // Minimum value mapped to 0
        double upper_zero;  // Maximum value mapped to 0
        double maximum_val; // Value mapped to 1
    } clipvals_struct;

    clipvals_struct clipvals[vrpn_CHANNEL_MAX];
};

//----------------------------------------------------------
//************** Users deal with the following *************

// User routine to handle a change in analog values.  This is called when
// the analog callback is called (when a message from its counterpart
// across the connection arrives).

typedef struct _vrpn_ANALOGCB {
    struct timeval msg_time;                // Timestamp of analog data
    vrpn_int32 num_channel;                 // how many channels
    vrpn_float64 channel[vrpn_CHANNEL_MAX]; // analog values
} vrpn_ANALOGCB;

typedef void(VRPN_CALLBACK *vrpn_ANALOGCHANGEHANDLER)(void *userdata,
                                                      const vrpn_ANALOGCB info);

// Open an analog device that is on the other end of a connection
// and handle updates from it.  This is the type of analog device
// that user code will deal with.

class VRPN_API vrpn_Analog_Remote : public vrpn_Analog {
public:
    // The name of the analog device to connect to
    // Optional argument to be used when the Remote should listen on
    // a connection that is already open.
    vrpn_Analog_Remote(const char *name, vrpn_Connection *c = NULL);

    // This routine calls the mainloop of the connection it's on
    virtual void mainloop();

    // (un)Register a callback handler to handle analog value change
    virtual int register_change_handler(void *userdata,
                                        vrpn_ANALOGCHANGEHANDLER handler)
    {
        return d_callback_list.register_handler(userdata, handler);
    };
    virtual int unregister_change_handler(void *userdata,
                                          vrpn_ANALOGCHANGEHANDLER handler)
    {
        return d_callback_list.unregister_handler(userdata, handler);
    }

protected:
    vrpn_Callback_List<vrpn_ANALOGCB> d_callback_list;

    static int VRPN_CALLBACK
    handle_change_message(void *userdata, vrpn_HANDLERPARAM p);
};

#endif