Programm unter X mit GTK+

Programm unter X

Das Steuerprogramm wollte ich jedoch mit einer grafischen Oberfläche versehen, um auch einmal eine GUI (grafische Benutzeroberfläche) programmiert zu haben. Es gibt zwei grundsätzlich verschieden Ansätze eine GUI zu realisieren, die eine wäre mit einer Scriptsprache (z.B. Tk) eine Oberfläche zu erstellen die dann auf das bestehende C-Programm zugreift, die andere wäre das ganze in C oder C++ (also einer Sprache die zuerst compiliert werden muss) zu schreiben. Da mein schon programmiertes C-Programm einige Mängel aufweist, machte ich mich an die komplette Neuprogrammierung der Steuerungssoftware. Ein Beispielprogramm einer Uhr im Buch "Linux Programmierung" brachte mich auf eine Idee zur Lösung meines Problems mit dem zeitlichen weiterführen des Magnetfeldes.

Funktionsweise

Im Programm wird alle 10ms (Variable Zeit) die Funktion auslassen aufgerufen. In der Funktion auslassen wird die Variable x ausgewertet ist sie 0 wird die Funktion wieder verlassen, ansonsten wird y errechnet die Variable zaehler um 1 erhöht und überprüft ob y grösser als zaehler ist. Wenn y kleiner als der zaehler ist wird die Funktion auslassen wieder verlassen nur wenn y grösser als zaehler ist wird eine Änderung des Schaltzustandes vorgenommen.

Die wichtigsten Variablen um die Zeitsteuerung zu verstehen.

Variable	Funktion
x	die Variable die mit dem Schieber bzw. den Pfeilen verändert werden kann, wenn der Motor steht ist sie 0, bei positivem Drehsinn ist sie positiv bei negativem negativ und je grösser sie ist desto schneller läuft der Motor.
y	wird aus x errechnet 1/\|x\|^exponent
exponent	Exponent in der Funktion zur Berechnung von y
zeit	Zeit in ms bis die Funktion auslassen wieder aufgerufen wird

Die anderen Variablen sind im Quellcode dokumentiert.

Sämtliche Einstellungen sind unter dem Menu Einstellungen unter dem Punkt Einstellungen zu erreichen.
Da nach dem Starten des Programmes die Debug-Funktionen eingeschaltet werden können und das Programm dann jeden Schritt den es macht auf die Konsole schreibt (funktioniert nur wenn das Programm aus einer grafischen Konsole gestartet wird) und auch die Daten die an die parallele Schnittstelle gesendet werden auf die zweite Text-Konsole (/dev/tty2) geschrieben werden können (auf tty2 muss jemand eingelogt sein), dokumentiere ich es nicht weiter.

Screen Shot für alle die noch nie KDE unter Linux gesehen haben oder einfach mal schnell wissen wollen wie das Programm aussieht, alles wichtige ist geöffnet.

Schaltplan Eagle

grosses Bild

Quellcode Version 0.3.5

Der neuste Quellcode ist unter Download auffindbar.


//Thomas Kuster, Lagerstrasse 19, 5432 Neuenhof, thomas@fam-kuster.ch -> www.fam-kuster.ch
//Programm zur Steuerung eines Schrittmotors (Drehzahlregelung, Links-, Rechtslauf)
//Released under the GNU Public Licens, Version 2.0 or higherr -> www.gnu.org
//compilieren mit ->gcc -Wall stepper[version].c -o stepper[version].x `gnome-config --cflags --libs gnomeui`

#include <gnome.h>
//#include <gtk/gtk.h>
#include <fcntl.h>
#include <math.h>

gint zeit = 10, interface, x = 0, y, kanal[8], max_warten = 500, zaehler = 0, k[8] = { 0, 0, 0, 1, 0, 0, 0, 0 };
gfloat exponent = 1.5, test = 10;  //Exponent in der Formel: y = max_warten/|x|^exponent
gchar version[] = "0.3.6", aus[] = "0-1-2-3-4-5-6-7-", minusplus[] = "-+", geraet1[] = "/dev/lp0", geraet2[]= "/dev/tty2", bit[1] = " ";
gboolean debug = TRUE, ausgabe_art = TRUE, wohin = FALSE, wohin_alt, magnetfelder = TRUE;  //debug richtig -> FALSE;

