Lazarus on Raspberry Pi/es: what changed

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

Old	New		Line
1	1		La información que viene a continuación es una traducción lo más aproximada posible de la entrada en inglés (con alguna variación allí donde requiera ser más detallada o explicativa) y puede que las que se redacten en los otros idiomas alternativos de esta wiki. Cada uno que utilice esta información bajo su propio riesgo, puede contener errores. Antes de aplicar los ejemplos asegurarse que la información es aplicable (y se corresponde) con la placa sobre la que se va a trabajar dada la existencia de diferentes modelos en los cuales tanto los pines de conexión como su funcionalidad y voltaje pueden variar. Si no se tiene conocimiento de lo que se está haciendo mejor no aplicarlo. Por otro lado siempre que se trabaja con dispositivos electrónicos se deben guardar las medidas de seguridad apropiadas dado que un uso indebido de dicho hardware puede conllevar la pérdida de la garantía. Desde aquí no se dá garantía ni implícita ni explícita sobre el correcto funcionamiento de la información aquí mostrada. Antes de seguir este tutorial es recomendable tener conocimientos de electrónica (también para conocer los riesgos de manejar tensiones e intensidades), aunque los componentes empleados en los ejemplos son simples.
2	2
3	3		![Lazarus on Raspbian Wheezy](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png) (Raspberry Pi only)
4	4
5	5		Raspberry Pi es un ordenador con una placa del tamaño de una tarjeta de crédito (ver fotos más abajo). Ha sido diseñada en Reino Unido (UK) por la Fundación Raspberry Pi con la intención de fomentar el aprendizaje básico de la computación en escuelas. Las Raspberry Pi se utilizan también para propósitos tan diversos como pueden ser servidores de medios, robótica e ingeniería de control.
6	6
7	7		La Fundación Raspberry Pi recomienda [[Raspbian]] Wheezy como la distribución estandar a utilizar con su hardware. También se utilizan sistemas alternativos tales como RISC y distribuciones Linux variadas y [[Android]].
8	8
9	9		Lazarus corre en modo nativo bajo la distro Raspbian con sistema operativo Linux.
10	10
11	11		## Installando y compilando Lazarus
12	12
13	13		### Instalación simple bajo Raspbian
14	14
15	15		#### Raspberry Pi 1
16	16
17	17		En la distro de Linux Raspbian es fácil instalar Lazarus y FreePascal. Para lograrlo simplemente abre una ventana de terminal y teclea lo siguiente:
18	18
19	19		``` bash
20	20		sudo apt-get update
21	21		sudo apt-get upgrade
22	22		sudo apt-get install fpc
23	23		sudo apt-get install lazarus
24	24		```
25	25
26	26		Esto instala una versión precompilada estable de FreePascal y Lazarus en la distro Raspbian que corre en el hardware Raspberry Pi. Por supuesto se necesita una conexión de red. La instalación puede llevar unos 30 minutos, pero la mayor parte de este proceso tiene lugar automáticamente. Después de la instalación ya se puede arrancar Lazarus desde la sección "Programming" en el menú de comienzo de LXDE.
27	27
28		-	Install Lazarus Rasbian Part1 en.png\\|Paso instalación 1 Install Lazarus Rasbian Part2 en.png\\|Paso instalación 2 Install Lazarus Rasbian Part3 en.png\\|Paso instalación 3 Install Lazarus Rasbian Part4 en.png\\|Paso instalación 4
	28	+	![](/wiki-images/0/02/Install_Lazarus_Rasbian_Part1_en.png)
29	29
	30	+	Paso instalación 1
	31	+
	32	+	![](/wiki-images/4/4a/Install_Lazarus_Rasbian_Part2_en.png)
	33	+
	34	+	Paso instalación 2
	35	+
	36	+	![](/wiki-images/5/53/Install_Lazarus_Rasbian_Part3_en.png)
	37	+
	38	+	Paso instalación 3
	39	+
	40	+	![](/wiki-images/2/24/Install_Lazarus_Rasbian_Part4_en.png)
	41	+
	42	+	Paso instalación 4
	43	+
