/*
 * Gruppe E9 - DZE
 */

#include <rtai_mbx.h>
#include <rtai_sched.h>

#include <uint128.h>
#include <sys/rtai_modbus.h>

#define SETBIT(i) (1 << i)
//Ausgänge
#define AUSGANG_HAUPTBAND_ANHALTEN SETBIT(0)
#define AUSGANG_HAUPTBAND_LANGSAMER SETBIT(1)
#define AUSGANG_HAUPTBAND_AN_LINKS SETBIT(2)
#define AUSGANG_HAUPTBAND_AN_RECHTS SETBIT(3)
#define AUSGANG_MASSENMAGAZINBAND_AN SETBIT(4)
#define AUSGANG_ZUBRINGERBAND_AN SETBIT(6)
#define AUSGANG_VEREINZELER SETBIT(7)
#define AUSGANG_AUSWURF_MASSENMAGAZIN SETBIT(8)
#define AUSGANG_MAGAZIN1_EINFAHREN SETBIT(9)
#define AUSGANG_MAGAZIN1_AUSFAHREN SETBIT(10)
#define AUSGANG_MAGAZIN2_EINFAHREN SETBIT(11)
#define AUSGANG_MAGAZIN2_AUSFAHREN SETBIT(12)
#define AUSGANG_MAGAZIN3_EINFAHREN SETBIT(13)
#define AUSGANG_MAGAZIN3_AUSFAHREN SETBIT(14)
#define AUSGANG_AUSWERFER_RECHTS SETBIT(15)
#define AUSGANG_AUSWERFER_LINKS SETBIT(16)
#define AUSGANG_AUSWERFER_SPERRE_ENTFERNEN SETBIT(17)
//Eingänge
#define EINGANG_MASSENMAGAZINBAND_ENDE SETBIT(0)
#define EINGANG_ZUBRINGERBAND_ENDE SETBIT(1)
#define EINGANG_HAUPTBAND_ANFANG SETBIT(2)
#define EINGANG_HAUPTBAND_ZW1U2 SETBIT(3)
#define EINGANG_HAUPTBAND_ZW2U3 SETBIT(4)
#define EINGANG_HAUPTBAND_VOR_WEICHE SETBIT(5)
#define EINGANG_VEREINZELER_AUSGEFAHREN SETBIT(6)
#define EINGANG_VEREINZELER_TEIL_DA SETBIT(7)
#define EINGANG_AUSWURF_MASSENMAGAZIN_AUSGEFAHREN SETBIT(8)
#define EINGANG_AUSWURF_MASSENMAGAZIN_TEIL_DA SETBIT(9)
#define EINGANG_MAGAZIN1_EINGEFAHREN SETBIT(10)
#define EINGANG_MAGAZIN1_AUSGEFAHREN SETBIT(11)
#define EINGANG_MAGAZIN1_TEIL_DA SETBIT(12)
#define EINGANG_MAGAZIN2_EINGEFAHREN SETBIT(13)
#define EINGANG_MAGAZIN2_AUSGEFAHREN SETBIT(14)
#define EINGANG_MAGAZIN2_TEIL_DA SETBIT(15)
#define EINGANG_MAGAZIN3_EINGEFAHREN SETBIT(16)
#define EINGANG_MAGAZIN3_AUSGEFAHREN SETBIT(17)
#define EINGANG_MAGAZIN3_TEIL_DA SETBIT(18)
#define EINGANG_AUSWERFER_RECHTS SETBIT(19)
#define EINGANG_AUSWERFER_LINKS SETBIT(20)
#define EINGANG_AUSWERFER_MITTE SETBIT(21) //evtl. sleep erforderlich, weil Sensor zu früh Volĺzug meldet
#define EINGANG_AUSWERFER_SPERRE SETBIT(22)
#define EINGANG_RUTSCHE_VOLL SETBIT(23)
#define EINGANG_HOEHENSENSOR_VERDREHT SETBIT(24)
#define EINGANG_HOEHENSENSOR_OK SETBIT(25)

MODULE_LICENSE("GPL");

static RT_TASK pruefercontrol_task;
static RT_TASK vereinzeler_task;
static RT_TASK magazin_task;
static RT_TASK massenmagazin_task;
static RT_TASK auswerfer_task;
static RT_TASK rutsche_task;

