Sign in Join
Wiki copytemporary

Lazarus on Raspberry Pi/de: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: Lazarus on Raspberry Pi/de

OldNewLine
1+<img src="Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png" title="Lazarus unter Raspbian Wheezy" width="200" alt="Lazarus unter Raspbian Wheezy" /> *(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.
16+
17+deb <http://plugwash.raspbian.org/wsf> wheezy-wsf main
18+
19+Diese Information bezieht sich auf den Artikel:
20+
21+[Raspberrypi.org FPC-Fix](http://www.raspberrypi.org/forums/viewtopic.php?f=34&t=88145)
22+
23+#### Raspberry Pi 1
24+
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:
26+
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+```
33+
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.
35+
36+Install Lazarus Rasbian Part1 de.png\|Installation 1 Install Lazarus Rasbian Part2 de.png\|Installation 2 Install Lazarus Rasbian Part3 de.png\|Installation 3 Install Lazarus Rasbian Part4 de.png\|Installation 4
37+
38+#### Raspberry Pi 2
39+
40+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/).
41+
42+<File:Lazarus> 0 9 30 4 on RPi 2.png\|Lazarus "out of the box" auf dem Raspberry Pi 2
43+
44+### Übersetzen aus den Quelltexten
45+
46+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.
47+
48+<File:Start> Menu with Lazarus de.png\|Starten von Lazarus unter Raspbian Wheezy <File:Lazarus> on Raspberry Pi.jpg\|Lazarus auf dem Raspberry Pi <File:rpi> gpio pins.png\|Nummerierung der GPIO-Anschlüsse
49+
50+## Zugriff auf externe Hardware
51+
52+<figure>
53+<img src="rpi_pinout_all_50.png" title="Belegung der externen Anschlüsse des Raspberry Pi" width="300" />
54+<figcaption>Belegung der externen Anschlüsse des Raspberry Pi</figcaption>
55+</figure>
56+
57+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:
58+
59+1. [[Lazarus on Raspberry Pi/de|Direktzugriff]] über die [[doc:rtl/baseunix/index.html|BaseUnix]]-Unit
60+2. Zugriff über [[Lazarus on Raspberry Pi/de|gekapselte Shell-Aufrufe]]
61+3. Zugriff über die [[Lazarus on Raspberry Pi/de|wiringPi library]].
62+4. Zugriff über die Unit [[Lazarus on Raspberry Pi/de|rpi_hal]].
63+
64+### 1. Nativer Hardware-Zugriff
65+
66+![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.
67+
68+#### Schalten eines Gerätes über den GPIO-Port
69+
70+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*.
71+
72+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.
73+
74+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**.
75+
76+*Steuerungs-Unit:*
77+
78+``` pascal
79+unit Unit1;
80+
81+{Demo application for GPIO on Raspberry Pi}
82+{Inspired by the Python input/output demo application by Gareth Halfacree}
83+{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
84+
85+{$mode objfpc}{$H+}
86+
87+interface
88+
89+uses
90+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
91+ Unix, BaseUnix;
92+
93+type
94+
95+ { TForm1 }
96+
97+ TForm1 = class(TForm)
98+ LogMemo: TMemo;
99+ GPIO17ToggleBox: TToggleBox;
100+ procedure FormActivate(Sender: TObject);
101+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
102+ procedure GPIO17ToggleBoxChange(Sender: TObject);
103+ private
104+ { private declarations }
105+ public
106+ { public declarations }
107+ end;
108+
109+const
110+ PIN_17: PChar = '17';
111+ PIN_ON: PChar = '1';
112+ PIN_OFF: PChar = '0';
113+ OUT_DIRECTION: PChar = 'out';
114+
115+var
116+ Form1: TForm1;
117+ gReturnCode: longint; {stores the result of the IO operation}
118+
119+implementation
120+
121+{$R *.lfm}
122+
123+{ TForm1 }
124+
125+procedure TForm1.FormActivate(Sender: TObject);
126+var
127+ fileDesc: integer;
128+begin
129+ { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
130+ try
131+ fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
132+ gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
133+ LogMemo.Lines.Add(IntToStr(gReturnCode));
134+ finally
135+ gReturnCode := fpclose(fileDesc);
136+ LogMemo.Lines.Add(IntToStr(gReturnCode));
137+ end;
138+ { Set SoC pin 17 as output: }
139+ try
140+ fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
141+ gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
142+ LogMemo.Lines.Add(IntToStr(gReturnCode));
143+ finally
144+ gReturnCode := fpclose(fileDesc);
145+ LogMemo.Lines.Add(IntToStr(gReturnCode));
146+ end;
147+end;
148+
149+procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
150+var
151+ fileDesc: integer;
152+begin
153+ { Free SoC pin 17: }
154+ try
155+ fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
156+ gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
157+ LogMemo.Lines.Add(IntToStr(gReturnCode));
158+ finally
159+ gReturnCode := fpclose(fileDesc);
160+ LogMemo.Lines.Add(IntToStr(gReturnCode));
161+ end;
162+end;
163+
164+procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
165+var
166+ fileDesc: integer;
167+begin
168+ if GPIO17ToggleBox.Checked then
169+ begin
170+ { Swith SoC pin 17 on: }
171+ try
172+ fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
173+ gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
174+ LogMemo.Lines.Add(IntToStr(gReturnCode));
175+ finally
176+ gReturnCode := fpclose(fileDesc);
177+ LogMemo.Lines.Add(IntToStr(gReturnCode));
178+ end;
179+ end
180+ else
181+ begin
182+ { Switch SoC pin 17 off: }
183+ try
184+ fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
185+ gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
186+ LogMemo.Lines.Add(IntToStr(gReturnCode));
187+ finally
188+ gReturnCode := fpclose(fileDesc);
189+ LogMemo.Lines.Add(IntToStr(gReturnCode));
190+ end;
191+ end;
192+end;
193+
194+end.
195+```
196+
197+*Hauptprogramm:*
198+
199+``` pascal
200+program io_test;
201+
202+{$mode objfpc}{$H+}
203+
204+uses
205+ {$IFDEF UNIX}{$IFDEF UseCThreads}
206+ cthreads,
207+ {$ENDIF}{$ENDIF}
208+ Interfaces, // this includes the LCL widgetset
209+ Forms, Unit1
210+ { you can add units after this };
211+
212+{$R *.res}
213+
214+begin
215+ Application.Initialize;
216+ Application.CreateForm(TForm1, Form1);
217+ Application.Run;
218+end.
219+```
220+
221+#### Den Status eines Anschlusses lesen
222+
223+![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)
224+
225+Umgekehrt ist es natürlich auch möglich, den Status z. B. eines Schalters abzufragen, der mit dem GPIO-Port verbunden ist.
226+
227+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*.
228+
229+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.
230+
231+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.
232+
233+Auch dieses Programm ist mit Root-Rechten auszuführen.
234+
235+*Steuerung-Unit:*
236+
237+``` pascal
238+unit Unit1;
239+
240+{Demo application for GPIO on Raspberry Pi}
241+{Inspired by the Python input/output demo application by Gareth Halfacree}
242+{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
243+
244+{This application reads the status of a push-button}
245+
246+{$mode objfpc}{$H+}
247+
248+interface
249+
250+uses
251+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
252+ ButtonPanel, Unix, BaseUnix;
253+
254+type
255+
256+ { TForm1 }
257+
258+ TForm1 = class(TForm)
259+ ApplicationProperties1: TApplicationProperties;
260+ GPIO18CheckBox: TCheckBox;
261+ LogMemo: TMemo;
262+ procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
263+ procedure FormActivate(Sender: TObject);
264+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
265+ private
266+ { private declarations }
267+ public
268+ { public declarations }
269+ end;
270+
271+const
272+ PIN_18: PChar = '18';
273+ IN_DIRECTION: PChar = 'in';
274+
275+var
276+ Form1: TForm1;
277+ gReturnCode: longint; {stores the result of the IO operation}
278+
279+implementation
280+
281+{$R *.lfm}
282+
283+{ TForm1 }
284+
285+procedure TForm1.FormActivate(Sender: TObject);
286+var
287+ fileDesc: integer;
288+begin
289+ { Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
290+ try
291+ fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
292+ gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
293+ LogMemo.Lines.Add(IntToStr(gReturnCode));
294+ finally
295+ gReturnCode := fpclose(fileDesc);
296+ LogMemo.Lines.Add(IntToStr(gReturnCode));
297+ end;
298+ { Set SoC pin 18 as input: }
299+ try
300+ fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
301+ gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
302+ LogMemo.Lines.Add(IntToStr(gReturnCode));
303+ finally
304+ gReturnCode := fpclose(fileDesc);
305+ LogMemo.Lines.Add(IntToStr(gReturnCode));
306+ end;
307+end;
308+
309+procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
310+var
311+ fileDesc: integer;
312+ buttonStatus: string[1] = '1';
313+begin
314+ try
315+ { Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
316+ fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
317+ if fileDesc > 0 then
318+ begin
319+ { Read status of this pin (0: button pressed, 1: button released): }
320+ gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
321+ LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
322+ LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
323+ if buttonStatus = '0' then
324+ GPIO18CheckBox.Checked := true
325+ else
326+ GPIO18CheckBox.Checked := false;
327+ end;
328+ finally
329+ { Close SoC pin 18 (pin 12 on GPIO port) }
330+ gReturnCode := fpclose(fileDesc);
331+ LogMemo.Lines.Add(IntToStr(gReturnCode));
332+ LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
333+ end;
334+end;
335+
336+procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
337+var
338+ fileDesc: integer;
339+begin
340+ { Free SoC pin 18: }
341+ try
342+ fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
343+ gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
344+ LogMemo.Lines.Add(IntToStr(gReturnCode));
345+ finally
346+ gReturnCode := fpclose(fileDesc);
347+ LogMemo.Lines.Add(IntToStr(gReturnCode));
348+ end;
349+end;
350+
351+end.
352+```
353+
354+Das Hauptprogramm ist identisch zu dem des obigen Beispiels.
355+
356+### 2. Hardware-Zugriff über gekapselte Shell-Aufrufe
357+
358+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.
359+
360+*Steuerungs-Unit:*
361+
362+``` pascal
363+unit Unit1;
364+
365+{Demo application for GPIO on Raspberry Pi}
366+{Inspired by the Python input/output demo application by Gareth Halfacree}
367+{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
368+
369+{$mode objfpc}{$H+}
370+
371+interface
372+
373+uses
374+ Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
375+
376+type
377+
378+ { TForm1 }
379+
380+ TForm1 = class(TForm)
381+ LogMemo: TMemo;
382+ GPIO17ToggleBox: TToggleBox;
383+ procedure FormActivate(Sender: TObject);
384+ procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
385+ procedure GPIO17ToggleBoxChange(Sender: TObject);
386+ private
387+ { private declarations }
388+ public
389+ { public declarations }
390+ end;
391+
392+var
393+ Form1: TForm1;
394+ gReturnCode: longint; {stores the result of the IO operation}
395+
396+implementation
397+
398+{$R *.lfm}
399+
400+{ TForm1 }
401+
402+procedure TForm1.FormActivate(Sender: TObject);
403+begin
404+ { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
405+ gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
406+ LogMemo.Lines.Add(IntToStr(gReturnCode));
407+ { Set SoC pin 17 as output: }
408+ gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
409+ LogMemo.Lines.Add(IntToStr(gReturnCode));
410+end;
411+
412+procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
413+begin
414+ { Free SoC pin 17: }
415+ gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
416+ LogMemo.Lines.Add(IntToStr(gReturnCode));
417+end;
418+
419+procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
420+begin
421+ if GPIO17ToggleBox.Checked then
422+ begin
423+ { Swith SoC pin 17 on: }
424+ gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
425+ LogMemo.Lines.Add(IntToStr(gReturnCode));
426+ end
427+ else
428+ begin
429+ { Switch SoC pin 17 off: }
430+ gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
431+ LogMemo.Lines.Add(IntToStr(gReturnCode));
432+ end;
433+end;
434+
435+end.
436+```
437+
438+Das Hauptprogramm ist identisch zu dem der obigen Beispiele. Es erfordert wieder Root-Rechte.
439+
440+### 3. wiringPi-Prozeduren und Funktionen
441+
442+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.
443+
444+``` pascal
445+Function wiringPiSetup:longint; {Initialisiert das wiringPi-System entsprechend dem wiringPi Pin-Nummerierungs-Schema.}
446+
447+Procedure wiringPiGpioMode(mode:longint); {Initialisiert das wiringPi-System mit dem Broadcom GPIO-Pin-Nummerierungs-Schema.}
448+
449+Procedure pullUpDnControl(pin:longint; pud:longint); {steuert die internen pull-up/down-Widerstände eines GPIO-Pins.}
450+
451+Procedure pinMode(pin:longint; mode:longint); {setzt den Betriebsmodus eines Pins auf entweder INPUT, OUTPUT oder PWM_OUTPUT.}
452+
453+Procedure digitalWrite(pin:longint; value:longint); {setzt ein Ausgabe-Bit.}
454+
455+Procedure pwmWrite(pin:longint; value:longint); {setzt einen Ausgabe-PWM-Wert zwischen 0 und 1024.}
456+
457+Function digitalRead(pin:longint):longint; {liest den Wert des übergebenen Pins, gibt 1 oder 0.}
458+
459+Procedure delay(howLong:dword); {wartet howLong Millisekunden.}
460+
461+Procedure delayMicroseconds(howLong:dword); {wartet howLong Mikrosekunden.}
462+
463+Function millis:dword; {gibt die Zahl der Millisekunden zurück, seit das Programm eine der wiringPiSetup-Funktionen aufgerufen hat.}
464+```
465+
466+### 4. rpi_hal-Hardware Abstraction Library (GPIO, I2C und SPI Funktionen und Prozeduren)
467+
468+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:
469+
470+Ein Auszug der verfügbaren Funktionen und Prozeduren:
471+
472+**procedure gpio_set_pin (pin:longword;highlevel:boolean);** { Set RPi GPIO pin to high or low level; Speed @ 700MHz -\> 0.65MHz }
473+
474+**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 }
475+
476+**procedure gpio_set_input (pin:longword);** { Set RPi GPIO pin to input direction }
477+
478+**procedure gpio_set_output(pin:longword);** { Set RPi GPIO pin to output direction }
479+
480+**procedure gpio_set_alt (pin,altfunc:longword);** { Set RPi GPIO pin to alternate function nr. 0..5 }
481+
482+**procedure gpio_set_gppud (mask:longword);** { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
483+
484+...
485+
486+**function rpi_snr :string;** { delivers SNR: 0000000012345678 }
487+
488+**function rpi_hw :string;** { delivers Processor Type: BCM2708 }
489+
490+**function rpi_proc:string;** { ARMv6-compatible processor rev 7 (v6l) }
491+
492+...
493+
494+**function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;**
495+
496+**function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;**
497+
498+**function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;**
499+
500+**function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;**
501+
502+...
503+
504+**procedure SPI_Write(devnum:byte; reg,data:word);**
505+
506+**function SPI_Read(devnum:byte; reg:word) : byte;**
507+
508+**procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);**
509+
510+**procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword);** { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
511+
512+...
513+
514+*Test Program (testrpi.pas):*
515+
516+``` pascal
517+//Simple Test program, which is using rpi_hal;
518+
519+ program testrpi;
520+ uses rpi_hal;
521+ begin
522+ writeln('Show CPU-Info, RPI-HW-Info and Registers:');
523+ rpi_show_all_info;
524+ writeln('Let Status LED Blink. Using GPIO functions:');
525+ GPIO_PIN_TOGGLE_TEST;
526+ writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
527+ Test_SPI;
528+ end.
529+```
530+
531+### 5. PascalIO
532+
533+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.
534+
535+#### GPIO
536+
537+##### Input
538+
539+``` pascal
540+program Project1;
541+uses fpgpio;
542+var
543+ pin_21: TGpioPin;
544+begin
545+ pin_21 := TGpioLinuxPin.Create(21);
546+ pin_21.Direction := gdIn;
547+ WriteLn('Pin 21 hat den Wert: ', pin_21.Value);
548+ pin_21.Destroy;
549+end.
550+```
551+
552+##### Output
553+
554+``` pascal
555+program Project1;
556+uses sysutils, fpgpio;
557+var
558+ i: Integer;
559+ pin_21: TGpioPin;
560+begin
561+ pin_21 := TGpioLinuxPin.Create(21);
562+ pin_21.Direction := gdOut;
563+ for i := 0 to 10 do
564+ begin
565+ pin_21.Value := (i and $01) = 0;
566+ sleep(1000);
567+ end;
568+ pin_21.Destroy;
569+end.
570+```
571+
572+##### Interrupt
573+
574+``` pascal
575+program Project1;
576+uses fpgpio;
577+var
578+ pin_21: TGpioPin;
579+ NewValue: Boolean;
580+begin
581+ pin_21 := TGpioLinuxPin.Create(21);
582+ pin_21.Direction := gdIn;
583+ pin_21.InterruptMode := [gimRising, gimFalling];
584+ try
585+ repeat
586+ if input.WaitForInterrupt(TGpioLinuxPin.INTERRUPT_WAIT_INFINITE, NewValue) then
587+ Writeln('Interrupt on Pin ', input.PinID, ' with value ', NewValue)
588+ else
589+ WriteLn('Timeout');
590+ until False;
591+ except
592+ // e.g. on sig int
593+ pin_21.Destroy;
594+ end;
595+end.
596+```
597+
598+## Literatur
599+
600+- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
601+
602+## Externe Links
603+
604+- [Raspberry Pi Foundation](http://www.raspberrypi.org)
605+- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
606+- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
607+- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
608+- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
609+- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
610+- [Lazberry Pi: Umfangreiche Informationen zu Lazarus auf dem Raspberry Pi (englisch)](http://superbitysoft.co.uk/lazberrypi/).
611+- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
612+
613+---
614+*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).*

Back to history