Vorbereitung 7.11.2022

20221031/hp-20221031.tex

@@ -20,7 +20,7 @@
 % Attribution-ShareAlike 3.0 Unported License along with this
 % document.  If not, see <http://creativecommons.org/licenses/>.
 
-% README: Callback-Funktionen, make
+% README: Callback-Funktionen, make, Bit-Operationen, I/O-Ports
 
 \documentclass[10pt,t]{beamer}
 

20221107/Makefile

+%.elf: %.c
+	avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
+
+%.hex: %.elf
+	avr-objcopy -O ihex $< $@
+
+download:
+	./download.sh

20221107/aufgabe-2.c

+#include <string.h>
+
+int fun_1 (char *s)
+{
+  int x = 0;
+  for (int i = 0; i < strlen (s); i++)
+    x += s[i];
+  return x;
+}
+
+int fun_2 (char *s)
+{
+  int i = 0, x = 0;
+  int len = strlen (s);
+  while (i < len)
+    x += s[i++];
+  return x;
+}

20221107/aufgabe-3.c

+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+uint8_t counter = 1;
+uint8_t leds = 0;
+
+ISR (TIMER0_COMP_vect)
+{
+  if (counter == 0)
+    {
+      leds = (leds + 1) % 8;
+      PORTC = leds << 4;
+    }
+  counter++;
+}
+
+void init (void)
+{
+  cli ();
+  TCCR0 = (1 << CS01) | (1 << CS00);
+  TIMSK = 1 << OCIE0;
+  sei ();
+  DDRC = 0x70;
+}
+
+int main (void)
+{
+  init ();
+  while (1)
+    ; /* do nothing */
+  return 0;
+}

20221107/blink-0.c

+#include <avr/io.h>
+
+int main (void)
+{
+  DDRD = 0x40;   /* binär: 0100 0000 */
+  PORTD = 0x40;  /* binär: 0100 0000 */
+  while (1);
+  return 0;
+}

20221107/blink-0a.c

+#include <avr/io.h>
+
+int main (void)
+{
+  DDRD = 0x40;   /* binär: 0100 0000 */
+  PORTD = 0x00;  /* binär: 0000 0000 */
+  while (1);
+  return 0;
+}

20221107/blink-1.c

+#include <avr/io.h>
+
+#define F_CPU 16000000l
+#include <util/delay.h>
+
+int main (void)
+{
+  DDRD = 0x01;
+  PORTD |= 0x01;
+  while (1)
+    {
+      _delay_ms (500);
+      PORTD &= ~0x01;
+      _delay_ms (500);
+      PORTD |= 0x01;
+    }
+  return 0;
+}

20221107/blink-1a.c

+#include <avr/io.h>
+
+#define F_CPU 16000000l
+#include <util/delay.h>
+
+int main (void)
+{
+  DDRD = 0xff;   /* 1111 1111 --> alle Ports als Output-Ports nutzen */
+  PORTD = 0x1a;  /* 0001 1010 */
+  while (1)
+    {
+      _delay_ms (500);
+      PORTD &= ~0x01;
+      _delay_ms (500);
+      PORTD |= 0x01;
+    }
+  return 0;
+}

20221107/blink-1b.c

+#include <avr/io.h>
+
+#define F_CPU 16000000l
+#include <util/delay.h>
+
+int main (void)
+{
+  DDRD = 0x7f;   /* 0111 1111 --> alle Ports als Output-Ports nutzen */
+  PORTD = 0x01;  /* 0000 0001 */
+  while (1)
+    {
+      while (PIND & 0x80)  /* 1000 0000 */
+        {
+          _delay_ms (500);
+          PORTD &= ~0x01;
+          _delay_ms (500);
+          PORTD |= 0x01;
+        }
+    }
+  return 0;
+}

20221107/download.sh

+port=$(ls -rt /dev/ttyACM* | tail -1)
+echo avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1)
+avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1) 2>/dev/null

20221107/hp-musterloesung-20221107.tex

