Skip to content
Snippets Groups Projects
Commit f957c776 authored by Peter Gerwinski's avatar Peter Gerwinski
Browse files

Vorbereitung 12.12.2024

parent 51fb845d
Branches
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 3421 additions and 0 deletions
20241212/aufgabe-1.c 0 → 100644
+ 10
− 0
View file @ f957c776
#include <stdio.h>
#include <stdint.h>
int main (void)
{
uint64_t x = 4262939000843297096;
char *s = &x;
printf ("%s\n", s);
return 0;
}
20241212/hp-20241212.pdf 0 → 100644
+ 0
− 0
View file @ f957c776
File added
20241212/hp-20241212.tex 0 → 100644
+ 861
− 0
View file @ f957c776
% hp-20241212.pdf - Lecture Slides on Low-Level Programming
% Copyright (C) 2012, 2013, 2015-2023, 2024 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: Byte-Reihenfolge, Binärdarstellung negativer Zahlen, Speicherausrichtung, Algorithmen: Differentialgleichungen
\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{12.\ Dezember 2024}
\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{4}] \textbf{Hardwarenahe Programmierung}
\begin{itemize}
\item[4.1] Bit-Operationen
\item[4.2] I/O-Ports
\color{medgreen}
\item[4.3] Interrupts
\item[4.4] volatile-Variable
\vspace*{-\smallskipamount}
\item[\dots]
\end{itemize}
\item[\textbf{5}] \textbf{Algorithmen}
\begin{itemize}
\color{orange}
\item[5.1] Differentialgleichungen
\vspace*{-\smallskipamount}
\item[\dots]
\end{itemize}
\item[\textbf{6}] \textbf{Objektorientierte Programmierung}
\item[\textbf{7}] \textbf{Datenstrukturen}
\vspace*{-1cm}
\end{itemize}
\end{frame}
\setcounter{section}{3}
\section{Hardwarenahe Programmierung}
\setcounter{subsection}{1}
\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
\item[4.2] I/O-Ports
\color{medgreen}
\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}
\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}
\section{Algorithmen}
\subsection{Differentialgleichungen}
\begin{frame}[fragile]
\showsection
\showsubsection
\textbf{Beispiel 1: Gleichmäßig beschleunigte Bewegung}
\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<2->{\hfill$\Rightarrow$\hfill}%
\begin{onlyenv}<2-8>
\begin{minipage}{8.3cm}
\begin{align*}
x(t) &= \int v_x(t)\,dt
\visible<4->{= \int v_{0x}\,dt}
\visible<5->{= x_0 + v_{0x}\cdot t}\\[\medskipamount]
y(t) &= \int v_y(t)\,dt
\visible<7->{= \int v_{0y} - g\cdot t\,dt}
\visible<8->{= y_0 + v_{0y}\cdot t
- {\textstyle\frac12}gt^2}\\[\bigskipamount]
v_x(t) &= \int 0\,dt
\visible<3->{= v_{0x}} \\[\medskipamount]
v_y(t) &= \int -g\,dt
\visible<6->{= v_{0y} - g\cdot t}
\end{align*}
\end{minipage}%
\end{onlyenv}%
\begin{onlyenv}<9->
\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}
\strut
\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}}
% \put(5,-1.5){\rotatebox{10}{\color{red}\bf\textarrow\ nächste Woche}}
\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}
\end{document}
20241212/hp-musterloesung-20241212.pdf 0 → 100644
+ 0
− 0
View file @ f957c776
File added
20241212/hp-musterloesung-20241212.tex 0 → 100644
+ 398
− 0
View file @ f957c776
% hp-musterloesung-20241212.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
% Copyright (C) 2013, 2015-2023, 2024 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: 8: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Kondensator
\documentclass[a4paper]{article}
\usepackage{pgscript}
\usepackage{gensymb}
\usepackage{gnuplot-lua-tikz}
\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
\newcommand{\ITWOC}{I\raisebox{0.5ex}{\normalsize 2}C}
\begin{document}
\section*{Hardwarenahe Programmierung\\
Musterlösung zu den Übungsaufgaben 8 -- 12.\ Dezember 2024}
\thispagestyle{empty}
\exercise{Trickprogrammierung}
Wir betrachten das folgende Programm (Datei: \gitfile{hp}{2024ws/20241212}{aufgabe-1.c}):
\begin{lstlisting}
#include <stdio.h>
#include <stdint.h>
int main (void)
{
uint64_t x = 4262939000843297096;
char *s = &x;
printf ("%s\n", s);
return 0;
}
\end{lstlisting}
Das Programm wird compiliert und auf einem 64-Bit-Little-Endian-Computer ausgeführt:
\begin{lstlisting}[style=terminal]
$ ¡gcc -Wall -O aufgabe-1.c -o aufgabe-1¿
aufgabe-1.c: In function `main':
aufgabe-1.c:7:13: warning: initialization from incompatible pointer type [...]
$ ¡./aufgabe-1¿
Hallo
\end{lstlisting}
\begin{itemize}
\item[(a)]
Erklären Sie die Warnung beim Compilieren. \points{2}
\item[(b)]
Erklären Sie die Ausgabe des Programms. \points{5}
\item[(c)]
Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten? \points{3}
\end{itemize}
Hinweis: Modifizieren Sie das Programm
und lassen Sie sich Speicherinhalte ausgeben.
\solution
\begin{itemize}
\item[(a)]
\textbf{Erklären Sie die Warnung beim Compilieren.}
Zeile 7 des Programms enthält eine Zuweisung von \lstinline{&x}
an die Variable \lstinline{s}.
Der Ausdruck \lstinline{&x} steht für die Speicheradresse der Variablen \lstinline{x},
ist also ein Zeiger auf \lstinline{x},
also ein Zeiger auf eine \lstinline{uint64_t}.
Die Variable \lstinline{s} hingegen ist ein Zeiger auf \lstinline{char},
also ein Zeiger auf eine viel kleinere Zahl,
also ein anderer Zeigertyp.
\item[(b)]
\textbf{Erklären Sie die Ausgabe des Programms.}
Die 64-Bit-Zahl (\lstinline{uint64_t}) \lstinline{x}
belegt 8 Speicherzellen (Bytes) von jeweils 8 Bit.
Um herauszufinden, was diese enthalten,
lassen wir uns \lstinline{x} als Hexadezimalzahl ausgeben,
z.\,B.\ mittels \lstinline{printf ("%lx\n", x)}
(auf 32-Bit-Rechnern: \lstinline{"%llx\n"})
oder mittels \lstinline{printf ("%" PRIx64 "\n", x)}
(erfordert \lstinline{#include <inttypes.h>}
-- siehe die Datei \gitfile{hp}{2024ws/20241212}{loesung-1-1.c}).
Das Ergebnis lautet:
\begin{lstlisting}[style=terminal,gobble=8]
3b29006f6c6c6148
\end{lstlisting}
Auf einzelne Bytes verteilt:
\begin{lstlisting}[style=terminal,gobble=8]
3b 29 00 6f 6c 6c 61 48
\end{lstlisting}
Auf einem Little-Endian-Rechner
ist die Reihenfolge der Bytes in den Speicherzellen genau umgekehrt:
\begin{lstlisting}[style=terminal,gobble=8]
48 61 6c 6c 6f 00 29 3b
\end{lstlisting}
Wenn wir uns diese Bytes als Zeichen ausgeben lassen
(\lstinline{printf()} mit \lstinline{%c} -- siehe die Datei \gitfile{hp}{2024ws/20241212}{loesung-1-2.c}),
erhalten wir:
\begin{lstlisting}[style=terminal,gobble=8]
H a l l o ) ;
\end{lstlisting}
Das Zeichen hinter "`Hallo"' ist ein Null-Symbol (Zahlenwert 0)
und wird von \lstinline{printf ("%s")} als Ende des Strings erkannt.
Damit ist die Ausgabe \lstinline[style=terminal]{Hallo}
des Programms erklärt.
\goodbreak
\item[(c)]
\textbf{Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten?}
Auf einem Big-Endian-Computer (egal, wieviele Bits die Prozessorregister haben)
ist die Reihenfolge der Bytes in den Speicherzellen genau umgekehrt
wie auf einem Little-Endian-Computer, hier also:
\begin{lstlisting}[style=terminal,gobble=8]
3b 29 00 6f 6c 6c 61 48
\end{lstlisting}
\lstinline{printf ("%s")} gibt in diesem Fall die Hexadezimalzahlen
\lstinline[style=terminal]{3b} und \lstinline[style=terminal]{29}
als Zeichen aus. Danach steht das String-Ende-Symbol mit Zahlenwert 0,
und die Ausgabe bricht ab.
Da, wie oben ermittelt, die Hexadezimalzahl \lstinline[style=terminal]{3b}
für das Zeichen \lstinline[style=terminal]{;}
und \lstinline[style=terminal]{29}
für das Zeichen \lstinline[style=terminal]{)} steht,
lautet somit die Ausgabe:
\begin{lstlisting}[style=terminal,gobble=8]
;)
\end{lstlisting}
Um die Aufgabe zu lösen, können Sie übrigens auch
auf einem Little-Endian-Computer (Standard-Notebook)
einen Big-Endian-Computer simulieren,
indem Sie die Reihenfolge der Bytes in der Zahl \lstinline{x} umdrehen
-- siehe die Datei \gitfile{hp}{2024ws/20241212}{loesung-1-3.c}.
\end{itemize}
\exercise{Thermometer-Baustein an \ITWOC-Bus}
Eine Firma stellt einen elektronischen Thermometer-Baustein her,
den man über die serielle Schnittstelle (RS-232) an einen PC anschließen kann,
um die Temperatur auszulesen.
Nun wird eine Variante des Thermo"-meter-Bausteins entwickelt,
die die Temperatur zusätzlich über einen \ItwoC-Bus bereitstellt.
Um das neue Thermometer zu testen, wird es in ein Gefäß mit heißem Wasser gelegt,
das langsam auf Zimmertemperatur abkühlt.
Alle 10 Minuten liest ein Programm, das auf dem PC läuft,
die gemessene Temperatur über beide Schnittstellen aus
und erzeugt daraus die folgende Tabelle:
\begin{center}
\renewcommand{\arraystretch}{1.2}
\begin{tabular}{|c|c|c|}\hline
Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
\phantom{0}0 & 94 & 122 \\\hline
10 & 47 & 244 \\\hline
20 & 30 & 120 \\\hline
30 & 24 & \phantom{0}24 \\\hline
40 & 21 & 168 \\\hline
\end{tabular}
\end{center}
\goodbreak
\begin{itemize}
\item[(a)]
Aus dem Vergleich der Meßdaten läßt sich
auf einen Fehler bei der \ItwoC-Übertragung schließen.\\
Um welchen Fehler handelt es sich,
und wie ergibt sich dies aus den Meßdaten?
\points{5}
\item[(b)]
Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.
\points{5}
\end{itemize}
\solution
\begin{itemize}
\item[(a)]
\textbf{Aus dem Vergleich der Meßdaten läßt sich
auf einen Fehler bei der \ItwoC-Übertragung schließen.
Um welchen Fehler handelt es sich,
und wie ergibt sich dies aus den Meßdaten?}
Sowohl RS-232 als auch \ItwoC\ übertragen die Daten Bit für Bit.
Für die Fehlersuche ist es daher sinnvoll,
die Meßwerte als Binärzahlen zu betrachten:
\begin{center}
\renewcommand{\arraystretch}{1.2}
\begin{tabular}{|c|c|c|}\hline
Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
\phantom{0}0 & 94$_{10}$ = 01011110$_2$ & 122$_{10}$ = 01111010$_2$ \\\hline
10 & 47$_{10}$ = 00101111$_2$ & 244$_{10}$ = 11110100$_2$ \\\hline
20 & 30$_{10}$ = 00011110$_2$ & 120$_{10}$ = 01111000$_2$ \\\hline
30 & 24$_{10}$ = 00011000$_2$ & \phantom{0}24$_{10}$ = 00011000$_2$ \\\hline
40 & 21$_{10}$ = 00010101$_2$ & 168$_{10}$ = 10101000$_2$ \\\hline
\end{tabular}
\end{center}
Man erkennt, daß die Reihenfolge der Bits in den (fehlerhaften) \ItwoC-Meßwerten
genau die umgekehrte Reihenfolge der Bits in den (korrekten) RS-232-Mewßwerten ist.
Der Übertragungsfehler besteht also darin,
daß die Bits in der falschen Reihenfolge übertragen wurden.
Dies paßt gut damit zusammen,
daß die Bit-Reihenfolge von \ItwoC\ \emph{MSB First}, die von RS-232 hingegen \emph{LSB First\/} ist.
Offenbar haben die Entwickler der \ItwoC-Schnittstelle dies übersehen
und die \ItwoC-Daten ebenfalls \emph{LSB First\/} übertragen.
\goodbreak
\item[(b)]
\textbf{Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.}
Die Aufgabe der Funktion besteht darin,
eine 8-Bit-Zahl \lstinline{data} entgegenzunehmen,
die Reihenfolge der 8 Bits genau umzudrehen
und das Ergebnis mittels \lstinline{return} zurückzugeben.
Zu diesem Zweck gehen wir die 8 Bits in einer Schleife durch
-- siehe die Datei \gitfile{hp}{2024ws/20241212}{loesung-2.c}.
Wir lassen eine Lese-Maske \lstinline{mask_data} von rechts nach links
und gleichzeitig eine Schreib-Maske \lstinline{mask_result}
von links nach rechts wandern.
Immer wenn die Lese-Maske in \lstinline{data} eine 1 findet,
schreibt die Schreib-Maske diese in die Ergebnisvariable \lstinline{result}.
Da \lstinline{result} auf 0 initialisiert wurde,
brauchen wir Nullen nicht hineinzuschreiben.
Ansonsten wäre dies mit \lstinline{result &= ~mask_result} möglich.
Um die Schleife bis 8 zählen zu lassen,
könnte man eine weitere Zähler-Variable von 0 bis 7 zählen lassen,
z.\,B.\ \lstinline{for (int i = 0; i < 8; i++)}.
Dies ist jedoch nicht nötig, wenn man beachtet,
daß die Masken den Wert 0 annehmen,
sobald das Bit aus der 8-Bit-Variablen herausgeschoben wurde.
In \gitfile{hp}{2024ws/20241212}{loesung-2.c} wird \lstinline{mask_data} auf 0 geprüft;
genausogut könnte man auch \lstinline{mask_result} prüfen.
Das \lstinline{return result} ist notwendig.
Eine Ausgabe des Ergebnisses per \lstinline{printf()} o.\,ä.\
erfüllt \emph{nicht\/} die Aufgabenstellung.
(In \gitfile{hp}{2024ws/20241212}{loesung-2.c} erfolgt entsprechend \lstinline{printf()}
nur im Testprogramm \lstinline{main()}.)
\end{itemize}
\exercise{Kondensator}
Ein Kondensator der Kapazität $C = 100\,{\rm\mbox{\rm\textmu}F}$
ist auf die Spannung $U_0 = 5\,{\rm V}$ aufgeladen
und wird über einen Widerstand $R = 33\,{\rm k}\Omega$ entladen.
\begin{enumerate}[(a)]
\item
Schreiben Sie ein C-Programm, das
den zeitlichen Spannungsverlauf in einer Tabelle darstellt.
\points{5}
\item
Schreiben Sie ein C-Programm, das ermittelt,
wie lange es dauert, bis die Spannung unter $0.1\,{\rm V}$ gefallen ist.
\points{4}
\item
Vergleichen Sie die berechneten Werte mit der exakten theoretischen Entladekurve:
\begin{math}
U(t) = U_0 \cdot e^{-\frac{t}{RC}}
\end{math}\\
\points{3}
\end{enumerate}
Hinweise:
\begin{itemize}
\item
Für die Simulation zerlegen wir den Entladevorgang in kurze Zeitintervalle $dt$.
Innerhalb jedes Zeitintervalls betrachten wir den Strom $I$ als konstant
und berechnen, wieviel Ladung $Q$ innerhalb des Zeitintervalls
aus dem Kondensator herausfließt.
Aus der neuen Ladung berechnen wir die Spannung am Ende des Zeitintervalls.
\item
Für den Vergleich mit der exakten theoretischen Entladekurve
benötigen Sie die Exponentialfunktion \lstinline{exp()}.
Diese finden Sie in der Mathematik-Bibliothek:
\lstinline{#include <math.h>} im Quelltext,
beim \lstinline[style=cmd]{gcc}-Aufruf \lstinline[style=cmd]{-lm} mit angeben.
\item
$Q = C \cdot U$,\quad $U = R \cdot I$,\quad $I = \frac{dQ}{dt}$
\end{itemize}
\solution
\begin{itemize}
\item
\textbf{Schreiben Sie ein C-Programm, das
den zeitlichen Spannungsverlauf in einer Tabelle darstellt.}
In dem Programm \gitfile{hp}{2024ws/20241212}{loesung-3a.c}
arbeiten wir, dem ersten Hinweis folgend,
mit einem Zeitintervall von \lstinline{dt = 0.01}.
Mit dieser Schrittweite lassen wir uns eine Tabelle ausgeben,
die jeweils die Zeit und durch die Simulation berechnete Spannung ausgibt.
Wir simulieren, wie die Ladung $Q = C \cdot U$ des Kondensators
im Laufe der Zeit abfließt.
Dazu berechnen wir in jedem Zeitschritt zunächst den Strom $I = U / R$,
der aus dem Kondensator fließt.
Dieser Strom bewirkt, daß innerhalb des Zeitintervalls $dt$
die Ladung $dQ = I \cdot dt$ aus dem Kondensator abfließt.
Am Ende des Zeitintervalls berechnen wir die zur neuen Ladung $Q$
gehörende neue Spannung $U = Q / C$.
Für eine einfache Ausgabe der Tabelle
verwenden wir die Formatspezifikationen \lstinline{%10.3lf} für drei
bzw.\ \lstinline{%15.8lf} für acht Nachkommastellen Genauigkeit.
Damit schreiben wir jeweils eine \emph{lange Fließkommazahl\/} (\lstinline{%lf})
rechtsbündig in ein Feld der Breite 10 bzw.\ 15
und lassen uns 3 bzw.\ 8 Nachkommastellen ausgeben.
Wir compilieren das Programm mit:
\lstinline[style=cmd]{gcc -Wall -O loesung-1a.c -o loesung-1a}
\item
\textbf{Schreiben Sie ein C-Programm, das ermittelt,
wie lange es dauert, bis die Spannung unter \boldmath $0.1\,{\rm V}$ gefallen ist.}
Wir ändern das Programm \gitfile{hp}{2024ws/20241212}{loesung-3a.c} so ab,
daß zum einen die Schleife abbricht, sobald die Spannung
den Wert $0.1\,{\rm V}$ unterschreitet (\gitfile{hp}{2024ws/20241212}{loesung-3b.c}),
und daß zum anderen nicht jedesmal eine Zeile für die Tabelle ausgegeben wird,
sondern erst am Ende die Zeit (und die Spannung).
Der Ausgabe entnehmen wir, daß die Spannung bei etwa $t = 12.90\,{\rm s}$
den Wert $0.1\,{\rm V}$ unterschreitet.
\item
\textbf{Vergleichen Sie die berechneten Werte
mit der exakten theoretischen Entladekurve:\\[0.5\smallskipamount]
\boldmath
\begin{math}
U(t) = U_0 \cdot e^{-\frac{t}{RC}}
\end{math}}
Wir ändern das Programm \gitfile{hp}{2024ws/20241212}{loesung-3a.c} so ab,
daß es zusätzlich zur Zeit und zur simulierten Spannung
die exakte Spannung $U_0 \cdot e^{-\frac{t}{RC}}$
gemäß der theoretischen Entladekurve ausgibt (\gitfile{hp}{2024ws/20241212}{loesung-3c.c}),
Da dieses Programm die Exponentialfunktion verwendet, müssen wir nun
beim Compilieren zusätzlich \lstinline[style=cmd]{-lm}\hspace{1pt}
für das Einbinden der Mathematik-Bibliothek angeben.
Der erweiterten Tabelle können wir entnehmen,
daß die durch die Simulation berechnete Spannung
mit der Spannung $U_0 \cdot e^{-\frac{t}{RC}}$
gemäß der theoretischen Entladekurve
bis auf wenige Prozent übereinstimmt.
Dies ist für viele praktische Anwendungen ausreichend,
wenn auch nicht für Präzisionsmessungen.
Wenn Sie die Ausgabe des Programms, z.\,B.\ mit
\lstinline[style=cmd]{./loesung-1c > loesung-1c.dat},
in einer Datei \gitfile{hp}{2024ws/20241212}{loesung-3c.dat} speichern,
können Sie sich die beiden Kurven graphisch darstellen lassen,
z.\,B.\ mit \file{gnuplot} und dem folgenden Befehl:
\begin{lstlisting}[style=cmd,gobble=8]
plot "loesung-1c.dat" using 1:2 with lines title "Simulation",
"loesung-1c.dat" using 1:3 with lines title "Theorie"
\end{lstlisting}
\vspace*{-\bigskipamount}
\begin{center}
\input{loesung-3c.tikz}
\end{center}
Der Unterschied zwischen der simulierten und der theoretischen Entladungskurve
ist mit bloßem Auge nicht sichtbar.
\end{itemize}
\end{document}
20241212/hp-uebung-20241212.pdf 0 → 100644
+ 0
− 0
View file @ f957c776
File added
20241212/hp-uebung-20241212.tex 0 → 100644
+ 172
− 0
View file @ f957c776
% hp-uebung-20241205.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
% Copyright (C) 2013, 2015-2023, 2024 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: 8: Trickprogrammierung, Thermometer-Baustein an I²C-Bus, Kondensator
\documentclass[a4paper]{article}
\usepackage{pgscript}
\usepackage{gensymb}
\newcommand{\ItwoC}{I\raisebox{0.5ex}{\footnotesize 2}C}
\newcommand{\ITWOC}{I\raisebox{0.5ex}{\normalsize 2}C}
\begin{document}
\section*{Hardwarenahe Programmierung\\
Übungsaufgaben 8 -- 12.\ Dezember 2024}
Diese Übung enthält Punkteangaben wie in einer Klausur.
Um zu "`bestehen"', müssen Sie innerhalb von 90 Minuten
unter Verwendung ausschließlich zugelassener Hilfsmittel
16 Punkte (von insgesamt \totalpoints) erreichen.
% \thispagestyle{empty}
\exercise{Trickprogrammierung}
Wir betrachten das folgende Programm (Datei: \gitfile{hp}{2024ws/20241212}{aufgabe-1.c}):
\begin{lstlisting}
#include <stdio.h>
#include <stdint.h>
int main (void)
{
uint64_t x = 4262939000843297096;
char *s = &x;
printf ("%s\n", s);
return 0;
}
\end{lstlisting}
Das Programm wird compiliert und auf einem 64-Bit-Little-Endian-Computer ausgeführt:
\begin{lstlisting}[style=terminal]
$ ¡gcc -Wall -O aufgabe-1.c -o aufgabe-1¿
aufgabe-1.c: In function `main':
aufgabe-1.c:7:13: warning: initialization from incompatible pointer type [...]
$ ¡./aufgabe-1¿
Hallo
\end{lstlisting}
\begin{itemize}
\item[(a)]
Erklären Sie die Warnung beim Compilieren. \points{2}
\item[(b)]
Erklären Sie die Ausgabe des Programms. \points{5}
\item[(c)]
Wie würde die Ausgabe des Programms auf einem 64-Bit-Big-Endian-Computer lauten? \points{3}
\end{itemize}
Hinweis: Modifizieren Sie das Programm
und lassen Sie sich Speicherinhalte ausgeben.
\exercise{Thermometer-Baustein an \ITWOC-Bus}
Eine Firma stellt einen elektronischen Thermometer-Baustein her,
den man über die serielle Schnittstelle (RS-232) an einen PC anschließen kann,
um die Temperatur auszulesen.
Nun wird eine Variante des Thermo"-meter-Bausteins entwickelt,
die die Temperatur zusätzlich über einen \ItwoC-Bus bereitstellt.
Um das neue Thermometer zu testen, wird es in ein Gefäß mit heißem Wasser gelegt,
das langsam auf Zimmertemperatur abkühlt.
Alle 10 Minuten liest ein Programm, das auf dem PC läuft,
die gemessene Temperatur über beide Schnittstellen aus
und erzeugt daraus die folgende Tabelle:
\begin{center}
\renewcommand{\arraystretch}{1.2}
\begin{tabular}{|c|c|c|}\hline
Zeit /\,min. & Temperatur per RS-232 /\,\degree C & Temperatur per \ItwoC\ /\,\degree C \\\hline\hline
\phantom{0}0 & 94 & 122 \\\hline
10 & 47 & 244 \\\hline
20 & 30 & 120 \\\hline
30 & 24 & \phantom{0}24 \\\hline
40 & 21 & 168 \\\hline
\end{tabular}
\end{center}
\goodbreak
\begin{itemize}
\item[(a)]
Aus dem Vergleich der Meßdaten läßt sich
auf einen Fehler bei der \ItwoC-Übertragung schließen.\\
Um welchen Fehler handelt es sich,
und wie ergibt sich dies aus den Meßdaten?
\points{5}
\item[(b)]
Schreiben Sie eine C-Funktion \lstinline{uint8_t repair (uint8_t data)},
die eine über den \ItwoC-Bus empfangene fehlerhafte Temperatur \lstinline{data} korrigiert.
\points{5}
\end{itemize}
\exercise{Kondensator}
Ein Kondensator der Kapazität $C = 100\,{\rm\mbox{\rm\textmu}F}$
ist auf die Spannung $U_0 = 5\,{\rm V}$ aufgeladen
und wird über einen Widerstand $R = 33\,{\rm k}\Omega$ entladen.
\begin{enumerate}[(a)]
\item
Schreiben Sie ein C-Programm, das
den zeitlichen Spannungsverlauf in einer Tabelle darstellt.
\points{5}
\item
Schreiben Sie ein C-Programm, das ermittelt,
wie lange es dauert, bis die Spannung unter $0.1\,{\rm V}$ gefallen ist.
\points{4}
\item
Vergleichen Sie die berechneten Werte mit der exakten theoretischen Entladekurve:
\begin{math}
U(t) = U_0 \cdot e^{-\frac{t}{RC}}
\end{math}\\
\points{3}
\end{enumerate}
Hinweise:
\begin{itemize}
\item
Für die Simulation zerlegen wir den Entladevorgang in kurze Zeitintervalle $dt$.
Innerhalb jedes Zeitintervalls betrachten wir den Strom $I$ als konstant
und berechnen, wieviel Ladung $Q$ innerhalb des Zeitintervalls
aus dem Kondensator herausfließt.
Aus der neuen Ladung berechnen wir die Spannung am Ende des Zeitintervalls.
\item
Für den Vergleich mit der exakten theoretischen Entladekurve
benötigen Sie die Exponentialfunktion \lstinline{exp()}.
Diese finden Sie in der Mathematik-Bibliothek:
\lstinline{#include <math.h>} im Quelltext,
beim \lstinline[style=cmd]{gcc}-Aufruf \lstinline[style=cmd]{-lm} mit angeben.
\item
$Q = C \cdot U$,\quad $U = R \cdot I$,\quad $I = \frac{dQ}{dt}$
\end{itemize}
\bigskip
\begin{flushright}
\textit{Viel Erfolg!}
\end{flushright}
\makeatletter
\immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
\makeatother
\end{document}
20241212/io-ports-and-interrupts.pdf 0 → 120000
+ 1
− 0
View file @ f957c776
../common/io-ports-and-interrupts.pdf
\ No newline at end of file
20241212/loesung-1-1.c 0 → 100644
+ 13
− 0
View file @ f957c776
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main (void)
{
uint64_t x = 4262939000843297096;
char *s = &x;
printf ("%lx\n", x);
printf ("%" PRIx64 "\n", x);
printf ("%s\n", s);
return 0;
}
20241212/loesung-1-2.c 0 → 100644
+ 15
− 0
View file @ f957c776
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main (void)
{
uint64_t x = 4262939000843297096;
char *s = &x;
printf ("%lx\n", x);
printf ("%" PRIx64 "\n", x);
printf ("%c %c %c %c %c %c %c %c\n",
0x48, 0x61, 0x6c, 0x6c, 0x6f, 0x00, 0x29, 0x3b);
printf ("%s\n", s);
return 0;
}
20241212/loesung-1-3.c 0 → 100644
+ 11
− 0
View file @ f957c776
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
int main (void)
{
uint64_t x = 0x48616c6c6f00293b;
char *s = &x;
printf ("%s\n", s);
return 0;
}
20241212/loesung-2.c 0 → 100644
+ 26
− 0
View file @ f957c776
#include <stdio.h>
#include <stdint.h>
uint8_t repair (uint8_t data)
{
uint8_t result = 0;
uint8_t mask_data = 0x01;
uint8_t mask_result = 0x80;
while (mask_data)
{
if (data & mask_data)
result |= mask_result;
mask_data <<= 1;
mask_result >>= 1;
}
return result;
}
int main (void)
{
int data[] = { 122, 244, 120, 24, 168, -1 };
int i = 0;
while (data[i] >= 0)
printf ("%d\n", repair (data[i++]));
return 0;
}
20241212/loesung-3a.c 0 → 100644
+ 22
− 0
View file @ f957c776
#include <stdio.h>
#include <math.h>
int main (void)
{
double C = 0.0001;
double U0 = 5.0;
double U = U0;
double R = 33000.0;
double t = 0.0;
double dt = 0.01;
double Q = C * U;
while (U > 0.09)
{
printf ("%10.3lf%15.8lf\n", t, U);
double I = U / R;
Q -= I * dt;
U = Q / C;
t += dt;
}
return 0;
}
20241212/loesung-3b.c 0 → 100644
+ 22
− 0
View file @ f957c776
#include <stdio.h>
#include <math.h>
int main (void)
{
double C = 0.0001;
double U0 = 5.0;
double U = U0;
double R = 33000.0;
double t = 0.0;
double dt = 0.01;
double Q = C * U;
while (U >= 0.1)
{
double I = U / R;
Q -= I * dt;
U = Q / C;
t += dt;
}
printf ("%10.3lf%15.8lf\n", t, U);
return 0;
}
20241212/loesung-3c.c 0 → 100644
+ 22
− 0
View file @ f957c776
#include <stdio.h>
#include <math.h>
int main (void)
{
double C = 0.0001;
double U0 = 5.0;
double U = U0;
double R = 33000.0;
double t = 0.0;
double dt = 0.01;
double Q = C * U;
while (U > 0.09)
{
printf ("%10.3lf%15.8lf%15.8lf\n", t, U, U0 * exp (-t / (R * C)));
double I = U / R;
Q -= I * dt;
U = Q / C;
t += dt;
}
return 0;
}
20241212/loesung-3c.dat 0 → 100644
+ 1324
− 0
View file @ f957c776
This diff is collapsed.
20241212/loesung-3c.tikz 0 → 100644
+ 521
− 0
View file @ f957c776
This diff is collapsed.
20241212/logo-hochschule-bochum-cvh-text-v2.pdf 0 → 120000
+ 1
− 0
View file @ f957c776
../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
20241212/logo-hochschule-bochum.pdf 0 → 120000
+ 1
− 0
View file @ f957c776
../common/logo-hochschule-bochum.pdf
\ No newline at end of file
20241212/pendulum.pdf 0 → 120000
+ 1
− 0
View file @ f957c776
../common/pendulum.pdf
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

Impressum Datenschutzerklärung