Das 5. Semester ist nun endlich hinter mir. Jetzt warten nur noch die Klausuren auf mich und dann heißt es erstmal Semesterferien. In den Semesterferien werden dann auch die Noten mit Spannung erwartet. Denn ein Großteil der Klausurnoten der Fächer im 5. Semester setzt sich aus Projektarbeiten zusammen. Mal schauen ob die Mühen entsprechend belohnt werden.

Nach einigen weiteren Wochen des Arbeitens wurde der Roboter umgebaut und auch wieder komplett neukonstruiert. Nebenbei wurden die verschiedenen Sensoren getestet und auch an der KI beziehungsweise an nötigen Funktionen sowie Interfaces gearbeitet.

Hier einige Bilder zu unserem Roboter M.O.N.T.E. aus dem KI Praktikum. Wie man erkennen kann ist der Roboter mittels Lego NXT Mindstorms fertig konstruiert worden. In den nächsten Sitzungen gilt es nun festzustellen, ob die Konstruktion ihren Zweck erfüllt. Dafür müssen sämtliche Sensoren und Bewegungsabläufe mit einem einfachen linear ablaufenden Testprogramm überprüft werden.

Und wieder gibt es eine Übersicht über das aktuelle Semester.

Projektmanagement:
Wie der Name schon sagt werden hier Inhalte und Methoden des Projektmanagements gelehrt. Um die Methoden direkt in die Praxis umzusetzen findet neben der Vorlesung auch ein Praktikum statt. In dem Praktikum selber gibt es Teams aus 6 Personen, die sich wiederum aus Teamgliedern aus mindestens drei verschiedenen Studiengängen zusammensetzen.

Künstliche Intelligenz 2:
KI2 besteht nur noch aus einem Praktikum, welches mit in die Klausurnote einfließt. Bestandteil des Praktikums ist die Konstruktion und Programmierung eines Roboters auf Basis von Lego Mindstorms NXT sowie LeJOS. Am Ende des Praktikums soll der Roboter an einem internen Wettbewerb teilnehmen und gegen andere Robtoren antreten.

Informatik und Gesellschaft:
Informatik und Gesellschaft ist eine Ringvorlesung, die aus 13 verschiedenen Vorlesungen von ebenso vielen Professoren besteht. In jeder Vorlesung wird ein anderes Thema aus dem Bereich Informatik und Gesellschaft behandelt.

Recht:
Neben informatikspezifischen Fächern gehören auch Fächer aus anderen Themen Bereichen zur Ausbildung eines “Allgemeinen Informatikers”. Im Fach Recht wird das BGB behandelt insbesondere der Allgemeine Teil, das Recht der Schuldverhältnisse und das Sachenrecht.

Informationsmanagement 2:
Wie auch KI2 besteht IM2 nur noch aus einem Praktikum. In dem Praktikum werden nun die gelehrten Inhalte und Methoden aus IM1 auf ein Business Engineering Projekt angewendet.

Am Dienstag fand die Abgabe des dritten DB2 Praktikums statt. Die 3 Aufgaben behandelten die Anbindung von Java an die Oracle Datenbank mittels JDBC. Es war nichts besonderes, außer das die UPDATE und SELECT Befehle entsprechend eingebunden werden mussten. Hier der Link zu den Lösungen: Praktikum_3_DB_2

Leider etwas verspätet, aber besser spät als nie. Hier die Lösungen zum dritten BS1 Praktikum:

In Aufgabe 2 sollte der folgende Programmcode mit den dazu vorgegebenen Befehlen ausgeführt werden:

#include <stdio.h>
#include <unistd.h>
int main () {
    printf(“Textausgabe vor dem Fork\n”);
    fork();
    printf(“Textausgabe nach dem Fork\n”);
    return 0;
}

Befehle:

./a.out
./a.out | cat

Es galt dann die Problemstellung zu lösen, wie für beide Befehle dieselbe Ausgabe zu realisieren sei. Die Lösung ist dabei ziemlich simpel, in dem man einfach eine Pufferentleerung vor dem fork() durchführt.

#include <stdio.h>
#include <unistd.h>
int main () {
    printf(“Textausgabe vor dem Fork\n”);
    fflush(stdout);
    fork();
    printf(“Textausgabe nach dem Fork\n”);
    return 0;
}

Die Lösung zu Aufgabe 3 sieht wie folgt aus:

#include<stdio.h>
#include<sys/wait.h>
#include<unistd.h>

