Bibliotheken

http://sites.prenninger.com/arduino-uno-r3/bibliotheken

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2016-11-22

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
                       Bibliotheken / Libraries

Header-Datei  #include <name.h>
// Library einbinden
// Bibliothek einbinden


http://arduino.cc/en/Reference/Libraries

Eine Excel-Tabelle der mit bekannten Librarys von www.schaltungen.at downloadbar

704_d_Arduino-x_Bibliotheken – meine Libraries  2015_1a.xls

015        4     #include <Arduino.h> heute    
014             #include <pin_arduino.h> ODER #include <pins_arduino.h>  früher    
013             #include <WConstants.h> früher    
011             #include <wiring.h> früher    
012             #include <WProgram.h> früher    
004           
005            
002             704_d_Arduino-x_Bibliotheken – meine Libraries  2015_1a.xls    
009             C:\2015 Arduino-IDE 1.0.6\fritz-Sketche\libraries\LiquidCrystal_I2C    
008             C:\Programme (x86)\Arduino\libraries\    
017    L         Librarys  http://www.arduino.cc/en/Reference/Libraries    
16    x         Standard Librarys  http://www.arduino.cc/en/Reference/Libraries    
110            #include <Adafruit_GFX.h>    
111            #include <Adafruit_ILI9341.h>    
112            #include <Adafruit_STMPE610.h>    STM-PE610
093            #include <AFMotor.h>    
115            #include <ArduBotMotor.h>    
081            #include <arduino_serial_lib.h>    
117    L        #include <Audio.h>    
065            #include <avr/interupt.h> ODER #include <avr\interrupt.h>    
064            #include <avr/io.h> ODER #include <avr\io.h>    
076            #include <avr/pgmspace.h>    
054            #include <avr/power.h>    
053            #include <avr/sleep.h>    
106        2    #include <blinkLED.h>    
118    L    2    #include <Bounce.h>  #include <Debounce.h>    Tasten entprellen
119    L        #include <Bridge.h>    
079            #include <burglar_alarm.h>    
088            #include <Button.h>    
120    L        #include <CapacitiveSensing.h>    
061        2    #include <CapSense.h>    
018            #include <CmdMessenger.h>    
052            #include <ctype.h>    
038            #include <DallasTemperature.h>    
121    L        #include <DateTime.h>    
068            #include <Def77.h>    
049            #include <DHT.h>    
101        2    #include <DS1307RTC.h>    
019    x    3    #include <EEPROM.h>    
077            #include <email.h>    
091            #include <EPD.h>    
122    L        #include <Esplora.h>    
020    x    3    #include <Ethernet.h>    
104            #include <EthernetUdp.h>    
094            #include <FatReader.h>    
123    L        #include <FFT.h>    
021    x    2    #include <Firmata.h>    
074            #include <fontALL.h>    
058            #include <fonts.h>    
098            #include <fonts/allFonts.h>    
084            #include <fonts/SystemFont5x7.h>    
125    L        #include <GFX.h>    
022            #include <Girino.h>    
124    L    3    #include <glcd.h>    
023    x        #include <GSM.h>    
050            #include <gy_65.h>    
047            #include <HttpClient.h>    
108            #include <i2cDebug.h>    
126    L        #include <ImprovedLCDlibrary.h>    
080            #include <infrared_proxy.h>    
051        2    #include <inttypes.h>    
063        3    #include <IRremote.h>    
127    L        #include <Keyboard.h>    
085            #include <Keypad.h>    
041            #include <Keypd2.h>    
062            #include <LED_display_interrupt_low_dot_degree_V010.h>    
067            #include <LED_display_V020.h>    
060        3    #include <LED_display.h>    
128    L        #include <LEDControl.h>    
129    L        #include <LEDDisplay.h>    
109    x    3    #include <LiquidCrystal_I2C.h>      I2C/TWI LCD 1602 Modul
024    x    3    #include <LiquidCrystal.h>      LCD HD44780  2x16
089            #include <LSM303DLH.h>    
130    L    3    #include <Matrix.h>    
131    L        #include <messenger.h>    
132    L        #include <Metro.h>    
044            #include <MIDI.h>    
134    L        #include <Mouse.h>    
133    L        #include <MsTimer2.h>    
114            #include <MyAnalogkeyPad.h>    
113            #include <MyKeyPad.h>    
135    L        #include <NewSoftSerial.h>    
043            #include <nmea.h>    
040            #include <nunchuck_funcs.h>    
092        2    #include <Nunchuk.h>    
136    L        #include <OneWire.h>    
025            #include <Oscilloscope.h>    
137    L        #include <PCD8544.h>    
070            #include <PCF8583.h>    
103            #include <Ports.h>    
107            #include <Print.h>    
071            #include <ps2.h>    
138    L        #include <PS2Keyboard.h>    
139    L        #include <PString.h>    
055            #include <rain.h>    
102            #include <RF12.h>    
026            #include <Robot_Control.h>    
027            #include <Robot_Motor.h>    
140    L        #include <Robot.h>    
028            #include <RobotIRremote.h>    
145    L        #include <Scheduler.h>    
029    x    4    #include <SD.h>    
095        2    #include <SdReader.h>    
141    L        #include <SerialControl.h>    
086        2    #include <SerialGSM.h>    
039        2    #include <SerialLCD.h>    
030    x    4    #include <Servo.h>    
146    L        #include <SimpleMesageSystem.h>    
078            #include <smtp_service.h>    
031    x    4    #include <SoftwareSerial.h>    
090            #include <SonMicroReader.h>    
032    x    5    #include <SPI.h>    
142    L    2    #include <Sprite.h>    
147    L        #include <SSerial2Mobile.h>    
144    L        #include <ST7735.h>    
069        4    #include <stdio.h>    
033    x    2    #include <Stepper.h>    
143    L        #include <Streaming.h>    
056            #include <sun.h>    
057            #include <suncloud.h>    
072            #include <Telegraph.h>    
083            #include <termios.h>    
046        2    #include <TextFinder.h>    
034    x        #include <TFT.h>    
075            #include <thermometer.h>    
099        2    #include <Time.h>    
100        2    #include <TimeAlarms.h>    
059        2    #include <TimerOne.h>    
042        2    #include <TinyGPS.h>    
148    L        #include <TLC5940.h>    
149    L        #include <Tone.h>    
073            #include <TVout.h>    
045            #include <Twitter.h>    
087            #include <Udp.h>    
082            #include <unistd.h>    
150    L        #include <USBHost.h>    
066            #include <util/delay.h>    
037        3    #include <VirtualWire.h>    
096            #include <WaveHC.h>    
097            #include <WaveUtil.h>    
151    L        #include <Webduino.h>    
035    x        #include <WiFi.h>    
036    x    3    #include <Wire.h>    
105        2    #include <Wuerfel.h>    
152    L        #include <X10.h>    
153    L        #include <XBee.h>    
048            #include <Xively.h>   



