/mnt/qfs4/jzweizig/nds2_svn/trunk/client/src/client/daqc.h

/* -*- mode: c; c-basic-offset: 4; -*- */
/*
 *  Data acquisition daemon access
 */
#ifndef DAQC_H
#define DAQC_H

#include "channel.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

typedef          int  int4_type;
typedef unsigned int uint4_type;


#define DAQD_PROTOCOL_VERSION 11
#define DAQD_PROTOCOL_REVISION 4

#define DAQD_PORT 31200

struct signal_conv1;
struct daq_block_header;

enum nds_version {

    nds_try = 0,

    nds_v1 = 1,

    nds_v2 = 2
};

/* pieces of the communication protocol */

#define HEADER_LEN 16

typedef struct daq_block_header daq_block_t;

typedef struct {
    float signal_gain;

    float signal_slope;

    float signal_offset;

    char signal_units [MAX_CHANNEL_NAME_LENGTH]; /* Engineering units  */  
} signal_conv_t;

typedef struct {
    char*  name;

    enum chantype type;

    double rate;

    daq_data_t data_type;

    uint4_type offset;

    int    status;

    signal_conv_t s;

} chan_req_t;


typedef struct {
    enum nds_version nds_versn;

    int sockfd;

    struct sockaddr_in srvr_addr;

    int datafd;

    uint4_type num_chan_request;

    uint4_type num_chan_alloc;

    chan_req_t* chan_req_list;

    int blocks;

    daq_block_t *tb;

    size_t tb_size;

    struct signal_conv1 *s;

    int s_size;

    int rev;

    void* auth_ctx;

    int err_num;
} daq_t;

typedef struct {
    char name [MAX_LONG_CHANNEL_NAME_LENGTH + 1]; /* Channel name */

    double rate;

    int tpnum;

    enum chantype type;

    int bps;

    int chNum;

    daq_data_t data_type;

    signal_conv_t s;
} daq_channel_t;

int
daq_clear_channel_list(daq_t* daq);

int 
daq_connect(daq_t* daq, const char* host, int port, enum nds_version version);

int 
daq_disconnect (daq_t* daq);

const char*
daq_get_channel_addr(daq_t *daq, const char* channel);

char*
daq_get_channel_data(daq_t *daq, const char* channel, char* data);

int
daq_get_data_length(daq_t *daq, const char* channel);

chan_req_t*
daq_get_channel_status(daq_t *daq, const char* channel);

int
daq_get_scaled_data(daq_t *daq, const char* channel, float* data);

void
daq_init_channel(daq_channel_t* chan, const char* name, enum chantype ctype,
                 double rate, daq_data_t dtype);

int
daq_recv_block_num (daq_t* daq);

int 
daq_recv_block (daq_t* daq);

int
daq_recv_next (daq_t* daq);

int
daq_recv_shutdown (daq_t* daq);

int 
daq_recv_channels (daq_t* daq, daq_channel_t* channel, int num_channels, 
                   int* num_channels_received);

int 
daq_recv_channel_list(daq_t* daq, daq_channel_t* channel, int num_channels, 
                   int* num_channels_received, time_t gps, enum chantype type);

long 
daq_recv_id (daq_t *daq);

int 
daq_recv_source_list(daq_t* daq, char* sources, size_t max_len, 
                     time_t gps, long* str_len);

int
daq_request_channel(daq_t* daq, const char* name, enum chantype type,
                    double rate);

int
daq_request_channel_from_chanlist(daq_t* daq, daq_channel_t* channel);

int
daq_request_data(daq_t* daq, time_t start, time_t end, time_t dt);

int 
daq_send (daq_t* daq, const char* command);

int
daq_startup(void);

const char*
daq_strerror(int errornum);

#endif

---