Dies möchte ich in dieser Folge nun nachholen.

In der Funktion Eingabe() steht uns lediglich die Schachtnummer, in der eine Münze eingeworfen wurde, zu Verfügung. Mit Hilfe dieser Schachtnummer muss nun das entsprechende Portbit – und zwar nur dieses Portbit ! – zurückgesetzt werden.

Bitweises Löschen des Portbits

In der Folge über die Bitweise Manipulation also das Bitweise Setzen und Löschen des Ports habe ich ja bereits den Mechanismus vorgestellt, wie man mit dem Operator & einzelne Bits zurücksetzen kann.

Die Maske hierfür müssen wir uns mit der Information über die Schachtnummer nun selbst zusammenbauen.

Der SHIFT-Operator

Wie bereits in der letzten Folge vorbereitet, kann man dies mit dem SHIFT-Operator << prima machen. In dem heutigen Video zeige ich, wie man das gewünschte Bitmuster zusammenstellen kann.

Hierzu kann man einfach eine 1 (binär gedacht als 00000001) soweit wie gewünscht nach links schieben. Man erhält 1 Byte mit 0, bei dem nur an der gewünschten Stelle eine 1 steht. Zieht man diesen Wert anschließend von einer 0xFF (binär gedacht 11111111) ab, erhält man die gewünschte Maske, z.B. 11111101.

Mit Hilfe dieser Maske kann man dann, wie in der Folge zur Bitweise Manipulation,  also das Bitweise Setzen und Löschen des Ports, gezeigt, das gewünschte Portbit zurückzusetzen. Alle anderen Portbits werden nicht verändert.

Noch einfacher durch das Bitweise Invertieren

Am Ende des Videos zeige ich noch, wie man die Maske noch eleganter zusammenstellen kann. Durch das Bitweise Invertieren der „geschifteten 1“ lässt sich die Maske sehr einfach erstellen.

Die Details im folgenden Video:

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Sommerpause

Mit diesem Artikel möchte ich eine Sommerpause beim Mikrocontroller-Kurs einlegen.

Wenn Du bis zu dieser Folge dem Kurs aufmerksam gefolgt bist und die Übungen gelöst hast, dann hast Du Dir auch eine Pause, vor allem bei diesem Wetter , mehr als verdient.

Sollte es Dir aber zu langweilig werden, empfehle ich die Programmierung des Kaffeeautomaten noch einmal von Anfang an selbständig zu programmieren.

Programmieren lernt man durch Programmieren. Sehr wichtig ist also das eigenständige Programmiren.

Sicher fallen Dir an der einen oder anderen Stelle auch noch Verbesserungsmöglichkeiten ein, die Du evtl. schon selbst umsetzen kannst, oder die wir nach den Sommerferien gemeinsam umsetzen können.

Bis dahin wünsche ich Dir auch einen schönen, sonnigen Sommer!

Wenn Du Dich bereits auf den Email-Verteil gesetzt hast, erhälst Du automatische eine Email, wenn es wieder los geht.

Falls nicht, trage, wenn Du möchtest, Deine Email Adresse in das folgende Feld ein.

Anschließend erhältst Du dann automatisch eine Email, wenn es wieder losgeht. In jeder Email befindet sich ein Link, mit dem Du Dich auch einfach wieder abmelden kannst.

Die Teilnehmerzahl beträgt zur Zeit:

Wichtig:

Deine EMail-Adresse behandle ich natürlich vertraulich und gebe diese an niemanden weiter. Zudem kannst Du Dich jederzeit durch einen Klick auf den Abmeldelink in einer der Emails einfach wieder abmelden.

Mit einem Array kann man eine Struktur von Daten gleichen Typs sehr geschickt speichern.

Auf die einzelnen Feld des Arrays kann dann sehr elegant über den geeigneten Index zugegriffen werden.

Deine Aufgabe aus der letzten Woche war es, ein Array zu nutzen, um nur einen Parameter an die Funktion Eingabe zu übergeben.

In dem Array

int Schacht[8]