http://arduino.cc/en/Reference/LibrariesTutorial


*********************************************************
Buch:
Arduino Kochbuch  S.559


KAPITEL 16
Bibliotheken nutzen, ändern und aufbauen


16.0 Einführung
Bibliotheken erweitern die Funktionalität der Arduino-Umgebung.
Sie erweitern die zur Verfügung stehenden Befehle um Fähigkeiten, die im Arduino-Kern nicht zur Verfügung stehen.
Mit Bibliotheken können Sie zusätzliche Features hinzufügen, die jedem Sketch zur Verfügung stehen, sobald die Bibliothek installiert ist.
Die Arduino-Software-Distribution enthält fest integrierte Bibliotheken, die gängige Aufgaben übernehmen.
Diese Bibliotheken werden in Rezept 16.1 diskutiert.
Bibliotheken stellen auch eine gute Möglichkeit dar, Code zu teilen, der für andere nützlich sein könnte.
Viele Bibliotheken von Drittanbietern stellen spezialisierte Fähigkeiten zur Verfügung.
Sie können im Arduino Playground und über andere Sites heruntergeladen werden.
Viele der in den früheren Kapitel behandelten Bauelemente nutzen Bibliotheken, um den Zugriff auf diese Geräte zu vereinfachen.
Bibliotheken können aber auch komplexen Code kapseln, um dessen Verwendung zu vereinfachen.
Ein Beispiel ist die bei Arduino mitgelieferte Wire-Bibliothek, die einen Großteil der Komplexität der Hardware-Kommunikation auf unterster Ebene vor uns versteckt (siehe Kapitel 13).
Dieses Kapitel erläutert, wie man Bibliotheken nutzt und anpasst.
Es zeigt auch, wie man eigene Bibliotheken aufbaut.

16.1 Mitgelieferte Bibliotheken nutzen
Problem
Sie wollen Bibliotheken in Ihrem Sketch nutzen, die bei der Arduino-Distributfon mitgeliefert werden.
Lösung
Dieses Rezept zeigt, wie Sie Funktionen einer Arduino-Bibliothek in Ihrem Sketch nutzen können.
Eine Liste der verfügbaren Bibliotheken können Sie sich im IDE-Menü über Sketch > Import Library anzeigen lassen.
Es erscheint eine Liste mit allen verfügbaren Bibliotheken.
Etwa das erste Dutzend sind die Bibliotheken, die mit Arduino mitgeliefert werden.
Eine horizontale Linie trennt diese von den Bibliotheken, die Sie selbst heruntergeladen und installiert haben.
Klicken Sie eine Bibliothek an, wird sie in den aktuellen Sketch eingebunden, indem die folgende Zeile zu Beginn des Sketches eingefügt wird.

#include <Name der gewählten Bibliothek.h>   

