main.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <sigrok.h>
  21 #include <gtk/gtk.h>
  22
  23 #include <errno.h>
  24 #include <stdlib.h>
  25 #include <sys/stat.h>
  26
  27 #include "sigrok-gtk.h"
  28
  29 GtkWidget *sigview;
  30
  31 static const char *colours[8] = {
  32         "black", "brown", "red", "orange",
  33         "gold", "darkgreen", "blue", "magenta",
  34 };
  35
  36 static void
  37 datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
  38 {
  39         static int probelist[SR_MAX_NUM_PROBES + 1] = { 0 };
  40         static int unitsize = 0;
  41         struct sr_probe *probe;
  42         struct sr_datafeed_header *header;
  43         struct sr_datafeed_logic *logic = NULL;
  44         int num_enabled_probes, sample_size, i;
  45         uint64_t filter_out_len;
  46         uint8_t *filter_out;
  47         GArray *data;
  48
  49         switch (packet->type) {
  50         case SR_DF_HEADER:
  51                 g_message("fe: Received SR_DF_HEADER");
  52                 header = packet->payload;
  53                 num_enabled_probes = 0;
  54                 gtk_list_store_clear(siglist);
  55                 for (i = 0; i < header->num_logic_probes; i++) {
  56                         probe = g_slist_nth_data(dev->probes, i);
  57                         if (probe->enabled) {
  58                                 GtkTreeIter iter;
  59                                 probelist[num_enabled_probes++] = probe->index;
  60                                 gtk_list_store_append(siglist, &iter);
  61                                 gtk_list_store_set(siglist, &iter,
  62                                                 0, probe->name,
  63                                                 1, colours[(num_enabled_probes - 1) & 7],
  64                                                 2, num_enabled_probes - 1,
  65                                                 -1);
  66                         }
  67                 }
  68                 /* How many bytes we need to store num_enabled_probes bits */
  69                 unitsize = (num_enabled_probes + 7) / 8;
  70                 data = g_array_new(FALSE, FALSE, unitsize);
  71                 g_object_set_data(G_OBJECT(siglist), "sampledata", data);
  72
  73                 break;
  74         case SR_DF_END:
  75                 sigview_zoom(sigview, 1, 0);
  76                 g_message("fe: Received SR_DF_END");
  77                 sr_session_halt();
  78                 break;
  79         case SR_DF_TRIGGER:
  80                 g_message("fe: received SR_DF_TRIGGER");
  81                 break;
  82         case SR_DF_LOGIC:
  83                 logic = packet->payload;
  84                 sample_size = logic->unitsize;
  85                 g_message("fe: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length);
  86                 break;
  87         }
  88
  89         if (!logic)
  90                 return;
  91
  92         if (sr_filter_probes(sample_size, unitsize, probelist,
  93                                    logic->data, logic->length,
  94                                    &filter_out, &filter_out_len) != SR_OK)
  95                 return;
  96
  97         data = g_object_get_data(G_OBJECT(siglist), "sampledata");
  98         g_return_if_fail(data != NULL);
  99
 100         g_array_append_vals(data, filter_out, filter_out_len/unitsize);
 101
 102         g_free(filter_out);
 103 }
 104
 105 void load_input_file(GtkWindow *parent, const gchar *file)
 106 {
 107         if (sr_session_load(file) == SR_OK) {
 108                 /* sigrok session file */
 109                 sr_session_datafeed_callback_add(datafeed_in);
 110                 sr_session_start();
 111                 sr_session_run();
 112                 sr_session_stop();
 113         }
 114
 115         /* Create a new session and programatically emit changed signal from
 116          * the device selection combo box to reselect the device.
 117          */
 118         sr_session_new();
 119         sr_session_datafeed_callback_add(datafeed_in);
 120         g_signal_emit_by_name(g_object_get_data(G_OBJECT(parent), "devcombo"),
 121                         "changed");
 122 }
 123
 124 int main(int argc, char **argv)
 125 {
 126         GtkWindow *window;
 127         GtkWidget *vbox, *vpaned, *log;
 128         gtk_init(&argc, &argv);
 129         icons_register();
 130         sr_init();
 131         sr_session_new();
 132         sr_session_datafeed_callback_add(datafeed_in);
 133
 134         window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 135         gtk_window_set_icon_name(window, "sigrok-logo");
 136         gtk_window_set_title(window, "Sigrok-GTK");
 137         gtk_window_set_default_size(window, 600, 400);
 138
 139         g_signal_connect(window, "destroy", gtk_main_quit, NULL);
 140
 141         vbox = gtk_vbox_new(FALSE, 0);
 142         vpaned = gtk_vpaned_new();
 143
 144         gtk_box_pack_start(GTK_BOX(vbox), toolbar_init(window), FALSE, FALSE, 0);
 145         gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
 146         log = log_init();
 147         gtk_widget_set_no_show_all(log, TRUE);
 148         g_object_set_data(G_OBJECT(window), "logview", log);
 149         gtk_paned_add2(GTK_PANED(vpaned), log);
 150         sigview = sigview_init();
 151         g_object_set_data(G_OBJECT(window), "sigview", sigview);
 152         gtk_paned_pack1(GTK_PANED(vpaned), sigview, TRUE, FALSE);
 153
 154         gtk_container_add(GTK_CONTAINER(window), vbox);
 155         gtk_widget_show_all(GTK_WIDGET(window));
 156
 157         sr_log_loglevel_set(SR_LOG_ERR);
 158
 159         gtk_main();
 160
 161         sr_session_destroy();
 162         gtk_exit(0);
 163
 164         return 0;
 165 }
 166