Taster und Relais an GPIO

Was GPIO leistet

GPIO-Leitungen (General-Purpose Input/Output) sind die Pins auf der Platine eines Players, die eine Anwendung einzeln lesen und ansteuern kann. Eine Leitung ist ein Eingang, der hoch oder niedrig liest, oder ein Ausgang, den die Anwendung auf hoch oder niedrig setzt.

Eingänge bekommen den Raum mit:

• Ein Taster, etwa ein Taster für „Service rufen“ oder „nächste Seite“.
• Ein Tür- oder Fensterkontakt, ein Reedschalter oder ein Endschalter.
• Jeder Sensor mit potenzialfreiem Kontakt, etwa ein Strömungswächter oder ein Relaisausgang an einem Bewegungsmelder.

Ausgänge wirken auf den Raum ein:

• Ein Relais, das einen Türöffner freigibt, eine Signalleuchte schaltet oder einen Summer ertönen lässt.
• Eine LED, die einen Taster beleuchtet.

Die Anwendung auf dem Bildschirm erledigt die Arbeit über screenrig.device.gpio und meldet Ihrem Agenten mit emit, was passiert ist, sodass „Service angefordert“ im Ereignisprotokoll des Projekts erscheint. Ihr Agent erstellt die Anwendung, lädt sie hoch und platziert sie wie jede andere auf dem Bildschirm. Die Hardware-Seite zeigt, was eine Anwendung sonst noch erreichen kann.

Welche Player GPIO haben

Das Flag geht an den Controller der Seite oder an die Anwendung, die allein auf ihrer Seite ist. Eine Anwendung sieht capabilities["device.gpio"] nur auf einem Player und einem Gerät mit GPIO als true, sodass ein Build auch auf einem Bildschirm ohne GPIO läuft.

Den Player einrichten

Raspberry Pi

Ein Raspberry Pi braucht keine Einrichtung. Der Linux-Player öffnet den Header-Chip eines Pi 3, 4 oder 5 von selbst, und ein Pin ist seine BCM-Nummer. Der Benutzer des Players braucht Zugriff auf /dev/gpiochip*. Unter Raspberry Pi OS gehört der Standardbenutzer zur Gruppe gpio, die diesen Zugriff gibt. Eine --kiosk-Installation fügt ihr Konto nur den Gruppen video und i2c hinzu; geben Sie daher einem anderen --kiosk-user-Konto die Gruppe gpio und starten Sie den Player neu:

sudo usermod -aG gpio KIOSK_USER

Andere Linux-Boards

Nennen Sie auf einem anderen Board den Chip, der die Leitungen trägt, mit SCREENRIG_GPIO_CHIP in der Startumgebung des Players:

SCREENRIG_GPIO_CHIP=/dev/gpiochip4

Fügen Sie es bei einer --kiosk-Installation mit sudo systemctl edit screenrig-player-kiosk.service zum Dienst hinzu:

[Service]
Environment=SCREENRIG_GPIO_CHIP=/dev/gpiochip4

Ein Pin ist dann eine Leitungsnummer dieses Chips. Der Benutzer des Players braucht Zugriff auf die Gerätedatei des Chips.

Android

Android hat GPIO, wo das Gerät einen beschreibbaren sysfs-GPIO-Chip bereitstellt, etwa eine Signage-Platine oder ein benutzerdefiniertes Image. Ein Pin ist die globale Leitungsnummer des Chips. Eine Standard-TV-Box hat keinen solchen Chip, und die Anwendung sieht device.gpio als false. Der Player hält eine Leitung nur, solange die Anwendung sie nutzt. Android kann den Pull eines Eingangs nicht setzen: Verdrahten Sie einen Widerstand, wie unter Einen Taster anschließen.

Einen Pin wählen

pin ist eine ganze Zahl von 0 bis 255: die Leitungsnummer des Chips. Auf einem Raspberry Pi ist es die BCM-Nummer, die GPIO-Nummer aus der Dokumentation des Pi, und nicht die Position des Pins am Header. GPIO17 ist der physische Pin 11. Gängige Leitungen:

Masse sind die physischen Pins 6, 9, 14, 20, 25, 30, 34 und 39, und 3.3 V liegt an den Pins 1 und 17. Die Dokumentation des Raspberry Pi listet den gesamten Header auf. Ein Zugriff auf eine Leitung, die ein anderes Programm bereits hält, wird mit pin_busy abgelehnt, auf eine Leitung, die der Chip nicht hat, mit pin_not_found.

Einen Taster anschließen