Das sorgt dafür, dass die Funktionen der Bibliothek in Ihrem Sketch zur Verfügung stehen.
Die Arduino-IDE aktualisiert die Liste der verfügbaren Bibliotheken nur beim Start.
Wenn Sie eine Bibliothek installieren, nachem die IDE bereits läuft, müssen Sie die IDE beenden und neu starten, damit die neue Bibliothek erkannt wird.
Die Arduino-Bibliotheken sind in der Referenz auf
http://arduino.cc/en/Reference/Libraries
dokumentiert und jede Bibliothek enthält Beispiel-Sketches, die ihre Verwendung demonstrieren.
Kapitel 1 zeigt, wie man in der IDE an die Beispiele gelangt.

Die bei Arduino Version 1.0 enthaltenen Bibliotheken sind:

EEPROM.h
Liest und schreibt Daten aus/in Speicher, dessen Inhalt auch erhalten bleibt, wenn
der Strom ausgeschaltet wird. Siehe Kapitel 17.
Ethernet.h
Wird zur Kommunikation mit dem Arduino Ethernet-Shield oder Arduino Ethernet-
Board genutzt. Siehe Kapitel 15.
Firmata.h
Ein Protokoll, das die serielle Kommunikation und die Steuerung des Boards verein-
facht.
LiquidCrystal.h
Zur Steuerung kompatibler LC-Displays; siehe Kapitel 11.
SD.h
Lesen und Schreiben von Dateien von/an SD-Karten über externe Hardware.
Servo.h
Steuerung von Servomotoren; siehe Kapitel 8.
SoftwareSerial.h
Stellt zusätzliche serielle Ports bereit.
SPI.h
Wird für Ethernet- und SPI-Hardware genutzt; siehe Kapitel 13.
Stepper.h
Steuerung von Schrittmotoren; siehe Kapitel 8.
Wire.h
Zur Steuerung von mit dem Arduino verbundenen I2C-Geräten; siehe Kapitel 13.
Die beiden folgenden Bibliotheken finden sich in Releases vor Arduino 1.0, sind aber nicht länger Teil der Arduino-Distribution:
Matrix.h
Hilft bei der Steuerung einer LED-Matrix; siehe Kapitel 7.
Sprite.h
Sprites für eine LED-Matrix.
Time.h
???????????????????????????


Diskussion

Mit einer bestimmten Hardware innerhalb des Arduino-Chips arbeitende Bibliotheken funktionieren nur mit vordefinierten Pins.
Beispiele für diese Art Bibliotheken sind Wire und SPI. Bibliotheken, die dem Benutzer die Wahl der Pins erlauben, erledigen das üblicherweise in
setup; Servo, LiquidCrystal und Stepper
sind Beispiele für diese Art von Bibliotheken. Informationen zur Konfiguration finden Sie in der Dokumentation der jeweiligen Bibliothek.
Das #include <Name.h> einer Bibliothek fügt den Bibliothekscode hinter den Kulissen in Ihren Sketch ein.
Das bedeutet, dass sich die Größe Ihres Sketches (wie sie am Ende der Kompilierung gemeldet wird) erhöht, aber der Arduino Build-Prozess ist clever genug, nur den Teil der Bibliothek einzufügen, den der Sketch tatsächlich verwendet.
Sie müssen sich also keine Gedanken um den Speicherbedarf von Methoden machen, die gar nicht verwendet werden.
Daher müssen Sie sich auch keine Gedanken darum machen, ob ungenutzte Funktionen die Codemenge reduzieren, die Sie in den Sketch packen können.
Die bei Arduino mitgelieferten Bibliotheken (und viele Bibliotheken von Drittanbietern) enthalten Beispiel-Sketches, die die Verwendung der Bibliothek demonstrieren.
Diese sind über das Menü File-+Examples zugänglich.
Siehe auch
Die Arduino-Referenz für Bibliotheken:
http://arduino.cc/en/Reference/Libraries



16.2 Bibliotheken von Drittanbietern installieren
Problem
Sie wollen eine Bibliothek für den Arduino nutzen, die nicht in der Standard-Distribution enthalten ist.
Lösung
Laden Sie die Bibliothek herunter, die häufig in Form einer *.zip-Datei vorliegt.
 Entpacken Sie diese Datei und Sie erhalten einen Ordner, der der gleichen Namen hat wie die Bibliothek.
