[Sammlung] SAS Version 6.00 - Kleine Toolbox für Sensoren - Bash-Scripts, Python, C++

Sidebar Sidebar
Upgrade 3CX to v18 and get it hosted free!
JL3

JL3

Aktives Mitglied
Mitglied seit
4 Dez 2010
Beiträge
1,995
Punkte für Reaktionen
8
Punkte
38
In diesem Thread nun einige Scripts bzw. C++Source-Codes als kleine Helferlein für Sensorenabfragen etc.:

DS18B20 (USB)
Temperatursensor DS18B20 an Interface AT90USB162
Mit diesem Programm wird der Temperatursensor gelesen. Je nach Parameter wird der Wert in 1/10 Grad (245 = 24,5°C) oder optisch aufbereitet mit weiteren Informationen zu Sensor und Interface angezeigt. Hilfe mit Option -h oder --help.
Aktualisiert: Nun für mehrere angeschlossene DS18B20 an AT90USB162 geeignet.

Bibliotheken / Pakete:
apt-get install libusb-1.0-0 libusb-1.0-0-dev xserver-xorg-dev

tempusb.cpp
Code: 
/*
    ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
    ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
    ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
        ║ ║   ║     ║ │  C++             │  tempusb.cpp                   │
    ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
    ┌─────────────────┤  Temperatur USB                                   │
    │  Info:          ╘═══════════════════════════════════════════════════╡
    ├─────────────────────────────────────────────────────────────────────┤
    │  USB-Temperatursensor Lesemodul für Temperatursensor DS18B20 an     │
    │  Interface AT90USB162                                               │
    │                                                                     │
    │ ┌───────────────┐                                                   │
    ├─┤ Compilierung: ├───────────────────────────────────────────────────┤
    │ ╘═══════════════╛                                                   │
    │  g++ tempusb.cpp -otempusb -lusb-1.0                                │
    │  ./tempusb                                                          │
    ╘═════════════════════════════════════════════════════════════════════╛
*/

#include <cstdlib>
#include <cstdio>
#include <locale>
#include <iostream>
#include <libusb-1.0/libusb.h>

using namespace std;

int main(int argc, char *argv[]) {
/******************************/
    char ver[]                        = "1.00.0312";
    char cpr[]                        = "(C)2016 BlueDragon";

    libusb_device_handle* handle;
    libusb_device* dev;
    
    struct libusb_device_descriptor desc;
    struct libusb_config_descriptor *config;

    int vid                            = 0x16c0;
    int pid                            = 0x0480;
    int interface                    = 0;
    int in                            = 0x81;
    int leng                        = 64;
    unsigned int timeout            = 5000;

    int res;
    int kernelDriverDetached;
    int numBytes;
    int bus;
    int devadr;
    unsigned char buffer[leng];
    char temp[10];
    char* p;
    int snr;
    int itemp;
    float ftemp;
    bool fehler                        = false;
    int i                            = 0;

    string help1                    = "-h";
    string help2                    = "--help";
    string info1                    = "info";
    string info2                    = "-i";
    string info3                    = "--info";
    string info4                    = "-info";
    string info5                    = "i";
    
    setlocale(LC_ALL, "de_DE");

    if (argc > 1 && ( argv[1] == help1 || argv[1] == help2)) {
        fprintf(stdout, "┌──────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m tempusb Version %s %s \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├──────────────────────────────────────────────┤\n");
        fprintf(stdout, "│ \e[1m\e[44mSyntax:\e[0m                                      │\n");
        fprintf(stdout, "│  tempusb [SENSOR#]                           │\n");
        fprintf(stdout, "│        - liefert den Wert des USB-Temperatur-│\n");
        fprintf(stdout, "│          sensors als 1/10 Grad Celsius       │\n");
        fprintf(stdout, "│          (z. B. 245 = 24,5°C)                │\n");
        fprintf(stdout, "│          wird keine Sensornummer angegeben,  │\n");
        fprintf(stdout, "│          wird die erste eingelesene ausge-   │\n");
        fprintf(stdout, "│          geben                               │\n");
        fprintf(stdout, "│  tempusb -i|i|--info|-info|info [SENSOR#]    │\n");
        fprintf(stdout, "│        - zeigt den Wert aufbereitet als Grad │\n");
        fprintf(stdout, "│          Celsius mit einer Kommastelle und   │\n");
        fprintf(stdout, "│          Informationen zum USB-Temperatur-   │\n");
        fprintf(stdout, "│          sensor an                           │\n");
        fprintf(stdout, "│          wird keine Sensornummer angegeben,  │\n");
        fprintf(stdout, "│          wird die erste eingelesene ausge-   │\n");
        fprintf(stdout, "│          geben                               │\n");
        fprintf(stdout, "│  tempusb -h|--help                           │\n");
        fprintf(stdout, "│        - diese Hilfe                         │\n");
        fprintf(stdout, "└──────────────────────────────────────────────┘\n");
        return 1;
    }

    res = libusb_init(0);
    if (res != 0) {
        fehler = true;
        fprintf(stderr, "Fehler: Initialisierung libusb. (ggf. apt-get install libusb-1.0-0 libusb-1.0-0-dev)\n");
        return 1;
    }

    handle = libusb_open_device_with_vid_pid(NULL, vid, pid);
    if (!handle) {
        fehler = true;
        fprintf(stderr, "Fehler: Gerätezugriff; Gerät %04X:%04X Interface AT90USB162 mit USB-Temperatursensor DS18B20 nicht gefunden.\n",
            vid,
            pid);
        return 1;
    }

    dev = libusb_get_device(handle);
    
    if (argc > 2) {
        snr = (int)*argv[argc - 1] - 48;
    }
    else {
        snr = 1;
    }
    
    do {
        res = libusb_get_device_descriptor(dev, &desc);

        if (res != 0) {
            fehler = true;
            fprintf(stderr, "Fehler: Lesen der Geräte-Beschreibung fehlgeschlagen.\n");
            return 1;
        }

        res = libusb_get_config_descriptor(dev, 0, &config);
        if (res != 0) {
            fehler = true;
            fprintf(stderr, "Fehler: Lesen der Konfigurations-Beschreibung fehlgeschlagen.\n");
            return 1;
        }

        if (libusb_kernel_driver_active(handle, interface)) {
            res = libusb_detach_kernel_driver(handle, interface);
            if (res == 0) {
                kernelDriverDetached=1;
            }
            else {
                fehler = true;
                fprintf(stderr, "Fehler: Kerneltreibertrennung.\n");
                return 1;
            }
        }

        res = libusb_claim_interface(handle, interface);
        if (res != 0) {
            fehler = true;
            fprintf(stderr, "Fehler: Interfacebelegung für Zugriff.\n");
            return 1;
        }

        res = libusb_interrupt_transfer(handle, in, buffer, leng, &numBytes, timeout);
        
        if (snr > (int)buffer[0] || snr < 1) {
            snr = 1;
        }
                
    } while ( fehler == false && (int)buffer[1] != snr);

    if (res == 0) {
        if (numBytes == leng) {
            itemp = buffer[4] + buffer[5] * 256;
            if (itemp > 32768) {
                itemp -= 65536;
            }
            sprintf(temp, "%d",
                itemp);
        }
        else {
            fehler = true;
            fprintf(stderr, "Warnung: Empfangen %d Byte(s), anstelle von %d Bytes.\n",
                numBytes,
                leng);
            if (numBytes >= 6) {
                itemp = buffer[4] + buffer[5] * 256;
                if (itemp > 32768) {
                    itemp -= 65536;
                }
                sprintf(temp, "%d",
                    itemp);
            }
        }
    }
    else
    {
        fehler = true;
        fprintf(stderr, "Fehler: Datenübertragung.\n");
    }

    res = libusb_release_interface(handle, interface);
    if (res != 0) {
        fehler = true;
        fprintf(stderr, "Fehler: Interfacefreigabe.\n");
    }

    bus = libusb_get_bus_number(dev);
    devadr = libusb_get_device_address(dev);

    if (kernelDriverDetached) {
        libusb_attach_kernel_driver(handle, interface);
    }

    libusb_exit(0);

    ftemp = itemp;
    ftemp = ftemp /10;
    if (argc > 1 && (argv[1] == info1 || argv[1] == info2 || argv[1] == info3 || argv[1] == info4 || argv[1] == info5)) {
        fprintf(stdout, "┌──────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m tempusb Version %s %s \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├─────────────────────────────────────┬────────┤\n");
        fprintf(stdout, "│ USB-Temperatursensor DS18B20        │\e[36m\e[1m%5.1f°C\e[0m │\n",
            ftemp);
        fprintf(stdout, "│ an Interface AT90USB162             │        │\n");
        fprintf(stdout, "├─────────────────────────────────────┼────────┤\n");
        fprintf(stdout, "│ Gerät \e[33m%04X:%04X\e[0m   Bus:\e[33m%3u\e[0m   Dev:\e[33m%3u\e[0m │        │\n",
            desc.idVendor,
            desc.idProduct,
            bus,devadr);
        fprintf(stdout, "│ MaxPower:\e[33m%4umA\e[0m      Interfaces:\e[33m%3u\e[0m │        │\n",
            config->MaxPower * 2,
            config->bNumInterfaces);
        fprintf(stdout, "├─────────────────────────────────────┼────────┤\n");
        fprintf(stdout, "│ \e[33m0x%02X\e[0m(IN):\e[33m%3u\e[0m Byte(s) von\e[33m%3u\e[0m Byte(s) │ ",
            in,
            numBytes,
            leng);
        if (fehler) {
            fprintf(stdout, "\e[31m\e[1mFehler\e[0m │\n");
        }
        else {
            fprintf(stdout, "\e[32m\e[1mOk    \e[0m │\n");
        }
        fprintf(stdout, "├─────────────────────────────────────┼────────┤\n");
        for (i = 0; i < numBytes; i = i + 8) {
            fprintf(stdout, "│ Daten (%02d): \e[33m%02X %02X %02X %02X %02X %02X %02X %02X\e[0m │        │\n",
                i,
                buffer[0 + i],
                buffer[1 + i],
                buffer[2 + i],
                buffer[3 + i],
                buffer[4 + i],
                buffer[5 + i],
                buffer[6 + i],
                buffer[7 + i]);
        }
        fprintf(stdout, "├─────────────────────────────────────┼────────┤\n");
        fprintf(stdout, "│ Anzahl Sensoren: \e[33m% 3d\e[0m Sensor #:  \e[33m% 3d\e[0m │        │\n",
            buffer[0],
            buffer[1]);
        fprintf(stdout, "│ Sensor-ID:  \e[33m%02X %02X %02X %02X %02X %02X %02X %02X\e[0m │        │\n",
            buffer[8],
            buffer[9],
            buffer[10],
            buffer[11],
            buffer[12],
            buffer[13],
            buffer[14],
            buffer[15]);
        fprintf(stdout, "└─────────────────────────────────────┴────────┘\n");
    }
    else {
        fprintf(stdout, "%s\n",
            temp);
    }

    return 0;
}
-DS18B20 (GPIO)
Temperatursensor DS18B20 direkt an GPIO
Mit diesem Programm wird der Temperatursensor gelesen. Je nach Parameter wird der Wert in 1/10 Grad (245 = 24,5°C) oder optisch aufbereitet mit weiteren Informationen zu Sensor und Interface angezeigt. Hilfe mit Option -h oder --help.