Schließen Sie einen Taster zwischen einer GPIO-Leitung und Masse an und schalten Sie den Pull-up dieser Leitung ein. Die Leitung liest hoch, bis der Taster gedrückt wird, und ein Druck zieht sie auf Masse, sodass ein Druck niedrig liest.

 GPIO17 (pin 11) -----+
                      |
                   [ button ]
                      |
 GND (pin 9) ---------+

Fordern Sie auf einem Raspberry Pi oder einem anderen Linux-Board den Pull-up beim Player mit pull: "up" an:

window.screenrig.device.gpio.onChange(17, handlePress, { pull: "up" });

pull: "down" eignet sich für einen Taster, der an 3.3 V angeschlossen ist und beim Drücken den hohen Pegel liest. "none" ist der Standard: Der Player setzt keine Vorspannung, sodass ein Eingang ohne Anschluss schwebt und ein Taster ohne Widerstand zufällige Änderungen liest.

Android setzt keinen Pull, ergänzen Sie daher für einen gegen Masse verdrahteten Taster einen Widerstand von etwa 10 kΩ von der Leitung nach 3.3 V (einen Pull-up). Ein BrightSign hat eingebaute Pull-ups an seinen Eingängen, und ein gegen Masse verdrahteter Taster funktioniert unverändert.

Wer "up" oder "down" auf einem Player anfordert, der es nicht setzen kann, stoppt den Handler nicht: Das SDK überwacht die Leitung ohne Pull und protokolliert einen warn-Eintrag mit dem Code gpio_pull_unsupported.

Ein Relais ansteuern

Steuern Sie ein Relais über eine Relaisplatine an und nie direkt von einem Pin. Ein Pin liefert bei 3.3 V nur wenige Milliampere, die keine Relaisspule, keinen Türöffner, keine Signalleuchte und keinen Summer schalten können, und die Spannungsspitze einer Spule kann die Platine beschädigen. Eine Relaisplatine trägt den Transistor und den Schutz der Spule.

 5V (pin 2) -------------- VCC |
 GND (pin 6) ------------- GND | relay board
 GPIO27 (pin 13) --------- IN1 |
                               |  COM ---- supply for the load
                               |  NO  ---- the load (door strike, light, buzzer)

Versorgen Sie die Last aus einem eigenen Netzteil über die Kontakte des Relais. Wählen Sie eine Platine, deren Eingang bei 3.3 V auslöst.

const sr = window.screenrig;
await sr.device.gpio.write(27, true);   // relay on
await sr.device.gpio.write(27, false);  // relay off

Die meisten Platinen ziehen bei hohem Pegel an. Viele günstige Platinen sind active low: Das Relais zieht an, wenn der Eingang auf niedrig gezogen wird. Übergeben Sie idle: true für eine Active-low-Platine, damit eine Seite, die den Bildschirm verlässt, das Relais als aus freigibt. Siehe Ruhepegel.

await sr.device.gpio.write(27, false, { idle: true }); // active-low board: relay on
await sr.device.gpio.write(27, true, { idle: true });  // relay off

Ein Ausgang an einem BrightSign liegt bei 3.3 V über 100 Ω, sodass ein BrightSign eine Relaisplatine auf dieselbe Weise ansteuert.

Nur 3.3 V

Jede GPIO-Leitung arbeitet mit 3.3 V-Logik. Die Pins eines Raspberry Pi sind nicht 5 V-tolerant, und 5 V an einem Pin können die Platine beschädigen. Schließen Sie nur potenzialfreie Kontakte an: einen Taster, einen Schalter oder einen Relaisausgang, der keine eigene Spannung führt. Ein Sensor, der 5 V, 12 V, 24 V oder Netzspannung ausgibt, braucht zwischen sich und dem Pin einen Pegelwandler, einen Optokoppler oder ein Relais.

Entprellen

Ein mechanischer Kontakt prellt: Für einige Millisekunden flackert ein Tastendruck zwischen hoch und niedrig. Der Player filtert das Kontaktprellen, sodass der Handler einen Druck als eine Änderung und das Loslassen als eine weitere Änderung mitbekommt. Eine Leitung unter Linux oder Raspberry Pi ignoriert Änderungen, die sich innerhalb von etwa 20 ms stabilisieren. Dafür ist kein Code von Ihnen nötig, und ein kürzerer Impuls ist kein Einsatzfall für einen GPIO-Eingang.

Änderungen einer Leitung mitbekommen

onChange(pin, handler, options) überwacht eine Leitung. Der Handler erhält den Pegel als Boolean, true für hoch. Der erste Aufruf enthält den Pegel, den die Leitung hat, wenn der Player mit der Überwachung beginnt, und jeder weitere Aufruf ist eine Änderung. Der Aufruf gibt eine Funktion zurück, die die Überwachung beendet.