Dieser Ordner muss in einen Ordner namens libraries im Arduino-Dokumentenordner kopiert werden.
Um diesen Ordner zu finden, öffnen Sie Preferences (File > Preferences unter Windows) und notieren sich die Position des Sketchbooks.
Wechseln Sie mit einem Dateisystem-Browser (Windows Explorer) oder über das Terminal in dieses Verzeichnis.
Gibt es keinen libraries-Ordner, legen Sie einen an und kopieren den entpackten Ordner dort hinein.
Wenn die Arduino IDE noch läuft, beenden und starten Sie sie neu.
Die IDE durchsucht diesen Ordner nur beim Start nach Bibliotheken.
Wenn Sie sich nun das Menü Sketch > Import Library ansehen, erscheint am unteren Rand (unter der grauen Linie und dem Wort Contributed) die gerade hinzugefügte Bibliothek.
Enthält die Bibliothek Beispiel-Sketches, können Sie diese über das IDE-Menü ansehen.
Klicken Sie auf File > Examples und Sie finden die Beispiele unter dem Namen der Bibliothek in einem Abschnitt zwischen den allgemeinen Beispielen und den Beispielen zu den mit Arduino ausgelieferten Bibliotheken.
Diskussion
Eine große Zahl von Bibliotheken steht von Drittanbietern zur Verfügung.
Viele sind von hoher Qualität, werden aktiv gepflegt und umfassen eine gute Dokumentation sowie Beispiel-Sketches.
Der Arduino Playground ist ein guter Ort, um nach Bibliotheken zu suchen:
http://www.arduino.cc/playground/
Achten Sie darauf, Bibliotheken mit einer guten Dokumentation und mit Beispielen zu nutzen.
Schauen Sie in den Arduino-Foren, ob es Threads (Diskussionen) gibt, die diese Bibliothek behandeln.
Bibliotheken, die für frühe Arduino-Versionen entwickelt wurden, können Probleme bereiten, wenn man sie mit der neuesten Arduino-Version nutzt.
Möglicherweise müssen Sie sehr viel lesen (die Threads beliebter Bibliotheken enthalten Hunderte Postings), um Informationen darüber zu finden, wie man ältere Bibliotheken mit der neuesten Arduino-Release nutzen kann.
Wenn die Bibliotheks-Beispiele nicht im Examples-Menü erscheinen, oder wenn Sie die Meldung erhalten, dass die Bibliothek nicht gefunden werden konnte (»Library not found«), dann prüfen Sie, ob der Bibliotheksordner am richtigen Ort liegt und ob der Name richtig geschrieben wurde.
Ein Bibliotheksordner namens <BibliotheksName> muss eine Datei namens <LibraryName>.h in genau der gleichen Schreibweise enthalten.
Stellen Sie sicher, dass auch alle weiteren Dateien im Ordner vorhanden sind, die von der Bibliothek benötigt werden.

16.3 Eine Bibliothek anpassen
16.4 Eine eigene Bibliothek entwickeln
16.5 Eine Bibliothek entwickeln, die andere Bibliotheken nutzt
16.6 Bibliotheken von Drittanbietern an Arduino 1.0 anpassen





*********************************************************
                             Importieren von Libraries
Wir hatten für die Würfel-Library einen speziellen Ordner mit dem Namen Wuerfel erstellt, und in ihm die Dateien
•    wuerfel.h
•    wuerfel.cpp
•    keywords.txt
abgespeichert.
Anschließend haben wir in das Verzeichnis ...\ Arduino\libraries diesen Ordner hineinkopiert, so dass er beim Neustart der Entwicklungsumgebung über den Menüpunkt SketchlLibrary importieren .... verfügbar war.
Vielleicht ist dir aufgefallen, dass es unter dem besagten Menüpunkt einen Punkt gibt, der recht vielversprechend aussieht, wenn es darum geht, Libraries zu hinzuzufügen.
Der Menüeintrag ist trotz deutscher Spracheinstellungen noch in Englisch gehalten, was uns aber nicht davon abhalten sollte, ihn zu nutzen.
Wählst du den Menüpunkt aus, hast du die Möglichkeit, das Verzeichnis deiner Würfel-Library mit ihren 3 genannten Dateien, die sich irgendwo im Dateisystem befinden mag, in die Entwicklungsumgebung zu integrieren.
Dabei wird der Ordner jedoch nicht in das Verzeichnis ...\ArduinoLibraries kopiert, sondern abhängig vom jeweiligen Betriebssystem in folgendes Verzeichnis:
Windows
...\Documents\Arduino\libraries


Die recht unscheinbare Rückmeldung der Entwicklungsumgebung lautet:
Aha, die Library ist zu meinen Libraries hinzugefügt worden.
Es handelt sich um den Pfad, den ich dem Betriebssystem entsprechend gerade genannt hatte.
Es sieht so aus, als ob hier — wie schon erwähnte — eine Trennung systemeigener und selbstentwickelter Software stattgefunden hat.
Nach dem Neustart der Entwicklungsumgebung befindet sich die Library zur Auswahl unterhalb des Punktes Beigetragen.
Das sieht, finde ich, ganz gut aus.
Auf vergleichbare Weise können auch komprimierte  ZIP-Dateien verarbeitet werden.
Für weitere Informationen kannst du einen Blick auf die Seite
http://arduino.cc/en/Guide/Libraries
werfen.




*********************************************************
Buch:
Arduino Praxiseinstieg S.323

Kapitel 7

Erweiterungen

7.1    Bibliotheken

