Maker-Projekte mit JavaScript E-Book

Gordon F. Williams

• Herausgeber: O'Reilly
• Kategorie: Wissenschaft und neue Technologien
• Serie: Make:
• Sprache: Deutsch
• Veröffentlichungsjahr: 2018

Seitenzahl: 300

Beschreibung

In einer Welt von Gadgets, die verwirrend viel können, führt Sie dieses Buch zurück auf die Grundlagen der Technik. Es zeigt Ihnen, wie Sie Ihren eigenen Scanner, Plotter, Ihre Kamera und vieles mehr mit ein paar Alltagsgegenständen und dem Espruino Mikrocontroller selbst bauen können. Mit der Internet-Programmiersprache JavaScript und einem Espruino – oder einem kompatiblen Mikrocontroller – realisieren Sie viele spannende Projekte und verstehen so, wie die Dinge von Grund auf funktionieren. Dabei entwickeln Sie Ihre Fähigkeiten und Kenntnisse weiter, sodass Sie in der Lage sind, auch eigene Ideen zum Leben zu erwecken und neue, clevere Objekte zu verwirklichen. Sie brauchen keine besonderen Fähigkeiten, Werkzeuge oder teure Komponenten, um interessante Geräte herzustellen. Dieses Buch ist perfekt für Einsteiger, aber auch für fortgeschrittene Maker geeignet. Es vermittelt Ihnen die Konzepte, die hinter den Alltagsgegenständen stecken, erklärt die Grundlagen der JavaScript-Progammierung und zeigt Ihnen, wie Sie alle Projekte mit dem Espruino und wenigen alltäglichen Komponenten selbst verwirklichen können. Espruino-Boards sind leicht erhältlich und der Espruino-Interpreter lässt sich auch auf vielen Standard-Boards nachinstallieren (z.B. BBC micro:bit, Raspberry Pi). Verwenden Sie Espruino mit nur wenigen gewöhnlichen Alltagsobjekten und lernen Sie: - Was ist ein Mikrocontroller und wie programmiert man ihn? - Die Grundlagen der JavaScript-Programmierung - Wie man einen Motor mit einem Weinkorken bastelt - Die Technik zur Herstellung eines eigenen Stroboskops - Einfache Roboter zu bauen - Wie man einen niedrig auflösenden Scanner selbst konstruiert - Die Grundlagen zum Bau eines funktionierenden Druckers - Wie bastele ich eine Digitalkamera?... und vieles mehr

Leseprobe

Der Autor

Gordon Williams ist ein Unternehmer und Erfinder aus der Gegend von Oxford. Schon als Kind schrieb er Software und spielte mit Elektronik, später studierte er Informatik an der Universität von Cambridge.

Gordon hat für verschiedene Technikunternehmen gearbeitet und sich dabei auf 3D-Grafik und Compilerdesign in verschiedenen Sprachen spezialisiert. Seit 2012 arbeitet er an dem JavaScript-Interpreter Espruino. Dabei hat er im Alleingang drei erfolgreiche Crowdfunding-Kampagnen gestartet und vier verschiedene Espruino-Geräte entwickelt.

Inzwischen entwickelt Gordon Espruino hauptberuflich weiter und unterstützt damit eine großartige Gemeinschaft von Espruino-Benutzern in aller Welt. Des Weiteren tritt er als Redner auf Veranstaltungen zu JavaScript, eingebetteter Software und bei Maker-Communitys in aller Welt auf.

Zu diesem Buch – sowie zu vielen weiteren O’Reilly-Büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei oreilly.plus + :

www.oreilly.plus

Maker-Projekte mit JavaScript

Mit Espruino und JavaScript aus Alltagsobjekten intelligente Maschinen bauen

Gordon F. Williams

Deutsche Übersetzung:G&U Language & Publishing Services GmbH

Gordon F. Williams

Lektorat: Michael Barabas

Übersetzung: G&U Language & Publishing Services GmbH, Flensburg (www.GundU.com)

Copy-Editing: Ursula Zimpfer

Satz: G&U Language & Publishing Services GmbH, Flensburg (www.GundU.com)

Herstellung: Susanne Bröckelmann

Umschlaggestaltung: Michael Oreal, www.oreal.de

Druckerei: M.P. Media-Print Informationstechnologie GmbH, 33100 Paderborn

Bibliografische Information der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

ISBN:

Print   978-3-96009-077-9

PDF    978-3-96010-189-5

ePub   978-3-96010-190-1

mobi   978-3-96010-191-8

1. Auflage 2018

Copyright © 2018 dpunkt.verlag GmbH

Wieblinger Weg 17

69123 Heidelberg

Authorized German translation of the English edition of Making Things Smart ISBN 9781680451894 © 2017 Gordon F. Williams, published by Maker Media Inc.This translation is published and sold by permission of O‘Reilly Media, Inc., which owns or controls all rights to publish and sell the same.

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten.

Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Alle Angaben und Programme in diesem Buch wurden von den Autoren mit größter Sorgfalt kontrolliert. Weder Autor noch Herausgeber noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buchs stehen.

In diesem Buch werden eingetragene Warenzeichen, Handelsnamen und Gebrauchsnamen verwendet. Auch wenn diese nicht als solche gekennzeichnet sind, gelten die entsprechenden Schutzbestimmungen.

5 4 3 2 1 0

Inhaltsverzeichnis

1.Einführung

Intelligente Geräte – wozu?

Lernen durch Bauen

JavaScript

Werkzeug und Material

Teil IMikrocontroller

2.Was sind Mikrocontroller?

Die Geschichte von ARM

Mikrocontroller programmieren

3.Erste Schritte mit dem Espruino

Vorbereitungen

Anschließen

Software installieren

Die Verbindung herstellen

Die Firmware aktualisieren

Erste Befehle

Der Editor

4.Erste Schritte mit JavaScript

Vorbereitungen

Kommentare

Datentypen

Mathematische Operatoren

Variablen

Inkrementieren und Dekrementieren

Objekte

Funktionen

Arrays

Objektorientierung

Bitarithmetik

If-Anweisungen

Die Operatoren && und ||

Der ternäre Operator

For-Schleifen

