Post on 11-Apr-2019
transcript
Sommer
FRA
NZI
S
Ulli Sommer
Auf CD-ROM:• Komplette Software für den Einstieg• Über 100 Quellcodes zu den Experimenten• Open-Source-VB.NET-Programme zum Messen und Steuern
Mikrocontrollerprogrammieren mit
Bascom BasicMessen, Steuern, Regeln und Robotertechnikmit den AVR-Controllern
PC & ELEKTRONIK
Ulli Sommer
Mikrocontroller steuern, messen und regeln dieunterschiedlichsten Geräte, und jeder Controller ist fürseine spezielle Aufgabe programmiert.
Wie Sie einen Mikrocontroller programmieren und was Siealles benötigen, um Ihre eigenen Spezial-ICs zu erstellen,erfahren Sie in diesem Buch. Es zeigt Ihnen Schritt fürSchritt auf verständliche Weise, was Sie für den Einstieg in die ATMEL-AVR-Mikrocontrollerwelt benötigen. Sie erfahren, wie Sie bei der Hardware vorgehen müssen undwie man das Programmieren erlernt, um später seine eigene Software zu entwickeln.
Dieses Buch baut auf dem Basic-Compiler Bascom undden ATMEL-AVRs auf. Bascom ist ein moderner Basic-Compiler mit integrierter Entwicklungsumgebung undeignet sich für fast alle 8-Bit-AVR- und XMega-Mikrocon-troller der Firma ATMEL.
Viele Problemstellungen, die früher zeitaufwendig inAssembler oder C gelöst werden mussten, können durchdiesen modernen Compiler blitzschnell mit wenigen Befehlen erledigt werden, und sollte dies einmal nicht ausreichen, so stellt Bascom noch die Möglichkeit des Inline-Assemblers zur Verfügung.
Die ersten Kapitel des Buches vermitteln Ihnen die Programmierung mit Bascom in einem ausführlichenProgrammierlehrgang. Hier werden die Befehle anhandkleiner Beispiele verdeutlicht. Hard- und Software werdendetailliert erklärt, und am Ende macht Ihnen keiner mehrein Byte für ein Bit vor. Das erlernte Wissen aus dem Programmierkurs wird in den darauf folgenden Experi-menten kreativ und spielerisch in Mess-, Steuer- und Regelanwendungen eingesetzt. Das Buch wird Ihnen auch danach als Referenz und Nachschlagewerk nützliche Dienste erweisen.
Mikrocontrollerprogrammieren mit
Bascom Basic Aus dem Inhalt:• AVR: Grundlagen und
Programmierung• Ausführlicher Bascom-
Programmier-Einsteigerkurs• Schaltplan und Erklärung zu jedem
Experiment• Sensoren und Aktoren anschließen
und anwenden• Von den Grundlagen bis zur eigenen
Applikation• Über 100 praktische Experimente,
z. B. Ein-/Ausschaltverzögerung,Temperaturschalter, Kapazitäts-messgerät, GPS-Maus auslesen, Digitalvoltmeter mit AVR undVB.NET, Rasenmäh-Roboter, Steuernmit VB.NET, Ultraschallsensoren,Drehzahlmesser, Transistor-LED-Dimmer, Lüftersteuerung, DigitalesCodeschloss, Daten aufzeichnen mitStamp PLOT, Digitaler Datenplottermit VB.NET selbst gemacht,Bewegungsmelder, Alarmanlage,Dämmerungsschalter, Morsezeichen-Encoder, Morsezeichen-Decoder,Modellflug: Drohnen-Telemetrie-system u. v. m.
ISBN 978-3-645-65041-0
39,95 EUR [D]
Besuchen Sie uns im Internet: www.franzis.de
ISBN 978-3-645-65041-0 Mik
roco
ntro
ller p
rogr
amm
iere
n m
it Ba
scom
Bas
ic65041-0 U1+U4_SC 05.09.2011 10:36 Uhr Seite 1
Ulli Sommer
Mikrocontroller programmierenmit Bascom Basic
65041-0 Titelei 25.08.2011 15:51 Uhr Seite 1
PC & ELEKTRONIK
Mit 161 Abbildungen
Ulli Sommer
Mikrocontrollerprogrammieren mit
Bascom BasicMessen, Steuern, Regeln und Robotertechnikmit den AVR-Controllern
65041-0 Titelei 25.08.2011 15:51 Uhr Seite 3
Bibliografische Information der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte Daten sind im Internet über http://dnb.ddb.de abrufbar.
Alle in diesem Buch vorgestellten Schaltungen und Programme wurden mit der größtmöglichen Sorgfalt entwickelt, geprüft und
getestet. Trotzdem können Fehler im Buch und in der Software nicht vollständig ausgeschlossen werden. Verlag und Autor haften in
Fällen des Vorsatzes oder der groben Fahrlässigkeit nach den gesetzlichen Bestimmungen. Im Übrigen haften Verlag und Autor nur
nach dem Produkthaftungsgesetz wegen der Verletzung des Lebens, des Körpers oder der Gesundheit oder wegen der schuldhaften
Verletzung wesentlicher Vertragspflichten. Der Schadensersatzanspruch für die Verletzung wesentlicher Vertragspflichten ist auf den
vertragstypischen, vorhersehbaren Schaden begrenzt, soweit nicht ein Fall der zwingenden Haftung nach dem Produkthaftungs-
gesetz gegeben ist. Für die Mitteilung etwaiger Fehler sind Verlag und Autor jederzeit dankbar. Internetadressen oder Versionsnum-
mern stellen den bei Redaktionsschluss verfügbaren Informationsstand dar. Verlag und Autor übernehmen keinerlei Verantwortung
oder Haftung für Veränderungen, die sich aus nicht von ihnen zu vertretenden Umständen ergeben. Evtl. beigefügte oder zum
Download angebotene Dateien und Informationen dienen ausschließlich der nicht gewerblichen Nutzung. Eine gewerbliche Nut-
zung ist nur mit Zustimmung des Lizenzinhabers möglich.
© 2011 Franzis Verlag GmbH, 85540 Haar bei München, www.franzis.de
Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Das Erstellen
und Verbreiten von Kopien auf Papier, auf Datenträgern oder im Internet, insbesondere als PDF, ist nur mit ausdrücklicher Genehmigung
des Verlags gestattet und wird widrigenfalls strafrechtlich verfolgt.
Die meisten Produktbezeichnungen von Hard- und Software sowie Firmennamen und Firmenlogos, die in diesem Werk genannt
werden, sind in der Regel gleichzeitig auch eingetragene Warenzeichen und sollten als solche betrachtet werden. Der Verlag folgt bei
den Produktbezeichnungen im Wesentlichen den Schreibweisen der Hersteller.
Satz: DTP-Satz A. Kugge, München
art & design: www.ideehoch2.de
Druck: Bercker, 47623 Kevelaer
Printed in Germany
ISBN 978-3-645-65041-0
65041-0 Titelei 25.08.2011 15:51 Uhr Seite 4
5
Vorwort Mikrocontroller zu programmieren wird, wie man in den verschiedensten Foren und Fachzeitschriften beobachten kann, immer populärer. Das liegt daran, dass Mikrocontroller und zusätzliche Peripheriebausteine immer günstiger angeboten werden und an Schulen zunehmend in Mikrocontroller und Computertechnik unterrichtet wird. Schaltungen, die man früher mit mehreren ICs aufbauen musste, können nun in einem einzigen Mikrocontroller untergebracht werden. Das spart Zeit, Geld und Platz auf der Leiterplatte. Dieses Buch baut auf dem beliebten Basic-Compiler BASCOM-AVR mit integrierter Entwicklungs-umgebung auf. Er ist für fast alle 8-Bit-AVR- und XMega-Mikrocontroller der Firma Atmel geeignet. BASCOM erfreut sich nicht nur bei Einsteigern, sondern auch bei Entwicklungsprofis, immer größerer Beliebtheit und stellt inzwischen schon fast einen Basic-Standard bei AVRs dar.
Viele Problemstellungen, die früher zeitaufwendig in Assembler oder C gelöst werden mussten, können durch diesen modernen Compiler blitzschnell mit wenigen Befehlen erledigt werden. Beispielsweise genügt ein einziger Befehl, um aus einem I/O-Port eine RS232-Schnittstelle, einen I²C-Bus oder einen Servoanschluss zu machen. Solche Dinge erfordern in anderen Programmier-sprachen oft einen enormen Aufwand.
BASCOM erzeugt optimierten Maschinen-Code. Es werden alle AVR-RISC-Controller mit internem RAM der Serien AT90S, ATmega und ATTiny unter-stützt. Mit einigen Einschränkungen sind jetzt auch ATTiny-Controller ohne SRAM mit BASCOM-AVR programmierbar. Dazu steht die $TINY-Funktion zur Verfügung.
Aus diesen Gründen ist der BASCOM Basic-Compiler ideal für den Einstieg in die Mikrocontroller-Programmierung geeignet. Er ist trotzdem sehr leistungs-fähig und ermöglicht auch optimierte komplexe Software-Entwicklungen mit Profianforderungen. Ein weiterer großer Vorteil ist, dass diese Entwicklungs-umgebung in hohem Tempo weiterentwickelt wird und die Updates kostenlos sind. So war BASCOM auch eine der ersten AVR-Entwicklungsumgebungen, die unter Vista und Windows 7 liefen.
Ich wünsche Ihnen viel Spaß beim Lesen und Experimentieren mit diesem Buch!
Waidhaus, Juli 2011
Ulli Sommer
7
Inhaltsverzeichnis 1 Die CD-ROM zum Buch....................................................................... 13
1.1 Inhalt der CD-ROM .............................................................. 13 1.2 GPL (General Public License)............................................... 13 1.3 Systemvoraussetzungen..................................................... 13 1.4 Updates und Support ......................................................... 13
2 Mikrocontroller-Grundlagen .............................................................. 15 2.1 Aufbau und Funktionsweise................................................ 16 2.2 Die CPU .............................................................................. 16 2.3 Arbeits- und Programmspeicher.......................................... 17 2.4 Peripherie........................................................................... 17
3 Mikrocontroller-Programmierung im Allgemeinen.............................. 19 3.1 Was ist ein Programm?........................................................ 19 3.2 Programmierung in Basic .................................................... 19 3.3 Konzept von Basic .............................................................. 20 3.4 Vor- und Nachteile von Basic .............................................. 20 3.5 Programmierung in Assembler ............................................ 20
4 Übersicht über die Atmel-8-Bit-Mikrocontroller ................................. 23 4.1 AT90Sxxx............................................................................ 23 4.2 ATmega .............................................................................. 23 4.3 ATTiny ................................................................................ 24 4.4 XMega ................................................................................ 24
5 Der ATmega88 für die Experimente und seine Grundbeschaltung für den Betrieb ..................................................... 25 5.1 Speicher............................................................................. 25 5.2 Die interessantesten Pins des ATmega88 auf
einen Blick ......................................................................... 26 5.3 Grundschaltung für den Betrieb .......................................... 27 5.4 ADC (Analog Digital Converter) ............................................ 28 5.5 PWM (Pulse Width Modulation)........................................... 28 5.6 UART (Universal Asynchronous Receiver
Transmitter)........................................................................ 28 5.7 IRQ (Interrupt)..................................................................... 28 5.8 Stromversorgung des Controllers ........................................ 29 5.9 Resetbeschaltung............................................................... 29
8 Inhaltsverzeichnis
5.10 Oszillator............................................................................ 30 5.11 ISP-Anschluss zur Programmierung..................................... 30
6 Programmiergeräte............................................................................ 33
7 Interessante AVR-Boards für den Einstieg .......................................... 37 7.1 RN-CONTROL ...................................................................... 37 7.2 RN-Mega8PLUS................................................................... 38 7.3 RN-MINICONTROL ............................................................... 40
8 BASCOM installieren ......................................................................... 41
9 Der Basic-Compiler – BASCOM .......................................................... 47 9.1 Landessprache auswählen ................................................. 47 9.2 Die BASCOM-IDE................................................................. 48 9.3 BASCOM-Hilfe .................................................................... 49 9.4 BASCOM-Einstellungen....................................................... 50
10 Der erste Hardware-Test »Es blinkt« .................................................. 55 10.1 Was haben wir getan?......................................................... 60
11 Grundlagen des Programmierens....................................................... 61 11.1 Bits und Bytes .................................................................... 61 11.2 Grundsätzlicher Aufbau eines Programms........................... 62 11.3 Sequenzieller Programmablauf ........................................... 62 11.4 Interrupt-gesteuerter Programmablauf ................................ 63
12 BASCOM-AVR Basic – Programmierkurs............................................. 65 12.1 Der Aufbau eines BASCOM-Programms ............................... 65 12.2 Testaufbau mit MAX232...................................................... 65 12.3 Testaufbau mit FTDI FT232RL .............................................. 68 12.4 Test der seriellen Ausgabe.................................................. 69 12.5 Der Simulator ..................................................................... 71 12.6 Die Hardware-Simulation.................................................... 73 12.7 Kommentare im Quelltext ................................................... 74 12.8 Datentypen und Variablen .................................................. 74 12.9 Lokale und globale Variablen.............................................. 75 12.10 Variablen-Zuweisung.......................................................... 75 12.11 Arrays................................................................................. 76 12.12 Operatoren......................................................................... 77 12.13 Kontrollstrukturen .............................................................. 77 12.13.1 If Then – End if ................................................................... 77 12.13.2 If Then – Else – End if ......................................................... 78 12.13.3 If und ElseIf ........................................................................ 79
Inhaltsverzeichnis 9
12.13.4 Select Case......................................................................... 80 12.14 Schleifen ............................................................................ 81 12.14.1 For Next .............................................................................. 81 12.14.2 Do Loop und Do Until.......................................................... 82 12.14.3 While Wend ........................................................................ 84 12.15 Funktionen, Prozeduren und Labels .................................... 84 12.15.1 Subroutinen ....................................................................... 85 12.15.2 Funktionen ......................................................................... 86 12.15.3 Gosub ................................................................................ 87 12.15.4 Goto ................................................................................... 87 12.15.5 On...................................................................................... 88 12.16 String und String-Bearbeitung............................................. 89 12.16.1 Strings................................................................................ 89 12.16.2 Ucase ................................................................................. 90 12.16.3 Lcase.................................................................................. 90 12.16.4 Bin ..................................................................................... 91 12.16.5 Hex..................................................................................... 91 12.16.6 Hexval ................................................................................ 91 12.16.7 Val ..................................................................................... 92 12.16.8 Str ...................................................................................... 92 12.16.9 String ................................................................................. 93 12.16.10 Space................................................................................. 93 12.16.11 Fusing ................................................................................ 93 12.16.12 Format................................................................................ 94 12.16.13 Len..................................................................................... 95 12.16.14 Instr ................................................................................... 95 12.16.15 Mid .................................................................................... 96 12.16.16 Split ................................................................................... 96 12.16.17 Left..................................................................................... 97 12.16.18 Right .................................................................................. 97 12.16.19 Ltrim................................................................................... 98 12.16.20 Rtrim .................................................................................. 98 12.16.21 Trim.................................................................................... 98
13 Input/Output-Konfiguration und Port-Setzen ................................... 101
14 Timer als Timer verwenden .............................................................. 109
15 Timer als Counter verwenden........................................................... 115
16 Der Analog-Digital-Wandler (ADC) .................................................... 119 16.1 Verwendung des ADC........................................................ 122
10 Inhaltsverzeichnis
17 Externe Interrupts............................................................................ 125
18 Die UART-Schnittstelle..................................................................... 129 18.1 Ein- und Ausgeben von Daten (Input, Inkey,
Print) ................................................................................ 131 18.2 Software-UART.................................................................. 133
19 Sleep Modes.................................................................................... 135
20 Weitere Experimente und praktische Anwendungen......................... 139 20.1 Taster entprellen .............................................................. 139 20.2 Einschaltverzögerung ....................................................... 142 20.3 Ausschaltverzögerung ...................................................... 144 20.4 LEDs an den Pins des Mikrocontrollers.............................. 145 20.5 Größere Verbraucher mit Transistoren schalten................. 148 20.6 Tonerzeugung mit dem Befehl Sound................................ 150 20.7 Töne über den 8-Bit-Timer0 erzeugen................................ 152 20.8 Morsecode-Generator ....................................................... 154 20.9 Impulszähler mit dem 8-Bit-Timer0 ................................... 157 20.10 Impulslängenmessung ..................................................... 159 20.11 PWM (Pulse Width Modulation)......................................... 161 20.12 DAC mit PWM-Ports........................................................... 165 20.13 Transistor-LED-Dimmer ..................................................... 168 20.14 LED-Dimmer mit dem 8-Bit-Timer0 .................................... 170 20.15 Softer Blinker ................................................................... 171 20.16 Zufallszahlen mit BASCOM ............................................... 173 20.17 Überwachung des Personalausgangs................................ 174 20.18 RTC (Real Time Clock) ....................................................... 177 20.19 Lüftersteuerung ................................................................ 178 20.20 Dämmerungsschalter........................................................ 182 20.21 Alarmanlage ..................................................................... 185 20.22 Digitales Codeschloss ...................................................... 187 20.23 Kapazitätsmesser mit Autorange....................................... 190 20.24 Potenziometer professionell auslesen .............................. 193 20.25 State Machine .................................................................. 194 20.26 6-Kanal-Voltmeter............................................................. 196 20.27 Spannungs-Plotter selbst programmiert ............................ 199 20.28 StampPlot – der Profi-Datenlogger zum Nulltarif ............... 201 20.29 Steuern über VB.NET......................................................... 205 20.30 Leuchtdiodentester .......................................................... 207 20.31 GPS-Mäuse auslesen........................................................ 208 20.32 Temperaturschalter .......................................................... 216 20.33 Temperaturmessung mit dem LM335 ................................ 218 20.34 MIN/MAX-Thermometer .................................................... 221
Inhaltsverzeichnis 11
20.35 Temperatur-Logger............................................................ 223 20.36 LCDs und ihre Verwendung ............................................... 229 20.36.1 LC-Display – Grundlagen................................................... 230 20.36.2 Polarisation von Displays.................................................. 230 20.36.3 Statische Ansteuerung, Multiplexbetrieb .......................... 231 20.36.4 Blickwinkel 6 Uhr/12 Uhr.................................................. 231 20.36.5 Reflektiv, transflektiv, transmissiv .................................... 231 20.36.6 Der Controller des LC-Displays .......................................... 232 20.36.7 Display vom Displaycontroller ansteuern .......................... 233 20.36.8 Kontrasteinstellung des Displays ...................................... 234 20.36.9 Der Befehlssatz der HD44780- und KS0066-
Controller und kompatibler Typen ..................................... 236 20.36.10 Der Zeichensatz................................................................ 237 20.36.11 Pin-Belegung der gängigen LCDs....................................... 238 20.36.12 So wird das Display mit dem Mikrocontroller
angesteuert ...................................................................... 240 20.36.13 Initialisierung der Displays ............................................... 241 20.36.14 Der Anschluss am Mikrocontroller..................................... 243 20.36.15 Der erste Test mit BASCOM ............................................... 244 20.36.16 Die LCD-Routinen von BASCOM......................................... 245 20.36.17 Eigene Zeichen mit BASCOM erstellen............................... 250 20.37 Der I²C-Bus ....................................................................... 255 20.38 LCDs über den I²C-Bus verbinden...................................... 258 20.39 I²C-Temperatursensor LM75.............................................. 260 20.40 Temperatursensor DS1621 ............................................... 262 20.41 I²C-Portexpander mit PCF8574 .......................................... 264 20.42 Ultraschallsensoren zur Entfernungsbestimmung.............. 267 20.42.1 Der SRF02-Ultraschallsensor............................................. 267 20.42.2 Auslesen der Entfernungsdaten ........................................ 268 20.42.3 Die I²C-Adresse des SRF02 ändern .................................... 271 20.42.4 Ultraschallsensor SRF08 ................................................... 272 20.43 Servos .............................................................................. 273 20.44 Schrittmotoransteuerung.................................................. 277 20.45 Impulsgeber mit der Lichtschranke CNY70 ........................ 284 20.46 Impulsgeber mit Reflexlichtschranke SFH-9102................. 286 20.47 Ein GPS-Navigationssystem für Roboter ............................ 290 20.47.1 ATmega32 als Navigator ................................................... 291 20.47.2 Motoransteuerung ............................................................ 292 20.47.3 Track-Points programmieren ............................................. 294 20.48 Mikrocontrollergesteuerter Rasenmähroboter ................... 296 20.48.1 Das Chassis...................................................................... 299 20.48.2 Das Mähwerk.................................................................... 301 20.48.3 Sensoren.......................................................................... 304 20.48.4 Der elektronische Gartenzaun........................................... 305
12 Inhaltsverzeichnis
20.49 RC5-4-Kanal-Relaiskarte ................................................... 310 20.49.1 Wie funktioniert die IR-Fernbedienung?............................. 310 20.49.2 Der Aufbau des RC5-Codes ............................................... 311 20.49.3 So werden die einzelnen Bits übertragen .......................... 312 20.49.4 RC5-Code mit BASCOM einlesen ....................................... 315 20.49.5 Verwirklichung der IR-Relaisplatine................................... 316 20.50 Telemetriesystem für eine Modellflugdrohne..................... 319 Schlusswort ..................................................................................... 330
A Anhang............................................................................................ 333 A.1 Schaltzeichen................................................................... 333 A.2 Escape-Sequenzen ........................................................... 334 A.2.1 Terminal-Ausgaben........................................................... 334 A.2.2 Terminal-Befehle .............................................................. 334 A.3 ASCII-Tabelle .................................................................... 335 A.4 Reservierte Worte in BASCOM ........................................... 339 A.5 Bezugsquellen.................................................................. 342 A.6 Links ................................................................................ 343
33
6 Programmiergeräte Wenn Sie hauptsächlich mit BASCOM und 8-Bit-Atmel-Controllern arbeiten möchten, empfehle ich, den BASCOM USB-ISP-Programmer zu verwenden. Er kann direkt mit BASCOM verwendet werden und man kann zudem auch die Fuse- und Lock-Bits unter BASCOM einstellen. Mit der USB-Schnittstelle ist er nicht nur sehr schnell bei der Programmierung, sondern erlaubt auch den Betrieb an neueren Rechnern, die meist nur noch über USB-Schnittstellen verfügen.
Bild 6.1: BASCOM USB-ISP-Programmer.
Beziehen lässt sich der Programmer direkt vom BASCOM-Hersteller oder in Deutschland über www.Robotikhardware.de.
Weit verbreitet ist auch der Atmel USB-ISP-Programmer MKII. Er wird nicht direkt unter BASCOM unterstützt, lässt sich aber auch dafür einrichten – jedoch nicht so komfortabel wie der BASCOM-eigene Programmer. Eine Aufstellung der unter BASCOM verwendbaren Programmiergeräte finden Sie unter http://avrhelp. mcselec.com/index.html?supported_programmers.htm.
34 Kapitel 6: Programmiergeräte
In diesem Buch wird der BASCOM USB-ISP-Programmer verwendet. Die Art, wie bei der Programmierung vorgegangen wird, ist bei anderen Programmiergeräten ähnlich.
Eine kostengünstige Alternative zu käuflich erwerbbaren Programmiergeräten ist der Eigenbau. Es werden nicht allzu viele Bauteile benötigt, womöglich finden sich die Teile sogar in Ihrer Bastelkiste. Der zu verwendende Computer muss jedoch eine parallele Schnittstelle besitzen. Der folgende Schaltplan zeigt, wie es geht.
Bild 6.2: Parallel-Port ISP-Programmer. (Quelle: BASCOM-Hilfe)
Diese Version ist auch bei verschiedenen Elektronikversendern für meist unter 20 € käuflich zu erwerben.
Es gibt noch eine Sparversion eines Parallel-Port-ISP-Programmers. Sie ist aber mit Vorsicht zu genießen, da ein Kurzschluss der I/Os des Parallelports zu einem Defekt der Schnittstelle führen kann. Die 330-Ohm-Widerstände schützen den Port nur geringfügig. Es ist also immer ratsamer, die Version mit dem Puffer-IC 74HC244 aufzubauen.
Kapitel 6: Programmiergeräte 35
Bild 6.3: Der »Lowcost«-ISP-Programmer für die parallele Schnittstelle.
37
7 Interessante AVR-Boards für den Einstieg
Es gibt natürlich auch einige kostengünstige AVR-Boards zu kaufen, die den Einstieg in die AVR-Welt vereinfachen. Eine breite Palette diverser AVR-Platinen bietet die Firma Robotikhardware an. Die Module besitzen meist schon diverse Zusatzhardware wie DC-Motortreiber, Schrittmotortreiber, Funkmodule, Schalt-ausgänge mit Transistoren oder Relais. Programmiert werden die Boards wie die Eigenbauschaltung. Es folgt ein kleiner Überblick verschiedenster Mikrocontrol-ler-Platinen aus dem Angebot der Firmen Robotikhardware und Atmel.
7.1 RN-CONTROL Für den Einstieg, erste Mikrocontroller-Experimente aber auch für konkrete Projekte wie autonome Roboter, Steuerungen und vieles mehr gibt es das Board RN-CONTROL. Bei der Entwicklung wurde besonders auf ein gutes Preis-Leistungs-Verhältnis geachtet. Trotz günstigen Preises ist ein sehr flexibles Board für unzählige Anwendungsmöglichkeiten entstanden. Über den I²C-Bus stehen zahlreiche Erweiterungs-Boards zur Verfügung. So können beispielsweise die gleichen I²C-Erweiterungen kombiniert werden wie beim großen RNBFRA-Board (Relaiskarte, Sprachausgabe usw.).
38 Kapitel 7: Interessante AVR-Boards für den Einstieg
Bild 7.1: RN-Control 1.4. (Quelle: Robotikhardware)
Besonders viel Wert wurde auch auf den einfachen Aufbau und viele Experimen-tier- und Einsatzmöglichkeiten gelegt. Mit diesem Board lässt sich schon ein recht ausgereifter Roboter konstruieren. Ultraschallsensoren, Infrarot-Entfer-nungssensoren, Motoren u. v. m. können direkt angeschlossen werden. Da das Board auch in der Community Roboternetz recht beliebt ist, findet man dort viele Tipps und Programme.
7.2 RN-Mega8PLUS Der Nachfolger des RN-Mega8-Boards, jetzt mit Funkmodulsteckplatz und weiteren Optimierungen. Dieses Nachfolge-Board wurde speziell zum Experimen-tieren mit den Mikrocontrollern Mega8 und Mega168 entworfen.
7.2 RN-Mega8PLUS 39
Bild 7.2: RN-Mega8PLUS. (Quelle: Robotikhardware)
Die Controller Mega8 und Mega168 eignen sich wegen ihres günstigen Preises und ihrer geringen Baugröße für zahlreiche Aufgaben, bei denen ein Mega16 oder ein Mega32 überdimensioniert wäre. Im Bereich Robotik kann dieser Con-troller ideal auch als Co-Controller für Servosteuerung, Motorsteuerung, Dis-play-Ausgabe, Sensorüberwachung und vieles mehr eingesetzt werden. Oft sind kaum externe Bauteile notwendig. Um den Controller jedoch für eine spezielle Aufgabe programmieren zu können, bedarf es einer Entwicklungsumgebung die quasi alle Ports steckbar zugänglich macht, also auch die visuelle Überwachung der Port-Zustände erlaubt.
Für diese Aufgabe ist RN-Mega8PLUS ideal. Ganze 20 Ports können gleichzeitig visuell über Leuchtbalken überwacht werden. Nahezu alle Ports sind über einfa-che Steckklemmen erreichbar. Zudem verfügt das Board über jeweils einen genormten LCD-Display-, I²C-Bus-, RS-232-, Servo- und ISP-Anschluss.
Eine Besonderheit von RN-Mega8PLUS ist der Steckplatz für ein EasyRadio-Funkmodul. Dadurch wird das Board funkkompatibel zu RN-Mega128Funk, RN-Steuerung und RN-Funk. So können Daten mit anderen Boards oder PCs per Funk ausgetauscht werden. Das Funkmodul ist optional über www.robotikhardware.de beziehbar – es wird nur eingesteckt und man kann los-legen.
40 Kapitel 7: Interessante AVR-Boards für den Einstieg
7.3 RN-MINICONTROL Dieses Controllerboard zeichnet sich durch seine kompakte Größe (nur 5 cm x 7,8 cm) und sehr geringen Strombedarf aus. Besonders viel Wert wurde auch auf die vielseitigen Anschlüsse gelegt. Nahezu alle Ports stehen dem Anwender somit zur Verfügung. Besonders günstig sind die wichtigen AD-, Interrupt-, Timer- und PWM-Ports auf die Stecker verteilt worden. So lassen sich Servos, Drehgeber und RC-Empfänger, aber auch Motortreiber (Doppel-H-Brücken wie RN-VN2Dualmotor) oder LCDs direkt anschließen. Natürlich steht auch der I²C-Bus zur Verfügung. Alle Stecker sind zudem kompatibel zu den Roboternetz-Defini-tionen.
Bild 7.3: RN-MINICONTROL. (Quelle: Robotikhardware)
Obwohl das Board, wie auch der »große Bruder« RN-Control, zum Experimen-tieren als Haupt-Board verwendet werden kann, ist es in erster Linie als praktisch einsetzbares Zusatz-Board für echte Projekte gedacht.
RN-MINICONTROL ist als kostengünstiges Co-Controllerboard ideal als Zweit- oder Dritt-Board in Projekten (Roboter etc.). Ein besonderes Feature sind zwei Stiftleisten auf der Unterseite. Dadurch kann das Board auf ein anderes Board wie RN-VNH2Dualmotor oder Lochrasterplatinen aufgesteckt werden. Das Board ist mit dem leistungsstarken Controller ATmega168 ausgestattet. Er ist weitgehend kompatibel zum ATmega8, daher kann wahlweise auch ein ATmega8 bestückt werden. Der Mega168 bietet jedoch weit mehr Features: 6x PWM, drei Timer, 16 KB Speicher und Interrupt an jedem Pin.
65
12 BASCOM-AVR Basic – Programmierkurs
Wer mit BASCOM seine ersten Programmierschritte wagt, sollte diese Kapitel genauer studieren und die Beispiele ausprobieren, bis er sie versteht. Dieser Grundlagenkurs der BASCOM-Programmierung legt den Grundstein für weitere Programme. Lassen Sie nicht gleich den Kopf hängen, wenn etwas nicht auf Anhieb klappt. Auch im Profibereich funktioniert nicht immer alles beim ersten Mal. Die Freude ist umso größer, wenn ein Versuch nach mehreren Anläufen endlich klappt, und man kann dabei nur lernen.
12.1 Der Aufbau eines BASCOM-Programms • Infotexte und Programmbeschreibung (Header)
• Prozessorangaben und Konfiguration
• Konfiguration der seriellen Schnittstelle
• Port, ADC, Timer, PWM-Konfiguration
• Variable anlegen, Alias für Ports
• Interrupts aktivieren
• Hauptschleife
• Eigene Prozeduren, Routinen und IRQ-Routinen
• Daten für LCD-Character oder Tabellen
• Include Files
12.2 Testaufbau mit MAX232 An dieser Stelle schreiben wir gleich das nächste BASCOM-Basic-Programm. Tippen Sie zur Übung den Quelltext einfach ab oder entnehmen Sie den Quell-code der CD-ROM unter Beispiele. Das Programm benötigt das interne Termi-nalprogramm von BASCOM und einen passenden Schnittstellenwandler (z. B. MAX232) oder einen USB-zu-UART-Brückenchip (z. B. FT232RL oder CP2102). Eine Beispielschaltung dazu zeigt der folgende Schaltplan.
66 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Bild
12.
1: D
er S
chal
tpla
n ze
igt e
ine
seri
elle
Ver
bind
ung
zum
PC
über
ein
en S
chni
ttst
elle
nwan
dler
MA
X232
.
12.2 Testaufbau mit MAX232 67
Es gibt verschiedene MAX232-Typen. Neuere Typen benötigen nur noch kleine Kondensatoren wie hier 100 nF. Im Datenblatt zu Ihren verwendeten Schnitt-stellenwandlern finden Sie die passenden Werte.
Der Schnittstellenwandler setzt das RS-232-Signal vom PC (+/-12 V) in ein 0/5-V-Signal für den Mikrocontroller um.
Wichtig zu wissen ist, dass die Sender-/Empfängerleitungen gedreht sind (dem Nullmodemkabel ähnlich). Der Sender muss mit dem Empfänger (TxD -> RxD) verbunden werden.
68 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
12.3 Testaufbau mit FTDI FT232RL
Bild
12.
2: D
iese
r Sch
altp
lan
zeig
t die
Ver
wen
dung
ein
es U
SB
-zu-
UA
RT-B
rück
ench
ips
FT23
2RL
der F
irm
a FT
DI.
12.4 Test der seriellen Ausgabe 69
Alternativ gibt es diverse Konverter wie den Mini-USB-zu-UART-Converter der Firma Conrad zu kaufen. Diesen Konverter kann man einfach in eine Lochras-terplatine löten und mit dem Controller verbinden.
Bild 12.3: USB-zu-UART-Konverter der Firma Conrad Electronic SE; Bestellnummer: 197326. (Quelle: Conrad Electronic SE)
Mehr Informationen zur seriellen Schnittstelle (UART) folgen im Kapitel 18.
12.4 Test der seriellen Ausgabe Nachdem Sie die Schaltung um einen Schnittstellenkonverter ergänzt haben, starten Sie nach dem Übertragen auf den Controller das Terminal unter Werk-zeuge oder mit STRG+T und klicken zur Sicherheit noch mal auf Reset oder drücken Sie die Tastenkombination SHIFT+F4. Jetzt werden Sie aufgefordert, die erste Zahl (0 bis 255) einzugeben. Drücken Sie nach der Eingabe Return. Geben Sie nun die zweite Zahl ein und bestätigen Sie diese Eingabe erneut mit Return. BASCOM gibt das Ergebnis der Addition der beiden Zahlen aus. Nach der Ausgabe beginnt die LED an Portb.1 zu blinken. Durch Drücken des Tasters S2 beginnt das Programm erneut.
Beispiel: erstes Programm.bas
' Das ist das erste Programm mit Bascom Basic $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Led Alias Portb.1
Config Led = Output
Led = 0
S2 Alias Pind.2
Config S2 = Input
70 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Portd.2 = 1
Const Pi = 3.14
Dim Byte1 As Byte
Dim Byte2 As Byte
Dim Ich_bin_eine_variable As Word
Declare Function Testfunktion(byval A As Byte , Byval B As Byte)
As Word
Declare Sub Led_toggle()
' Hauptprogramm Do
' Hier steht das eigentliche Programm ' In der Funktion wird der Wert berechnet und ' an "ich bin eine Variable" übergeben.
Print "Zwei Zahlen mit Bascom addieren"
Input "Ersten Wert eingeben: " , Byte1
Input "Zeiten Wert eingeben: " , Byte2
Ich_bin_eine_variable = Testfunktion(byte1 , Byte2)
Print "Ergebnis = " ; Ich_bin_eine_variable ; Chr(10) ; Chr(13)
Print "Taste S2 druecken um fortzufahren!" ; Chr(10) ; Chr(13)
Do
Led_toggle
Loop Until S2 = 0
Loop
End
Function Testfunktion(a As Byte , B As Byte) As Word
Testfunktion = A + B
End Function
Sub Led_toggle()
Toggle Led
Waitms 250
End Sub
Das Programm enthält bereits die wichtigsten Grundzüge eines sequenziellen Programms. Zuerst wird BASCOM mitgeteilt, welcher Controller verwendet wird.
12.5 Der Simulator 71
Danach wird die Taktfrequenz auf 16 MHz festgelegt und die Geschwindigkeit der UART-Schnittstelle eingestellt.
Mit dem Befehl Alias wird den I/O-Pins ein Name zugeteilt (z. B. »LED«). Ver-wenden Sie auch in Ihren Programmen den Alias-Befehl. Das macht den Quell-code lesbarer.
Mit Config <Name> = Input oder Output teilt man BASCOM mit, ob wir den Pin als Aus- oder Eingang verwenden möchten. Wird der Pin als Ausgang verwendet, muss man ihn als PORT benennen. Möchte man den Pin als Eingang verwenden, muss man bei der Zuweisung PIN schreiben. Wird der I/O als Eingang benutzt, muss man (in unserem Fall) noch den internen Pull-up-Widerstand aktivieren, da die Taster gegen Masse schalten. Dies geschieht mit Portd.2 = 1. Hier darf man nicht PIN schreiben, auch wenn der Pin eigentlich ein Eingang ist.
Jetzt werden die Konstanten und Variablen angelegt und die Funktionen und Subroutinen bekannt gegeben.
Nun beginnt das eigentliche Programm. Es läuft in einer Do-Loop-Schleife, die nie verlassen wird. Der Befehl Print gibt zuerst eine Information über die UART-Schnittstelle aus, das zweite Print generiert eine Leerzeile. Bei den danach folgenden Prints ist ein chr(10) ; chr(13) angefügt. Das erfüllt den gleichen Zweck wie ein zusätzliches Print.
Der Befehl Input wartet nun so lange, bis eine Eingabe erfolgt ist und diese mit Return abgeschlossen wurde. Der eingegebene Wert wird in die Variable hinter dem String Byte1 und Byte2 abgelegt. Nun wird das Ergebnis berechnet, indem die beiden Werte von Byte1 und Byte2 in die Funktion mit dem Namen Test-funktion übergeben werden. Das Ergebnis steht nun in der Variablen mit dem Namen Ich_bin_eine_Variable.
Das errechnete Ergebnis wird nun mit Print über die serielle Schnittstelle ausge-geben. Jetzt springt das Programm in eine Do-Loop-Until-Schleife. In dieser Schleife wird so lange die Subroutine Led_toggle aufgerufen, bis der Taster S2 gedrückt wird. Erst wenn die Bedingung S2 = 0 (Taster gegen Masse geschaltet) erfüllt ist, wird diese Schleife wieder verlassen. In der Subroutine Led_toggle wird mithilfe des Toggle-Befehls die LED zum Blinken gebracht.
12.5 Der Simulator BASCOM besitzt einen sehr guten und vor allem einen sehr komfortablen Simulator, der es ermöglicht, die Programme auch ohne Hardware zu testen und zu simulieren.
72 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Um in den Simulator zu gelangen, drücken Sie die Taste F2 oder gehen Sie unter Programmieren auf Simulator. Ein kleines Beispiel wird Ihnen nun den Umgang mit dem BASCOM-Simulator erklären.
Bild 12.4: Der BASCOM-Simulator.
Beispiel: Simulator.bas
‘ Bascom Simulator $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Config Portb.1 = Output
Cls
Locate 1 , 1
Lcd "Bascom ist"
Locate 2 , 2
Lcd "super!"
Dim X As Byte
For X = 1 To 10
12.6 Die Hardware-Simulation 73
Print X
Next
X = 0
Input "Eine Zahl eingeben: " , X
Print "Die Zahl war: " ; X
End
Wenn Sie das Programm nun kompilieren und den Simulator aufrufen, sehen Sie bereits, ob es funktioniert. Drücken Sie dazu auf Play oder F5, wird links im Pro-grammcode Fenster ein kleiner Pfeil angezeigt, der die Stelle zeigt, an dem sich das Programm derzeit befindet.
Bild 12.5: Die Hardware-Simulation.
12.6 Die Hardware-Simulation Alle Variablen und Registerinhalte können im Simulator überwacht und simu-liert werden. Spielen Sie ruhig ein wenig mit dem Simulator herum. Es kann auch die Hardware wie das LCD, ADC usw. simuliert werden. Probieren Sie hin und wieder die Beispiele auch im Simulator aus, um sich mit ihm vertraut zu machen.
Im mittleren Teil des Simulators sehen Sie ein kleines Terminal. Hier werden die Werte ausgegeben und auch die Eingaben können darüber erfolgen.
74 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
12.7 Kommentare im Quelltext Wer sein Programm auch später noch richtig lesen und verstehen möchte, sollte seinen Quelltext exakt dokumentieren. Die Dokumentation kann man übersicht-lich im Quellcode selbst erstellen. Dazu gibt es unterschiedliche Kommentar-zeichen, die man dazu verwenden kann, normale Texte auszuklammern. In den Standardeinstellungen von BASCOM erscheint ein auskommentierter Text in Grün.
Beispiel: Kommentar.bas
' Ich bin ein einzeiliger Kommentar
REM Auch ich bin ein einzeiliger Kommentar
' (
Ich bin ein mehrzeiliger Kommentar, der immer länger und länger wird … ' )
12.8 Datentypen und Variablen Jedes Programm besteht aus verschieden Variablen – externen, die entweder von der Außenwelt wie von einem ADC oder I/O-Port stammen, oder internen, die man zur Verrechnung im Programm benötigt, um daraus wieder eine Ausgabe über ein LCD, einen Port, eine RS-232 etc. zu machen. Für die Programmierung stehen verschiedene Variablen-Typen wie Byte, Word, Integer usw. (siehe BASCOM-Hilfe) zur Verfügung. Diese müssen vor der Verwendung immer defi-niert werden. Das kann als Konstante oder als Variable geschehen.
Variablen-Namen=
In BASCOM-Basic-Variablen-Namen wird nicht zwischen Groß- und Kleinschrei-bung unterschieden. Außerdem ist der Unterstrich _ zugelassen. Dieser wird oft benutzt, um lange Variablen-Namen lesbarer zu machen. Schlüsselwörter wie If, While usw. dürfen als Variablen-Namen nicht verwendet werden. Globale Vari-ablen und Funktionen dürfen nicht denselben Namen besitzen. Außerdem können Funktionen innerhalb des Bezugsrahmens einer lokalen Variablen nicht benutzt werden, wenn sie denselben Namen wie die Variablen besitzen.
12.9 Lokale und globale Variablen 75
12.9 Lokale und globale Variablen Wenn eine Variable innerhalb einer Funktion, einer Prozedur, oder als Argument einer Funktion deklariert wird, ist sie lokal eingebunden. Dies geschieht dann nicht mit Dim, sondern mit der Anweisung Local. Das bedeutet für uns, dass die Variable nur innerhalb dieser Funktionsdefinition existiert. Eine außerhalb einer Funktion deklarierte Variable wird als globale Variable bezeichnet. Sie ist für alle Funktionen innerhalb unseres Programms definiert, einschließlich der Funktio-nen, die in anderen Dateien definiert sind (Include Files).
12.10 Variablen-Zuweisung Eine Variable in BASCOM kann als Hex-, Dezimal- oder Binärzahl, als String oder als String Array angegeben werden. In der folgenden Auflistung sehen Sie, welche Variablen-Typen möglich sind und wie viel Speicher dabei belegt wird.
• Bit (1/8 Byte) kann den Zustand 1 oder 0 speichern.
• Byte (1 Byte) kann Werte von 0 bis 255 aufnehmen.
• Integer (zwei Bytes) kann Werte von –32.768 bis +32.768 aufnehmen (16 Bit Integer).
• Word (zwei Bytes) kann Werte von 0 bis 65.535 annehmen.
• Long (4 Bytes) kann Werte von –2.147.483.648 bis 2.147.483.647 annehmen (32 Bit Long).
• Single-Variablen können Werte mit 32 Bit und Vorzeichen speichern. Der Bereich liegt zwischen 1,5 x 10–45 und 3,4 x 1038.
• Double können Werte mit 64 Bit speichern. Der Bereich liegt zwischen 5,0 x 10–324 und 1,7 x 10308
• String(bis zu 254 Bytes)-Variablen speichern Bytes mit einer 0 Terminierung ab. Wenn man 10 Zeichen in einen String schreiben möchte, muss man das String-Array mit einer Länge von 11 spezifizieren.
Beispiel: Variablen Zuweisung.bas
Const PI = 3.14 ' Konstante PI
Dim Variable As Byte ' Byte-Variable, Sie kann Werte von 0 bis ' 255 annehmen
Dim Var(9) As Byte ' Byte Array, hat eine ähnliche Bedeutung ' wie 10x ein Byte
76 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
' mit Dim Var X As Byte zu erstellen. ' Das jeweilige Byte ' wird über den Index angesprochen: Var( x) ' Die Arrays der Pro werden von 0 aus gezählt!
12.11 Arrays Ein Array (Feld) ist eine Anordnung von Variablen. Array bezeichnet in der Informatik eine Datenstruktur. Mithilfe eines Arrays können Daten eines üblicherweise einheitlichen Datentyps (Byte, Word usw.) geordnet so im Speicher eines Computers abgelegt werden, dass ein Zugriff auf die Daten über einen Index möglich wird. Der Index für ein Array startet bei BASCOM mit 1, bei anderen Compilern beginnt der Index mit 0. Zudem unterstützt BASCOM derzeit nur eindimensionale Arrays.
Bild 12.6: So kann man sich die Anordnung der Variablen im Speicher vorstellen.
Beispiel: Arrays.bas
' Bascom Arrays $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X(10) As Byte
Dim Y As Byte
For Y = 1 To 10
X(y) = Y
Next
For Y = 1 To 10
Print X(y)
Next
End
12.12 Operatoren 77
Das obige Beispiel verdeutlicht die Verwendung von Arrays. Erst werden dem Array über den Index die Werte der For-Next-Zählschleife zugewiesen (1 bis 10), danach werden die gespeicherten Werte ausgegeben.
12.12 Operatoren Jeder Datentyp verfügt über einige spezifische Operatoren, die angeben, welche Operationen auf den Typ angewendet werden können. Die folgende Auflistung zeigt eine Auswahl der BASCOM-Operatoren.
Arithmetik: Grundrechenarten
Vergleich: größer/kleiner usw.
Bitweise Arithmetik: And, Or, Xor, usw.
Boolesche Arithmetik: logische And-, Or-, Xor-Verknüpfung, usw., (wahr/falsch)
Ganze Zahlen: Char, Byte, Word, Integer, Long
Fließkommazahlen: Single, Double
Arithmetische Funktionen: Sin, Cos, Tan, usw.
Sehen Sie dazu auch in der Hilfe von BASCOM nach.
12.13 Kontrollstrukturen Jedes Programm benötigt, um auf Ereignisse reagieren zu können, Bedingungen, sogenannte Kontrollstrukturen. Diese werden mit If … Then … Else … End If angegeben. Die Ausgaben der Beispielprogramme erfolgen über das BASCOM-Terminalprogramm. Laden Sie die Beispiele auf das Mikrocontroller-Board und starten Sie danach das Terminalprogramm.
12.13.1 If Then – End if If [Variable A] = [Variable B] Then
' Hier steht der Code, der bei der Bedingung A=B ausgeführt ' wird End If
78 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Beispiel: If Then.bas
$regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
Main:
X = X + 1
If X = 10 Then
Print "X ist jetzt 10!"
Goto Ende
End If
Goto Main
Ende:
Print "fertig!"
End
Der Programmcode durchläuft so lange die Goto-Main-Schleife, bis X gleich 10 ist. Erst dann wird der Programmteil zwischen If und End If ausgeführt. Sie sehen: Mit If Then kann man einfach Programmverzweigungen realisieren.
12.13.2 If Then – Else – End if If [Variable A] > [Variable B] Then
' Code, der ausgeführt werden soll Else ' Oder wenn A nicht größer B ' Code, der ausgeführt werden soll End If
Beispiel: Else.bas
$regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
Main:
X = X + 1
If X <= 10 Then
Print X
Goto Main
12.13 Kontrollstrukturen 79
Else
Print "X ist bereits 10, Juhu!"
End If
End
Mit der Else-Anweisung kann man eine Alternative anbieten. Das Programm gibt so lange den Wert von X aus, bis X den Wert 10 erreicht hat. Erst wenn X größer/gleich 10 ist, wird der Programmteil zwischen Else und End if ausgeführt.
12.13.3 If und ElseIf Eine weitere Möglichkeit der mehrfachen Verschachtelung von If-Anweisungen ist ElseIf. Hier können unterschiedliche Zustände der Variablen abgefragt wer-den. Je nach Wahrheit (true oder false) wird der entsprechende Abschnitt in der ElseIf-Anweisung ausgeführt.
If [Variable A] <> [Variable B] Then
' Code, der ausgeführt werden soll ElseIf [Variable A] > [Variable B] Then
' Code, der ausgeführt werden soll ElseIf [Variable A] < [Variable B] Then
' Code, der ausgeführt werden soll End If
Beispiel: ElseIf.bas
$regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
Main:
X = X + 1
If X = 1 Then
Print "X = 1"
Elseif X = 2 Then
Print "X = 2"
Elseif X = 3 Then
Print "X = 3"
Else
Print "X = 4, Fertig!"
Goto Ende
End If
80 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Goto Main
Ende:
End
Je nach Wert der Variablen X ist der ausgegebene Text anders.
12.13.4 Select Case Ähnlich der ElseIf-Anweisung verhält sich der Befehl Select Case. Auch hier wird, je nachdem, welcher Wert true ist (also der Wahrheit entspricht), der entspre-chende Codeabschnitt ausgeführt. Alternativ kann mit Case Else eine Alternative angeboten werden, sollte nichts innerhalb von Case zutreffen.
Select Case [Variable]
Case 1
' Code, der ausgeführt werden soll, Variable = 1 Case Is > 10
' Code, der ausgeführt werden soll, Variable >10
Case Else
' Alternativ-Code, wenn alle anderen Bedingungen nicht ' zutreffen
End Select
Beispiel: Select Case.bas
$regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim Zahl As Byte
Main:
Input "Geben Sie eine Zahl ein: " , Zahl
Select Case Zahl
Case 1
Print "Zahl ist 1"
Case 2 To 10
Print "Die Zahl liegt zwischen 2 und 10"
Case Is > 10
12.14 Schleifen 81
Print "Die Zahl ist groesser 10"
Case Else
Print "Die Zahl ist Null"
End Select
Goto Main
Geben Sie in diesem Programm eine Zahl zwischen 0 und 255 ein. Über Select Case wird Ihnen BASCOM eine Antwort darauf geben, in welchem Bereich sich die Zahl befindet. Der zusätzliche Befehl Input dient zur Eingabe über das Terminalprogramm. Er gibt den Textstring Geben Sie eine Zahl aus: aus und übergibt Ihre Eingabe der Variablen mit dem Namen Zahl.
12.14 Schleifen Bei der Programmierung werden häufig Programmschleifen benötigt, z. B. um Dezimal- oder Binärzähler oder eine Hauptschleife zu realisieren. Es wird viel-leicht auch die serielle Schnittstelle so lange ausgelesen, wie Zeichen im Puffer sind – um nur einige zu nennen. Es gibt dafür verschieden Schleifentypen. Jede von ihnen hat ihre Eigenheiten.
12.14.1 For Next Die For-Next-Schleife zählt innerhalb eines angegeben Wertebereichs die Variable X hoch oder herunter. Dabei können bestimmte Schrittweiten (Steps) vorgegeben werden.
' Diese Schleife zählt von Var1 bis Var2 mit einer Schrittweite ' von 1 For X = [Var1] To [Var2]
'Code, der 10-mal durchlaufen werden soll
Next
' Die Variable X wird jetzt immer um 2 erhöht For X = [Var1] To [Var2] Step 2
' Code, der durchlaufen werden soll Next
' Variable X wird von Var1 auf Var2 heruntergezählt ' (Schrittweite 1) For X = Var1 To Var2 Step -1
' Code, der durchlaufen werden soll Next
82 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Beispiel: For Next.bas
$regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim Zahl As Byte
Dim X As Byte
Input "Wie weit soll ich zaehlen? " , Zahl
Print "Ich zaehle bis " ; Zahl
For X = 1 To Zahl
Print X
Next
Input "Wie weit soll ich zaehlen? " , Zahl
Print "Ich zaehle bis " ; Zahl ; " Schrittweite = 2"
For X = 1 To Zahl Step 2
Print X
Next
Input "Mit welcher Zahl soll ich beginnen? " , Zahl
Print "Ich beginne mit " ; Zahl
For X = Zahl To 1 Step -1
Print X
Next
Print "fertig!"
End
Übertragen Sie das Beispiel auf den Controller und starten Sie wieder das Termi-nalprogramm. Das Programm wird Sie nach einer Zahl fragen. Geben Sie einen Wert zwischen 1 und 255 ein. Die Variable X wird bei jedem Durchlauf ausgege-ben und zeigt Ihnen, was bei der For-Next-Schleife genau passiert. Sie werden sehen, dass wir bei einer For-Next-Schleife eine definierte Anzahl von n Durch-läufen mit einer gewünschten Schrittweite realisieren können. Mit dem Befehl Exit For können Sie die Schleife auch vorzeitig verlassen.
12.14.2 Do Loop und Do Until Weitere Varianten einer Schleife sind die Do-Loop- und die Do-Loop-Until-Ver-sion. Die Do-Loop-Until-Version wird einmal durchlaufen und prüft erst nach einem Durchlauf, ob die Bedingung erfüllt ist. D h., diese Schleife wird mindes-tens einmal durchlaufen. Die reine Do-Loop-Schleife wird gern für Endlosschlei-fen eingesetzt. Auch die Do-Loop-Schleife kann mit Exit-Do-Anweisung abgebro-chen werden.
12.14 Schleifen 83
' Endlosschleife Do
' Was auch immer wir hier tun wollen Loop
' Endlosschleife mit bedingtem Abbruch Do
Variable = Variable + 1
If Variable > 10 Then Exit Do
Loop
' Do Loop Until Do
Variable = Variable + 1
Loop Until Variable > X
Beispiel: Do Loop.bas
' Bascom Do Loop $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
X = 0
Do
X = X + 1
Print X
If X > 9 Then Exit Do
Loop
X = 0
Do
X = X + 1
Print X
Loop Until X > 9
Print "fertig!"
End
Endlosschleifen werden z. B. für das Hauptprogramm verwendet, da sonst das Programm nach einem Durchlauf beendet wäre.
84 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
12.14.3 While Wend Eine Schleifenvariante, die nur durchlaufen wird, wenn die Bedingung erfüllt ist (true), ist die While-Wend-Schleife. Sie prüft zu Beginn, ob die Bedingung erfüllt ist.
Beispiel: While Wend.bas
' Bascom While Wend $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
X = 0
While X < 10
X = X + 1
Print X
If X > 5 Then Exit While
Wend
While X < 3
X = X + 1
Print X
Wend
Print "fertig!"
End
Hier wird nur die erste While-Wend-Schleife durchlaufen. Die zweite Schleife wird nicht durchlaufen, weil X bereits größer 3 ist. Auch dieser Schleifentyp kann vorzeitig mit einer Exit-Anweisung beendet werden. In unserem Beispiel dann, wenn X größer 5 ist.
12.15 Funktionen, Prozeduren und Labels Funktionen benötigt man immer wieder. Sie machen das Programm wesentlich übersichtlicher, und auch eigene Befehle können damit verwirklicht werden. Man kann eigene Funktionen und Prozeduren (Unterprogramme ohne Rückgabe-wert), die man immer wieder benötigt, selbst schreiben und in kommenden Pro-jekten wiederverwenden (Modularität). Der Unterschied zwischen Funktion und Prozedur, oder allgemein Routine (Sub Routine) genannt, ist, dass eine Funktion im Gegensatz zu einer Prozedur einen Rückgabewert besitzt. In einer Funktion kann man z. B. eine mathematische Berechnung durchführen, die das Ergebnis an eine Variable zurückgibt.
12.15 Funktionen, Prozeduren und Labels 85
' Am Programmanfang muss die Prozedur bekanntgegeben werden. Declare Sub Unterroutine_xyz(Variablen, die Sie übergeben
möchten)
' Die eigentliche Prozedur Sub Unterroutine_xyz(Variablen, die Sie übergeben möchten)
' Hier könnten wir z. B. einen Port setzen End Sub
Der Aufruf in BASCOM geschieht nur durch die Eingabe des Prozedurnamens, in unserem Fall Unterroutine_xyz oder, wenn man Variablen übergeben möchte: Unterroutine(Variablen die übergeben werden sollen).
Achtung: Hier muss man auf den HW Stack, Soft Stack und die Frame Size achten! Werden diese zu klein ausgelegt, können Funktionen und Routinen nicht richtig behandelt werden. In der BASCOM-Hilfe findet man mehr darüber.
Original Konfiguration
$hwstack = 32 '
default use 32 for the hardware stack
$swstack = 10
'default use 10 for the SW stack
$framesize = 40
'default use 40 for the frame space
besser…
$hwstack = 64
$swstack = 20
$framesize = 80
12.15.1 Subroutinen Beispiel: Sub.bas
' Bascom Unterprogramme Subs $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
86 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Declare Sub Ausgabe_1()
Declare Sub Ausgabe_2()
Ausgabe_1
Ausgabe_2
End
Sub Ausgabe_1()
Print "Ausagbe 1"
End Sub
Sub Ausgabe_2()
Print "Ausgabe 2"
End Sub
12.15.2 Funktionen ' Am Programmanfang muss die Funktion bekanntgegeben werden. Declare Function Funktion_xyz(Variablen die übergeben werden)
Rückgabe Variable
' Die eigentliche Funktion Function Funktion_xyz(Variablen die übergeben werden) Rückgabe
Variable
' Hier könnten wir z. B. eine Berechnung durchführen End Function
Beispiel: Function.bas
‘ Bascom Funktionen $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Word
Declare Function Addiere(byval A As Byte , Byval B As Byte) As
Word
X = Addiere(10 , 13)
Print "Das Ergebnis = " ; X
End
Function Addiere(byval A As Byte , Byval B As Byte) As Word
Addiere = A + B
End Function
12.15 Funktionen, Prozeduren und Labels 87
Innerhalb der Klammer stehen die Übergabeparameter, nach der Klammer wird definiert, um welchen Variablen-Typ die Rückgabe erfolgen soll.
Je nachdem, wie eine Variable in einer Prozedur oder Funktion übergeben wer-den soll, muss die Zuweisung als Byval oder Byref erfolgen. Dazu finden Sie noch mehr Informationen in der Hilfe zu BASCOM.
12.15.3 Gosub Eine weitere Möglichkeit ist es, die Unterprogramme ohne Übergabe- oder Rückgabewert über Gosub anzuspringen. Hier muss die Prozedur nicht zuvor am Anfang des Programms bekannt gegeben werden.
' Der Aufruf der Routine Gosub Test_Routine
' Die Routine Test_Routine:
' auszuführender Programmcode Return
Beispiel: Gosub.bas
' Bascom Gosub $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim X As Byte
Gosub Zaehlen
End
Zaehlen:
For X = 1 To 10
Print X
Next
Return
12.15.4 Goto Eine weitere praktische aber mittlerweile veraltete Anweisung ist Goto (= gehe zur Markierung xxx). Dieser Befehl stammt aus Zeiten, in denen Basic-Pro-gramme noch mit Zeilennummern und Sprüngen geschrieben wurden. Es gibt zwar in unserem Basic noch die Möglichkeit, Zeilennummern anzuzeigen, aber sie dienen nur noch zur Orientierung und haben mit dem Programmablauf
88 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
nichts zu tun. Doch kann es hin und wieder sinnvoll sein, den Goto-Befehl zu verwenden. Er benötigt nur sehr wenig Ausführungszeit, da er in Assembler direkt ausgeführt werden kann. In den obigen Beispielen haben wir den Befehl Goto immer wieder für Endlosschleifen und zum Beenden des Programms ver-wendet. Wenn Sie im Besitz eines Oszilloskops sind, können Sie mit dem folgen-den Beispiel sehen, wie schnell der BASCOM und der kleine ATmega88 mit dem 16-MHz-Oszillator ist. Über eine Goto-Schleife wird der Portb.1 ein- und ausge-schaltet. Dabei wird eine Frequenz von knapp 3 MHz erreicht, was ein sehr guter Wert für ein Basic-Programm ist.
Start: ' Label anstatt Zeilennummer ' Code, der ausgeführt werden soll Goto Start ' Sprung zum Label Start
Beispiel: Goto.bas
' Bascom Goto $regfile = "m88def.dat"
$crystal = 16000000
Config Portb.1 = Output
Portb.1 = 0
Main:
Portb.1 = 1
Portb.1 = 0
Goto Main
TIPP: Goto kann man sehr gut zum Abbrechen, für einen Programmneustart oder zur Fehlerbehandlung nutzen.
12.15.5 On Eine weitere Verzweigung zu den bereits aufgeführten Varianten ist die On-Ver-zweigung. Je nachdem, welchen Wert die Variable angenommen hat, wird das dementsprechende Label angesprungen. Der Index der Variablen beginnt mit 0.
' Wenn eine Variable dem Wert entspricht (true), springe zu Label x. On [Var] Goto [Label 0], [Label 2],... [Label n]
End if
Beispiel: On.bas
' Bascom On $regfile = "m88def.dat"
$crystal = 16000000
12.16 String und String-Bearbeitung 89
$baud = 19200
Dim X As Byte
Do
Input "Welches Label (0 bis 2): " , X
On X Gosub Label0 , Label1 , Label2
Loop
End
Label0:
Print "Label 0"
Return
Label1:
Print "Label 1"
Return
Label2:
Print "Label 2"
Return
12.16 String und String-Bearbeitung Unter Strings versteht man eine Zeichenkette mit einem Character als Variab-leninhalt. In einem String können ASCII-Zeichen oder ganze ASCII-Zeichenket-ten abgespeichert werden. Kurz gesagt: Strings sind Character-Arrays.
12.16.1 Strings ' String mit der Länge 1, er kann nur 1 Zeichen enthalten Dim Text as string * 1
' String mit der Länge 10, er kann 10 Zeichen enthalten Dim Text as string * 10
Beispiel: Strings.bas
' Bascom Strings $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim Text1 As String * 1
90 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Dim Text2 As String * 10
Text1 = "A"
Text2 = "1234567890"
Print Text1
Print Text2
End
12.16.2 Ucase Mit Ucase konvertiert man einen String von Klein- in Großbuchstaben.
Beispiel: Ucase.bas
' Bascom Strings (Ucase) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 10
A = "franzis"
B = Ucase(a)
Print B
End
12.16.3 Lcase Mit Lcase konvertiert man einen String von Groß- in Kleinbuchstaben.
Beispiel: Lcase.bas
' Bascom Strings (Lcase) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 10
A = "FRANZIS"
B = Lcase(a)
Print B
End
12.16 String und String-Bearbeitung 91
12.16.4 Bin Mit Bin wandelt man ein Byte in einen binären String um.
Beispiel: Bin.bas
' Bascom Strings (Bin) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As Byte
B = 42
A = Bin(b)
Print A
End
12.16.5 Hex Mit Hex konvertiert man ein Byte in einen Hex-String.
Beispiel: Hex.bas
' Bascom Strings (Hex) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As Integer
Dim B As String * 4
A = 1023
B = Hex(a)
Print B
End
12.16.6 Hexval Mit Hexval wandelt man einen Hex-String in eine Zahl um.
Beispiel: Hexval.bas
' Bascom Strings (Hexval) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
92 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Dim A As Integer
Dim B As String * 2
B = "42"
A = Hexval(b)
Print A
End
12.16.7 Val Mit Val wandelt man eine String-Zahl in eine Zahl um.
Beispiel: Val.bas
' Bascom Strings (Val) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As Byte
A = "42"
B = Val(a)
Print B
End
12.16.8 Str Mit Str konvertiert man eine Zahl in einen String (also das Gegenteil von Val).
Beispiel: Str.bas
' Bascom Strings (Str) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As Word
B = 65535
A = Str(b)
Print A
End
12.16 String und String-Bearbeitung 93
12.16.9 String Mit String erzeugt man eine bestimmte Anzahl von einem ASCII-Zeichen.
Beispiel: StringConv.bas
' Bascom Strings (String) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
A = String(3 , 65)
Print A
End
12.16.10 Space Mit Space erzeugt man eine bestimmte Anzahl von Leerzeichen.
Beispiel: Space.bas
' Bascom Strings (Space) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As Byte
B = 10
A = Space(b)
Print "<" ; A ; ">"
End
12.16.11 Fusing Mit Fusing wird eine Single-Variable in einen String gewandelt. Diese Funktion rundet das Ergebnis dabei gegebenenfalls.
Beispiel: Fusing.bas
' Bascom Strings (Fusing) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
94 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
Dim A As Single
Dim B As String * 10
A = 128.1234567
B = Fusing(a , "#.###")
Print B
End
12.16.12 Format Mit Format formatiert man den Ursprungsstring. Dabei kann auch ein mathe-matisches Vorzeichen (+ oder -) mit angegeben werden.
Beispiel: Format.bas
' Bascom Strings (Format) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 6
Dim B As String * 6
A = "12345"
B = Format(a , "+")
Print B
A = "123"
B = Format(a , "00000")
Print B
A = "12345"
B = Format(a , "000.00")
Print B
A = "12345"
B = Format(a , " +000.00")
Print B
End
12.16 String und String-Bearbeitung 95
12.16.13 Len Mit Len bestimmt man die Länge eines Strings.
Beispiel: Len.bas
' Bascom Strings (Len) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As Byte
A = "Franzis"
B = Len(a)
Print B
End
12.16.14 Instr Mit Instr sucht man in einem String eine bestimmte Reihenfolge von Zeichen und gibt deren Position zurück. Es wird immer die zuerst gefundene Zeichen-kette zurückgegeben.
Beispiel: Instr.bas
' Bascom Strings (Instr) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 14
Dim B As String * 2
Dim C As Integer
A = "www.franzis.de"
B = "de"
C = Instr(a , B)
Print C
End
96 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
12.16.15 Mid Mit Mid ermittelt man den mittleren Teil eines Strings.
Beispiel: Mid.bas
' Bascom Strings (Mid) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 20
Dim B As String * 10
Dim C As Byte
Dim D As Byte
A = "Franzis ist super!"
C = 9
D = 3
B = Mid(a , C , D)
Print B
End
12.16.16 Split Mithilfe von Split teilt man einen String in einzelne kleine Blöcke auf. So kann man z. B. die einzelnen Wörter eines Satzes herausfiltern.
Beispiel: Split.bas
' Bascom Strings (Split) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A(5) As String * 10
Dim B As Byte
Dim C As Byte
B = Split( "Franzis ist super!" , A(1) , " ")
For C = 1 To B
Print A(c)
Next
End
12.16 String und String-Bearbeitung 97
12.16.17 Left Mit Left schneidet man einen bestimmten Ausschnitt des Strings von links aus heraus.
Beispiel: Left.bas
' Bascom Strings (Left) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 3
Dim C As Integer
A = "Franzis"
C = 5
B = Left(a , C)
Print B
End
12.16.18 Right Mit Right schneidet man einen bestimmten Ausschnitt des Strings von rechts aus heraus.
Beispiel: Right.bas
' Bascom Strings (Right) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 3
Dim C As Integer
A = "Franzis"
C = 3
B = Right(a , C)
Print B
End
98 Kapitel 12: BASCOM-AVR Basic – Programmierkurs
12.16.19 Ltrim Mit Ltrim entfernt man die Leerzeichen von der linken Seite eines Strings.
Beispiel: Ltrim.bas
' Bascom Strings (Ltrim) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 10
A = " Franzis"
B = Ltrim(a)
Print B
End
12.16.20 Rtrim Mit Rtrim entfernt man die Leerzeichen von der rechten Seite eines Strings.
Beispiel: Rtrim.bas
' Bascom Strings (Rtrim) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
Dim A As String * 10
Dim B As String * 10
A = "Franzis "
B = Rtrim(a)
Print B
End
12.16.21 Trim Mit Trim entfernt man die Leerzeichen (Space) auf beiden Seiten eines Strings.
Beispiel: Trim.bas
' Bascom Strings (Trim) $regfile = "m88def.dat"
$crystal = 16000000
$baud = 19200
12.16 String und String-Bearbeitung 99
Dim A As String * 15
Dim B As String * 15
A = " Franzis "
B = Trim(a)
Print B
End
Sommer
FRA
NZI
S
Ulli Sommer
Auf CD-ROM:• Komplette Software für den Einstieg• Über 100 Quellcodes zu den Experimenten• Open-Source-VB.NET-Programme zum Messen und Steuern
Mikrocontrollerprogrammieren mit
Bascom BasicMessen, Steuern, Regeln und Robotertechnikmit den AVR-Controllern
PC & ELEKTRONIK
Ulli Sommer
Mikrocontroller steuern, messen und regeln dieunterschiedlichsten Geräte, und jeder Controller ist fürseine spezielle Aufgabe programmiert.
Wie Sie einen Mikrocontroller programmieren und was Siealles benötigen, um Ihre eigenen Spezial-ICs zu erstellen,erfahren Sie in diesem Buch. Es zeigt Ihnen Schritt fürSchritt auf verständliche Weise, was Sie für den Einstieg in die ATMEL-AVR-Mikrocontrollerwelt benötigen. Sie erfahren, wie Sie bei der Hardware vorgehen müssen undwie man das Programmieren erlernt, um später seine eigene Software zu entwickeln.
Dieses Buch baut auf dem Basic-Compiler Bascom undden ATMEL-AVRs auf. Bascom ist ein moderner Basic-Compiler mit integrierter Entwicklungsumgebung undeignet sich für fast alle 8-Bit-AVR- und XMega-Mikrocon-troller der Firma ATMEL.
Viele Problemstellungen, die früher zeitaufwendig inAssembler oder C gelöst werden mussten, können durchdiesen modernen Compiler blitzschnell mit wenigen Befehlen erledigt werden, und sollte dies einmal nicht ausreichen, so stellt Bascom noch die Möglichkeit des Inline-Assemblers zur Verfügung.
Die ersten Kapitel des Buches vermitteln Ihnen die Programmierung mit Bascom in einem ausführlichenProgrammierlehrgang. Hier werden die Befehle anhandkleiner Beispiele verdeutlicht. Hard- und Software werdendetailliert erklärt, und am Ende macht Ihnen keiner mehrein Byte für ein Bit vor. Das erlernte Wissen aus dem Programmierkurs wird in den darauf folgenden Experi-menten kreativ und spielerisch in Mess-, Steuer- und Regelanwendungen eingesetzt. Das Buch wird Ihnen auch danach als Referenz und Nachschlagewerk nützliche Dienste erweisen.
Mikrocontrollerprogrammieren mit
Bascom Basic Aus dem Inhalt:• AVR: Grundlagen und
Programmierung• Ausführlicher Bascom-
Programmier-Einsteigerkurs• Schaltplan und Erklärung zu jedem
Experiment• Sensoren und Aktoren anschließen
und anwenden• Von den Grundlagen bis zur eigenen
Applikation• Über 100 praktische Experimente,
z. B. Ein-/Ausschaltverzögerung,Temperaturschalter, Kapazitäts-messgerät, GPS-Maus auslesen, Digitalvoltmeter mit AVR undVB.NET, Rasenmäh-Roboter, Steuernmit VB.NET, Ultraschallsensoren,Drehzahlmesser, Transistor-LED-Dimmer, Lüftersteuerung, DigitalesCodeschloss, Daten aufzeichnen mitStamp PLOT, Digitaler Datenplottermit VB.NET selbst gemacht,Bewegungsmelder, Alarmanlage,Dämmerungsschalter, Morsezeichen-Encoder, Morsezeichen-Decoder,Modellflug: Drohnen-Telemetrie-system u. v. m.
ISBN 978-3-645-65041-0
39,95 EUR [D]
Besuchen Sie uns im Internet: www.franzis.de
ISBN 978-3-645-65041-0 Mik
roco
ntro
ller p
rogr
amm
iere
n m
it Ba
scom
Bas
ic
65041-0 U1+U4_SC 05.09.2011 10:36 Uhr Seite 1