Arduino-Boards nutzen Bibliotheken in Form von Softwarebibliotheken.
Diese Softwarebibliotheken, englisch »Library« oder »Libraries« (Mehrzahl), sind in sich geschlossene Programme mit meist einer Anzahl von Funktionen.
Sie erweitern die Funktionalität des Arduino und sind speziell für einen Anwendungsfall erstellt.
Der Vorteil dieser Bibliotheken ist, dass der Anwender auf vorgefertigte Funktionen zurückgreifen kann und diese nicht selbst ausprogrammieren muss.
Bei einer Bibliothek für ein serielles GPS-Modul beispielsweise kann man Daten wie Längen- und Breitengrad direkt abfragen und muss den über die serielle Schnittstelle eingelesenen String nicht selbst auseinandernehmen.
Bibliotheken werden meist verwendet, wenn externe Sensoren, Aktoren oder andere elektronische Schaltungen mit dem Arduino eingesetzt werden.

Auf der Arduino-Website werden viele Bibliotheken für die verschiedensten Einsatzgebiete aufgelistet:
http://arduino.cc/en/Reference/Libraries
Fortgeschrittene Anwender können eigene Bibliotheken für Arduino schreiben und der Community zur Verfügung stellen.
Eine ausführliche Anleitung erklärt alles Wissenswerte dazu:
http://arduino.cc/en/Hacking/LibraryTutorial
Die Arduino-Bibliotheken sind in der Arduino-IDE in einem eigenen Verzeichnis abgelegt.
Der Pfad hierzu lautet:
Arduino-IDE 1.0:
Arduino-Verzeichnis\libraries
Jede Bibliothek wird in einem eigenen Unterverzeichnis abgelegt.
Nach dem Neustart der Arduino-IDE kann eine neu eingefügte Bibliothek im Menü über
SKETCH > IMPORT LIBRARY in den aktuellen Sketch eingefügt werden.


Die in einem Sketch geladenen Bibliotheken werden jeweils am Beginn des Codes mit der Anweisung # include <Bibliothek.h>  eingefügt.
z.B. #include <Arduino.h>

Die meisten Bibliotheken liefern zur eigentlichen Funktion zusätzliche Beispiele mit, die die Nutzung der Bibliothek beschreiben.
Diese Beispiele sind ein guter Startpunkt für den Anwender.
Nachfolgend werden diese Standardbibliotheken beschrieben.


7.1.1 Ethernet Lib
http://www.arduino.cc/en/Reference/Ethernet
7.1.2 Wire Lib
http://www.arduino.cc/en/Reference/Wire
7.1.3 SoftwareSerial
http://arduino.cc/en/Reference/SoftwareSerial
7.1.4 TinyG PS
http://arduiniana.org/libraries/tinygps/
7.1.5 N M EA
http://www.maartenlamers.com/nmea/
7.1.6 PString
http://arduiniana.org/libraries/pstring/
7.1.7 Matrix
http://wiring.org.co/reference/libraries/Matrix/Matrix.html
7.1.8 LiquidCrystal (LCD)
http://arduino.cc/en/Reference/LiquidCrystal
7.1.9 MIDI
http://www.arduino.cc/playground/Main/MIDILibrary
7.1.10 Stepper
http://www.arduino.cc/en/Reference/Stepper
7.1.11 Webduino
https://github.com/sirleech/Webduino
7.1.12 Wii Nunchuk
http://todbot.com/blog/2008/02/18/wiichuck-wii-nunchuck-adapter-available/

Genaue Beschreibung obenstehender Bibliotheken in
"505_d_ARDUINO-x_Praxiseinstieg - S.323 Bibliotheken - Libraries_1a.pdf"




*********************************************************
Buch:
Die elektronische Welt mit Arduino entdecken  S.358

Weitere Möglichkeiten, das Prellen zu kompensieren