static SEM hauptband_kreuzung_sem;
static SEM modbus_sem;
static SEM alles_anhalten_sem;

static MBX pruefer_an_auswerfer_mbx;
static MBX auswerfer_an_rutsche_mbx;
static MBX rutsche_an_auswerfer_mbx;

char hauptband_kreuzung_geblockt = 0;
char massenmagazin_leer = 0;
char alles_anhalten = 0;

int fd_node;
int current_Modbus_Out;
int readModbus(int in_or_out);
int writeModbus(int in_or_out, int values);
int isSet(int in_or_out, int wert);
int set(int wert);
int delete(int wert);
int deleteAll(void);
void magazinAuswerfen(int magazin);
void pollKreuzung(void);


int readModbus(int in_or_out) {
	unsigned short low;
	unsigned short high;
	if (rt_modbus_get(fd_node, in_or_out, 0, (unsigned short *) &low)) {
		rt_printk("failed reading modbus");
	}
	if (rt_modbus_get(fd_node, in_or_out, 1, (unsigned short *) &high)) {
		rt_printk("failed reading modbus");
	}
	return ((int) low | (int) (high << 16));
}

int writeModbus(int in_or_out, int values) {
	int worked = 1;
	unsigned short low = values;
	unsigned short high = (values >> 16);
	if (rt_modbus_set(fd_node, in_or_out, 0, low)) {
		rt_printk("failed writing modbus");
		worked = 0;
	}
	if (rt_modbus_set(fd_node, in_or_out, 1, high)) {
		rt_printk("failed writing modbus");
		worked = 0;
	}
	return worked;
}

int isSet(int in_or_out, int wert) {
	int currentStatus = readModbus(in_or_out);
	currentStatus = currentStatus & wert;
	return currentStatus;
}

int set(int wert) {
	int result;

	rt_sem_wait(&modbus_sem);
	current_Modbus_Out = current_Modbus_Out | wert;
	result = writeModbus(DIGITAL_OUT, current_Modbus_Out);
	rt_sem_signal(&modbus_sem);

	return result;
}

int delete(int wert) {
	int result;

	rt_sem_wait(&modbus_sem);
	if(isSet(DIGITAL_OUT, wert)) {
		current_Modbus_Out = current_Modbus_Out ^ wert;
		result = writeModbus(DIGITAL_OUT, current_Modbus_Out);
	} else {
		result = 1;
	}
	rt_sem_signal(&modbus_sem);

	return result;
}

int deleteAll(void) {
	return writeModbus(DIGITAL_OUT, 0);
}

void magazinAuswerfen(int magazin) {
	int ausfahren, einfahren, ausgefahren, eingefahren;
	if (magazin == 3) {
		ausfahren = AUSGANG_MAGAZIN3_AUSFAHREN;
		einfahren = AUSGANG_MAGAZIN3_EINFAHREN;
		ausgefahren = EINGANG_MAGAZIN3_AUSGEFAHREN;
		eingefahren = EINGANG_MAGAZIN3_EINGEFAHREN;
	}
	if (magazin == 2) {
		ausfahren = AUSGANG_MAGAZIN2_AUSFAHREN;
		einfahren = AUSGANG_MAGAZIN2_EINFAHREN;
		ausgefahren = EINGANG_MAGAZIN2_AUSGEFAHREN;
		eingefahren = EINGANG_MAGAZIN2_EINGEFAHREN;
	}
	if (magazin == 1) {
		ausfahren = AUSGANG_MAGAZIN1_AUSFAHREN;
		einfahren = AUSGANG_MAGAZIN1_EINFAHREN;
		ausgefahren = EINGANG_MAGAZIN1_AUSGEFAHREN;
		eingefahren = EINGANG_MAGAZIN1_EINGEFAHREN;
	}
	set(ausfahren);
	// Druck aufbauen
	rt_sleep(50 * nano2count(1000000));
	while (!isSet(DIGITAL_IN, ausgefahren)) {
		rt_sleep(50 * nano2count(1000000));
	}
	delete(ausfahren);
	rt_sleep(50 * nano2count(1000000));
	set(einfahren);
	rt_sleep(50 * nano2count(1000000));
	while (!isSet(DIGITAL_IN, eingefahren)) {
		rt_sleep(5 * nano2count(1000000));
	}
	delete(einfahren);
	rt_sleep(50 * nano2count(1000000));
}

