Not logged in. · Lost password · Register

All posts by Musil (10)

topic: Juli 2008 A1 f)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Juli 2008 A1 f)
Bei der Klausur Juli 2008 A1 f) schwanke ich zwischen 3 und 4

Da die Variable bar static ist, wird sie ja nach Verlassen der Funktion nicht vom Speicher genommen. Durch int* hole ich mir den Zugriff auf die Speicherstelle, also kann ich doch darin rumschreiben, deswegen klingt 3 nicht falsch.

Gleichzeitig wird bar doch jedes mal neu auf 0 initialisiert (würde das einen Unterschied machen, wenn da nur static int bar; stände?)
Kein Interrupt kann den Wert der Variable ändern, da sie lokal static ist, von daher klingt auch 4 nicht falsch

Was ist denn richtig?
topic: Wertebereichüberschreitung einer uint Variable  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Wertebereichüberschreitung einer uint Variable
was würde hier passieren?
uint8_t i = 999;
uint8_t j = -3;
uint8_t a = 255;
a+= 3000;
hat a dann den Wert (255+3000)%256 ?
Aber was würde bei den Zuweisungen passieren?
topic: Arrays (Nullpointer)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Arrays
Wenn ich mir ein Array von einer Stuktur anlege z.B. (kommt aus der Klausur März 2012)


static struct dst tabelle[100];

wenn ich jetzt weiter nichts getan habe, dann würde bei
if(tabelle[42]==NULL){
  //--//
}
niemals die Bedingung in if zutreffen oder?

kann ich aber tabelle[42] auf NULL setzen?
topic: polling  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: polling
polling haben wir so weit ich mich erinnere in nur in aktiven Warteschleifen implementiert, ist das dann trotzdem im großen Stile (wie z.B. bei den Tankkontrollaufgaben) klausurrelevant?
topic: Parameterübergabe über den Stack (Klausur Juli 2009 A3 b))  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Parameterübergabe über den Stack
Ich habe eine Frage zu folgender Klausuraufgabe:

Wie wird die Paramterübergabe über den Stack(z.B. auf einer Intel-Prozessorarchitektur) realisiert. Beschreiben Sie, wie die akutellen Paramter abgelegt werden und wie der Zugriff über die formalen Parameter erfolgt:

Ich weiß nicht so ganz, was ihr hier von mir wollt, bzw. welcher Foliensatz das ist. Ich poste hier mal das, was ich hingeschrieben hätte (ich weiß aber nicht, ob das überhaupt den Kern der Frage trifft bzw. ganz richtig ist)

der Stack ist in Stack-Frames unterteilt (für jede Funktion ein Stack-Frame), darin sind lokale automatic-Varialben, Rücksprungadressen und Funktionsparameter abgelegt. Der Stackpointer zeigt beim Anlegen immer hinter das aktuelle Ende, der Framepointer an den Anfang des jeweiligen Stackframes.

Könntet ihr verraten, was ihr eigentlich hören wolltet :)
topic: Klausur 2010-07 (Aufgab 2b backuplist)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
In reply to post ID 6015
Wenn es heißt: "reguläre" Dateien, sind dann automatisch alle versteckten Dateien ausgeschlossen?

Ich hab auch nochmal eine Lösung mit strcpy und strcat, würde die funktionieren? (also ich meine damit, ob es auf irgendwas davon Punktabzug geben würde)
Sry, ich hab weder Linux, noch eine Shell, noch irgendeine Programmierumgebung und vor allem keine Ahnung, wie ich das testen sollte.
  1. /*Funktion main*/
  2. int main(int argc, char **argv){   
  3.  
  4.     /*Aufrufargument pruefen, Referenzzeitpunkt ermitteln*/
  5.    
  6.     if(argc!=2){
  7.         fprintf(stderr, "wrong amout of arguments");
  8.         exit(EXIT_FAILURE);
  9.     }
  10.     char path[1024];
  11.     strcpy(path, argv[1]);
  12.     strcat(path, "/back.timestamp");
  13.     struct stat inf;
  14.     time_t backup;
  15.     if(lstat(path,&inf)==0){
  16.         backup = inf.st_mtime;
  17.     } else{
  18.         perror("lstat");
  19.         exit(EXIT_FAILURE);
  20.     }
  21.  
  22.    
  23.     /*Verzeichnis oeffnen*/
  24.     DIR* ver = opendir(argv[1]);
  25.     if(ver==NULL){
  26.         perror("opendir");
  27.         exit(EXIT_FAILURE);
  28.     }
  29.    
  30.     for(struct dirent *eintrag; (eintrag = readdir(ver)) != NULL; errno =0){
  31.         char name[1024];
  32.         struct stat buf;
  33.         strcpy(name, argv[1]);
  34.         strcat(name, "/");
  35.         strcat(name, eintrag->d_name);
  36.         if(lstat(name, &inf)==0){
  37.             if(S_ISREG(inf.st_mode)){
  38.                 if(inf.st_mtime>backup){
  39.                     printf("%s\n", name);
  40.                 }
  41.             }
  42.         } else {
  43.             perror("lstat");
  44.             exit(EXIT_FAILURE);
  45.         }
  46.        
  47.     }   
  48.        
  49.     }
  50.     if(errno){
  51.         perror("readdir");
  52.         exit(EXIT_FAILURE);
  53.     }
  54.     if(closdir(ver)){
  55.         perror("closedir");
  56.         exit(EXIT_FAILURE);
  57.     }
  58. }

