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 auf unterschiedliche 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 die Spitze. 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
Jumper LED3 Mitte.jpg
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 der Jumper 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 Anschlussbedingungen 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ünschten Ä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 Attiny 13 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:
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 Einfluss 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.
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 kennen lernen, 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:
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:
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 in folgender 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 hierzu ganz einfach:
Portb.0 = 1
Echt schwer, nicht wahr?
Genauso schwer geht es weiter. Das Programm soll die LED eine Sekunde eingeschaltet lassen, danach 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:
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:
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:
Compilieren.png
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 einfach durch 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 Vertauschen der Anschlusskabel nichts.
Anschluß Experimentierboard 1.jpg
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.
Blinker Mitte wait 1.gif
Wenn Ihr das Experimentierboard wie beschrieben angeschlossen habt und das Programm nach dem Speichern compiliert und geflasht habt, sollte nun die mittlere LED gleichmäßig vor sich hinblinken. Hat sich ein Fehler eingeschlichen? Dann 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 beschrieben.
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 noch auf eine einfachere Art umsetzen.Diesen Erweiterungen widmen wir uns auf einer neuen Seite
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 die Spitze. 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
Jumper LED3 Mitte.jpg
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 der Jumper 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 Anschlussbedingungen 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ünschten Ä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 Attiny 13 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:
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 Einfluss 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.
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 kennen lernen, 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
- '************************************************************
- 'Kleiner Mikrocontroller Einsteigerkurs
- '(c) 2013/2014 ceperiga
- '------------------------------------------------------------
- 'Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- 'Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- 'Name:
- 'Unit: 1.0
- '------------------------------------------------------------
- 'Beschreibung: Erste Schritte -Eine blinkende LED an Port B.0
- '************************************************************
- $regfile = "attiny13.dat"'verwendeter Controller
- $crystal = 1200000'Taktfrequenz
- $HWSTACK=6'Stackwerte und Framesize zuweisen
- $SWSTACK=6
- $FRAMESIZE=28
- '========================================================================
- 'Hauptprogramm
- '-----------------------------------------------------------------------
- Do
- Loop
- '========================================================================
- End'end program
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:
- Wir haben eine LED an Portpin B.0 (siehe oben)
- Wir möchten die LED zu Programmbeginn einschalten
- Die LED soll eine Zeit X eingeschaltet bleiben
- Danach soll die LED ausgeschaltet werden
- Nach einer Zeit Y (kann auch gleich X sein), soll der Ablauf wiederholt werden.
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 in folgender 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 hierzu ganz einfach:
Portb.0 = 1
Echt schwer, nicht wahr?
Genauso schwer geht es weiter. Das Programm soll die LED eine Sekunde eingeschaltet lassen, danach 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:
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
- '************************************************************
- 'Kleiner Mikrocontroller Einsteigerkurs
- '(c) 2013/2014 ceperiga
- '------------------------------------------------------------
- 'Projektinfos: www.bascomforum.de
- '------------------------------------------------------------
- 'Stufe 1: Attiny 13
- '------------------------------------------------------------
- 'Informationen zur CC-Lizensierung:http://creativecommons.org
- '============================================================
- 'Name:
- 'Unit: 1.0
- '------------------------------------------------------------
- 'Beschreibung: Erste Schritte -Eine blinkende LED an Port B.0
- '************************************************************
- $regfile = "attiny13.dat" 'verwendeter Controller
- $crystal = 1200000'Taktfrequenz
- $HWSTACK=6 'Stackwerte und Framesize zuweisen
- $SWSTACK=6
- $FRAMESIZE=28
- Config Portb.0 = Output 'Port b.0 als Ausgang
- '======================================================
- 'Hauptprogramm
- '------------------------------------------------------------------------------
- Do 'Schleifenanfang
- Portb.0 = 1 'Port B.0 einschalten
- Wait 1 '1 Sekunde warten
- Portb.0 = 0 'Port B.0 ausschalten
- Wait 1 '1 Sekunde warten
- Loop 'Zurück zu Do (Schleifenanfang)
- '======================================================
- End 'end program
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:
Compilieren.png
- Speichern des Programms vor jedem neuen Compilieren, sonst sind die Änderungen wirkungslos (roter Pfeil 1)
- Überprüfen des Codes und eventuell Beseitigung angezeigter Fehler (Im Kurs wohl meist Schreibfehler) (gelber Pfeil 2)
- Compilieren des Programmes (grüner Pfeil 3)
- Der blaue Pfeil (4) zeigt Euch hier den Button, um das Fenster mit der Pinbelegung des verwendeten Controllers anzuzeigen
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 einfach durch 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 Vertauschen der Anschlusskabel nichts.
Anschluß Experimentierboard 1.jpg
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.
Blinker Mitte wait 1.gif
Wenn Ihr das Experimentierboard wie beschrieben angeschlossen habt und das Programm nach dem Speichern compiliert und geflasht habt, sollte nun die mittlere LED gleichmäßig vor sich hinblinken. Hat sich ein Fehler eingeschlichen? Dann 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 beschrieben.
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 noch auf eine einfachere Art umsetzen.Diesen Erweiterungen widmen wir uns auf einer neuen Seite
6.867 mal gelesen