Bibliotheken / Pakete:
apt-get install wiringPi bc

tempgpio (bash)
Code: 
#!/bin/bash
#
# ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
# ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
# ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
#     ║ ║   ║     ║ │  SAS-Core-Sys    │  tempgpio                      │
# ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
# ┌─────────────────┤  Temperatur DS18B20 GPIO                          │
# │  Info:          ╘═══════════════════════════════════════════════════╡
# ├─────────────────────────────────────────────────────────────────────┤
# │  Temperatursensor DS18B20 GPIO Wert-Ausgabe                         │
# ╘═════════════════════════════════════════════════════════════════════╛
#
VER=6.00.0018
#
SASSYS=/usr/local/bin/sas
#
XSPC="                                        "
XDEVICE=$1$XSPC
XDEVICE=${XDEVICE:0:15}
#
if [ "$1" == "--help" ] || [ "$1" == "-h" ]; then
 echo -e "┌───────────────────────────────────┐"
 echo -e "│\e[45m\e[1m SensorAndSwitch Version $VER \e[0m│"
 echo -e "├───────────────────────────────────┤"
 echo -e "│ \e[1m\e[44mSyntax:\e[0m                           │"
 echo -e "│  tempgpio DEVICE                  │"
 echo -e "│        - liefert den Wert des     │"
 echo -e "│          CPU-Temperatursensors    │"
 echo -e "│          als 1/10 Grad Celsius    │"
 echo -e "│          (Z. B. 489 = 48,9°C)     │"
 echo -e "│          DEVICE ist z.B.          │"
 echo -e "│          28-000002af52ca          │"
 echo -e "│  tempgpio DEVICE info|i           │"
 echo -e "│        - zeigt den Wert aufbe-    │"
 echo -e "│          reitet als Grad Celsius  │"
 echo -e "│          mit einer Kommastelle an │"
 echo -e "│  tempgpio -h|--help               │"
 echo -e "│        - diese Hilfe              │"
 echo -e "└───────────────────────────────────┘"
else
 if [ -e /sys/bus/w1/devices/$1/w1_slave ]; then
  TEMPGPIO=$(echo "scale=0;$(cat /sys/bus/w1/devices/$1/w1_slave | grep  -E -o ".{0,0}t=.{0,5}" | cut -c 3-)/100" | bc)
  if [ "$2" == "info" ] || [ "$2" == "i" ]; then
   XTEMPGPIO=$(echo "scale=1;$TEMPGPIO / 10" | bc)
   XTEMPGPIO=$(echo $XTEMPGPIO | sed 's/\./,/g')
   XTEMPGPIO=$(printf "%2.1f" $XTEMPGPIO)
   echo -e "┌───────────────────────────────────┐"
   echo -e "│\e[45m\e[1m SensorAndSwitch Version $VER \e[0m│"
   echo -e "├──────────────────────────┬────────┤"
   echo -e "│ Temperatursensor DS18B20 │ \e[36m\e[1m$XTEMPGPIO°C\e[0m │"
   echo -e "│ $XDEVICE          │        │"
   echo -e "└──────────────────────────┴────────┘"
  else
   echo $TEMPGPIO
  fi
 else
  if [ "$2" == "info" ] || [ "$2" == "i" ]; then
   echo -e "┌───────────────────────────────────┐"
   echo -e "│\e[45m\e[1m SensorAndSwitch Version $VER \e[0m│"
   echo -e "├──────────────────────────┬────────┤"
   echo -e "│ Temperatursensor DS18B20 │ \e[31m\e[1m -,-°C\e[0m │"
   echo -e "│ $XDEVICE          │        │"
   echo -e "└──────────────────────────┴────────┘"
  else
   echo ""
  fi
 fi