Und noch eine Frage zu strcpy:
z.B:
  1. char buf[100];
  2. strcpy(buf, "Marmelade");
  3. strcpy(buf, "Brot");
steht jetzt in buf nur "Brot" oder "Brotelade" oder etwas ganz anderes?
topic: Modifikationszeiten bei Dateien auslesen (Klausur Juli 2010 2b: backuplist)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Modifikationszeiten bei Dateien auslesen
In der Klausur Juli 2010 2b soll man den Zeitpunkt der letzten Datensicherung überprüfen.
Frage: wie greift man darauf in der Datei backup.timestamp zu??

  1. /*Funktion main*/
  2. int main(int argc, char **argv){   
  3.  
  4.     /*Aufrufargument pruefen, Referenzzeitpunkt ermitteln*/
  5.  
  6.     if(argc != 2){
  7.         fprintf(stderr, "wrong amout of arguments");
  8.         exit(EXIT_FAILURE);
  9.     }
  10.    
  11.     //time_t safe = ????? back.timestamp....
  12.  
  13.    
  14.     /*Verzeichnis oeffnen*/
  15.     DIR* ver = opendir(argv[1]);
  16.     if(ver==NULL){
  17.         perror("opendir");
  18.         exit(EXIT_FAILURE);
  19.     }
  20.    
  21.     for(struct dirent *eintrag; (eintrag = readdir(ver)) != NULL; errno =0){
  22.         struct stat inf;
  23.         if(lstat(eintrag->d_name,&inf)==0){
  24.             if(S_ISREG(inf.st_mode)){
  25.                 if(inf.st_time > safe){
  26.                     printf("%s\n", eintrag->d_name);
  27.                 }
  28.             }
  29.         }
  30.     }
  31.     if(errno){
  32.         perror("readdir");
  33.         exit(EXIT_FAILURE);
  34.     }
  35.     if(closdir(ver)){
  36.         perror("closedir");
  37.         exit(EXIT_FAILURE);
  38.     }
  39. }
  40. /*Ende der Funktion main
topic: im Programm in andere Verzeichnisse wechseln, Fehlerüberprüfung bei lstat (Klausur April 2009 A2b: sls)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: im Programm in andere Verzeichnisse wechseln, Fehlerüberprüfung bei lstat
In der Klausur April 2009 2b bekommt man in argv den Verzeichnisnamen übergeben, welches man ausgeben soll.
Frage: reicht es, wenn man diesen Namen direkt an opendir übergibt oder muss man da noch etwas tun

2. Muss man bei lstat eine Fehlerüberprüfung machen?
Hier ist der Code:

  1. /*Funktion main*/
  2. int main(int argc, char **argv){
  3.  
  4. /*Argumente prüfuen*/
  5.     if(argc != 2){
  6.         fprintf(stderr, "wrong amout of arguments");
  7.         exit(EXIT_FAILURE);
  8.     }
  9.  
  10. /*in das auszugebene Verzeichnis wechseln*/
  11.  
  12. //wie macht man das??
  13.  
  14. /*auszugebendes Verzeichnis oeffnen*/
  15.     DIR *ver = opendir(argv[1]);
  16.     if(ver==NULL){
  17.         perror("opendir");
  18.         exit(EXIT_FAILURE);
  19.     }
  20.    
  21.     /*Directory durchsuchen und Einträge ausgegben*/
  22.     struct dirent *ent;
  23.    
  24.     while(errno = 0, (ent=readdir(ver)!= NULL)){
  25.         struct stat info;
  26.         if(ent->d_name[0]!='.'){
  27.             if(lstat(ent->d_name, &info)==0){
  28.                 printf("Dateiname %s, Dateigröße %d\n", ent->d_name, info.st_size);
  29.             } else {//notwendig????
  30.                 perror("lstat");
  31.                 exit(EXIT_FAILURE);
  32.             }
  33.         }
  34.     }
  35.     if(errno){
  36.         perror("readdir");
  37.         exit(EXIT_FAILURE);
  38.     }
  39.                
  40.     /*Ressourcen freigeben*/
  41.     if(closedir(ver)){
  42.         perror("closedir");
  43.         exit(EXIT_FAILURE);
  44.     }
  45.     exit(EXIT_SUCCESS);
  46. }