void pollKreuzung(void){
	char hauptband_kreuzung_polling;
	rt_sem_wait(&hauptband_kreuzung_sem);
	hauptband_kreuzung_polling = hauptband_kreuzung_geblockt;
	rt_sem_signal(&hauptband_kreuzung_sem);

	if (hauptband_kreuzung_polling) {
		// Prüfen ob Teil da
		while (!isSet(DIGITAL_IN, EINGANG_HAUPTBAND_VOR_WEICHE)) {
			// Pollingfrequenz
			rt_sleep(5 * nano2count(1000000));
		}
		// Teil muss Sensor verlassen haben
		while (isSet(DIGITAL_IN, EINGANG_HAUPTBAND_VOR_WEICHE)) {
			// Pollingfrequenz
			rt_sleep(5 * nano2count(1000000));
		}
		rt_sem_wait(&hauptband_kreuzung_sem);
		hauptband_kreuzung_geblockt--;
		rt_sem_signal(&hauptband_kreuzung_sem);
		while (isSet(DIGITAL_IN, EINGANG_HAUPTBAND_VOR_WEICHE)) {
			// Pollingfrequenz
			rt_sleep(5 * nano2count(1000000));
		}
	}
}

/* Control Task */
static void pruefercontrol(long x) {

	//Initialisierung
	rt_printk("control: task started\n");

	/* Verbindung zum Modbus-Knoten herstellen */
	if ((fd_node = rt_modbus_connect("modbus-node")) == -1) {

		rt_printk("control: task exited\n");
		return;
	}
	rt_printk("control: MODBUS communication opened\n");
	rt_printk("%i\n", readModbus(DIGITAL_OUT));
	deleteAll();

	current_Modbus_Out = readModbus(DIGITAL_OUT);
	// Vor dieser Zeile keinen Code einfügen!!!

	// Auswerfer in definierten Zustand bringen
	set(AUSGANG_AUSWERFER_RECHTS);
	rt_printk("Druck rechts\n");
	set(AUSGANG_AUSWERFER_LINKS);
	rt_printk("Druck links\n");
	set(AUSGANG_AUSWERFER_SPERRE_ENTFERNEN);
	// Druck aufbauen
	rt_sleep(50 * nano2count(1000000));
	delete(AUSGANG_AUSWERFER_LINKS);
	rt_printk("Warte, bis Auswerfer rechts ist...\n");
	while(!isSet(DIGITAL_IN, EINGANG_AUSWERFER_RECHTS)) {
		// Pollingfrequenz
		rt_sleep(50 * nano2count(1000000));
	}
	rt_printk("... Auswerfer ist rechts.\n");
	// kann ggf. weg.
	//rt_sleep(50 * nano2count(1000000));

	// Auswerfer in die Mitte setzen:
	delete(AUSGANG_AUSWERFER_SPERRE_ENTFERNEN);
	// Druck aufbauen
	rt_sleep(50 * nano2count(1000000));
	set(AUSGANG_AUSWERFER_RECHTS);
	set(AUSGANG_AUSWERFER_LINKS);
	// Druck aufbauen
	rt_sleep(50 * nano2count(1000000));
	delete(AUSGANG_AUSWERFER_RECHTS);

	//Magazine einfahren, falls ausgefahren
	if(isSet(DIGITAL_IN, EINGANG_MAGAZIN1_AUSGEFAHREN)) {
		set(AUSGANG_MAGAZIN1_EINFAHREN);
		// Druck aufbauen
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_MAGAZIN1_EINFAHREN);
	}
	if(isSet(DIGITAL_IN, EINGANG_MAGAZIN2_AUSGEFAHREN)) {
		set(AUSGANG_MAGAZIN2_EINFAHREN);
		// Druck aufbauen
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_MAGAZIN2_EINFAHREN);
	}
	if(isSet(DIGITAL_IN, EINGANG_MAGAZIN3_AUSGEFAHREN)) {
		set(AUSGANG_MAGAZIN3_EINFAHREN);
		// Druck aufbauen
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_MAGAZIN3_EINFAHREN);
	}
	if(isSet(DIGITAL_IN, EINGANG_AUSWURF_MASSENMAGAZIN_AUSGEFAHREN)) {
		set(AUSGANG_AUSWURF_MASSENMAGAZIN);
		// Druck aufbauen
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_AUSWURF_MASSENMAGAZIN);
		rt_printk("Initialisierung Massenmagazin...\n");
		while(isSet(DIGITAL_IN, EINGANG_AUSWURF_MASSENMAGAZIN_AUSGEFAHREN)) {
			// Pollingfrequenz
			rt_sleep(50 * nano2count(1000000));
		}
		rt_printk("... Massenmagazin initialisiert!\n");
	}

	// Den Vereinzeler-Task brauchen wir bereits hier
	rt_task_resume(&vereinzeler_task);
	rt_printk("Vereinzeler geladen\n");

	//Zubringerband an und auf volle Geschwindigkeit
	rt_modbus_set(fd_node, IB_IL_AO, 0, 30000);
	set(AUSGANG_ZUBRINGERBAND_AN);

	// Hauptband an
	set(AUSGANG_HAUPTBAND_AN_RECHTS);
	// Leerfahrt der Bänder
	rt_printk("Leerfahrt\n");
	rt_sleep(10000 * nano2count(1000000));

	// Massenmagazinband leerlaufen lassen...
	set(AUSGANG_MASSENMAGAZINBAND_AN);
	rt_sleep(3000 * nano2count(1000000));
	delete(AUSGANG_MASSENMAGAZINBAND_AN);
	rt_printk("Massenmagazinband fertig\n");
	rt_sleep(4000 * nano2count(1000000));
	rt_printk("Resuming tasks.\n\n---------------------------------------------\n\n");

	rt_task_resume(&magazin_task);
	rt_printk("Magazin geladen\n");

	rt_task_resume(&massenmagazin_task);
	rt_printk("Massenmagazin geladen\n");

	rt_task_resume(&auswerfer_task);
	rt_printk("Auswerfer geladen\n");

	rt_task_resume(&rutsche_task);
	rt_printk("Rutsche geladen\n");

	rt_printk("Initialisiert\n");


	//Pruefer-funktion
	while (1) {
		if(isSet(DIGITAL_IN, EINGANG_HAUPTBAND_VOR_WEICHE)){
			if(isSet(DIGITAL_IN, EINGANG_HOEHENSENSOR_VERDREHT)){
				// Nachricht an Auswerfer
				char msg = 'a';
				rt_mbx_send(&pruefer_an_auswerfer_mbx, &msg, sizeof(char));
			}
			while(isSet(DIGITAL_IN, EINGANG_HAUPTBAND_VOR_WEICHE)){
				// Pollingrequenz
				rt_sleep(5 * nano2count(1000000));
			}
		}

		// Prüfer muss schnell reagieren können, daher wenig sleep
		rt_sleep(5 * nano2count(1000000));
	}
}