fi
#EOF
-DHT11, DHT22 und AM2302 (GPIO wiringPi)
Temperatur-/Luftfeuchtigkeitssensor Lesemodul für Sensor DHT11, DHT22 und AM2302 an GPIO wiringPi
Mit diesem Programm wird Temperatur und Luftfeuchtigkeit gelesen. Je nach Parameter wird der Wert für Temperatur, Luftfeuchtigkeit oder optisch aufbereitet mit weiteren Informationen zum Sensor angezeigt. Hilfe mit Option -h oder --help.

Bibliotheken / Pakete:
apt-get install wiringPi

tempfeuchtwpi.cpp
Code: 
/*
    ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
    ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
    ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
        ║ ║   ║     ║ │  C++             │  tempfeuchtwpi.cpp             │
    ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
    ┌─────────────────┤  Temperatur/Luftfreuchtigkeit GPIO wiringPi       │
    │  Info:          ╘═══════════════════════════════════════════════════╡
    ├─────────────────────────────────────────────────────────────────────┤
    │  Temperatur-/Luftfeuchtigkeitssensor Lesemodul für Sensor DHT11,    │
    │  DHT22 und AM2302 an GPIO wiringPi                                  │
    │                                                                     │
    │ ┌───────────────┐                                                   │
    ├─┤ Compilierung: ├───────────────────────────────────────────────────┤
    │ ╘═══════════════╛                                                   │
    │  g++ tempfeuchtwpi.cpp -otempfeuchtwpi -lwiringPi                   │
    │  ./tempfeuchtwpi                                                    │
    ╘═════════════════════════════════════════════════════════════════════╛
*/

#define MAXTIMINGS                85

#include <cstdio>
#include <iostream>
#include <wiringPi.h>
#include <unistd.h>
#include <algorithm>
#include <cstring>

using namespace std;

int main(int argc, char *argv[]) {
/******************************/
    char ver[]                        = "1.00.0187";
    char cpr[]                        = "(C)2016 BlueDragon";

    string help1                    = "-h";
    string help2                    = "--help";
    string info1                    = "i";
    string info2                    = "info";
    string DHT11                    = "dht11";
    string DHT22                    = "dht22";
    string AM2302                    = "am2302";
    string modust                    = "t";
    string modusf                    = "f";
    string modush                    = "h";
    string modustf                    = "tf";
    string modusth                    = "th";
    char device[6];
    bool fehler                        = false;
    float temp                        = 0;
    float hum                        = 0;
    int itemp                        = 0;
    int ihum                        = 0;

    int data[5]                        = { 0, 0, 0, 0, 0 };
    int counter                        = 0;
    int laststate                    = HIGH;
    int j                            = 0;
    int i                            = 0;
    unsigned int l                  = 0;

    if (getuid() != 0) {
        fprintf(stderr, "Fehler: Nur als root starten!\n");
        return -1;
    }
    if (wiringPiSetup() == -1) {
        fprintf(stderr, "Fehler: Initialisierung schlug fehl!\n");
        return 1;
    }

    if (argc > 1 && ( argv[1] == help1 || argv[1] == help2)) {
        fprintf(stdout, "┌────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m tempfeuchtwpi Version %s %s \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├────────────────────────────────────────────────────┤\n");
        fprintf(stdout, "│ \e[1m\e[44mSyntax:\e[0m                                            │\n");
        fprintf(stdout, "│  tempfeuchtwpi dht11|dht22|am2302 t|f|h|tf|th PIN# │\n");
        fprintf(stdout, "│        - liefert den entsprechenden Wert des       │\n");
        fprintf(stdout, "│          Sensors als Zahl in 1/10 Grad Celsius bzw.│\n");
        fprintf(stdout, "│          Luftfeuchtigkeitswert (z. B. 248 bzw. 560 │\n");
        fprintf(stdout, "│          entspräche 24,8°C bzw. 56%%)               │\n");
        fprintf(stdout, "│  tempfeuchtwpi dht11|dht22|am2302 i|info PIN#      │\n");
        fprintf(stdout, "│        - zeigt die Werte aufbereitet mit weiteren  │\n");
        fprintf(stdout, "│          Informationen zum Sensor an               │\n");
        fprintf(stdout, "│  tempfeuchtwpi -h|--help                           │\n");
        fprintf(stdout, "│        - diese Hilfe                               │\n");
        fprintf(stdout, "└────────────────────────────────────────────────────┘\n");
        return 1;
    }

    if (argc <= 3) {
        fprintf(stderr, "Fehler: Bitte gültigen Gerätetyp, Ausgabemodus und gültige Pin-Nummer angeben.\n");
        return -1;
    }
    int pin = atoi(argv[3]);

    if (pin < 0) {
        fprintf(stderr, "Fehler: Bitte gültigen Gerätetyp, Ausgabemodus und gültige Pin-Nummer angeben.\n");
        return -1;
    }

    data[0] = data[1] = data[2] = data[3] = data[4] = 0;
 
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
    delay(18);
    digitalWrite(pin, HIGH);
    delayMicroseconds(40);
    pinMode(pin, INPUT);
 
    for (i = 0; i < MAXTIMINGS; i++) {
        counter = 0;
        while (digitalRead(pin) == laststate) {
            counter++;
            delayMicroseconds(1);
            if (counter == 255) {
                break;
            }
        }
        laststate = digitalRead(pin);
        if (counter == 255) {
            break;
        }
        if ((i >= 4) && (i % 2 == 0)) {
            data[j / 8] <<= 1;
            if (counter > 16) {
                data[j / 8] |= 1;
            }
            j++;
        }
    }

    strcpy(device,argv[1]);
    for (l = 0; l < 6; l++) {
        device[l] = toupper(device[l]);
    }
    
    if (argv[1] == DHT11) {
        hum = data[0] * 1;
        temp = data[2] * 1;
    }
    else {
        hum = data[0] * 256 + data[1];
        hum /= 10.0;
        temp = (data[2] & 0x7F)* 256 + data[3];
        temp /= 10.0;
        if (data[2] & 0x80) {
            temp *= -1;
        }
    }

    if ((j >= 40) && (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF))) {
        fehler = false;
    }
    else {
        fprintf(stderr, "Fehler: Daten Lesefehler!\n");
        fehler = true;
    }

    if (!fehler && (argv[2] == modust)) {
        itemp = (int)temp * 10 + 0.5;
        fprintf(stdout, "%d\n", itemp);
        return 0;
    }
    if (!fehler && (argv[2] == modusf || argv[2] == modush)) {
        ihum = (int)hum * 10 + 0.5;
        fprintf(stdout, "%d\n", ihum);
        return 0;
    }
    if (!fehler && (argv[2] == modustf || argv[2] == modusth)) {
        itemp = (int)temp * 10 + 0.5;
        ihum = (int)hum * 10 + 0.5;
        fprintf(stdout, "%d %d\n", itemp, ihum);
        return 0;
    }
    if (argv[2] == info1 || argv[2] == info2) {
        setlocale(LC_ALL, "de_DE");
        fprintf(stdout, "┌────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m tempfeuchtwpi Version %s %s \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├───────────────────────────────────────────┬────────┤\n");
        if (!fehler) {
            fprintf(stdout, "│ Temperatur                                │\e[36m\e[1m%5.1f°C\e[0m │\n",
                temp);
            fprintf(stdout, "│ Luftfeuchtigkeit                          │\e[36m\e[1m%5.1f%% \e[0m │\n",
                hum);
        }
        else {
            fprintf(stdout, "│ Temperatur                                │\e[36m\e[1m  -,-°C\e[0m │\n",
                temp);
            fprintf(stdout, "│ Luftfeuchtigkeit                          │\e[36m\e[1m  -,-%% \e[0m │\n",
                hum);
        }
        fprintf(stdout, "├───────────────────────────────────────────┼────────┤\n");
        fprintf(stdout, "│ Sensor: \e[33m%6s\e[0m  GPIO:  wiringPi-Pin#: \e[33m%02d\e[0m  │        │\n",
            device,
            pin);
        fprintf(stdout, "├───────────────────────────────────────────┼────────┤\n");
        fprintf(stdout, "│ Daten:  (\e[33m%05d\e[0m):\e[33m0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\e[0m  │ ",
            j, 
            data[0], 
            data[1], 
            data[2], 
            data[3], 
            data[4]);
        if (fehler) {
            fprintf(stdout, "\e[31m\e[1mFehler\e[0m │\n");
        }
        else {
            fprintf(stdout, "\e[32m\e[1mOk    \e[0m │\n");
        }
        fprintf(stdout, "└───────────────────────────────────────────┴────────┘\n");
    }
    if (fehler == true) {
        return -1;
    }

    return 0;
}
-BH1750FVI (GPIO I2C)
Lichtsensor Lesemodul für Sensor BH1750 an GPIO I2C
Mit diesem Programm wird die Helligkeit in Lux gelesen. Je nach Parameter wird der Wert ggf. optisch aufbereitet mit weiteren Informationen zum Sensor angezeigt. Hilfe mit Option -h oder --help.