sind die 8 möglichen Zahlenwerte einer europäischen Münze gespeichert. Da sich diese Information nicht ändert, muss sie nicht bei jedem Funktionsaufruf übergeben zu werden.

Das heutige Video ist in 2 Teile unterteilt.

Im ersten Teil zeige ich eine mögliche Lösung für das Auslesen des Münzwertes aus dem Array.

Im zweiten Teil des Videos geht es dann um das zurücksetzen des Portbits. Anhand der Information, in welchem Schacht eine Münze erkannt worden ist, kann ein Bitmuster errechnet werden, mit dessen Hilfe das entsprechende Portbit zurückgesetzt werden kann.

Die Lösung der Aufgabe

Im heutigen Video geht es also zunächst um eine mögliche Lösung der Aufgabe von letzter Woche.

Aus der Information, an welcher Stelle eine Münze erkannt worden ist, wird der Münzwert aus dem Array gelesen und dann zum aktuellen Betrag addiert. Damit es nicht ganz so einfach ist, habe ich alles in einer Zeile programmiert.

Der SHIFT-Operator

Nach der Addition des Münzwertes zum Gesamtbetrag muss noch das jeweilige Port-Bit zurückgesetzt werden. Wie im Video gezeigt, kann mit dem SHIFT-Operator ein Bit nach links oder rechts verschoben werden.

Deine Aufgabe für die nächste Woche ist es, den SHIFT Operator zu nutzen, um das korrekte Bit wieder auf 0 zu setzen. Wenn Du Dich nicht mehr so genau daran erinnerst, wie man einzelne Bits löscht, kann Dir der Artikel über das Setzen und Löschen von Bits innerhalb eines Bytes sicher helfen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Bei der Aufgabenstellung zur Auslagerung von Code in Funktionen habe ich ja schon angedeutet, dass man nicht unbedingt die Münzschachtnummer UND den Wert der Münze bei jedem Funktionsaufruf übergeben muss.

Wenn man weiß in welchen Münzschacht eine Münze liegt, kennt man ja auch den Wert der Münze.

Bei der ersten Lösung haben wir der Einfachheit beide Informationen an die Funktion Eingabe() übergeben und dort ausgewertet.

Im folgenden soll es darum gehen, nur die Nummer des Münzschachts zu übergeben und dann aus dieser Information, den Wert der Münze zu ermitteln.

Array

Dies lässt sich einfach über sogenannte Arrays realisieren.

In einem Array lassen sich Daten gleichen Typs in einem Feld anordnen.

Die einzelnen Daten lassen sich dann über einen fortlaufenden Index ansprechen.

Also genau das, was wir brauchen.

Beim Kaffeeautomaten lassen sich die einzelnen Münzschächte durchnummerieren. Die Zuordnung Schacht-Nummer und Münzwert lässt sich dann über ein Array realisieren.

Im Video zeige ich die

• Definition des Arrays
• die Möglichkeiten der Initialisierung
• und das Auslesen des Arrays

Nun bist Du wieder an der Reihe

Das Array soll nun verwendet werden, um die Parameterübergabe an die Funktion Eingabe zu erleichtern. Es soll in folgenden nur noch der Index des Schachtes [0 ... 7] übergeben werden.

In der Funktion Eingabe() soll dann der korrekte Münzwert über das Array ermittelt werden und der Gesamtbetrag entsprechend erhöht werden.

Das Zurücksetzen des Ports ist nun etwas schwieriger, weil wir die Schachtnummer als Index von 0 bis 7 und nicht mehr als binärcodiertes Portbit zur Verfügung haben.

Kümmere Dich also noch nicht um das Zurücksetzen des Ports. Dies wird Inhalt des nächsten Artikels sein.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Wie immer gibt es verschiedene Möglichkeiten die Funktion zu realisieren.

Mein Vorschlag ist daher nur eine mögliche Lösung. Es gibt sicher elegantere Lösung. Vor allem der Umgang mit der Variablen Betrag lässt sich sicher noch optimieren . Nähere Information gibt es dazu Video.

Die Anforderungen an die Funktion Eingabe()