GtkWidget *stepper_app, *buttonled0, *buttonled1, *buttonled2, *buttonled3, *debug_checkbox, *interface_radio1, *interface_radio2, *wohin_radio1, *wohin_radio2, *magnetfelder_radio1, *magnetfelder_radio2;

GtkObject *schieber;

static void auslassen (void);
static void kanaele_setzen (void);
static void oeffnen (void);
static void ausgeben (void);
static void quit (void);
static void reset (void);
static void schliessen(void);
static void plus (void);
static void minus (void);
static void fehler (void);
static void apply_preferences (GnomePropertyBox *propertybox, gint page_num); //, GtkWidget *debug_checkbox);
static void schieberegler (GtkAdjustment *schieber);
static void einstellungen (void);
static void info (void);

static void auslassen(void) //kontrolliert die Zeitverz&ouml;gerung durch nur teilweisen aufrufen von ausgeben 
{
  gtk_adjustment_set_value ( GTK_ADJUSTMENT(schieber), (gfloat) x);

  if(x != 0)                 //falls x = 0 nichts machen -> Motor bleibt stehen
    {

      y = max_warten / pow( abs(x) , exponent);  //y berechnen

      if (debug)
	g_print("y = %i\n", y);

      zaehler++;

      if ( zaehler > y )
	{
	  zaehler = 0;
	  kanaele_setzen();
	}
      else                   //else Zweig nur zum debuggen
	{
	  if (debug)
	    g_print("auslassen %i\n", zaehler);
	}
    }
  else
    zaehler = max_warten;    //Motor reagiert sofort, nur zur Sch&ouml;nheit
}

static void kanaele_setzen(void)
{
  if(x > 0)  //positiver Drehsinn
    {    
      k[0] = k[1];    //'erstes Magnetfeld'
      k[1]++;
      if(k[1] >= 4)
	k[1] = 0;

      
      if(magnetfelder)
	{
	  k[2] = k[3];    //'zweites Magnetfeld' nur wenn aktiviert
	  k[3]++;
	  if(k[3] >= 4)
	    k[3] = 0;
	}

      if (debug) 
	g_print("positiver Drehsinn\n");
	
    }
  else
    {
	    
      k[0] = k[1];    //'erstes Magnetfeld'
      k[1]--;
      if(k[1] <= -1)
	k[1] = 3;    
	    
      if(magnetfelder)
	{
	  k[2] = k[3];    //'zweites Magnetfeld' nur wenn aktiviert
	  k[3]--;
	  if(k[3] <= -1)
	    k[3] = 3;
	}

      if (debug)
	g_print("negativer Drehsinn\n");
	
    }

  //Bitmuster in Array kanal[] ablegen 0 = Kanal aus, 1 = Kanal ein Arraynummer entspricht Kanalnummer von 0 bis 7
  kanal[k[0]] = 0;    //ausschalten, zuerst ausschalten, damit ein Kanal der aus und eingeschaltet wird auf ein ist

  if(magnetfelder)
    kanal[k[2]] = 0;  //ausschalten

  kanal[k[1]] = 1;    //einschalten

  if(magnetfelder)
    kanal[k[3]] = 1;  //einschalten

  ausgeben();
}

static void oeffnen(void)
{
  if(wohin)
    {
      if(debug)
	g_print("oeffnen geraet1 \"%s\"\n", geraet1);
      if((interface = open(geraet1, O_WRONLY|O_APPEND)) == -1)
	fehler();
    }
  else
    {
      if(debug)
	g_print("oeffnen geraet2 \"%s\"\n", geraet2);
      if((interface = open(geraet2, O_WRONLY|O_APPEND)) == -1)
	fehler();
    }
}

