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 1

#define DAQD_PORT 8088

struct signal_conv1;
struct daq_block_header;

enum nds_version {
    nds_v1 = 1,
    nds_v2 = 2
};

/* pieces of the communication protocol */

#define DAQD_LENGTH_UNKNOWN 0
#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 enum chantype {

    cUnknown,

    cOnline,

    cRaw,

    cRDS,

    cSTrend,

    cMTrend,

    cTestPoint

} chantype_t;

typedef struct {
    char*  name;

    enum chantype type;

    double rate;

    daq_data_t data_type;

    int   offset;

    int    status;

    signal_conv_t s;

} chan_req_t;


typedef struct {
    enum nds_version nds_versn;

    int sockfd;

    struct sockaddr_in srvr_addr;

    /* data connection socket */
    int datafd;

    int num_chan_request;

    int num_chan_alloc;

    chan_req_t* chan_req_list;

    int blocks;

    daq_block_t *tb;

    int tb_size;

    struct signal_conv1 *s;

    int s_size;

    int rev;
} 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;

chantype_t cvt_str_chantype(const char* str);

const char* cvt_chantype_str(chantype_t code);

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);

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

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

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

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

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

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_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_request_online(daq_t* daq);

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

#endif

---