Bibliotheken / Pakete:
apt-get install i2c-tools wiringPi

lichti2c.cpp
Code: 
/*
    ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
    ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
    ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
        ║ ║   ║     ║ │  C++             │  lichti2c.cpp                  │
    ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
    ┌─────────────────┤  Lichtstärke in Lux GPIO I2C                      │
    │  Info:          ╘═══════════════════════════════════════════════════╡
    ├─────────────────────────────────────────────────────────────────────┤
    │  Lichsensor Lesemodul für Sensor BH1750FVI an GPIO I2C              │
    │                                                                     │
    │ ┌───────────────┐                                                   │
    ├─┤ Compilierung: ├───────────────────────────────────────────────────┤
    │ ╘═══════════════╛                                                   │
    │  g++ lichti2c.cpp -olichti2c -lwiringPi                             │
    │  ./lichti2c                                                         │
    ╘═════════════════════════════════════════════════════════════════════╛
*/

#include <cstdio>
#include <iostream>
#include <wiringPiI2C.h>
#include <unistd.h>
#include <algorithm>
#include <cstring>

using namespace std;

int main(int argc, char *argv[]) {
/******************************/
    char ver[]                        = "1.00.0017";
    char cpr[]                        = "(C)2016 BlueDragon";
    
    string help1                    = "-h";
    string help2                    = "--help";
    string info1                    = "i";
    string info2                    = "info";
    int adresse                        = 0x23;
    int handle;
    int word;
    int lux;

    if (argc > 1 && ( argv[1] == help1 || argv[1] == help2)) {
        fprintf(stdout, "┌────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m lichti2c Version %s %s      \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├────────────────────────────────────────────────────┤\n");
        fprintf(stdout, "│ \e[1m\e[44mSyntax:\e[0m                                            │\n");
        fprintf(stdout, "│  lichti2c I2CDEV#                                  │\n");
        fprintf(stdout, "│        - liefert den entsprechenden Wert des       │\n");
        fprintf(stdout, "│          Sensors als Zahl in Lux                   │\n");
        fprintf(stdout, "│  lichti2c I2CDEV# i|info                           │\n");
        fprintf(stdout, "│        - zeigt die Werte aufbereitet mit weiteren  │\n");
        fprintf(stdout, "│          Informationen zum Sensor an               │\n");
        fprintf(stdout, "│  lichti2c -h|--help                                │\n");
        fprintf(stdout, "│        - diese Hilfe                               │\n");
        fprintf(stdout, "└────────────────────────────────────────────────────┘\n");
        return 1;
    }

    if (argc > 1 && argv[1] != info1 && argv[1] != info2) {
        adresse = atoi(argv[1]);
    }

    handle = wiringPiI2CSetup(adresse);
    if (handle == -1) {
        fprintf(stderr, "Fehler: Initialisierung schlug fehl!\n");
        return 1;
    }
    
    wiringPiI2CWrite(handle,0x10);
    sleep(1);
    word = wiringPiI2CReadReg16(handle,0x00);
    lux = ((word & 0xff00)>>8) | ((word & 0x00ff)<<8);
    
    if ((argc == 2  && (argv[1] == info1 || argv[1] == info2)) || (argc > 2 && (argv[2] == info1 || argv[2] == info2))) {
        fprintf(stdout, "┌────────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m lichti2c Version %s %s          \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├─────────────────────────────────────────────┬──────────┤\n");
        fprintf(stdout, "│ Lichtstärke                                 │\e[36m\e[1m%5.0d Lux\e[0m │\n",
            lux);
        fprintf(stdout, "├─────────────────────────────────────────────┼──────────┤\n");
        fprintf(stdout, "│ Sensor: BH1750 GPIO I2C-DevAddr: \e[33m%3d (0x%02X)\e[0m │          │\n",
            adresse,
            adresse);
        fprintf(stdout, "└─────────────────────────────────────────────┴──────────┘\n");
    }
    else {
        fprintf(stdout, "%d\n", lux);
    }
    
    return 0 ;
}
 
Zuletzt bearbeitet:
DS3231 (GPIO I2C)
RTC (Batteriegepufferte Echtzeituhr) DS3231 an GPIO I2C
Hierfür wird kein eigenes Programm benötigt.

Bibliotheken / Pakete:
apt-get install i2c-tools