In der Funktion Eingabe sollen zwei Dinge umgesetzt werden.

1. Die Erhöhung des Gesamtbetrages um den Wert der eingeworfenen Münze und die Ausgabe des Gesamtbetrages.
2. Das Zurücksetzen des entsprechenden Portbits, damit die Münze beim nächsten Durchlauf nicht noch einmal gezählt wird.

Um die Funktion Eingabe() zu realiseren, musst Du verschiedene Dinge, die Du in den vergangenen Folgen gelernt hast umsetzen.

Zur Verwendung von Funktionen kannst Du Dir evtl, noch einmal die Videos ab Artikel 22 Funktionen in C angucken.

Auch die Videos zur Variablenzuweisung, zur if-Abfrage und zur Bitweisen Manipulation können vielleicht helfen.

Während der erste Teil, Die Erhöhung des Gesamtbetrages um den Wert der eingeworfenen Münze und die Ausgabe des Gesamtbetrages, noch verhältnismäßig einfach ist, geht es bei dem 2. Teil der Aufgabe schon ziemlich zur Sache.

Wie häufig bei Funktionen, bei denen die Ausführung abhängig von Parametern ist, ist es auch in diesem Beispiel so, dass Du bei der Programmierung der Funktion noch nicht weißt, welche Parameter übergeben werden. Du musst also die Funktion so flexibel gestalten, dass aus den übergebenen Parametern die durchzuführenden Befehle errechnet werden können.

Eine mögliche Lösung findest Du im Video.

Bis zum nächsten Mal.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Zur Erinnerung:

Der Kaffeeautomat hatte eine Münzeingabe, die alle europäischen Geldstücke vom 1 Ct Stück bis zum 2 € annimmt.

Dass dies zufällig 8 verschiedene Münzen sind, freut uns natürlich. So können wir die einzelnen Münzschächte über die Bits genau eines Bytes abfragen.

Eine mögliche Programmierung der Münzeingabe haben wir ja bereits besprochen und haben anschließend noch das Programm optimiert, so dass auch mehrere Münzen gleichzeitig bzw. schnell hintereinander eingeworfen werden können.

Das war durch das Bitweise Auslesen der Information möglich.

Schlanker Code

Das Programm funktionierte bis dahin so weit auch ganz gut. Es fällt jedoch auf, dass der Code zur Identifikation der einzelnen Münzen fast gleich ist.

Das Programm besteht daher aus sehr ähnlichen Programmteilen.

Eine ideale Voraussetzung, um diese Programmteile in eine Funktion zu integrieren und dann jeweils nur diese Funktion aufzurufen.

Im folgenden Video zeige am C-Programm, was ich damit meine.

Jetzt geht’s zur Sache

Und hier kommt Deine Aufgabe zur nächsten Woche.

Versuche die Funktion Eingabe() zu realisieren, so dass sie so flexibel ist, um mit den unterschiedlichen Münzen zurecht zu kommen. Es soll also in der Funktion Eingabe der korrekte Wert zum Betrag addiert und anschließend das zughörige Bit des Ports P1 zurückgesetzt werden.

