Vorbereitung 14.1.2021

20210114/Tower_of_Hanoi.jpeg

+../common/Tower_of_Hanoi.jpeg
\ No newline at end of file

20210114/aufgabe-2.c

+#include <avr/io.h>
+
+int main (void)
+{
+  DDRA = 0xff;
+  DDRB = 0xff;
+  DDRC = 0xff;
+  DDRD = 0xff;
+  PORTA = 0x1f;
+  PORTB = 0x10;
+  PORTD = 0x10;
+  PORTC = 0xfc;
+  while (1);
+  return 0;
+}

20210114/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;
+}

20210114/hp-2020ws-p3.tex

+% hp-2020ws-p3.pdf - Labor Notes on Low-Level Programming
+% Copyright (C) 2014, 2015, 2016, 2017, 2018, 2019, 2021  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: Versuch 3: Druckknopfampel
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+\usepackage{multicol}
+\usepackage{amsmath}
+\usepackage{sfmath}
+
+\sloppy
+\raggedcolumns
+\pagestyle{empty}
+\addtolength{\textheight}{1cm}
+\newcommand{\sep}{~$\cdot$~}
+\newcommand{\mylicense}{CC BY-SA (Version 4.0) oder GNU GPL (Version 3 oder höher)}
+
+\begin{document}
+
+  \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill
+  \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}}
+  \par\bigskip\bigskip
+  \begin{center}
+    \Large\textbf{Praktikumsversuch 2: Druckknopfampel}
+    \par\medskip
+    \normalsize Hardwarenahe Programmierung\sep
+    Wintersemester 2020/21\sep
+    Prof.~Dr.~Peter Gerwinski
+  \end{center}
+
+  Aufgabe: Programmieren Sie in C einen Mikrocontroller so,
+  daß er eine Druckknopfampel steuern kann.
+
+  \begin{multicols}{2}
+
+    \begin{itemize}
+      \item
+        Normalerweise zeigt eine Druckknopfampel rotes Licht für die
+        Fußgänger und grünes Licht für die Straße.
+      \item
+        Nach Knopfdruck wechselt die Straße über Gelb nach Rot.
+        Danach bekommen die Fußgänger Grün.
+        Nach einer gewissen Zeit bekommen die Fußgänger wieder Rot,
+        und die Straße wechselt über Rot-Gelb wieder zu Grün.
+
+      \medskip
+      \item
+        Als Mikrocontroller-Entwicklungsplattform eignet sich u.\,a.\
+        ein \emph{Arduino Uno\/}. \textbf{Wenn Sie keinen Zugang zu einer
+        geeigneten Mi\-kro\-con\-trol\-ler-Ent\-wick\-lungs\-platt\-form haben,
+        sprechen Sie uns an.}
+      \item
+        Software-Entwiklung für den Arduino geschieht üblicherweise
+        mit Hilfe der Entwicklungswerkzeuge \emph{GCC, binutils und
+        glibc für AVR} sowie \emph{avrdude\/} für das Herunterladen
+        des geschriebenen Programms vom PC auf den Mikrocontroller.
+
+        Die Arduino-Entwicklungsumgebung (siehe z.\,B.\
+        \url{https://www.arduino.cc/en/Main/Software}) integriert
+        alle diese Komponenten.
+      \item
+        Wir schreiben unser Programm \textbf{in C und nicht in der INO-Sprache}.
+        Wenn die Quelltext-Dateien in der Arduino-Entwicklungsumgebung
+        die Endung \file{.ino} haben, ist das kein Problem,
+        sofern der Inhalt der Datei in C geschrieben ist.
+      \item
+        Den Schaltplan des Arduino Uno sowie das Datenblatt des
+        ATmega328p finden Sie per Web-Recherche.
+
+      \columnbreak
+
+      \item
+        Sie können Ihr Programm direkt aus der Arduino-Entwicklungsumgebung heraus
+        compilieren und auf den Mikrocontroller herunterladen.
+        Wenn Sie dies von der Kommandozeile aus machen möchten,
+        geht dies folgendermaßen:
+
+        \lstinline[style=cmd]{avr-gcc -Wall -Os -mmcu=atmega328p \}\\
+        \lstinline[style=cmd]{dateiname.c -o dateiname.elf}
+
+        \lstinline[style=cmd]{avr-objcopy -O ihex \}\\
+        \lstinline[style=cmd]{dateiname-4.elf dateiname-4.hex}
+
+        \lstinline[style=cmd]{avrdude -P /dev/ttyACM0 -c arduino \}\\
+        \lstinline[style=cmd]{-p m328p -U flash:w:dateiname.hex}
+
+        Bei Zugriffsproblemen auf die Schnittstelle
+        (hier: \lstinline[style=terminal]{/dev/ttyACM0}) fügen Sie Ihr
+        Benutzerkonto der entsprechenden Gruppe hinzu (normalerweise:
+        \lstinline[style=terminal]{dialout}).
+
+        Notfalls: \lstinline[style=cmd]{sudo chmod 666 /dev/ttyACM0}
+
+      \medskip
+      \item
+        Die Verdrahtung erfolgt üblicherweise auf einer Steckplatine
+        -- siehe Abb.~\ref{Steckplatine}.
+        Die mit roten und blauen Streifen markierten Lochreihen sind
+        in Längsrichtung elektrisch verbunden, alle anderen in
+        Querrichtung mit einer Trennung in der Mitte. Üblicherweise
+        verwendet man die Längsrichtung für die Stromversorgung: Rot
+        = Versorgungsspannung, Blau = 0\,V.
+      \item
+        LEDs sind keine Glühlampen! Sie haben einen Pluspol (länger)
+        und einen Minuspol (kürzer, Gehäuse abgeflacht), und sie dürfen
+        \textbf{nur mit Vorwiderstand} betrieben werden,
+        andernfalls besteht die Gefahr einer Zerstörung der LED
+        und/oder des Arduino.
+      \item
+        Anstelle eines Drucktasters kann man auch ein Stück Draht verwenden.
+      \item
+        \textbf{Abgabe:}
+        Ihre Quelltexte mit den Lösungen der Praktikumsaufgabe schicken Sie bitte
+        per E-Mail an \file{peter.gerwinski@hs-bochum.de}
+        mit dem \textbf{Betreff:} \lstinline[style=terminal]{PaoJ6nae}
+        unter Angabe von Name, Matrikel-Nummer,
+        Studiengang (MI/MP/TI) und Studienmodell (KIA/KIS/GS).
+
+    \end{itemize}
+
+    \vspace*{-\medskipamount}
+
+    \strut\hfill\emph{Viel Erfolg!}\\[-3.5cm]
+
+  \end{multicols}
+
+  \vspace*{-5\bigskipamount}
+
+  \begin{figure}[h]
+    \begin{minipage}{7.3cm}
+      \includegraphics[width=8cm]{400_points_breadboard.jpg}
+      \vspace*{-1cm}
+      \caption{Steckplatine\label{Steckplatine}\hspace*{1.2cm}}
+      \vspace*{1cm}
+    \end{minipage}%
+    \begin{picture}(0,0)
+      \put(-1.6,0.0){\makebox(0,0)[tl]{%
+        \begin{minipage}{9cm}
+          \small\raggedright
+          \vspace*{1cm}
+          Bildquelle:
+          \href{https://commons.wikimedia.org/wiki/File:400_points_breadboard.jpg}%
+               {\nolinkurl{https://commons.wikimedia.org/}\\
+                \nolinkurl{wiki/File:400_points_breadboard.jpg}}\\
+          Autor: \url{https://www.flickr.com/people/33504192@N00}\\
+          Lizenz: CC-BY-SA 2.0 Generic
+        \end{minipage}}}
+    \end{picture}
+  \end{figure}
+
+  \vspace*{-1.5\bigskipamount}
+
+  \vfill
+
+  \begingroup
+
+    \small
+
+    \setlength{\leftskip}{3cm}
+
+    Stand: 14.\ Januar 2021
+
+%    Soweit nicht anders angegeben:\\
+    Copyright \copyright\ 2014, 2015, 2016, 2017, 2018, 2019, 2021\quad Peter Gerwinski\\
+    Lizenz: \mylicense
+
+    Sie können diese Praktikumsunterlagen einschließlich \LaTeX-Quelltext
+%    und Beispielprogramme\\
+    herunterladen unter:\\
+    \url{https://gitlab.cvh-server.de/pgerwinski/hp}
+
+  \endgroup
+
+\end{document}

20210114/hp-musterloesung-20210114.tex

+% hp-musterloesung-20210107.pdf - Solutions to the Exercises on Low-Level Programming
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021  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: Fakultät, Länge von Strings (Neuauflage), Hexdumps
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+\usepackage{gnuplot-lua-tikz}
+
+\begin{document}
+
+  \section*{Hardwarenahe Programmierung\\
+            Musterlösung zu den Übungsaufgaben -- 7.\ Januar 2021}
+
+  \exercise{Fakultät}
+
+  Die Fakultät $n!$ einer ganzen Zahl $n \ge 0$ ist definiert als:
+  \begin{eqnarray*}
+    1 & \mbox{für} & n = 0, \\
+    n \cdot (n-1)! & \mbox{für} & n > 0.
+  \end{eqnarray*}
+
+  Mit anderen Worten: $n! = 1\cdot2\cdot3\cdot\dots\cdot n$.
+
+  Die folgende Funktion \lstinline{fak()} berechnet die Fakultät \emph{rekursiv}
+  (Datei: \gitfile{hp}{2020ws/20210107}{aufgabe-1.c}):
+
+  \begin{lstlisting}
+    int fak (int n)
+    {
+      if (n <= 0)
+        return 1;
+      else
+        return n * fak (n - 1);
+    }
+  \end{lstlisting}
+
+  \begin{enumerate}[\quad(a)]
+    \item
+      Schreiben Sie eine Funktion, die die Fakultät \emph{iterativ} berechnet,\\
+      d.\,h.\ mit Hilfe einer Schleife anstelle von Rekursion.
+      \points{3}
+    \item
+      Wie viele Multiplikationen (Landau-Symbol)
+      erfordern beide Versionen der Fakultätsfunktion\\
+      in Abhängigkeit von \lstinline$n$?
+      Begründen Sie Ihre Antwort.
+      \points{2}
+    \item
+      Wieviel Speicherplatz (Landau-Symbol)
+      erfordern beide Versionen der Fakultätsfunktion\\
+      in Abhängigkeit von \lstinline$n$?
+      Begründen Sie Ihre Antwort.
+      \points{3}
+  \end{enumerate}
+
+  \solution
+
+  \begin{itemize}
+    \item[(a)]
+      \textbf{Schreiben Sie eine Funktion, die die Fakultät \emph{iterativ} berechnet,\\
+      d.\,h.\ mit Hilfe einer Schleife anstelle von Rekursion.}
+
+      Datei: \gitfile{hp}{2020ws/20210107}{loesung-1.c}
+      \begin{lstlisting}[gobble=8]
+        int fak (int n)
+        {
+          int f = 1;
+          for (int i = 2; i <= n; i++)
+            f *= i;
+          return f;
+        }
+      \end{lstlisting}
+
+    \item[(b)]
+      \textbf{Wie viele Multiplikationen (Landau-Symbol)
+      erfordern beide Versionen der Fakultätsfunktion\\
+      in Abhängigkeit von \lstinline$n$?
+      Begründen Sie Ihre Antwort.}
+
+      In beiden Fällen werden $n$ Zahlen miteinander multipliziert --
+      oder $n - 1$, wenn man Multiplikationen mit 1 ausspart.
+      In jedem Fall hängt die Anzahl der Multiplikationen
+      linear von $n$ ab; es sind $\mathcal{O}(n)$ Multiplikationen.
+      Insbesondere arbeiten also beide Versionen gleich schnell.
+
+    \item[(c)]
+      \textbf{Wieviel Speicherplatz (Landau-Symbol)
+      erfordern beide Versionen der Fakultätsfunktion\\
+      in Abhängigkeit von \lstinline$n$?
+      Begründen Sie Ihre Antwort.}
+
+      Die iterative Version der Funktion benötigt 2 Variable vom Typ \lstinline{int},
+      nämlich \lstinline{n} und \lstinline{f}.
+      Dies ist eine konstante Zahl;
+      der Speicherplatzverbrauch ist daher $\mathcal{O}(1)$.
+
+      Die rekursive Version der Funktion erzeugt
+      jedesmal, wenn sie sich selbst aufruft,
+      eine zusätzliche Variable \lstinline{n}.
+      Es sind $n + 1$ Aufrufe; die Anzahl der Variablen \lstinline{n}
+      hängt linear von $n$ ab; der Speicherplatzverbrauch ist also $\mathcal{O}(n)$.
+  \end{itemize}
+
+  \exercise{Länge von Strings}
+
+  Diese Aufgabe ist eine Neuauflage von Aufgabe 3 der
+  Übung vom 14.\ November 2019,\\
+  ergänzt um die Teilaufgaben (f) und (g).
+
+  \medskip
+
+  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{enumerate}[\quad(a)]
+    \item
+      Auf welche Weise ist die Länge eines Strings gekennzeichnet?
+      \points{1}
+    \item
+      Wie lang ist die Beispiel-String-Konstante \lstinline{"Hello, world!\n"},
+      und wieviel Speicherplatz belegt sie?\\
+      \points{2}
+    \item
+      Schreiben Sie eine eigene Funktion \lstinline{int strlen (char *s)},
+      die die Länge eines Strings zurückgibt.\\
+      \points{3}
+  \end{enumerate}
+
+  \goodbreak
+
+  Wir betrachten nun die folgenden Funktionen (Datei: \gitfile{hp}{2020ws/20210107}{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{enumerate}[\quad(a)]\setcounter{enumi}{3}
+    \item
+      Was bewirken die beiden Funktionen?
+      \points{2}
+    \item
+      Schreiben Sie eine eigene Funktion,
+      die dieselbe Aufgabe erledigt wie \lstinline{fun_2()},\\
+      nur effizienter.
+      \points{4}
+    \item
+      Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
+      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String?
+      Begründen Sie Ihre Antwort.
+      Sie dürfen für \lstinline{strlen()} Ihre eigene Version der Funktion voraussetzen.
+       \points{3}
+    \item
+      Von welcher Ordnung (Landau-Symbol) ist Ihre effizientere Funktion?\\
+      Begründen Sie Ihre Antwort.
+      \points{1}
+  \end{enumerate}
+
+  \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}{2020ws/20210107}{loesung-2c-1.c} (mit Array-Index)
+      und \gitfile{hp}{2020ws/20210107}{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}{2020ws/20210107}{loesung-2d-1.c} und \gitfile{hp}{2020ws/20210107}{loesung-2d-2.c}).
+
+    \item[(e)]
+      \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}{2020ws/20210107}{loesung-2e-1.c}
+      realisiert dies mit einem Array-Index,
+      Die Funktion \lstinline{fun_4()} in der Datei \gitfile{hp}{2020ws/20210107}{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)$ -- siehe unten.
+
+    \item[(f)]
+      \textbf{Von welcher Ordnung (Landau-Symbol) sind die beiden Funktionen
+      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen im String?
+      Begründen Sie Ihre Antwort.
+      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[(g)]
+      \textbf{Von welcher Ordnung (Landau-Symbol) ist Ihre effizientere Funktion?\\
+      Begründen Sie Ihre Antwort.}
+
+      In beiden o.\,a.\ Lösungsvarianten
+      -- \gitfile{hp}{2020ws/20210107}{loesung-2e-1.c}
+      und \gitfile{hp}{2020ws/20210107}{loesung-2e-2.c} --
+      arbeitet die Funktion mit einer einzigen Schleife,
+      die gleichzeitig die Zahlenwerte addiert und das Ende des Strings sucht.
+
+      Mit jeweils einer einzigen Schleife
+      haben beide Funktionen die Ordnung $\mathcal{O}(n)$.
+
+  \end{itemize}
+
+  \exercise{Hexdumps}
+
+  Das folgende Programm (\gitfile{hp}{2020ws/20210107}{aufgabe-2.c}) liest
+  einen String ein und gibt die ASCII-Werte der Buchstaben hexadezimal aus.
+  (Anders als z.\,B.\ \lstinline{scanf()}
+  akzeptiert die Funktion \lstinline{fgets()} zum Lesen von Strings auch Leerzeichen,
+  und sie vermeidet Pufferüberläufe.)
+  \begin{lstlisting}[style=numbered]
+    #include <stdio.h>
+
+    int main (void)
+    {
+      char buffer[100];
+      fgets (buffer, 100, stdin);
+      for (char *p = buffer; *p; p++)
+        printf ("%02x", *p);
+      printf ("\n");
+    }
+  \end{lstlisting}
+  Beispiel: Bei der Eingabe von \lstinline[style=cmd]{Dies ist ein Test.}
+  erscheint die Ausgabe\\
+  \lstinline[style=terminal]{44696573206973742065696e20546573742e0a}.
+
+  Schreiben Sie ein Programm, das diese Umwandlung in umgekehrter Richtung vornimmt,
+  also z.\,B.\ bei Eingabe von \lstinline[style=cmd]{44696573206973742065696e20546573742e0a}
+  wieder \lstinline[style=terminal]{Dies ist ein Test.} ausgibt.
+
+  \points{6}
+
+  Hinweis für die Klausur:
+  Abgabe in digitaler Form ist erwünscht, aber nicht zwingend.
+
+  \solution
+
+  Siehe \gitfile{hp}{2020ws/20210107}{loesung-2.c}.
+
+  Das Programm macht mehrfach davon Gebrauch,
+  daß in C Zeichen und Zahlen äquivalent sind.
+  Wenn z.\,B.\ die \lstinline{char}-Variable \lstinline{c}
+  den Wert \lstinline{'3'} (Ziffer 3) enthält,
+  dann hat der Ausdruck \lstinline{c - '0'} den Wert \lstinline{3} (Zahlenwert 3).
+  Hierfür ist es insbesondere nicht nötig, vorauszusetzen,
+  daß wir den ASCII-Zeichensatz verwenden und \lstinline{'0'}
+  den Wert \lstinline{48} hat.
+
+  Bei Eingabe von \lstinline[style=cmd]{44696573206973742065696e20546573742e0a}
+  gibt das Programm zusätzlich eine Leerzeile aus.
+  Die liegt daran, daß das \lstinline[style=cmd]{0a} am Ende
+  bereits eine Zeilenschaltung enthält und das Programm mit
+  \lstinline{printf ("\n")} eine zusätzliche Zeilenschaltung ausgibt.
+
+\end{document}

20210114/hp-uebung-20210114.tex

+% hp-uebung-20210114.pdf - Exercises on Low-Level Programming
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021  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: Zahlensysteme, Mikrocontroller, LED-Blinkmuster
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+%  \thispagestyle{empty}
+
+  \section*{Hardwarenahe Programmierung\\
+            Übungsaufgaben -- 14.\ Januar 2021}
+
+  Diese Übung enthält Punkteangaben wie in einer Klausur.
+  Um zu "`bestehen"', müssen Sie innerhalb von 85 Minuten
+  unter Verwendung ausschließlich zugelassener Hilfsmittel
+  17 Punkte (von insgesamt \totalpoints) erreichen.
+
+  \exercise{Zahlensysteme}
+
+  Wandeln Sie ohne Hilfsmittel
+
+  \begin{minipage}[t]{0.3\textwidth}
+    \begin{itemize}
+      \item
+        nach Dezimal:
+        \begin{itemize}
+          \item[(a)]
+            0010\,0000$_2$
+          \item[(b)]
+            42$_{16}$
+          \item[(c)]
+            17$_8$
+        \end{itemize}
+    \end{itemize}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.3\textwidth}
+    \begin{itemize}
+      \item
+        nach Hexadezimal:
+        \begin{itemize}
+          \item[(d)]
+            0010\,0000$_2$
+          \item[(e)]
+            42$_{10}$
+          \item[(f)]
+            192.168.20.254$_{256}$
+        \end{itemize}
+    \end{itemize}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.3\textwidth}
+    \begin{itemize}
+      \item
+        nach Binär:
+        \begin{itemize}
+          \item[(g)]
+            750$_8$
+          \item[(h)]
+            42$_{10}$
+          \item[(i)]
+            AFFE$_{16}$
+        \end{itemize}
+    \end{itemize}
+  \end{minipage}
+  
+  \medskip
+
+  Berechnen Sie ohne Hilfsmittel:
+  \begin{itemize}
+    \item[(j)]
+      750$_8$ \& 666$_8$
+    \item[(k)]
+      A380$_{16}$ + B747$_{16}$
+    \item[(l)]
+      AFFE$_{16} >> 1$
+  \end{itemize}
+
+  Die tiefgestellte Zahl steht für die Basis des Zahlensystems.
+  Jede Teilaufgabe zählt 1 Punkt. \addtocounter{points}{12}
+
+  (In der Klausur sind Hilfsmittel zugelassen,
+  daher ist dies \emph{keine\/} typische Klausuraufgabe.)
+
+  \exercise{Mikrocontroller}
+
+  \begin{minipage}[t]{10cm}
+    An die vier Ports eines ATmega16-Mikrocontrollers sind Leuchtdioden angeschlossen:
+    \begin{itemize}
+      \item
+        von links nach rechts an die Ports A, B, C und D,
+      \item
+        von oben nach unten an die Bits Nr.\ 0 bis 7.
+    \end{itemize}
+
+    Wir betrachten das folgende Programm (\gitfile{hp}{2019ws/20191121}{aufgabe-2.c}):
+
+    \begin{lstlisting}[gobble=6]
+      #include <avr/io.h>
+
+      int main (void)
+      {
+        DDRA = 0xff;
+        DDRB = 0xff;
+        DDRC = 0xff;
+        DDRD = 0xff;
+        PORTA = 0x1f;
+        PORTB = 0x10;
+        PORTD = 0x10;
+        PORTC = 0xfc;
+        while (1);
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3cm}
+    \strut\\[-\baselineskip]
+    \includegraphics[width=3cm]{leds.jpg}
+  \end{minipage}
+
+  \vspace*{-3cm}
+
+  \strut\hfill
+  \begin{minipage}{11.8cm}
+    \begin{itemize}
+      \item[(a)]
+        Was bewirkt dieses Programm? \points{4}
+      \item[(b)]
+        Wozu dienen die ersten vier Zeilen des Hauptprogramms? \points{2}
+      \item[(c)]
+        Was würde stattdessen die Zeile \lstinline{DDRA, DDRB, DDRC, DDRD = 0xff;} bewirken?
+        \points{2}
+      \item[(d)]
+        Schreiben Sie das Programm so um,
+        daß die durch das Programm dargestellte Figur spiegelverkehrt erscheint. \points{3}
+      \item[(e)]
+        Wozu dient das \lstinline{while (1)}? \points{2}
+      \item
+        Alle Antworten bitte mit Begründung.
+    \end{itemize}
+  \end{minipage}
+
+  \exercise{LED-Blinkmuster}
+
+  Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
+  (Datei: \gitfile{hp}{2019ws/20191128}{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}
+
+  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}

20210114/io-ports-and-interrupts.pdf

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

20210114/landau-symbols-2.pdf

+../common/landau-symbols-2.pdf
\ No newline at end of file

20210114/landau-symbols-3.pdf

+../common/landau-symbols-3.pdf
\ No newline at end of file

20210114/landau-symbols.pdf

+../common/landau-symbols.pdf
\ No newline at end of file

20210114/leds.jpg

+../common/leds.jpg
\ No newline at end of file

20210114/logo-hochschule-bochum-cvh-text-v2.pdf

+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file