/* Vereinzeler */
static void vereinzeler(long x) {
	char bandaus = 0;
	while (1) {
		if (isSet(DIGITAL_IN, EINGANG_VEREINZELER_TEIL_DA)) {
			int i = 0;
			set(AUSGANG_VEREINZELER);
			do {
				if(isSet(DIGITAL_OUT, AUSGANG_HAUPTBAND_ANHALTEN) && !bandaus) {
					continue;
				}
				// Pollingfrequenz
				rt_sleep(50 * nano2count(1000000));
				i++;
				if (i >= 20) {
					set(AUSGANG_HAUPTBAND_ANHALTEN);
					// Warten, damit Band sicher angehalten ist
					rt_sleep(100 * nano2count(1000000));
					bandaus = 1;
				}

			} while (isSet(DIGITAL_IN, EINGANG_VEREINZELER_TEIL_DA) && i <= 20);
			if (bandaus) {
				delete(AUSGANG_VEREINZELER);
				rt_sem_wait(&alles_anhalten_sem);
				alles_anhalten = 1;
				rt_sem_signal(&alles_anhalten_sem);

				while (isSet(DIGITAL_IN, EINGANG_ZUBRINGERBAND_ENDE)) {
					// Pollingfrequenz
					rt_sleep(50 * nano2count(1000000));
				}
				delete(AUSGANG_HAUPTBAND_ANHALTEN);
				// warten bis sicher angelaufen
				rt_sleep(50 * nano2count(1000000));
				set(AUSGANG_VEREINZELER);
				while (isSet(DIGITAL_IN, EINGANG_VEREINZELER_TEIL_DA)) {
					// Pollingfrequenz
					rt_sleep(50 * nano2count(1000000));
				}
				rt_sem_wait(&alles_anhalten_sem);
				alles_anhalten = 0;
				rt_sem_signal(&alles_anhalten_sem);
				bandaus = 0;
			}
			delete(AUSGANG_VEREINZELER);
		}
		// Linux Zeit abgeben
		rt_sleep(100 * nano2count(1000000));
	}
}