static void ausgeben(void)
{
  //&Uuml;bersetzen des Bitmuster in die f&uuml;r die entsprechende Schalteinheit n&ouml;tigen Zeichen die gesendet werden m&uuml;ssen
  //F&uuml;r die 'einfache' zu programmierende 8-Kanal-Schalteinheit aus = "[kanal]-" und ein = "[kanal]+"

  if (debug)
    g_print("k[0-3] Kan&auml;le die ver&auml;ndert werden (ein hat priorit&auml;t): %i (aus), %i (ein), %i (aus), %i (ein)\nKanal[1-8] Bit-Muster: %i %i %i %i %i %i %i %i\n", k[0], k[1], k[2], k[3], kanal[0], kanal[1], kanal[2], kanal[3], kanal[4], kanal[5], kanal[6], kanal[7]);  //nur zum debuggen

  aus[1] = minusplus[kanal[0]];
  aus[3] = minusplus[kanal[1]];
  aus[5] = minusplus[kanal[2]];
  aus[7] = minusplus[kanal[3]];
  aus[9] = minusplus[kanal[4]];
  aus[11] = minusplus[kanal[5]];
  aus[13] = minusplus[kanal[6]];
  aus[15] = minusplus[kanal[7]];   

  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled0), (gboolean) kanal[0]);
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled1), (gboolean) kanal[1]);
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled2), (gboolean) kanal[2]);
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled3), (gboolean) kanal[3]);
  //gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled4), (gboolean) kanal[4]); //falls einmal 8-Kan&auml;le
  //gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled5), (gboolean) kanal[5]);
  //gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled6), (gboolean) kanal[6]);
  //gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (buttonled7), (gboolean) kanal[7]);
  
  if (ausgabe_art)
    {
      bit[0] = kanal[0] * 1 + kanal[1] * 2 + kanal[2] * 4 + kanal[3] * 8;
      if (debug)
	g_print("Zahl die Bin&auml;r ausgegeben wird: %i\n", (kanal[0] * 1 + kanal[1] * 2 + kanal[2] * 4 + kanal[3] * 8) );
      if ((write(interface, bit, 1)) != 1)
	fehler();
    }
  else
    {
      if (debug)
	g_print("Ausgabe mit write: %s\n", aus);
      if ((write(interface, aus, 16)) != 16)
	fehler();
    }
}

static void quit(void)     //zum sauberen beenden alle Kan&auml;le ausschalten und das Interface 'schliessen'
{
  reset();

  if (debug)
    g_print("Alle Kan&auml;le wurden ausgeschaltet\n");

  schliessen();

  gtk_main_quit();
}

static void reset(void)
{
  if (debug)
    g_print ("Reset x vorher(%i) und nachher (", x);

  x = 0;

  if (debug)
    g_print ("%i)\n", x);

  kanal[0] = 0;  //Bitmuster f&uuml;r alles aus in kanal[] ablegen
  kanal[1] = 0;
  kanal[2] = 0;
  kanal[3] = 0;
  kanal[4] = 0;
  kanal[5] = 0;
  kanal[6] = 0;
  kanal[7] = 0;
  ausgeben();
}

static void schliessen(void)
{
  close(interface);

  if (debug)
    g_print("Interface wurde \'geschlossen\'\n");  
}

static void plus(void)
{
  if (debug)
    g_print ("Plus x vorher(%i) und nachher (", x);

  x++;

  if (debug)
    g_print ("%i)\n", x);
}

static void minus(void)
{
  if (debug)
    g_print ("Minus x vorher(%i) und nachher (", x);

  x--;

  if (debug)
    g_print ("%i)\n", x);
}

static void fehler(void)    //Fehlermeldung erscheint nur wenn aus einer X-Konsole gestartet wird!!!
{
  g_print ("Konnte /dev/lp0 nicht zum schreiben &ouml;ffnen\n");
  exit(1);
}

static void apply_preferences(GnomePropertyBox *propertybox, gint page_num) //, GtkWidget *debug_checkbox, GtkWidget *interface_checkbox)
{

  if(debug)
    g_print("Function apply_preferences wurde aufgerufen mit page_num = %i\n", page_num);
  if (page_num != -1)
    {
      if(debug)
	g_print ("aufruf abgelehnt\n");
      return;
    }
  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (debug_checkbox)) == FALSE)
      debug = FALSE;
  else
      debug = TRUE;

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (wohin_radio1)) == FALSE) //Radio Buttons auswerten
    {
      if(wohin_alt)
	{
	  if(debug)
	    g_print("wohin = FALSE\n");
	  wohin = FALSE;
	  wohin_alt = wohin;
	  schliessen();
	  oeffnen();
	}
    }
  else
    {
      if(!wohin_alt)
	{
	  if(debug)
	    g_print("wohin = TRUE\n");
	  wohin = TRUE;
	  wohin_alt = wohin;
	  schliessen();
	  oeffnen();
	}
    }

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (interface_radio1)) == FALSE) //Radio Buttons auswerten
    {
      if(debug)
	g_print("ausgabe_art = FALSE\n");
      ausgabe_art = FALSE;
    }
  else
    {
      if(debug)
	g_print("ausgabe_art = TRUE\n");
      ausgabe_art = TRUE;
    }

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (magnetfelder_radio1)) == FALSE) //Radio Buttons auswerten
    {
      if(debug)
	g_print("magnetfelder = FALSE\n");
      magnetfelder = TRUE;
    }
  else
    {
      if(debug)
	g_print("magnetfelder = TRUE\n");
      magnetfelder = FALSE;
    }
}