Wir haben bisher lediglich eine Möglichkeit zur Kompensation des Prellens eines mechanischen Bauelementes,
z.B. des Tasters, kennengelernt. Es gibt noch weitere:
1. spezielle Taster, die nicht prellen und einen festen Druckpunkt haben;
2. durch eine eigens dafür geschriebene Bibliothek mit dem Namen Bounce-Library;
3. mittels einer kleinen zusätzlichen hardwaretechnischen Lösung über ein RC-Glied.
Ich möchte kurz auf den Punkt 2 eingehen.
Falls dich auch Punkt 3 interessiert, findest du hierzu zahlreiche Informationen im Internet oder auf meiner eigenen Internetseite.
Eine Bibliothek, auch Library genannt, ist eine Software-Komponente, die
z. B. von anderen Programmierern entwickelt wurde, um ein spezielles Problem zu lösen.
Damit das Rad nicht immer wieder neu erfunden werden muss, wurde der betreffende Code in eine Library verpackt und anderen Usern zur Verfügung gestellt, um ihnen Arbeit zu ersparen.
Wenn es sich um frei verfügbare Bibliotheken handelt, und das ist im Arduino-Umfeld wohl meistens der Fall, kannst du sie bedenkenlos in deinem Projekt verwenden.
Die Bounce-Library findest du im Internet auf der Seite
http://playground.arduino.cc/code/bounce
Du kannst sie dort in Form einer gepackten Zip-Datei herunterladen.
Entpacke sie in das Arduino-Verzeichnis Arduino\libraries, in dem sich auch schon diverse andere Libraries befinden, die im Lieferumfang der Arduino-Software standardmäßig enthalten sind.
Nach dem Entpacken sollte sich folgende File-Struktur ergeben:
C:\Programme (x86)\Arduino\libraries\Bounce\Bounce.h
Wenn du jetzt einen Sketch programmieren möchtest, in dem du diese Library verwendest, wirst du durch die Entwicklungsumgebung unterstützt, indem dir beim Einfügen der Bibliothek in dein Projekt entsprechende Hilfestellung geleistet wird.
Du musst deinem Compiler zunächst in irgendeiner Weise mitteilen, dass du Fremdcode mit einbinden möchtest.
Dies erfolgt mittels der Präprozessoranweisung #include < Bounce.h>  // Bounce-Library einbinden.
Nähere Erläuterungen hierzu folgen später.
Du musst nach dem Entpacken des Codes in das o.g. Verzeichnis lediglich die #include-Anweisung über die in der folgenden Abbildung gezeigten Menüpunkte der IDE hinzuzufügen.
Über Sketch > Library importieren... kannst du eine Liste aller verfügbaren Bibliotheken im libraries-Verzeichnis anzeigen.
Bei Auswahl der Option Bounce wird die erforderliche #include-Präprozessoranweisung automatisch in der ersten Zeile des Editors platziert.
Nach dieser Zeile schreibst du deinen Code, der z.B. wie folgt ausschauen kann:
#include <Bounce.h>    // Bounce-Library einbinden




*********************************************************
Buch:
Die elektronische Welt mit Arduino entdecken  S.459


www.erik-bartmann.de

Projekt 1 2-1 0:
Der elektronische Würfel
 (und wie erstelle ich eine Bibliothek?)

Irgendwann ist auch für dich der Zeitpunkt gekommen, an dem du dir so viele Grundkenntnisse angeeignet hast, dass du eigene Ideen realisieren möchtest, die andere vielleicht noch nicht hatten.
Oder du möchtest ein schon vorhandenes Projekt verbessern, weil deine Lösung eleganter ist und sich viel unkomplizierter umsetzen lässt.
Unzählige Softwareentwickler vor dir haben sich Gedanken zu den unterschiedlichsten Themen gemacht und Bibliotheken programmiert, um anderen Entwicklern Arbeit und Zeit zu sparen.
In diesem Kapitel geht es um die Grundlagen bzw. die Erstellung derartiger Bibliotheken.
Falls dich die Programmiersprache C++ inklusive objektorientierte Programmierung schon immer interessiert hat, wirst du hier einiges zu diesem Thema erfahren.

Bibliotheken
/ Libraries

Wenn du die Arduino-Entwicklungsumgebung installiert bzw. entpackt hast, werden von Haus aus einige fertige Bibliotheken, auch Libraries genannt, mitgeliefert.
Es handelt sich dabei um so interessante Themen wie

z. B. die Ansteuerung
•    eines Servos
•    eines Schrittmotors
•    eines LC-Displays
•    eines externen EEPROM zu Speicherung von Daten
•    etc.

Diese Bibliotheken werden im Verzeichnis libraries unterhalb des Arduino-Installationsverzeichnisses gespeichert.
Wenn du auf einen Blick sehen möchtest, welche Libraries vorhanden sind, kannst du dazu den Windows-Explorer nutzen oder den Weg über die Arduino-Entwicklungsumgebung beschreiten.
Es gibt dort einen speziellen Menüpunkt Sketch Library importieren ..., über den du eine entsprechende Liste anzeigen kannst.
Die Menüpunkte stimmen mit den Verzeichnissen im Ordner Libraries überein.
Das ist zwar alles wunderbar, doch wir sollten uns zunächst einmal anschauen, wie eine Arduino-Library arbeitet bzw. was du mit ihr bewirken kannst.

Was ist eine Library im Detail?

Bevor wir zu einem konkreten Beispiel kommen, solltest du zunächst einige grundlegende Informationen über Libraries erhalten.
Ich hatte schon erwähnt, dass mit einer Library mehr oder weniger komplexe Programmieraufgaben quasi gebündelt und in einem Programmpaket zusammengefasst werden. Die folgende Grafik veranschaulicht das Zusammenspiel von Arduino-Library und Arduino-API:
Wir haben es mit zwei Programmschichten zu tun, die sich in einem Abhängigkeitsverhältnis voneinander befinden.
Ich fange von innen nach außen an.
Die innere Schicht habe ich Arduino-API genannt.
API ist die Abkürzung für Application Programming Interface und eine Schnittstelle zu allen zur Verfügung stehenden Arduino-Befehlen.
Ich habe aus Platzgründen nur wenige Befehle ausgewählt.
Die äußere Schicht wird durch die Arduino-Library repräsentiert, die sich um die innere Schicht herumwickelt.
Sie wird deshalb als Wrapper (deutsch Hülle) bezeichnet und bedient sich der Arduino-API. Damit du Zugriff auf die Wrapper-Schicht erhältst, muss dort eine Schnittstelle implementiert sein, denn du willst ja die Funktionalität einer Library nutzen.
Eine Schnittstelle ist ein Durchgangsportal zum Inneren der Library, die eine in sich geschlossene Einheit darstellt.
Der Fachbegriff dafür lautet Kapselung.
Was das im Detail ist und was das Ganze mit der Programmiersprache C++ zu tun hat, wirst du gleich sehen.