/* Magazin */
static void magazin(long x) {
	int i = 0;
	while (1) {
		pollKreuzung();
		if (isSet(DIGITAL_IN, EINGANG_MAGAZIN3_TEIL_DA)) {
			rt_printk("Magazin 3: Blockiere Hauptband\n");
			rt_sem_wait(&hauptband_kreuzung_sem);
			hauptband_kreuzung_geblockt = 1;
			rt_sem_signal(&hauptband_kreuzung_sem);
			magazinAuswerfen(3);
		}
		else if (isSet(DIGITAL_IN, EINGANG_MAGAZIN2_TEIL_DA)) {

			magazinAuswerfen(2);

			while (!isSet(DIGITAL_IN, EINGANG_HAUPTBAND_ZW2U3)) {
				// Pollingfrequenz
				rt_sleep(5 * nano2count(1000000));
			}
			rt_printk("Magazin 2: Blockiere Hauptband\n");
			rt_sem_wait(&hauptband_kreuzung_sem);
			hauptband_kreuzung_geblockt = 1;
			rt_sem_signal(&hauptband_kreuzung_sem);

		} else if (isSet(DIGITAL_IN, EINGANG_MAGAZIN1_TEIL_DA)) {

			magazinAuswerfen(1);

			while (!isSet(DIGITAL_IN, EINGANG_HAUPTBAND_ZW2U3)) {
				// Pollingfrequenz
				rt_sleep(5 * nano2count(1000000));
			}
			rt_printk("Magazin 1: Blockiere Hauptband\n");
			rt_sem_wait(&hauptband_kreuzung_sem);
			hauptband_kreuzung_geblockt = 1;
			rt_sem_signal(&hauptband_kreuzung_sem);
		} else {
			if(massenmagazin_leer){
				i++;
				if(i >= 11){
					set(AUSGANG_HAUPTBAND_ANHALTEN);
					while(i){
						if (isSet(DIGITAL_IN, EINGANG_MAGAZIN3_TEIL_DA) || isSet(DIGITAL_IN, EINGANG_MAGAZIN2_TEIL_DA)|| isSet(DIGITAL_IN, EINGANG_MAGAZIN1_TEIL_DA)|| isSet(DIGITAL_IN, EINGANG_AUSWURF_MASSENMAGAZIN_TEIL_DA)) {
							delete(AUSGANG_HAUPTBAND_ANHALTEN);
							i = 0;
						}
					}
				}
			}
		}
		// Linux Zeit abgeben
		rt_sleep(1000 * nano2count(1000000));
	}
}

/* Massenmagazin */
static void massenmagazin(long x) {
	char ausgeworfen = 0;
	while (1) {
		start:
		if(ausgeworfen==0){
			//wenn nichts ausgeworfen, dann auswerfen
			if(isSet(DIGITAL_IN, EINGANG_AUSWURF_MASSENMAGAZIN_TEIL_DA)){
				set(AUSGANG_MASSENMAGAZINBAND_AN);
				set(AUSGANG_AUSWURF_MASSENMAGAZIN);
				// Warten bis Teil aus Vereinzeler gefahren
				rt_sleep(500 * nano2count(1000000));
				delete(AUSGANG_AUSWURF_MASSENMAGAZIN);
				ausgeworfen = 1;
				// Warten bis Teil vorne ist, Task muss in der Zeit nichts machen...
				rt_sleep(1500 * nano2count(1000000));
			}
			else {
				massenmagazin_leer = 1;
				delete(AUSGANG_MASSENMAGAZINBAND_AN);
				while(!isSet(DIGITAL_IN, EINGANG_AUSWURF_MASSENMAGAZIN_TEIL_DA)){
					// Pollingfrequenz
					rt_sleep(100 * nano2count(1000000));
				}
				set(AUSGANG_MASSENMAGAZINBAND_AN);
				goto start;
			}
		}
		// warten bis Teil vorne
		while(!isSet(DIGITAL_IN, EINGANG_MASSENMAGAZINBAND_ENDE)) {
			// Pollingfrequenz
			rt_sleep(100 * nano2count(1000000));
		}
		//Band anhalten
		delete(AUSGANG_MASSENMAGAZINBAND_AN);
		// Fragen, ob Kreuzung frei ist
		rt_sem_wait(&hauptband_kreuzung_sem);
		while(hauptband_kreuzung_geblockt) {
			rt_sem_signal(&hauptband_kreuzung_sem);
			// Pollingfrequenz
			rt_sleep(100 * nano2count(1000000));
			rt_sem_wait(&hauptband_kreuzung_sem);
		}
		rt_sem_signal(&hauptband_kreuzung_sem);
		set(AUSGANG_MASSENMAGAZINBAND_AN);
		hauptband_kreuzung_geblockt = 1;
		rt_sem_signal(&hauptband_kreuzung_sem);
		ausgeworfen = 0;

		// Linux Zeit abgeben
		rt_sleep(500 * nano2count(1000000));
	}
}