//Schieberegler x &auml;nder je nach Stellung von x
static void schieberegler (GtkAdjustment *schieber)
{
  x = (gint) schieber->value;
  if (debug)
    g_print("Schieberegler x = %i\n", x);
}

static void einstellungen(void)
{

  GtkWidget *preferencebox;
  GtkWidget *vbox_1, *vbox_2, *vbox_3;
  GtkWidget *label1_1, *label1_2, *label2, *label3;

  preferencebox = gnome_property_box_new();

  gtk_window_set_title(GTK_WINDOW(preferencebox), "Einstellungen");

  vbox_1 = gtk_vbox_new(FALSE, 2);
  vbox_2 = gtk_vbox_new(FALSE, 2);
  vbox_3 = gtk_vbox_new(FALSE, 2);

  label1_1 = gtk_label_new ("Debug Funktion");
  gtk_box_pack_start (GTK_BOX (vbox_1), label1_1, FALSE, FALSE, 4);

  debug_checkbox = gtk_check_button_new_with_label( "einschalten" );
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON (debug_checkbox), debug);
  gtk_box_pack_start (GTK_BOX (vbox_1), debug_checkbox, FALSE, FALSE, 0);

  label1_2 = gtk_label_new ("Ausgabe Ger&auml;te \(Device)");
  gtk_box_pack_start (GTK_BOX (vbox_1), label1_2, FALSE, FALSE, 4);

  wohin_radio1 = gtk_radio_button_new_with_label(NULL, "/dev/lp0 \(parallele Schnittstelle)" );
  wohin_radio2 = gtk_radio_button_new_with_label( gtk_radio_button_group ( GTK_RADIO_BUTTON ( wohin_radio1 )), "/dev/tty2 \(Konsole 2)");

  if(wohin)
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( wohin_radio1 ), TRUE );
  else
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( wohin_radio2 ), TRUE );

  gtk_box_pack_start (GTK_BOX (vbox_1), wohin_radio1, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_1), wohin_radio2, FALSE, FALSE, 0);


  label2 = gtk_label_new ("Auswahl des Interface");
  gtk_box_pack_start (GTK_BOX (vbox_2), label2, FALSE, FALSE, 4);

  interface_radio1 = gtk_radio_button_new_with_label(NULL, "Steuerung mit einem 8-Bit-Wort" );
  interface_radio2 = gtk_radio_button_new_with_label( gtk_radio_button_group ( GTK_RADIO_BUTTON ( interface_radio1 )), "Steuerung mit der Zeichenfolge Kanalnummer und + bzw. -");

  if(ausgabe_art)
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( interface_radio1 ), TRUE );
  else
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( interface_radio2 ), TRUE );

  gtk_box_pack_start (GTK_BOX (vbox_2), interface_radio1, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_2), interface_radio2, FALSE, FALSE, 0);


  label3 = gtk_label_new ("Anzahl der umlaufenden Magnetfelder");
  gtk_box_pack_start (GTK_BOX (vbox_3), label3, FALSE, FALSE, 4);

  magnetfelder_radio1 = gtk_radio_button_new_with_label(NULL, "Ein Magnetfeld" );
  magnetfelder_radio2 = gtk_radio_button_new_with_label( gtk_radio_button_group ( GTK_RADIO_BUTTON ( magnetfelder_radio1 )), "Zwei Magnetfelder");

  if(magnetfelder)
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( magnetfelder_radio2 ), TRUE );
  else
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( magnetfelder_radio1 ), TRUE );

  gtk_box_pack_start (GTK_BOX (vbox_3), magnetfelder_radio1, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox_3), magnetfelder_radio2, FALSE, FALSE, 0);


  gtk_signal_connect_object (GTK_OBJECT (debug_checkbox), "toggled",
			     GTK_SIGNAL_FUNC (gnome_property_box_changed),
			     GTK_OBJECT (preferencebox));

  gtk_signal_connect_object (GTK_OBJECT (wohin_radio1), "toggled",
		     GTK_SIGNAL_FUNC (gnome_property_box_changed),
		     GTK_OBJECT (preferencebox));

  gtk_signal_connect_object (GTK_OBJECT (interface_radio1), "toggled",
		     GTK_SIGNAL_FUNC (gnome_property_box_changed),
		     GTK_OBJECT (preferencebox));

  gtk_signal_connect_object (GTK_OBJECT (magnetfelder_radio1), "toggled",
		     GTK_SIGNAL_FUNC (gnome_property_box_changed),
		     GTK_OBJECT (preferencebox));

  gtk_signal_connect (GTK_OBJECT (preferencebox), "apply",
		      GTK_SIGNAL_FUNC (apply_preferences), NULL);

  gnome_dialog_set_parent(GNOME_DIALOG(preferencebox), GTK_WINDOW(stepper_app));


  gnome_property_box_append_page(GNOME_PROPERTY_BOX(preferencebox),
				 vbox_1, gtk_label_new("Debug"));

  gnome_property_box_append_page(GNOME_PROPERTY_BOX(preferencebox),
  				 vbox_2, gtk_label_new("Interface"));

  gnome_property_box_append_page(GNOME_PROPERTY_BOX(preferencebox),
  				 vbox_3, gtk_label_new("Magnetfelder"));


  gtk_widget_show_all(preferencebox);

  wohin_alt = wohin;

  if(debug)
    g_print ("Einstellungen\n");  
}