Ausnahmen

Teil IIMotoren

5.Elektromotoren

Experiment 1: Faradays Motor

Experiment 2: Motor mit Kommutator

Bürstenlose Gleichstrommotoren

Experiment 3: Schrittmotor

Experiment 4: Schrittmotorsteuerung

Experiment 5: Schrittmotorsteuerung für Fortgeschrittene

6.Stroboskop-Tachometer

Einen geeigneten Lüfter finden

Experiment 6: Drehzahlmessung

Experiment 7: Stroboskop

Experiment 8: Ein helleres Stroboskop

7.Der Fernseher von John Logie Baird

Experiment 9: Trägheit des Auges

Experiment 10: Der Fernseher von John Logie Baird

Teil IIIElektromechanik

8.Einen einfachen Roboter bauen

Experiment 11: Einen Servomotor ausprobieren

Experiment 12: Einen einfachen Roboter bauen

Experiment 13: Dem Licht folgen

9.Stiftplotter

Experiment 14: Stiftplotter

10.Digitale Lochkamera

Experiment 15: Eine Digitalkamera bauen

11.Drucker

Einen Drucker bauen

Teil IVKommunikation

12.Kabelgebundene Kommunikation

Taktung

Experiment 17: Ein Oszilloskop bauen

13.Kabellos: Infrarot

Experiment 18: Den IR-Empfänger bauen

Experiment 19: IR-Signale decodieren

Experiment 20: Das decodierte Signal verwenden

Experiment 21: Die Fernbedienung mit dweet.io im Web einsetzen

Experiment 22: Die Fernbedienung mit IFTTT im Web einsetzen

14.Kabellos: Funksignale

Experiment 23: Den Empfänger verkabeln

Experiment 24: Den Sender verkabeln

Experiment 25: Vom Espruino senden

Experiment 26: Die empfangenen Daten decodieren

15.WLAN-Verbindungen

Experiment 27: Den Pico WLAN-fähig machen

Experiment 28: Die Schaltung prüfen

Experiment 29: Die WLAN-Verbindung herstellen

Experiment 30: Daten ins Internet senden

Experiment 31: Daten aus dem Internet abrufen

Experiment 32: Einen Server erstellen

Geräte steuern

16.Bluetooth Low Energy

Wie funktioniert Bluetooth Low Energy?

Wie können wir Bluetooth LE verwenden?

Web Bluetooth

Experiment 33: Puck.js verwenden

Experiment 34: Einen Türöffnungszähler bauen

Experiment 35: Türöffnungsvorgänge bekannt geben

Experiment 36: Türöffnungswerte mit Eddystone empfangen

Teil VDas Gelernte anwenden

17.XY-Plotter

Experiment 37: Den Plottertisch bauen

Experiment 38: Den Plottertisch steuern

18.Plotter mit Internetanschluss

Experiment 39: Plotter mit Internetanschluss

Teil VISchlusswort

19.Wie geht es weiter?

A.Material

Gängige Komponenten

Motoren und Zubehör

Elektromechanische Komponenten

Kommunikation

Das Gelernte anwenden

B.Gängige Espruino-Befehle und -Variablen

print(text) und console.log(text)

LED1 und LED2

BTN1 oder BTN

digitalWrite(pin[s], value)

digitalRead(pin[s])

Pin.read(), Pin.write(value), Pin.set() und Pin.reset()

analogWrite (pin, value[, options])

analogRead(pin)

digitalPulse(pin, polarity, time[s])

pinMode(pin, mode)

reset()

save()

load()

onInit()

C.Espruino-Assembler

Assemblercode ausführen

Register

Anweisungen

Anspruchsvollerer Assemblercode

Index

1 Einführung

Intelligente Geräte – wozu?

Wir neigen dazu, kreative Tätigkeiten in Kategorien einzuteilen, die sich nicht überschneiden. Wir stellen uns kreative Personen entweder als Maler, Computerprogrammierer, Architekten oder Modeschöpfer vor.

Allen diesen Personen ist aber gemeinsam, dass sie in den letzten Jahren intelligente Komponenten in ihre Werke eingebaut haben. Heimautomatisierung, am Körper oder in der Kleidung tragbare Technologie (Wearable Computing) und intelligente Kunstinstallationen haben explosionsartige Verbreitung erfahren. Computerprogramme werden nicht mehr nur auf Laptops verwendet – wir haben inzwischen auch programmierbare Wasserkocher, Kleider, Autos und Klimaanlagen.

Selbst auf dem Gebiet der Technik ziehen wir noch Grenzen zwischen Mechanik, Elektronik und Software. Die Beherrschung jedes dieser Teilgebiete wird als eine eigene Fähigkeit betrachtet, und nur wenige Menschen kombinieren sie. Wenn Sie sich im Netz umschauen, werden Sie viele wunderschöne Holzkonstruktionen, komplizierte elektronische Schaltungen und einfallsreiche Computersoftware finden. Allerdings stößt man nur selten auf ein Projekt, das alle Techniken vereint.

Solche Unterscheidungen sind aber für intelligente Dinge, die wir in der realen Welt brauchen, nicht hilfreich. In diesem Buch zeige ich Ihnen, wie Sie einfache Hardware, Schaltungen und Software zu faszinierenden Maschinen kombinieren – und das alles mit Alltagsmaterialien und einfachen Bauteilen.

Nachdem Sie die Projekte in diesem Buch durchgearbeitet haben, besitzen Sie das Rüstzeug, selbst etwas zu kreieren und Ihre neuen Fähigkeiten und Kenntnisse einzusetzen, um intelligente Dinge zu bauen – seien es interessante bewegliche Skulpturen, funktionale Datenerfassungsgeräte, elegante Leuchthandtaschen oder Gadgets zur Automatisierung Ihres Zuhauses.

Lernen durch Bauen

Der Autor George Kneller sagte: »Eines der Paradoxa der Kreativität besteht darin, dass man sich mit den Ideen anderer vertraut machen muss, um selbst originell zu denken.« Seien wir ehrlich: Der Drucker, die Digitalkamera und der Fernseher, die Sie vermutlich besitzen, sind besser als diejenigen, die Sie in diesem Buch herstellen werden. Aber sehr wahrscheinlich wissen Sie nicht, wie die Geräte genau funktionieren, und sicherlich hätten Sie nicht gedacht, dass Sie solche Geräte zu Hause selbst aus einfachen Bauteilen und alltäglichen Materialien bauen können.