const stop = window.screenrig.device.gpio.onChange(17, function (high) {
  doorOpen = high;
}, { pull: "up" });

Höchstens 16 Leitungen werden gleichzeitig überwacht, und eine 17. löst invalid_request aus. Zwei Handler an einer Leitung teilen sich deren Pull: Ein zweiter Handler mit einem anderen pull löst sofort invalid_request aus.

Ruhepegel

write(pin, value, options) akzeptiert eine Option idle, den Pegel, auf den der Player die Leitung ansteuert, wenn die Seite sie freigibt. Der Standard ist der niedrige Pegel. Die Seite gibt eine Leitung frei, wenn sie den Bildschirm verlässt, wenn ihr Kontext endet und wenn sie screenrig.destroy() aufruft. Der Player gibt die Leitung dann frei. Der letzte Schreibzugriff für einen Pin legt seinen Ruhepegel fest.

Deshalb bleibt ein Relais nach dem Verlassen der Seite nicht angezogen. Setzen Sie idle auf den Pegel, der für Ihre Platine „aus“ bedeutet: niedrig für die meisten Platinen, hoch für eine Active-low-Platine.

Wenn die Seite den Bildschirm verlässt

Was eine Seite hält, endet mit der Seite. Wenn sie den Bildschirm verlässt, enden ihre Eingänge, und jeder Ausgang geht auf seinen Ruhepegel und wird freigegeben. Wenn der Player stoppt oder das Gerät die Stromversorgung verliert, gehen die Leitungen mit. Planen Sie die Last darauf ein: Wählen Sie einen Türöffner, der bei Stromausfall so verriegelt oder entriegelt, wie das Gebäude es braucht.

Grenzen und Fehler

• Ein Pin ist eine ganze Zahl von 0 bis 255.
• Höchstens 16 Leitungen werden gleichzeitig überwacht.
• write wird mit invalid_request abgelehnt bei einem ungültigen pin, value oder idle, mit pin_not_found bei einer Leitung, die der Chip nicht hat, mit pin_busy bei einer Leitung, die ein anderer Prozess hält, und mit gpio_unavailable, wenn der Player keinen GPIO-Chip öffnen kann.
• onChange löst invalid_request aus bei einer 17. Leitung oder einem widersprüchlichen pull. Eine abgelehnte Überwachung wird protokolliert, und der Handler läuft nie.
• Ein Aufruf prüft inert, not_supported und capability_denied, bevor er etwas sendet. Die SDK-Referenz nennt die Reihenfolge. Ein write mit idle wird auf einem Player, der es nicht setzen kann, mit not_supported abgelehnt.

Beispiel: Service rufen

Ein Taster an GPIO17, gegen Masse verdrahtet, meldet Ihrem Agenten, dass ein Kunde Hilfe möchte, und eine LED oder ein Summer-Relais an GPIO27 antwortet fünf Sekunden lang. Die erste Messung ist der Pegel, den die Leitung bereits hat, daher reagiert der Handler nur auf einen Wechsel von hoch auf niedrig.

const sr = window.screenrig;

function active() {
  return sr.readyState === "active";
}

async function start() {
  if (!sr) return;
  await sr.waitUntilActive();
  await sr.ready();
  if (!sr.supports("device.gpio") || !sr.capabilities["device.gpio"]) return;

  let wasHigh = null;
  sr.device.gpio.onChange(17, function (high) {
    const pressed = wasHigh === true && high === false;
    wasHigh = high;
    if (!pressed || !active()) return;
    sr.emit("service.requested");
    document.getElementById("message").hidden = false;
    sr.device.gpio.write(27, true).catch(function () {});
    setTimeout(function () {
      document.getElementById("message").hidden = true;
      if (active()) sr.device.gpio.write(27, false).catch(function () {});
    }, 5000);
  }, { pull: "up" });
}
start();

Wenn die Seite den Bildschirm verlässt, gibt sie die Leitung 27 auf ihrem Ruhepegel frei, niedrig, sofern Sie nicht idle übergeben, sodass ein kurz vor dem Verlassen der Seite gedrückter Taster das Relais nicht eingeschaltet lässt.

Ihr Agent liest jeden Druck aus dem Ereignisprotokoll:

screenrig events list --type application.event --screen-id scr_SCREEN

Beispiel: Eingang für offene Tür

Ein Reedschalter an GPIO17, gegen Masse verdrahtet, schließt, wenn die Tür zu ist, sodass die Leitung bei geschlossener Tür niedrig und bei offener Tür hoch liest. Die Seite zeigt einen Hinweis, solange die Tür offen ist, und meldet es Ihrem Agenten.

