3. Fernstudent suchen Hilfe in Echtzeitprogramierung, per Teamviewer und Auszahlung per PayPal

Fernstudent suchen Hilfe in Echtzeitprogramierung, per Teamviewer und Auszahlung per PayPal

  • C

    Hallo zusammen,

    ich studiere zur Zeit Informationstechnik.
    Ich schreibe nächste Woche im Studienfach "Echtzeitprogrammierung" meine Prüfung.

    In der Prüfung muss ich ein C++ Code umschreiben. Und ein Petrinet erstellen.
    Als Übung habe ich paar C++-Codes. die ich leider nicht ganz verstehe.

    Kann mir jemand, heute oder morgen über TeamView helfen? Ich denke eine 1-2 Stunden Sitzung würde ausreichen. Un eventuell noch 1-2 Mails wenn ich nachträgliche paar fragen haben sollte.

    Ich möchte gerne dafür was Zahlen, um geholfen zu werden! Ich denke 50€ für die action ist fair 🙂

    anbei ein Beispiel_Code den ich nicht verstehe.
    Und unten weiter ein Link zum Petrinet

    Aufgabenstellung:

    Raucher-Problem:

In einer Kneipe sitzen 3 Raucher ("Selbstdreher", welche die

Utensilien Tabak, Papier und Streichhˆlzer zum Rauchen benˆtigen).

Jeder besitzt je ein Utensil in unendlicher Menge, gibt aber

keinem anderen etwas ab.

Deshalb bringt die Wirtin 2 von 3 zuf‰llig ausgew‰hlten Utensilien,

wartet auf die Fertigmeldung eines Rauchers, um dann wiederholt

2 Utensilien zu bringen.

Die Raucher ergreifen die ihnen fehlenden Utensilien, rauchen und

geben die Fertigmeldung an die Wirtin, um erneut auf Utensilien

zu warten.

Der Zugriff auf die Utensilien (= Betriebsmittelzugriff) erfolgt

auch dann, wenn lediglich eines passt.

Deshalb kommt es sehr schnell zu Verklemmungen (sog. Deadlocks,

siehe Datei Ergebnisse.txt).

Generieren Sie folgende Petrinetze:

- Stellen-Transitionsnetz (nichtunterscheidbare Marken) mit

  zugelassener Verklemmung,

- Pr‰dikats-Transitionsnetz (unterscheidbare Marken) ebenfalls

  mit zugelassener Verklemmung,

- Pr‰dikats-Transitionsnetz mit Verhinderung der Verklemmung

  durch BM-Zugriff en bloc!

Leiten Sie schliefllich ein unter RTAI-LINUX lauff‰higes ANSI-C-

Programm ab, das durch bedingte Compilierung folgende Funktiona-

lit‰ten abdeckt:

- unbehandelte Verklemmung (Prototyp),

- Verklemmungserkennung (Timeout f¸r Wartezeit auf Fertigmeldung),

- Verklemmungsverhinderung (BM-Zugriff en bloc)!

    CODE:

    /**********************************************************************************
 *  	Raucherproblem unter RTAI-Linux							  *
 *	ohne "wachen",	ohne "verkl_frei":	Verklemmungen zulassen	  *
 *	mit "wachen",	ohne "verkl_frei":	Verklemmungen erkennen	  *
 *	ohne/mit "wachen", mit "verkl_frei":	Verklemmungen verhindern *
 **********************************************************************************/
#define wachen			// Verklemmung bei BM-Anford. erkennen
//#define verkl_frei		// verklemmungsfreie Anforderung der BM

#include <linux/module.h>
#include <rtai_sched.h>
#include <rtai_sem.h>

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Raucherproblem (mit Zufallszahlengenerator)");
MODULE_AUTHOR("Juergen Ruck <ruck@hs-mittweida.de>, 26.10.2011");

RT_TASK Prozess[4];		// Prozessbeschreibungsvariablen
int PNR[4] = {1,2,3,4};		// Prozessnummern
SEM ut[3], fertig;			// Semaphore
char UT[3][8] = {"Tabak", "Papier", "Hoelzer"};

// Zufallszahlengenerator random(R)
// liefert gleichverteilte Zufallszahl im Bereich von 0..R-1
// Wertebereich fuer R: 1..2^32 (dargestellt mit 0),
// Initialisierung des Generators bei erstmaligem Aufruf
// Achtung: Zufallszahlen abwechselnd gerade und ungerade !!!
unsigned random(unsigned R)
{   static unsigned Z, I=1;
    if(I) I=0, Z=(unsigned)(rt_get_time()>>4);
    Z = Z*65537+257;
    if (R) return Z%R;
    return Z;
}