void ausgabe(int x){
    int i;
    for(i=0; i<20; i++){
        printf(“%d”, x);
        usleep(1000);
        fflush(stdout);
    }
}

int main() {
    if(fork()==0){
        ausgabe(0);
    }
    else if(fork()==0){
        ausgabe(1);
    }
    else if(fork()==0){
        ausgabe(2);
    }
    else{
        waitpid(-1, NULL, 0);
        waitpid(-1, NULL, 0);
        waitpid(-1, NULL, 0);
        printf(“\nfertig\n”);
    }
    return 0;
}

Hier sollten jeweils 3 Kindprozesse erzeugt werden, die zwanzig mal eine 1, 2 und 3 ausgeben. Nach jedem Durchlauf der Schleife wird 1 ms gewartet und eine Pufferentleerung durchgeführt. Der Vaterprozess wartet mittels waitpid() auf das Ende der Kindprozesse.

Zuletzt wurde eine Prozess-Synchronisation mittels pipe programmiert. Das Programm soll nur zwei Parameter als Übergabe zulassen und ansonsten eine Fehlermeldung ausgeben!

#include<stdio.h>

int main(int argc, char *argv[]){

    int pipe_connect[2];
    if(pipe(pipe_connect)==-1){
        printf(“Fehler beim Erzeugen der Pipe”);
        return -1;
    }
    if(argc>3){
        printf(“Zu viele Parameter!\n”);
        return -1;
    }
    if(fork()==0){
        dup2(pipe_connect[1], 1);
        close(pipe_connect[0]);
        execlp(argv[1], argv[1], 0);

        printf(“Der Aufruf 1 ist fehlgeschlagen!”);
        return -1;
    }
    else if(fork()==0){
        dup2(pipe_connect[0], 0);
        close(pipe_connect[1]);
        execlp(argv[2], argv[2], 0);

        printf(“Der Aufruf 2 ist fehlgeschlagen!”);
        return -1;
    }
    else{
        close(pipe_connect[0]);
        close(pipe_connect[1]);
        wait(0);
        wait(0);
    }
    return 0;
}

Hier nun die Lösungen zu den Aufgaben 2-4 aus dem zweiten BS1 Praktikum!
In Aufgabe 2 sollte man die Anzahl der Parameter in der Argumentenliste und die Argumentenliste, die bei dem Programmaufruf angegeben wird, mittels des Programms ausgeben. Die Ausgabe erfolgt, wie gefordert, dabei über die Pointerschreibweise. Werden keine Parameter angegeben, so wird eine Fehlermeldung ausgegeben und ein Fehlercode an die Shell zurück gegeben.

#include<stdio.h>
#include<stdlib.h>

int main(int argc, char *argv[]) {
    int    i = 0;
    if (argc==1){
        printf(“ERROR: Kein Parameter!\n”);
        return 1;
    }
    else {
        printf(“Anzahl der Kommandozeilenparameter: %d \n”, argc);
        printf(“Die Eingabeparameter sind:\n”);
        while(*argv != 0) {
            printf(“argv[%d] = %s \n”, i++, *argv++);
        }
    }
    return 0;
}

Die Aufgabenstellung Nummer drei lässt sich schnell und unkompliziert zusammenfassen. Gefordert war die Ausgabe der Umgebungsvariablen, das Setzen einer Umgebungsvariable und das Suchen nach Umgebungsvariablen, ob diese vorhanden sind!

#include<stdio.h>
#include<stdlib.h>

void main(int argc, char* argv[], char* envp[]) {
    printf(“Liste der Umgebungsvariablen:\n”);
    while(*envp != 0) {
        printf(“%s \n”, *envp++);
    }

    setenv (“HUGO”, “Hugo”, 1);

    char search[50];
    printf(“Geben Sie die zusuchende Umgebungsvariable an:\n”);
    scanf(“%s”, &search);
    if(getenv(search)){
        printf(“%s = %s\n”, search, getenv(search));
    }
    else{
        printf(“Die gesuchte Umgebungsvariable existiert nicht!\n”);
    }
}

Das Programm für Ausgabe 4 ersetzt einen vorhandenen Prozess durch einen anderen mittels einem Befehl aus der exec-Familie. Der fork()-Aufruf durfte laut Aufgabenstellung nicht verwendet werden.

#include <stdio.h>
#include <unistd.h>

int main() {
    printf(“Eigene Prozess-ID: %i\n\n”, getpid());
    execlp(“ps”, “ps-Test”, 0);
    printf(“Ein Problem ist während dem Ersetzen des Prozesses aufgetreten!”);
return -1;
}