Kits / Starterkit: Hardware Hacking / Beispiele / Rauchmelder auslesen / Mit C/C++

Rauchmelder mit C auslesen¶

Für diese Projekt setzen wir voraus, dass eine C Entwicklungsumgebung eingerichtet ist und ein grundsätzliches Verständnis der C Programmiersprache vorhanden ist.

Falls dies nicht der Fall ist sollte hier begonnen werden. Informationen über die Tinkerforge API sind dann hier zu finden.

Wir setzen weiterhin voraus, dass ein passender Rauchmelder mit einem Industrial Digital In 4 Bricklet verbunden wurde wie hier beschrieben.

Ziele¶

Wir setzen uns folgendes Ziel für dieses Projekt:

Alarmstatus eines Rauchmelders auslesen
und auf dessen Alarmsignal reagieren.

Da dieses Projekt wahrscheinlich 24/7 laufen wird, wollen wir sicherstellen, dass das Programm möglichst robust gegen externe Einflüsse ist. Das Programm sollte weiterhin funktionieren falls

Bricklets ausgetauscht werden (z.B. verwenden wir keine fixen UIDs),
Brick Daemon läuft nicht oder wird neu gestartet,
WIFI Extension ist außer Reichweite oder
Brick wurde neu gestartet (Stromausfall oder USB getrennt).

Im Folgenden werden wir Schritt für Schritt zeigen wie diese Ziele erreicht werden können.

Schritt 1: Bricks und Bricklets dynamisch erkennen¶

Als Erstes legen wir fest wohin unser Programm sich verbinden soll:

#define HOST "localhost"
#define PORT 4223

Falls eine WIFI Extension verwendet wird, oder der Brick Daemon auf einem anderen PC läuft, dann muss "localhost" durch die IP Adresse oder den Hostnamen der WIFI Extension oder des anderen PCs ersetzt werden.

Nach dem Start des Programms müssen der IPCON_CALLBACK_ENUMERATE Callback und der IPCON_CALLBACK_CONNECTED Callback registriert und ein erstes Enumerate ausgelöst werden:

typedef struct {
    IPConnection ipcon;
} SmokeDetector;

int main() {
    SmokeDetector sd;
    ipcon_create(&sd.ipcon);
    ipcon_connect(&sd.ipcon, HOST, PORT);

    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_ENUMERATE,
                            (void *)cb_enumerate,
                            (void *)&sd);
    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_CONNECTED,
                            (void *)cb_connected,
                            (void *)&sd);

    ipcon_enumerate(&sd.ipcon);
    return 0;
}

Der Enumerate Callback wird ausgelöst wenn ein Brick per USB angeschlossen wird oder wenn die ipcon_enumerate() Funktion aufgerufen wird. Dies ermöglicht es die Bricks und Bricklets im Stapel zu erkennen ohne im Voraus ihre UIDs kennen zu müssen.

Der Connected Callback wird ausgelöst wenn die Verbindung zur WIFI Extension oder zum Brick Daemon hergestellt wurde. In diesem Callback muss wiederum ein Enumerate angestoßen werden, wenn es sich um ein Auto-Reconnect handelt:

void cb_connected(uint8_t connected_reason, void *user_data) {
    SmokeDetector *sd = (SmokeDetector *)user_data;

    if(connected_reason == IPCON_CONNECT_REASON_AUTO_RECONNECT) {
        ipcon_enumerate(&sd->ipcon);
    }
}

Ein Auto-Reconnect bedeutet, dass die Verbindung zur WIFI Extension oder zum Brick Daemon verloren gegangen ist und automatisch wiederhergestellt werden konnte. In diesem Fall kann es sein, dass die Bricklets ihre Konfiguration verloren haben und wir sie neu konfigurieren müssen. Da die Konfiguration beim Enumerate (siehe unten) durchgeführt wird, lösen wir einfach noch ein Enumerate aus.

Schritt 1 zusammengefügt:

typedef struct {
    IPConnection ipcon;
} SmokeDetector;

void cb_connected(uint8_t connected_reason, void *user_data) {
    SmokeDetector *sd = (SmokeDetector *)user_data;

    if(connected_reason == IPCON_CONNECT_REASON_AUTO_RECONNECT) {
        ipcon_enumerate(&sd->ipcon);
    }
}

int main() {
    SmokeDetector sd;
    ipcon_create(&sd.ipcon);
    ipcon_connect(&sd.ipcon, HOST, PORT);

    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_ENUMERATE,
                            (void *)cb_enumerate,
                            (void *)&sd);
    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_CONNECTED,
                            (void *)cb_connected,
                            (void *)&sd);

    ipcon_enumerate(&sd.ipcon);
    return 0;
}

Schritt 2: Bricklets beim Enumerate initialisieren¶

Während des Enumerierungsprozesses soll das Industrial Digital In 4 Bricklet konfiguriert werden. Dadurch ist sichergestellt, dass es neu konfiguriert wird nach einem Verbindungsabbruch oder einer Unterbrechung der Stromversorgung.

