diff --git a/20210107/InstallationUndVerwendungGTKWin10.pdf b/20210107/InstallationUndVerwendungGTKWin10.pdf deleted file mode 100644 index 3757e05839ad8463e7da520b343a93af1f30d951..0000000000000000000000000000000000000000 Binary files a/20210107/InstallationUndVerwendungGTKWin10.pdf and /dev/null differ diff --git a/20210107/hanoi.xcf.gz b/20210107/hanoi.xcf.gz new file mode 100644 index 0000000000000000000000000000000000000000..77c7ad5d82486563f7ae1188a7de539f9bad3663 Binary files /dev/null and b/20210107/hanoi.xcf.gz differ diff --git a/20210114/400_points_breadboard.jpg b/20210114/400_points_breadboard.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8ba048255851581a84db16c4d5a50802f7521486 Binary files /dev/null and b/20210114/400_points_breadboard.jpg differ diff --git a/20210114/Tower_of_Hanoi.jpeg b/20210114/Tower_of_Hanoi.jpeg new file mode 120000 index 0000000000000000000000000000000000000000..a1a794afda08596ffa2f46f278db53455de25b6c --- /dev/null +++ b/20210114/Tower_of_Hanoi.jpeg @@ -0,0 +1 @@ +../common/Tower_of_Hanoi.jpeg \ No newline at end of file diff --git a/20210114/aufgabe-2.c b/20210114/aufgabe-2.c new file mode 100644 index 0000000000000000000000000000000000000000..1afa7b1260506cb307aff5f929c6357c7bdcb708 --- /dev/null +++ b/20210114/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/20210114/aufgabe-3.c b/20210114/aufgabe-3.c new file mode 100644 index 0000000000000000000000000000000000000000..4c95eb6ad4881c904448309c6b7c46fa101cc109 --- /dev/null +++ b/20210114/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/20210114/hp-2020ws-p3.pdf b/20210114/hp-2020ws-p3.pdf new file mode 100644 index 0000000000000000000000000000000000000000..95e1f2fb877e9e32d0f8d5709938bd291ae1ca09 Binary files /dev/null and b/20210114/hp-2020ws-p3.pdf differ diff --git a/20210114/hp-2020ws-p3.tex b/20210114/hp-2020ws-p3.tex new file mode 100644 index 0000000000000000000000000000000000000000..42026861efdff7a93709aefd072eff2704db654d --- /dev/null +++ b/20210114/hp-2020ws-p3.tex @@ -0,0 +1,195 @@ +% 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} diff --git a/20210114/hp-20210114.pdf b/20210114/hp-20210114.pdf new file mode 100644 index 0000000000000000000000000000000000000000..1f457a7b9e76aaa6ff5fb042f3ee01b8dabcd37a Binary files /dev/null and b/20210114/hp-20210114.pdf differ diff --git a/20210114/hp-20210114.tex b/20210114/hp-20210114.tex new file mode 100644 index 0000000000000000000000000000000000000000..81466728852b1e65e1d23af0a5bb577e4627a432 --- /dev/null +++ b/20210114/hp-20210114.tex @@ -0,0 +1,1223 @@ +% hp-20210114.pdf - Lecture Slides on Low-Level Programming +% Copyright (C) 2012, 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: 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} + +\title{Hardwarenahe Programmierung} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{14.\ Januar 2021} + +\begin{document} + +\maketitleframe + +\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{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \color{medgreen} + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \begin{itemize} + \color{red} + \item[4.1] Bit-Operationen + \item[4.2] I/O-Ports + \item[4.3] Interrupts + \item[4.4] volatile-Variable + \item[4.6] Byte-Reihenfolge -- Endianness + \item[4.7] Binärdarstellung negativer Zahlen + \item[4.8] Speicherausrichtung -- Alignment + \end{itemize} + \vspace*{-\smallskipamount} + \item[\textbf{\dots}] + \end{itemize} + +\end{frame} + +\setcounter{section}{3} +\section{Algorithmen} +\subsection{Differentialgleichungen} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung} -- Schräger Wurf + + \strut\hfill + \begin{minipage}{2.5cm} + \vspace*{0.6cm} + \begin{align*} + x'(t) &= v_x(t) \\[0.65cm] + y'(t) &= v_y(t) \\[0.75cm] + v_x'(t) &= 0 \\[0.65cm] + v_y'(t) &= -g + \end{align*} + \vspace*{0.0cm} + \end{minipage}% +% \only<1>{\hspace*{9.49cm}}\strut + \only<1->{\hfill$\Rightarrow$\hfill}% + \begin{onlyenv}<1> + \begin{minipage}{8.3cm} + \begin{align*} + x(t) &= \int v_x(t)\,dt + \visible<1->{= \int v_{0x}\,dt} + \visible<1->{= x_0 + v_{0x}\cdot t}\\[\medskipamount] + y(t) &= \int v_y(t)\,dt + \visible<1->{= \int v_{0y} - g\cdot t\,dt} + \visible<1->{= y_0 + v_{0y}\cdot t + - {\textstyle\frac12}gt^2}\\[\bigskipamount] + v_x(t) &= \int 0\,dt + \visible<1->{= v_{0x}} \\[\medskipamount] + v_y(t) &= \int -g\,dt + \visible<1->{= v_{0y} - g\cdot t} + \end{align*} + \end{minipage}% + \end{onlyenv}% + \begin{onlyenv}<2-> + \begin{minipage}{3.5cm} + \vspace*{0.5cm} + \begin{lstlisting}[gobble=8,xleftmargin=0.5em] + ¡x += vx * dt;¿ + \end{lstlisting} + \vspace{0.75cm} + \begin{lstlisting}[gobble=8,xleftmargin=0.5em] + ¡y += vy * dt;¿ + \end{lstlisting} + \vspace{0.90cm} + \begin{lstlisting}[gobble=8,xleftmargin=0.5em] + ¡vx += 0 * dt;¿ + \end{lstlisting} + \vspace{0.75cm} + \begin{lstlisting}[gobble=8,xleftmargin=0.5em] + ¡vy += -g * dt;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}{5.13cm} + Siehe: \file{gtk-13.c} + \end{minipage} + \end{onlyenv}% + \hfill\strut + +\end{frame} + +\begin{frame}[fragile] + \showsection + \showsubsection + + \textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung} + + \medskip + + \textbf{Beispiel 2: Mathematisches Pendel} + + \vspace*{-2\bigskipamount} + + \begin{picture}(0,0) + \put(8,-6.5){\includegraphics{pendulum.pdf}} + \end{picture} + + \begin{eqnarray*} + \varphi'(t) &=& \omega(t) \\[\smallskipamount] + \omega'(t) &=& -\frac{g}{l}\cdot\sin\varphi(t)\hspace*{7.1cm} + \end{eqnarray*} + \vspace*{-1.5\medskipamount} + \begin{itemize} + \item + Von Hand (analytisch):\\ + Lösung raten (Ansatz), Parameter berechnen + \item + Mit Computer (numerisch):\\ + Eulersches Polygonzugverfahren + \end{itemize} + \smallskip + \begin{lstlisting}[gobble=0] + phi += dt * omega; + omega += - dt * g / l * sin (phi); + \end{lstlisting} + +% \pause + \bigskip + + \textbf{Beispiel 3: Weltraum-Simulation} + + Praktikumsaufgabe + \vspace*{-1cm} + +\end{frame} + +\subsection{Rekursion} + +\begin{frame}[fragile] + + \showsubsection + + Vollständige Induktion: + \vspace*{-0.725cm} + \begin{displaymath} + \hspace*{4cm} + \left. + \begin{array}{r} + \mbox{Aussage gilt für $n = 1$}\\[2pt] + \mbox{Schluß von $n - 1$ auf $n$} + \end{array} + \right\} + \mbox{Aussage gilt für alle $n\in\mathbb{N}$} + \end{displaymath} + \vspace*{-0.5cm} + +% \pause + + Türme von Hanoi + +% \begin{onlyenv}<1> +% \begin{center} +% \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg} +% \end{center} +% \end{onlyenv} + + \begin{onlyenv}<1-> + \begin{itemize} + \item + 64 Scheiben, 3 Plätze, + \only<1>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\ + immer 1 Scheibe verschieben + \item + Ziel: Turm verschieben + \item + Es dürfen nur kleinere Scheiben\\ + auf größeren liegen. + \bigskip +% \pause +% \pause + \item + $n = 1$ Scheibe: fertig + \item + Wenn $n - 1$ Scheiben verschiebbar:\\ + schiebe $n - 1$ Scheiben auf Hilfsplatz,\\ + verschiebe die darunterliegende,\\ + hole $n - 1$ Scheiben von Hilfsplatz + \end{itemize} + \begin{onlyenv}<2> + \vspace{-4.3cm} + \begin{lstlisting}[gobble=8,xleftmargin=6.4cm] + void move (int from, int to, int disks) + { + if (disks == 1) + move_one_disk (from, to); + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } + } + \end{lstlisting} + \end{onlyenv} + \begin{onlyenv}<3-> + \vspace{-5.0cm} + \hspace*{7.4cm}\begin{minipage}[t]{5cm} + 32 Scheiben: + \begin{lstlisting}[gobble=10,style=terminal] + $ ¡time ./hanoi-9a¿ + ... + real 0m32,712s + user 0m32,708s + sys 0m0,000s + \end{lstlisting} +% \pause[7] + \begin{itemize} + \arrowitem + etwas über 1 Minute\\ + für 64 Scheiben + \end{itemize} +% \pause + \vspace*{-0.5cm} + \begin{picture}(0,0) + \color{red} + \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}} + \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}} + \end{picture} + + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + \end{minipage} + \end{onlyenv} + \end{onlyenv} + +\end{frame} + +\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse} + +\begin{frame}[fragile] + +% \newcommand{\w}{\hspace*{0.75pt}} + + \showsubsection + + \begin{picture}(0,0) + \put(7.6,-0.5){% + \begin{minipage}[t]{5.3cm} +% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf} + \vspace*{-1.0cm}\alt<16->{\includegraphics{landau-symbols-3.pdf}}% + {\alt<15->{\includegraphics{landau-symbols-2.pdf}}% + {\includegraphics{landau-symbols.pdf}}} + \small + \begin{description}\itemsep0pt\leftskip-0.5cm + \item[$n$:] Eingabedaten + \item[$g(n)$:] Rechenzeit + \end{description} + \end{minipage}} + \end{picture} + + \vspace*{-\bigskipamount} + + Wann ist ein Programm "`schnell"'? + + \medskip + + \begin{onlyenv}<1-2> + Türme von Hanoi: $\mathcal{O}(2^n)$ + \par\medskip + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<2-> + Faustregel:\\Schachtelung der Schleifen zählen\\ + $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$ + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<3-13> + \textbf{Beispiel: Sortieralgorithmen} + + \smallskip + + Anzahl der Vergleiche bei $n$ Strings + \begin{itemize} + \item + Maximum suchen \pause[4]mit Schummeln\pause: $\mathcal{O}(1)$ + \pause + \item + Maximum suchen\pause: $\mathcal{O}(n)$ + \pause + \item + Selection-Sort\pause: $\mathcal{O}(n^2)$ + \pause + \item + Bubble-Sort\pause: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$ + \pause + \item + Quicksort\pause: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$ + \end{itemize} + + \end{onlyenv} + + \begin{onlyenv}<14> + \textbf{Wie schnell ist RSA-Verschlüsselung?} + + \smallskip + + \begin{math} + c = m^e\,\%\,N + \end{math} + \quad + ("`$\%$"' = "`modulo"') + + \medskip + + \begin{lstlisting}[gobble=6,xleftmargin=2em] + int c = 1; + for (int i = 0; i < e; i++) + c = (c * m) % N; + \end{lstlisting} + + \smallskip + + \begin{itemize} + \item + $\mathcal{O}(e)$ Iterationen +% \item +% wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist: +% $\mathcal{O}(2^n)$ Iterationen + \item + mit Trick: + $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$) + \end{itemize} + + \smallskip + + Jede Iteration enthält eine Multiplikation und eine Division.\\ + Aufwand dafür: $\mathcal{O}(\log e)$\\ + \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$ + + \end{onlyenv} + + \begin{onlyenv}<15-> + + \textbf{Wie schnell ist RSA?}\\ + + \smallskip + + ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$) + + \begin{itemize} + \item + Ver- und Entschlüsselung (Exponentiation):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Schlüsselerzeugung (Berechnung von $d$):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<16->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Verschlüsselung brechen (Primfaktorzerlegung):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss} + \only<16->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}} + \end{itemize} + + \vspace{0cm plus 1filll} + + \textbf{Die Sicherheit von RSA beruht darauf, + daß das Brechen der Verschlüsselung aufwendiger ist als + \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).} + + \vspace*{0.65cm} + + \end{onlyenv} + +\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{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \color{medgreen} + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \begin{itemize} + \color{red} + \item[4.1] Bit-Operationen + \item[4.2] I/O-Ports + \item[4.3] Interrupts + \item[4.4] volatile-Variable + \item[4.6] Byte-Reihenfolge -- Endianness + \item[4.7] Binärdarstellung negativer Zahlen + \item[4.8] Speicherausrichtung -- Alignment + \end{itemize} + \vspace*{-\smallskipamount} + \item[\textbf{\dots}] + \end{itemize} + \vspace*{-1cm} + +\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} + +\iffalse + + \bigskip + + Aufgabe: Schreiben Sie C-Funktionen, die ein "`Array von Bits"' realisieren, z.\,B. + + \smallskip + + \begin{tabular}[t]{ll} + \lstinline|void set_bit (int i);| & Bei Index $i$ auf 1 setzen \\ + \lstinline|void clear_bit (int i);| & Bei Index $i$ auf 0 setzen \\ + \lstinline|int get_bit (int i);| & Bei Index $i$ lesen + \end{tabular} + + \medskip + + Hinweise: + \begin{itemize} + \item + Die Größe des Bit-"`Arrays"' (z.\,B.\ 1000) dürfen Sie als \emph{vorher bekannt\/} voraussetzen. + \item + Sie benötigen ein Array, z.\,B.\ von \lstinline|char|- oder \lstinline|int|-Variablen. + \item + Sie benötigen eine Division (\lstinline|/|) sowie den Divisionsrest (Modulo: \lstinline|%|). + \end{itemize} + +\fi + +\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{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} + +\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} + +\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{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \begin{itemize} + \color{medgreen} + \item[4.1] Bit-Operationen + \item[4.2] I/O-Ports + \item[4.3] Interrupts + \item[4.4] volatile-Variable + \item[4.6] Byte-Reihenfolge -- Endianness + \item[4.7] Binärdarstellung negativer Zahlen + \item[4.8] Speicherausrichtung -- Alignment + \end{itemize} + \item[\textbf{\dots}] + \end{itemize} + +\end{frame} + +\end{document} diff --git a/20210114/hp-musterloesung-20210114.pdf b/20210114/hp-musterloesung-20210114.pdf new file mode 100644 index 0000000000000000000000000000000000000000..c154a59ec11e00019d6653f8a309f770ce37a0e6 Binary files /dev/null and b/20210114/hp-musterloesung-20210114.pdf differ diff --git a/20210114/hp-musterloesung-20210114.tex b/20210114/hp-musterloesung-20210114.tex new file mode 100644 index 0000000000000000000000000000000000000000..2027ef6d209d940a82a925f8d8fee50f54ab0048 --- /dev/null +++ b/20210114/hp-musterloesung-20210114.tex @@ -0,0 +1,357 @@ +% 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} diff --git a/20210114/hp-uebung-20210114.pdf b/20210114/hp-uebung-20210114.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9afd3ffcd9d2f7db7bdc28cf1ebfeb186060650d Binary files /dev/null and b/20210114/hp-uebung-20210114.pdf differ diff --git a/20210114/hp-uebung-20210114.tex b/20210114/hp-uebung-20210114.tex new file mode 100644 index 0000000000000000000000000000000000000000..c1af612e29887e3ab2b8c650a00a5e526fcc368c --- /dev/null +++ b/20210114/hp-uebung-20210114.tex @@ -0,0 +1,271 @@ +% 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} diff --git a/20210114/io-ports-and-interrupts.pdf b/20210114/io-ports-and-interrupts.pdf new file mode 120000 index 0000000000000000000000000000000000000000..bcd46f7afb35605b20bdb05637e6de0a039893ec --- /dev/null +++ b/20210114/io-ports-and-interrupts.pdf @@ -0,0 +1 @@ +../common/io-ports-and-interrupts.pdf \ No newline at end of file diff --git a/20210114/landau-symbols-2.pdf b/20210114/landau-symbols-2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4 --- /dev/null +++ b/20210114/landau-symbols-2.pdf @@ -0,0 +1 @@ +../common/landau-symbols-2.pdf \ No newline at end of file diff --git a/20210114/landau-symbols-3.pdf b/20210114/landau-symbols-3.pdf new file mode 120000 index 0000000000000000000000000000000000000000..46efa409b35ff5df763c744a423599cba515d886 --- /dev/null +++ b/20210114/landau-symbols-3.pdf @@ -0,0 +1 @@ +../common/landau-symbols-3.pdf \ No newline at end of file diff --git a/20210114/landau-symbols.pdf b/20210114/landau-symbols.pdf new file mode 120000 index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565 --- /dev/null +++ b/20210114/landau-symbols.pdf @@ -0,0 +1 @@ +../common/landau-symbols.pdf \ No newline at end of file diff --git a/20210114/leds.jpg b/20210114/leds.jpg new file mode 120000 index 0000000000000000000000000000000000000000..5e66b77c5c428129f6f4abcc80ae48f0c9a53c35 --- /dev/null +++ b/20210114/leds.jpg @@ -0,0 +1 @@ +../common/leds.jpg \ No newline at end of file diff --git a/20210114/logo-hochschule-bochum-cvh-text-v2.pdf b/20210114/logo-hochschule-bochum-cvh-text-v2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8 --- /dev/null +++ b/20210114/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/20210114/logo-hochschule-bochum.pdf b/20210114/logo-hochschule-bochum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1 --- /dev/null +++ b/20210114/logo-hochschule-bochum.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum.pdf \ No newline at end of file diff --git a/20210114/pendulum.pdf b/20210114/pendulum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..7d1d87305cdb8840a248ff2207538d758464f452 --- /dev/null +++ b/20210114/pendulum.pdf @@ -0,0 +1 @@ +../common/pendulum.pdf \ No newline at end of file diff --git a/20210114/pgscript.sty b/20210114/pgscript.sty new file mode 120000 index 0000000000000000000000000000000000000000..95c888478c99ea7fda0fd11ccf669ae91be7178b --- /dev/null +++ b/20210114/pgscript.sty @@ -0,0 +1 @@ +../common/pgscript.sty \ No newline at end of file diff --git a/20210114/pgslides.sty b/20210114/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64 --- /dev/null +++ b/20210114/pgslides.sty @@ -0,0 +1 @@ +../common/pgslides.sty \ No newline at end of file diff --git a/README.md b/README.md index 2cd6792da4dc6fd24f4d81ea43a0d63e412eb9ee..313247610584508ee3119cfb01f15d6376c3a339 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,8 @@ Vortragsfolien und Beispiele: * [03.12.2020: Parameter des Hauptprogramms, String-Operationen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201203/hp-20201203.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20201203/) * [10.12.2020: Präprozessor, Bibliotheken einbinden und verwenden](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201210/hp-20201210.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20201210/) * [17.12.2020: make, Differentialgleichungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201217/hp-20201217.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20201217/) + * [07.01.2021: Rekursion, Aufwandsabschätzungen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210107/hp-20210107.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210107/) + * [14.01.2021: Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210114/hp-20210114.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2020ws/20210114/) * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/hp-slides-2020ws.pdf) Übungsaufgaben: @@ -35,6 +37,8 @@ Vortragsfolien und Beispiele: * [03.12.2020: Arrays mit Zahlen, Datum-Bibliothek](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201203/hp-uebung-20201203.pdf) * [10.12.2020: Ausgabe von Hexadezimalzahlen, Einfügen in Strings, Länge von Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201210/hp-uebung-20201210.pdf) * [17.12.2020: Kondensator, hüpfender Ball](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201217/hp-uebung-20201217.pdf) + * [07.01.2021: Fakultät, Länge von Strings (Neuauflage), Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210107/hp-uebung-20210107.pdf) + * [14.01.2021: Zahlensysteme, Mikrocontroller, LED-Blinkmuster](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210114/hp-uebung-20210114.pdf) Musterlösungen: --------------- @@ -44,6 +48,8 @@ Musterlösungen: * [03.12.2020: Arrays mit Zahlen, Datum-Bibliothek](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201203/hp-musterloesung-20201203.pdf) * [10.12.2020: Ausgabe von Hexadezimalzahlen, Einfügen in Strings, Länge von Strings](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201210/hp-musterloesung-20201210.pdf) * [17.12.2020: Kondensator, hüpfender Ball](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201217/hp-musterloesung-20201217.pdf) + * [07.01.2021: Fakultät, Länge von Strings (Neuauflage), Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210107/hp-musterloesung-20210107.pdf) + * [14.01.2021: Fakultät, Länge von Strings (Neuauflage), Hexdumps](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210114/hp-musterloesung-20210114.pdf) Tafelbilder: ------------ @@ -53,6 +59,7 @@ Praktikumsunterlagen: --------------------- * [Versuch 1: RSA-Verschlüsselung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201112/hp-2020ws-p1.pdf) * [Versuch 2: Weltraum-Simulation](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20201217/hp-2020ws-p2.pdf) + * [Versuch 3: Druckknopfampel](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2020ws/20210114/hp-2020ws-p3.pdf) Alte Klausuren: --------------- diff --git a/hp-slides-2020ws.pdf b/hp-slides-2020ws.pdf index 4f36f89341d38beb155f7c1b2cf88ea449c8442c..204153ff3843d9c96fb2acdd2c1cbe2b3bc62764 100644 Binary files a/hp-slides-2020ws.pdf and b/hp-slides-2020ws.pdf differ diff --git a/hp-slides-2020ws.tex b/hp-slides-2020ws.tex index 7d3efeca4af1a12cafb02e471aa5fb0dd15e1f9d..1bca6b8a138335f36365db9d3774f5c109da05f2 100644 --- a/hp-slides-2020ws.tex +++ b/hp-slides-2020ws.tex @@ -20,8 +20,12 @@ \includepdf[pages=-]{20201126/hp-20201126.pdf} \pdfbookmark[1]{03.12.2020: Parameter des Hauptprogramms, String-Operationen}{20201203} \includepdf[pages=-]{20201203/hp-20201203.pdf} - \pdfbookmark[1]{10.12.2020: Parameter des Hauptprogramms, String-Operationen}{20201210} + \pdfbookmark[1]{10.12.2020: Präprozessor, Bibliotheken einbinden und verwenden}{20201210} \includepdf[pages=-]{20201210/hp-20201210.pdf} - \pdfbookmark[1]{17.12.2020: Parameter des Hauptprogramms, String-Operationen}{20201217} + \pdfbookmark[1]{17.12.2020: make, Differentialgleichungen}{20201217} \includepdf[pages=-]{20201217/hp-20201217.pdf} + \pdfbookmark[1]{07.01.2021: Rekursion, Aufwandsabschätzungen}{20210107} + \includepdf[pages=-]{20210107/hp-20210107.pdf} + \pdfbookmark[1]{14.01.2021: Hardwarenahe Programmierung}{20210114} + \includepdf[pages=-]{20210114/hp-20210114.pdf} \end{document} diff --git a/update b/update index c7d95a3a86107178f7d2dba4d604abb538851742..b2addb606cf3fb4357faafb8fa97da9cfbfce225 100755 --- a/update +++ b/update @@ -5,8 +5,8 @@ course=hp date_mask="20[12][0-9][01][0-9][0-3][0-9]" time_mask="[0-2][0-9][0-5][0-9][0-5][0-9]" -base_url="https://gitlab.cvh-server.de/pgerwinski/$course/tree/master/" -raw_base_url="https://gitlab.cvh-server.de/pgerwinski/$course/raw/master/" +base_url="https://gitlab.cvh-server.de/pgerwinski/$course/tree/$sem/" +raw_base_url="https://gitlab.cvh-server.de/pgerwinski/$course/raw/$sem/" pattern="README:" if [ "$1" = "--no-slides" ]; then @@ -122,17 +122,17 @@ Copyright © 2012–2020 Peter Gerwinski **Diese Lehrmaterialien sind freie Software.** Sie dürfen diese gemäß den jeweils angegebenen Lizenzen -([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/CC-BY-SA-3.0), -[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/GNU-GPL-3), -[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/BSD-MODIFIED)) +([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/CC-BY-SA-3.0), +[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/GNU-GPL-3), +[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/BSD-MODIFIED)) studieren, kopieren, modifizieren und/oder weitergeben. -Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/README). +Für Details siehe [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/README). EOF collect --with-examples "Vortragsfolien und Beispiele:" tex pdf $date_mask/hp-$date_mask.tex $date_mask/verschluesselung-$date_mask.tex cat >> $readme << EOF - * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-$sem.pdf) + * [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/hp-slides-$sem.pdf) EOF collect "Übungsaufgaben:" tex pdf $date_mask/hp-uebung-$date_mask.tex @@ -145,13 +145,13 @@ cat >> $readme << EOF Skript: ------- - * [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/script/hp-$sem.pdf) + * [Hardwarenahe Programmierung](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/script/hp-$sem.pdf) Original-Materialien einschließlich Beispiel-Programme und LaTeX-Quelltexte: ---------------------------------------------------------------------------- - * [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/common) - * [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/script) - * [201????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master) + * [common – gemeinsame Dateien für Skript und Vortragsfolien](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/common) + * [script – Skript zur Lehrveranstaltung](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/script) + * [201????? – Vortragsfolien und Beispiele](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem) * [branch 2018ws – vollständige Lehrmaterialien vom Wintersemester 2018/19](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2018ws) @@ -167,15 +167,15 @@ Copyright © 2012–2020 Peter Gerwinski **These teaching materials are Free Software.** You may study, copy, modify, and/or distribute them according to their respective licences -([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/CC-BY-SA-3.0), -[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/GNU-GPL-3), -[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/BSD-MODIFIED)). -See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/common/README) for details. - - * [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/common) - * [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master/script) - * [201????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/master) - * [hp-slides-2020ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/master/hp-slides-2020ws.pdf) +([CC-BY-SA 3.0](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/CC-BY-SA-3.0), +[GNU GPL 3+](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/GNU-GPL-3), +[modified BSD License](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/BSD-MODIFIED)). +See the file [common/README](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/common/README) for details. + + * [common – common files for lecture notes and slides](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/common) + * [script – lecture notes](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem/script) + * [201????? – slides and examples](https://gitlab.cvh-server.de/pgerwinski/hp/tree/$sem) + * [hp-slides-2020ws.pdf – all slides in 1 file](https://gitlab.cvh-server.de/pgerwinski/hp/raw/$sem/hp-slides-2020ws.pdf) * [branch 2018ws – complete teaching materials from winter semester 2018–19](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2018ws) EOF