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



  • 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



  • Hallo zusammen.

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

    Gruß,
    Christian


Log in to reply