This post was edited on 2013-07-21, 14:14 by Musil.
topic: Klausur 2013-03 (Aufgabe 2b - compiledir)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
In reply to post ID 5984
ja, das hätte dann eher
    for(int i = 0; d->d_name[i] != '\0' || d->d_name[i+1] != '\0'; i++){
heißen sollen... passt das so?
topic: Klausur März 2012 Aufgabe 2a (dimmer)  in the forum: 2. Semester Grundlagen der systemnahen Programmierung in C
Musil
Member since Jul 2013
10 posts
Subject: Klausur März 2012 Aufgabe 2a
Hi,
könnte da mal jemand drüber schauen, ob das so passt?
Ich bin mir beim Ausrechnen der Warteintervalle nicht so ganz sicher, ob man das so machen darf (automatisches Runden...) genauso wie beim Setzen der Register in der Initialisierung
wär super :)

  1. /*Funktionsdeklarationen, globale Variablen etc.*/
  2. volatile int8_t helligkeit;
  3. volatile int8_t led =1;
  4. static void init(void);
  5. static void wait(uint16_t us);
  6.  
  7. /*Funktion main*/
  8. void main(void){
  9.  
  10.     /*Initialisierung und lokale Variablen*/
  11.     sleep_enable();
  12.     uint16_t leuchtzeit;
  13.     uint16_t auszeit;
  14.     init();
  15.  
  16.     /*Hauptschleife*/
  17.     for(;;){
  18.    
  19.         /*Schlafen*/
  20.         cli();
  21.         while(helligkeit == 0)
  22.             sei();
  23.             sleep_cpu();
  24.             cli();
  25.         }
  26.         sei();
  27.         /*LED ansteuern*/
  28.  
  29.         leuchtzeit = (LOOPS_PER_US*512/10*helligkeit);
  30.         auszeit = LOOPS_PER_US*512-leuchtzeit;
  31.  
  32.         PORTA = ~(1<<(led-1));
  33.         wait(leuchtzeit);
  34.         PORTA = 0xff;
  35.         wait(auszeit);
  36.     }
  37. }      
  38. /*Ende der Funktion main*/
  39.  
  40. /*Initialisierungsfunktion*/
  41. static void init(void){
  42.     DDRA = 0xff;
  43.     PORTA = 0xff;
  44.     DDRD &= ~((1<<2)|(1<<0));
  45.     PORTD |= (1<<2)|(1<<3);
  46.     MCUCR |= (1<<ISC01)|(1<<ISC11);
  47.     MCUCR &= ~((1<<ISC00)|(1<<ISC10));
  48.     GICR |= (1<<INT0)|(1<<INT1);
  49.         sei();
  50. }
  51.  
  52. /*Wartefunktion*/
  53. static void wait(uint16_t us){
  54.    
  55.     for(volatile uint16_t i = 0; i<us; i++){}
  56.    
  57. }
  58.  
  59. /*Unberbrechungsbehandlung*/
  60. ISR(INT0_vect){
  61.    
  62.     if(helligeit == 0){
  63.         if(led<8){
  64.             led++;
  65.         }
  66.     }
  67.     helligkeit = (helligkeit+1)%11;
  68.  
  69. }
  70.  
  71. ISR(INT1_vect){
  72.  
  73.     if(helligkeit==1){
  74.         if(led>1){
  75.             led--;
  76.         }
  77.     }
  78.     helligkeit = (helligkeit-1)%11;
  79.        
  80. }
This post was edited 2 times, last on 2013-07-20, 18:27 by Musil.
Close Smaller – Larger + Reply to this post:
Special characters:
Go to forum
Powered by the Unclassified NewsBoard software, 20110527-dev, © 2003-8 by Yves Goergen