In einer Welt, in der die meisten Menschen über ein Telefon verfügen, das auch als Kamera, Videorecorder, Musikabspielgerät, Webbrowser und GPS-Navigationssystem fungiert, kann es schon sehr entmutigend sein, wenn man zu verstehen versucht, was genau in unseren technischen Geräten vor sich geht. Dieses Buch führt Sie zurück zu den Grundlagen. Während Sie die Projekte von Grund auf realisieren, lernen Sie die Prinzipien kennen, auf denen weit komplexere Technologien beruhen, und gewinnen so Einsicht in die grundlegenden Bausteine unserer modernen Welt.

Bei der Beschäftigung mit den Projekten und Anleitungen in diesem Buch werden Sie auch Ihre eigenen Fähigkeiten und Kenntnisse entwickeln. Mit dieser Erfahrung können Sie dann Ihre eigenen Ideen zum Leben erwecken und selbst intelligente Dinge bauen.

JavaScript

In diesem Buch lernen Sie, Ihre Hardware mit JavaScript zu programmieren. Dabei verwenden Sie den Espruino-Interpreter, der auf Ihrem Mikrocontroller läuft. JavaScript ist eine der am weitesten verbreiteten Programmiersprachen im Internet, zu der Sie online viel Unterstützung und Ressourcen finden. Ich habe den Espruino-Interpreter entwickelt, um JavaScript auch in der Welt der intelligenten Geräte verwenden zu können. Der Grund dafür war, dass die Leichtigkeit, mit der sich der Code ändern lässt, die iterative Entwicklung fördert.

In vielen Büchern über Mikrocontroller finden Sie komplette Listings des Computer-codes. Dieses Buch ist anders. Bei der Espruino-Programmierung können Sie die Software Zeile für Zeile aufbauen und dabei die Auswirkungen jeder Codezeile erkennen, sobald Sie sie hinzugefügt haben. Der Espruino stürzt auch nicht einfach sang- und klanglos ab. Wenn Ihr Code einen Fehler hervorruft, dann erhalten Sie eine Meldung, die Ihnen erklärt, was schiefgelaufen ist, und Sie auf die Stelle des Codes hinweist, in der das geschehen ist.

