Lazarus on Raspberry Pi/es: what changed

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