/* Auswurf Task */
static void auswerfer(long x) {
	char msg;
	while (1) {
		// Nur arbeiten, wenn Teil ausgeworfen werden muss
		rt_mbx_receive(&pruefer_an_auswerfer_mbx, &msg, sizeof(char));
		set(AUSGANG_AUSWERFER_LINKS);
		set(AUSGANG_AUSWERFER_RECHTS);
		set(AUSGANG_AUSWERFER_SPERRE_ENTFERNEN);
		//Druckaufbau
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_AUSWERFER_LINKS);

		while(!isSet(DIGITAL_IN, EINGANG_AUSWERFER_RECHTS)) {
			// Pollingfrequenz
			rt_sleep(10 * nano2count(1000000));
		}
		// Druck aufbauen
		rt_sleep(50 * nano2count(1000000));

		rt_mbx_send(&auswerfer_an_rutsche_mbx, &msg, sizeof(char));
		rt_mbx_receive(&rutsche_an_auswerfer_mbx, &msg, sizeof(char));

		while(!isSet(DIGITAL_IN, EINGANG_RUTSCHE_VOLL)){
			// niedrige Pollingfrequenz, weil Task sowieso nur arbeitet, wenn wirklich nötig
			rt_sleep(5 * nano2count(1000000));
		}
		// in die Mitte setzen:
		set(AUSGANG_AUSWERFER_LINKS);
		set(AUSGANG_AUSWERFER_RECHTS);
		delete(AUSGANG_AUSWERFER_SPERRE_ENTFERNEN);
		//Druckaufbau
		rt_sleep(50 * nano2count(1000000));
		delete(AUSGANG_AUSWERFER_RECHTS);
	}
}

static void rutsche(long x){
	char msg;
	while (1) {
		// Arbeitet nur wenn Teil ausgeworfen wurde
		rt_mbx_receive(&auswerfer_an_rutsche_mbx, &msg, sizeof(char));
		if(isSet(DIGITAL_IN, EINGANG_RUTSCHE_VOLL)){
			// Zeit zwischen beiden Abfragen
			rt_sleep(50 * nano2count(1000000));
			if(isSet(DIGITAL_IN, EINGANG_RUTSCHE_VOLL)){
				set(AUSGANG_HAUPTBAND_ANHALTEN);
				while(isSet(DIGITAL_IN, EINGANG_RUTSCHE_VOLL)){
					// Pollingfrequenz
					rt_sleep(50 * nano2count(1000000));
				}
				rt_sem_signal(&alles_anhalten_sem);
				while(alles_anhalten){
					rt_sem_signal(&alles_anhalten_sem);
					//Pollingfrequenz
					rt_sleep(100 * nano2count(1000000));
					rt_sem_signal(&alles_anhalten_sem);
				}
				rt_sem_signal(&alles_anhalten_sem);

				delete(AUSGANG_HAUPTBAND_ANHALTEN);
				msg = 'v';
			}
		}
		else {
			msg = 'f';
		}
		rt_mbx_send(&rutsche_an_auswerfer_mbx, &msg, sizeof(char));

		rt_sleep(500 * nano2count(1000000));
	}
}