Das fördert nicht nur das Lernen, sondern macht auch viel mehr Spaß und gibt Ihnen hoffentlich das Selbstvertrauen, eigene Experimente zu wagen. Wenn Sie aber einfach nur das fertige Gerät ausprobieren möchten, finden Sie die vollständigen Listings immer noch online (https://github.com/espruino/making-things-smart).

Werkzeug und Material

Die Projekte in diesem Buch sind so gestaltet, dass Sie sie mit sehr einfachen Materialien und Werkzeugen bauen können. In den meisten Haushalten sind die erforderlichen Gegenstände vorhanden.

Da Sie eine Menge Pappe schneiden müssen, brauchen Sie eine kräftige Schere.

Gelegentlich müssen Sie auch Schneidarbeiten ausführen, für die eine Schere ungeeignet ist. Dazu benötigen Sie ein Cuttermesser und eine Unterlage.

Manchmal ist es erforderlich, etwas auf einen Holzblock zu schrauben oder Platten an einem Servomotor zu befestigen. Einfache Schraubendreher reichen dazu als Werkzeug völlig aus.

Wenn Sie Büroklammern oder Draht in spitze Winkel biegen müssen, können Sie sich mit einer Spitzzange das Leben erleichtern.

Sie müssen auch Draht schneiden und abisolieren. Dazu möchte ich Ihnen eine Abisolierzange ans Herz legen, also keines der automatischen Abisolierwerkzeuge. Besorgen Sie sich am besten eine Zange für Drahtstärken bis zu 0,5 mm.

Da Sie auch einige Nägel einschlagen müssen, benötigen Sie einen Hammer. Ein einfacher, leichter Hammer ist für unsere Zwecke bestens geeignet.

Ein Bohrer ist eigentlich nur im letzten Projekt erforderlich, allerdings kann Ihnen ein Handbohrer auch sonst die Arbeit erleichtern. Im letzten Kapitel erzielen Sie mit einer Ständerbohrmaschine (oder irgendeiner anderen Vorrichtung, um gerade Löcher zu bohren) die besten Ergebnisse.

Zu guter Letzt brauchen Sie noch eine Heißklebepistole. Bei einer ganzen Reihe von Projekten wird Heißkleber zur Befestigung verwendet, da er schnell fest wird, gut an Pappe haftet und sich von den meisten Oberflächen auch gut wieder abziehen lässt, wenn Sie ein Teil falsch positioniert haben oder es wiederverwenden möchten.

Teil I

Mikrocontroller

Die meisten von uns haben täglich mit Dutzenden oder gar Hunderten von Mikrocontrollern zu tun, ohne es zu bemerken.

Diese Geräte sind die idealen Computer – sie erleichtern uns das Leben, ohne jemals zu stören oder Schwierigkeiten zu verursachen.

In den Kapiteln dieses Buchteils befassen wir uns mit Mikrocontrollern, finden heraus, was sie sind, und sehen uns an, wie Sie sie gemeinsam mit dem Espruino und JavaScript verwenden können.

2 Was sind Mikrocontroller?

Ein Mikrocontroller ist ein kleiner, eigenständiger Computer. Ihr PC und wahrscheinlich auch Ihr Telefon bestehen aus verschiedenen Komponenten wie dem RAM, nicht flüchtigem Speicher wie Festplatten oder SSDs, Oszillatoren und der Stromversorgung. Bei den meisten Mikrocontrollern sind dagegen alle benötigten Elemente in einem einzigen Bauteil vereint: RAM, Flash-Speicher, Oszillatoren und ggf. sogar Spannungsregler. Die meisten Mikrocontroller müssen Sie lediglich an eine Batterie der passenden Spannung anschließen, um mit ihnen arbeiten zu können.

Die Grenzen zwischen den beiden Arten von Prozessoren verschwimmen mehr und mehr. Mikrocontroller sind heute schneller als Desktop-Computer es noch vor 20 Jahren waren, und in SoC-Prozessoren (System on Chip) von Geräten wie Mobiltelefonen sind mehr und mehr Komponenten integriert, um Kosten zu sparen. Der wahre Unterschied liegt im Verwendungszweck. Mikrocontroller werden in andere Geräte eingebettet und erledigen dort eine einzige Aufgabe (oftmals ohne Anzeige), während reguläre Computer Allzweckgeräte sind.

Die meisten von uns haben schon über Computer geflucht, weil sie nicht das taten, was wir erwartet haben. Mikrocontroller dagegen funktionieren so gut und so zuverlässig, dass wir ihr Vorhandensein meistens gar nicht wahrnehmen. Jeden Tag haben Sie mit hundert oder mehr Mikrocontrollern zu tun: in Ihrer Uhr, Ihrem Telefon, Ihrem Auto, Ihrer Kreditkarte, Ihrer Fahrradlampe usw. Sie arbeiten still im Hintergrund, um uns das Leben zu erleichtern.

Im Jahr 2015 wurden 15 Milliarden ARM-Kerne (Advanced RISC Machines) lizenziert. Das sind zwei für jeden Menschen auf der Erde. ARM-Mikrocontroller stellen aber nur eine der vielen verschiedenen Arten von Mikrocontrollern dar. Die tatsächliche Anzahl produzierter Mikrocontroller ist daher weitaus höher. Sie sind praktisch überall zu finden.

Mikrocontroller gibt es in unterschiedlichen Formen und Größen. Manche sind nur so groß wie ein Sandkorn, während andere die Maße einer Briefmarke einnehmen. Ihr RAM kann nur 16 Bytes, aber auch eine Million Bytes umfassen. Es gibt sie auch mit verschiedenen Architekturen, die sich durch die Anweisungen und deren Ausführung unterscheiden.

Übliche Architekturen für Mikrocontroller sind PIC und MIPS (verwendet von Microchip), AVR (Atmel) und ARM (ST, Atmel, Nordic, Freescale, Silicon Labs usw.). PIC und AVR wurden zunächst für 8-Bit-Prozessoren entwickelt. Dabei operieren die einzelnen Anweisungen auf 8-Bit-Werten (Zahlen zwischen 0 und 255), was die Prozessoren sehr klein und für einfache Aufgaben sehr wirtschaftlich macht, wohingegen kompliziertere Aufgabenstellungen wie die Multiplikation von 32-Bit-Zahlen lange dauern können.

Die ersten PIC- und AVR-Mikrocontroller hatten nur sehr wenig Speicher. Beispielsweise verfügte der AVR-Mikrocontroller AT90S8515 nur über 8 KB Flash-Speicher und 512 Byte RAM. Dass für den Zugriff auf den RAM nur 8-Bit-Zahlen zur Verfügung standen, war kein großes Problem, da man erst auf die eine und dann auf die andere Hälfte zugreifen konnte. Diese Prozessoren nutzten auch die Harvard-Architektur, bei der RAM und der Flash-Speicher komplett voneinander getrennt waren. Das war sinnvoll, da das Design damit sehr einfach gehalten werden konnte: Die Anweisungen für den Mikrocontroller wurden im Flash-Speicher ausgeführt und die Daten im RAM gespeichert.

Als in Mikrocontrollern immer mehr RAM verfügbar wurde (und die Erwartungen der Programmierer wuchsen, die sich keine Gedanken mehr darüber machen wollten, ob sich ihre Daten nun im Flash-Speicher oder im RAM befanden), mussten die Prozessoren jedoch erheblich mehr Zeit für Berechnungen aufwenden, nur um auf den richtigen Teil des Speichers zuzugreifen. Die Kompromisse, die bei einem Speicher von nur 0,5 KB sinnvoll gewesen waren, wirkten in umfangreicheren Systemen nun äußerst ineffizient.

Die Geschichte von ARM

Der erste ARM-Chip wurde 1985 von Steve Furber und Sophie Wilson bei Acorn Computers in Cambridge konstruiert. Damals begann Acorn gerade damit, den BBC Micro Model B+128 zu produzieren, der, wie der Name schon sagt, über einen RAM von 128 KB verfügte. Das waren 64 KB mehr, als der 16-Bit-Prozessor dieses Computers direkt adressieren konnte.

Die Ingenieure bei Acorn waren offensichtlich sehr vorausschauend. Ihnen war klar, dass sie in den nächsten Jahren Computer mit noch viel mehr Arbeitsspeicher bauen würden. Sie brauchten eine einfache Möglichkeit, um effizient auf mehr Arbeitsspeicher zuzugreifen, und deshalb entschieden sie sich, einen 32-Bit-Prozessor zu entwickeln.

WARUM KEINE ANDERE BITANZAHL?

Praktisch jeder Computer verwendet Mehrfache von 8 Bits. Nach 16 Bits wäre die nächste offensichtliche Möglichkeit daher 24 Bits. Das hätte beim Speicherzugriff jedoch eine Multiplikation mit 3 und – was entscheidend ist – eine Division durch 3 erfordert. Für den Zugriff auf das 18. Byte müssten Sie beispielsweise auf das 6. Wort (18/3) zurückgreifen.

Im Binärsystem (und ganz allgemein in der Mathematik) ist die Division durch die meisten Zahlen ziemlich schwierig. Einfach wird es dagegen, wenn Sie durch die Basiszahl des Zahlensystems dividieren. Im Dezimalsystem verwenden wir die Basis 10. Daher ist es ganz einfach, etwa 3.732.867.532 durch 10 zu teilen: Sie nehmen einfach die 2 am Ende weg. Die Division durch 100 oder 1000 ist ebenso einfach. Wollen Sie dagegen durch 7 teilen, wird es knifflig!

Im Binärsystem mit der Basis 2 verhält es sich ebenso. Die Division von 10010101110 durch 3 ist schwierig, die Division durch 2, 4, 8, 16 usw. dagegen ist einfach: Sie entfernen einfach die Stellen am Ende.

Bei ARM fiel die Wahl auf einen 32-Bit-Prozessor, sodass man einfach mit 4 multiplizieren und durch 4 dividieren konnte, um Adressen zu berechnen. Bei modernen Computern, die oft mehr als 4 GB RAM haben, musste die Größe erneut angehoben werden. Um mit 8 multiplizieren und dividieren zu können, ging man dabei zu 64 Bit über. Hierdurch kann auf so viele Daten verwiesen werden, dass wir damit noch eine ganze Weile auskommen werden!

Der ARM-Kern wurde von Anfang an als 32-Bit-Prozessor ausgelegt, wobei jede Anweisung mit Zahlen zwischen 0 und 4.294.967.295 umgehen können muss. Das machte die Sache zwar etwas komplizierter, aber nicht so schlimm, wie es den Anschein hat. Die Registerbits und die arithmetischen Logikeinheiten waren modular aufgebaut, sodass eine funktionierende Konstruktion für ein Bit einfach 32 Mal wiederholt werden konnte.

Mit der Möglichkeit, 32-Bit-Zahlen auf einmal zu speichern und zu verarbeiten, konnte ARM problemlos eine Von-Neumann-Architektur verwenden, bei der sowohl Anweisungen als auch Daten im selben Adressraum gespeichert werden. Eine einzige Anweisung kann Daten aus dem RAM oder ROM laden, wobei die Adresse den Bereich bestimmt. Das machte den Anweisungssatz des ARM-Prozessors sehr einfach und erleichterte die Programmierung dafür.

Der ARM-Kern war ursprünglich für voll ausgestattete Computer gedacht. In einigen wenigen davon sowie in fast allen Mobiltelefonen und Tablets wird er auch heute noch als Hauptprozessor verwendet. Mit zunehmender Leistungsfähigkeit von Mikrocontrollern wurde die ARM-Architektur jedoch auch für sie eingesetzt.

Mikrocontroller programmieren

Computer lesen in ihrem Arbeitsspeicher Anweisungen, die ihnen mitteilen, was sie tun sollen. Um diese schnell und effizient ausführen zu können, müssen diese Anweisungen für den Computer leicht verständlich sein. Deshalb ist die Gestaltung dieser Anweisungen mit hohem Aufwand verbunden. Leider ist das, was für einen Computer leicht zu verstehen ist, für Menschen oft alles andere als leicht verständlich.

Nehmen Sie beispielsweise an, Sie wollen die Zahlen von 1 bis 10 addieren. Die Anweisungen für einen ARM-Prozessor (der Maschinencode) sehen wie folgt aus:

e3 a0 50 00

e3 a0 40 01

ea 00 00 01

e0 85 50 04

e2 84 40 01

e3 54 00 0a

da ff ff fb

Für Menschen ist das weder leicht zu verstehen noch zu schreiben. Da wir es mit einem 32-Bit-Prozessor zu tun haben, bildet jede Zeile von vier Bytes eine Anweisung. Die Sache wäre schon viel leichter zu verstehen, wenn wir einfach aufschreiben könnten, was in jeder Zeile geschehen soll:

e3 a0 50 00 mov r5, #0

e3 a0 40 01 mov r4, #1

loopstart:

ea 00 00 01 b loopcheck

e0 85 50 04 add r5, r5, r4

e2 84 40 01 add r4, r4, #1

loopcheck:

e3 54 00 0a cmp r4, #10

da ff ff fb ble loopstart

Dies ist die sogenannte Assemblersprache, also die Darstellung der vom Computer ausgeführten Anweisungen in Textform. Jede Zeile (außer den Labels, die mit einem Doppelpunkt enden) stellt eine Anweisung dar. Mehr darüber erfahren Sie in Anhang C, mit dessen Hilfe Sie versuchen können, Assemblercode für den Espruino zu schreiben.

Die Übersetzung von Assembler- in Maschinencode war ursprünglich ein sehr langsamer Vorgang, der manuell ausgeführt werden musste. Mittlerweile aber gibt es eine als Assembler bezeichnete Software, die diese Umwandlung automatisch erledigt. Da unser Mikrocontroller jedoch noch gar keine Software enthält, müssen wir den Assembler erst auf unserem PC ausführen, um den Maschinencode zu erhalten, und diesen dann an den Mikrocontroller senden.

Assemblercode zu schreiben ist jedoch immer noch ziemlich schwierig. Einfacher geht es mit einer Programmiersprache, die für Menschen besser geeignet ist. Der folgende Quellcode wurde in einer Sprache namens C verfasst:

Eine weitere Software, die als Compiler bezeichnet wird (und im Grunde genommen nur eine kompliziertere Version eines Assemblers ist) und die Sie auf Ihrem PC ausführen können, nimmt diesen einfacheren Code entgegen und wandelt ihn in Maschinencode um, den sie anschließend an den Mikrocontroller senden können. Da Sie hier einen Computer verwenden, um den Code für eine andere Art von Computer zu kompilieren, wird dieser Vorgang Kreuzkompilierung genannt.

COMPILEROPTIMIERUNG

Der in diesem Beispiel gezeigte Assemblercode wird in Wirklichkeit niemals generiert. Moderne Compiler optimieren den von Ihnen geschriebenen Code. Wenn Sie beispielsweise 1+2 schreiben, dann fügt der Compiler einfach 3 in den Code ein.

Ein moderner Compiler würde sogar bemerken, dass die obige Schleife stets 55 ergibt, und sie daher gleich durch dieses Resultat ersetzen. Er ordnet sogar Ihren Code um und entfernt Teile, wenn er feststellt, dass sie niemals ausgeführt werden.

Zur Fehlerbehebung (Debugging) können Sie diese Optimierungen jedoch ausschalten. Dadurch ist es möglich, die Anweisungen manuell eine nach der anderen zu durchlaufen. Und so habe ich auch den gezeigten Assemblercode erhalten.

Auf diese Weise werden die meisten Mikrocontroller programmiert. Es gibt allerdings ein Problem: Der hier gezeigte Quellcode hat keine Ähnlichkeit mit dem Maschinencode, der an den Mikrocontroller gesendet wird. Wenn der Mikrocontroller bestimmte Anweisungen nicht ausführen kann (etwa wenn wir die Zahlen von 1 bis 100.000 addieren wollen, wobei die Zahlen so groß werden, dass sie nicht mehr in 32 Bits passen), gibt es keine einfache Möglichkeit, um vom Maschinencode wieder zum ursprünglichen Quellcode zurückzukehren, in dem sich der Fehler befindet.

Die meisten professionellen Programmierwerkzeuge bieten eine Lösung für dieses Problem. Sie können an den Mikrocontroller eine besondere Hardware anschließen, um sich genau anzusehen, was geschieht, und die einzelnen Stellen zum ursprünglichen Quellcode zurückverfolgen. Für die meisten Personen (u. a. die Benutzer herkömmlicher Arduino-Platinen) bildet der Mikrocontroller jedoch im Grunde genommen eine Blackbox.

Nachdem der Quellcode kompiliert und das Ergebnis an den Mikrocontroller gesendet wurde, gibt es keine Rückmeldung. Der Mikrocontroller führt den Code aus und macht dabei genau das, was Sie ihm gesagt haben. Tritt aber ein Fehler auf, kann Ihnen der Mikrocontroller nicht mitteilen, wo er liegt. Wenn Sie beobachten wollen, was Ihr Code macht, müssen Sie speziell dafür Code hinzufügen. Als Rückmeldung können Sie beispielsweise die Spannung an einem Pin ändern lassen oder Zeichen über ein Peripheriegerät auf dem Chip senden, die Sie dann auf Ihrem Computer lesen können.

Eine andere Lösung besteht darin, auf dem Mikrocontroller besonderen Maschinencode unterzubringen, der Ihren Quellcode liest und direkt ausführt. Dies ist ein sogenannter Interpreter. Diese Vorgehensweise ist nicht sehr wirtschaftlich, da der Mikrocontroller jetzt neben Ihrem Code auch noch den Interpretercode ausführen muss. Allerdings kann der Interpreter Ihren Code überprüfen und Fehler melden, anstatt einfach abzustürzen.

JIT-KOMPILIERUNG

Viele moderne Interpreter verwenden eine Just-in-Time-Kompilierung (JIT). Sie enthalten dazu einen Compiler, mit dem sie Ihren Quellcode in Maschinencode kompilieren, wenn er ausgeführt werden soll.

Ist der Code einmal kompiliert, muss der Interpreter also nicht mehr jede Anweisung einzeln interpretieren. Dadurch läuft das Programm schneller. Die Kompilierung dauert jedoch einige Zeit, weshalb die meisten Interpreter Ihren Code nur dann kompilieren, wenn sie feststellen, dass er häufig verwendet wird. Wird Code nur einmal aufgerufen, so wird er nur interpretiert und nicht kompiliert.

Eine Ausnahme bildet der Interpreter V8 von Google. Er kompiliert Ihren Code immer und ist daher sehr schnell. Wenn Sie Ihren Code häufig verwenden, versucht er es erneut und wendet noch mehr Zeit dafür auf, Möglichkeiten zur Optimierung zu finden, um ihn noch schneller ausführen zu können.

Mit einem Interpreter auf dem Mikrocontroller brauchen Sie auch keinen Compiler auf Ihrem Hostcomputer mehr. Praktisch alles, was Sie brauchen, befindet sich dann auf dem Mikrocontroller. Auf Ihrem Computer benötigen Sie daher nur eine Möglichkeit, um Zeichen zu senden und zu empfangen.

So funktioniert auch der Espruino: Code, der sich bereits auf dem Mikrocontroller befindet, ermöglicht es ihm, den von Ihnen eingegebenen JavaScript-Code auszuführen, ohne dass Sie dafür eine besondere Software auf Ihrem PC installieren müssen.

3 Erste Schritte mit dem Espruino

Es wird Zeit, uns die Hardware anzusehen.

Der Einfachheit halber betrachten wir hier nur den Espruino Pico, der den anderen Espruino-Platinen stark ähnelt (siehe Abb. 3-1). Sie können die Espruino-Firmware auch auf anderen Platinen ausführen (nachdem Sie sie dort geladen haben), aber damit wollen wir uns hier nicht beschäftigen. Ausführliche Informationen über unterstützte Platinen und Installationsanweisungen erhalten Sie auf der Espruino-Website (http://www.espruino.com).

Abbildung 3–1.Der Espruino Pico mit Schnellreferenzkarte

Der Espruino Pico ist bei verschiedenen Händlern weltweit erhältlich (http://www.espruino.com/Order).

Wenn Sie Puck.js verwenden (ein eigenständiges Bluetooth-Gerät mit dem Espruino-Interpreter), benötigen Sie keinen USB-Anschluss und können den ersten Abschnitt dieses Kapitels überspringen. Befolgen Sie stattdessen die Anweisungen auf http://www.puck-js.com/go.

Vorbereitungen

Wenn Sie den Espruino Pico über USB an Ihren PC anschließen, sollte er als USB-Standardgerät am virtuellen COM-Port angezeigt werden. Auf einigen Plattformen müssen Sie jedoch dazu einige Vorbereitungen treffen.

Wenn Sie keine Lust haben, die Links abzutippen, können Sie auch einfach die Links im Espruino Quick Start Guide auf http://s.espruino.com nutzen.

Mac und Chromebook

Hier müssen Sie nichts weiter tun, als einfach den Pico anzuschließen.

Windows

Für Windows-Versionen außer XP (10, 8, 7, Vista) müssen Sie die ST-Treiber für den virtuellen COM-Port in Version 1.4.0 herunterladen (http://www.espruino.com/files/stm32_vcp_1.4.0.zip).

Für Windows XP benötigen Sie die Version 1.3.1 (http://www.espruino.com/files/stm32_vcp_1.3.1.zip).

Nachdem Sie die Datei heruntergeladen haben, müssen Sie Folgendes tun:

1. Öffnen Sie das ZIP-Archiv.

2. Führen Sie die darin befindliche ausführbare Datei aus. (Die anderen Dateien müssen Sie nicht entpacken.)

3. Folgen Sie den Anweisungen des Installers.

4. Öffnen Sie den Windows Explorer und wechseln Sie zu

C:\Programme (x86)\ STMicroelectronics\Software\Virtual comport driver

. (Auf 32-Bit-Systemen heißt der Ordner

Programme (x86)

einfach

Programme

.)

5. Führen Sie die ausführbare Datei für Ihr System aus (

amd64

für einen 64-Bit- und

x86

für einen 32-Bit-Computer).

Linux (einschließlich Raspberry Pi)

Unter Linux funktioniert der Espruino Pico einfach so, allerdings haben Standardbenutzer keine Zugriffsrechte. Um das zu korrigieren, gehen Sie wie folgt vor:

1. Laden Sie die Datei

45-espruino.rules

herunter (

https://github.com/espruino/Espruino/blob/master/misc/45-espruino.rules

).

2. Kopieren Sie sie mit

sudo cp 45-espruino.rules /etc/udev/rules.d

in

/etc/udev/rules.d

.

3. Führen Sie

sudo udevadm control --reload-rules

aus, um die Udev-Regeln ohne Neustart neu zu laden.

4. Geben Sie

groups

ein. Achten Sie darauf, dass Ihr Benutzer ein Mitglied der Gruppe

plugdev

ist.

5. Ist das nicht der Fall, geben Sie

sudo adduser $USER plugdev

ein. Danach melden Sie sich ab und wieder an.

Anschließen

Für die meisten Projekte in diesem Buch brauchen Sie ein USB-Verlängerungskabel von Typ A auf A, also mit dem großen, rechteckigen Stecker an dem einen Ende und der großen, rechteckigen Buchse am anderen. Wenn Sie einen modernen Mac verwenden, kann es sein, dass Sie auch einen Adapter benötigen, um Ihren Computer mit einer USB-Standardbuchse vom Typ A zu versehen.

Sie können den Pico zwar direkt am Computer einstecken, aber dann wird es ziemlich schwierig, andere Geräte mit dem Pico zu verbinden. Ein USB-Verlängerungskabel gibt Ihnen mehr Flexibilität.

Andere Espruino-Platinen wie der Original-Espruino und der Espruino WiFi haben einen Micro-USB-Anschluss (und zwar den Typ, der 2017 in den meisten der günstigeren Mobiltelefone verwendet wurde).

Der einzige Kniff besteht nun darin, dass Sie den Espruino richtig herum anschließen müssen (siehe Abb. 3-2). Die goldenen Kontakte des Espruino Pico müssen zu dem Plastikeinsatz der USB-Buchse zeigen, nicht zum Metallschild (sonst wird kein Kontakt hergestellt).

Wenn alles richtig angeschlossen ist, blinkt die rote LED auf dem Espruino für einen Sekundenbruchteil auf. Unter Windows kann es mehrere Minuten dauern, bis die Platine als Kommunikationsport erkannt wird, aber diese Zeit können Sie nutzen, indem Sie schon einmal die Espruino-IDE installieren.

Abbildung 3–2.Anschließen des Espruino Pico an eine USB-Buchse. Achten Sie darauf, dass die goldenen USB-Kontakte des Pico zu der Kunststoffseite der USB-Buchse zeigen.

Software installieren

Der Espruino kann jetzt über eine beliebige Terminalanwendung verwendet werden (in der er als normaler Kommunikationsport erscheint). Am besten lässt es sich jedoch mit einem praktischen Editor und Debugger arbeiten, weshalb Sie die Espruino-Web-IDE installieren sollten.

Zurzeit lässt sich die Web-IDE noch direkt aus Chrome heraus installieren (siehe Abb. 3-3). Google hat jedoch angekündigt, den Chrome-Webstore Ende 2017 einzustellen. Daher ist die Web-IDE auch als separater Download erhältlich (http://www.espruino.com/Web+IDE).

Abbildung 3–3.Das Logo des Webbrowsers Chrome

Als Erstes müssen Sie sich den Webbrowser Chrome beschaffen (http://google.com/chrome; siehe Abb. 3-4).

Abbildung 3–4.Die Downloadseite für Chrome

Öffnen Sie Chrome, wechseln Sie zum Chrome-Webstore (siehe Abb. 3-5), geben Sie in das Suchfeld Espruino ein und klicken Sie auf Espruino Web IDE.

Abbildung 3–5.Der Eintrag für die Espruino-Web-IDE im Chrome-Webstore

Wenn Sie die App nicht finden, können Sie auch direkt über http://bit.ly/2ojgtBl darauf zugreifen.

Klicken Sie oben rechts auf das Symbol , um die App zu installieren.

Klicken Sie auf , um die Web-IDE zu starten. Sie steht auch auf dem Startbildschirm und im App Launcher von Chrome zur Verfügung. Daraufhin wird der Bildschirm aus Abbildung 3-6 angezeigt.

Abbildung 3–6.Die Espruino-Web-IDE

Die Verbindung herstellen

Wenn Sie das Programm zum ersten Mal starten, sehen Sie eine Kurzeinführung, die Ihnen die verschiedenen Teile der IDE vorstellt.

Danach geht’s auch schon los! Klicken Sie auf das orangefarbene Symbol oben links. Daraufhin erscheint ein Pop-up-Fenster mit einer Liste der verfügbaren Ports, unter anderem Espruino (siehe Abb. 3-7).

Abbildung 3–7.Der Portselektor der Web-IDE zeigt die angeschlossene Espruino-Platine.

Sollte die Platine nicht angezeigt werden, schlagen Sie auf http://www.espruino.com/Troubleshooting nach, woran der Fehler liegen könnte und wie Sie ihn beheben können.

Klicken Sie jetzt auf das Menüelement für die Espruino-Platine. Nach wenigen Sekunden verschwindet das Menü. Auf der linken Seite wird Connected angezeigt (siehe Abb. 3-8).

Abbildung 3–8.Die Web-IDE, nachdem die Verbindung zum Espruino hergestellt ist

Die Firmware aktualisieren

Wenn Sie die Verbindung herstellen, wird sehr wahrscheinlich ein gelbes Warnsymbol in der oberen rechten Ecke angezeigt (siehe Abb. 3-8). Das bedeutet, dass die Firmware auf dem Espruino veraltet ist. Die Software des Espruino wird ständig verbessert, weshalb die werkseitig darauf installierte Software meistens schon nicht mehr auf dem neuesten Stand ist.

Um unnötige Probleme zu vermeiden, sollten Sie die Firmware wie folgt aktualisieren:

1. Klicken Sie auf das gelbe Warndreieck. Daraufhin wird der Bildschirm

Flasher

eingeblendet (siehe

Abb. 3-9

). Dieses Fenster können Sie auch erreichen, indem Sie auf das Einstellungssymbol oben rechts und dann auf der linken Seite des daraufhin eingeblendeten Menüs

Settings

auf

Flasher

klicken.

Abbildung 3–9.Das Menü der Web-IDE zur Aktualisierung der Espruino-Firmware

2. Klicken Sie auf

Flash Firmware

und befolgen Sie die Anweisungen. Die Aktualisierung der Firmware dauert etwa eine Minute.

3. Vergewissern Sie sich, dass die Lämpchen auf dem Espruino nicht blinken, denn das würde bedeuten, dass sich die Platine immer noch im Boot-Ladermodus befindet. Wenn das der Fall ist, ziehen Sie sie ab und schließen Sie sie neu an.

4. Klicken Sie erneut auf das Verbindungssymbol oben links, um die Verbindung mit der Platine wiederzustellen, und wählen Sie sie aus der Liste aus.

Erste Befehle

Jetzt können Sie endlich loslegen!

Die linke Seite der IDE, mit der Sie bis jetzt herumgespielt haben, ist die Espruino-Konsole (manchmal auch REPL genannt), die eine direkte Verbindung zum Mikrocontroller herstellt. Wenn Sie eine Taste auf der Tastatur drücken, wird dieser Vorgang in Datenbytes übersetzt, die an die Platine gesendet werden, und für jedes dieser Zeichen sendet die Platine wiederum Daten zurück.

Das Gleiche können Sie auch mit einer beliebigen VT100-Terminalanwendung erreichen (z. B. screen auf dem Mac oder PuTTY auf Windows). Die Web-IDE kann aber noch viel mehr leisten.

Der Editor

Auf der rechen Seite der IDE befindet sich der JavaScript-Editor. Er ist schon vorab mit folgendem Code ausgefüllt:

Dieser Code bringt die rote LED zum Blinken. Statt digitalWrite(…) wie in unserem Beispiel verwendet dieser Code LED1.write(…). Dies ist einfach nur ein anderer Weg, um das Gleiche zu erreichen (also den Status eines digitalen Ausgangs festzulegen). Die Funktion setInterval ruft die ihr übergebene Funktion alle 500 Millisekunden auf, also zweimal pro Sekunde. Eine genauere Erklärung, was all diese Befehle bedeuten, erhalten Sie in Kapitel 4.

Um den Text übersichtlicher zu gestalten, zeigt der Editor die verschiedenen Arten von Wörtern in unterschiedlichen Farben an. Außerdem bietet er noch einige andere praktische Funktionen:

1. Wenn Sie auf ein Wort wie

write

klicken und + drücken, erscheint ein Pop-up-Fenster mit einer Erklärung, was diese Funktion tut.

2. Wenn Sie beispielsweise

di

eingeben und + drücken, wird ähnlich wie bei der Autovervollständigung in der Konsole eine Liste von möglichen Funktionen angezeigt, diesmal aber noch mit Beschreibungen.

Des Weiteren können Sie auch nach Variablen suchen, ihre Definitionen einsehen und sie umbenennen. Weitere Informationen erhalten Sie, indem Sie auf das Symbol Einstellungen in der oberen rechten Ecke und dann auf About klicken.

Jetzt aber wollen wir einfach den vorhandenen Code zum Laufen bringen. Klicken Sie dazu auf die Schaltfläche Upload. Wenn Sie den Mauszeiger über diese Schaltfläche halten, sehen Sie den Hinweis Send to Espruino. Der Code, der auf der rechten Seite der IDE steht, wird dadurch auf den Espruino hochgeladen und sorgt dafür, dass die LED blinkt. Dabei erledigt er die folgenden wichtigen Aufgaben:

Als Erstes setzt er den Espruino zurück. Das entspricht der Eingabe von

reset()

auf der linken Seite der IDE.

Anschließend schaut er sich Ihren Code an. Wenn darin mit

require

irgendwelche Module eingebunden werden (siehe

Kapitel 15

), lädt er sie automatisch auf die Platine herunter.

Er sucht auch nach Code, der kompiliert oder assembliert werden muss (siehe Anhang B und C), und fügt Zeilennummern u. a. für das Debugging hinzu.

All dies bedeutet, dass es viel besser ist, Programme in der rechten Seite der IDE zu schreiben. Sie lassen sich dort auch viel einfacher laden und speichern.

Die linke Seite eignet sich mehr für die Interaktion mit diesen Programmen, nachdem sie hochgeladen wurden, etwa zur Suche nach Variablen oder zur Optimierung von Funktionen.

Um Ihnen ein Beispiel zu geben, wollen wir das Programm, das wir auf der rechten Seite hochgeladen haben, jetzt in der linken Seite untersuchen.

1. Geben Sie

on

ein und drücken Sie die .

Dadurch wird der Wert der Variablen on ausgegeben. Er lautet entweder true oder false.

2. Drücken Sie und , um

on

erneut auszuwerten. Das müssen Sie möglicherweise mehrmals tun, bevor Sie eine Änderung sehen. Der angezeigte Zustand von

on

entspricht jeweils dem Zustand der LED zu dem Zeitpunkt, an dem Sie die gedrückt haben.

3. Geben Sie

changeInterval(1, 200)

ein. Dadurch wird das erste von

setInterval

festgelegte Intervall auf 200 ms verkürzt, sodass die LED etwas schneller blinkt.

4. Geben Sie

dump()

ein und drücken Sie die .

Espruino gibt jetzt in etwa Folgendes aus:

Das ist nicht genau Ihr Code, aber nahe daran. Espruino hat den aktuellen Zustand