30	44		Si necesitas una versión más nueva, o si Lazarus/FreePascal muestran errores durante la instalación puedes consultar más información [aquí](http://www.raspberrypi.org/forums/viewtopic.php?f=34&t=88145).
31	45
32	46		#### Raspberry Pi 2
33	47
34	48		Desde junio de 2015 el método de instalación regular "out of the box (listo para usar)" también funciona para Raspberry Pi 2 Modelo B. La versión que lleva instalada es, por tanto, demasiado antigua. Para aquellos que busquen construir los últimos IDE de FreePascal y Lazarus mejor ver [este artículo](http://www.tweaking4all.com/hardware/raspberry-pi/install-lazarus-pascal-on-raspberry-pi-2/).
35	49
36		-	~~<File:Lazarus> 0 9 30 4 on RPi 2.png\\|Lazarus "out of the box" en Raspberry Pi 2~~
	50	+	![](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)
37	51
	52	+	Lazarus "out of the box" en Raspberry Pi 2
	53	+
38	54		160
39	55
40	56		#### Raspberry Pi 3
41	57
42	58		Ver Raspberry Pi 2.
43	59
44	60		![](/wiki-images/5/50/RaspBerryPi3B%2B.png)
45	61
46		-	~~<File:RaspBerryPi3B+_img1.png>~~
	62	+	![](/wiki-images/1/12/RaspBerryPi3B%2B_img1.png)
47	63
48		-	~~<File:RaspBerryPi3B+_img2.png>~~
	64	+	![](/wiki-images/5/56/RaspBerryPi3B%2B_img2.png)
49	65
50	66		Como se puede observar tiene más pines de los cuales se debe consultar la funcionalidad de cada uno antes de conectar algo.
51	67
52	68		![](/wiki-images/f/f3/RaspBerryPi3B%2B_img3.png)
53	69
54	70		### Compilación cruzada (cross compiling) para Raspberry Pi desde Windows
55	71
56	72		1\. Utilizando fpcup
57	73
58	74		Un camino es utilizar fpcup para configurar un compilador cruzado; seguir estas instrucciones:
59	75
60	76		[[fpcup\|fpcup#Linux_ARM_cross_compiler]]
61	77
62	78		2\. Utilizando scripts
63	79
64	80		Alternativamente, para una aproximación más manual, y utilizando ficheros de proceso por lotes, puedes seguir los siguientes pasos.
65	81
66	82		2.1 Prerequisitos
67	83
68	84		`FPC 2.7.1 or higher installed with sourcecode`\
69	85		`Install the Windows version from the Linaro binutils for linux gnueabihf into %FPCPATH%/bin/win32-armhf-linux `[`1`](https://launchpad.net/linaro-toolchain-binaries/trunk/2013.10/+download/gcc-linaro-arm-linux-gnueabihf-4.8-2013.10_win32.zip)
70	86
71	87		2.2 Script ejemplo para construir (adaptar los trayectos a como se necesiten)
72	88
73	89		``` bat
74	90		set PATH=C:\pp\bin\i386-win32;%PATH%;
75	91		set FPCMAKEPATH=C:/pp
76	92		set FPCPATH=C:/pp
77	93		set OUTPATH=C:/pp271
78	94		%FPCMAKEPATH%/bin/i386-win32/make distclean OS_TARGET=linux CPU_TARGET=arm CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" FPC=%FPCPATH%/bin/i386-win32/ppc386.exe
79	95
80	96		%FPCMAKEPATH%/bin/i386-win32/make all OS_TARGET=linux CPU_TARGET=arm CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" FPC=%FPCPATH%/bin/i386-win32/ppc386.exe
81	97		if errorlevel 1 goto quit
82	98		%FPCMAKEPATH%/bin/i386-win32/make crossinstall CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" OS_TARGET=linux CPU_TARGET=arm FPC=%FPCPATH%/bin/i386-win32/ppc386.exe INSTALL_BASEDIR=%OUTPATH%
83	99
84	100		:quit
85	101		pause
86	102		```
87	103
88	104		Con el resultado de ppcrossarm.exe y ARM RTL deberias ser capaz de construir una versión de Lazarus para plataforma cruzada como habitualmente y compilar proyectos FPC para Raspberry Pi y otros dispositivos armhf. Recuerda que no todas las librerias, - especialmente en Windows - se encuentran disponibles para Linux arm.
89	105
90	106		### Compilando desde el código fuente
91	107
92	108		Puede que necesites compilar Lazarus a partir de sus fuentes subverion. Ver \[<http://www.michellcomputing.co.uk/blog/?p=72>: Michell Computing: Lazarus en la Raspberry Pi\] para más detalles..
93	109
94		-	~~<File:Start> Menu with Lazarus en.png\\|Como arrancar Lazarus en Raspbian Wheezy <File:Lazarus> on Raspberry Pi.jpg\\|Lazarus bajo Raspberry Pi <File:rpi> gpio pins.png\\|Numeración de los pines GPIO~~
	110	+	![](/wiki-images/8/8d/Start_Menu_with_Lazarus_en.png)
	111	+
	112	+	Como arrancar Lazarus en Raspbian Wheezy
	113	+
	114	+	![](/wiki-images/8/87/Lazarus_on_Raspberry_Pi.jpg)
	115	+
	116	+	Lazarus bajo Raspberry Pi
	117	+
	118	+	![](/wiki-images/c/c7/Rpi_gpio_pins.png)
	119	+
	120	+	Numeración de los pines GPIO
95	121
96	122		Compilando desde las fuentes en Raspberry con Gentoo (y otra distro)
97	123
98	124		------------------------------------------------------------------------
99	125
100	126		Si necesitas instalar la última release estable de fpc y, adicional y aisladamente, el compilador fpc del trunk entonces puedes leer la siguiente guía.
101	127
102	128		Esto se escribió utilizando Gentoo, pero esta guía debería ser de utilidad para cualquier otra distro: [[Install fpc on Raspberry with Gentoo]]
103	129
104	130		## Accediendo a hardware externo
105	131
106	132		![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
107	133
108	134		Una de las finalidades en el desarrollo de Raspberry Pi fue la de facilitar el acceso sin esfuerzo a dispositivos externos tales como sensores y actuadores. A nivel de sofware desde FreePascal y Lazarus además presenta varias modalidades de acceso de E/S (Entrada/Salida) / (I/O (Input/Output):
109	135
110	136		1. [[Lazarus on Raspberry Pi\|Direct access]] Utilizando la unidad [[BaseUnix]].
111	137		2. Acceso a través de [[Lazarus on Raspberry Pi\|encapsulated shell calls]]
112	138		3. Acceso a través de [[Lazarus on Raspberry Pi\|wiringPi library]].
113	139		4. Acceso a través de la unidad [[Lazarus on Raspberry Pi\|rpi_hal]].
114	140		5. Acceso a través de la unidad [[Lazarus on Raspberry Pi\|PiGpio]].
115	141		6. Acceso a través de la librería [PascalIO](https://github.com/SAmeis/pascalio).
116	142		7. Acceso a través de la librería [PXL](http://asphyre.net/products/pxl).
117	143
118	144		### Acceso nativo al hardware
119	145
120	146		![ Programa simple de testeo que permite el acceso al puerto GPIO en Raspberry Pi\\|thumb\\|300px\\|right](/wiki-images/d/d2/Testprogram_for_GPIO_on_RPI_annotated.png) ![Circuito de test para acceso GPIO con el programa asociado\\|thumb\\|300px\\|right](/wiki-images/7/7c/Rpi_testcircuit_1d.png) ![Demo simple con la implementación del circuito propuesto en una placa de prototipos\\|thumb\\|300px\\|right](/wiki-images/7/7e/Rpi_testcircuit_1p_annotaded.png) Este método provee acceso a hardware externo que no requiere librerías adicionales. El único requerimiento es la librería BaseUnix que es parte de la RTL de FreePascal.
121	147
122	148		#### Conmutando un dispositivo a través de un puerto GPIO
123	149
124	150		El siguiente ejemplo lista un programa simple que controla el pin 17 GPIO establecido como salida para conmutar el estado de un LED, transistor o relé. Este programa contiene un [[doc:lcl/stdctrls/ttogglebox.html\|ToggleBox]] with name GPIO17ToggleBox y para logging retorna códigos a un [[doc:lcl/stdctrls/tmemo.html\|TMemo]] llamado LogMemo.
125	151
126	152		Para el ejemplo, el ánodo del LED se ha conectado al Pin 11 del conector Pi (que a su vez su correspondencia es con el pin 17 del chip BCM2835 SOC) y por otro lado el cátodo del LED se ha conectado al pin 6 del conector (que corresponde a masa (GND: Ground) pero poniendo una resistencia entre medias de 68 Ohm (R1 en el esquema) tal como se describió previamente por Upton and Halfacree (esto nos permite limitar convenientemente la intensidad que circula por el LED). Subsecuentemente el LED puede ser conmutado entre dos estados ON / OFF mediante el toggle box de la aplicación.
127	153
128	154		El código puede requerir en un principio que se ejecute como root, i.e. adicionalmente con una cuenta tipo root (no recomendado) o a través del mandato su antepuesto al nombre del programa lo que nos promocionará el acceso como super usuario (su: super user). Una mejor opción es añadir el usuario con el que trabajemos a los grupos gpio, i2c y spi tal como se indica a continuación:
129	155
130	156		``` bash
131	157		sudo adduser pi gpio
132	158		sudo adduser pi i2c
133	159		sudo adduser pi spi
134	160		```
135	161
136	162		Unidad de control:
137	163
138	164		``` pascal
139	165		unit Unit1;
140	166
141	167		{Demo application for GPIO on Raspberry Pi}
142	168		{Inspired by the Python input/output demo application by Gareth Halfacree}
143	169		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
144	170
145	171		{$mode objfpc}{$H+}
146	172
147	173		interface
148	174
149	175		uses
150	176		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
151	177		Unix, BaseUnix;
152	178
153	179		type
154	180
155	181		{ TForm1 }
156	182
157	183		TForm1 = class(TForm)
158	184		LogMemo: TMemo;
159	185		GPIO17ToggleBox: TToggleBox;
160	186		procedure FormActivate(Sender: TObject);
161	187		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
162	188		procedure GPIO17ToggleBoxChange(Sender: TObject);
163	189		private
164	190		{ private declarations }
165	191		public
166	192		{ public declarations }
167	193		end;
168	194
169	195		const
170	196		PIN_17: PChar = '17';
171	197		PIN_ON: PChar = '1';
172	198		PIN_OFF: PChar = '0';
173	199		OUT_DIRECTION: PChar = 'out';
174	200
175	201		var
176	202		Form1: TForm1;
177	203		gReturnCode: longint; {stores the result of the IO operation}
178	204
179	205		implementation
180	206
181	207		{$R *.lfm}
182	208
183	209		{ TForm1 }
184	210
185	211		procedure TForm1.FormActivate(Sender: TObject);
186	212		var
187	213		fileDesc: integer;
188	214		begin
189	215		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
190	216		try
191	217		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
192	218		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
193	219		LogMemo.Lines.Add(IntToStr(gReturnCode));
194	220		finally
195	221		gReturnCode := fpclose(fileDesc);
196	222		LogMemo.Lines.Add(IntToStr(gReturnCode));
197	223		end;
198	224		{ Set SoC pin 17 as output: }
199	225		try
200	226		fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
201	227		gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
202	228		LogMemo.Lines.Add(IntToStr(gReturnCode));
203	229		finally
204	230		gReturnCode := fpclose(fileDesc);
205	231		LogMemo.Lines.Add(IntToStr(gReturnCode));
206	232		end;
207	233		end;
208	234
209	235		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
210	236		var
211	237		fileDesc: integer;
212	238		begin
213	239		{ Free SoC pin 17: }
214	240		try
215	241		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
216	242		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
217	243		LogMemo.Lines.Add(IntToStr(gReturnCode));
218	244		finally
219	245		gReturnCode := fpclose(fileDesc);
220	246		LogMemo.Lines.Add(IntToStr(gReturnCode));
221	247		end;
222	248		end;
223	249
224	250		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
225	251		var
226	252		fileDesc: integer;
227	253		begin
228	254		if GPIO17ToggleBox.Checked then
229	255		begin
230	256		{ Swith SoC pin 17 on: }
231	257		try
232	258		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
233	259		gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
234	260		LogMemo.Lines.Add(IntToStr(gReturnCode));
235	261		finally
236	262		gReturnCode := fpclose(fileDesc);
237	263		LogMemo.Lines.Add(IntToStr(gReturnCode));
238	264		end;
239	265		end
240	266		else
241	267		begin
242	268		{ Switch SoC pin 17 off: }
243	269		try
244	270		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
245	271		gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
246	272		LogMemo.Lines.Add(IntToStr(gReturnCode));
247	273		finally
248	274		gReturnCode := fpclose(fileDesc);
249	275		LogMemo.Lines.Add(IntToStr(gReturnCode));
250	276		end;
251	277		end;
252	278		end;
253	279
254	280		end.
255	281		```
256	282
257	283		Programa principal:
258	284
259	285		``` pascal
260	286		program io_test;
261	287
262	288		{$mode objfpc}{$H+}
263	289
264	290		uses
265	291		{$IFDEF UNIX}{$IFDEF UseCThreads}
266	292		cthreads,
267	293		{$ENDIF}{$ENDIF}
268	294		Interfaces, // this includes the LCL widgetset
269	295		Forms, Unit1
270	296		{ puedes añadir unidades después de esto };
271	297
272	298		{$R *.res}
273	299
274	300		begin
275	301		Application.Initialize;
276	302		Application.CreateForm(TForm1, Form1);
277	303		Application.Run;
278	304		end.
279	305		```
280	306
281	307		#### Leyendo el estado de un pin
282	308
283	309		![Programa de desmostración para la lectura del estado de un pin GPIO\\|thumb\\|300px\\|right](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png) ![Circuito de chequeo para acceso GPIO mediante el programa mostrado\\|thumb\\|300px\\|right](/wiki-images/f/f4/Rpi_testcircuit_2d.png) ![Posible implementación de este circuito de chequeo mediante el uso de placa de prototipos\\|thumb\\|300px\\|right](/wiki-images/2/2f/Rpi_testcircuit_2p_annotaded.png)
284	310
285	311		Por supuesto también es posible leer el estado de un pulsador conectado a un puerto GPIO (General Porpouse Inpunt Output).
286	312
287	313		El siguiente ejemplo es muy similar al anterior. Controla el pin GPIO 18 como entrada para un dispositivo binario tal como un pulsador, un transistor o un relé. Este programa contiene un [[doc:lcl/stdctrls/tcheckbox.html\|CheckBox]] con el nombre GPIO18CheckBox y un [[doc:lcl/stdctrls/tmemo.html\|TMemo]] llamado LogMemo para los códigos retornados de logging.
288	314
289	315		Para el ejemplo se ha conectado un pulsador al Pin 12 del conector de la Pi (correspondiente al pin GPIO 18 del SOC BCM2835) a través de una resistencia de 10 KOhm conectada al pin 1 (+3.3V, ver diagrama de cableado). El otro polo se ha cableado al pin 6 del conector (corresponde a la masa o GND). El programa detecta el estado del pulsador y commuta correlativamente a On u Off según el estado del mismo.
290	316
291	317		Ten en cuenta que el potencial del pin 18 es "alto" (gracias a la conexión al pin 1 mediate la resistencia) si el pulsador está sin pulsar y "bajo" si se encuentra pulsado (porque en esta situación el pin 18 se encuentra conectado a masa (GND) a través del pulsador). Por tanto, el pin GPIO marca 0 si el botón está presionado y 1 si está sin pulsar.
292	318
293	319		Este programa tiene que ser ejecutado también como usuario root.
294	320
295	321		Unidad de control:
296	322
297	323		``` pascal
298	324		unit Unit1;
299	325
300	326		{Demo application for GPIO on Raspberry Pi}
301	327		{Inspired by the Python input/output demo application by Gareth Halfacree}
302	328		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
303	329
304	330		{This application reads the status of a push-button}
305	331
306	332		{$mode objfpc}{$H+}
307	333
308	334		interface
309	335
310	336		uses
311	337		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
312	338		ButtonPanel, Unix, BaseUnix;
313	339
314	340		type
315	341
316	342		{ TForm1 }
317	343
318	344		TForm1 = class(TForm)
319	345		ApplicationProperties1: TApplicationProperties;
320	346		GPIO18CheckBox: TCheckBox;
321	347		LogMemo: TMemo;
322	348		procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
323	349		procedure FormActivate(Sender: TObject);
324	350		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
325	351		private
326	352		{ private declarations }
327	353		public
328	354		{ public declarations }
329	355		end;
330	356
331	357		const
332	358		PIN_18: PChar = '18';
333	359		IN_DIRECTION: PChar = 'in';
334	360
335	361		var
336	362		Form1: TForm1;
337	363		gReturnCode: longint; {stores the result of the IO operation}
338	364
339	365		implementation
340	366
341	367		{$R *.lfm}
342	368
343	369		{ TForm1 }
344	370
345	371		procedure TForm1.FormActivate(Sender: TObject);
346	372		var
347	373		fileDesc: integer;
348	374		begin
349	375		{ Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
350	376		try
351	377		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
352	378		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
353	379		LogMemo.Lines.Add(IntToStr(gReturnCode));
354	380		finally
355	381		gReturnCode := fpclose(fileDesc);
356	382		LogMemo.Lines.Add(IntToStr(gReturnCode));
357	383		end;
358	384		{ Set SoC pin 18 as input: }
359	385		try
360	386		fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
361	387		gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
362	388		LogMemo.Lines.Add(IntToStr(gReturnCode));
363	389		finally
364	390		gReturnCode := fpclose(fileDesc);
365	391		LogMemo.Lines.Add(IntToStr(gReturnCode));
366	392		end;
367	393		end;
368	394
369	395		procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
370	396		var
371	397		fileDesc: integer;
372	398		buttonStatus: string[1] = '1';
373	399		begin
374	400		try
375	401		{ Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
376	402		fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
377	403		if fileDesc > 0 then
378	404		begin
379	405		{ Read status of this pin (0: button pressed, 1: button released): }
380	406		gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
381	407		LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
382	408		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
383	409		if buttonStatus = '0' then
384	410		GPIO18CheckBox.Checked := true
385	411		else
386	412		GPIO18CheckBox.Checked := false;
387	413		end;
388	414		finally
389	415		{ Close SoC pin 18 (pin 12 on GPIO port) }
390	416		gReturnCode := fpclose(fileDesc);
391	417		LogMemo.Lines.Add(IntToStr(gReturnCode));
392	418		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
393	419		end;
394	420		end;
395	421
396	422		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
397	423		var
398	424		fileDesc: integer;
399	425		begin
400	426		{ Free SoC pin 18: }
401	427		try
402	428		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
403	429		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
404	430		LogMemo.Lines.Add(IntToStr(gReturnCode));
405	431		finally
406	432		gReturnCode := fpclose(fileDesc);
407	433		LogMemo.Lines.Add(IntToStr(gReturnCode));
408	434		end;
409	435		end;
410	436
411	437		end.
412	438		```
413	439
414	440		El programa main es idéntico al del ejemplo de arriba.
415	441
416	442		### Acceso hardware mediante llamadas encapsuladas del shell
417	443
418	444		Otro modo de acceder al hardware es mediante el encapsulamiento de mandatos a través del shell. Esto se consigue mediante el uso de la función [[Executing External Programs\|fpsystem]]. Este método permite el acceso a funciones que no están soportadas por la unidad BaseUnix. El siguiente código implementa un programa que tiene la misma funcionalidad que as the program resulting from the first listing above.
419	445
420	446		Controlling unit:
421	447
422	448		``` pascal
423	449		unit Unit1;
424	450
425	451		{Demo application for GPIO on Raspberry Pi}
426	452		{Inspired by the Python input/output demo application by Gareth Halfacree}
427	453		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
428	454
429	455		{$mode objfpc}{$H+}
430	456
431	457		interface
432	458
433	459		uses
434	460		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
435	461
436	462		type
437	463
438	464		{ TForm1 }
439	465
440	466		TForm1 = class(TForm)
441	467		LogMemo: TMemo;
442	468		GPIO17ToggleBox: TToggleBox;
443	469		procedure FormActivate(Sender: TObject);
444	470		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
445	471		procedure GPIO17ToggleBoxChange(Sender: TObject);
446	472		private
447	473		{ private declarations }
448	474		public
449	475		{ public declarations }
450	476		end;
451	477
452	478		var
453	479		Form1: TForm1;
454	480		gReturnCode: longint; {stores the result of the IO operation}
455	481
456	482		implementation
457	483
458	484		{$R *.lfm}
459	485
460	486		{ TForm1 }
461	487
462	488		procedure TForm1.FormActivate(Sender: TObject);
463	489		begin
464	490		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
465	491		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
466	492		LogMemo.Lines.Add(IntToStr(gReturnCode));
467	493		{ Set SoC pin 17 as output: }
468	494		gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
469	495		LogMemo.Lines.Add(IntToStr(gReturnCode));
470	496		end;
471	497
472	498		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
473	499		begin
474	500		{ Free SoC pin 17: }
475	501		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
476	502		LogMemo.Lines.Add(IntToStr(gReturnCode));
477	503		end;
478	504
479	505		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
480	506		begin
481	507		if GPIO17ToggleBox.Checked then
482	508		begin
483	509		{ Swith SoC pin 17 on: }
484	510		gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
485	511		LogMemo.Lines.Add(IntToStr(gReturnCode));
486	512		end
487	513		else
488	514		begin
489	515		{ Switch SoC pin 17 off: }
490	516		gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
491	517		LogMemo.Lines.Add(IntToStr(gReturnCode));
492	518		end;
493	519		end;
494	520
495	521		end.
496	522		```
497	523
498	524		El programa main es idéntico al del ejemplo de arriba. Este programa necesita ejecutarse con privilegios de root también.
499	525
500	526		### Procedimientos y funciones de wiringPi
501	527
502	528		Alex Schaller's wrapper unit for Gordon Henderson's Arduino compatible wiringPi library provides a numbering scheme that resembles that of Arduino boards.
503	529
504	530		Function wiringPiSetup:longint: Initializes wiringPi system using the wiringPi pin numbering scheme.
505	531
506	532		Procedure wiringPiGpioMode(mode:longint): Initializes wiringPi system with the Broadcom GPIO pin numbering scheme.
507	533
508	534		Procedure pullUpDnControl(pin:longint; pud:longint): controls the internal pull-up/down resistors on a GPIO pin.
509	535
510	536		Procedure pinMode(pin:longint; mode:longint): sets the mode of a pin to either INPUT, OUTPUT, or PWM_OUTPUT.
511	537
512	538		Procedure digitalWrite(pin:longint; value:longint): sets an output bit.
513	539
514	540		Procedure pwmWrite(pin:longint; value:longint): sets an output PWM value between 0 and 1024.
515	541
516	542		Function digitalRead(pin:longint):longint: reads the value of a given Pin, returning 1 or 0.
517	543
518	544		Procedure delay(howLong:dword): waits for at least howLong milliseconds.
519	545
520	546		Procedure delayMicroseconds(howLong:dword): waits for at least howLong microseconds.
521	547
522	548		Function millis:dword: returns the number of milliseconds since the program called one of the wiringPiSetup functions.
523	549
524	550		### rpi_hal-Hardware Abstraction Library (funciones y procedimientos GPIO, I2C y SPI de la librería de abstracción hardware de la RaspBerry Pi)
525	551
526	552		Esta unidad con cerca de 1700 líneas de código aportada por Stefan Fischer, aporta procedimientos y funciones para acceso HW I2C, SPI y GPIO en la RaspBerry Pi:
527	553
528	554		Justamente un extracto de los procedimientos y funciones disponibles:
529	555
530	556		procedure gpio_set_pin (pin:longword;highlevel:boolean); { Establece RPi GPIO pin a nivel alto o bajo; Velocidad @ 700MHz -\> 0.65MHz }
531	557
532	558		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 }
533	559
534	560		procedure gpio_set_input (pin:longword); { Establece RPi GPIO pin en modo entrada }
535	561
536	562		procedure gpio_set_output(pin:longword); { Establece RPi GPIO pin en modo salida}
537	563
538	564		procedure gpio_set_alt (pin,altfunc:longword); { Establece RPi GPIO pin to alternate function nr. 0..5 }
539	565
540	566		procedure gpio_set_gppud (mask:longword); { Establece RPi GPIO Pull-up/down Register (GPPUD) with mask }
541	567
542	568		...
543	569
544	570		function rpi_snr :string; { Emtrega el SNR: 0000000012345678 }
545	571
546	572		function rpi_hw :string; { Entrega el tipo de procesador: BCM2708 }
547	573
548	574		function rpi_proc:string; { ARMv6-compatible processor rev 7 (v6l) }
549	575
550	576		...
551	577
552	578		function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
553	579
554	580		function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
555	581
556	582		function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;
557	583
558	584		function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;
559	585
560	586		...
561	587
562	588		procedure SPI_Write(devnum:byte; reg,data:word);
563	589
564	590		function SPI_Read(devnum:byte; reg:word) : byte;
565	591
566	592		procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);
567	593
568	594		procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword); { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
569	595
570	596		...
571	597
572	598		Test Program (testrpi.pas):
573	599
574	600		``` pascal
575	601		//Progama simple de chequeo, el cual utiliza rpi_hal;
576	602
577	603		program testrpi;
578	604		uses rpi_hal;
579	605		begin
580	606		writeln('Show CPU-Info, RPI-HW-Info and Registers:');
581	607		rpi_show_all_info;
582	608		writeln('Let Status LED Blink. Using GPIO functions:');
583	609		GPIO_PIN_TOGGLE_TEST;
584	610		writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
585	611		Test_SPI;
586	612		end.
587	613		```
588	614
589	615		### Unidad nativa PiGpio de bajo nivel escrita en pascal (control GPIO en lugar de la librería c de wiringPi)
590	616
591	617		Esta unit (pigpio.pas[2](https://docs.google.com/file/d/0B-b-5ooIWPvGN1BIcEJzRDgyeUE/edit?usp=sharing)) de 270 líneas de código aportada por Gabor Szollosi, funciona muy rápido (para ex. GPIO pin output conmutando a una frecuencia de 8 MHz) :
592	618
593	619		``` pascal
594	620
595	621		unit PiGpio;
596	622		{
597	623		BCM2835 GPIO Registry Driver, also can use to manipulate cpu other registry areas
598	624
599	625		This code is tested only Broadcom bcm2835 cpu, different arm cpus may need different
600	626		gpio driver implementation
601	627
602	628		2013 Gabor Szollosi
603	629		}
604	630		{$mode objfpc}{$H+}
605	631
606	632		interface
607	633
608	634		uses
609	635		Classes, SysUtils;
610	636
611	637		const
612	638		REG_GPIO = $3F000;// bcm2835 gpio register 0x2000 0000 (RPi1), 0x3F00 0000 (RPi2)
613	639		// new fpMap uses page offset, one page is 4096 bytes = 0x1000 so simply calculate 0x2000 0000 / 0x1000 = 0x2000 0
614	640		PAGE_SIZE = 4096;
615	641		BLOCK_SIZE = 4096;
616	642		// The BCM2835 has 54 GPIO pins.
617	643		// BCM2835 data sheet, Page 90 onwards.
618	644		// There are 6 control registers, each control the functions of a block
619	645		// of 10 pins.
620	646
621	647		CLOCK_BASE = (REG_GPIO + $101);
622	648		GPIO_BASE = (REG_GPIO + $200);
623	649		GPIO_PWM = (REG_GPIO + $20C);
624	650
625	651		INPUT = 0;
626	652		OUTPUT = 1;
627	653		PWM_OUTPUT = 2;
628	654		LOW = False;
629	655		HIGH = True;
630	656		PUD_OFF = 0;
631	657		PUD_DOWN = 1;
632	658		PUD_UP = 2;
633	659
634	660		// PWM
635	661
636	662		PWM_CONTROL = 0;
637	663		PWM_STATUS = 4;
638	664		PWM0_RANGE = 16;
639	665		PWM0_DATA = 20;
640	666		PWM1_RANGE = 32;
641	667		PWM1_DATA = 36;
642	668
643	669		PWMCLK_CNTL = 160;
644	670		PWMCLK_DIV = 164;
645	671
646	672		PWM1_MS_MODE = $8000; // Run in MS mode
647	673		PWM1_USEFIFO = $2000; // Data from FIFO
648	674		PWM1_REVPOLAR = $1000; // Reverse polarity
649	675		PWM1_OFFSTATE = $0800; // Ouput Off state
650	676		PWM1_REPEATFF = $0400; // Repeat last value if FIFO empty
651	677		PWM1_SERIAL = $0200; // Run in serial mode
652	678		PWM1_ENABLE = $0100; // Channel Enable
653	679
654	680		PWM0_MS_MODE = $0080; // Run in MS mode
655	681		PWM0_USEFIFO = $0020; // Data from FIFO
656	682		PWM0_REVPOLAR = $0010; // Reverse polarity
657	683		PWM0_OFFSTATE = $0008; // Ouput Off state
658	684		PWM0_REPEATFF = $0004; // Repeat last value if FIFO empty
659	685		PWM0_SERIAL = $0002; // Run in serial mode
660	686		PWM0_ENABLE = $0001; // Channel Enable
661	687
662	688		type
663	689
664	690		{ TIoPort }
665	691
666	692		TIoPort = class // IO bank object
667	693		private //
668	694
669	695		//function get_pinDirection(aPin: TGpIoPin): TGpioPinConf;
670	696
671	697		public
672	698		FGpio: ^LongWord;
673	699		FClk: ^LongWord;
674	700		FPwm: ^LongWord;
675	701		procedure SetPinMode(gpin, mode: byte);
676	702		function GetBit(gpin : byte):boolean;inline; // gets pin bit}
677	703		procedure ClearBit(gpin : byte);inline;// write pin to 0
678	704		procedure SetBit(gpin : byte);inline;// write pin to 1
679	705		procedure SetPullMode(gpin, mode: byte);
680	706		procedure PwmWrite(gpin : byte; value : LongWord);inline;// write pin to pwm value
681	707		end;
682	708
683	709		{ TIoDriver }
684	710
685	711		TIoDriver = class
686	712		private
687	713
688	714		public
689	715		destructor Destroy;override;
690	716		function MapIo:boolean;// creates io memory mapping
691	717		procedure UnmapIoRegisrty(FMap: TIoPort);// close io memory mapping
692	718		function CreatePort(PortGpio, PortClk, PortPwm: LongWord):TIoPort; // create new IO port
693	719		end;
694	720
695	721		var
696	722
697	723		fd: integer;// /dev/mem file handle
698	724		procedure delayNanoseconds (howLong : LongWord);
699	725
700	726		implementation
701	727
702	728		uses
703	729		baseUnix, Unix;
704	730
705	731		procedure delayNanoseconds (howLong : LongWord);
706	732		var
707	733		sleeper, dummy : timespec;
708	734		begin
709	735		sleeper.tv_sec := 0 ;
710	736		sleeper.tv_nsec := howLong ;
711	737		fpnanosleep (@sleeper,@dummy) ;
712	738		end;
713	739		{ TIoDriver }
714	740		//*******************************************************************************
715	741		destructor TIoDriver.Destroy;
716	742		begin
717	743		inherited Destroy;
718	744		end;
719	745		//*******************************************************************************
720	746		function TIoDriver.MapIo: boolean;
721	747		begin
722	748		Result := True;
723	749		fd := fpopen('/dev/mem', O_RdWr or O_Sync); // Open the master /dev/memory device
724	750		if fd < 0 then
725	751		begin
726	752		Result := False; // unsuccessful memory mapping
727	753		end;
728	754		//
729	755		end;
730	756		//*******************************************************************************
731	757		procedure TIoDriver.UnmapIoRegisrty(FMap:TIoPort);
732	758		begin
733	759		if FMap.FGpio <> nil then
734	760		begin
735	761		fpMUnmap(FMap.FGpio,PAGE_SIZE);
736	762		FMap.FGpio := Nil;
737	763		end;
738	764		if FMap.FClk <> nil then
739	765		begin
740	766		fpMUnmap(FMap.FClk,PAGE_SIZE);
741	767		FMap.FClk := Nil;
742	768		end;
743	769		if FMap.FPwm <> nil then
744	770		begin
745	771		fpMUnmap(FMap.FPwm ,PAGE_SIZE);
746	772		FMap.FPwm := Nil;
747	773		end;
748	774		end;
749	775		//*******************************************************************************
750	776		function TIoDriver.CreatePort(PortGpio, PortClk, PortPwm: LongWord): TIoPort;
751	777		begin
752	778		Result := TIoPort.Create;// new io port, pascal calls new fpMap, where offst is page sized 4096 bytes!!!
753	779		Result.FGpio := FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortGpio); // port config gpio memory
754	780		Result.FClk:= FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortClk);; // port clk
755	781		Result.FPwm:= FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortPwm);; // port pwm
756	782		end;
757	783		//*******************************************************************************
758	784		procedure TIoPort.SetPinMode(gpin, mode: byte);
759	785		var
760	786		fSel, shift, alt : byte;
761	787		gpiof, clkf, pwmf : ^LongWord;
762	788		begin
763	789		fSel := (gpin div 10)*4 ; //Select Gpfsel 0 to 5 register
764	790		shift := (gpin mod 10)*3 ; //0-9 pin shift
765	791		gpiof := Pointer(LongWord(Self.FGpio)+fSel);
766	792		if (mode = INPUT) then
767	793		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) //7 shl shift komplemens - Sets bits to zero = input
768	794		else if (mode = OUTPUT) then
769	795		begin
770	796		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) or (1 shl shift);
771	797		end
772	798		else if (mode = PWM_OUTPUT) then
773	799		begin
774	800		Case gpin of
775	801		12,13,40,41,45 : alt:= 4 ;
776	802		18,19 : alt:= 2 ;
777	803		else alt:= 0 ;
778	804		end;
779	805		If alt > 0 then
780	806		begin
781	807		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) or (alt shl shift);
782	808		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_CNTL);
783	809		clkf^ := $5A000011 or (1 shl 5) ; //stop clock
784	810		delayNanoseconds(200);
785	811		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_DIV);
786	812		clkf^ := $5A000000 or (32 shl 12) ; // set pwm clock div to 32 (19.2/3 = 600KHz)
787	813		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_CNTL);
788	814		clkf^ := $5A000011 ; //start clock
789	815		Self.ClearBit(gpin);
790	816		pwmf := Pointer(LongWord(Self.FPwm)+PWM_CONTROL);
791	817		pwmf^ := 0 ; // Disable PWM
792	818		delayNanoseconds(200);
793	819		pwmf := Pointer(LongWord(Self.FPwm)+PWM0_RANGE);
794	820		pwmf^ := $400 ; //max: 1023
795	821		delayNanoseconds(200);
796	822		pwmf := Pointer(LongWord(Self.FPwm)+PWM1_RANGE);
797	823		pwmf^ := $400 ; //max: 1023
798	824		delayNanoseconds(200);
799	825		// Enable PWMs
800	826		pwmf := Pointer(LongWord(Self.FPwm)+PWM0_DATA);
801	827		pwmf^ := 0 ; //start value
802	828		pwmf := Pointer(LongWord(Self.FPwm)+PWM1_DATA);
803	829		pwmf^ := 0 ; //start value
804	830		pwmf := Pointer(LongWord(Self.FPwm)+PWM_CONTROL);
805	831		pwmf^ := PWM0_ENABLE or PWM1_ENABLE ;
806	832		end;
807	833		end;
808	834		end;
809	835		//*******************************************************************************
810	836		procedure TIoPort.SetBit(gpin : byte);
811	837		var
812	838		gpiof : ^LongWord;
813	839		begin
814	840		gpiof := Pointer(LongWord(Self.FGpio) + 28 + (gpin shr 5) shl 2);
815	841		gpiof^ := 1 shl gpin;
816	842		end;
817	843		//*******************************************************************************
818	844		procedure TIoPort.ClearBit(gpin : byte);
819	845		var
820	846		gpiof : ^LongWord;
821	847		begin
822	848		gpiof := Pointer(LongWord(Self.FGpio) + 40 + (gpin shr 5) shl 2);
823	849		gpiof^ := 1 shl gpin;
824	850		end;
825	851		//*******************************************************************************
826	852		function TIoPort.GetBit(gpin : byte):boolean;
827	853		var
828	854		gpiof : ^LongWord;
829	855		begin
830	856		gpiof := Pointer(LongWord(Self.FGpio) + 52 + (gpin shr 5) shl 2);
831	857		if (gpiof^ and (1 shl gpin)) = 0 then Result := False else Result := True;
832	858		end;
833	859		//*******************************************************************************
834	860		procedure TIoPort.SetPullMode(gpin, mode: byte);
835	861		var
836	862		pudf, pudclkf : ^LongWord;
837	863		begin
838	864		pudf := Pointer(LongWord(Self.FGpio) + 148 );
839	865		pudf^ := mode; //mode = 0, 1, 2 :Off, Down, Up
840	866		delayNanoseconds(200);
841	867		pudclkf := Pointer(LongWord(Self.FGpio) + 152 + (gpin shr 5) shl 2);
842	868		pudclkf^ := 1 shl gpin ;
843	869		delayNanoseconds(200);
844	870		pudf^ := 0 ;
845	871		pudclkf^ := 0 ;
846	872		end;
847	873		//*******************************************************************************
848	874		procedure TIoPort.PwmWrite(gpin : byte; value : Longword);
849	875		var
850	876		pwmf : ^LongWord;
851	877		port : byte;
852	878		begin
853	879		Case gpin of
854	880		12,18,40 : port:= PWM0_DATA ;
855	881		13,19,41,45 : port:= PWM1_DATA ;
856	882		else exit;
857	883		end;
858	884		pwmf := Pointer(LongWord(Self.FPwm) + port);
859	885		pwmf^ := value and $FFFFFBFF; // $400 complemens
860	886		end;
861	887		//*******************************************************************************
862	888		end.
863	889		```
864	890
865	891		Controlling Lazarus unit:(Project files[3](https://drive.google.com/folderview?id=0B-b-5ooIWPvGU043ZTZ0cUc2YkE&usp=sharing))
866	892
867	893		``` pascal
868	894		unit Unit1;
869	895
870	896		{Demo application for GPIO on Raspberry Pi}
871	897		{Inspired by the Python input/output demo application by Gareth Halfacree}
872	898		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
873	899
874	900		{$mode objfpc}{$H+}
875	901
876	902		interface
877	903
878	904		uses
879	905		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
880	906		ExtCtrls, Unix, PiGpio;
881	907
882	908		type
883	909
884	910		{ TForm1 }
885	911
886	912		TForm1 = class(TForm)
887	913		GPIO25In: TButton;
888	914		SpeedButton: TButton;
889	915		LogMemo: TMemo;
890	916		GPIO23switch: TToggleBox;
891	917		Timer1: TTimer;
892	918		GPIO18Pwm: TToggleBox;
893	919		Direction: TToggleBox;
894	920		procedure DirectionChange(Sender: TObject);
895	921		procedure GPIO18PwmChange(Sender: TObject);
896	922		procedure GPIO25InClick(Sender: TObject);
897	923		procedure FormActivate(Sender: TObject);
898	924		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
899	925		procedure GPIO23switchChange(Sender: TObject);
900	926		procedure SpeedButtonClick(Sender: TObject);
901	927		procedure Timer1Timer(Sender: TObject);
902	928		private
903	929		{ private declarations }
904	930		public
905	931		{ public declarations }
906	932		end;
907	933
908	934		const
909	935		INPUT = 0;
910	936		OUTPUT = 1;
911	937		PWM_OUTPUT = 2;
912	938		LOW = False;
913	939		HIGH = True;
914	940		PUD_OFF = 0;
915	941		PUD_DOWN = 1;
916	942		PUD_UP = 2;
917	943		// Convert Raspberry Pi P1 pins (Px) to GPIO port
918	944		P3 = 0;
919	945		P5 = 1;
920	946		P7 = 4;
921	947		P8 = 14;
922	948		P10 = 15;
923	949		P11 = 17;
924	950		P12 = 18;
925	951		P13 = 21;
926	952		P15 = 22;
927	953		P16 = 23;
928	954		P18 = 24;
929	955		P19 = 10;
930	956		P21 = 9;
931	957		P22 = 25;
932	958		P23 = 11;
933	959		P24 = 8;
934	960		P26 = 7;
935	961
936	962		var
937	963		Form1: TForm1;
938	964		GPIO_Driver: TIoDriver;
939	965		GpF: TIoPort;
940	966		PWM :Boolean;
941	967		i, d : integer;
942	968		Pin,Pout,Ppwm : byte;
943	969
944	970		implementation
945	971
946	972		{$R *.lfm}
947	973
948	974		{ TForm1 }
949	975
950	976		procedure TForm1.FormActivate(Sender: TObject);
951	977		begin
952	978		if not GPIO_Driver.MapIo then
953	979		begin
954	980		LogMemo.Lines.Add('Error mapping gpio registry');
955	981		end
956	982		else
957	983		begin
958	984		GpF := GpIo_Driver.CreatePort(GPIO_BASE, CLOCK_BASE, GPIO_PWM);
959	985		end ;
960	986		Timer1.Enabled:= True;
961	987		Timer1.Interval:= 25; //25 ms controll interval
962	988		Pin := P22;
963	989		Pout := P16;
964	990		Ppwm := P12;
965	991		i:=1;
966	992		GpF.SetPinMode(Pout,OUTPUT);
967	993		GpF.SetPinMode(Pin,INPUT);
968	994		GpF.SetPullMode(Pin,PUD_Up); // Input PullUp High level
969	995		end;
970	996
971	997		procedure TForm1.GPIO25InClick(Sender: TObject);
972	998		begin
973	999		If GpF.GetBit(Pin) then LogMemo.Lines.Add('In: '+IntToStr(1))
974	1000		else LogMemo.Lines.Add('In: '+IntToStr(0));
975	1001		end;
976	1002
977	1003		procedure TForm1.GPIO18PwmChange(Sender: TObject);
978	1004		begin
979	1005		if GPIO18Pwm.Checked then
980	1006		begin
981	1007		GpF.SetPinMode(Ppwm,PWM_OUTPUT);
982	1008		PWM := True; //PWM on
983	1009		end
984	1010		else
985	1011		begin
986	1012		GpF.SetPinMode(Ppwm,INPUT);
987	1013		PWM := False; //PWM off
988	1014		end;
989	1015		end;
990	1016
991	1017		procedure TForm1.DirectionChange(Sender: TObject);
992	1018		begin
993	1019		if Direction.Checked then d:=10 else d:=-10;
994	1020		end;
995	1021
996	1022
997	1023		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
998	1024		begin
999	1025		GpF.SetPinMode(Ppwm,INPUT);
1000	1026		GpF.ClearBit(Pout);
1001	1027		GpIo_Driver.UnmapIoRegisrty(GpF);
1002	1028		end;
1003	1029
1004	1030		procedure TForm1.GPIO23switchChange(Sender: TObject);
1005	1031
1006	1032		Begin
1007	1033		Timer1.Enabled := False;
1008	1034		if GPIO23switch.Checked then
1009	1035		begin
1010	1036		GpF.SetBit(Pout); //Turn LED on
1011	1037		end
1012	1038		else
1013	1039		begin
1014	1040		GpF.ClearBit(Pout); //Turn LED off
1015	1041		end;
1016	1042		Timer1.Enabled := True;
1017	1043		end;
1018	1044
1019	1045		procedure TForm1.SpeedButtonClick(Sender: TObject);
1020	1046		var
1021	1047		i,p,k,v: longint;
1022	1048		ido:TDateTime;
1023	1049		begin
1024	1050		ido:= Time;
1025	1051		k:= TimeStampToMSecs(DateTimeToTimeStamp(ido));
1026	1052		LogMemo.Lines.Add('Start: '+TimeToStr(ido));
1027	1053		p:=10000000 ;
1028	1054		For i:=1 to p do Begin
1029	1055		GpF.SetBit(P16);
1030	1056		GpF.ClearBit(P16);
1031	1057		end;
1032	1058		ido:= Time;
1033	1059		v:= TimeStampToMSecs(DateTimeToTimeStamp(ido));
1034	1060		LogMemo.Lines.Add('Stop: '+TimeToStr(ido)+' Frequency: '+
1035	1061		IntToStr(p div (v-k))+' kHz');
1036	1062		end;
1037	1063
1038	1064		procedure TForm1.Timer1Timer(Sender: TObject);
1039	1065		begin
1040	1066		If PWM then Begin
1041	1067		If (d > 0) and (i+d < 1024) then begin
1042	1068		i:=i+d;
1043	1069		GpF.PwmWrite(Ppwm,i);
1044	1070		end ;
1045	1071		If (d < 0) and (i+d > -1) then begin
1046	1072		i:=i+d;
1047	1073		GpF.PwmWrite(Ppwm,i);
1048	1074		end;
1049	1075		end;
1050	1076		end;
1051	1077
1052	1078
1053	1079		end.
1054	1080		```
1055	1081
1056	1082		### PXL (Platform eXtended Library) for low level native access to GPIO, I²C, SPI, PWM, UART, V4L2, displays and sensors
1057	1083
1058	1084		- Fácil y rápido acceso a GPIO, I²C, SPI, PWM, UART y timer de alta preción de la CPU.
1059	1085		- V4L2 captura de video/imagen utilizando los conectores dedicados de la placa y cámaras USB. Por ejemplo cámaras serie como VC0706 y LSY201.
1060	1086		- OpenGL ES hardware de renderizado con y sin servidor X. Software de renderizado.
1061	1087		- Pantallas I²C y SPI tales como SSD1306, SSD1351, PCB8544 (Nokia), HX8357 y ILI9340.
1062	1088		- LCD de caracteres con cableado de pines directo.
1063	1089		- Suporte para software SPI y UART (bit-banging).
1064	1090		- Suporte para SC16IS7x0 (controladora UART conectada a través de I²C o SPI), incluyendo pins GPIO extra.
1065	1091		- Soporte para sensores tales como BMP180, DHT22, L3GD20, LSM303 y SHT10.
1066	1092		- Otras características como networking, math, transformación de imágenes, efectos, dibujo de primitivas gráficas...
1067	1093
1068	1094		Más información y descargas de la [librería PXL](http://asphyre.net/products/pxl).
1069	1095
1070	1096		## Referencias
1071	1097
1072	1098		- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
1073	1099		- B. J. Rao (2013) The Raspberry Pi, Pi Vision and Lazarus/FPC. [Blaise Pascal Magazine](http://www.blaisepascal.eu). 29: 14-21.
1074	1100
1075	1101		## External Links
1076	1102
1077	1103		- [Raspberry Pi Foundation](http://www.raspberrypi.org)
1078	1104		- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
1079	1105		- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
1080	1106		- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
1081	1107		- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
1082	1108		- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
1083	1109		- [Lazberry Pi: Comprehensive information on Lazarus on the Raspberry Pi computer](http://superbitysoft.co.uk/lazberrypi/).
1084	1110		- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
1085	1111		- [Improved Lazarus Unit for fast access to GPIO](http://www.meltonisl.com/software.html).
1086	1112		- [PXL - Platform eXtended Library](http://asphyre.net/products/pxl).
1087	1113
1088	1114		---
1089	1115		From the Free Pascal wiki, page "Lazarus on Raspberry Pi/es", as it stood on 2020-02-19 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