Warum benötigen wir Libraries?
Das ist eventuell eine blöde Frage, weil ich die Antwort bzw. den Grund für das Erstellen einer Library schon mehrfach genannt habe.
Doch ich möchte die Vorteile an dieser Stelle noch einmal zusammenfassen:
•    Damit das Rad nicht immer neu erfunden werden muss, haben die Entwickler die Möglichkeit geschaffen, Programmcode in eine Library auszulagern.
Viele Programmierer auf der ganzen Welt profitieren von diesen programmtechnischen Konstrukten, die sie ohne größere Probleme in ihren eigenen Projekten verwenden können.
Das entsprechende Stichwort hierfür ist Wiederverwendbarkeit.
•    Wurde eine Library getestet und weist keine Fehler mehr auf, kann sie ohne Kenntnis der inneren Abläufe verwendet werden.
Ihre Funktionalität wird gekapselt und vor der Außenwelt verborgen.
Das einzige, was ein Programmierer zu wissen hat, ist die korrekte Verwendung ihrer Schnittstellen.
•    Der eigene Code wird auf diese Weise übersichtlicher und stabiler.





*********************************************************


Eigene Bibliothek für den Arduino erstellen

In diesem Artikel geht es darum, wie man eine Bibliothek für den Arduino erstellen kann. Eine Bibliothek ist eine Art Sammlung von Befehlsdefinitionen, die ausgelagert wurden. Ein Beispiel ist die LiquidCrystal Bibliothek, durch die man ohne große Fachkenntnisse ein LCD Display verwenden. Durch eine Bibliothek kann man dann viele Befehle mit nur einer Zeile Code im Sketch definieren.


Aufbau einer Bibliothek für die Arduino IDE

Eine Bibliothek besteht aus drei Teilen. Einerseits dem Ordner, und andererseits die im Ordner enthaltenen Dateien, die Header Datei, und die C++ Datei. In der Headerdatei, eine Textdatei mit der Endung ".h", werden die Funktionen einer Klasse benannt und die nötigen Variablen definiert. In der CPP Datei wird der Inhalt der Funktionen angegeben, also die, von der Arduino IDE bekannten, Befehle.

Um das Erstellen einer Bibliothek an einem Beispiel zu veranschaulichen, erstelle ich eine Bibliothek, über die man eine LED zum Blinken bringen kann. Der Pin kann vom User angegeben werden.

Die Headerdatei

Eine gute Headerdatei beginnt immer mit einer if Schleife. Diese fragt ab, ob der Programmierer versehentlich die Bibliothek zum zweiten Mal nachlädt. Wenn dem nicht so ist, wird eine Klasse mit dem Namen der Bibliothek erzeugt. Diese Klasse hat diverse Methoden, also Befehle. Diese werden in public angegeben. Wenn eine Funktion Werte benötigt gibt man diese, wie in der Arduino IDE, in den Klammern, samt Datentyp an. Wenn eine Funktion keine Argumente hat, schreibt man void vor den Funktionsnamen. Diese Funktionen kann dann der User, sobald er die Bibliotehk importiert hat, verwenden. Auf Alles, was im Bereich private steht, hat nur die Bibliothek/die Klasse selbst Zugriff. Dort würde beispielsweise Variablen, die später Zwischenergebnisse enthalten, definiert werden. Das #include "Arduino.h" am Anfang ist immer notwendig und gibt einige Standardeinstellungen und Definitionen vor. Unsere Klasse/Bibliothek soll eine Funktion Blinken haben, auf die wir zugreifen können, und bei der wir den Pin angeben können. Deshalb kommt die Funktion in den public Bereich. Die gesamte Headerdatei sieht dann so aus:

Um eine Headerdatei zu erstellen öffnet ihr euren ganz normalen Windows Editor und tippt dort den Text ein. Anschließend klickt ihr auch Datei > Speichern unter. Dort wählt ihr den Namen Blinken.h und als Dateityp "Alle Dateien". Wenn ihr das nicht tut, interpretiert euer PC das ganze als eine Textdatei mit dem Namen "Blinken.h.txt".

Die C++ Datei

