---

gtkdaq.c

Go to the documentation of this file.

#include <stdio.h>
#include <gtk/gtk.h>
#include <gtkdatabox.h>
#include <math.h>

#include "di194.h"

static gfloat *analog = NULL;
static gfloat *digital_0 = NULL;
static gfloat *digital_1 = NULL;
static GdkColor analog_color = 
{
    0, 0, 65535
};

static GdkColor d0_color = 
{
    65535, 0, 0
};
static GdkColor d1_color = 
{
    0, 65535, 0
};

static gfloat *x_axis = NULL;

static gint     bars_idle=0;
static GtkWidget *bars_label=NULL;
static guint    bars_counter=0;

static int COMM_FD;
const static int DRAW_TYPE = GTK_DATABOX_LINES;
const static int PT_SIZE = 1;
const static int NUM_PTS = 240;
volatile bool di_paused;

static void di_pause(GtkWidget *widget, GtkWidget **window)
{
    int    rc;

    if(di_paused)
        rc = di_start(COMM_FD);
    else
        rc = di_stop(COMM_FD);

    di_paused = !di_paused;
    fprintf(stderr, "\npause called, pause now %d", di_paused);
}
        
static void bars_destroy(GtkWidget *widget, GtkWidget **window)
{
    if (bars_idle) 
    {
        gtk_idle_remove(bars_idle);
        bars_idle=0;
    }

    *window=NULL;  
}

static void do_exit (GtkWidget *widget, GtkWidget *window)
{
    di_close(COMM_FD);
    // free x_axis, y1, y2?
    gtk_widget_destroy (window);
    gtk_main_quit ();
}

// Idle function, used to read data
static gboolean my_bars_idle_func(GtkDatabox *box)
{
    daq_reading_t  data;
    int            rc;
    char           label[128] = "";
    int            idx;
    

    if(di_paused)
    {
        gtk_entry_set_text(GTK_ENTRY(bars_label), "Paused");
        
        return FALSE;
    }

    // Read the data from the device
    rc = di_read(COMM_FD, &data);
    if(rc != 0)
    {
        sprintf(label, "Error %d on data read", rc);
        gtk_entry_set_text(GTK_ENTRY(bars_label), label);
        
        return TRUE;
    }
    
    // Hack for now!
    //    sprintf(label, "%5.2f", data.analog[0]);
    //    gtk_entry_set_text(GTK_ENTRY(bars_label), label);

    for(idx = 0; idx < 4; idx++, bars_counter++)
    {
        analog[bars_counter] = data.analog[idx];

        // For now, just read bit D0
        digital_0[bars_counter] = data.digital[0][idx];
        digital_1[bars_counter] = data.digital[1][idx];
    }

    // Scope wraparound - clear screen
    if(bars_counter >= NUM_PTS)
        bars_counter = 0;

    gtk_databox_redraw(GTK_DATABOX(box));
    
    return TRUE;
}