/* Funktion, die beim Entfernen des Moduls aufgerufen wird */
static void __exit
example_exit(void) {
	/* Task loeschen */
	rt_task_delete(&pruefercontrol_task);
	rt_task_delete(&vereinzeler_task);
	rt_task_delete(&magazin_task);
	rt_task_delete(&massenmagazin_task);
	rt_task_delete(&auswerfer_task);
	rt_task_delete(&rutsche_task);

	/* Semaphoren löschen */
	rt_sem_delete(&hauptband_kreuzung_sem);
	rt_sem_delete(&modbus_sem);
	rt_sem_delete(&alles_anhalten_sem);

	/* Mailboxen löschen */
	rt_mbx_delete(&pruefer_an_auswerfer_mbx);
	rt_mbx_delete(&rutsche_an_auswerfer_mbx);
	rt_mbx_delete(&auswerfer_an_rutsche_mbx);
	/* Timer stoppen */
	stop_rt_timer();
	printk("DZE Gruppe E9 unloaded\n");
}

/* Funktion die beim Laden des Moduls aufgerufen wird */
static int __init
example_init(void) {
	/* variables Timing basierend auf dem CPU-Takt */
	rt_set_oneshot_mode();
	/* Timer starten */
	start_rt_timer(0);
	/* Modbuskommunikation initialisieren */
	modbus_init();

	/* Taskinitialisierung
	 *
	 * &task = Adresse des zu initialisierenden TCB
	 * control = zum Task gehörende Funktion
	 * 0 = Uebergabeparameter an die zum Task gehoerende Funktion (long)
	 * 1024 = Stacksize
	 * 0 = Priorität des Tasks (0 = groesste)
	 * 0 = uses_fpu (Fliesskommaeinheit nicht benutzen); im Praktikum sollte es 0 bleiben
	 * NULL = &signal_handler; Referenz zu einer Fkt., die bei jeder Aktivierung
	 * des Tasks aufgerufen wird, ansonsten NULL
	 *
	 * Achtung: Nach der Initialisierung ist der Task "suspended"!
	 *
	 */
	if (rt_task_init(&pruefercontrol_task, pruefercontrol, 0,
			10240, 0, 0, NULL)) {
		printk("prueferrutschecontrol kann nicht starten\n");
		goto fail;
	}
	if (rt_task_init(&vereinzeler_task, vereinzeler, 0, 10240, 1, 0, NULL)) {
		printk("vereinzeler kann nicht starten\n");
		goto fail;
	}
	if (rt_task_init(&magazin_task, magazin, 0, 10240, 1, 0, NULL)) {
		printk("magazin kann nicht starten\n");
		goto fail;
	}
	if (rt_task_init(&massenmagazin_task, massenmagazin, 0, 10240, 1, 0,
			NULL)) {
		printk("massenmagazin kann nicht starten\n");
		goto fail;
	}
	if (rt_task_init(&auswerfer_task, auswerfer, 0, 10240, 1, 0, NULL)) {
		printk("auswerfer kann nicht starten\n");
		goto fail;
	}
	if (rt_task_init(&rutsche_task, rutsche, 0, 10240, 1, 0, NULL)) {
			printk("rutsche kann nicht starten\n");
			goto fail;
	}

	/* Semaphoren initialisieren */
	rt_typed_sem_init(&hauptband_kreuzung_sem, 1, BIN_SEM | FIFO_Q);
	rt_typed_sem_init(&modbus_sem, 1, BIN_SEM | FIFO_Q);
	rt_typed_sem_init(&alles_anhalten_sem, 1, BIN_SEM | FIFO_Q);

	/* Mailboxen initialisieren */
	rt_mbx_init(&pruefer_an_auswerfer_mbx, 3 * sizeof(char));
	rt_mbx_init(&rutsche_an_auswerfer_mbx, 3 * sizeof(char));
	rt_mbx_init(&auswerfer_an_rutsche_mbx, 3 * sizeof(char));

	/* suspend -> ready bzw. running */
	rt_task_resume(&pruefercontrol_task);

	printk("DZE Gruppe E9 loaded\n");
	return (0);

	fail:
	/* Aufraeumen */
	stop_rt_timer();
	return (1);
}

/* Modulein- und ausstieg festlegen */
module_exit(example_exit)
module_init(example_init)