const sr = window.screenrig;
const notice = document.getElementById("door-notice");

function show(open) {
  notice.hidden = !open;
  document.body.classList.toggle("door-open", open);
}

async function start() {
  show(false);
  if (!sr) return;
  await sr.waitUntilActive();
  await sr.ready();
  if (!sr.supports("device.gpio") || !sr.capabilities["device.gpio"]) return;
  sr.device.gpio.onChange(17, function (high) {
    show(high);
    if (sr.readyState === "active") sr.emit(high ? "door.opened" : "door.closed");
  }, { pull: "up" });
}
start();

BrightSign

Ein BrightSign-Player führt dieselbe API aus. Die Pins 0 bis 7 sind die Leitungen des GPIO-Anschlusses, des Anschlusses an den Modellen XT, XD und HD (eine DA-15-Buchse); Pin 0 ist die Leitung 0 des Anschlusses und Pin 7 seine Leitung 7. Seine Eingänge haben feste Pull-ups, daher wird pull nicht angeboten, und ein gegen Masse verdrahteter Taster funktioniert unverändert. idle funktioniert wie auf jedem Player. Die Ausgänge liegen bei 3.3 V über 100 Ω: Steuern Sie ein Relais über eine Relaisplatine an.

Ein BrightSign ergänzt über USB zwei weitere Gruppen von Leitungen:

Ein Schreibzugriff auf Pin 100+k schaltet die LED von Taste k ein, und eine Überwachung von Pin 100+k bekommt die Taste mit. Bei einer nicht angeschlossenen Platine oder einem nicht angeschlossenen Expander werden Aufrufe für ihre Pins mit pin_not_found abgelehnt.

In app dev ausprobieren

screenrig app dev simuliert GPIO. Der Harness zeigt einen Schalter für den GPIO-Chip und drei simulierte Leitungen: 17 (niedrig), 27 (hoch) und 22, die ein anderer Prozess hält und die daher mit pin_busy antwortet. Die Beispiele oben verwenden 17 und 27. Klicken Sie auf den Pegel einer Leitung, um ihn zu ändern, und Ihre Anwendung bekommt die Änderung mit, wenn sie die Leitung überwacht. Ein Schreibzugriff der Anwendung bewegt die Leitung, und der Bereich zeigt den Ruhepegel, den sie gesetzt hat. Der Harness akzeptiert pull und idle, sodass ein Build dort läuft, bevor er einen Bildschirm erreicht. Lokal entwickeln beschreibt die Steuerelemente.

Referenz

• screenrig.device.gpio.write() und screenrig.device.gpio.onChange() in der SDK-Referenz.
• Hardware, die eine Anwendung nutzen kann: jeder Player und jede Gerätefähigkeit.
• Digital Signage mit Raspberry Pi: der Pi als Bildschirm.
• Linux und Raspberry Pi: den Player installieren.

Fragen

Kann ein Bildschirm ein Relais ansteuern?

Ja, über eine Relaisplatine. Eine Anwendung setzt eine Leitung auf hoch oder niedrig, und die Platine schaltet den Türöffner, die Signalleuchte oder den Summer. Steuern Sie ein Relais nie direkt von einem Pin an.

Braucht ein Taster einen Widerstand?

Auf einem Raspberry Pi oder einem anderen Linux-Board nein: Fordern Sie den Pull-up an und verdrahten Sie den Taster gegen Masse. Unter Android ergänzen Sie einen Widerstand von etwa 10 kΩ nach 3.3 V. Ein BrightSign hat Pull-ups eingebaut.

Welche Nummer übergebe ich für einen Pin?

Auf einem Raspberry Pi die BCM-Nummer: GPIO17 ist 17 und sitzt auf dem physischen Pin 11. Auf einem anderen Board die Leitungsnummer seines GPIO-Chips. Auf einem BrightSign die Pin-Bereiche im Abschnitt zu BrightSign.

Was passiert mit einem Relais, wenn die Seite wechselt?

Der Player steuert die Leitung auf ihren Ruhepegel an, niedrig, sofern die Anwendung keinen anderen gewählt hat, und gibt sie frei. Wählen Sie hoch für eine Active-low-Relaisplatine, damit das Relais aus ist.

Muss die Anwendung die ganze Zeit laufen?

Die Anwendung hört zu, solange ihre Seite auf dem Bildschirm ist. Wenn die Seite den Bildschirm verlässt, enden die Eingänge, und die Ausgänge gehen auf ihren Ruhepegel.

Was kostet es?

screenRIG ist kostenlos. Die Platine, der Taster und das Relais gehen auf Ihre Kosten.