+(venv)$ pip install git+git://git.graph-it.com/graphit/controlpi-pinio.git
+```
+
+## Benutzung
+Für die Benutzung der GPIO-Pins des Pi selbst, gibt es die Plugins
+`OutputPin`, `HackPin`, `InputPin` und `PWMPin`.
+
+`OutputPin` und `HackPin` werden einfach nur mit der Angabe des Pins
+(GPIO-Nummer zwischen 0 und 31) konfiguriert:
+```json
+ "Aktor": {
+ "plugin": "OutputPin",
+ "pin": 23
+ },
+ "Relais": {
+ "plugin": "HackPin",
+ "pin": 24
+ },
+```
+Diesen Plugins können dann Kommandos
+`{"target": "Aktor", "command": "set state", "new state": true}` bzw.
+`{"target": "Relais", "command": "set state", "new state": false}` gesendet
+werden.
+Der Unterschied zwischen `OutputPin` und `HackPin` ist, dass `OutputPin`
+die Versorgungsspannung des Pi auf den Pin legt, während `HackPin` den Pin
+auf Masse zieht, was für das Schalten einiger Arten von Relais notwendig
+ist.
+Außerdem kann beiden das Kommando
+`{"target": "Aktor", "command": "get state"}` gesendet werden, welches den
+momentanen Zustand als Nachricht auf den Bus legt.
+Die Nachrichten von den Plugins haben die Form
+`{"sender": "Aktor", "event": "changed", "state": true}` bzw.
+`{"sender": "Relais", "state": false}`.
+`"event": "changed"` wird nur aufgenommen, wenn sich der Zustand
+tatsächlich geändert hat.
+
+Für `InputPin` kann zusätzlich zur Angabe des Pins optional der
+Glitch-Filter (zwischen 0 und 300 000 Mikrosekunden, Default sind 5000
+Mikrosekunden) und der Pull-Up-Widerstand konfiguriert werden (Default ist
+Benutzung des Pull-Down-Widerstands):
+```json
+ "Sensor": {
+ "plugin": "InputPin",
+ "pin": 25,
+ "glitch filter": 10000,
+ "pullup": true
+ },
+```
+Ein `InputPin`-Plugin verarbeitet nur `get state`-Kommandos.
+Die Nachrichten, die das Plugin sendet, haben die gleiche Form wie bei
+`OutputPin` und `HackPin`.
+
+Das `PWMPin`-Plugin ermöglicht es, auf den GPIO-Pins 12 und 13 bzw. 18 und
+19 Pulse-Width-Modulation zu benutzen.
+Hierfür kann eine Frequenz zwischen 1 MHz und 125 MHz gewählt werden (wobei
+die `pigpio`-Dokumentation Werte kleiner als 30 MHz empfiehlt.
+Der aktive Anteil wird mit dem Parameter `duty` gewählt, der zwischen 0
+(aus) und 1 000 000 (durchgehend an) liegen kann:
+```json
+ "Dimmer": {
+ "plugin": "PWMPin",
+ "pin": 18,
+ "freq": 10000000,
+ "duty": 0
+ },
+```
+Die initialen Werte können durch die Kommandos
+`{"target": "Dimmer", "command": "set freq", "new freq": 20000000}` und
+`{"target": "Dimmer", "command": "set duty", "new duty": 500000}` geändert
+werden.
+Die Kommandos `get freq` und `get duty` fragen die aktuellen Werte ab.
+Die Nachrichten vom Plugin haben die Form
+`{"sender": "Dimmer", "freq": 10000000}` bzw.
+`{"sender": "Dimmer", "event": "changed", "duty": 500000}`, wobei
+`"event": "changed"` wiederum nur enthalten ist, wenn es tatsächlich eine
+Änderung gab.
+
+Für die Benutzung der I2C-I/O-Karten, gibt es die Plugins `OutputCard` und
+`InputCard`.
+
+Eine `OutputCard` wird konfiguriert, indem die I2C-Adresse angegeben wird
+und einer Auswahl der Pins der Karte (diejenigen, die für die Anwendung
+interessant sind) Namen zugewiesen werden:
+```json
+ "Ausgangskarte 1": {
+ "plugin": "OutputCard",
+ "address": 56,
+ "pins": { "Aktor 1": 0, "Aktor 2": 2, "Aktor 3": 4 }
+ },
+```
+Die Kommandos an und Nachrichten von `"Aktor 1"`, `"Aktor 2"` und
+`"Aktor 3"` sind dann genau die gleichen wie für `OutputPin` oben.
+
+Für eine `InputCard` wird zusätzlich ein `"interrupt pin"` (GPIO-Pin auf
+dem Pi selbst) konfiguriert, auf dem die Karte meldet, wenn sich einer der
+Karten-Pins geändert hat:
+```json
+ "Eingangskarte 1": {
+ "plugin": "InputCard",
+ "address": 32,
+ "interrupt pin": 4,
+ "pins": { "Sensor 1": 0, "Sensor 2": 2, "Sensor 3": 4 }
+ }
git.graph-it.com / graphit / controlpi-pinio.git / commitdiff