void Raucher(long NR)	// Rumpf der Raucherprozesse 1..3
{   unsigned u1=NR-1, u2=NR%3, i, k;
    while (1)
    {	rt_printk("Raucher %ld wartet auf %s und %s\n", NR, UT[u1], UT[u2]);
#ifdef verkl_frei
	while ( (i = rt_sem_wait_if(&ut[u1]))  +  (k = rt_sem_wait_if(&ut[u2]))  <  2 )
	{	if (i)	rt_sem_signal(&ut[u1]);
		if (k) rt_sem_signal(&ut[u2]);
		rt_sleep(nano2count(10000000));	// 0.01 s Verzoegerung
	}
#else
	if (random(256)<128)				// zufaellige Zugriffsreihenfolge
	{	i=u1; k=u2; }
	else
	{	i=u2; k=u1; }
	rt_sem_wait(&ut[i]);				// nimmt Utensil 1
	rt_sleep(nano2count(10000000));	// 0.01s Verzoeg.
	rt_printk("Raucher %ld hat %s und wartet auf %s\n", NR, UT[i], UT[k]);
	rt_sem_wait(&ut[k]);				// nimmt Utensil 2
#endif
	rt_printk("Raucher %ld hat %s und %s und raucht\n", NR, UT[u1], UT[u2]);
	rt_sleep(nano2count(random(100000000)+100000000)); // 0.1..0.2 s Verzoeg.
	rt_printk("Raucher %ld gibt Fertigmeldung\n", NR);
	rt_sem_signal(&fertig);	// Fertigmeldung geben
    }
}

void Wirtin(long dummy)		// Rumpf des Wirtinnenprozesses
{   unsigned u1, u2;
    while (1)
    {	rt_printk("Wirtin ist am Tresen\n\n");
	rt_sleep(nano2count(100000000));	// 0.1 s Verzoegerung
	u1 = random(3);
	do u2 = random(3); while (u1==u2);
	rt_printk("Wirtin bringt %s und %s und wartet auf Fertigmeldung\n",
		    UT[u1], UT[u2]);
	rt_sem_signal(&ut[u1]);	// Utensil 1 bringen
	rt_sleep(nano2count(random(10000000)+10000000)); // 0.01..0.02 s Verzoeg.
	rt_sem_signal(&ut[u2]);	// Utensil 2 bringen
#ifdef wachen
	if (rt_sem_wait_timed(&fertig, nano2count(300000000)))	// 0.3 s warten
		rt_printk("\n*********Verklemmung eingetreten **********\n\n\n");
	else continue;
#endif
	rt_sem_wait(&fertig);		// Fertigmeldung erwarten
   }
}

int start(void)
{   int i;
    rt_set_oneshot_mode();	// CPU-Taktzaehler als Zeitgeber verwenden
    start_rt_timer(0);		// APIC-Zeitgeber starten

    for (i=0; i<3; i++)		// Semaphore initialisieren
		rt_sem_init(&ut[i], 0);
    rt_sem_init(&fertig, 0);

    for (i=0; i<3; i++)		// Raucher 1..3 starten und in ready versetzen
    {	rt_task_init(&Prozess[i], Raucher, PNR[i], 2048, 1, 0 ,0);
        rt_task_resume(&Prozess[i]);
    }
    rt_task_init(&Prozess[3], Wirtin, PNR[3], 2048, 0, 0 ,0); // hoeher prior.
    rt_task_resume(&Prozess[3]);// Wirtin starten und in ready versetzen
    return 0;
}

void cleanup(void)
{   int i;
    for (i=0; i<4; i++)		// Prozesse stoppen
    	rt_task_delete(&Prozess[i]);
    for (i=0; i<3; i++)		// Semaphore zerstoeren
		rt_sem_delete(&ut[i]);
    rt_sem_delete(&fertig);
    stop_rt_timer();		// APIC-Zeitgeber stoppen
}

module_init(start);
module_exit(cleanup);

    Petrinet:

    https://www.dropbox.com/s/jh810pdv9olqp6j/Raucher Petrinet.pdf?dl=0

    Anbei meine Email: christian.klein.torres@gmail.com

    Mit freundlichen Grüßen
    Christian aus Braunschweig

    0
  • C

    Hallo zusammen.

    Leider hat sich hier keiner gemeldet.
    Aber ich habe es jetzt doch durch eine andere Hilfe es hinbekommen.

    Gruß,
    Christian

    0
Anmelden zum Antworten