Sign in Join
Wiki copytemporary

Lazarus on Raspberry Pi/de: what changed

Revision 4 to 5. Removed lines have a minus sign; added lines have a plus sign.

OldNewLine
1-![Lazarus unter Raspbian Wheezy](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png) *(Raspberry Pi only)*
2-
3-Der **Raspberry Pi** ist ein kreditkartengroßer Einplatinenrechner. Er wurde in Großbritannien von der Raspberry Pi Foundation ursprünglich entwickelt, um den grundlegenden Informatikunterricht in Schulen zu fördern. Raspberry Pis können aber nicht nur für die Ausbildung, sondern für die unterschiedlichsten Zwecke, z. B. als Medienserver, Robotersteuerungen und für die Regelungstechnik eingesetzt werden.
4-
5-Die Raspberry Pi Foundation empfiehlt als Standard-Betriebssystem Raspbian Wheezy. Alternative Betriebssysteme für den RPI sind z. B. RISC OS und verschiedene Linux-Distributionen, einschließlich Android.
6-
7-Lazarus läuft nativ unter dem Betriebssystem Raspbian.
8-
9-## Lazarus installieren und/oder compilieren
10-
11-### Einfache Installation unter Raspbian
12-
13-Hinweis:
14-
15-In der Wheezy Version (2014-09-09) muss folgende Paketquelle in etc/apt/sources.list hinzugefügt werden.
1+[![Lazarus on Raspbian Wheezy.](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png)](</File:Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png>)
162
17-deb <http://plugwash.raspbian.org/wsf> wheezy-wsf main
3+[](</File:Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png> "Enlarge")
184
19-Diese Information bezieht sich auf den Artikel:
5+Lazarus unter Raspbian Wheezy
206
21-[Raspberrypi.org FPC-Fix](http://www.raspberrypi.org/forums/viewtopic.php?f=34&t=88145)
7+[![Raspberry Pi Logo.png](/wiki-images/8/85/Raspberry_Pi_Logo.png)](</File:Raspberry_Pi_Logo.png>)
228
23-#### Raspberry Pi 1
9+Dieser Artikel behandelt ausschließlich [Raspberry Pi](</Category:Raspberry_Pi> "Category:Raspberry Pi").
2410
25-Lazarus und Free Pascal können unter Raspbian OS schnell und einfach installiert werden. Es ist dafür nur nötig, ein Terminal-Fenster zu öffnen und die folgenden Kommandos einzugeben:
11+Siehe auch: [[Multiplatform Programming Guide/de]]
2612
27-``` pascal
28- sudo apt-get update
29- sudo apt-get upgrade
30- sudo apt-get install fpc
31- sudo apt-get install lazarus
32-```
13+Der **Raspberry Pi** ist ein kreditkartengroßer Einplatinenrechner. Er wurde in Großbritannien von der Raspberry Pi Foundation ursprünglich entwickelt, um den grundlegenden Informatikunterricht in Schulen zu fördern. Raspberry Pis können aber nicht nur für die Ausbildung, sondern für die unterschiedlichsten Zwecke, z. B. als Medienserver, Robotersteuerungen und für die Regelungstechnik eingesetzt werden.
3314
34-Damit wird, natürlich unter der Voraussetzung einer funktionierenden Netzwerkverbindung, eine vorkompilierte Lazarus-Version auf dem Raspberry Pi installiert. Die Installation kann, je nach Version und Netzwerkgeschwindigkeit, etwa 30 Minuten erfordern, sie läuft aber überwiegend automatisch ab. Nach der Installation kann Lazarus direkt über das "Programming"-Untermenü des LXDE Startmenüs gestartet werden.
15+Die Raspberry Pi Foundation empfiehlt als Standard-Betriebssystem Raspbian Wheezy. Alternative Betriebssysteme für den RPI sind z. B. RISC OS und verschiedene Linux-Distributionen, einschließlich Android.
3516
36-![](/wiki-images/1/19/Install_Lazarus_Rasbian_Part1_de.png)
17+Lazarus läuft nativ unter dem Betriebssystem Raspbian.
3718
38-Installation 1
19+Installation 1
3920
40-![](/wiki-images/4/4c/Install_Lazarus_Rasbian_Part2_de.png)
21+* [![Installation 2](/wiki-images/4/4c/Install_Lazarus_Rasbian_Part2_de.png)](</File:Install_Lazarus_Rasbian_Part2_de.png> "Installation 2")
4122
42-Installation 2
23+Installation 2
4324
44-![](/wiki-images/6/6d/Install_Lazarus_Rasbian_Part3_de.png)
25+* [![Installation 3](/wiki-images/6/6d/Install_Lazarus_Rasbian_Part3_de.png)](</File:Install_Lazarus_Rasbian_Part3_de.png> "Installation 3")
4526
46-Installation 3
27+Installation 3
4728
48-![](/wiki-images/f/ff/Install_Lazarus_Rasbian_Part4_de.png)
29+* [![Installation 4](/wiki-images/f/ff/Install_Lazarus_Rasbian_Part4_de.png)](</File:Install_Lazarus_Rasbian_Part4_de.png> "Installation 4")
4930
50-Installation 4
31+Installation 4
5132
5233#### Raspberry Pi 2
5334
54-Seit Juni 2015 funktioniert die oben angeführte "out of the box" Installationsmethode auch auf dem Raspberry Pi 2 Model B. Allerdings ist nach gegenwärtigem Stand die installierte Version recht alt. Wer die neuesten Versionen des Free Pascal Compilers und der Lazarus IDE installieren möchte, findet eine Anleitung in [diesem Artikel](http://www.tweaking4all.com/hardware/raspberry-pi/install-lazarus-pascal-on-raspberry-pi-2/).
35+Seit Juni 2015 funktioniert die oben angeführte "out of the box" Installationsmethode auch auf dem Raspberry Pi 2 Model B. Allerdings ist nach gegenwärtigem Stand die installierte Version recht alt. Wer die neuesten Versionen des Free Pascal Compilers und der Lazarus IDE installieren möchte, findet eine Anleitung in [diesem Artikel](<http://www.tweaking4all.com/hardware/raspberry-pi/install-lazarus-pascal-on-raspberry-pi-2/>).
5536
56-![](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)
37+ * [![Lazarus "out of the box" auf dem Raspberry Pi 2](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)](</File:Lazarus_0_9_30_4_on_RPi_2.png> "Lazarus "out of the box" auf dem Raspberry Pi 2")
5738
58-Lazarus "out of the box" auf dem Raspberry Pi 2
39+Lazarus "out of the box" auf dem Raspberry Pi 2
5940
6041### Übersetzen aus den Quelltexten
6142
62-Alternativ kann Lazarus auch aus den Subversion-Quelltexten übersetzt werden. Einzelheiten sind unter \[<http://www.michellcomputing.co.uk/blog/?p=72>: Michell Computing: Lazarus on the Raspberry Pi\] beschrieben.
43+Alternativ kann Lazarus auch aus den Subversion-Quelltexten übersetzt werden. Einzelheiten sind unter [Michell Computing: Lazarus on the Raspberry Pi](<http://www.michellcomputing.co.uk/blog/?p=72:>) beschrieben.
6344
64-![](/wiki-images/a/a1/Start_Menu_with_Lazarus_de.png)
45+ * [![Starten von Lazarus unter Raspbian Wheezy](/wiki-images/a/a1/Start_Menu_with_Lazarus_de.png)](</File:Start_Menu_with_Lazarus_de.png> "Starten von Lazarus unter Raspbian Wheezy")
6546
66-Starten von Lazarus unter Raspbian Wheezy
47+Starten von Lazarus unter Raspbian Wheezy
6748
68-![](/wiki-images/8/87/Lazarus_on_Raspberry_Pi.jpg)
49+ * [![Lazarus auf dem Raspberry Pi](/wiki-images/8/87/Lazarus_on_Raspberry_Pi.jpg)](</File:Lazarus_on_Raspberry_Pi.jpg> "Lazarus auf dem Raspberry Pi")
6950
70-Lazarus auf dem Raspberry Pi
51+Lazarus auf dem Raspberry Pi
7152
72-![](/wiki-images/c/c7/Rpi_gpio_pins.png)
53+ * [![Nummerierung der GPIO-Anschlüsse](/wiki-images/c/ce/rpi_gpio_pins.png)](</File:rpi_gpio_pins.png> "Nummerierung der GPIO-Anschlüsse")
7354
74-Nummerierung der GPIO-Anschlüsse
55+Nummerierung der GPIO-Anschlüsse
7556
7657## Zugriff auf externe Hardware
7758
78-![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
79-
80-Eines der Ziele bei der Entwicklung des Raspberry Pi bestand darin, einfachen und schnellen Zugriff auf esterne Geräte wie Sensoren und Aktuatoren zu ermöglichen. Es gibt vier Möglichkeiten, die E/A-Optionen unter Lazarus und Free Pascal zu nutzen:
81-
82-1. [[Lazarus on Raspberry Pi/de|Direktzugriff]] über die [[doc:rtl/baseunix/index.html|BaseUnix]]-Unit
83-2. Zugriff über [[Lazarus on Raspberry Pi/de|gekapselte Shell-Aufrufe]]
84-3. Zugriff über die [[Lazarus on Raspberry Pi/de|wiringPi library]].
85-4. Zugriff über die Unit [[Lazarus on Raspberry Pi/de|rpi_hal]].
86-
87-### 1. Nativer Hardware-Zugriff
88-
89-![Einfaches Testprogramm für den Zugriff auf den GPIO-Port des Raspberry Pi\|thumb\|300px\|right](/wiki-images/d/d2/Testprogram_for_GPIO_on_RPI_annotated.png) ![Testschaltung für den GPIO-Zugriff mit dem beschriebenen Programm\|thumb\|300px\|right](/wiki-images/7/7c/Rpi_testcircuit_1d.png) ![Einfache Demo-Umsetzung der Schaltung auf einer Steckplatine\|thumb\|300px\|right](/wiki-images/7/7e/Rpi_testcircuit_1p_annotaded.png) Diese Methode bietet Zugriff auf externe Hardware, ohne zusätzliche Bibliotheken oder Packages zu benötigen. Die einzige Voraussetzung ist die BaseUnix-Bibliothek, die zur RTL gehört und mit Free Pascal automatisch mitinstalliert wird.
90-
91-#### Schalten eines Gerätes über den GPIO-Port
59+[![Raspberry Pi pinout](/wiki-images/5/50/rpi_pinout_all_50.png)](</File:rpi_pinout_all_50.png>)
9260
93-Im folgenden Beispiel ist ein einfaches Programm aufgelistet, das den GPIO-Pin 17 als Ausgang zum Schalten einer LED, eines Transistors oder eines Relais benutzt. Es enthält eine [[doc:lcl/stdctrls/ttogglebox.html|ToggleBox]] mit dem Namen *GPIO17ToggleBox* und zur Aufzeichnung von Return-Codes ein [[doc:lcl/stdctrls/tmemo.html|TMemo]]-Feld mit der Bezeichnung *LogMemo*.
61+[](</File:rpi_pinout_all_50.png> "Enlarge")
9462
95-Hardwareseitig wurde die Anode einer LED mit Pin 11 des Anschlusses auf dem Pi (entsprechend GPIO-Pin 17 des BCM2835 SOC) und ihre Kathode über einen 68-Ohm-Schutzwiderstand mit Pin 6 des Pi-Anschlusses (GND = Masse) verbunden (s. auch die Beschreibung bei Upton and Halfacree). Damit kann die LED durch die ToggleBox des Programms ein- und ausgeschaltet werden.
63+Belegung der externen Anschlüsse des Raspberry Pi
9664
97-Das Programm muss mit Root-Rechten ausgeführt werden, d. h. entweder von einem Root-Account aus (aus Sicherheitsgründen weniger zu empfehlen) oder über das Shell-Kommando **su**.
65+Eines der Ziele bei der Entwicklung des Raspberry Pi bestand darin, einfachen und schnellen Zugriff auf esterne Geräte wie Sensoren und Aktuatoren zu ermöglichen. Es gibt vier Möglichkeiten, die E/A-Optionen unter Lazarus und Free Pascal zu nutzen:
9866
99-*Steuerungs-Unit:*
67+ 1. [[Lazarus on Raspberry Pi/de|Direktzugriff]] über die [BaseUnix](<http://lazarus-ccr.sourceforge.net/docs/rtl/baseunix/index.html> "doc:rtl/baseunix/index.html")-Unit
68+ 2. Zugriff über [[Lazarus on Raspberry Pi/de|gekapselte Shell-Aufrufe]]
69+ 3. Zugriff über die [[Lazarus on Raspberry Pi/de|wiringPi library]].
70+ 4. Zugriff über die Unit [[Lazarus on Raspberry Pi/de|rpi_hal]]> "Lazarus on Raspberry Pi/de").
10071
101-``` pascal
102-unit Unit1;
72+### 1\. Nativer Hardware-Zugriff
10373
104-{Demo application for GPIO on Raspberry Pi}
105-{Inspired by the Python input/output demo application by Gareth Halfacree}
106-{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
74+[![](/wiki-images/f/fd/testprogram_for_GPIO_on_RPI_annotated.png)](</File:testprogram_for_GPIO_on_RPI_annotated.png>)
10775
108-{$mode objfpc}{$H+}
76+[](</File:testprogram_for_GPIO_on_RPI_annotated.png> "Enlarge")
10977
110-interface
78+Einfaches Testprogramm für den Zugriff auf den GPIO-Port des Raspberry Pi
11179
112-uses
113- Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
114- Unix, BaseUnix;
80+[![](/wiki-images/0/00/rpi_testcircuit_1d.png)](</File:rpi_testcircuit_1d.png>)
11581
116-type
82+[](</File:rpi_testcircuit_1d.png> "Enlarge")
11783
118- { TForm1 }
84+Testschaltung für den GPIO-Zugriff mit dem beschriebenen Programm
11985
120- TForm1 = class(TForm)
121- LogMemo: TMemo;
122- GPIO17ToggleBox: TToggleBox;
123- procedure FormActivate(Sender: TObject);
124- procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
125- procedure GPIO17ToggleBoxChange(Sender: TObject);
126- private
127- { private declarations }
128- public
129- { public declarations }
130- end;
86+[![](/wiki-images/1/1f/rpi_testcircuit_1p_annotaded.png)](</File:rpi_testcircuit_1p_annotaded.png>)
13187
132-const
133- PIN_17: PChar = '17';
134- PIN_ON: PChar = '1';
135- PIN_OFF: PChar = '0';
136- OUT_DIRECTION: PChar = 'out';
88+[](</File:rpi_testcircuit_1p_annotaded.png> "Enlarge")
13789
138-var
139- Form1: TForm1;
140- gReturnCode: longint; {stores the result of the IO operation}
90+Einfache Demo-Umsetzung der Schaltung auf einer Steckplatine
14191
142-implementation
92+Diese Methode bietet Zugriff auf externe Hardware, ohne zusätzliche Bibliotheken oder Packages zu benötigen. Die einzige Voraussetzung ist die BaseUnix-Bibliothek, die zur RTL gehört und mit Free Pascal automatisch mitinstalliert wird.
14393
144-{$R *.lfm}
94+#### Schalten eines Gerätes über den GPIO-Port
14595
146-{ TForm1 }
96+Im folgenden Beispiel ist ein einfaches Programm aufgelistet, das den GPIO-Pin 17 als Ausgang zum Schalten einer LED, eines Transistors oder eines Relais benutzt. Es enthält eine [ToggleBox](<http://lazarus-ccr.sourceforge.net/docs/lcl/stdctrls/ttogglebox.html> "doc:lcl/stdctrls/ttogglebox.html") mit dem Namen _GPIO17ToggleBox_ und zur Aufzeichnung von Return-Codes ein [TMemo](<http://lazarus-ccr.sourceforge.net/docs/lcl/stdctrls/tmemo.html> "doc:lcl/stdctrls/tmemo.html")-Feld mit der Bezeichnung _LogMemo_.
14797
148-procedure TForm1.FormActivate(Sender: TObject);
149-var
150- fileDesc: integer;
151-begin
152- { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
153- try
154- fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
155- gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
156- LogMemo.Lines.Add(IntToStr(gReturnCode));
157- finally
158- gReturnCode := fpclose(fileDesc);
159- LogMemo.Lines.Add(IntToStr(gReturnCode));
160- end;
161- { Set SoC pin 17 as output: }
162- try
163- fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
164- gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
165- LogMemo.Lines.Add(IntToStr(gReturnCode));
166- finally
167- gReturnCode := fpclose(fileDesc);
168- LogMemo.Lines.Add(IntToStr(gReturnCode));
169- end;
170-end;
98+Hardwareseitig wurde die Anode einer LED mit Pin 11 des Anschlusses auf dem Pi (entsprechend GPIO-Pin 17 des BCM2835 SOC) und ihre Kathode über einen 68-Ohm-Schutzwiderstand mit Pin 6 des Pi-Anschlusses (GND = Masse) verbunden (s. auch die Beschreibung bei Upton and Halfacree). Damit kann die LED durch die ToggleBox des Programms ein- und ausgeschaltet werden.
17199
172-procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
173-var
174- fileDesc: integer;
175-begin
176- { Free SoC pin 17: }
177- try
178- fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
179- gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
180- LogMemo.Lines.Add(IntToStr(gReturnCode));
181- finally
182- gReturnCode := fpclose(fileDesc);
183- LogMemo.Lines.Add(IntToStr(gReturnCode));
184- end;
185-end;
100+Das Programm muss mit Root-Rechten ausgeführt werden, d. h. entweder von einem Root-Account aus (aus Sicherheitsgründen weniger zu empfehlen) oder über das Shell-Kommando **su**.
186101
187-procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
188-var
189- fileDesc: integer;
190-begin
191- if GPIO17ToggleBox.Checked then
192- begin
193- { Swith SoC pin 17 on: }
194- try
195- fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
196- gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
197- LogMemo.Lines.Add(IntToStr(gReturnCode));
198- finally
199- gReturnCode := fpclose(fileDesc);
200- LogMemo.Lines.Add(IntToStr(gReturnCode));
102+_Steuerungs-Unit:_
103+```
104+unit Unit1;
105+
106+ {Demo application for GPIO on Raspberry Pi}
107+ {Inspired by the Python input/output demo application by Gareth Halfacree}
108+ {written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
109+
110+ {$mode objfpc}{$H+}
111+
112+ interface
113+
114+ uses
115+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
116+ Unix, BaseUnix;
117+
118+ type
119+
120+ { TForm1 }
121+
122+ TForm1 = class(TForm)
123+ LogMemo: TMemo;
124+ GPIO17ToggleBox: TToggleBox;
125+ procedure FormActivate(Sender: TObject);
126+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
127+ procedure GPIO17ToggleBoxChange(Sender: TObject);
128+ private
129+ { private declarations }
130+ public
131+ { public declarations }
132+ end;
133+
134+ const
135+ PIN_17: PChar = '17';
136+ PIN_ON: PChar = '1';
137+ PIN_OFF: PChar = '0';
138+ OUT_DIRECTION: PChar = 'out';
139+
140+ var
141+ Form1: TForm1;
142+ gReturnCode: longint; {stores the result of the IO operation}
143+
144+ implementation
145+
146+ {$R *.lfm}
147+
148+ { TForm1 }
149+
150+ procedure TForm1.FormActivate(Sender: TObject);
151+ var
152+ fileDesc: integer;
153+ begin
154+ { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
155+ try
156+ fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
157+ gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
158+ LogMemo.Lines.Add(IntToStr(gReturnCode));
159+ finally
160+ gReturnCode := fpclose(fileDesc);
161+ LogMemo.Lines.Add(IntToStr(gReturnCode));
162+ end;
163+ { Set SoC pin 17 as output: }
164+ try
165+ fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
166+ gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
167+ LogMemo.Lines.Add(IntToStr(gReturnCode));
168+ finally
169+ gReturnCode := fpclose(fileDesc);
170+ LogMemo.Lines.Add(IntToStr(gReturnCode));
171+ end;
201172 end;
202- end
203- else
204- begin
205- { Switch SoC pin 17 off: }
206- try
207- fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
208- gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
209- LogMemo.Lines.Add(IntToStr(gReturnCode));
210- finally
211- gReturnCode := fpclose(fileDesc);
212- LogMemo.Lines.Add(IntToStr(gReturnCode));
173+
174+ procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
175+ var
176+ fileDesc: integer;
177+ begin
178+ { Free SoC pin 17: }
179+ try
180+ fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
181+ gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
182+ LogMemo.Lines.Add(IntToStr(gReturnCode));
183+ finally
184+ gReturnCode := fpclose(fileDesc);
185+ LogMemo.Lines.Add(IntToStr(gReturnCode));
186+ end;
213187 end;
214- end;
215-end;
216-
217-end.
188+
189+ procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
190+ var
191+ fileDesc: integer;
192+ begin
193+ if GPIO17ToggleBox.Checked then
194+ begin
195+ { Swith SoC pin 17 on: }
196+ try
197+ fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
198+ gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
199+ LogMemo.Lines.Add(IntToStr(gReturnCode));
200+ finally
201+ gReturnCode := fpclose(fileDesc);
202+ LogMemo.Lines.Add(IntToStr(gReturnCode));
203+ end;
204+ end
205+ else
206+ begin
207+ { Switch SoC pin 17 off: }
208+ try
209+ fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
210+ gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
211+ LogMemo.Lines.Add(IntToStr(gReturnCode));
212+ finally
213+ gReturnCode := fpclose(fileDesc);
214+ LogMemo.Lines.Add(IntToStr(gReturnCode));
215+ end;
216+ end;
217+ end;
218+
219+ end.
218220```
219221
220-*Hauptprogramm:*
221-
222-``` pascal
222+_Hauptprogramm:_
223+```
223224program io_test;
224-
225-{$mode objfpc}{$H+}
226-
227-uses
228- {$IFDEF UNIX}{$IFDEF UseCThreads}
229- cthreads,
230- {$ENDIF}{$ENDIF}
231- Interfaces, // this includes the LCL widgetset
232- Forms, Unit1
233- { you can add units after this };
234-
235-{$R *.res}
236-
237-begin
238- Application.Initialize;
239- Application.CreateForm(TForm1, Form1);
240- Application.Run;
241-end.
225+
226+ {$mode objfpc}{$H+}
227+
228+ uses
229+ {$IFDEF UNIX}{$IFDEF UseCThreads}
230+ cthreads,
231+ {$ENDIF}{$ENDIF}
232+ Interfaces, // this includes the LCL widgetset
233+ Forms, Unit1
234+ { you can add units after this };
235+
236+ {$R *.res}
237+
238+ begin
239+ Application.Initialize;
240+ Application.CreateForm(TForm1, Form1);
241+ Application.Run;
242+ end.
242243```
243244
244245#### Den Status eines Anschlusses lesen
245246
246-![Demo-Programm, das den Status eines GPIO-Pins ausliest\|thumb\|300px\|right](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png) ![Testschaltung für das o. a. Programm\|thumb\|300px\|right](/wiki-images/f/f4/Rpi_testcircuit_2d.png) ![Beispiel für diese Testschaltung auf einer Steckplatine\|thumb\|300px\|right](/wiki-images/2/2f/Rpi_testcircuit_2p_annotaded.png)
247-
248-Umgekehrt ist es natürlich auch möglich, den Status z. B. eines Schalters abzufragen, der mit dem GPIO-Port verbunden ist.
249-
250-Das folgende einfache Beispiel ist dem vorherigen sehr ähnlich. Es benutzt den GPIO-Pin 18 als Eingang für ein binäres Gerät, z. B. einen Schalter, einen Transistor oder ein Relais. Das Programm enthält eine [[doc:lcl/stdctrls/tcheckbox.html|CheckBox]] mit der Bezeichnung *GPIO18CheckBox* und zur Aufzeichnung von Return-Codes ein [[doc:lcl/stdctrls/tmemo.html|TMemo]]-Feld mit dem Namen *LogMemo*.
251-
252-Im Beispiel wurde ein Pol eines Tasters mit Pin 12 an der Anschlussleiste des Pi (entsprechend GPIO-Pin 18 des BCM2835 SOCs) und über einen 10-kOhm Pull-Up-Widerstand mit Pin 1 (+3.3V, siehe Schaltplan) verbunden. Der andere Pol wurde mit Pin 6 der Anschlussleiste (GND = Masse) verdrahtet. Das Programm liest den Status des Tasters aus und schaltet dementsprechend die CheckBox an oder aus.
253-
254-Das Potential des Pins 18 ist hoch, wenn der Taster nicht gedrückt wird (wegen der Verbindung mit Pin 1 über den Pull-Up-Widerstand) und niedrig, wenn er gedrückt wird (da in dieser Situation Pin 18 über den Taster mit Masse verbunden wird). Der GPIO-Pin meldet daher 0, wenn der Taster gedrückt wird und 1, wenn er losgelassen wird.
255-
256-Auch dieses Programm ist mit Root-Rechten auszuführen.
257-
258-*Steuerung-Unit:*
259-
260-``` pascal
261-unit Unit1;
262-
263-{Demo application for GPIO on Raspberry Pi}
264-{Inspired by the Python input/output demo application by Gareth Halfacree}
265-{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
247+[![](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png)](</File:2013-04-28-193243_1280x1024_scrot.png>)
266248
267-{This application reads the status of a push-button}
249+[](</File:2013-04-28-193243_1280x1024_scrot.png> "Enlarge")
268250
269-{$mode objfpc}{$H+}
251+Demo-Programm, das den Status eines GPIO-Pins ausliest
270252
271-interface
253+[![](/wiki-images/4/4d/rpi_testcircuit_2d.png)](</File:rpi_testcircuit_2d.png>)
272254
273-uses
274- Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
275- ButtonPanel, Unix, BaseUnix;
255+[](</File:rpi_testcircuit_2d.png> "Enlarge")
276256
277-type
257+Testschaltung für das o. a. Programm
278258
279- { TForm1 }
259+[![](/wiki-images/5/54/rpi_testcircuit_2p_annotaded.png)](</File:rpi_testcircuit_2p_annotaded.png>)
280260
281- TForm1 = class(TForm)
282- ApplicationProperties1: TApplicationProperties;
283- GPIO18CheckBox: TCheckBox;
284- LogMemo: TMemo;
285- procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
286- procedure FormActivate(Sender: TObject);
287- procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
288- private
289- { private declarations }
290- public
291- { public declarations }
292- end;
261+[](</File:rpi_testcircuit_2p_annotaded.png> "Enlarge")
293262
294-const
295- PIN_18: PChar = '18';
296- IN_DIRECTION: PChar = 'in';
263+Beispiel für diese Testschaltung auf einer Steckplatine
297264
298-var
299- Form1: TForm1;
300- gReturnCode: longint; {stores the result of the IO operation}
265+Umgekehrt ist es natürlich auch möglich, den Status z. B. eines Schalters abzufragen, der mit dem GPIO-Port verbunden ist.
301266
302-implementation
267+Das folgende einfache Beispiel ist dem vorherigen sehr ähnlich. Es benutzt den GPIO-Pin 18 als Eingang für ein binäres Gerät, z. B. einen Schalter, einen Transistor oder ein Relais. Das Programm enthält eine [CheckBox](<http://lazarus-ccr.sourceforge.net/docs/lcl/stdctrls/tcheckbox.html> "doc:lcl/stdctrls/tcheckbox.html") mit der Bezeichnung _GPIO18CheckBox_ und zur Aufzeichnung von Return-Codes ein [TMemo](<http://lazarus-ccr.sourceforge.net/docs/lcl/stdctrls/tmemo.html> "doc:lcl/stdctrls/tmemo.html")-Feld mit dem Namen _LogMemo_.
303268
304-{$R *.lfm}
269+Im Beispiel wurde ein Pol eines Tasters mit Pin 12 an der Anschlussleiste des Pi (entsprechend GPIO-Pin 18 des BCM2835 SOCs) und über einen 10-kOhm Pull-Up-Widerstand mit Pin 1 (+3.3V, siehe Schaltplan) verbunden. Der andere Pol wurde mit Pin 6 der Anschlussleiste (GND = Masse) verdrahtet. Das Programm liest den Status des Tasters aus und schaltet dementsprechend die CheckBox an oder aus.
305270
306-{ TForm1 }
271+Das Potential des Pins 18 ist hoch, wenn der Taster nicht gedrückt wird (wegen der Verbindung mit Pin 1 über den Pull-Up-Widerstand) und niedrig, wenn er gedrückt wird (da in dieser Situation Pin 18 über den Taster mit Masse verbunden wird). Der GPIO-Pin meldet daher 0, wenn der Taster gedrückt wird und 1, wenn er losgelassen wird.
307272
308-procedure TForm1.FormActivate(Sender: TObject);
309-var
310- fileDesc: integer;
311-begin
312- { Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
313- try
314- fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
315- gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
316- LogMemo.Lines.Add(IntToStr(gReturnCode));
317- finally
318- gReturnCode := fpclose(fileDesc);
319- LogMemo.Lines.Add(IntToStr(gReturnCode));
320- end;
321- { Set SoC pin 18 as input: }
322- try
323- fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
324- gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
325- LogMemo.Lines.Add(IntToStr(gReturnCode));
326- finally
327- gReturnCode := fpclose(fileDesc);
328- LogMemo.Lines.Add(IntToStr(gReturnCode));
329- end;
330-end;
273+Auch dieses Programm ist mit Root-Rechten auszuführen.
331274
332-procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
333-var
334- fileDesc: integer;
335- buttonStatus: string[1] = '1';
336-begin
337- try
338- { Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
339- fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
340- if fileDesc > 0 then
275+_Steuerung-Unit:_
276+```
277+unit Unit1;
278+
279+ {Demo application for GPIO on Raspberry Pi}
280+ {Inspired by the Python input/output demo application by Gareth Halfacree}
281+ {written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
282+
283+ {This application reads the status of a push-button}
284+
285+ {$mode objfpc}{$H+}
286+
287+ interface
288+
289+ uses
290+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
291+ ButtonPanel, Unix, BaseUnix;
292+
293+ type
294+
295+ { TForm1 }
296+
297+ TForm1 = class(TForm)
298+ ApplicationProperties1: TApplicationProperties;
299+ GPIO18CheckBox: TCheckBox;
300+ LogMemo: TMemo;
301+ procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
302+ procedure FormActivate(Sender: TObject);
303+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
304+ private
305+ { private declarations }
306+ public
307+ { public declarations }
308+ end;
309+
310+ const
311+ PIN_18: PChar = '18';
312+ IN_DIRECTION: PChar = 'in';
313+
314+ var
315+ Form1: TForm1;
316+ gReturnCode: longint; {stores the result of the IO operation}
317+
318+ implementation
319+
320+ {$R *.lfm}
321+
322+ { TForm1 }
323+
324+ procedure TForm1.FormActivate(Sender: TObject);
325+ var
326+ fileDesc: integer;
341327 begin
342- { Read status of this pin (0: button pressed, 1: button released): }
343- gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
344- LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
345- LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
346- if buttonStatus = '0' then
347- GPIO18CheckBox.Checked := true
348- else
349- GPIO18CheckBox.Checked := false;
328+ { Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
329+ try
330+ fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
331+ gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
332+ LogMemo.Lines.Add(IntToStr(gReturnCode));
333+ finally
334+ gReturnCode := fpclose(fileDesc);
335+ LogMemo.Lines.Add(IntToStr(gReturnCode));
336+ end;
337+ { Set SoC pin 18 as input: }
338+ try
339+ fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
340+ gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
341+ LogMemo.Lines.Add(IntToStr(gReturnCode));
342+ finally
343+ gReturnCode := fpclose(fileDesc);
344+ LogMemo.Lines.Add(IntToStr(gReturnCode));
345+ end;
350346 end;
351- finally
352- { Close SoC pin 18 (pin 12 on GPIO port) }
353- gReturnCode := fpclose(fileDesc);
354- LogMemo.Lines.Add(IntToStr(gReturnCode));
355- LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
356- end;
357-end;
358-
359-procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
360-var
361- fileDesc: integer;
362-begin
363- { Free SoC pin 18: }
364- try
365- fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
366- gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
367- LogMemo.Lines.Add(IntToStr(gReturnCode));
368- finally
369- gReturnCode := fpclose(fileDesc);
370- LogMemo.Lines.Add(IntToStr(gReturnCode));
371- end;
372-end;
373-
374-end.
347+
348+ procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
349+ var
350+ fileDesc: integer;
351+ buttonStatus: string[1] = '1';
352+ begin
353+ try
354+ { Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
355+ fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
356+ if fileDesc > 0 then
357+ begin
358+ { Read status of this pin (0: button pressed, 1: button released): }
359+ gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
360+ LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
361+ LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
362+ if buttonStatus = '0' then
363+ GPIO18CheckBox.Checked := true
364+ else
365+ GPIO18CheckBox.Checked := false;
366+ end;
367+ finally
368+ { Close SoC pin 18 (pin 12 on GPIO port) }
369+ gReturnCode := fpclose(fileDesc);
370+ LogMemo.Lines.Add(IntToStr(gReturnCode));
371+ LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
372+ end;
373+ end;
374+
375+ procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
376+ var
377+ fileDesc: integer;
378+ begin
379+ { Free SoC pin 18: }
380+ try
381+ fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
382+ gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
383+ LogMemo.Lines.Add(IntToStr(gReturnCode));
384+ finally
385+ gReturnCode := fpclose(fileDesc);
386+ LogMemo.Lines.Add(IntToStr(gReturnCode));
387+ end;
388+ end;
389+
390+ end.
375391```
376392
377-Das Hauptprogramm ist identisch zu dem des obigen Beispiels.
378-
379-### 2. Hardware-Zugriff über gekapselte Shell-Aufrufe
393+Das Hauptprogramm ist identisch zu dem des obigen Beispiels.
380394
381-Eine andere Möglichkeit, auf Hardware zuzugreifen, besteht in der Nutzung gekapselter Shell-Aufrufe. Dies geschieht mit Hilfe der [[Executing External Programs|fpsystem]]-Funktion. Auf diese Weise ist es möglich, auf Funktionen zuzugreifen, die von der BaseUnix-Unit nicht unterstützt werden. Der folgende Code hat die selbe Funktionalität wie das Programm des ersten Listings oben.
395+### 2\. Hardware-Zugriff über gekapselte Shell-Aufrufe
382396
383-*Steuerungs-Unit:*
397+Eine andere Möglichkeit, auf Hardware zuzugreifen, besteht in der Nutzung gekapselter Shell-Aufrufe. Dies geschieht mit Hilfe der [[Executing External Programs|fpsystem]]-Funktion. Auf diese Weise ist es möglich, auf Funktionen zuzugreifen, die von der BaseUnix-Unit nicht unterstützt werden. Der folgende Code hat die selbe Funktionalität wie das Programm des ersten Listings oben.
384398
385-``` pascal
399+_Steuerungs-Unit:_
400+```
386401unit Unit1;
387-
388-{Demo application for GPIO on Raspberry Pi}
389-{Inspired by the Python input/output demo application by Gareth Halfacree}
390-{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
391-
392-{$mode objfpc}{$H+}
393-
394-interface
395-
396-uses
397- Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
398-
399-type
400-
401- { TForm1 }
402-
403- TForm1 = class(TForm)
404- LogMemo: TMemo;
405- GPIO17ToggleBox: TToggleBox;
406- procedure FormActivate(Sender: TObject);
407- procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
408- procedure GPIO17ToggleBoxChange(Sender: TObject);
409- private
410- { private declarations }
411- public
412- { public declarations }
413- end;
414-
415-var
416- Form1: TForm1;
417- gReturnCode: longint; {stores the result of the IO operation}
418-
419-implementation
420-
421-{$R *.lfm}
422-
423-{ TForm1 }
424-
425-procedure TForm1.FormActivate(Sender: TObject);
426-begin
427- { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
428- gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
429- LogMemo.Lines.Add(IntToStr(gReturnCode));
430- { Set SoC pin 17 as output: }
431- gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
432- LogMemo.Lines.Add(IntToStr(gReturnCode));
433-end;
434-
435-procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
436-begin
437- { Free SoC pin 17: }
438- gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
439- LogMemo.Lines.Add(IntToStr(gReturnCode));
440-end;
441-
442-procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
443-begin
444- if GPIO17ToggleBox.Checked then
445- begin
446- { Swith SoC pin 17 on: }
447- gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
448- LogMemo.Lines.Add(IntToStr(gReturnCode));
449- end
450- else
451- begin
452- { Switch SoC pin 17 off: }
453- gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
454- LogMemo.Lines.Add(IntToStr(gReturnCode));
455- end;
456-end;
457-
458-end.
402+
403+ {Demo application for GPIO on Raspberry Pi}
404+ {Inspired by the Python input/output demo application by Gareth Halfacree}
405+ {written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
406+
407+ {$mode objfpc}{$H+}
408+
409+ interface
410+
411+ uses
412+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
413+
414+ type
415+
416+ { TForm1 }
417+
418+ TForm1 = class(TForm)
419+ LogMemo: TMemo;
420+ GPIO17ToggleBox: TToggleBox;
421+ procedure FormActivate(Sender: TObject);
422+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
423+ procedure GPIO17ToggleBoxChange(Sender: TObject);
424+ private
425+ { private declarations }
426+ public
427+ { public declarations }
428+ end;
429+
430+ var
431+ Form1: TForm1;
432+ gReturnCode: longint; {stores the result of the IO operation}
433+
434+ implementation
435+
436+ {$R *.lfm}
437+
438+ { TForm1 }
439+
440+ procedure TForm1.FormActivate(Sender: TObject);
441+ begin
442+ { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
443+ gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
444+ LogMemo.Lines.Add(IntToStr(gReturnCode));
445+ { Set SoC pin 17 as output: }
446+ gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
447+ LogMemo.Lines.Add(IntToStr(gReturnCode));
448+ end;
449+
450+ procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
451+ begin
452+ { Free SoC pin 17: }
453+ gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
454+ LogMemo.Lines.Add(IntToStr(gReturnCode));
455+ end;
456+
457+ procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
458+ begin
459+ if GPIO17ToggleBox.Checked then
460+ begin
461+ { Swith SoC pin 17 on: }
462+ gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
463+ LogMemo.Lines.Add(IntToStr(gReturnCode));
464+ end
465+ else
466+ begin
467+ { Switch SoC pin 17 off: }
468+ gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
469+ LogMemo.Lines.Add(IntToStr(gReturnCode));
470+ end;
471+ end;
472+
473+ end.
459474```
460475
461-Das Hauptprogramm ist identisch zu dem der obigen Beispiele. Es erfordert wieder Root-Rechte.
462-
463-### 3. wiringPi-Prozeduren und Funktionen
476+Das Hauptprogramm ist identisch zu dem der obigen Beispiele. Es erfordert wieder Root-Rechte.
464477
465-Mit Hilfe von Alex Schallers Wrapper-Unit für Gordon Hendersons Arduino-kompatible wiringPi-Bibliothek kann ein Nummerierungs-Schema verwendet werden, das dem der Arduino-Boards entspricht.
478+### 3\. wiringPi-Prozeduren und Funktionen
466479
467-``` pascal
480+Mit Hilfe von Alex Schallers Wrapper-Unit für Gordon Hendersons Arduino-kompatible wiringPi-Bibliothek kann ein Nummerierungs-Schema verwendet werden, das dem der Arduino-Boards entspricht.
481+```
468482Function wiringPiSetup:longint; {Initialisiert das wiringPi-System entsprechend dem wiringPi Pin-Nummerierungs-Schema.}
469-
470-Procedure wiringPiGpioMode(mode:longint); {Initialisiert das wiringPi-System mit dem Broadcom GPIO-Pin-Nummerierungs-Schema.}
471-
472-Procedure pullUpDnControl(pin:longint; pud:longint); {steuert die internen pull-up/down-Widerstände eines GPIO-Pins.}
473-
474-Procedure pinMode(pin:longint; mode:longint); {setzt den Betriebsmodus eines Pins auf entweder INPUT, OUTPUT oder PWM_OUTPUT.}
475-
476-Procedure digitalWrite(pin:longint; value:longint); {setzt ein Ausgabe-Bit.}
477-
478-Procedure pwmWrite(pin:longint; value:longint); {setzt einen Ausgabe-PWM-Wert zwischen 0 und 1024.}
479-
480-Function digitalRead(pin:longint):longint; {liest den Wert des übergebenen Pins, gibt 1 oder 0.}
481-
482-Procedure delay(howLong:dword); {wartet howLong Millisekunden.}
483-
484-Procedure delayMicroseconds(howLong:dword); {wartet howLong Mikrosekunden.}
485-
486-Function millis:dword; {gibt die Zahl der Millisekunden zurück, seit das Programm eine der wiringPiSetup-Funktionen aufgerufen hat.}
483+
484+ Procedure wiringPiGpioMode(mode:longint); {Initialisiert das wiringPi-System mit dem Broadcom GPIO-Pin-Nummerierungs-Schema.}
485+
486+ Procedure pullUpDnControl(pin:longint; pud:longint); {steuert die internen pull-up/down-Widerstände eines GPIO-Pins.}
487+
488+ Procedure pinMode(pin:longint; mode:longint); {setzt den Betriebsmodus eines Pins auf entweder INPUT, OUTPUT oder PWM_OUTPUT.}
489+
490+ Procedure digitalWrite(pin:longint; value:longint); {setzt ein Ausgabe-Bit.}
491+
492+ Procedure pwmWrite(pin:longint; value:longint); {setzt einen Ausgabe-PWM-Wert zwischen 0 und 1024.}
493+
494+ Function digitalRead(pin:longint):longint; {liest den Wert des übergebenen Pins, gibt 1 oder 0.}
495+
496+ Procedure delay(howLong:dword); {wartet howLong Millisekunden.}
497+
498+ Procedure delayMicroseconds(howLong:dword); {wartet howLong Mikrosekunden.}
499+
500+ Function millis:dword; {gibt die Zahl der Millisekunden zurück, seit das Programm eine der wiringPiSetup-Funktionen aufgerufen hat.}
487501```
488502
489-### 4. rpi_hal-Hardware Abstraction Library (GPIO, I2C und SPI Funktionen und Prozeduren)
503+### 4\. rpi_hal-Hardware Abstraction Library (GPIO, I2C und SPI Funktionen und Prozeduren)
490504
491-Diese Unit mit ca. 1700 Lines of Code wird von Stefan Fischer zur Verfügung gestellt und bietet Prozeduren und Funktionen, die auf die rpi HW Zugriff auf I2C, SPI und GPIO bietet:
505+Diese Unit mit ca. 1700 Lines of Code wird von Stefan Fischer zur Verfügung gestellt und bietet Prozeduren und Funktionen, die auf die rpi HW Zugriff auf I2C, SPI und GPIO bietet:
492506
493-Ein Auszug der verfügbaren Funktionen und Prozeduren:
507+Ein Auszug der verfügbaren Funktionen und Prozeduren:
494508
495-**procedure gpio_set_pin (pin:longword;highlevel:boolean);** { Set RPi GPIO pin to high or low level; Speed @ 700MHz -\> 0.65MHz }
509+**procedure gpio_set_pin (pin:longword;highlevel:boolean);** { Set RPi GPIO pin to high or low level; Speed @ 700MHz -> 0.65MHz }
496510
497-**function gpio_get_PIN (pin:longword):boolean;** { Get RPi GPIO pin Level is true when Pin level is '1'; false when '0'; Speed @ 700MHz -\> 1.17MHz }
511+**function gpio_get_PIN (pin:longword):boolean;** { Get RPi GPIO pin Level is true when Pin level is '1'; false when '0'; Speed @ 700MHz -> 1.17MHz }
498512
499-**procedure gpio_set_input (pin:longword);** { Set RPi GPIO pin to input direction }
513+**procedure gpio_set_input (pin:longword);** { Set RPi GPIO pin to input direction }
500514
501-**procedure gpio_set_output(pin:longword);** { Set RPi GPIO pin to output direction }
515+**procedure gpio_set_output(pin:longword);** { Set RPi GPIO pin to output direction }
502516
503-**procedure gpio_set_alt (pin,altfunc:longword);** { Set RPi GPIO pin to alternate function nr. 0..5 }
517+**procedure gpio_set_alt (pin,altfunc:longword);** { Set RPi GPIO pin to alternate function nr. 0..5 }
504518
505-**procedure gpio_set_gppud (mask:longword);** { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
519+**procedure gpio_set_gppud (mask:longword);** { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
506520
507-...
521+...
508522
509-**function rpi_snr :string;** { delivers SNR: 0000000012345678 }
523+**function rpi_snr :string;** { delivers SNR: 0000000012345678 }
510524
511-**function rpi_hw :string;** { delivers Processor Type: BCM2708 }
525+**function rpi_hw :string;** { delivers Processor Type: BCM2708 }
512526
513-**function rpi_proc:string;** { ARMv6-compatible processor rev 7 (v6l) }
527+**function rpi_proc:string;** { ARMv6-compatible processor rev 7 (v6l) }
514528
515-...
529+...
516530
517-**function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;**
531+**function i2c_bus_write(baseadr,reg:word; var data:databuf_t; lgt:byte; testnr:integer) : integer;**
518532
519-**function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;**
533+**function i2c_bus_read (baseadr,reg:word; var data:databuf_t; lgt:byte; testnr:integer) : integer;**
520534
521-**function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;**
535+**function i2c_string_read(baseadr,reg:word; var data:databuf_t; lgt:byte; testnr:integer) : string;**
522536
523537**function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;**
524538
525-...
539+...
526540
527541**procedure SPI_Write(devnum:byte; reg,data:word);**
528542
529543**function SPI_Read(devnum:byte; reg:word) : byte;**
530544
531545**procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);**
532546
533-**procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword);** { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
534-
535-...
547+**procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword);** { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
536548
537-*Test Program (testrpi.pas):*
549+...
538550
539-``` pascal
551+
552+_Test Program (testrpi.pas):_
553+```
540554//Simple Test program, which is using rpi_hal;
541-
542- program testrpi;
543- uses rpi_hal;
544- begin
545- writeln('Show CPU-Info, RPI-HW-Info and Registers:');
546- rpi_show_all_info;
547- writeln('Let Status LED Blink. Using GPIO functions:');
548- GPIO_PIN_TOGGLE_TEST;
549- writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
550- Test_SPI;
551- end.
555+
556+ program testrpi;
557+ uses rpi_hal;
558+ begin
559+ writeln('Show CPU-Info, RPI-HW-Info and Registers:');
560+ rpi_show_all_info;
561+ writeln('Let Status LED Blink. Using GPIO functions:');
562+ GPIO_PIN_TOGGLE_TEST;
563+ writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
564+ Test_SPI;
565+ end.
552566```
553567
554-### 5. PascalIO
568+### 5\. PascalIO
555569
556-Mit dem Package [PascalIO](https://github.com/SAmeis/pascalio) kann objektorientiert auf die Schnittstellen zugegriffen werden. Es beinhaltet Klassen für die GPIO-Pins sowie für den I2C- und SPI-Bus.
570+Mit dem Package [PascalIO](<https://github.com/SAmeis/pascalio>) kann objektorientiert auf die Schnittstellen zugegriffen werden. Es beinhaltet Klassen für die GPIO-Pins sowie für den I2C- und SPI-Bus.
557571
558572#### GPIO
559573
560574##### Input
561-
562-``` pascal
575+```
563576program Project1;
564-uses fpgpio;
565-var
566- pin_21: TGpioPin;
567-begin
568- pin_21 := TGpioLinuxPin.Create(21);
569- pin_21.Direction := gdIn;
570- WriteLn('Pin 21 hat den Wert: ', pin_21.Value);
571- pin_21.Destroy;
572-end.
577+ uses fpgpio;
578+ var
579+ pin_21: TGpioPin;
580+ begin
581+ pin_21 := TGpioLinuxPin.Create(21);
582+ pin_21.Direction := gdIn;
583+ WriteLn('Pin 21 hat den Wert: ', pin_21.Value);
584+ pin_21.Destroy;
585+ end.
573586```
574587
575588##### Output
576-
577-``` pascal
589+```
578590program Project1;
579-uses sysutils, fpgpio;
580-var
581- i: Integer;
582- pin_21: TGpioPin;
583-begin
584- pin_21 := TGpioLinuxPin.Create(21);
585- pin_21.Direction := gdOut;
586- for i := 0 to 10 do
587- begin
588- pin_21.Value := (i and $01) = 0;
589- sleep(1000);
590- end;
591- pin_21.Destroy;
592-end.
591+ uses sysutils, fpgpio;
592+ var
593+ i: Integer;
594+ pin_21: TGpioPin;
595+ begin
596+ pin_21 := TGpioLinuxPin.Create(21);
597+ pin_21.Direction := gdOut;
598+ for i := 0 to 10 do
599+ begin
600+ pin_21.Value := (i and $01) = 0;
601+ sleep(1000);
602+ end;
603+ pin_21.Destroy;
604+ end.
593605```
594606
595607##### Interrupt
596-
597-``` pascal
608+```
598609program Project1;
599-uses fpgpio;
600-var
601- pin_21: TGpioPin;
602- NewValue: Boolean;
603-begin
604- pin_21 := TGpioLinuxPin.Create(21);
605- pin_21.Direction := gdIn;
606- pin_21.InterruptMode := [gimRising, gimFalling];
607- try
608- repeat
609- if input.WaitForInterrupt(TGpioLinuxPin.INTERRUPT_WAIT_INFINITE, NewValue) then
610- Writeln('Interrupt on Pin ', input.PinID, ' with value ', NewValue)
611- else
612- WriteLn('Timeout');
613- until False;
614- except
615- // e.g. on sig int
616- pin_21.Destroy;
617- end;
618-end.
610+ uses fpgpio;
611+ var
612+ pin_21: TGpioPin;
613+ NewValue: Boolean;
614+ begin
615+ pin_21 := TGpioLinuxPin.Create(21);
616+ pin_21.Direction := gdIn;
617+ pin_21.InterruptMode := [gimRising, gimFalling];
618+ try
619+ repeat
620+ if input.WaitForInterrupt(TGpioLinuxPin.INTERRUPT_WAIT_INFINITE, NewValue) then
621+ Writeln('Interrupt on Pin ', input.PinID, ' with value ', NewValue)
622+ else
623+ WriteLn('Timeout');
624+ until False;
625+ except
626+ // e.g. on sig int
627+ pin_21.Destroy;
628+ end;
629+ end.
619630```
620631
621632## Literatur
622633
623-- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
634+ * Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
624635
625636## Externe Links
626637
627-- [Raspberry Pi Foundation](http://www.raspberrypi.org)
628-- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
629-- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
630-- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
631-- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
632-- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
633-- [Lazberry Pi: Umfangreiche Informationen zu Lazarus auf dem Raspberry Pi (englisch)](http://superbitysoft.co.uk/lazberrypi/).
634-- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
638+ * [Raspberry Pi Foundation](<http://www.raspberrypi.org>)
639+ * [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](<http://www.raspberrypi-spy.co.uk>)
640+ * [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](<http://www.lazarus.freepascal.org/index.php/topic,17404.0.html>)
641+ * [Pin layout of the wiringPi library](<https://projects.drogon.net/raspberry-pi/wiringpi/pins/>)
642+ * [Additional information on Lazarus and Raspberry Pi at eLinux.org](<http://www.elinux.org/Lazarus_on_RPi>)
643+ * [Getting Started with Pascal on the Pi](<http://www.pp4s.co.uk/main/gs-pi-intro.html>)
644+ * [Lazberry Pi: Umfangreiche Informationen zu Lazarus auf dem Raspberry Pi (englisch)](<http://superbitysoft.co.uk/lazberrypi/>).
645+ * [Stefan Fischer's Lazarus unit rpi_hal](<http://www.lazarus.freepascal.org/index.php/topic,20991.0.html>).
635646
636647---
637-*From the Free Pascal wiki, page "Lazarus on Raspberry Pi/de", as it stood on 2020-02-18 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*
648+*From the Free Pascal wiki, page "Lazarus on Raspberry Pi/de", as the Internet Archive kept it on 2025-06-16, last changed on 2020-02-19. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*

Back to history