static void info(void) //Info Kasten
{
  GtkWidget *about;
  const gchar *authors[] = { "Thomas Kuster", NULL };
  about = gnome_about_new("Programm zur Steuerung eines Schrittmotors", version,
                          "Released under the GNU Public License", authors,
                          ("Anwendung um die Drehzahl des Schrittmotor am parallelen Interface zu regeln.\n"), NULL);
  gtk_widget_show (about);
}


GnomeUIInfo file_menu[] = {
  GNOMEUIINFO_MENU_EXIT_ITEM(gtk_main_quit, NULL),
  GNOMEUIINFO_END
};

GnomeUIInfo settings_menu[] = {
  GNOMEUIINFO_ITEM_NONE ("Reset, alle Spulen aus", "Stelle alle Ausg&auml;nge am Interface ab", reset),  
  GNOMEUIINFO_ITEM_NONE ("Drehzahl Richtung +", "Drehzahl ver&auml;ndern in Richtung positiven Drehsinn", plus),
  GNOMEUIINFO_ITEM_NONE ("Drehzahl Richtung -", "Drehzahl ver&auml;ndern in Richtung negativen Drehsinn", minus),
  GNOMEUIINFO_MENU_PREFERENCES_ITEM(einstellungen, NULL),
  GNOMEUIINFO_END
  };

GnomeUIInfo help_menu[] = {
  GNOMEUIINFO_MENU_ABOUT_ITEM(info, NULL),
  GNOMEUIINFO_END
  };

GnomeUIInfo menubar[] = {
  GNOMEUIINFO_MENU_FILE_TREE(file_menu),
  GNOMEUIINFO_MENU_SETTINGS_TREE(settings_menu),
  GNOMEUIINFO_MENU_HELP_TREE(help_menu),
  GNOMEUIINFO_END
};

