diff --git a/20231109/Makefile b/20231109/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..7ae33df99f68fcf460324cfbb008f3f7a3863638
--- /dev/null
+++ b/20231109/Makefile
@@ -0,0 +1,8 @@
+%.elf: %.c
+ avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
+
+%.hex: %.elf
+ avr-objcopy -O ihex $< $@
+
+download:
+ ./download.sh
diff --git a/20231109/aufgabe-2.c b/20231109/aufgabe-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..1afa7b1260506cb307aff5f929c6357c7bdcb708
--- /dev/null
+++ b/20231109/aufgabe-2.c
@@ -0,0 +1,15 @@
+#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;
+}
diff --git a/20231109/aufgabe-3.c b/20231109/aufgabe-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..4c95eb6ad4881c904448309c6b7c46fa101cc109
--- /dev/null
+++ b/20231109/aufgabe-3.c
@@ -0,0 +1,33 @@
+#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;
+}
diff --git a/20231109/download.sh b/20231109/download.sh
new file mode 100755
index 0000000000000000000000000000000000000000..770c3b5dca74ac09778be055c9d6f5adb0df293b
--- /dev/null
+++ b/20231109/download.sh
@@ -0,0 +1,3 @@
+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
diff --git a/20231109/hp-20231109.pdf b/20231109/hp-20231109.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..28ee19101f939b3bcc19e9af5397b73ac1b924b1
Binary files /dev/null and b/20231109/hp-20231109.pdf differ
diff --git a/20231109/hp-20231109.tex b/20231109/hp-20231109.tex
new file mode 100644
index 0000000000000000000000000000000000000000..2d6afd3f993fa4686fa7f3e1994fac1aa689c9e5
--- /dev/null
+++ b/20231109/hp-20231109.tex
@@ -0,0 +1,1104 @@
+% hp-20231109.pdf - Lecture Slides on Low-Level Programming
+% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 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: Hardwarenahe Programmierung
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{pdftricks}
+\usepackage{tikz}
+
+\begin{psinputs}
+ \usepackage[utf8]{inputenc}
+ \usepackage[german]{babel}
+ \usepackage[T1]{fontenc}
+ \usepackage{helvet}
+ \renewcommand*\familydefault{\sfdefault}
+ \usepackage{pstricks,pst-grad}
+\end{psinputs}
+
+\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
+
+\title{Hardwarenahe Programmierung}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{9.\ November 2023}
+
+\begin{document}
+
+\maketitleframe
+
+\title{Hardwarenahe Programmierung}
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+ \shownosectionnonumber
+
+ \begin{itemize}
+ \item[\textbf{1}] \textbf{Einführung}
+ \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
+ \item[\textbf{2}] \textbf{Einführung in C}
+ \item[\textbf{3}] \textbf{Bibliotheken}
+ \begin{itemize}
+ \item[3.1] Der Präprozessor
+ \item[3.2] Bibliotheken einbinden
+ \item[3.3] Bibliotheken verwenden
+ \color{medgreen}
+ \item[3.4] Callbacks
+ \item[3.5] Projekt organisieren: make
+ \end{itemize}
+ \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+ \begin{itemize}
+ \color{orange}
+ \item[4.1] Bit-Operationen
+ \color{red}
+ \item[4.2] I/O-Ports
+ \item[4.3] Interrupts
+ \vspace*{-0.1cm}
+ \item[\dots]
+ \end{itemize}
+ \vspace*{-\smallskipamount}
+ \item[\textbf{\dots}]
+% \item[\textbf{5}] \textbf{Algorithmen}
+% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+ \end{itemize}
+
+\end{frame}
+
+\setcounter{section}{2}
+\section{Bibliotheken}
+\setcounter{subsection}{3}
+\subsection{Callbacks}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Selbst geschriebene Funktion übergeben: \newterm{Callback}
+
+ \bigskip
+
+ \begin{lstlisting}[xleftmargin=1em]
+ static void hello (GtkWidget *this, gpointer user_data)
+ {
+ char *world = user_data;
+ printf ("Hello, %s!\n", world);
+ }
+
+ ...
+
+ g_signal_connect (button, "clicked", G_CALLBACK (hello), "world");
+ \end{lstlisting}
+
+ \medskip
+
+ \begin{itemize}
+ \arrowitem
+ GTK ruft immer dann, wenn der Button betätigt wurde,\\
+ die Funktion \lstinline{hello} auf.
+ \end{itemize}
+
+% \pause
+ \begin{picture}(0,0)(1.1,0.8)
+ \color{red}
+ \put(9.7,5.1){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.3,0.5);}}}
+ \put(10.0,5.0){\makebox(0,0)[t]{\shortstack{\strut optionale Zusatzinformationen\\
+ \strut für hello(), hier ein String\\
+ \strut oft ein Zeiger auf ein struct}}}
+ \put(10.5,3.5){\makebox(0,0)[tl]{\tikz{\draw[-latex](0,0)--(0.3,-0.5);}}}
+ \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Selbst geschriebene Funktion übergeben: \newterm{Callback}
+
+ \bigskip
+
+ \begin{lstlisting}[xleftmargin=1em]
+ static void draw (GtkDrawingArea *drawing_area, cairo_t *c,
+ int width, int height, gpointer user_data)
+ {
+ /* Zeichenbefehle */
+ ...
+ }
+
+ ...
+
+ gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
+ draw, NULL, NULL);
+ \end{lstlisting}
+
+ \medskip
+
+ \begin{itemize}
+ \arrowitem
+ GTK ruft immer dann, wenn es etwas zu zeichnen gibt,\\
+ die Funktion \lstinline{draw} auf.
+ \end{itemize}
+
+% \pause
+ \begin{picture}(0,0)
+ \color{red}
+ \put(10.0,4.9){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.3,0.9);}}}
+ \put(10.0,4.8){\makebox(0,0)[t]{\shortstack{\strut repräsentiert den\\
+ \strut Bildschirm, auf den\\
+ \strut gezeichnet werden soll}}}
+ \end{picture}
+
+\end{frame}
+
+\iffalse
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Selbst geschriebene Funktion übergeben: \newterm{Callback}
+
+ \bigskip
+
+ \begin{lstlisting}[xleftmargin=1em]
+ gboolean timer (GtkWidget *widget)
+ {
+ /* Rechenbefehle */
+ ...
+
+ gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
+ g_timeout_add (50, (GSourceFunc) timer, widget);
+ return FALSE;
+ }
+
+ ...
+
+ g_timeout_add (50, (GSourceFunc) timer, drawing_area);
+ \end{lstlisting}
+
+ \medskip
+
+ \begin{itemize}
+ \arrowitem
+ GTK+ ruft nach 50 Millisekunden
+ die Funktion \lstinline{timer} auf.
+ \end{itemize}
+
+ \pause
+ \begin{picture}(0,0)(-0.07,0.2)
+ \color{red}
+ \put(9.7,6.7){\makebox(0,0)[t]{\shortstack{\strut Dieser Bereich soll\\
+ \strut neu gezeichnet werden.}}}
+ \put(9.7,5.7){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.8);}}}
+ \pause
+ \put(4.3,3.2){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-0.7,0.6);}}}
+ \put(4.3,3.1){\makebox(0,0)[t]{\shortstack{\strut In weiteren 50 Millisekunden soll\\
+ \strut die Funktion erneut aufgerufen werden.}}}
+ \pause
+ \put(9.3,2.9){\makebox(0,0)[br]{\tikz{\draw[-latex](0,0)--(-3.3,0.9);}}}
+ \put(9.8,2.8){\makebox(0,0)[t]{\shortstack{\strut Explizite Typumwandlung\\
+ \strut eines Zeigers (später)}}}
+ \end{picture}
+
+\end{frame}
+
+\fi
+
+\subsection{Projekt organisieren: make}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+ \begin{itemize}
+ \item
+ \only<4->{explizite und implizite} Regeln
+ \begin{onlyenv}<2>
+ \smallskip
+ \begin{lstlisting}[language=make,gobble=10]
+ philosophy: philosophy.o answer.o
+ gcc philosophy.o answer.o -o philosophy
+
+ answer.o: answer.c answer.h
+ gcc -Wall -O answer.c -c
+
+ philosophy.o: philosophy.c answer.h
+ gcc -Wall -O philosophy.c -c
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<4>
+ \smallskip
+ \begin{lstlisting}[language=make,gobble=10]
+ TARGET = philosophy
+ OBJECTS = philosophy.o answer.o
+ HEADERS = answer.h
+ CFLAGS = -Wall -O
+
+ $(TARGET): $(OBJECTS)
+ gcc $(OBJECTS) -o $(TARGET)
+
+ %.o: %.c $(HEADERS)
+ gcc $(CFLAGS) $< -c
+
+ clean:
+ rm -f $(OBJECTS) $(TARGET)
+ \end{lstlisting}
+ \end{onlyenv}
+ \item
+ Makros
+ \begin{onlyenv}<3>
+ \smallskip
+ \begin{lstlisting}[language=make,gobble=10]
+ TARGET = philosophy
+ OBJECTS = philosophy.o answer.o
+ HEADERS = answer.h
+ CFLAGS = -Wall -O
+
+ $(TARGET): $(OBJECTS)
+ gcc $(OBJECTS) -o $(TARGET)
+
+ answer.o: answer.c $(HEADERS)
+ gcc $(CFLAGS) answer.c -c
+
+ philosophy.o: philosophy.c $(HEADERS)
+ gcc $(CFLAGS) philosophy.c -c
+
+ clean:
+ rm -f $(OBJECTS) $(TARGET)
+ \end{lstlisting}
+ \vspace*{-1cm}
+ \end{onlyenv}
+ \begin{onlyenv}<5->
+ \smallskip
+ \arrowitem
+ 3 Sprachen: C, Präprozessor, make
+ \end{onlyenv}
+ \end{itemize}
+
+\end{frame}
+
+\section{Hardwarenahe Programmierung}
+\subsection{Bit-Operationen}
+\subsubsection{Zahlensysteme}
+
+\begin{frame}[fragile]
+
+ \showsection
+ \vspace*{-\smallskipamount}
+ \showsubsection
+ \vspace*{-\medskipamount}
+ \showsubsubsection
+
+ \begin{tabular}{rlrl}
+ Basis & Name & Beispiel & Anwendung \\[\smallskipamount]
+ 2 & Binärsystem & 1\,0000\,0011 & Bit-Operationen \\
+ 8 & Oktalsystem & \lstinline,0403, & Dateizugriffsrechte (Unix) \\
+ 10 & Dezimalsystem & \lstinline,259, & Alltag \\
+ 16 & Hexadezimalsystem & \lstinline,0x103, & Bit-Operationen \\
+ 256 & (keiner gebräuchlich) & 0.0.1.3 & IP-Adressen (IPv4)
+ \end{tabular}
+
+ \bigskip
+
+ \begin{itemize}
+ \item
+ Computer rechnen im Binärsystem.
+ \item
+ Für viele Anwendungen (z.\,B.\ I/O-Ports, Grafik, \dots) ist es notwendig,\\
+ Bits in Zahlen einzeln ansprechen zu können.
+ \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsubsection
+
+ \begin{tabular}{rlrlrc}
+ \qquad 000 & \bf 0 \hspace*{1.5cm} & 0000 & \bf 0 & \quad 1000 & \bf 8\\
+ 001 & \bf 1 & 0001 & \bf 1 & 1001 & \bf 9\\
+ 010 & \bf 2 & 0010 & \bf 2 & 1010 & \bf A\\
+ 011 & \bf 3 & 0011 & \bf 3 & 1011 & \bf B\\[\smallskipamount]
+ 100 & \bf 4 & 0100 & \bf 4 & 1100 & \bf C\\
+ 101 & \bf 5 & 0101 & \bf 5 & 1101 & \bf D\\
+ 110 & \bf 6 & 0110 & \bf 6 & 1110 & \bf E\\
+ 111 & \bf 7 & 0111 & \bf 7 & 1111 & \bf F\\
+ \end{tabular}
+
+ \medskip
+
+ \begin{itemize}
+ \item
+ Oktal- und Hexadezimalzahlen lassen sich ziffernweise\\
+ in Binär-Zahlen umrechnen.
+ \item
+ Hexadezimalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
+ gruppiert zu jeweils 4 Bits.
+ \item
+ Oktalzahlen sind eine Kurzschreibweise für Binärzahlen,\\
+ gruppiert zu jeweils 3 Bits.
+ \item
+ Trotz Taschenrechner u.\,ä.\ lohnt es sich,\\
+ die o.\,a.\ Umrechnungstabelle \textbf{auswendig} zu kennen.
+ \end{itemize}
+
+\end{frame}
+
+\subsubsection{Bit-Operationen in C}
+
+\begin{frame}[fragile]
+
+ \showsubsubsection
+
+ \begin{tabular}{lll}
+ C-Operator & Verknüpfung & Anwendung \\[\smallskipamount]
+ \lstinline,&, & Und & Bits gezielt löschen \\
+ \lstinline,|, & Oder & Bits gezielt setzen \\
+ \lstinline,^, & Exklusiv-Oder & Bits gezielt invertieren \\
+ \lstinline,~, & Nicht & Alle Bits invertieren \\[\smallskipamount]
+ \lstinline,<<, & Verschiebung nach links & Maske generieren \\
+ \lstinline,>>, & Verschiebung nach rechts & Bits isolieren
+ \end{tabular}
+
+ \bigskip
+
+ Numerierung der Bits: von rechts ab 0
+
+ \medskip
+
+ \begin{tabular}{ll}
+ Bit Nr.\ 3 auf 1 setzen: &
+ \lstinline,a |= 1 << 3;, \\
+ Bit Nr.\ 4 auf 0 setzen: &
+ \lstinline,a &= ~(1 << 4);, \\
+ Bit Nr.\ 0 invertieren: &
+ \lstinline,a ^= 1 << 0;,
+ \end{tabular}
+
+ \smallskip
+
+ ~~Abfrage, ob Bit Nr.\ 1 gesetzt ist:\quad
+ \lstinline{if (a & (1 << 1))}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsubsection
+
+ C-Datentypen für Bit-Operationen:
+ \smallskip\par
+ \lstinline{#include <stdint.h>}
+ \medskip\par
+ \begin{tabular}{lllll}
+ & 8 Bit & 16 Bit & 32 Bit & 64 Bit \\
+ mit Vorzeichen & \lstinline,int8_t,
+ & \lstinline,int16_t,
+ & \lstinline,int32_t,
+ & \lstinline,int64_t, \\
+ ohne Vorzeichen & \lstinline,uint8_t,
+ & \lstinline,uint16_t,
+ & \lstinline,uint32_t,
+ & \lstinline,uint64_t,
+ \end{tabular}
+
+ \bigskip
+ \bigskip
+
+ Ausgabe:
+ \smallskip\par
+ \begin{lstlisting}
+ #include <stdio.h>
+ #include <stdint.h>
+ #include <inttypes.h>
+ ...
+ uint64_t x = 42;
+ printf ("Die Antwort lautet: %" PRIu64 "\n", x);
+ \end{lstlisting}
+
+\end{frame}
+
+\subsection{I/O-Ports}
+
+\begin{frame}[fragile]
+
+% \showsection
+ \showsubsection
+ \vspace*{-1.5\medskipamount}
+ {\large\textbf{\color{structure}4.3\quad Interrupts}}
+
+ \bigskip
+
+ Kommunikation mit externen Geräten
+
+ \bigskip
+
+ \begin{center}
+ \includegraphics{io-ports-and-interrupts.pdf}
+ \end{center}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ In Output-Port schreiben = Aktoren ansteuern
+
+ Beispiel: LED
+
+ \medskip
+
+ \begin{lstlisting}
+ #include <avr/io.h>
+ ...
+ DDRC = 0x70;
+ PORTC = 0x40;
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \put(3,0.67){\begin{minipage}{3cm}
+ \color{red}%
+ binär: 0111\,0000\\
+ binär: 0100\,0000
+ \end{minipage}}
+ \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
+ \end{picture}
+
+ \bigskip
+
+ \lstinline{DDR} = Data Direction Register\\
+ Bit = 1 für Output-Port\\
+ Bit = 0 für Input-Port
+
+ \bigskip
+
+ \emph{Details: siehe Datenblatt und Schaltplan}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Aus Input-Port lesen = Sensoren abfragen
+
+ Beispiel: Taster
+
+ \medskip
+
+ \begin{lstlisting}
+ #include <avr/io.h>
+ ...
+ DDRC = 0xfd;
+ while ((PINC & 0x02) == 0)
+ ; /* just wait */
+ \end{lstlisting}
+ \begin{picture}(0,0)(-1.5,-0.42)
+ \put(3,0.67){\begin{minipage}{3cm}
+ \color{red}%
+ binär: 1111\,1101\\
+ binär: 0000\,0010
+ \end{minipage}}
+ \put(10,0.67){\makebox(0,0)[r]{\color{red}Herstellerspezifisch!}}
+ \end{picture}
+
+ \bigskip
+
+ \lstinline{DDR} = Data Direction Register\\
+ Bit = 1 für Output-Port\\
+ Bit = 0 für Input-Port
+
+ \bigskip
+
+ \emph{Details: siehe Datenblatt und Schaltplan}
+
+ \bigskip
+
+ Praktikumsaufgabe: Druckknopfampel
+
+\end{frame}
+
+\subsection{Interrupts}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Externes Gerät ruft (per Stromsignal) Unterprogramm auf
+
+ Zeiger hinterlegen: "`Interrupt-Vektor"'
+
+ Beispiel: eingebaute Uhr\hfill
+ \makebox(0,0)[tr]{%
+ \only<1->{\begin{minipage}[t]{4.7cm}
+ \vspace*{-0.3cm}%
+ statt Zählschleife (\lstinline{_delay_ms}):\\
+ Hauptprogramm kann\\
+ andere Dinge tun
+ \end{minipage}}%
+ }
+
+ \medskip
+
+ \begin{lstlisting}
+ #include <avr/interrupt.h>
+
+ ...
+
+
+ ISR (TIMER0B_COMP_vect)
+ {
+ PORTD ^= 0x40;
+ }
+ \end{lstlisting}
+ \begin{picture}(0,0)
+ \color{red}
+ \put(1.9,3.1){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-1.4,-1.0);}}}
+ \put(2.0,3.2){\makebox(0,0)[l]{"`Dies ist ein Interrupt-Handler."'}}
+ \put(2.3,2.6){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.6,-0.55);}}}
+ \put(2.4,2.6){\makebox(0,0)[l]{Interrupt-Vektor darauf zeigen lassen}}
+ \end{picture}
+
+ Initialisierung über spezielle Ports:
+ \lstinline{TCCR0B}, \lstinline{TIMSK0}
+
+ \bigskip
+
+ \emph{Details: siehe Datenblatt und Schaltplan}
+
+ \vspace*{-2.5cm}\hfill
+ {\color{red}Herstellerspezifisch!}%
+ \hspace*{1cm}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Externes Gerät ruft (per Stromsignal) Unterprogramm auf
+
+ Zeiger hinterlegen: "`Interrupt-Vektor"'
+
+ Beispiel: Taster\hfill
+ \makebox(0,0)[tr]{%
+ \begin{minipage}[t]{4.7cm}
+ \vspace*{-0.3cm}%
+ statt \newterm{Busy Waiting\/}:\\
+ Hauptprogramm kann\\
+ andere Dinge tun
+ \end{minipage}}
+
+ \medskip
+
+ \begin{lstlisting}
+ #include <avr/interrupt.h>
+ ...
+
+ ISR (INT0_vect)
+ {
+ PORTD ^= 0x40;
+ }
+ \end{lstlisting}
+
+ \medskip
+
+ Initialisierung über spezielle Ports:
+ \lstinline{EICRA}, \lstinline{EIMSK}
+
+ \bigskip
+
+ \emph{Details: siehe Datenblatt und Schaltplan}
+
+ \vspace*{-2.5cm}\hfill
+ {\color{red}Herstellerspezifisch!}%
+ \hspace*{1cm}
+
+\end{frame}
+
+\subsection{volatile-Variable}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Externes Gerät ruft (per Stromsignal) Unterprogramm auf
+
+ Zeiger hinterlegen: "`Interrupt-Vektor"'
+
+ Beispiel: Taster
+
+ \vspace*{-2.5pt}
+
+ \begin{minipage}[t]{5cm}
+ \begin{onlyenv}<1>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <avr/interrupt.h>
+ ...
+
+ uint8_t key_pressed = 0;
+
+ ISR (INT0_vect)
+ {
+ key_pressed = 1;
+ }¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<2>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <avr/interrupt.h>
+ ...
+
+ volatile uint8_t key_pressed = 0;
+
+ ISR (INT0_vect)
+ {
+ key_pressed = 1;
+ }¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \end{minipage}\hfill
+ \begin{minipage}[t]{6cm}
+ \begin{lstlisting}[gobble=6]
+ ¡int main (void)
+ {
+ ...
+
+ while (1)
+ {
+ while (!key_pressed)
+ ; /* just wait */
+ PORTD ^= 0x40;
+ key_pressed = 0;
+ }
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{minipage}
+
+ \pause
+ \begin{picture}(0,0)
+ \color{red}
+ \put(10.3,4.0){\makebox(0,0)[b]{\begin{minipage}{6cm}
+ \begin{center}
+ \textbf{volatile}:\\
+ Speicherzugriff\\
+ nicht wegoptimieren
+ \end{center}
+ \end{minipage}}}
+ \put(10.3,3.95){\makebox(0,0)[tr]{\tikz{\draw[-latex](0,0)--(-0.5,-0.9);}}}
+ \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Was ist eigentlich \lstinline{PORTD}?
+
+ \bigskip
+ \pause
+
+ \lstinline[style=cmd]{avr-gcc -Wall -Os -mmcu=atmega328p blink-3.c -E}
+
+ \bigskip
+ \pause
+ \lstinline{PORTD = 0x01;}\\
+ \textarrow\quad
+ \lstinline[style=terminal]{(*(volatile uint8_t *)((0x0B) + 0x20)) = 0x01;}\\
+ \pause
+ \begin{picture}(0,2)(0,-1.7)
+ \color{red}
+ \put(5.75,0.3){$\underbrace{\rule{2.95cm}{0pt}}_{\mbox{Zahl: \lstinline|0x2B|}}$}
+ \pause
+ \put(1.55,0.3){$\underbrace{\rule{4.0cm}{0pt}}_{\mbox{\shortstack[t]{Umwandlung in Zeiger\\
+ auf \lstinline|volatile uint8_t|}}}$}
+ \pause
+ \put(1.32,-1){\makebox(0,0)[b]{\tikz{\draw[-latex](0,0)--(0,1.3)}}}
+ \put(1.12,-1.1){\makebox(0,0)[tl]{Dereferenzierung des Zeigers}}
+ \end{picture}
+
+ \pause
+ \textarrow\quad
+ \lstinline|volatile uint8_t|-Variable an Speicheradresse \lstinline|0x2B|
+
+ \pause
+ \bigskip
+ \bigskip
+
+ \textarrow\quad
+ \lstinline|PORTA = PORTB = PORTC = PORTD = 0| ist eine schlechte Idee.
+
+\end{frame}
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+ \shownosectionnonumber
+
+ \begin{itemize}
+ \item[\textbf{1}] \textbf{Einführung}
+ \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}}
+ \item[\textbf{2}] \textbf{Einführung in C}
+ \item[\textbf{3}] \textbf{Bibliotheken}
+ \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+ \begin{itemize}
+ \item[4.1] Bit-Operationen
+ \color{medgreen}
+ \item[4.2] I/O-Ports
+ \item[4.3] Interrupts
+ \item[4.4] volatile-Variable
+ \color{red}
+ \item[4.5] Byte-Reihenfolge -- Endianness
+ \item[4.6] Binärdarstellung negativer Zahlen
+ \item[4.7] Binärdarstellung von Gleitkommazahlen
+ \item[4.8] Speicherausrichtung -- Alignment
+ \end{itemize}
+ \item[\textbf{5}] \textbf{Algorithmen}
+ \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+ \item[\textbf{7}] \textbf{Datenstrukturen}
+ \end{itemize}
+
+\end{frame}
+
+\iffalse
+
+\subsection{Byte-Reihenfolge -- Endianness}
+\subsubsection{Konzept}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+ \showsubsubsection
+
+ Eine Zahl geht über mehrere Speicherzellen.\\
+ Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
+
+ \smallskip
+
+ Welche Bits liegen wo?
+
+ \pause
+ \bigskip
+
+ $1027 = 1024 + 2 + 1 = 0000\,0100\,0000\,0011_2 = 0403_{16}$
+
+ \pause
+ \bigskip
+ Speicherzellen:
+
+ \medskip
+ \begin{tabular}{|c|c|l}\cline{1-2}
+ \raisebox{-0.25ex}{04} & \raisebox{-0.25ex}{03} & \strut Big-Endian "`großes Ende zuerst"' \\\cline{1-2}
+ \multicolumn{2}{c}{} & \pause für Menschen leichter lesbar \pause \\
+ \multicolumn{3}{c}{} \\[-5pt]\cline{1-2}
+ \raisebox{-0.25ex}{03} & \raisebox{-0.25ex}{04} & \strut Little-Endian "`kleines Ende zuerst"' \\\cline{1-2}
+ \multicolumn{2}{c}{} & \pause bei Additionen effizienter
+ \end{tabular}
+
+ \pause
+ \medskip
+ \textarrow\ Geschmackssache
+ \pause\\
+ \quad\textbf{\dots\ außer bei Datenaustausch!}
+
+% \pause
+% \bigskip
+%
+% Aber: nicht verwechseln! \qquad $0304_{16} = 772$
+
+\end{frame}
+
+\begin{frame}
+
+ \showsubsection
+ \showsubsubsection
+
+ Eine Zahl geht über mehrere Speicherzellen.\\
+ Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen
+
+ \smallskip
+
+ Welche Bits liegen wo?
+
+ \medskip
+
+ \textarrow\ Geschmackssache\\
+ \textbf{\dots\ außer bei Datenaustausch!}
+
+ \begin{itemize}
+ \item
+ Dateiformate
+ \item
+ Datenübertragung
+ \end{itemize}
+
+\end{frame}
+
+\subsubsection{Dateiformate}
+
+\begin{frame}
+
+ \showsubsection
+ \showsubsubsection
+
+ Audio-Formate: Reihenfolge der Bytes in 16- und 32-Bit-Zahlen
+ \begin{itemize}
+ \item
+ RIFF-WAVE-Dateien (\file{.wav}): Little-Endian
+ \item
+ Au-Dateien (\file{.au}): Big-Endian
+ \pause
+ \item
+ ältere AIFF-Dateien (\file{.aiff}): Big-Endian
+ \item
+ neuere AIFF-Dateien (\file{.aiff}): Little-Endian
+ \end{itemize}
+
+ \pause
+ \bigskip
+
+ Grafik-Formate: Reihenfolge der Bits in den Bytes
+ \begin{itemize}
+ \item
+ PBM-Dateien: Big-Endian\only<4->{, MSB first}
+ \item
+ XBM-Dateien: Little-Endian\only<4->{, LSB first}
+ \end{itemize}
+ \only<4->{MSB/LSB = most/least significant bit}
+
+\end{frame}
+
+\subsubsection{Datenübertragung}
+
+\begin{frame}
+
+ \showsubsection
+ \showsubsubsection
+
+ \begin{itemize}
+ \item
+ RS-232 (serielle Schnittstelle): LSB first
+ \item
+ I$^2$C: MSB first
+ \item
+ USB: beides
+ \pause
+ \medskip
+ \item
+ Ethernet: LSB first
+ \item
+ TCP/IP (Internet): Big-Endian
+ \end{itemize}
+
+\end{frame}
+
+\subsection{Binärdarstellung negativer Zahlen}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Speicher ist begrenzt!\\
+ \textarrow\ feste Anzahl von Bits
+
+ \medskip
+
+ 8-Bit-Zahlen ohne Vorzeichen: \lstinline{uint8_t}\\
+ \textarrow\ Zahlenwerte von \lstinline{0x00} bis \lstinline{0xff} = 0 bis 255\\
+ \pause
+ \textarrow\ 255 + 1 = 0
+
+ \pause
+ \medskip
+
+ 8-Bit-Zahlen mit Vorzeichen: \lstinline{int8_t}\\
+ \lstinline{0xff} = 255 ist die "`natürliche"' Schreibweise für $-1$.\\
+ \pause
+ \textarrow\ Zweierkomplement
+
+ \pause
+ \medskip
+
+ Oberstes Bit = 1: negativ\\
+ Oberstes Bit = 0: positiv\\
+ \textarrow\ 127 + 1 = $-128$
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Speicher ist begrenzt!\\
+ \textarrow\ feste Anzahl von Bits
+
+ \medskip
+
+ 16-Bit-Zahlen ohne Vorzeichen:
+ \lstinline{uint16_t}\hfill\lstinline{uint8_t}\\
+ \textarrow\ Zahlenwerte von \lstinline{0x0000} bis \lstinline{0xffff}
+ = 0 bis 65535\hfill 0 bis 255\\
+ \textarrow\ 65535 + 1 = 0\hfill 255 + 1 = 0
+
+ \medskip
+
+ 16-Bit-Zahlen mit Vorzeichen:
+ \lstinline{int16_t}\hfill\lstinline{int8_t}\\
+ \lstinline{0xffff} = 66535 ist die "`natürliche"' Schreibweise für $-1$.\hfill
+ \lstinline{0xff} = 255 = $-1$\\
+ \textarrow\ Zweierkomplement
+
+ \medskip
+
+ Oberstes Bit = 1: negativ\\
+ Oberstes Bit = 0: positiv\\
+ \textarrow\ 32767 + 1 = $-32768$
+
+ \bigskip
+ Literatur: \url{http://xkcd.com/571/}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ Frage: \emph{Für welche Zahl steht der Speicherinhalt\,
+ \raisebox{2pt}{%
+ \tabcolsep0.25em
+ \begin{tabular}{|c|c|}\hline
+ \rule{0pt}{11pt}a3 & 90 \\\hline
+ \end{tabular}}
+ (hexadezimal)?}
+
+ \pause
+ \smallskip
+ Antwort: \emph{Das kommt darauf an.} ;--)
+
+ \pause
+ \medskip
+ Little-Endian:
+
+ \smallskip
+
+ \begin{tabular}{lrl}
+ als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
+ als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
+ als \lstinline,int16_t,: & $-28509$\\
+ als \lstinline,uint16_t,: & $37027$\\
+ \lstinline,int32_t, oder größer: & $37027$
+ & (zusätzliche Bytes mit Nullen aufgefüllt)
+ \end{tabular}
+
+ \pause
+ \medskip
+ Big-Endian:
+
+ \smallskip
+
+ \begin{tabular}{lrl}
+ als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\
+ als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\
+ als \lstinline,int16_t,: & $-23664$\\
+ als \lstinline,uint16_t,: & $41872$\\ als \lstinline,int32_t,: & $-1550843904$ & (zusätzliche Bytes\\
+ als \lstinline,uint32_t,: & $2744123392$ & mit Nullen aufgefüllt)\\
+ als \lstinline,int64_t,: & $-6660823848880963584$\\
+ als \lstinline,uint64_t,: & $11785920224828588032$\\
+ \end{tabular}
+
+ \vspace*{-1cm}
+
+\end{frame}
+
+\subsection{Speicherausrichtung -- Alignment}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdint.h>
+
+ uint8_t a;
+ uint16_t b;
+ uint8_t c;
+ \end{lstlisting}
+
+ \pause
+ \bigskip
+
+ Speicheradresse durch 2 teilbar -- "`16-Bit-Alignment"'
+ \begin{itemize}
+ \item
+ 2-Byte-Operation: effizienter
+ \pause
+ \item
+ \dots\ oder sogar nur dann erlaubt
+ \pause
+ \arrowitem
+ Compiler optimiert Speicherausrichtung
+ \end{itemize}
+
+ \medskip
+
+ \pause
+ \begin{minipage}{3cm}
+ \begin{lstlisting}[gobble=6]
+ ¡uint8_t a;
+ uint8_t dummy;
+ uint16_t b;
+ uint8_t c;¿
+ \end{lstlisting}
+ \end{minipage}
+ \pause
+ \begin{minipage}{3cm}
+ \begin{lstlisting}[gobble=6]
+ ¡uint8_t a;
+ uint8_t c;
+ uint16_t b;¿
+ \end{lstlisting}
+ \end{minipage}
+
+ \pause
+ \vspace{-1.75cm}
+ \strut\hfill
+ \begin{minipage}{6.5cm}
+ Fazit:
+ \begin{itemize}
+ \item
+ \textbf{Adressen von Variablen\\
+ sind systemabhängig}
+ \item
+ Bei Definition von Datenformaten\\
+ Alignment beachten \textarrow\ effizienter
+ \end{itemize}
+ \end{minipage}
+
+\end{frame}
+
+\fi
+
+\end{document}
diff --git a/20231109/hp-20231109.toc b/20231109/hp-20231109.toc
new file mode 100644
index 0000000000000000000000000000000000000000..8e2efffd909dd6cdec34596b1b1ad4a53f3366d2
--- /dev/null
+++ b/20231109/hp-20231109.toc
@@ -0,0 +1,11 @@
+\babel@toc {german}{}\relax
+\beamer@sectionintoc {3}{Bibliotheken}{3}{0}{1}
+\beamer@subsectionintoc {3}{4}{Callbacks}{3}{0}{1}
+\beamer@subsectionintoc {3}{5}{Projekt organisieren: make}{5}{0}{1}
+\beamer@sectionintoc {4}{Hardwarenahe Programmierung}{10}{0}{2}
+\beamer@subsectionintoc {4}{1}{Bit-Operationen}{10}{0}{2}
+\beamer@subsubsectionintoc {4}{1}{1}{Zahlensysteme}{10}{0}{2}
+\beamer@subsubsectionintoc {4}{1}{2}{Bit-Operationen in C}{12}{0}{2}
+\beamer@subsectionintoc {4}{2}{I/O-Ports}{14}{0}{2}
+\beamer@subsectionintoc {4}{3}{Interrupts}{17}{0}{2}
+\beamer@subsectionintoc {4}{4}{volatile-Variable}{19}{0}{2}
diff --git a/20231109/hp-musterloesung-20231109.pdf b/20231109/hp-musterloesung-20231109.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..d6e237168d76b14d25b21f44210e697d2ca18946
Binary files /dev/null and b/20231109/hp-musterloesung-20231109.pdf differ
diff --git a/20231109/hp-musterloesung-20231109.tex b/20231109/hp-musterloesung-20231109.tex
new file mode 100644
index 0000000000000000000000000000000000000000..b7fb6a16b5ba3dbcf68201ebed5f51881bf4944a
--- /dev/null
+++ b/20231109/hp-musterloesung-20231109.tex
@@ -0,0 +1,438 @@
+% hp-musterloesung-20231109.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 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: Text-Grafik-Bibliothek, Mikrocontroller, LED-Blinkmuster
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+\renewcommand{\breath}{\bigskip}
+
+\begin{document}
+
+ \section*{Hardwarenahe Programmierung\\
+ Musterlösung zu den Übungsaufgaben -- 9.\ November 2023}
+
+ \exercise{Text-Grafik-Bibliothek}
+
+ Schreiben Sie eine Bibliothek für "`Text-Grafik"' mit folgenden Funktionen:\vspace*{-\medskipamount}
+ \begin{itemize}
+ \item
+ \lstinline|void clear (char c)|\\
+ Bildschirm auf Zeichen \lstinline|c| löschen,\\
+ also komplett mit diesem Zeichen (z.\,B.: Leerzeichen) füllen
+ \item
+ \lstinline|void put_point (int x, int y, char c)|\\
+ Punkt setzen (z.\,B.\ einen Stern (\lstinline{*}) an die Stelle $(x,y)$ "`malen"')
+ \item
+ \lstinline|char get_point (int x, int y)|\\
+ Punkt lesen
+% \item
+% \lstinline|void fill (int x, int y, char c, char o)|\\
+% Fläche in der "`Farbe"' \lstinline|o|,
+% die den Punkt \lstinline|(x, y)| enthält,
+% mit der "`Farbe"' \lstinline|c| ausmalen
+ \item
+ \lstinline|void display (void)|\\
+ das Gezeichnete auf dem Bildschirm ausgeben
+ \end{itemize}
+
+ \goodbreak
+
+ Hinweise:\vspace*{-\medskipamount}
+ \begin{itemize}
+ \item
+ Eine C-Bibliothek besteht aus (mindestens)
+ einer \file{.h}-Datei und einer \file{.c}-Datei.
+ \item
+ Verwenden Sie ein Array als "`Bildschirm"'.
+
+ Vor dem Aufruf der Funktion \lstinline|display()| ist nichts zu sehen;\\
+ alle Grafikoperationen erfolgen auf dem Array.
+ \item
+ Verwenden Sie Präprozessor-Konstante,
+ z.\,B.\ \lstinline{WIDTH} und \lstinline{HEIGHT},\\
+ um Höhe und Breite des "`Bildschirms"' festzulegen:
+ \begin{lstlisting}[gobble=8]
+ #define WIDTH 72
+ #define HEIGHT 24
+ \end{lstlisting}
+ \item
+ Schreiben Sie zusätzlich ein Test-Programm,
+ das alle Funktionen der Bibliothek benutzt,\\
+ um ein hübsches Bild (z.\,B.\ ein stilisiertes Gesicht -- "`Smiley"')
+ auszugeben.
+ \end{itemize}
+ \points{8}
+
+ \solution
+
+ Siehe die Dateien \gitfile{hp}{2023ws/20231109}{textgraph.c} und \gitfile{hp}{2023ws/20231109}{textgraph.h} (Bibliothek)
+ sowie \gitfile{hp}{2023ws/20231109}{test-textgraph.c} (Test-Programm).
+
+ Diese Lösung erfüllt zusätzlich die Aufgabe,
+ bei fehlerhafter Benutzung (Koordinaten außerhalb des Zeichenbereichs)
+ eine sinnvolle Fehlermeldung auszugeben,
+ anstatt unkontrolliert Speicher zu überschreiben und abzustürzen.
+
+ Das Schlüsselwort \lstinline{static}
+ bei der Deklaration der Funktion \lstinline{check_coordinates()}
+ bedeutet, daß diese Funktion nur lokal (d.\,h.\ innerhalb der Bibliothek)
+ verwendet und insbesondere nicht nach außen
+ (d.\,h.\ für die Benutzung durch das Hauptprogramm) exportiert wird.
+ Dies dient dazu, nicht unnötig Bezeichner zu reservieren
+ (Vermeidung von "`Namensraumverschmutzung"').
+
+ Man beachte die Verwendung einfacher Anführungszeichen (Apostrophe)
+ bei der Angabe von \lstinline{char}-Kon"-stanten (\lstinline{'*'})
+ im Gegensatz zur Verwendung doppelter Anführungszeichen
+ bei der Angabe von String-Konstanten
+ (String = Array von \lstinline{char}s, abgeschlossen mit Null-Symbol).
+ Um das einfache Anführungszeichen selbst als \lstinline{char}-Konstante anzugeben,
+ ist ein vorangestellter Backslash erforderlich: \lstinline{'\''} ("`Escape-Sequenz"').
+ Entsprechendes gilt für die Verwendung doppelter Anführungszeichen
+ innerhalb von String-Konstanten:
+ \lstinline{printf ("Your name is: \"%s\"", name);}
+
+ \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}{2023ws/20231109}{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}
+
+ \solution
+
+ \begin{itemize}
+ \item[(a)]
+ \textbf{Was bewirkt dieses Programm?}
+
+ \newcommand{\x}{$\bullet$}
+ \renewcommand{\o}{$\circ$}
+
+ \begin{minipage}[t]{0.75\textwidth}\parskip\smallskipamount
+ Es läßt die LEDs in dem rechts abgebildeten Muster aufleuchten,\\
+ das z.\,B.\ als die Ziffer 4 gelesen werden kann.
+
+ (Das Zeichen \x\ steht für eine leuchtende, \o\ für eine nicht leuchtende LED.)
+
+ Die erste Spalte (Port A) von unten nach oben gelesen (Bit 7 bis 0)\\
+ entspricht der Binärdarstellung von \lstinline{0x1f}: 0001\,1111.
+
+ Die dritte Spalte (Port C) von unten nach oben gelesen (Bit 7 bis 0)\\
+ entspricht der Binärdarstellung von \lstinline{0xfc}: 1111\,1100.
+
+ Die zweite und vierte Spalte (Port B und D) von unten nach oben gelesen\\
+ (Bit 7 bis 0) entsprechen der Binärdarstellung von \lstinline{0x10}: 0001\,0000.
+
+ Achtung: Die Zuweisung der Werte an die Ports erfolgt im Programm\\
+ \emph{nicht\/} in der Reihenfolge A B C D, sondern in der Reihenfolge A B D C.
+ \end{minipage}\hfill
+ \begin{minipage}[t]{0.15\textwidth}
+ \vspace*{-0.5cm}%
+ \begin{tabular}{cccc}
+ \x & \o & \o & \o \\
+ \x & \o & \o & \o \\
+ \x & \o & \x & \o \\
+ \x & \o & \x & \o \\
+ \x & \x & \x & \x \\
+ \o & \o & \x & \o \\
+ \o & \o & \x & \o \\
+ \o & \o & \x & \o \\
+ \end{tabular}
+ \end{minipage}
+
+ \item[(b)]
+ \textbf{Wozu dienen die ersten vier Zeilen des Hauptprogramms?}
+
+ Mit diesen Zeilen werden alle jeweils 8 Bits aller 4 Ports
+ als Output-Ports konfiguriert.
+
+ \item[(c)]
+ \textbf{Was würde stattdessen die Zeile \lstinline{DDRA, DDRB, DDRC, DDRD = 0xff;} bewirken?}
+
+ Der Komma-Operator in C bewirkt, daß der erste Wert berechnet
+ und wieder verworfen wird und stattdessen der zweite Wert weiterverarbeitet wird.
+ Konkret hier hätte das zur Folge,
+ daß \lstinline{DDRA}, \lstinline{DDRB} und \lstinline{DDRC}
+ gelesen und die gelesenen Werte ignoriert werden;
+ anschließend wird \lstinline{DDRD} der Wert \lstinline{0xff} zugewiesen.
+ Damit würde also nur einer von vier Ports überhaupt konfiguriert.
+
+ Da es sich bei den \lstinline{DDR}-Variablen
+ um \lstinline{volatile}-Variable handelt,
+ nimmt der Compiler an, daß der Lesezugriff schon irgendeinen Sinn hätte.
+ Der Fehler bliebe also unbemerkt.
+
+ \item[(d)]
+ \textbf{Schreiben Sie das Programm so um,
+ daß die durch das Programm dargestellte Figur spiegelverkehrt erscheint.}
+
+ Hierzu vertauschen wir die Zuweisungen
+ an \lstinline{PORTA} und \lstinline{PORTD}
+ sowie die Zuweisungen
+ an \lstinline{PORTB} und \lstinline{PORTC}:
+
+ \begin{lstlisting}[gobble=8]
+ PORTD = 0x1f;
+ PORTC = 0x10;
+ PORTA = 0x10;
+ PORTB = 0xfc;
+ \end{lstlisting}
+
+ Damit ergibt sich eine Spiegelung an der vertikalen Achse.
+
+ Alternativ kann man auch an der horizontalen Achse spiegeln.
+ Dafür muß man die Bits in den Hexadezimalzahlen umdrehen:
+
+ \begin{lstlisting}[gobble=8]
+ PORTA = 0xf8;
+ PORTB = 0x08;
+ PORTD = 0x08;
+ PORTC = 0x3f;
+ \end{lstlisting}
+
+ Die Frage, welche der beiden Spiegelungen gewünscht ist,
+ wäre übrigens \emph{auch in der Klausur zulässig}.
+
+ \item[(e)]
+ \textbf{Wozu dient das \lstinline{while (1)}?}
+
+ Mit dem \lstinline{return}-Befehl am Ende des Hauptprogramms
+ gibt das Programm die Kontrolle an das Betriebssystem zurück.
+
+ Dieses Programm jedoch läuft auf einem Mikrocontroller,
+ auf dem es kein Betriebssystem gibt.
+ Wenn das \lstinline{return} ausgeführt würde,
+ hätte es ein undefiniertes Verhalten zur Folge.
+
+ Um dies zu verhindern, endet das Programm in einer Endlosschleife,
+ mit der wir den Mikrocontroller anweisen,
+ nach der Ausführung des Programms \emph{nichts mehr\/} zu tun
+ (im Gegensatz zu: \emph{irgendetwas Undefiniertes\/} zu tun).
+
+ \end{itemize}
+
+ \exercise{LED-Blinkmuster}
+
+ Wir betrachten das folgende Programm für einen ATmega32-Mikro-Controller
+ (Datei: \gitfile{hp}{2023ws/20231109}{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}
diff --git a/20231109/hp-uebung-20231109.pdf b/20231109/hp-uebung-20231109.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..382f5b3bc4c820d2774078b28a671feb6a508837
Binary files /dev/null and b/20231109/hp-uebung-20231109.pdf differ
diff --git a/20231109/hp-uebung-20231109.tex b/20231109/hp-uebung-20231109.tex
new file mode 100644
index 0000000000000000000000000000000000000000..c95f1467fc190e6e5e7cfa13b9fa34231063e710
--- /dev/null
+++ b/20231109/hp-uebung-20231109.tex
@@ -0,0 +1,263 @@
+% hp-uebung-20231109.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 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: Text-Grafik-Bibliothek, Mikrocontroller, LED-Blinkmuster
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+ \thispagestyle{empty}
+
+ \section*{Hardwarenahe Programmierung\\
+ Übungsaufgaben -- 9.\ November 2023}
+
+ 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{Text-Grafik-Bibliothek}
+
+ \begin{minipage}[t]{0.45\textwidth}
+ Schreiben Sie eine Bibliothek für "`Text-Grafik"' mit folgenden Funktionen:\vspace*{-\medskipamount}
+ \begin{itemize}
+ \item
+ \lstinline|void clear (char c)|\\
+ Bildschirm auf Zeichen \lstinline|c| löschen,\\
+ also komplett mit diesem Zeichen\\
+ (z.\,B.: Leerzeichen) füllen
+ \item
+ \lstinline|void put_point (int x, int y, char c)|\\
+ Punkt setzen (z.\,B.\ einen Stern (\lstinline{*})\\
+ an die Stelle $(x,y)$ "`malen"')
+ \item
+ \lstinline|char get_point (int x, int y)|\\
+ Punkt lesen
+% \item
+% \lstinline|void fill (int x, int y, char c, char o)|\\
+% Fläche in der "`Farbe"' \lstinline|o|,
+% die den Punkt \lstinline|(x, y)| enthält,
+% mit der "`Farbe"' \lstinline|c| ausmalen
+ \item
+ \lstinline|void display (void)|\\
+ das Gezeichnete auf dem Bildschirm\\
+ ausgeben
+ \end{itemize}
+ \points{8}
+ \end{minipage}\hfill
+ \begin{minipage}[t]{0.45\textwidth}
+ \strut\\[-1.2cm]
+ Hinweise:\vspace*{-\medskipamount}
+ \begin{itemize}
+ \item
+ Eine C-Bibliothek besteht aus (mindestens)
+ einer \file{.h}-Datei und einer \file{.c}-Datei.
+ \item
+ Verwenden Sie ein Array als "`Bildschirm"'.
+
+ Vor dem Aufruf der Funktion \lstinline|display()| ist nichts zu sehen;
+ alle Grafikoperationen erfolgen auf dem Array.
+ \item
+ Verwenden Sie Präprozessor-Konstante,
+ z.\,B.\ \lstinline{WIDTH} und \lstinline{HEIGHT},
+ um Höhe und Breite des "`Bildschirms"' festzulegen, z.\,B.:
+ \begin{lstlisting}[gobble=8]
+ #define WIDTH 72
+ #define HEIGHT 24
+ \end{lstlisting}
+ \item
+ Schreiben Sie zusätzlich ein Test-Pro\-gramm,
+ das alle Funktionen der Bibliothek benutzt,
+ um ein hübsches Bild (z.\,B.\ ein stilisiertes Gesicht -- "`Smiley"')
+ auszugeben.
+ \end{itemize}
+ \end{minipage}
+
+ \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}{2023ws/20231109}{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}{2023ws/20231109}{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}
diff --git a/20231109/io-ports-and-interrupts.pdf b/20231109/io-ports-and-interrupts.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..bcd46f7afb35605b20bdb05637e6de0a039893ec
--- /dev/null
+++ b/20231109/io-ports-and-interrupts.pdf
@@ -0,0 +1 @@
+../common/io-ports-and-interrupts.pdf
\ No newline at end of file
diff --git a/20231109/leds.jpg b/20231109/leds.jpg
new file mode 120000
index 0000000000000000000000000000000000000000..5e66b77c5c428129f6f4abcc80ae48f0c9a53c35
--- /dev/null
+++ b/20231109/leds.jpg
@@ -0,0 +1 @@
+../common/leds.jpg
\ No newline at end of file
diff --git a/20231109/logo-hochschule-bochum-cvh-text-v2.pdf b/20231109/logo-hochschule-bochum-cvh-text-v2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8
--- /dev/null
+++ b/20231109/logo-hochschule-bochum-cvh-text-v2.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20231109/logo-hochschule-bochum.pdf b/20231109/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20231109/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20231109/pgscript.sty b/20231109/pgscript.sty
new file mode 120000
index 0000000000000000000000000000000000000000..95c888478c99ea7fda0fd11ccf669ae91be7178b
--- /dev/null
+++ b/20231109/pgscript.sty
@@ -0,0 +1 @@
+../common/pgscript.sty
\ No newline at end of file
diff --git a/20231109/pgslides.sty b/20231109/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20231109/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file
diff --git a/20231109/test-textgraph.c b/20231109/test-textgraph.c
new file mode 100644
index 0000000000000000000000000000000000000000..4033f61ba55d794afbb5b6c03a0bb55dcc5d3e4e
--- /dev/null
+++ b/20231109/test-textgraph.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include "textgraph.h"
+
+int main (void)
+{
+ clear (' ');
+ put_point (-5, 10, 'X');
+ for (int i = 17; i < 23; i++)
+ put_point (i, 5, '*');
+ put_point (15, 6, '*');
+ put_point (14, 7, '*');
+ put_point (13, 8, '*');
+ put_point (13, 9, '*');
+ put_point (14, 10, '*');
+ put_point (15, 11, '*');
+ for (int i = 17; i < 23; i++)
+ put_point (i, 12, '*');
+ put_point (24, 11, '*');
+ put_point (25, 10, '*');
+ put_point (26, 9, '*');
+ put_point (26, 8, '*');
+ put_point (25, 7, '*');
+ put_point (24, 6, '*');
+ put_point (18, 8, 'O');
+ put_point (21, 8, 'O');
+ put_point (17, 10, '`');
+ for (int i = 18; i < 22; i++)
+ put_point (i, 10, '-');
+ put_point (22, 10, '\'');
+ put_point (13, 42, 'Y');
+ printf ("get_point (%d, %d): '%c'\n", 13, 9, get_point (13, 9));
+ printf ("get_point (%d, %d): '%c'\n", 14, 9, get_point (14, 9));
+ printf ("get_point (%d, %d): '%c'\n", 94, 9, get_point (94, 9));
+ display ();
+ return 0;
+}
diff --git a/20231109/textgraph.c b/20231109/textgraph.c
new file mode 100644
index 0000000000000000000000000000000000000000..a17f9a91173f9fe871967f5aef509798c0efbb64
--- /dev/null
+++ b/20231109/textgraph.c
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include "textgraph.h"
+
+char buffer[HEIGHT][WIDTH];
+
+void clear (char c)
+{
+ for (int y = 0; y < HEIGHT; y++)
+ for (int x = 0; x < WIDTH; x++)
+ buffer[y][x] = c;
+}
+
+static int check_coordinates (int x, int y, char *function)
+{
+ if (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT)
+ return 1;
+ else
+ {
+ fprintf (stderr, "coordinates (%d,%d) out of range in %s\n", x, y, function);
+ return 0;
+ }
+}
+
+void put_point (int x, int y, char c)
+{
+ if (check_coordinates (x, y, "put_point"))
+ buffer[y][x] = c;
+}
+
+char get_point (int x, int y)
+{
+ if (check_coordinates (x, y, "get_point"))
+ return buffer[y][x];
+ else
+ return 0;
+}
+
+void display (void)
+{
+ for (int y = 0; y < HEIGHT; y++)
+ {
+ for (int x = 0; x < WIDTH; x++)
+ printf ("%c", buffer[y][x]);
+ printf ("\n");
+ }
+}
diff --git a/20231109/textgraph.h b/20231109/textgraph.h
new file mode 100644
index 0000000000000000000000000000000000000000..419e0fbd04f3b5d07d42509ab1980513d434eb07
--- /dev/null
+++ b/20231109/textgraph.h
@@ -0,0 +1,12 @@
+#ifndef TEXTGRAPH_H
+#define TEXTGRAPH_H
+
+#define WIDTH 40
+#define HEIGHT 20
+
+extern void clear (char c);
+extern void put_point (int x, int y, char c);
+extern char get_point (int x, int y);
+extern void display (void);
+
+#endif
diff --git a/README.md b/README.md
index 4424725ad8ad26b1d5b33f335acd1bba462cac83..d128bc2664dee18913b849b94dd49a441d04f66e 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ Vortragsfolien und Beispiele:
* [19.10.2023: Einführung in C (ab 2.11: Arrays und Strings)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-20231019.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231019/)
* [26.10.2023: Einführung in C: String-Operationen; Bibliotheken](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231026/hp-20231026.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231026/)
* [02.11.2023: Bibliotheken](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231102/hp-20231102.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231102/)
+ * [09.11.2023: Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231109/hp-20231109.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231109/)
* [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/hp-slides-2023ws.pdf)
Übungsaufgaben:
@@ -31,6 +32,7 @@ Vortragsfolien und Beispiele:
* [19.10.2023: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-uebung-20231019.pdf)
* [26.10.2023: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231026/hp-uebung-20231026.pdf)
* [02.11.2023: Zahlensysteme, Ausgabe von Hexadezimalzahlen, Einfügen in Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231102/hp-uebung-20231102.pdf)
+ * [09.11.2023: Text-Grafik-Bibliothek, Mikrocontroller, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231109/hp-uebung-20231109.pdf)
Musterlösungen:
---------------
@@ -38,6 +40,7 @@ Musterlösungen:
* [19.10.2023: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-musterloesung-20231019.pdf)
* [26.10.2023: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231026/hp-musterloesung-20231026.pdf)
* [02.11.2023: Zahlensysteme, Ausgabe von Hexadezimalzahlen, Einfügen in Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231102/hp-musterloesung-20231102.pdf)
+ * [09.11.2023: Text-Grafik-Bibliothek, Mikrocontroller, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231109/hp-musterloesung-20231109.pdf)
Praktikumsunterlagen:
---------------------
diff --git a/hp-slides-2023ws.pdf b/hp-slides-2023ws.pdf
index 3149c974b177c90ab4f3f759720146412596c1c2..9229781f1f8299781a1fa4be6bdb270848b2e974 100644
Binary files a/hp-slides-2023ws.pdf and b/hp-slides-2023ws.pdf differ
diff --git a/hp-slides-2023ws.tex b/hp-slides-2023ws.tex
index 836d957f212d0b41d68c4a6cd4d387d17981df23..4b3dddcf7a3f8b14711e28e30bd154a9e63e4c01 100644
--- a/hp-slides-2023ws.tex
+++ b/hp-slides-2023ws.tex
@@ -21,4 +21,6 @@
\includepdf[pages=-]{20231026/hp-20231026.pdf}
\pdfbookmark[1]{02.11.2023: Bibliotheken}{20231102}
\includepdf[pages=-]{20231102/hp-20231102.pdf}
+ \pdfbookmark[1]{09.11.2023: Hardwarenahe Programmierung}{20231109}
+ \includepdf[pages=-]{20231109/hp-20231109.pdf}
\end{document}