static void create_bars(void)
{
    static GtkWidget *window = NULL;
    GtkWidget  *box1;
    GtkWidget *box2;
    GtkWidget *close_button;
    GtkWidget *pause_button;
    GtkWidget *box;
    GtkWidget *label;
    GtkWidget *separator;
    gint i;
    GtkDataboxValue  disp_min, disp_max;
    

    if (!window)
    {
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        gtk_widget_set_usize (window, 640, 480);  
        
        gtk_signal_connect (GTK_OBJECT (window), "destroy",
                            GTK_SIGNAL_FUNC(bars_destroy),
                            &window);
        
        gtk_window_set_title (GTK_WINDOW (window), "Databox Bars");
        gtk_container_border_width (GTK_CONTAINER (window), 0);
        
        box1 = gtk_vbox_new (FALSE, 0);
        gtk_container_add (GTK_CONTAINER (window), box1);
        
        label=gtk_label_new("DI-194 oscilloscope");
        
        gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
        separator=gtk_hseparator_new();
        gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);
        bars_label=gtk_entry_new();
        gtk_entry_set_text(GTK_ENTRY(bars_label), "0");
        gtk_box_pack_start (GTK_BOX (box1), bars_label, FALSE, FALSE, 0);
        separator=gtk_hseparator_new();
        gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);
        
        bars_idle=0;
        bars_counter=0;
        
        box=gtk_databox_new();
        gtk_signal_connect (GTK_OBJECT (box), "destroy",
                            GTK_SIGNAL_FUNC(gtk_databox_data_destroy_all),
                            NULL);
        
        // Allocate vectors for X, Y, Y2
        x_axis = g_new0(gfloat, NUM_PTS);
        analog = g_new0(gfloat, NUM_PTS);
        digital_0 = g_new0(gfloat, NUM_PTS);
        digital_1 = g_new0(gfloat, NUM_PTS);

        // Initialize x axis - others set to zero by new0
        for (i = 0; i < NUM_PTS; i++ ) 
            x_axis[i] = i;
        
        gtk_databox_data_add_x_y(GTK_DATABOX(box), NUM_PTS, 
                                 x_axis, analog, analog_color, 
                                 DRAW_TYPE, PT_SIZE);
        gtk_databox_data_add_x_y(GTK_DATABOX(box), NUM_PTS, 
                                 x_axis, digital_0, d0_color, 
                                 DRAW_TYPE, PT_SIZE);
        gtk_databox_data_add_x_y(GTK_DATABOX(box), NUM_PTS, 
                                 x_axis, digital_1, d1_color, 
                                 DRAW_TYPE, PT_SIZE);
        // Set viewing range
        disp_min.x = 0;
        disp_min.y = -10.0;
        disp_max.x = NUM_PTS;
        disp_max.y = 10.0;

        gtk_databox_rescale_with_values(GTK_DATABOX(box),
                                        disp_min, disp_max);
        
        gtk_box_pack_start (GTK_BOX (box1), box, TRUE, TRUE, 0);
        
        separator = gtk_hseparator_new();
        gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
        
        box2 = gtk_vbox_new (FALSE, 10);
        gtk_container_border_width (GTK_CONTAINER (box2), 10);
        gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);
        close_button = gtk_button_new_with_label("close");
        pause_button = gtk_button_new_with_label("pause");
        
        gtk_signal_connect_object_after (GTK_OBJECT (close_button), "clicked",
                                         GTK_SIGNAL_FUNC(do_exit),
                                         GTK_OBJECT (window));
        
        gtk_signal_connect_object_after (GTK_OBJECT (pause_button), "clicked",
                                         GTK_SIGNAL_FUNC(di_pause),
                                         GTK_OBJECT (window));
        
        gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);
        gtk_box_pack_start (GTK_BOX (box2), pause_button, TRUE, TRUE, 0);

        GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);
        GTK_WIDGET_SET_FLAGS (pause_button, GTK_CAN_DEFAULT);
        gtk_widget_grab_default (pause_button);
        
        // Hook in idle function
        bars_idle=gtk_idle_add((GtkFunction) my_bars_idle_func, box);
        
        // Set initial label
        gtk_entry_set_text(GTK_ENTRY(bars_label), "Running");
    }
    
    if (!GTK_WIDGET_VISIBLE (window))
        gtk_widget_show_all (window);
    else 
    {
        gtk_widget_destroy (window);
    }
}

gint main(gint argc, char *argv[])
{
    char     me[] = "main";
    int      rc;
    
    // Now seems a good time to open comms
    rc = di_open(NULL);
    if(rc <= 0)
    {
        fprintf(stderr, "\n%s: Error %d opening DI-194\n",
                me, rc);
        return(1);
    }
    else
        COMM_FD = rc;
        
    // Start DAQ rollingt
    rc = di_start(COMM_FD);
    if(rc != 0)
    {
        fprintf(stderr, "\nError %d starting DAQ\n", rc);
        return(2);
    }
    
    gtk_init(&argc, &argv);
    
    create_bars();
    
    gtk_main();
    
    return 0;
}

---