Die Konfiguration soll beim ersten Start (IPCON_ENUMERATION_TYPE_CONNECTED) durchgeführt werden und auch bei jedem extern ausgelösten Enumerate (IPCON_ENUMERATION_TYPE_AVAILABLE):

void cb_enumerate(const char *uid, const char *connected_uid,
                  char position, uint8_t hardware_version[3],
                  uint8_t firmware_version[3], uint16_t device_identifier,
                  uint8_t enumeration_type, void *user_data) {
    SmokeDetector *sd = (SmokeDetector*)user_data;

    if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED ||
       enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE) {

Das Industrial Digital In 4 Bricklet wird so eingestellt, dass es die cb_interrupt Callback-Funktion aufruft wenn sich die Spannung an einem der Eingänge verändert. Die Entprellperiode wird auf 10s (10000ms) gestellt, um zu vermeiden zu viele Callback zu erhalten. Interrupt-Erkennung wird für alle Eingänge aktiviert (15 = 0b1111).

if(device_identifier == INDUSTRIAL_DIGITAL_IN_4_DEVICE_IDENTIFIER) {
    industrial_digital_in_4_create(&sd->idi4, uid, &sd->ipcon);
    industrial_digital_in_4_set_debounce_period(&sd->idi4, 10000);
    industrial_digital_in_4_register_callback(&sd->idi4,
                                              INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT,
                                              (void *)cb_interrupt,
                                              (void *)sd);
    industrial_digital_in_4_set_interrupt(&sd->idi4, 15);
}

Schritt 2 zusammengefügt:

void cb_enumerate(const char *uid, const char *connected_uid,
                  char position, uint8_t hardware_version[3],
                  uint8_t firmware_version[3], uint16_t device_identifier,
                  uint8_t enumeration_type, void *user_data) {
    SmokeDetector *sd = (SmokeDetector*)user_data;

    if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED ||
       enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE) {
        if(device_identifier == INDUSTRIAL_DIGITAL_IN_4_DEVICE_IDENTIFIER) {
            industrial_digital_in_4_create(&sd->idi4, uid, &sd->ipcon);
            industrial_digital_in_4_set_debounce_period(&sd->idi4, 10000);
            industrial_digital_in_4_register_callback(&sd->idi4,
                                                      INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT,
                                                      (void *)cb_interrupt,
                                                      (void *)sd);
            industrial_digital_in_4_set_interrupt(&sd->idi4, 15);
        }
    }
}

Schritt 3: Auf Alarmsignal reagieren¶

Jetzt müssen wir noch auf das Alarmsignal des Rauchmelders reagieren. Es soll aber nur auf das Einschalten der LED reagiert werden, nicht auf das Ausschalten. Dazu wird value_mask auf > 0 geprüft, in diesem Fall liegt an mindesten einem Eingang eine Spannung an, sprich die LED leuchtet.

void cb_interrupt(uint16_t interrupt_mask, uint16_t value_mask, void *user_data) {
    if(value_mask > 0) {
        printf("Fire! Fire!\n");
    }
}

Das ist es. Wenn wir diese drei Schritte zusammen in eine Datei kopieren und ausführen, dann hätten wir jetzt eine funktionierendes Programm, das den Alarmstatus eines Rauchmelders ausließt und auf dessen Alarmsignal reagiert.

In der jetzigen Form gibt das Programm nur eine Meldung aus. Dies kann auf verschiedene Weise verbessert werden. Zum Beispiel könnte das Programm jemanden per E-Mail oder SMS über den Alarm informieren.

Wie dem auch sei, wir haben noch nicht alle Ziele erreicht. Das Programm ist noch nicht robust genug. Was passiert wenn die Verbindung beim Start des Programms nicht hergestellt werden kann, oder wenn das Enumerate nach einem Auto-Reconnect nicht funktioniert?

Wir brauchen noch Fehlerbehandlung!

Schritt 4: Fehlerbehandlung und Logging¶

Beim Start des Programms versuchen wir solange die Verbindung herzustellen, bis es klappt:

while(true) {
    int rc = ipcon_connect(&sd.ipcon, HOST, PORT);
    if(rc < 0) {
        fprintf(stderr, "Could not connect to brickd: %d\n", rc);
        // TODO: sleep 1s
        continue;
    }
    break;
}

und es wird solange versucht ein Enumerate zu starten bis auch dies geklappt hat:

while(true) {
    int rc = ipcon_enumerate(&sd.ipcon);
    if(rc < 0) {
        fprintf(stderr, "Could not enumerate: %d\n", rc);
        // TODO: sleep 1s
        continue;
    }
    break;
}