+% hp-musterloesung-20221031.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+  \section*{Hardwarenahe Programmierung\\
+            Musterlösung zu den Übungsaufgaben -- 7.\ November 2022}
+
+  \exercise{Ausgabe von Hexadezimalzahlen}
+
+  Schreiben Sie eine Funktion \lstinline{void print_hex (uint32_t x)},
+  die eine gegebene vorzeichenlose 32-Bit-Ganzzahl \lstinline{x}
+  als Hexadezimalzahl ausgibt.
+  (Der Datentyp \lstinline{uint32_t} ist mit \lstinline{#include <stdint.h>} verfügbar.)
+
+  Verwenden Sie dafür \emph{nicht\/} \lstinline{printf()} mit
+  der Formatspezifikation \lstinline{%x} als fertige Lösung,
+  sondern programmieren Sie die nötige Ausgabe selbst.
+  (Für Tests ist \lstinline{%x} hingegen erlaubt und sicherlich nützlich.)
+
+  Die Verwendung von \lstinline{printf()}
+  mit anderen Formatspezifikationen wie z.\,B.\ \lstinline{%d}
+  oder \lstinline{%c} oder \lstinline{%s} ist hingegen zulässig.
+
+  \points{8}
+
+  (Hinweis für die Klausur: Abgabe auf Datenträger ist erlaubt und erwünscht,
+  aber nicht zwingend.)
+
+  \solution
+
+  Um die Ziffern von \lstinline{x} zur Basis 16 zu isolieren,
+  berechnen wir \lstinline{x % 16} (modulo 16 = Rest bei Division durch 16)
+  und dividieren anschließend \lstinline{x} durch 16,
+  solange bis \lstinline{x} den Wert 0 erreicht.
+
+  Wenn wir die auf diese Weise ermittelten Ziffern direkt ausgeben,
+  sind sie \emph{Little-Endian}, erscheinen also in umgekehrter Reihenfolge.
+  Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-1.c} setzt diesen Zwischenschritt um.
+
+  Die Ausgabe der Ziffern erfolgt in \gitfile{hp}{2022ws/20221107}{loesung-1-1.c}
+  über \lstinline{printf ("%d")}
+  für die Ziffern 0 bis 9. Für die darüberliegenden Ziffern
+  wird der Buchstabe \lstinline{a} um die Ziffer abzüglich 10 inkrementiert
+  und der erhaltene Wert mit \lstinline{printf ("%c")} als Zeichen ausgegeben.
+
+  Um die umgekehrte Reihenfolge zu beheben,
+  speichern wir die Ziffern von \lstinline{x}
+  in einem Array \lstinline{digits[]} zwischen
+  und geben sie anschließend in einer zweiten Schleife
+  in umgekehrter Reihenfolge aus (siehe \gitfile{hp}{2022ws/20221107}{loesung-1-2.c}).
+  Da wir wissen, daß \lstinline{x} eine 32-Bit-Zahl ist
+  und daher höchstens 8 Hexadezimalziffern haben kann,
+  ist 8 eine sinnvolle Länge für das Ziffern-Array \lstinline{digits[8]}.
+
+  Nun sind die Ziffern in der richtigen Reihenfolge,
+  aber wir erhalten zusätzlich zu den eigentlichen Ziffern führende Nullen.
+  Da in der Aufgabenstellung nicht von führenden Nullen die Rede war,
+  sind diese nicht verboten; \gitfile{hp}{2022ws/20221107}{loesung-1-2.c} ist daher
+  eine richtige Lösung der Aufgabe.
+
+  \breath
+
+  Wenn wir die führenden Nullen vermeiden wollen,
+  können wir die \lstinline{for}-Schleifen durch \lstinline{while}-Schleifen ersetzen.
+  Die erste Schleife zählt hoch, solange \lstinline{x} ungleich 0 ist;
+  die zweite zählt von dem erreichten Wert aus wieder herunter
+  -- siehe \gitfile{hp}{2022ws/20221107}{loesung-1-3.c}.
+  Da wir wissen, daß die Zahl \lstinline{x} höchstens 32 Bit,
+  also höchstens 8 Hexadezimalziffern hat,
+  wissen wir, daß \lstinline{i} höchstens den Wert 8 erreichen kann,
+  das Array also nicht überlaufen wird.
+
+  Man beachte, daß der Array-Index nach der ersten Schleife "`um einen zu hoch"' ist.
+  In der zweiten Schleife muß daher \emph{zuerst\/} der Index dekrementiert werden.
+  Erst danach darf ein Zugriff auf \lstinline{digit[i]} erfolgen.
+
+  \breath
+
+  Alternativ können wir auch mitschreiben,
+  ob bereits eine Ziffer ungleich Null ausgegeben wurde,
+  und andernfalls die Ausgabe von Null-Ziffern unterdrücken
+  -- siehe \gitfile{hp}{2022ws/20221107}{loesung-1-4.c}.
+
+  \breath
+
+  Weitere Möglichkeiten ergeben sich, wenn man bedenkt,
+  daß eine Hexadezimalziffer genau einer Gruppe von vier Binärziffern entspricht.
+  Eine Bitverschiebung um 4 nach rechts
+  ist daher dasselbe wie eine Division durch 16,
+  und eine Und-Verknüpfung mit 15$_{10}$ = f$_{16}$ = 1111$_2$
+  ist dasselbe wie die Operation Modulo 16.
+  Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-5.c} ist eine in dieser Weise abgewandelte Variante
+  von \gitfile{hp}{2022ws/20221107}{loesung-1-3.c}.
+
+  Mit dieser Methode kann man nicht nur auf die jeweils unterste Ziffer,
+  sondern auf alle Ziffern direkt zugreifen.
+  Damit ist kein Array als zusätzlicher Speicher mehr nötig.
+  Die Datei \gitfile{hp}{2022ws/20221107}{loesung-1-6.c} setzt dies auf einfache Weise um.
+  Sie gibt wieder führende Nullen mit aus,
+  ist aber trotzdem eine weitere richtige Lösung der Aufgabe.
+
+  Die führenden Nullen ließen sich auf die gleiche Weise vermeiden
+  wie in \gitfile{hp}{2022ws/20221107}{loesung-1-4.c}.
+
+  Die Bitverschiebungsmethode hat den Vorteil,
+  daß kein zusätzliches Array benötigt wird.
+  Auch wird die als Parameter übergebene Zahl \lstinline{x} nicht verändert,
+  was bei größeren Zahlen, die über Zeiger übergeben werden, von Vorteil sein kann.
+  Demgegenüber steht der Nachteil,
+  daß diese Methode nur für eine ganze Anzahl von Bits funktioniert,
+  also für Basen, die Zweierpotenzen sind (z.\,B.\ 2, 8, 16, 256).
+  Für alle anderen Basen (z.\,B.\ 10) eignet sich nur die Methode
+  mit Division und Modulo-Operation.
+
+  \exercise{Länge von Strings}
+
+  Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+  Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
+
+  Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
+  zur Verfügung (\lstinline{#include <string.h>}).
+
+  \begin{itemize}
+    \item[(a)]
+      Auf welche Weise ist die Länge eines Strings gekennzeichnet?
+      \points{1}
+    \item[(b)]
+      Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
+      und wieviel Speicherplatz belegt sie?\\
+      \points{2}
+    \item[(c)]
+      Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
+      die die Länge eines Strings zurückgibt.\\
+      \points{3}
+  \end{itemize}
+
+  Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-2.c}):
+  \begin{center}
+    \begin{minipage}{8cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_1 (char *s)
+        {
+          int x = 0;
+          for (int i = 0; i < strlen (s); i++)
+            x += s[i];
+          return x;
+        }
+      \end{lstlisting}
+    \end{minipage}%
+    \begin{minipage}{6cm}
+      \vspace*{-1cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_2 (char *s)
+        {
+          int i = 0, x = 0;
+          int len = strlen (s);
+          while (i < len)
+            x += s[i++];
+          return x;
+        }
+      \end{lstlisting}
+      \vspace*{-1cm}
+    \end{minipage}
+  \end{center}
+  \begin{itemize}
+    \item[(d)]
+      Was bewirken die beiden Funktionen?
+      \points{2}
+    \item[(e)]
+%      Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
+%      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
+%      Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
+%       \points 3
+%    \item[(f)]
+      Schreiben Sie eine eigene Funktion,
+      die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
+      nur effizienter.
+      \points{4}
+  \end{itemize}
+
+  \solution
+
+  \begin{itemize}
+    \item[(a)]
+      \textbf{Auf welche Weise ist die Länge eines Strings gekennzeichnet?}
+
+      Ein String ist ein Array von \lstinline{char}s.
+      Nach den eigentlichen Zeichen des Strings enthält das Array
+      \textbf{ein Null-Symbol} (Zeichen mit Zahlenwert 0,
+      nicht zu verwechseln mit der Ziffer \lstinline{'0'}) als Ende-Markierung.
+      Die Länge eines Strings ist die Anzahl der Zeichen
+      \emph{vor\/} diesem Symbol.
+
+    \item[(b)]
+      {\bf Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
+      und wieviel Speicherplatz belegt sie?}
+
+      Sie ist 14 Zeichen lang (\lstinline{'\n'} ist nur 1 Zeichen;
+      das Null-Symbol, das das Ende markiert, zählt hier nicht mit)
+      und belegt Speicherplatz für 15 Zeichen
+      (15 Bytes -- einschließlich Null-Symbol / Ende-Markierung).
+
+    \item[(c)]
+      \textbf{Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
+      die die Länge eines Strings zurückgibt.}
+
+      Siehe die Dateien \gitfile{hp}{2022ws/20221107}{loesung-2c-1.c} (mit Array-Index)
+      und \gitfile{hp}{2022ws/20221107}{loesung-2c-2.c} (mit Zeiger-Arithmetik).
+      Beide Lösungen sind korrekt und arbeiten gleich schnell.
+
+      Die Warnung \lstinline[style=terminal]{conflicting types for built-in function "strlen"}
+      kann normalerweise ignoriert werden;
+      auf manchen Systemen (z.\,B.\ MinGW) hat jedoch die eingebaute Funktion \lstinline{strlen()}
+      beim Linken Vorrang vor der selbstgeschriebenen,
+      so daß die selbstgeschriebene Funktion nie aufgerufen wird.
+      In solchen Fällen ist es zulässig, die selbstgeschriebene Funktion
+      anders zu nennen (z.\,B.\ \lstinline{my_strlen()}).
+
+    \item[(d)]
+      \textbf{Was bewirken die beiden Funktionen?}
+
+      Beide addieren die Zahlenwerte der im String enthaltenen Zeichen
+      und geben die Summe als Funktionsergebnis zurück.
+
+      Im Falle des Test-Strings \lstinline{"Hello, world!\n"}
+      lautet der Rückgabewert 1171 (siehe \gitfile{hp}{2022ws/20221107}{loesung-2d-1.c} und \gitfile{hp}{2022ws/20221107}{loesung-2d-2.c}).
+
+    \item[(e)]
+%      \textbf{Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
+%      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
+%      Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.}
+%
+%      Vorüberlegung: \lstinline{strlen()} greift in einer Schleife
+%      auf alle Zeichen des Strings der Länge $n$ zu,
+%      hat also $\mathcal{O}(n)$.
+%
+%      \lstinline{fun_1()} ruft in jedem Schleifendurchlauf
+%      (zum Prüfen der \lstinline{while}-Bedingung) einmal \lstinline{strlen()} auf
+%      und greift anschließend auf ein Zeichen des Strings zu,
+%      hat also $\mathcal{O}\bigl(n\cdot(n+1)\bigr) = \mathcal{O}(n^2)$.
+%
+%      \lstinline{fun_2()} ruft einmalig \lstinline{strlen()} auf
+%      und greift anschließend in einer Schleife auf alle Zeichen des Strings zu,
+%      hat also $\mathcal{O}(n+n) = \mathcal{O}(n)$.
+%
+%    \item[(f)]
+      \textbf{Schreiben Sie eine eigene Funktion,
+      die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},
+      nur effizienter.}
+
+      Die Funktion wird effizienter,
+      wenn man auf den Aufruf von \lstinline{strlen()} verzichtet
+      und stattdessen die Ende-Prüfung in derselben Schleife vornimmt,
+      in der man auch die Zahlenwerte der Zeichen des Strings aufsummiert.
+
+      Die Funktion \lstinline{fun_3()} in der Datei \gitfile{hp}{2022ws/20221107}{loesung-2e-1.c}
+      realisiert dies mit einem Array-Index,
+      Die Funktion \lstinline{fun_4()} in der Datei \gitfile{hp}{2022ws/20221107}{loesung-2e-2.c}
+      mit Zeiger-Arithmetik.
+      Beide Lösungen sind korrekt und arbeiten gleich schnell.
+
+%      \textbf{Bemerkung:} Die effizientere Version der Funktion
+%      arbeitet doppelt so schnell wie die ursprüngliche,
+%      hat aber ebenfalls die Ordnung $\mathcal{O}(n)$.
+
+  \end{itemize}
+
+  \exercise{LED-Blinkmuster}
+
+  Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
+  (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-3.c}).
+
+  \begin{minipage}[t]{7cm}
+    \begin{lstlisting}[gobble=6]
+      #include <stdint.h>
+      #include <avr/io.h>
+      #include <avr/interrupt.h>
+
+      uint8_t counter = 1;
+      uint8_t leds = 0;
+
+      ISR (TIMER0_COMP_vect)
+      {
+        if (counter == 0)
+          {
+            leds = (leds + 1) % 8;
+            PORTC = leds << 4;
+          }
+        counter++;
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill\begin{minipage}[t]{8.5cm}
+    \begin{lstlisting}[gobble=6]
+      void init (void)
+      {
+        cli ();
+        TCCR0 = (1 << CS01) | (1 << CS00);
+        TIMSK = 1 << OCIE0;
+        sei ();
+        DDRC = 0x70;
+      }
+
+      int main (void)
+      {
+        init ();
+        while (1)
+          ; /* do nothing */
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}
+
+  An die Bits Nr.\ 4, 5 und 6 des Output-Ports C des Mikro-Controllers sind LEDs angeschlossen.\\
+  Sobald das Programm läuft, blinken diese in charakteristischer Weise:
+  \begin{quote}
+    \newcommand{\tdn}[1]{\raisebox{-2pt}{#1}}
+    \begin{tabular}{|c|c|c|c|}\hline
+      \tdn{Phase} & \tdn{LED oben (rot)} & \tdn{LED Mitte (gelb)} & \tdn{LED unten (grün)} \\[2pt]\hline
+      1 & aus & aus & an  \\\hline
+      2 & aus & an  & aus \\\hline
+      3 & aus & an  & an  \\\hline
+      4 & an  & aus & aus \\\hline
+      5 & an  & aus & an  \\\hline
+      6 & an  & an  & aus \\\hline
+      7 & an  & an  & an  \\\hline
+      8 & aus & aus & aus \\\hline
+    \end{tabular}
+  \end{quote}
+  Jede Phase dauert etwas länger als eine halbe Sekunde.
+  Nach 8 Phasen wiederholt sich das Schema.
+
+  Erklären Sie das Verhalten des Programms anhand des Quelltextes:
+  \vspace{-\medskipamount}
+  \begin{itemize}\itemsep0pt
+    \item[(a)]
+      Wieso macht das Programm überhaupt etwas,
+      wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
+      in der \emph{nichts} passiert?
+      \points{1}
+    \item[(b)]
+      Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
+      wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
+      wobei die Variable \lstinline|counter| auf 1 initialisiert,
+      fortwährend erhöht und nirgendwo zurückgesetzt wird?
+      \points{2}
+    \item[(c)]
+      Wie kommt das oben beschriebene Blinkmuster zustande?
+      \points{2}
+    \item[(d)]
+      Wieso dauert eine Phase ungefähr eine halbe Sekunde?
+      \points{2}
+    \item[(e)]
+      Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?
+      \points{1}
+  \end{itemize}
+
+  \goodbreak
+  Hinweis:
+  \vspace{-\medskipamount}
+  \begin{itemize}\itemsep0pt
+    \item
+      Die Funktion \lstinline|init()| sorgt dafür, daß der Timer-Interrupt Nr.\ 0 des Mikro-Controllers
+      etwa 488mal pro Sekunde aufgerufen wird.
+      Außerdem initialisiert sie die benötigten Bits an Port C als Output-Ports.
+      Sie selbst brauchen die Funktion \lstinline|init()| nicht weiter zu erklären.
+  \end{itemize}
+
+  \solution
+
+  \begin{itemize}\itemsep0pt
+    \item[(a)]
+      \textbf{Wieso macht das Programm überhaupt etwas,
+      wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
+      in der \emph{nichts} passiert?}
+
+      Das Blinken wird durch einen Interrupt-Handler implementiert.
+      Dieser wird nicht durch das Hauptprogramm,
+      sondern durch ein Hardware-Ereignis (hier: Uhr) aufgerufen.
+
+    \item[(b)]
+      \textbf{Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
+      wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
+      wobei die Variable \lstinline|counter| auf 1 initialisiert,
+      fortwährend erhöht und nirgendwo zurückgesetzt wird?}
+
+      Die vorzeichenlose 8-Bit-Variable \lstinline{counter} kann nur
+      Werte von 0 bis 255 annehmen; bei einem weiteren
+      Inkrementieren springt sie wieder auf 0 (Überlauf),
+      und die \lstinline{if}-Bedingung ist erfüllt.
+
+    \item[(c)]
+      \textbf{Wie kommt das oben beschriebene Blinkmuster zustande?}
+
+      In jedem Aufruf des Interrupt-Handlers wird die Variable
+      \lstinline{leds} um 1 erhöht und anschließend modulo 8 genommen.
+      Sie durchläuft daher immer wieder die Zahlen von 0 bis 7.
+
+      Durch die Schiebeoperation \lstinline{leds << 4} werden die 3 Bits 
+      der Variablen \lstinline{leds} an diejenigen Stellen im Byte
+      geschoben, an denen die LEDs an den Mikro-Controller
+      angeschlossen sind (Bits 4, 5 und 6).
+
+      Entsprechend durchläuft das Blinkmuster immer wieder
+      die Binärdarstellungen der Zahlen von 0 bis 7
+      (genauer: von 1 bis 7 und danach 0).
+
+    \item[(d)]
+      \textbf{Wieso dauert eine Phase ungefähr eine halbe Sekunde?}
+
+      Der Interrupt-Handler wird gemäß Hinweis 488mal pro Sekunde aufgerufen.
+      Bei jedem 256sten Aufruf ändert sich das LED-Muster.
+      Eine Phase dauert somit $\frac{256}{488} \approx 0.52$ Sekunden.
+
+    \item[(e)]
+      \textbf{Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?}
+
+      Deklaration eines Interrupt-Handlers für den Timer-Interrupt Nr.\ 0
+  \end{itemize}
+
+\end{document}

20221107/hp-uebung-20221107.tex

+% hp-uebung-20221107.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Ausgabe von Hexadezimalzahlen, Länge von Strings, LED-Blinkmuster
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+  \thispagestyle{empty}
+
+  \section*{Hardwarenahe Programmierung\\
+            Übungsaufgaben -- 7.\ November 2022}
+
+  Diese Übung enthält Punkteangaben wie in einer Klausur.
+  Um zu "`bestehen"', müssen Sie innerhalb von 80 Minuten
+  unter Verwendung ausschließlich zugelassener Hilfsmittel
+  14 Punkte (von insgesamt \totalpoints) erreichen.
+
+  \exercise{Ausgabe von Hexadezimalzahlen}
+
+  Schreiben Sie eine Funktion \lstinline{void print_hex (uint32_t x)},
+  die eine gegebene vorzeichenlose 32-Bit-Ganzzahl \lstinline{x}
+  als Hexadezimalzahl ausgibt.
+  (Der Datentyp \lstinline{uint32_t} ist mit \lstinline{#include <stdint.h>} verfügbar.)
+
+  Verwenden Sie dafür \emph{nicht\/} \lstinline{printf()} mit
+  der Formatspezifikation \lstinline{%x} als fertige Lösung,
+  sondern programmieren Sie die nötige Ausgabe selbst.
+  (Für Tests ist \lstinline{%x} hingegen erlaubt und sicherlich nützlich.)
+
+  Die Verwendung von \lstinline{printf()}
+  mit anderen Formatspezifikationen wie z.\,B.\ \lstinline{%d}
+  oder \lstinline{%c} oder \lstinline{%s} ist hingegen zulässig.
+
+  \points{8}
+
+  (Hinweis für die Klausur: Abgabe auf Datenträger ist erlaubt und erwünscht,
+  aber nicht zwingend.)
+
+  \exercise{Länge von Strings}
+
+  Strings werden in der Programmiersprache C durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+  Beispiel: \lstinline{char *hello_world = "Hello, world!\n"}
+
+  Die Systembibliothek stellt eine Funktion \lstinline{strlen()} zur Ermittlung der Länge von Strings\\
+  zur Verfügung (\lstinline{#include <string.h>}).
+
+  \begin{itemize}
+    \item[(a)]
+      Auf welche Weise ist die Länge eines Strings gekennzeichnet?
+      \points{1}
+    \item[(b)]
+      Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
+      und wieviel Speicherplatz belegt sie?\\
+      \points{2}
+    \item[(c)]
+      Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
+      die die Länge eines Strings zurückgibt.\\
+      \points{3}
+  \end{itemize}
+
+  Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-2.c}):
+  \begin{center}
+    \begin{minipage}{8cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_1 (char *s)
+        {
+          int x = 0;
+          for (int i = 0; i < strlen (s); i++)
+            x += s[i];
+          return x;
+        }
+      \end{lstlisting}
+    \end{minipage}%
+    \begin{minipage}{6cm}
+      \vspace*{-1cm}
+      \begin{lstlisting}[gobble=8]
+        int fun_2 (char *s)
+        {
+          int i = 0, x = 0;
+          int len = strlen (s);
+          while (i < len)
+            x += s[i++];
+          return x;
+        }
+      \end{lstlisting}
+      \vspace*{-1cm}
+    \end{minipage}
+  \end{center}
+  \begin{itemize}
+    \item[(d)]
+      Was bewirken die beiden Funktionen?
+      \points{2}
+    \item[(e)]
+%      Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
+%      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String -- und warum?
+%      Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
+%       \points 3
+%    \item[(f)]
+      Schreiben Sie eine eigene Funktion,
+      die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
+      nur effizienter.
+      \points{4}
+  \end{itemize}
+
+  \exercise{LED-Blinkmuster}
+
+  Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
+  (Datei: \gitfile{hp}{2022ws/20221107}{aufgabe-3.c}).
+
+  \begin{minipage}[t]{7cm}
+    \begin{lstlisting}[gobble=6]
+      #include <stdint.h>
+      #include <avr/io.h>
+      #include <avr/interrupt.h>
+
+      uint8_t counter = 1;
+      uint8_t leds = 0;
+
+      ISR (TIMER0_COMP_vect)
+      {
+        if (counter == 0)
+          {
+            leds = (leds + 1) % 8;
+            PORTC = leds << 4;
+          }
+        counter++;
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill\begin{minipage}[t]{8.5cm}
+    \begin{lstlisting}[gobble=6]
+      void init (void)
+      {
+        cli ();
+        TCCR0 = (1 << CS01) | (1 << CS00);
+        TIMSK = 1 << OCIE0;
+        sei ();
+        DDRC = 0x70;
+      }
+
+      int main (void)
+      {
+        init ();
+        while (1)
+          ; /* do nothing */
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}
+
+  An die Bits Nr.\ 4, 5 und 6 des Output-Ports C des Mikro-Controllers sind LEDs angeschlossen.\\
+  Sobald das Programm läuft, blinken diese in charakteristischer Weise:
+  \begin{quote}
+    \newcommand{\tdn}[1]{\raisebox{-2pt}{#1}}
+    \begin{tabular}{|c|c|c|c|}\hline
+      \tdn{Phase} & \tdn{LED oben (rot)} & \tdn{LED Mitte (gelb)} & \tdn{LED unten (grün)} \\[2pt]\hline
+      1 & aus & aus & an  \\\hline
+      2 & aus & an  & aus \\\hline
+      3 & aus & an  & an  \\\hline
+      4 & an  & aus & aus \\\hline
+      5 & an  & aus & an  \\\hline
+      6 & an  & an  & aus \\\hline
+      7 & an  & an  & an  \\\hline
+      8 & aus & aus & aus \\\hline
+    \end{tabular}
+  \end{quote}
+  Jede Phase dauert etwas länger als eine halbe Sekunde.
+  Nach 8 Phasen wiederholt sich das Schema.
+
+  Erklären Sie das Verhalten des Programms anhand des Quelltextes:
+  \vspace{-\medskipamount}
+  \begin{enumerate}[\quad(a)]
+    \item
+      Wieso macht das Programm überhaupt etwas,
+      wenn doch das Hauptprogramm nach dem Initialisieren lediglich eine Endlosschleife ausführt,
+      in der \emph{nichts} passiert?
+      \points{1}
+    \item
+      Wieso wird die Zeile \lstinline|PORTC = leds << 4;| überhaupt aufgerufen,
+      wenn dies doch nur unter der Bedingung \lstinline|counter == 0| passiert,
+      wobei die Variable \lstinline|counter| auf 1 initialisiert,
+      fortwährend erhöht und nirgendwo zurückgesetzt wird?
+      \points{2}
+    \item
+      Wie kommt das oben beschriebene Blinkmuster zustande?
+      \points{2}
+    \item
+      Wieso dauert eine Phase ungefähr eine halbe Sekunde?
+      \points{2}
+    \item
+      Was bedeutet "`\lstinline|ISR (TIMER0_COMP_vect)|"'?
+      \points{1}
+  \end{enumerate}
+
+  Hinweis:
+  \vspace{-\medskipamount}
+  \begin{itemize}\itemsep0pt
+    \item
+      Die Funktion \lstinline|init()| sorgt dafür, daß der Timer-Interrupt Nr.\ 0 des Mikro-Controllers
+      etwa 488mal pro Sekunde aufgerufen wird.
+      Außerdem initialisiert sie die benötigten Bits an Port C als Output-Ports.
+      Sie selbst brauchen die Funktion \lstinline|init()| nicht weiter zu erklären.
+  \end{itemize}
+
+  \begin{flushright}
+    \textit{Viel Erfolg!}
+  \end{flushright}
+
+  \makeatletter
+    \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
+  \makeatother
+
+\end{document}

20221107/io-ports-and-interrupts.pdf

+../common/io-ports-and-interrupts.pdf
\ No newline at end of file

20221107/loesung-1-1.c

+#include <stdio.h>
+#include <stdint.h>
+
+void print_hex (uint32_t x)
+{
+  while (x)
+    {
+      int digit = x % 16;
+      if (digit < 10)
+        printf ("%d", digit);
+      else
+        printf ("%c", 'a' + digit - 10);
+      x /= 16;
+    }
+}
+
+int main (void)
+{
+  print_hex (0xcafe42);
+  printf ("\n");
+  return 0;
+}

20221107/loesung-1-2.c

+#include <stdio.h>
+#include <stdint.h>
+
+void print_hex (uint32_t x)
+{
+  char digit[8];
+  for (int i = 0; i < 8; i++)
+    {
+      digit[i] = x % 16;
+      x /= 16;
+    }
+  for (int i = 7; i >= 0; i--)
+    {
+      if (digit[i] < 10)
+        printf ("%d", digit[i]);
+      else
+        printf ("%c", 'a' + digit[i] - 10);
+    }
+}
+
+int main (void)
+{
+  print_hex (0xcafe42);
+  printf ("\n");
+  return 0;
+}

20221107/loesung-1-3.c

+#include <stdio.h>
+#include <stdint.h>
+
+void print_hex (uint32_t x)
+{
+  char digit[8];
+  int i = 0;
+  while (x)
+    {
+      digit[i] = x % 16;
+      x /= 16;
+      i++;
+    }
+  while (i > 0)
+    {
+      i--;
+      if (digit[i] < 10)
+        printf ("%d", digit[i]);
+      else
+        printf ("%c", 'a' + digit[i] - 10);
+    }
+}
+
+int main (void)
+{
+  print_hex (0xcafe42);
+  printf ("\n");
+  return 0;
+}