/etc/init.d/starten (wenn SaS V6.xx installiert ist, gibt es bereits diese Datei)
Code: 
#! /bin/sh
# /etc/init.d/starten
#
### BEGIN INIT INFO
# Provides: Starten
# Required-Start: $local_fs
# Required-Stop: $local_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# X-Start-Before: rsyslog
# X-Stop-After: rsyslog
# Short-Description: Starten
# Description: Startroutine beim Hochfahren
### END INIT INFO
#
echo "Script /etc/init.d/starten"
echo "=========================="
case "$1" in
start)
echo "Start..."
[COLOR=#008000][B]echo ds3231 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
hwclock -s[/B][/COLOR]
cp /var/www/sas/tmpbackup/*.d* /var/www/sas/tmp
chown www-data:www-data /var/www/sas/tmp/*.d*
chmod 0777 /var/www/sas/tmp/*.d*
echo "Fertig!"
exit 0
;;
stop)
echo "Stop..."
[B][COLOR=#008000]hwclock -w
[/COLOR][/B]exit 0
;;
*)
echo "Benutzung: /etc/init.d/starten {start|stop}"
exit 1
;;
esac
exit 0
 
LCD2004 20x4 (HD44780) I2C (GPIO I2C)
LCD-Display 20 Zeichen x 4 Zeilen an GPIO I2C
Mit diesem Programm wird das Display über die I2C-Schnittstelle angesteuert und zeigt im Beispiel unten die Uhrzeit mit Sekunden, Wochentag, Datum, Temperatur (als Wert und grafisch), sowie die Lichtintensität (als Wert und grafisch) an. Die Abfrage der Sensoren ist über Threads gelöst und somit asynchron. Die Anzeige ist im Programm auch auf andere Sensorwerte abänderbar. Hilfe mit Option -h oder --help.
lcd2004i2c.jpg

Bibliotheken / Pakete:
apt-get install i2c-tools wiringPi

lcd2004i2c
Code: 
/*
    ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
    ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
    ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
        ║ ║   ║     ║ │  C++             │  lcd2004i2c.cpp                │
    ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
    ┌─────────────────┤  LCD 20x4 Display GPIO I2C                        │
    │  Info:          ╘═══════════════════════════════════════════════════╡
    ├─────────────────────────────────────────────────────────────────────┤
    │  LCD 20x4 Display GPIO I2C                                          │
    │                                                                     │
    │ ┌───────────────┐                                                   │
    ├─┤ Compilierung: ├───────────────────────────────────────────────────┤
    │ ╘═══════════════╛                                                   │
    │  g++ lcd2004i2c.cpp -olcd2004i2c -lwiringPi -lpthread               │
    │  ./lcd2004i2c                                                       │
    ╘═════════════════════════════════════════════════════════════════════╛
*/

#include <cstdio>
#include <iostream>
#include <wiringPiI2C.h>
#include <wiringPi.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <algorithm>
#include <cstring>
#include <stdexcept>
#include <time.h>
#include <pthread.h>
#include <math.h>

#define LCD_DATA                    1            // Mode - Sending data
#define LCD_CMD                        0            // Mode - Sending command

#define LINE1                        0x80        // 1st line
#define LINE2                        0xC0        // 2nd line
#define LINE3                        0x94        // 3rd line
#define LINE4                        0xD4        // 4th line

#define LCD_BACKLIGHT                0x08        // On
#define LCD_BACKLIGHT_OFF            0x00        // Off

#define ENABLE                        0b00000100    // Enable bit

#define N                            80

using namespace std;

void lcdInit(void);
void lcdByte(int bits, int mode);
void lcdToggleEnable(int bits);
void typeInt(int i);
void typeFloat(float myFloat);
void lcdLOC(int line);                            //move cursor
void lcdCLR(void);                                // clr LCD return home
void typeLn(const char *s);
void typeChar(char val);
void *exectemp(void *partemp);
void *execlx(void *parlx);

char ver[]                            = "1.00.0248";
char cpr[]                            = "(C)2016 BlueDragon";

string exec(const char* cmd);
string ergebnis;
char const * wt[7]                    = { "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa" };
int adresse                            = 0x27;
int handle;                                        // seen by all subroutines

float temp                            = 0;
float tempkorr                        = 0;
int lx                                = 0;

int main(int argc, char *argv[]) {
/******************************/
    char sl[20];    
    string help1                    = "-h";
    string help2                    = "--help";
    string info1                    = "i";
    string info2                    = "info";
    string addr                        = "-addr";
    string tkorr                    = "-tkorr";
    int word;
    int status;

    if (argc > 1 && ( argv[1] == help1 || argv[1] == help2)) {
        fprintf(stdout, "┌────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m lcd2004i2c Version %s %s    \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├────────────────────────────────────────────────────┤\n");
        fprintf(stdout, "│ \e[1m\e[44mSyntax:\e[0m                                            │\n");
        fprintf(stdout, "│  lcd2004i2c [-addr I2CDEV#] [-tkorr WERT]          │\n");
        fprintf(stdout, "│        - I2CDEV# - Gibt die LCD-Display Adresse an │\n");
        fprintf(stdout, "│        - WERT - Gibt den Korrekturwert für die     │\n");
        fprintf(stdout, "│                 Temperaturanzeige an (z. B. -1.3)  │\n");
        fprintf(stdout, "│  lcd2004i2c -h|--help                              │\n");
        fprintf(stdout, "│        - diese Hilfe                               │\n");
        fprintf(stdout, "└────────────────────────────────────────────────────┘\n");
        return 1;
    }

    tempkorr = 0;
    for (int i = 0; i < argc; i++) {
        if (argv[i] == addr) {
            adresse = atoi(argv[i+1]);
        }
        if (argv[i] == tkorr) {
            tempkorr = atof(argv[i+1]);
        }
    }

    handle = wiringPiI2CSetup(adresse);
    if (handle == -1) {
        fprintf(stderr, "Fehler: Initialisierung schlug fehl!\n");
        return 1;
    }
    
    setlocale(LC_ALL, "de_DE");

    lcdInit();

    fprintf(stdout, "  ┌────────────────────┐\n");
    fprintf(stdout, "  │\e[45m\e[1mlcd2004i2c   Version\e[0m│\n");
    fprintf(stdout, "  │\e[45m\e[1m           %s\e[0m│\n",
        ver);
    fprintf(stdout, "  │\e[45m\e[1m  %s\e[0m│\n",
        cpr);
    fprintf(stdout, "  ├────────────────────┤\n");
    fprintf(stdout, "  │\e[44m\e[1m                    \e[0m│\n");
    fprintf(stdout, "  │\e[44m\e[1m                    \e[0m│\n");
    fprintf(stdout, "  │\e[44m\e[1m                    \e[0m│\n");
    fprintf(stdout, "  │\e[44m\e[1m                    \e[0m│\n");
    fprintf(stdout, "  └────────────────────┘\n");

    pthread_t p1, p2;

    pthread_create (&p1, NULL, exectemp, NULL);
    pthread_create (&p2, NULL, execlx, NULL);

    while(1) {
        time_t Zeitstempel;
        tm *nun;
        char str[N];
        Zeitstempel = time(0);
        nun = localtime(&Zeitstempel);

        fprintf(stdout, "\033[5A");
        fprintf(stdout, "  │\e[44m\e[1m====================\e[0m│\n");
        fprintf(stdout, "  │\e[44m\e[1mT% 5.1f°C %02d:%02d.%02d %s\e[0m│\n",
            temp,
            nun->tm_hour,
            nun->tm_min,
            nun->tm_sec,
            wt[nun->tm_wday]
            );
        fprintf(stdout, "  │\e[44m\e[1mL% 5dlx  %02d:%02d.%04d\e[0m│\n",
            lx,
            nun->tm_mday,
            nun->tm_mon+1,
            nun->tm_year+1900
            );
        fprintf(stdout, "  │\e[44m\e[1m====================\e[0m│\n");
        fprintf(stdout, "\n");
        
        lcdLOC(LINE1);
        float tb = temp;
        if (tb<0) {tb=0;}
        if (tb>40) {tb=40;}
        int ti = tb;
        tb = tb / 40 * 20;
        ti = tb;
        char tr = (tb - ti) * 10 / 4;
        tr = tr + 5;
        char ts = 8;
        char tn = 5;
        for (int j = 1; j < 20; j++) {
            if (j <= ti) {
                typeChar(ts);
            }
            else {
                typeChar(tn);
            }
            if (j == ti) {
                typeChar(tr);
            }
        }

        lcdLOC(LINE2);
        sprintf(sl, "%c% 5.1f%c  %02d:%02d.%02d %s", 
            0x01, temp, 0x02,
            nun->tm_hour,
            nun->tm_min,
            nun->tm_sec,
            wt[nun->tm_wday]
            );
        typeLn(sl);

        lcdLOC(LINE3);
        sprintf(sl, "%c% 5d%c   %02d.%02d.%04d", 
            0x03, lx, 0x04,
            nun->tm_mday,
            nun->tm_mon+1,
            nun->tm_year+1900
            );
        typeLn(sl);

        lcdLOC(LINE4);
        float lxb = lx;
        lxb=pow(lxb,0.1264)*32-32+2;
        if (lxb<0) {lxb=0;}
        if (lxb>100) {lxb=100;}
        int lxi = lxb;
        lxb = lxb / 100 * 20;
        lxi = lxb;
        char lxr = (lxb - lxi) * 10 / 4;
        lxr = lxr + 5;
        char lxs = 8;
        char lxn = 5;
        for (int i = 1; i < 20; i++) {
            if (i <= lxi) {
                typeChar(lxs);
            }
            else {
                typeChar(lxn);
            }
            if (i == lxi) {
                typeChar(lxr);
            }
        }
    }

    return 0;
}

void *exectemp(void *partemp) {
/***************************/
    while (1) {
        temp = (float)atoi(exec("/usr/local/bin/sas/tempusb 2>/dev/null").c_str()) / 10 + tempkorr;
        sleep(1);
    }
    return NULL;
}

void *execlx(void *parlx) {
/***********************/
    while (1) {
        lx = atoi(exec("/usr/local/bin/sas/lichti2c 2>/dev/null").c_str());
    }
    return NULL;
}

void typeFloat(float myFloat) {
/***************************/
    // float to string
    char buffer[20];
    sprintf(buffer, "%4.2f",  myFloat);
    typeLn(buffer);
}

void typeInt(int i) {
/*****************/
    // int to string
    char array1[20];
    sprintf(array1, "%d",  i);
    typeLn(array1);
}

void lcdCLR(void) {
/***************/
    // clr lcd go home loc 0x80
    lcdByte(0x01, LCD_CMD);
    lcdByte(0x02, LCD_CMD);
}

void lcdLOC(int line) {
/*******************/
    // go to location on LCD
    lcdByte(line, LCD_CMD);
}

void typeChar(char val) {
/*********************/
    // out char to LCD at current position
    lcdByte(val, LCD_DATA);
}

void typeLn(const char *s) {
/************************/
    // this allows use of any size string
    while ( *s ) lcdByte(*(s++), LCD_DATA);

}

void lcdByte(int bits, int mode) {
/******************************/
    //Send byte to data pins
    // bits = the data
    // mode = 1 for data, 0 for command
    int bits_high;
    int bits_low;
    // uses the two half byte writes to LCD
    bits_high = mode | (bits & 0xF0) | LCD_BACKLIGHT ;
    bits_low = mode | ((bits << 4) & 0xF0) | LCD_BACKLIGHT ;

    // High bits
    wiringPiI2CReadReg8(handle, bits_high);
    lcdToggleEnable(bits_high);

    // Low bits
    wiringPiI2CReadReg8(handle, bits_low);
    lcdToggleEnable(bits_low);
}

void lcdToggleEnable(int bits) {
/****************************/
    // Toggle enable pin on LCD display
    delayMicroseconds(50);
    wiringPiI2CReadReg8(handle, (bits | ENABLE));
    delayMicroseconds(50);
    wiringPiI2CReadReg8(handle, (bits & ~ENABLE));
    delayMicroseconds(50);
}

void lcdInit() {
/************/
    // Initialise display
    lcdByte(0x33, LCD_CMD); // Initialise
    lcdByte(0x32, LCD_CMD); // Initialise
    lcdByte(0x06, LCD_CMD); // Cursor move direction
    lcdByte(0x0C, LCD_CMD); // 0x0F On, Blink Off
    lcdByte(0x50, LCD_CMD); // Data length, number of lines, font size
    lcdByte(0x01, LCD_CMD); // Clear display
    delayMicroseconds(50);
    // setting the 8 User-characters
    lcdByte(0x40, LCD_CMD);
    // 0
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    // 1
    lcdByte(0b00100, LCD_DATA);
    lcdByte(0b01010, LCD_DATA);
    lcdByte(0b01011, LCD_DATA);
    lcdByte(0b01010, LCD_DATA);
    lcdByte(0b01010, LCD_DATA);
    lcdByte(0b10001, LCD_DATA);
    lcdByte(0b10001, LCD_DATA);
    lcdByte(0b01110, LCD_DATA);
    // 2
    lcdByte(0b01000, LCD_DATA);
    lcdByte(0b10100, LCD_DATA);
    lcdByte(0b01000, LCD_DATA);
    lcdByte(0b00011, LCD_DATA);
    lcdByte(0b00100, LCD_DATA);
    lcdByte(0b00100, LCD_DATA);
    lcdByte(0b00011, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    // 3
    lcdByte(0b00100, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b01110, LCD_DATA);
    lcdByte(0b11011, LCD_DATA);
    lcdByte(0b01110, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00100, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    // 4
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10010, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    // 4
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    // 5
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b10000, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    // 6
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10100, LCD_DATA);
    lcdByte(0b10100, LCD_DATA);
    lcdByte(0b10100, LCD_DATA);
    lcdByte(0b10100, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    // 7
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    lcdByte(0b00000, LCD_DATA);
    lcdByte(0b10101, LCD_DATA);
    // end
    lcdByte(0x00, LCD_CMD);
}

string exec(const char* cmd) {
/**************************/
    char buffer[128];
    std::string result = "";
    FILE* pipe = popen(cmd, "r");
    if (!pipe) throw std::runtime_error("popen() failed!");
    try {
        while (!feof(pipe)) {
        if (fgets(buffer, 128, pipe) != NULL)
            result += buffer;
        }
    } 
    catch (...) {
        pclose(pipe);
        throw;
    }
    pclose(pipe);
    return result;
}
 
Zuletzt bearbeitet:
BME280 (GPIO I2C)
Lesemodul für Sensor BME280 an GPIO I2C
Mit diesem Programm wird die Temperatur, Luftfeuchtigkeit und der Luftdruck gelesen. Je nach Parameter wird der Wert ggf. optisch aufbereitet mit weiteren Informationen zum Sensor angezeigt. Hilfe mit Option -h oder --help.

Bibliotheken / Pakete:
apt-get install i2c-tools wiringPi

bme280i2c.cpp
Code: 
/*
    ╔═══╗ ╔═══╗ ╔═══╗ ┌───────────────────────────────────────────────────┐
    ║     ║   ║ ║     │  SensorAndSwitch (C)2014-16 Bluedragon            │
    ╚═══╗ ╠═══╣ ╚═══╗ ├──────────────────┬────────────────────────────────┤
        ║ ║   ║     ║ │  C++             │  bme280i2c.cpp                 │
    ╚═══╝ ╝   ╚ ╚═══╝ ├──────────────────┴────────────────────────────────┤
    ┌─────────────────┤  Sensor BME280 GPIO I2C                           │
    │  Info:          ╘═══════════════════════════════════════════════════╡
    ├─────────────────────────────────────────────────────────────────────┤
    │  Temperatur-/Luftfeuchtigkeitssensor Lesemodul für Sensor BME280    │
    │  an GPIO I2C                                                        │
    │                                                                     │
    │ ┌───────────────┐                                                   │
    ├─┤ Compilierung: ├───────────────────────────────────────────────────┤
    │ ╘═══════════════╛                                                   │
    │  g++ bme280i2c.cpp -obme280i2c -lwiringPi                           │
    │  ./bme280i2c                                                        │
    ╘═════════════════════════════════════════════════════════════════════╛
*/

#include <cstdio>
#include <iostream>
#include <wiringPiI2C.h>
#include <wiringPi.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <algorithm>
#include <cstring>
#include <stdexcept>
#include <time.h>
#include <pthread.h>
#include <math.h>

double BME280_compensate_P_double(int adc_P,int dig_P1, int dig_P2, int dig_P3, int dig_P4, int dig_P5, int dig_P6, int dig_P7, int dig_P8, int dig_P9);
double BME280_compensate_H_double(int adc_H, int dig_H1, int dig_H2, int dig_H3, int dig_H4, int dig_H5, int dig_H6);
double BME280_compensate_T_double(int adc_T, int dig_T1, int dig_T2, int dig_T3);
unsigned short int swap_bytes(unsigned short int input);

using namespace std;

char ver[]                            = "1.00.0025";
char cpr[]                            = "(C)2016 BlueDragon";

int adresse                            = 0x76;
int handle;                                        // seen by all subroutines

int word;
int status;
int t_fine;

int adc_T,dig_T1,dig_T2,dig_T3;
int adc_H,dig_H1,dig_H2,dig_H3,dig_H4,dig_H5,dig_H6;
int adc_P,dig_P1,dig_P2,dig_P3,dig_P4,dig_P5,dig_P6,dig_P7,dig_P8,dig_P9;

float temperature,humidity,pressure;

int main(int argc, char *argv[]) {
/******************************/
    string help1                    = "-h";
    string help2                    = "--help";
    string info1                    = "i";
    string info2                    = "info";
    string addr                        = "-addr";

    if (argc > 1 && ( argv[1] == help1 || argv[1] == help2)) {
        fprintf(stdout, "┌────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m bme280i2c Version %s %s     \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├────────────────────────────────────────────────────┤\n");
        fprintf(stdout, "│ \e[1m\e[44mSyntax:\e[0m                                            │\n");
        fprintf(stdout, "│  bme280i2c [-addr I2CDEV#]                         │\n");
        fprintf(stdout, "│        - I2CDEV# - Gibt die I2C-Adresse an         │\n");
        fprintf(stdout, "│        - liefert die entsprechenden Werte des      │\n");
        fprintf(stdout, "│          Sensors als Fließkommazahlen in           │\n");
        fprintf(stdout, "│          Temperatur (°C), Feuchtigkeit (%%) und     │\n");
        fprintf(stdout, "│          Luftdruck (hPa);                          │\n");
        fprintf(stdout, "│          22.123456 11.345678 1025.234563           │\n");
        fprintf(stdout, "│  bme280i2c i|info [-addr I2CDEV#]                  │\n");
        fprintf(stdout, "│        - zeigt die Werte aufbereitet mit weiteren  │\n");
        fprintf(stdout, "│          Informationen zum Sensor an               │\n");
        fprintf(stdout, "│  bme280i2c -h|--help                               │\n");
        fprintf(stdout, "│        - diese Hilfe                               │\n");
        fprintf(stdout, "└────────────────────────────────────────────────────┘\n");
        return 1;
    }

    for (int i = 0; i < argc; i++) {
        if (argv[i] == addr) {
            adresse = atoi(argv[i+1]);
        }
    }

    handle = wiringPiI2CSetup(adresse);
    if (handle == -1) {
        fprintf(stderr, "Fehler: Initialisierung schlug fehl!\n");
        return 1;
    }
    
    wiringPiI2CWrite(handle,0xf2);    // activate humidity measurement
    wiringPiI2CWrite(handle,0x01);    // activate humidity measurement
    wiringPiI2CWrite(handle,0xf4);    // activate temperature measurement
    wiringPiI2CWrite(handle,0x27);    // activate temperature measurement

    dig_P1=wiringPiI2CReadReg16(handle, 0x8e);
    dig_P2=wiringPiI2CReadReg16(handle, 0x90);
    dig_P3=wiringPiI2CReadReg16(handle, 0x92);
    dig_P4=wiringPiI2CReadReg16(handle, 0x94);
    dig_P5=wiringPiI2CReadReg16(handle, 0x96);
    dig_P6=wiringPiI2CReadReg16(handle, 0x98);
    dig_P7=wiringPiI2CReadReg16(handle, 0x9a);
    dig_P8=wiringPiI2CReadReg16(handle, 0x9c);
    dig_P9=wiringPiI2CReadReg16(handle, 0x9f);
    dig_T1=wiringPiI2CReadReg16(handle, 0x88);
    dig_T2=wiringPiI2CReadReg16(handle, 0x8a);
    dig_T3=wiringPiI2CReadReg16(handle, 0x8c);
    dig_H1=wiringPiI2CReadReg8(handle, 0xa1);
    dig_H2=wiringPiI2CReadReg16(handle, 0xe1);
    dig_H3=wiringPiI2CReadReg8(handle, 0xe3);
    dig_H4=((wiringPiI2CReadReg8(handle, 0xe4))<<4)+(wiringPiI2CReadReg8(handle, 0xe5)&0x0f);
    dig_H5=((wiringPiI2CReadReg8(handle, 0xe5)&0xf0)>>4)+(wiringPiI2CReadReg8(handle, 0xe6)>>4);
    dig_H6=wiringPiI2CReadReg8(handle, 0xe7);

    adc_P=((swap_bytes(wiringPiI2CReadReg16(handle, 0xF7)))<<4)+(((wiringPiI2CReadReg8(handle ,0xF9))>>4)&0x0F);
    adc_T=((swap_bytes(wiringPiI2CReadReg16(handle, 0xFA)))<<4)+(((wiringPiI2CReadReg8(handle ,0xFC))>>4)&0x0F);
    adc_H=swap_bytes(wiringPiI2CReadReg16(handle, 0xFD));

    temperature=BME280_compensate_T_double(adc_T,dig_T1,dig_T2,dig_T3);
    humidity=BME280_compensate_H_double(adc_H,dig_H1,dig_H2,dig_H3,dig_H4,dig_H5,dig_H6);
    pressure=BME280_compensate_P_double(adc_P,dig_P1,dig_P2,dig_P3,dig_P4,dig_P5,dig_P6,dig_P7,dig_P8,dig_P9) / 1.25651798484727 / 100; //Korr.

    if (argc > 1  && (argv[1] == info1 || argv[1] == info2)) {
        setlocale(LC_ALL, "de_DE");
        fprintf(stdout, "┌──────────────────────────────────────────────────────────┐\n");
        fprintf(stdout, "│\e[45m\e[1m bme280i2c Version %s %s           \e[0m│\n",
            ver,
            cpr);
        fprintf(stdout, "├─────────────────────────────────────────────┬────────────┤\n");
        fprintf(stdout, "│ Temperatur                                  │\e[36m\e[1m% 9.3f°C \e[0m│\n",
            temperature);
        fprintf(stdout, "│ Luftfeuchtigkeit                            │\e[36m\e[1m% 9.3f%%  \e[0m│\n",
            humidity);
        fprintf(stdout, "│ Luftdruck                                   │\e[36m\e[1m% 9.3fhPa\e[0m│\n",
            pressure);
        fprintf(stdout, "├─────────────────────────────────────────────┼────────────┤\n");
        fprintf(stdout, "│ Sensor: BME280 GPIO I2C-DevAddr: \e[33m%3d (0x%02X)\e[0m │            │\n",
            adresse,
            adresse);
        fprintf(stdout, "└─────────────────────────────────────────────┴────────────┘\n");
    }
    else {
        fprintf(stdout, "%f %f %f\n",
            temperature,
            humidity,
            pressure);
    }

    return 0;
}

unsigned short int swap_bytes(unsigned short int input) {
/*****************************************************/
    return (((input & 0xff) << 8) | ((input >> 8) & 0xff));
}

double BME280_compensate_P_double(int adc_P,int dig_P1, int dig_P2, int dig_P3, int dig_P4, int dig_P5, int dig_P6, int dig_P7, int dig_P8, int dig_P9) {
/*****************************************************************************************************************************************************/
    double var1, var2, p;
    var1 = ((double)t_fine) - 128000.0;
    var2 = var1 * var1 * ((double)dig_P6) / 32768.0;
    var2 = var2 + var1 * ((double)dig_P5);
    var2 = (var2/4.0)+(((double)dig_P4) * 65536.0);
    var1 = (((double)dig_P3) * var1 * var1 / 524288.0 + ((double)dig_P2) * var1) / 524288.0;
    var1 = (1.0 + var1 / 32768.0)*((double)dig_P1);
    if (var1 == 0.0) {
        return 0;
    }
    p = 1048576.0 - (double)adc_P;
    p = (p - (var2 / 4096.0)) * 6250.0 / var1;
    var1 = ((double)dig_P9) * p * p / 2147483648.0;
    var2 = p * ((double)dig_P8) / 32768.0;
    p = p + (var1 + var2 + ((double)dig_P7)) / 16.0;
    return p;
}

double BME280_compensate_H_double(int adc_H, int dig_H1, int dig_H2, int dig_H3, int dig_H4, int dig_H5, int dig_H6) {
/******************************************************************************************************************/
    double var_H;
    var_H = (((double)t_fine) - 76800.0);
    var_H = (adc_H - (((double)dig_H4) * 64.0 + ((double)dig_H5) / 16384.0 * var_H)) * (((double)dig_H2) / 65536.0 * (1.0 + ((double)dig_H6) / 67108864.0 * var_H * (1.0 + ((double)dig_H3) / 67108864.0 * var_H)));
    var_H = var_H * (1.0 - ((double)dig_H1) * var_H / 524288.0);
    if (var_H > 100.0)
        var_H = 100.0;
    else if (var_H < 0.0)
        var_H = 0.0;
    return var_H;
}

double BME280_compensate_T_double(int adc_T, int dig_T1, int dig_T2, int dig_T3) {
/******************************************************************************/
    double var1, var2, T;
    var1 = (((double)adc_T)/16384.0 - ((double)dig_T1)/1024.0) * ((double)dig_T2);
    var2 = ((((double)adc_T)/131072.0 - ((double)dig_T1)/8192.0) * (((double)adc_T)/131072.0 - ((double) dig_T1)/8192.0)) * ((double)dig_T3);
    t_fine = (int)(var1 + var2);
    T = (var1 + var2) / 5120.0;
    return T;
}
 
Zuletzt bearbeitet:
Die einzelnen Sensorausleseprogramme werden nicht mehr weiterentwickelt.
-
Stattdessen gibt es das C++-Programm sassensor, welches alle hier aufgeführten Sensoren lesen kann, ob per GPIO, wiringPi oder I2C oder Gerätedatei.

Der Link zum Programm und zum Source-Code in C++: sassensor.zip

Bibliotheken / Pakete:
apt-get install libusb-1.0-0 libusb-1.0-0-dev xserver-xorg-dev
apt-get install i2c-tools wiringPi

C++ Source-Code Compilierung:
g++ sassensor.cpp -osassensor -lusb-1.0 -lwiringPi

Das Programm wird in Zukunft auch mit weiteren Sensorleseroutinen erweitert.

Code: 
┌────────────────────────────────────────────────────────┐
│ sassensor Version 1.00.0447 (C)2016 BlueDragon         │
├────────────────────────────────────────────────────────┤
│ Syntax:                                                │
│                                                        │
│  sassensor [-d|-device DEVICE] [-c|-connect TYP]       │
│     [-i|-ident IDENTNR] [i|info]                       │
│                                                        │
│     - DEVICE = Der abzufragende Sensor:                │
│       am2302    = Temperatur (°C)                      │
│                   Feuchtigkeit (%)                     │
│       bh1750fvi = Helligkeit (lx)                      │
│       bme280    = Temperatur (°C)                      │
│                   Feuchtigkeit (%)                     │
│                   Luftdruck (hPa)                      │
│       dht11     = Temperatur (°C)                      │
│                   Feuchtigkeit (%)                     │
│       dht22     = Temperatur (°C)                      │
│                   Feuchtigkeit (%)                     │
│       ds18b20   = Temperatur (°C)                      │
│       raspi (*) = CPU-Temperatur (°C)                  │
│                   CPU-Frequenz (kHz)                   │
│                   Core-Frequenz (kHz)                  │
│                   Core-Spannung (V)                    │
│                   CPU-Auslastung (%)                   │
│                   RAM Speicherplatz Gesamt (B)         │
│                   RAM Speicherplatz Frei (B)           │
│                   Root Speicherplatz Gesamt (B)        │
│                   Root Speicherplatz Frei (B)          │
│       ds18b20   = Temperatur (°C)                      │
│                                                        │
│     - TYP = Anschlussart:                              │
│       usb       = USB-Anschluss                        │
│       i2c       = I2C-Verbindung (GPIO)                │
│       wpi       = wiringPi 1wire (GPIO)                │
│       gpio      = GPIO direkt (Pin)                    │
│       os (*)    = GPIO direkt (Gerätedatei) | OS       │
│                                                        │
│     - IDENTNR = Identifikation des Sensors:            │
│       Device#   = bei USB                              │
│       I2C#      = bei I2C                              │
│       Pin#      = bei wiringPi und GPIO direkt         │
│       Gerätedateiname                                  │
│                 = bei OS-Erkennung                     │
│       default ist automatisch das erste Device bzw.    │
│       die Standardeinstellung des Devicetyps           │
│                                                        │
│     - info = Ausführliche, optisch aufbereitete        │
│              Anzeige der Sensorinformationen, sonst    │
│              nur Werte mit drei Kommastellen Genauig-  │
│              keit in Kurzform getrennt durch eine      │
│              Leerstelle                                │
│      (*) default                                       │
│                                                        │
│  sassensor -h|--help                                   │
│                                                        │
│     - diese Hilfe                                      │
└────────────────────────────────────────────────────────┘

- - - Aktualisiert - - -

Update sassensor auf V 1.00.0430

Historie:

  • Korr. BME280
 
Zuletzt bearbeitet:
Update sassensor auf V 1.00.0447

Historie:

  • Device raspi mit mehr Sensorwerten und CPU-Auslastung, die "realtime" ermittelt wird.
  • default-Werte für die Parameter -d, -c und -i
 
Update sassensor auf V 1.00.0500

Historie:

  • kleine Bugfixes
 
Um antworten zu können musst du eingeloggt sein.

Zurzeit aktive Besucher

Gesamt: 397 (Mitglieder: 32, Gäste: 365)

Neueste Beiträge

Statistik des Forums

Themen
244,812
Beiträge
2,218,812
Mitglieder
371,498
Neuestes Mitglied
Scorp1337
Holen Sie sich 3CX - völlig kostenlos!
Verbinden Sie Ihr Team und Ihre Kunden Telefonie Livechat Videokonferenzen

Gehostet oder selbst-verwaltet. Für bis zu 10 Nutzer dauerhaft kostenlos. Keine Kreditkartendetails erforderlich. Ohne Risiko testen.

3CX
Für diese E-Mail-Adresse besteht bereits ein 3CX-Konto. Sie werden zum Kundenportal weitergeleitet, wo Sie sich anmelden oder Ihr Passwort zurücksetzen können, falls Sie dieses vergessen haben.
Ihr E-Mail-Adresse verifizieren

Ihr E-Mail-Adresse verifizieren

Wir haben Ihnen eine E-Mail geschickt. Klicken Sie auf die Schaltfläche im E-Mail-Text, um Ihre E-Mail-Adresse zu verifizieren – (Können Sie diese nicht finden können, dann überprüfen Sie Ihren Spam-Ordner).

IPPF im Überblick

Neueste Beiträge

Direktlinks Telefonanlage

Website-Sponsoren

3CX sponsor
KONTAKTIEREN SIE UNS BEI INTERESSE
| Style by ThemeHouse
XenPorta 2 PRO © Jason Axelrod of 8WAYRUN
Oben Unten
Zurück