MCK 1.1 Die blinkende LED (Beginn des praktischen Teils)

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Die blinkende LED. Hier beginnt der praktische Teil des Mikrocontrollerkurses
    In den meisten Fällen ist die blinkende Leuchtdiode wohl die obligatorisch erste Übung, wenn es um den Einstieg in die Programmierung von Mikrocontrollern geht. Auch wenn manch alter Hase dies wohlwollend belächelt, bringt sie den Einsteiger schon einen Riesenschritt näher an sein Ziel, den Umgang mit Mikrocontrollern zu verstehen. Ein- und derselbe Effekt kann bereits hier aufunterschiedliche Weise umgesetzt werden und das "Spielen" mit den Blinkzeiten zeigt bereits eine der Stärken der Mikrocontrollerverwendung.

    Aber die alten Hasen sind hier nicht das Thema, womit wir uns jetzt den Anfängern zuwenden. Elektrische Blinkgeber haben eine lange Tradition, weil ein unterbrochenes Signal wesentlich mehr Aufmerksamkeit erregt, als ein konstant vorhandenes Ereignis. Angefangen bei motorbetriebenen Nockenschaltwerken über Bimetallblinker, Transistorblinker (astabile Kippschaltung) und Lösungen mit (speziellen) Integrierten Schaltkreisen (Timer- IC 555) wurde die Umsetzung ständig vereinfacht. Unsere Mikrokontroller treiben die Bauteilersparnis (was die Außenbeschaltung angeht) jedoch auf dieSpitze. Ein kleiner Attiny 13 im DIP8- Gehäuse benötigt eigentlich nur noch die Lichtquelle selbst, um einen Blinker umzusetzen. Auf unserem Experimentierboard verwenden wir allerdings Leuchtdioden, sodass zusätzlich noch ein Vorwiderstand verwendet wird, der den Strom durch die LED auf ein Maß reduziert, welches diese nicht zerstört. Alle anderen Bauteile auf unserem Experimentierboard sind für unsere ersten Programme folglich ohne Bedeutung.

    Einstellungen auf unserer Experimentierplatine



    Ein Blick auf unsere Experimentierplatine zeigt uns die verwendeten Teile. Für unser erstes Experiment benötigen wir lediglich eine Leuchtdiode. Wir wählen dafür die mittlere LED aus. Die benötigten Vorwiderstände zum Schutz der LED´s sind auf der Platine natürlich bereits vorgesehen. Für die 5 roten LED´s findet ihr diese direkt darunter. Für unsere Betriebsspannung von 5 Volt haben die Vorwiderstände für rote LED´s einen Wert von 150 Ohm.

    Da unsere Platine für spätere Versuche "umprogrammiert" werden kann, müssen wir noch einen sogenannten Jumper auf der entsprechenden Stiftleiste setzen. In unserem Fall also den mittleren der 5 Jumper, so wie auf der Abbildung oben. Der Jumper bewirkt, dass der Ausgang vom Mikrocontroller mit der roten Leuchtdiode verbunden wird und nicht mit dem Stift "C3", der sich weiter oben befindet. Wie wir in der Einleitung gelesen haben besitzt unser Controller auch wenn er nicht sehr groß ist schon mehrere Ausgänge (oder auch Eingänge). Daher müssen wir festlegen welcher Ausgang in diesem Versuch verwendet wird. Die rote LED 4, die wir mit Jumper aktiviert haben gehört zum Controllerpin PB.0. Die Bezeichnung der Portpins ist unterhalb der Jumper auf der Platine aufgedruckt. Dank derJumper brauchen wir für unser erstes Experiment keine Kabelbrücke verlegen, sodass wir jetzt mit unserem Programmieren beginnen können.


    Programm- Kopftext mit Kommentarzeilen (Header)

    Es ist eine gute Angewohnheit zu Beginn eines jeden Programms einen Kopftext (Header) aus Kommentarzeilen einzufügen. Hier ist Platz für Hinweise auf den Autor, den verwendeten Controller und externe Hardware, sowie eine Beschreibung von besonderen Anschlußbedingungen und nicht zuletzt eine kurze Beschreibung des Programms selbst.
    Man brauch sich jedoch nicht immer die Mühe zu machen, den kompletten Text stets auf´s Neue komplett zu schreiben. Ich habe mir hierfür einen Vorlagetext angelegt, den ich jeweils zum Projektstart lade. Dort nehme ich die gewünscten Änderungen vor und speichere diesen dann unter neuem Namen ab (unbedingt "speichern unter" verwenden, sonst ist Eure Vorlage weg!).

    Für dieses Projekt sieht mein Header folgendermaßen aus:

    '************************************************************
    ' Kleiner Mikrocontroller Einsteigerkurs' (c) 2013/2014 ceperiga
    '---------------------------------------------------------------------------------------------------------
    ' Projektinfos: www.bascomforum.de
    '---------------------------------------------------------------------------------------------------------
    ' Stufe 1: Attiny 13
    '---------------------------------------------------------------------------------------------------------
    ' Informationen zur CC-Lizensierung:creativecommons.org
    '============================================================
    ' Name:
    ' Unit: 1.0
    '---------------------------------------------------------------------------------------------------------
    ' Beschreibung: Erste Schritte -Eine blinkende LED an Port B.0
    '************************************************************


    Contollerangaben für unser Programm

    Als nächstes tragen wir die in der Einleitung beschriebenen Angaben zu unserem verwendeten Controller ein. In diesem Fall also für den Attiny13 mit 1,2 MHz Taktfrequenz. An dieser Stelle verlangt BASCOM die Angabe von Werten für $hwstack, $swstack, $framesize. Diese weisen spezielle Speicherbereiche zu und sind nicht ganz einfach zu erklären. Darum werden wir diese Erklärung erst zu einem späteren Zeitpunkt behandeln und nehmen die eingesetzten Werte in den Beispielprogrammen einfach als gegeben hin.

    Wir fügen also zunächst folgendes ein:

    BASCOM-Quellcode

    1. $regfile = "attiny13.dat" 'verwendeter Controller
    2. $crystal = 1200000 'Taktfrequenz
    3. $HWSTACK=6 'Stackwerte und Framesize zuweisen
    4. $SWSTACK=6
    5. $FRAMESIZE=28



    Do, Loop und End - Wichtige Bestandteile unseres Programms

    Bevor wir jetzt unser eigentliches Programm schreiben, lernen wir die ersten drei Bascombefehle kennen, die direkt auf die Programmausführung Einfluß nehmen.

    Bis auf wenige Ausnahmen ist ein Programm immer so aufgebaut, dass eine gewisse Abfolge von Befehlen der Reihe nach abgearbeitet wird. Was im eigentlichen Programm genau passiert, interessiert uns zunächst einmal nicht. Nach Abarbeitung aller Befehle springt das Programm dann wieder zu seinem Anfang und prüft im erneuten Durchlauf, ob es Änderungen gibt, die zu bearbeiten sind.


    [IMG:https://www.ceperiga.de/s/cc_images/cache_56071363.png?t=1480618065]





    Die Anfangs- und Endmarken der Programmhauptschleife haben in BASCOM einen festen Namen. Die Startmarke wird mit Do und die Endmarke mit Loop bezeichnet. Zwischen Do und Loop steht unser eigentliches Programm, welches kontinuierlich abgearbeitet wird. Nach dem Befehl "Do" arbeitet das Programm so lange, bis es auf "Loop" stößt. Bei Erreichen von Loop springt das Programm zurück zu Do und beginnt erneut mit der Abarbeitung. Später werden wir noch kennenlernen, dass auch mehrere Do- Loop- Schleifen verschachtelt Verwendung finden können. Dazu aber später mehr.



    Zum guten Programmierstil gehört ferner, dass am Ende des Programms der Befehl "End" gesetzt wird, dessen Funktion an dieser Stelle schnell erklärt ist: Eigentlich dürfte unser Programm nie den End- Befehl erreichen, da vorher ja der Befehl Loop einen Sprung zu Do erzwingt. Sollte das Programm dennoch jemals hinter den Loop- Befehl kommen, kann es passieren, dass das Programm in undefinierte Speicherbereiche des Controllers vordringt und hier beispielsweise an angeschlossener Hardware Schäden verursacht. Der End- Befehl ist sozusagen eine Art Notstop, vergleichbar mit einem Prellbock bei der Eisenbahn um die Funktion zu verbildlichen.

    Unserem Bascomcode fügen wir also jetzt noch die folgenden Zeilen hinzu, die wir mit Kommentarzeilen optisch voneinander trennen:



    BASCOM-Quellcode

    1. '************************************************************
    2. 'Kleiner Mikrocontroller Einsteigerkurs
    3. '(c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. 'Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. 'Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. 'Name:
    12. 'Unit: 1.0
    13. '------------------------------------------------------------
    14. 'Beschreibung: Erste Schritte -Eine blinkende LED an Port B.0
    15. '************************************************************
    16. $regfile = "attiny13.dat"'verwendeter Controller
    17. $crystal = 1200000'Taktfrequenz
    18. $HWSTACK=6'Stackwerte und Framesize zuweisen
    19. $SWSTACK=6
    20. $FRAMESIZE=28
    21. '========================================================================
    22. 'Hauptprogramm
    23. '-----------------------------------------------------------------------
    24. Do
    25. Loop
    26. '========================================================================
    27. End'end program
    Alles anzeigen

    Config und Wait - wir schreiben unser erstes Programm

    Wir haben jetzt alles vorbereitet um mit unserem ersten Programm zu beginnen. Wie wir gelernt haben, wartete das Programm jetzt darauf, dass wir zwischen Do und Loop unsere gewünschten Befehle einfügen.

    Nun geht es darum, unsere Vorstellungen vom geplanten Funktionsablauf anhand von BASCOM- Befehlen zu formulieren. Verschaffen wir uns erst einmal einen Überblick über unsere Wünsche:
    1. Wir haben eine LED an Portpin B.0 (siehe oben)
    2. Wir möchten die LED zu Programmbeginn einschalten
    3. Die LED soll eine Zeit X eingeschaltet bleiben
    4. Danach soll die LED ausgeschaltet werden
    5. Nach einer Zeit Y (kann auch gleich X sein), soll der Ablauf wiederholt werden.
    Unser erster Schritt wird sein, dem Mikrocontroller mitzuteilen, dass der Portpin B.0 nicht als Eingang, sondern als Ausgang verwendet werden soll. Zu Beginn sind alle Portpins als Eingang geschaltet, sodass bei der Verwendung von Ausgängen diese erst eingerichtet werden müssen.
    Da der Portpin B.0 im gesamten Programm ein Ausgang bleiben soll, kann die "Konfiguration" als Ausgang vor der Do-Loop-Schleife erfolgen. Der Befehl in BASCOM lautet hierzu Config und wird infolgender Weise angewendet:

    Config Portb.0 = Output 'Portb.0 als Ausgang

    Als Zweites schalten wir die LED ein. Da dies ja wiederholt geschehen soll, steht dieser Befehl innerhalb der Do- Loop -Schleife und weil sich die LED an Portb.0 befindet lautet der Befehl hierzuganz einfach:

    Portb.0 = 1

    Echt schwer, nicht wahr?

    Genauso schwer gehts weiter. Das Programm soll die LED eine Sekunde eingeschaltet lassen, dannach soll die LED wieder ausgeschaltet werden. Hier der Code:

    Wait 1 ' weist das Programm an, 1 Sekunde ' bei diesem Befehl zu verweilen
    Portb.0 = 0

    Ich denke der Befehl Wait erklärt sich von selbst, aber eine Definition soll es doch geben:


    [IMG:https://www.ceperiga.de/s/cc_images/cache_56071639.png?t=1480619216]






    Der Befehl Wait x unterbricht das Programm für x volle Sekunden. In dieser Zeit verrichtet der Controller keinerlei andere Arbeiten. Was hier ein Segen ist, wird sich mit etwas mehr Kenntnissen zu einem Fluch umwandeln, da der Mikrocontroller für die Waitzeit praktisch still steht. Aber keine Angst, es gibt Auswege, was dazu führt, dass der Waitbefehl mit fortgeschrittenen Kenntnissen nur noch selten zum Einsatz kommt. In der Anfangsphase wollen wir uns aber den einfachen Umgang zu Nutze machen und werden im weiteren Verlauf auch direkt noch seine "Geschwister" kennen lernen.



    Was jetzt noch fehlt ist der zweite Wartebefehl, für den wir ebenfalls eine Sekunde wählen. Da nun bei Loop der Vorgang von vorne beginnt ist unser Blinkprogramm auch schon fertig. Der kompletteCode sieht jetzt folgendermaßen aus:




    BASCOM-Quellcode

    1. '************************************************************
    2. 'Kleiner Mikrocontroller Einsteigerkurs
    3. '(c) 2013/2014 ceperiga
    4. '------------------------------------------------------------
    5. 'Projektinfos: www.bascomforum.de
    6. '------------------------------------------------------------
    7. 'Stufe 1: Attiny 13
    8. '------------------------------------------------------------
    9. 'Informationen zur CC-Lizensierung:http://creativecommons.org
    10. '============================================================
    11. 'Name:
    12. 'Unit: 1.0
    13. '------------------------------------------------------------
    14. 'Beschreibung: Erste Schritte -Eine blinkende LED an Port B.0
    15. '************************************************************
    16. $regfile = "attiny13.dat" 'verwendeter Controller
    17. $crystal = 1200000'Taktfrequenz
    18. $HWSTACK=6 'Stackwerte und Framesize zuweisen
    19. $SWSTACK=6
    20. $FRAMESIZE=28
    21. Config Portb.0 = Output 'Port b.0 als Ausgang
    22. '======================================================
    23. 'Hauptprogramm
    24. '------------------------------------------------------------------------------
    25. Do 'Schleifenanfang
    26. Portb.0 = 1 'Port B.0 einschalten
    27. Wait 1 '1 Sekunde warten
    28. Portb.0 = 0 'Port B.0 ausschalten
    29. Wait 1 '1 Sekunde warten
    30. Loop 'Zurück zu Do (Schleifenanfang)
    31. '======================================================
    32. End 'end program
    Alles anzeigen


    Compilieren und Flashen des Programms

    So, ich hoffe Ihr konntet den Ausführungen soweit folgen und hattet die Möglichkeit, die gemachten Schritte nicht nur zu wiederholen, sondern auch zu verstehen. Nun möchten wir natürlich auch wissen, ob das geschriebene Programm auf der Experimentierplatine läuft.
    Hierzu sind folgende Schritte notwendig:




    1. Speichern des Programms vor jedem neuen Compilieren, sonst sind die Änderungen wirkungslos (roter Pfeil 1)
    2. Überprüfen des Codes und eventuell Beseitigung angezeigter Fehler (Im Kurs wohl meist Schreibfehler) (gelber Pfeil 2)
    3. Compilieren des Programmes (grüner Pfeil 3)
    4. Der blaue Pfeil (4) zeigt Euch hier den Button, um das Fenster mit der Pinbelegung des verwendeten Controllers anzuzeigen
    Danach befindet sich im Ordner des BASCOM- Programms ebenfalls die HEX- Datei, welche wir für das Flashen in PonyProg benötigen. Hinweise hierzu gab es ja bereits hier: PonyProg

    Wenn Ihr einen USB- Programmer verwendet (z.B. den beschriebenen Programmer von DIAMEX) benötigt Ihr die HEX- Datei natürlich nicht direkt. Hier reicht es dann, das Programm direkt aus BASCOM heraus zu flashen. Dies geht über den grünen Button in BASCOM, welcher sich zwei Buttons neben dem "Compilierbutton" (Pfeil 3) befindet, oder einfachdurch Drücken von Taste F4

    Anschluss des Experimentierboards

    Vor dem Flashen schließen wir auf dem Experimentierboard oben links an die Eingangsklemmen eine gesiebte Gleichspannung von ca. 4,9 bis 5,5 Volt, beispielsweise aus einem alten Steckernetzgerät an. Achtet hier auf die Polarität (+/-). Wenn die orange LED leuchtet ist die Spannungsquelle richtig gepolt. Wenn nicht, die Anschlüsse tauschen. Die Schaltung ist gegen Verpoolen gesichert, kaputtmachen könnt Ihr durch Verwechseln der Anschlußkabel nichts.




    Unser erstes Programm auf dem Experimentierboard

    Ich habe zu den hier vorgestellten Experimenten animierte Grafiken erstellt, die im Folgenden soweit das möglich ist immer mit der jeweiligen Schaltung programmiert wurden. Dies erleichtert das Verständnis der Programme erheblich, ersetzt meiner Meinung nach aber nicht den Aufbau mit einer eigenen Platine.




    Wenn Ihr das Experimentierboard wie beschrieben angeschlossen habt und das Programm nach dem Speichern compiliert und geflasht habt, sollte nun die mittlere LED gleichmaäßig vor sichhinblinken.
    Alles ok ? Dann Herzlichen Glückwunsch!
    Hat sich ein Fehler eingeschlichen? Dann geht geht einmal die Fehlerliste durch, welche ich für den Kurs erstellt habe. Hier sind die meisten Ursachen für eine Fehlfunktion und deren Beseitigung beschrien.

    So gehts weiter: Experimente zur blinkenden LED

    Wenn jetzt unsere LED blinkt, haben wir einen großen Schritt geschafft. Der Pegel unseres Portpins lässt sich aber auch noch auf andere Weise beeinflussen. Außerdem kann man die Blinkfunktion nochauf eine einfachere Art umsetzen.Diesen Erweiterungen widmen wir uns auf einer neuen Seite

    991 mal gelesen