Guck Dir zur Lösung der Aufgabe am besten noch einmal die älteren Videos zum Kaffeeautomaten und die Videos zur Verwendung von Funktionen (ab Video 22 Funktionen in C an.

Auch die Videos zur Variablenzuweisung, zur if-Abfrage und zur Bitweisen Manipulation können vielleicht helfen.

In der nächsten Folge werde ich eine mögliche Lösung vorstellen. Ich empfehle aber nicht bis dahin zu warten, sondern auf jeden Fall selbst eine Lösung zu versuchen. Durch diese Aufgabe wird vieles aus den vergangenen Artikeln wiederholt und zusammengefasst. Das ist für Dich eine ideale Möglichkeit um zu überprüfen, ob Du bis hierhin wirklich alles verstanden hast.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Zum Abschluss gab es dann im Artikel der letzten Woche eine Aufgabe. Und zwar ging es darum, mit Hilfe von Funktionen den Umfang und die Fläche eines Kreises zu berechnen.

Als drittes sollte dann anschließend noch das Volumen eines Zylinders berechnet werden, wobei bei der zu programmierenden Funktion volumen() auf die Funktion flaeche() zurückgegriffen werden sollte.

Die Berechnung der Grundfläche des Zylinders sollte also nicht in der Funktion volumen() selbst, sondern sozusagen an die Funktion flaeche delegiert werden. Also ein Aufruf einer Funktion innerhalb einer Funktion.

Um weiterhin mit Integer-Werten rechnen zu können, hatte ich für PI=3 vorgegeben – was ja zu 95% auch so stimmt

Im ersten Video zeige ich Dir heute eine mögliche Lösung der Aufgabe.

Link:

Da das Video zu lang geworden wäre, habe ich das Video heute wieder geteilt. Im zweiten Teil werde ich das Programm zunächst einmal testen und dann den Quell-Code noch etwas nachbessern.

Auf viele Variablendefinitionen des ersten Videos kann man nämlich verzichten und somit das Programm kürzen und die Nutzung des Speicherplatzes optimieren. Gerade wenn man mit dem Programmieren beginnt, ist es häufig einfach den Code ein bisschen ausführlicher als nötig zu schreiben und dann im zweiten Schritt das Programm zu kürzen.

Später, wenn man etwas mehr Erfahrung in der C-Programmierung hat, fasst man automatisch an bestimmten Stellen mehrere Befehle zusammen. Aber auch dann sollte es m.E. nicht übertreiben. Man möchte ein C-Programm ja auch ein Jahr später noch verstehen können. Zu sehr komprimierter C-Code ist aber häufig schwer zu lesen.

Link:

So, dass war zunächst einmal eine Einführung in den Bereich Funktionen. In der nächsten Folge werde ich mich wieder unserem Kaffeeautomaten zuwenden und überprüfen, an welchen Stellen wir durch den Gebrauch von Funktionen unser Programm für den Kaffeeautomaten verbessern können.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Dieses Wissen hilft nun, beim Aufruf von Funktionen. Vor allem wenn es darum geht, den aufzurufenden Funktionen Parameter zu übergeben.

Da das heutige Video etwas lang geworden wäre, habe ich es in 2 Teile aufgeteilt.

Im ersten Video zeige ich den prinzipiellen Funktionsaufruf und die Parameterübergabe sozusagen als Trockenübung.

Im zweiten Video werde ich dann wieder die Entwicklungsumgebung an und zeige den Funktionsaufruf am System.

Alles geht über den Stack

Wenn es sich vermeiden lässt, globale Variablen für die Kommunikation zwischen unterschiedlichen Funktionen zu nehmen, nutzt man lokale Variablen. Da lokale Variablen eine begrenzte Sichtbarkeit und eine begrenzte Gültigkeitsdauer haben, können Programme so besser strukturiert werden.

Die Variablen für die Parameterübergabe von Funktion zu Funktion werden also über den Stack übergeben.

Im zweiten Video zeige ich die Implementierung des Funktionsaufrufes in der Entwicklungsumgebung und, am Ende des Videos, die Deklarationen von Funktionen, wenn Parameter mit übergeben werden sollen.

Nun bist Du wieder an der Reihe …

Heute gibt es wieder – endlich – eine Hausaufgabe.

Die heutige Hausaufgabe besteht aus drei Funktionen. Und zwar sollen zum einen für einen Kreis der Umfang und der Flächeninhalt berechnet werden. Zudem soll für einen Zylinder das Volumen berechnet werden.

Radius und Höhe sollen über den PORT 1 (Radius) und PORT 2(Höhe) eingegeben werden können. Der Einfachheit halber soll alles in der Grundeinheit m angegeben werden.

Die Besonderheit bei der Berechnung des Volumens für den Zylinder besteht darin, dass zur Berechnung der Grundfläche des Zylinders die vorher definierte Funktion genutzt werden soll.

Also:

Programmiere die Funktionen

• int umfang (int radius)

• int flaeche (int radius)

• int volumen(int radius, int hoehe)

wobei in der Funktion volumen() die Funktion flaeche() genutzt werden soll.

Zu Beginn von main() sollen radius und hoehe über die Ports P1 und P2 eingelesen werden.

Am Ende von main sollen Umfang, Fläche und Volumen ausgegeben werden.

Hinweis:
Für unsere Übung reichen grobe Werte. Wir nehmen für PI = 3

Und zur Erinnerung ein paar Formeln:

• U=2*PI*radius

• A=Pi*radius²

• V=A*hoehe

Bis zum nächsten Mal!

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

In einem der vergangenen Artikel habe ich ja schon gezeigt, welche Variablen es in der Programmiersprache C gibt.

Beim Umgang mit Variablen und Funktionen stellt sich häufig die Frage, auf welche Variablen kann eine Funktion zugreifen, mit welchen Variablen kann eine Funktion arbeiten.

Wozu Gültigkeitsbereiche

Häufig möchte man gar nicht, dass jede Variable von jeder Funktion änderbar ist. Stell Dir vor mehrere Programmierer arbeiten an einem Projekt und müssten sich einigen, wer denn seine Inter-Variable „i“ nennen darf.

Oder noch schlimmer: Man nutzt Funktionen aus einem anderen Projekt und müsste bevor man selbst programmiert, alle Programme durchforsten ob die Variable „Wert“ schon einmal genutzt worden ist.

Um dies zu verhindern unterscheidet man zwischen globalen Variablen, die global, also im gesamten Programm gelten und lokalen Variablen, die einen beschränkten Gültigkeitsbereich haben.

Speicherorte von Variablen

Welche Variablen global sind und welche lokal sind, versteht man am besten, wenn man sich einmal anguckt, in welche Speicherbereiche die Variablen vom Compiler/Linker bzw. vom Mikrocontroller abgelegt werden.

Globale Variablen kann der Compiler bei der Erstellung des Programms in den Datenbereich ablegen. Bei lokalen Variablen ist bei der Übersetzung des Programms nicht bekannt, wie häufig (oder ob überhaupt) diese Variablen benötigt werden.

Im folgenden Video zeige ich daher zunächst, wie der Compiler bzw. während der Ausführung der Mikrocontroller Variablen behandelt.

Nachdem Du nun gesehen hast, wo Compiler und Mikrocontroller die Variablen verwalten, möchte ich im nächsten Video einige Beispiele zeigen.

Am besten ist nun, Du rufst auf Deinem PC die Entwicklungsumgebung auf und testet selbst einmal die Gültigkeitsbereiche von Variablen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Nachdem ich also in der letzten Folge schon einmal kurz die prinzipielle Verwendung von Funktion angesprochen habe, möchte ich mit der heutigen Folge beginnen, etwas tiefer in das Thema Funktionen in C einzusteigen.

Definition und Deklaration

Konkret soll es heute um das Thema Definition und Deklarationen von Funktionen in C gehen. Um die Verwendung von Funktionen zu verstehen ist es hilfreich ein wenig über die Arbeitsweise eines Compilers zu verstehen.

Das prinzipielle Vorgehen beim Übersetzen eines Programms hatte ich zu Beginn des Kurs schon vorgestellt. Wenn Du Dich nicht mehr genau erinnerst, könnte diese Folge interessant sein, ich der ich die Zusammenarbeit von Compiler und Linker kurz zeige.

Im heutigen Video zeige ich zunächst noch einmal, wie Funktionen sich gegenseitig aufrufen können und demonstriere dann mit dem Emulator, die Probleme bei der Definition von Funktionen und die Lösung mit Hilfe der Deklaration von Funktionen.

Hier zunächst das heutige Video.

/*——————————————————————————
 HELLO.C

 Copyright 1995-2005 Keil Software, Inc.
 ——————————————————————————*/

 #include <REG52.H>               
  #include <stdio.h>               
 /*————————————————
 The main C function.  Program execution starts
 here after stack initialization.
 ————————————————*/

void funk1(void); // Deklaration von funk1
void funk2(void); // Deklaration von funk2

void main (void) {

 /*————————————————
 Setup the serial port for 1200 baud at 16MHz.
 ————————————————*/
 #ifndef MONITOR51
 SCON  = 0x50;              
 TMOD |= 0x20;              
 TH1   = 221;               
 TR1   = 1;                                           
 TI    = 1;                 
 #endif

 /*————————————————
 Note that an embedded program never exits (because
 there is no operating system to return to).  It
 must loop and execute forever.
 ————————————————*/

printf("In main()\n");

while(1)
{

}

}    //end main

Zusammengefasst

In der Definition einer Funktion wird genau festgelegt, wie eine Funktion aufgebaut ist, welche Parameter sie übergeben bekommt und welchen Wert sie an die aufrufende Funktion zurückgibt.

Eine Deklaration gibt dem Compiler Informationen darüber, dass eine bestimmte Funktion existiert und welche Parameter sie erwartet und welchen Wert sie zurückgibt. Die Deklaration einer Funktion hilft dem Compiler beim weiteren Übersetzen des Programms.

Häufig werden Deklarationen von Funktionen in sogenannten Header-Dateien ausgelagert und dann im Quellcode über den #include-Befehl eingebettet. Dies erhöht bei größeren Programmen die Übersichtlichkeit.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Für unseren Kaffeeautomaten wird beispielsweise bei der Auswertung des Geldeinwurfs jedes Mal zunächst überprüft, ob der Restbetrag noch ausreicht, eine passende Meldung ausgegeben, ggf. das Getränk ausgegeben und der Betrag entsprechend belastet.

Den Code für diese Befehlfolge muss man, wenn man eine Funktion hierfür schreibt, nur einmal programmieren (und im Speicher des Mikrocontrollers ablegen) und diese Funktion dann bei der Wahl eines Getränks aufrufen.

Wir habe in unserem Beispiel zwar nur 3 Getränke zur Auswahl um die Anwendung übersichtlich zu halten.

Welche Einsparung man bei 20 Getränken erhielte kann man sich aber leicht vorstellen.

2 Vorteile von Funktionen

1. Das Programm wird durch Funktionen strukturierter.
   Wenn zur Verwendung einer Befehlsfolge eine Funktion genutzt wird und die Befehlfolge dann anschließend doch noch geändert werden soll, dann muss man diese Änderung nur einmal vornehmen – eben in dieser Funktion.
2. Das Programm wird kleiner.
   Mikrocontroller-Steuerungen sind häufig mit relativ wenig Speicher ausgestattet. Diesen Speicher muss man effektiv nutzen. Auch unser Emulator hat eine Beschränkung des Speichers, und zwar auf 2K Programmspeicher. Mit unseren derzeitigen Programmen stoßen wir schon knapp an diese Grenze.

Was sind Funktionen

Eine Funktionen, die wir schon kennen, ist die Funktion main(), die direkt zu Beginn vom Mikrocontroller aufgerufen wird.

Weiter Funktionen können definiert und dann innerhalb von main() aufgerufen werden.

In dem Video zeige ich, wie man Funktionen definiert, sie dann aufruft und wie man Parameter übergibt und Rückgabewerte zurückgibt und auswertet.

Das Video

Schau Dir zunächst einmal das Video an. Hier geht es zunächst einmal um eine grobe Einordnung des Themas Funktionen.

Jetzt bist Du wieder an der Reihe.

Die „Hausaufgabe“ ist dieses Mal etwas lose definiert.

Versuche einmal mit diesen Funktionen etwas herum zu experimentieren. Bau also zunächst einmal das Beispiel nach.

Vielleicht fallen Dir ähnliche Aufgabenstellungen ein, die Du mit Funktionen realisieren kannst. An der einen oder anderen Stelle wirst Du wahrscheinlich auf Probleme stoßen, die wir hier noch nicht behandelt haben.

Das stört jedoch nicht – im Gegenteil. Das könnte Dir helfen beim Verständnis helfen, wenn es in den nächsten Folgen um die Feinheiten beim Gebrauch von Funktionen geht.