int main(int argc, char *argv[])
{
  GtkWidget *hbox1, *hbox2, *hbox3, *hbox4, *vbox, *vbox1_1, *vbox1_2;
  GtkWidget *buttonminus, *buttonplus, *buttonend, *buttonreset;
  GtkWidget *label_stepper;
  GtkWidget *hscale;

  gnome_init ("Schrittmotor", version, argc, argv);
  stepper_app = gnome_app_new ("Schrittmotor", "Steuerung des Schrittmotors");

  gtk_container_border_width (GTK_CONTAINER (stepper_app), 0);
    vbox1_1 = gtk_vbox_new (TRUE, 0);
    vbox1_2 = gtk_vbox_new (TRUE, 0);
    hbox1 = gtk_hbox_new (TRUE, 10);
    hbox2 = gtk_hbox_new (TRUE, 10);
    hbox3 = gtk_hbox_new (TRUE, 10);
    hbox4 = gtk_hbox_new (TRUE, 10);
    vbox  = gtk_vbox_new (FALSE, 0);

  label_stepper = gtk_label_new ( "Drehzahl und Richtung\ndes Schrittmotors\nsind &auml;nderbar" );
    gtk_box_pack_start (GTK_BOX (vbox1_1), label_stepper, FALSE, FALSE, 0);

  buttonled0 = gtk_check_button_new_with_label( "Spule / LED 0" );
    gtk_box_pack_start (GTK_BOX (vbox1_2), buttonled0, FALSE, FALSE, 0);

  // gtk_signal_connect (GTK_OBJECT (buttonled0), "toggled",
    //			GTK_SIGNAL_FUNC (LED), buttonled0);

  buttonled1 = gtk_check_button_new_with_label( "Spule / LED 1" );
    gtk_box_pack_start (GTK_BOX (vbox1_2), buttonled1, FALSE, FALSE, 0);
  buttonled2 = gtk_check_button_new_with_label( "Spule / LED 2" );
    gtk_box_pack_start (GTK_BOX (vbox1_2), buttonled2, FALSE, FALSE, 0);
  buttonled3 = gtk_check_button_new_with_label( "Spule / LED 3" );
    gtk_box_pack_start (GTK_BOX (vbox1_2), buttonled3, FALSE, FALSE, 0);

  schieber = gtk_adjustment_new (0, -75, 75, 1.0, 1.0, 0);  //default, min, max, step, page, page size
    hscale = gtk_hscale_new (GTK_ADJUSTMENT (schieber));
    gtk_scale_set_draw_value (GTK_SCALE (hscale), TRUE); //FALSE); 

    gtk_signal_connect (GTK_OBJECT (schieber), "value_changed",
    GTK_SIGNAL_FUNC (schieberegler), NULL);
    gtk_box_pack_start (GTK_BOX (hbox2), hscale, TRUE, TRUE, 0);

  buttonminus = gtk_button_new_with_label ( "- <-" );
    gtk_signal_connect_object (GTK_OBJECT (buttonminus), "clicked",
			       GTK_SIGNAL_FUNC (minus), NULL);
    gtk_box_pack_start (GTK_BOX (hbox3), buttonminus, TRUE, TRUE, 10);

  buttonplus = gtk_button_new_with_label ( "-> +" );
    gtk_signal_connect_object (GTK_OBJECT (buttonplus), "clicked",
			       GTK_SIGNAL_FUNC (plus), NULL);
    gtk_box_pack_start (GTK_BOX (hbox3), buttonplus, TRUE, TRUE, 10);

  buttonend = gtk_button_new_with_label ( "Beenden" );
    gtk_signal_connect_object (GTK_OBJECT (buttonend), "clicked",
			       GTK_SIGNAL_FUNC (quit), NULL);
    gtk_box_pack_start (GTK_BOX (hbox4), buttonend, TRUE, TRUE, 10);

  buttonreset = gtk_button_new_with_label ( "Reset" );
    gtk_signal_connect_object (GTK_OBJECT (buttonreset), "clicked",
			       GTK_SIGNAL_FUNC (reset), NULL);
    gtk_box_pack_start (GTK_BOX (hbox4), buttonreset, TRUE, TRUE, 10);

  gtk_signal_connect (GTK_OBJECT (stepper_app), "delete_event",
		      GTK_SIGNAL_FUNC (quit), NULL);  //Beendet auch beim schliessen des Hauptfensters

  gnome_app_create_menus (GNOME_APP (stepper_app), menubar);           //Menus erstellen
  gtk_container_add (GTK_CONTAINER (hbox1), vbox1_1);
  gtk_container_add (GTK_CONTAINER (hbox1), vbox1_2);
  gtk_container_add (GTK_CONTAINER (vbox), hbox1);
  gtk_container_add (GTK_CONTAINER (vbox), hbox2);
  gtk_container_add (GTK_CONTAINER (vbox), hbox3);
  gtk_container_add (GTK_CONTAINER (vbox), hbox4);
  gnome_app_set_contents (GNOME_APP (stepper_app), vbox);

  oeffnen();

  gtk_timeout_add(zeit, auslassen, NULL);  //Alle [Zahl] die Funktion auslassen aufrufen welche testet ob ausgeben aufgerufen wird 

  gtk_widget_show_all (stepper_app);
  gtk_main();

  return 0;
}