LED A1 und A2 Ansteuerung via Python & GPIO ?

[MPe-1954]

Hallo,

in meiner Anwendung des RevPi Core möchte ich auch die beiden LEDs A1 und A2 ansteuern. Im $HOME/demo/piControl.h habe ich folgende LED Definitionen gefunden, daraus werde ich jedoch nicht schlau:

#define PICONTROL_LED_A1_GREEN 0x01
#define PICONTROL_LED_A1_RED 0x02
#define PICONTROL_LED_A2_GREEN 0x04
#define PICONTROL_LED_A2_RED 0x08

Wie kann ich z.B. via Python auf die beiden LEDs wirken, also jedes dieser 4 Bits setzen (1/0) und damit die beiden LEDs auf AUS / ROT / GRÜN / GELB stellen?
Wie ist die GPIO Pin-Belegung der insgesamt 4 LEDs oben, und gibt es dazu allenfalls ein Beispielprogramm?

Besten Dank für Eure guten Hinweise!

Peter

[volker]

Hallo Peter,
eigentlich müsste ich mehr über eine Anwendung wissen, um die optimale Antwort geben zu können. Die direkte Ansteuerung der LEDs ist nämlich durchaus machbar, aber nicht ratsam. Wenn Du jemals Deine HW zusammen mit anderer SW nutzen willst, dann solltest Du den von uns beschriebenen Weg gehen und alle IOs über das Prozessabbild ansteuern. Das gilt auch für die LEDs. Im PiCtory findest Du sowohl den Status, als auch die LEDs als IOs vom RevPi Core unten rechts. Der symbolische Namen der LEDs ist per Default "RevPiLED" (Du kannst ihn natürlich abändern). Unter diesem Namen kannst Du dann die LEDs über PiControl und das Prozessabbild anteuern. Wie so etwas mit Python geht, habe ich im Forum hier beschireben:
viewtopic.php?f=10&t=32
Du kannst aber auch das Shell-Programm PiTest dafür verwenden und von der Kommandozeile aus (oder über ein Shell-Script) das Byte im Prozessabbild ansprechen. Dirk zeigt dies im Detail in einem Video-Tutorial:
https://www.youtube.com/watch?v=eQGtqjX3pYA
Der C-Code von diesem Testporgramm steht im Supportbereich und dient als Beispiel, wie man PiControl über C ansprechen kann:
https://revolution.kunbus.de/tutorials/downloads/
Wenn Du dabei nicht mit dem symbolischen Namen arbeiten willst, sondern den direkten Offset des Bytes, welches die LED ansteuert, verwenden möchtest, dann mach in PiCtory einen Export vom Typ "Offsetliste" in eine Datei und schau Dir den Inhalt an. Bei mir haben die LEDs im Prozessabbild den Offset 114 und die Größe "Byte".
Ich kann dann also per SW einfach PiControl als binary device öffnen und mit write(114,X) den Wert in das Byte im Prozessabbild schreiben. PiControl stellt dann die LEDs entsprechend ein. X ist dabei ein Byte-Wert, in welchem die 4 Einzel-LEDs (2 x rot und 2 x grün) jeweils als ein Bit drinnen stehen. Die Wertigkeit der Bits waren die von Dir zitierten Zahlen 0x01, 0x02, 0x04, 0x08 (als Hexadezimal in C-Notation, was vielleicht ein wenig unnötig "geschwollen" für 1 ,2, 3, 4 steht). Wenn Du also A1 auf grün und A2 auf rot schalten willst, dann schreibst Du 1 + 4 = 5 in das Byte im Prozessabbild (X in meinem Beispiel oben). Für A1 rot und A2 orange schreibst Du 2 + 3 + 4 = 9 in das Byte.
Der Vorteil gegenüber einer direkten Ansteuerung über GPIO ist der, dass die LEDs unter der Kontrolle des Prozessabbildes bleiben und somit auch andere SW darauf zugreifen könnte, die nur mit Prozessabbild arbeitet (zum Beispiel logi.RTS). Wenn Du GPIOs direkt ansteurst, dann merkt das Prozessabbild davon nichts, weil es die LED-Asugänge nur schreibt, aber nicht liest.
Direkte Ansteuerung geht über GPIO 30 (A1 grün), 06 (A1 rot), 32 (A2 grün) und 33 (A2 rot), für den Fall, dass Du PiControl abschaltest und in Deiner Anwendung nicht verwenden möchtest (dann wird es aber schwer mit DIO-Modulen, denn dann musst Du einen Ersatz für die Kommunikation über die PiBridge selber schreiben

[MPe-1954]

Danke Volker,
für Deine guten Erklärungen !
Meine Anwendung benötigt einen indistriellen Raspberry, in Form vom RevPi Core, keine DIO Module, deshalb bin ich auch dankbar für das GPIO Mapping, das ich (oder evtl. doch mit PiControl) verwende. Die Anwendung ist eine Fernsteuerung via Kommunikation, und da sind A1 und A2 gut um als einfache Statusanzeige zu dienen.

Grüsse,
Peter

[Sipple]

Guten Morgen

Erfolgreich getestet unter Jessie mit WiringPi.

Code: Select all

cd ~
git clone git://git.drogon.net/wiringPi
cd wiringPi
./build

gpio -v

gpio version: 2.38
Copyright (c) 2012-2017 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty

Raspberry Pi Details:
  Type: CM, Revision: 01, Memory: 512MB, Maker: Sony
  * Device tree is enabled.
  *--> Raspberry Pi Compute Module Rev 1.0
  * This Raspberry Pi supports user-level GPIO access.

gpio readall

+-----+------+-------+      +-----+------+-------+
| Pin | Mode | Value |      | Pin | Mode | Value |
+-----+------+-------+      +-----+------+-------+
|   0 | IN   | High  |      |  27 | IN   | Low   |
|   1 | IN   | High  |      |  28 | IN   | Low   |
|   2 | IN   | High  |      |  29 | IN   | Low   |
|   3 | IN   | High  |      |  30 | OUT  | Low   |
|   4 | IN   | High  |      |  31 | IN   | High  |
|   5 | IN   | High  |      |  32 | OUT  | Low   |
|   6 | OUT  | Low   |      |  33 | OUT  | Low   |
|   7 | IN   | High  |      |  34 | IN   | High  |
|   8 | IN   | High  |      |  35 | IN   | High  |
|   9 | IN   | Low   |      |  36 | IN   | High  |
|  10 | IN   | Low   |      |  37 | IN   | High  |
|  11 | IN   | Low   |      |  38 | IN   | Low   |
|  12 | IN   | Low   |      |  39 | IN   | Low   |
|  13 | IN   | Low   |      |  40 | IN   | Low   |
|  14 | ALT0 | High  |      |  41 | IN   | Low   |
|  15 | ALT0 | High  |      |  42 | IN   | High  |
|  16 | IN   | Low   |      |  43 | IN   | High  |
|  17 | IN   | Low   |      |  44 | ALT2 | High  |
|  18 | IN   | Low   |      |  45 | ALT2 | High  |
|  19 | IN   | Low   |      |  46 | IN   | High  |
|  20 | IN   | Low   |      |  47 | OUT  | Low   |
|  21 | IN   | Low   |      |  48 | ALT3 | Low   |
|  22 | IN   | Low   |      |  49 | ALT3 | High  |
|  23 | IN   | Low   |      |  50 | ALT3 | High  |
|  24 | IN   | Low   |      |  51 | ALT3 | High  |
|  25 | IN   | Low   |      |  52 | ALT3 | High  |
|  26 | IN   | Low   |      |  53 | ALT3 | High  |
+-----+------+-------+      +-----+------+-------+

gpio export 6 out	 #GPIO 6 für LED A1 rot auf Ausgang stellen
gpio export 30 out	#GPIO 30 für LED A1 grün auf Ausgang stellen
gpio export 32 out	#GPIO 32 für LED A2 grün auf Ausgang stellen
gpio export 33 out	#GPIO 33 für LED A2 rot auf Ausgang stellen

gpio write 6 1		#LED A1 rot einschalten
gpio write 6 0		#wieder ausschalten
							#usw...

Die Mischfarbe Gelb, wenn Grün und Rot zusammen eingeschaltet sind, kann man aber vergessen. Da sieht man keinen Unterschied, weil Rot einfach alles überstrahlt. Für mich kein Problem.
Es sind halt einzelne LEDs und keine echten DUO-LEDs.

Um die LEDs unter Python nutzen zu können: https://sourceforge.net/p/raspberry-gpi ... wiki/Home/
Das sehe ich mir als nächstes an. Hier noch ein nützlicher Link: http://raspberrypiguide.de/howtos/raspb ... io-how-to/
Runterscrollen bis "Ansteuerung mit Python"

Gruß, Martin

[RevPiModIO]

Wenn man piControl auf dem RevPi verwendet, sollte man, wie Volker schon schrieb, lieber den Weg über das Prozessabbild gehen (auch wenn man nur die LEDs schalten will):

Code: Select all

import revpimodio

# RevPiModIO instantiieren, dabei wird die Konfiguration
# automatisch aus piCtory gelesen.
# Parameter auto_refresh=True setzt alle Devices in die
# automatische Prozessabbildsynchronisierung.
myrevpi = revpimodio.RevPiModIO(auto_refresh=True)

# LED A1 grün und A2 rot leuchten lassen
myrevpi.devices.core.A1 = revpimodio.GREEN
myrevpi.devices.core.A2 = revpimodio.RED
# Durch das "auto_refresh" leuchtet diese sofort grün/rot auf

Aber wenn man auf dem RevPi eine andere Firmware hat ohne piControl, finde ich die Lösung von Sipple total cool Muss ich auch mal testen! NICE!!!

[RevPiModIO]

@Sipple:

Hast du mal geschaut ob man das auch über die Shell machen kann?

Beim Raspberry Pi war da mal was in dieser Art:

Code: Select all

echo $led > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio$led/direction

echo "1" > /sys/class/gpio/gpio$led/value
echo "0" > /sys/class/gpio/gpio$led/value

um die GPIO-Pins zu setzen?

Wäre ja für ein init bzw. systemd script cool, wenn man die einfach nur beim Systemstart an / aus schalten will?

Gruß, Sven

[Sipple]

Das geht wunderbar. Eigentlich macht WiringPi ja auch nichts anderes.

Code: Select all

root@RevPi:~# cd /sys/class/gpio
root@RevPi:/sys/class/gpio# l
total 0
--w------- 1 root root 4096 Feb 22 11:36 export
lrwxrwxrwx 1 root root    0 Feb 22 11:37 gpio17 -> ../../devices/platform/soc/20200000.gpio/gpio/gpio17
lrwxrwxrwx 1 root root    0 Feb 21 22:43 gpio30 -> ../../devices/platform/soc/20200000.gpio/gpio/gpio30
lrwxrwxrwx 1 root root    0 Feb 21 22:43 gpio32 -> ../../devices/platform/soc/20200000.gpio/gpio/gpio32
lrwxrwxrwx 1 root root    0 Feb 21 22:43 gpio33 -> ../../devices/platform/soc/20200000.gpio/gpio/gpio33
lrwxrwxrwx 1 root root    0 Feb 21 21:12 gpio6 -> ../../devices/platform/soc/20200000.gpio/gpio/gpio6
lrwxrwxrwx 1 root root    0 Jan  1  1970 gpiochip0 -> ../../devices/platform/soc/20200000.gpio/gpio/gpiochip0
--w------- 1 root root 4096 Jan  1  1970 unexport
root@RevPi:/sys/class/gpio# cd gpio6
root@RevPi:/sys/class/gpio/gpio6# l
total 0
-rw-r--r-- 1 root root 4096 Feb 22 11:37 active_low
lrwxrwxrwx 1 root root    0 Feb 22 11:37 device -> ../../../20200000.gpio
-rw-r--r-- 1 root root 4096 Feb 21 21:12 direction
-rw-r--r-- 1 root root 4096 Feb 21 21:12 edge
drwxr-xr-x 2 root root    0 Feb 22 11:37 power
lrwxrwxrwx 1 root root    0 Feb 22 11:37 subsystem -> ../../../../../../class/gpio
-rw-r--r-- 1 root root 4096 Feb 21 21:12 uevent
-rw-r--r-- 1 root root 4096 Feb 21 21:12 value
root@RevPi:/sys/class/gpio/gpio6# cat direction
out
root@RevPi:/sys/class/gpio/gpio6# echo "1" > /sys/class/gpio/gpio6/value
root@RevPi:/sys/class/gpio/gpio6# echo "0" > /sys/class/gpio/gpio6/value

Wenn ich das originale Image vom RevPI verwenden würde, würde ich es auch so machen wie Volker es super erklärt hat. Ich habe aber ein ua-netinst Jessie Minimalsystem drauf, weil ich keine der Zusatzmodule brauche. Auch keinen Desktop udgl. Die 4GB eMMC sind schnell voll. Dann bräuchte ich wieder einen USB Stick o.ä., womit dann ein USB Port belegt wäre, womit ich dann einen USB-Hub bräuchte, usw.

Mit Python habe ich es eben auch versucht. Alles kein Thema.

Gruß, Martin

[ChristianEWS]

Zitat: "
PiControl stellt dann die LEDs entsprechend ein. X ist dabei ein Byte-Wert, in welchem die 4 Einzel-LEDs (2 x rot und 2 x grün) jeweils als ein Bit drinnen stehen. Die Wertigkeit der Bits waren die von Dir zitierten Zahlen 0x01, 0x02, 0x04, 0x08 (als Hexadezimal in C-Notation, was vielleicht ein wenig unnötig "geschwollen" für 1 ,2, 3, 4 steht). Wenn Du also A1 auf grün und A2 auf rot schalten willst, dann schreibst Du 1 + 4 = 5 in das Byte im Prozessabbild (X in meinem Beispiel oben). Für A1 rot und A2 orange schreibst Du 2 + 3 + 4 = 9 in das Byte.
"

Zwei Fragen bezgl. das letzte Beispiels:
1.)
Muss doch 14 sein oder?
A1 rot => 0x02
A2 orange = 0x0C
zusammen = 0x0E (14)

2.)
Ist das Orange optisch vom rot zu unterscheiden?
Bei mir ist das gleich aus.

[volker]

Hallo Christian,
Du hast natürlich recht! Das sind 2 + 4 + 8 =14...
Nein, orange ist keine gute Idee, dafür sind die Helligkeiten nicht optimal ausgelegt. Wir gehen davon aus, dass die Norm rote Zustandsanzeigen als Alarm haben will, während Grün für dne Regelbetrieb gilt. Daher haben wir Grün dunkler eingestellt, als Rot. Rot soll eben sofort ins Augefallen. Das bedeutet aber auch, dass Orange dann kaum vom Rot zu unterscheiden ist.

[ChristianEWS]

Danke, ich dachte ich hätte was an den Augen und eine orange/rot Sehschwäche.