Es gibt keine portable Sleep Funktion in C. Auf Windows deklariert windows.h` eine Sleep Funktion die die Wartedauer in Millisekunden übergeben bekommt. Auf POSIX Systemen wie Linux und macOS gibt es eine sleep Funktion deklariert in unistd.h die die Wartedauer in Sekunden übergeben bekommt.

Mit diesen Änderungen kann das Programm schon gestartet werden bevor der Master Brick angeschlossen ist.

Es müssen auch noch mögliche Fehler während des Enumerierungsprozesses behandelt werden:

if(device_identifier == INDUSTRIAL_DIGITAL_IN_4_DEVICE_IDENTIFIER) {
    industrial_digital_in_4_create(&sd->idi4, uid, &sd->ipcon);
    industrial_digital_in_4_set_debounce_period(&sd->idi4, 10000);
    industrial_digital_in_4_register_callback(&sd->idi4,
                                              INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT,
                                              (void *)cb_interrupt,
                                              (void *)sd);

    int rc = industrial_digital_in_4_set_interrupt(&sd->idi4, 15);
    if(rc < 0) {
        fprintf(stderr, "Industrial Digital In 4 init failed: %d\n", rc);
    } else {
        printf("Industrial Digital In 4 initialized\n");
    }
}

Zusätzlich wollen wir noch ein paar Logausgaben einfügen. Diese ermöglichen es später herauszufinden was ein mögliches Problem ausgelöst hat.

Zum Beispiel, wenn der Master Brick über WLAN angebunden ist und häufig Auto-Reconnects auftreten, dann ist wahrscheinlich die WLAN Verbindung nicht sehr stabil.

Schritt 5: Alles zusammen¶

Jetzt sind alle für gesteckten Ziele für unseren gehackten Rauchmelder erreicht.

Das gesamte Programm für den gehackten Rauchmelder (download):

#include <stdio.h>

#include "ip_connection.h"
#include "bricklet_industrial_digital_in_4.h"

#define HOST "localhost"
#define PORT 4223

typedef struct {
    IPConnection ipcon;
    IndustrialDigitalIn4 idi4;
} SmokeDetector;

void cb_interrupt(uint16_t interrupt_mask, uint16_t value_mask, void *user_data) {
    // avoid unused parameter warning
    (void)interrupt_mask; (void)user_data;

    if(value_mask > 0) {
        printf("Fire! Fire!\n");
    }
}

void cb_connected(uint8_t connected_reason, void *user_data) {
    SmokeDetector *sd = (SmokeDetector *)user_data;

    if(connected_reason == IPCON_CONNECT_REASON_AUTO_RECONNECT) {
        printf("Auto Reconnect\n");

        while(true) {
            int rc = ipcon_enumerate(&sd->ipcon);
            if(rc < 0) {
                fprintf(stderr, "Could not enumerate: %d\n", rc);
                // TODO: sleep 1s
                continue;
            }
            break;
        }
    }
}

void cb_enumerate(const char *uid, const char *connected_uid,
                  char position, uint8_t hardware_version[3],
                  uint8_t firmware_version[3], uint16_t device_identifier,
                  uint8_t enumeration_type, void *user_data) {
    SmokeDetector *sd = (SmokeDetector *)user_data;

    // avoid unused parameter warning
    (void)connected_uid; (void)position; (void)hardware_version; (void)firmware_version;

    if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED ||
       enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE) {
        if(device_identifier == INDUSTRIAL_DIGITAL_IN_4_DEVICE_IDENTIFIER) {
            industrial_digital_in_4_create(&sd->idi4, uid, &sd->ipcon);
            industrial_digital_in_4_set_debounce_period(&sd->idi4, 10000);
            industrial_digital_in_4_register_callback(&sd->idi4,
                                                      INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT,
                                                      (void (*)(void))cb_interrupt,
                                                      (void *)sd);

            int rc = industrial_digital_in_4_set_interrupt(&sd->idi4, 15);
            if(rc < 0) {
                fprintf(stderr, "Industrial Digital In 4 init failed: %d\n", rc);
            } else {
                printf("Industrial Digital In 4 initialized\n");
            }
        }
    }
}

int main(void) {
    SmokeDetector sd;

    ipcon_create(&sd.ipcon);

    while(true) {
        int rc = ipcon_connect(&sd.ipcon, HOST, PORT);
        if(rc < 0) {
            fprintf(stderr, "Could not connect to brickd: %d\n", rc);
            // TODO: sleep 1s
            continue;
        }
        break;
    }

    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_ENUMERATE,
                            (void (*)(void))cb_enumerate,
                            (void *)&sd);

    ipcon_register_callback(&sd.ipcon,
                            IPCON_CALLBACK_CONNECTED,
                            (void (*)(void))cb_connected,
                            (void *)&sd);

    while(true) {
        int rc = ipcon_enumerate(&sd.ipcon);
        if(rc < 0) {
            fprintf(stderr, "Could not enumerate: %d\n", rc);
            // TODO: sleep 1s
            continue;
        }
        break;
    }

    printf("Press key to exit\n");
    getchar();
    ipcon_destroy(&sd.ipcon);
    return 0;
}