In der C++ Datei werden die einzelnen Befehle, die ihr erstellt habt, mit Leben gefüllt. Das bedeutet, dass ihr, ähnlich wie bei der Funktionsdefinition in der IDE selbst, sagt welche Befehle eure neue Methode enthält. Dazu müsst ihr zunächst wieder die Arduino.h und eure Bibliotheksheaderdatei, die ihr gerade erstellt habt, nachladen. Danach könnt ihr schon mit der Definition der Methoden beginnen. Dort verwendet man die ganz normalen Befehle, die aus der Arduino IDE bekannt sind.

Auch diese Datei kann, wie die Headerdatei, mit einem normalen Texteditor erstellt werden.

Die Bibliothek im Arduino Sketch verwenden

Um nun den Befehl Blinken aus der Bibliothek zu verwenden, muss man diese Bibliothek ganz normal nachladen. Also entweder über das schreiben der Zeile #include <Blinken.h> oder über Sketch > IncludeLibrary > Blinken. Nun müssen wir nur noch die Methode Blinken(Pinnummer); im Loopteil angeben, und schon blinkt die gewählte LED.


Das ist ein einfaches Beispiel, wie man eine Bibliothek für die Arduino IDE erstellt und verwendet


Quelle:
http://michaelsarduino.blogspot.co.at/2015/06/eigene-bibliothek-fur-den-arduino.html




*********************************************************


BUCH:
Arduino Workshops von John Boxall

Seite 172
Seite 188 Sketche durch Bibliotheken erweitern


Sketche durch Bibliotheken erweitern

So wie Sie mit einem Arduino-Shield die Hardware erweitern, können Sie Ihre Sketche mithilfe einer Bibliothek um nützliche Funktionen für bestimmte Aufgaben
oder für die Ansteuerung herstellerspezifischer Hardware ergänzen.
Jeder kann eine Bibliothek erstellen, und tatsächlich schreiben die Hersteller mancher Arduino-Shields eigene Bibliotheken für ihre Hardware.
Die Arduino-IDE umfasst bereits einen Satz vorinstallierter Bibliotheken.

Um sie in Ihre Sketche einzuschließen, wählen Sie  IDE-MENU > Sketch > Include Library, woraufhin eine Aufstellung dieser Bibliotheken angezeigt wird, darunter Ethernet, LiquidCrystal, Servo usw.
Viele dieser Namen sind selbsterklärend.
Wenn Sie für eines der Projekte in diesem Buch eine Bibliothek benötigen, wird diese genau erklärt.




Die Bibliotheken für einen Shield importieren z.B Shield für microSD-Karte Fa. sparkfun.com
Wenn Sie einen Shield kaufen, müssen Sie gewöhnlich die zugehörigen Bibliotheken von der Website des Herstellers oder über einen angegebenen Link herunterladen.
Um Ihnen zu zeigen, wie das geht, wollen wir die Bibliothek für den microSD-Shield aus Abbildung 8-3 herunterladen.

1. Öffnen Sie die Website

http://code.google.com/p/sdfatlib/downloads/list/

A new version of SdFat, sdfatlib20120719.zip, is available here http://code.google.com/p/sdfatlib/downloads/list.
https://github.com/madsci1016/Sparkfun-MP3-Player-Shield-Arduino-Library/tree/master/SdFat
https://github.com/SuperTango/KellyKBLCanbusReader/tree/master/libraries/sdfatlib20120719
http://forum.arduino.cc/index.php?topic=115016.0
https://www.sparkfun.com/products/12761


Documents:


https://www.arduino.cc/en/Reference/SD

https://www.arduino.cc/en/Reference/SDCardNotes


die Sie in Abbildung 8-14 sehen.


Abb. 8-14 Die Seite mit den verschiedenen Versionen der Bibliothek


Installation unter Windows XP und höher
Wenn Sie die Datei auf einen PC mit Windows XP oder höher herunterge-laden haben, gehen Sie folgendermaßen vor:
1. Nachdem der Download abgeschlossen ist, öffnen Sie den heruntergela-denen Ordner, um seinen Inhalt anzuzeigen, und suchen darin nach dem Ordner SdFat (siehe Abb. 8-19).


Abb. 8-19 Der Ordner der heruntergeladenen Bibliothek

2. Kopieren Sie den Ordner SdFat aus dem Fenster in Abbildung 8-19 in Ihren Ordner Arduinollibraries (siehe Abb. 8-20).

C:\Benutzer\fritz\Dokumente\Arduino\libraries\SDFat

Abb. 8-20 Fertigstellen der Installation


3. Stellen Sie sicher, dass die Bibliothek SdFat installiert und verfügbar ist, indem Sie die IDE-Software neu starten und
IDE-MENU > Sketch > Include Library,
 wählen.
In der Liste sollte SdFat zu sehen sein.
(Wenn nicht, versuchen Sie erneut die Installation durchzuführen.)
Nachdem Sie die Bibliothek installiert haben, blättern Sie vor zum Abschnitt »microSD-Speicherkarten« auf Seite 192.





DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE






Comments