TVHeadEnd auf dem Raspberry installieren

TVHeadEnd ist ein TV Streaming Server fuer Linux Systeme. Er unterstützt DVB-S, DVB-S2, DVB-C, DVB-T, ATSC, IPTV  sowie Analoges Video. Alle Einstellungen werden über ein Webinterface vorgenommen. Die bereit gestellten Daten können dann beispielsweise mit Kodi auf ein TV Gerät gebracht werden.

In diesem Beispiel werden die DVB-S2 Signale eines Megasat IP Server 3 eingebunden und für KODI oder VLC aufbereitet.

PI vorbereiten zur Installation

Wie immer bei einem Linux System ist es sinnvoll zu beginn das System auf den aktuellen Stand zu bringen.

sudo apt-get update
sudo apt-get upgrade

TVHeadEnd installieren

Die Installation ist denkbar einfach.

sudo apt-get install tvheadend

Bestaetigen Sie nun den Download der Pakete mit „Y“. Im Bereich der TVHeadEnd Konfiguration werden Sie noch nach einem Admin Namen und einem Passwort gefragt. Geben Sie beides ein und bestätigen Sie dies.
Nach diesen Angaben läuft die Installation noch weiter.

TVHeadEnd testen

Ist die Installation abgeschlossen finden Sie das Webfront von TVHeadEnd unter folgendem Link:

http://<IP DES RASPBERRY>:9981

Die jeweilige IP des PI bekommen Sie über den Befehl > ifconfig

Weiter geht es mit der Konfiguration von TVHeadEnd.

E-Mails versenden mit sSMTP

Es gib immer mal wieder die Situation mit einem Linux System E-Mails zu versenden. Das können zu hohe Temperaturen der Festplatte, störungen von Cronjob oder eine IP, die aufgrund von falschen Login versuchen auffällt. Natürlich ist dieser Service auch bei anderen Diensten wie FHEM interessant. 

Man könnte sich eine E-Mail senden lassen wenn ein bestimmter Bewegungsmelder aktiv wird.  Oder die Temperatur der Gefriertruhe steigt wegen einem defekt. Hier kann auch sSMTP einspringen und eine E-Mail versenden. Die Einsatzmöglichkeiten sind unglaublich vielfältig.

Und diese Möglichkeiten gibt es mit sSMTP mit relativ wenig Aufwand.

Installation von sSMTP

Wie immer, wer sein Linux liebt der updatet als erstes 🙂

apt-get update && apt-get upgrade -V

Nun kann man die beiden Pakete von sSMTP installieren

apt-get install ssmtp mailutils

Nun wird als erster Schritt die generelle Einrichtung von sSMTP vorgenommen

nano /etc/ssmtp/ssmtp.conf

Gebt in diesem File euer E-Mail Konto sowie die entsprechenden Ports eures E-Mail Anbieters an.

root=DEINE@EMAIL.DE
mailhub=DEIN-EMAIL.SERVER.DE:PORT(ist bei jedem Anbieter anders!)
hostname=localhost
UseTLS=Yes
UseSTARTTLS=Yes
AuthUser=DEIN-EMAIL-LOGIN-BENUTZER
AuthPass=DEIN-EMAIL-PASSWORT
FromLineOverride=yes

Wer mehr zu den einzelnen Eintragen wissen möchte kann sich gerne mal die man von sSMTP ansehen.  Linux versteht man nur durch lesen :).

man ssmtp

Nun müssen wir Linux nur noch mitteilen welche Benutzer eigentlich sSMTP nutzen dürfen.

Dazu öffnen wir das Benutzer File des sSMTP

nano /etc/ssmtp/revaliases

In diesem File müssen alle Benutzer des jeweiligen Linux System eingetragen werden die gerne eine Email versenden möchten. Bitte achtet drauf auch hier die richtigen PORTs mit anzugeben.

root:DEINE@EMAIL-ADRESSE.DE:smtp.EMAIL-ADRESSE.de:587 (Je nach Anbeiter)
www-data:WWW-USER@SEINE-EMAIL.DE:smtp.IRGENDWAS.DE:PORT

Zum Schluss schicken wir nun mal eine Test E-Mail 😀

echo "Mail-Inhalt" | mail -s "Betreff" EMAIL@AN-DIE-GESENDET-WERDEN-SOLL.DE

So das waren die Grundlagen. Nun ist dein Linux System in der Lage E-Mails zu versenden. War ja eigentlich gar nicht so viel Aufwand!

SDS011 – Feinstaubsensor

Mit dem Modul SDS011 kann der Feinstaub in der Luft per Particulate Matter (PM) „gezählt“ werden. Es werden Partikelgrößen in den Bereichen PM 2.5 und PM 10 registriert.

Die Kommunikation mit dem Arduino geht per Serieller Verbindung. Der Sensor kann per HEX Befehl gesteuert oder Schlafen gelegt werden. Dies ist auch bei Einsatz als „Messsonde“ auch sinnvoll da die Lebensdauer der Laserdiode auf 8000 h geschätzt wird. Mehr Infos gibt es Datenblatt am Ende des Beitrages.

Ein einfacher Arduino Sketch zum auslesen der Daten sollte als Basis für weitere Entwicklungen ausreichend sein. Hierfür bietet sich die Library von Paweł Kołodziejczyk an die hier zu finden ist.



Nachfolgend eine Ausgabe im Arduino Seriellen Monitor.

 
#include "SdsDustSensor.h"
 
int rxPin = 6;
int txPin = 7;
SdsDustSensor sds(rxPin, txPin);
 
void setup() {
  Serial.begin(9600);
  sds.begin();
 
  Serial.println(sds.queryFirmwareVersion().toString()); // prints firmware version
  Serial.println(sds.setActiveReportingMode().toString()); // ensures sensor is in 'active' reporting mode
  Serial.println(sds.setCustomWorkingPeriod(10).toString()); // sensor sends data every 3 minutes
}
 
void loop() {
  PmResult pm = sds.readPm();
  if (pm.isOk()) {
    Serial.print("PM2.5 = ");
    Serial.print(pm.pm25);
    Serial.print(", PM10 = ");
    Serial.println(pm.pm10);
 
    // if you want to just print the measured values, you can use toString() method as well
    Serial.println(pm.toString());
  } else {
    // notice that loop delay is set to 5s (sensor sends data every 3 minutes) and some reads are not available
    Serial.print("Could not read values from sensor, reason: ");
    Serial.println(pm.statusToString());
  }
 
  delay(5000);
}

Nachfolgend noch das Datenblatt von Nova Fitness Co., Ltd..

Arduino Relaiskarte per MQTT Befehl steuern

Die Hausautomatisierung benötigt sehr viele Aktoren. In diesem Bereich gibt es sehr viele Produkte der großen Hersteller. Leider auch entsprechend teuer. Hier möchte ich ein Projekt vorstellen das über einen Arduino (WeMos D1) eine Relaiskarte ansteuert. zur Steuerung verwende ich das MQTT Protokoll. Natürlich alles per WiFi. Es wird nur noch die Versorgungsspannung und der Laststromkreis benötig.

5 Minuten Probeaufbau

Gesteuert wird nun das Relais A mit folgendem Befehl:

Ebenso einfach geht das Aus schalten des Relais

Relais B reagiert folglich auf

Das Relais ist nun im kompletten Heimnetzwerk erreichbar.

Code Snipes

WeMos D1 per WiFI Daten in mySQL schreiben

Mit dem nachfolgendem Sketch ist der WeMos D1 in der Lage Messdaten in eine mySQL Datenbank zu senden.

Das eigentliche schreiben der Daten erfolgt mit dem Aufrufen einer PHP Datei in Form eines GET Befehls.

<?php
/*
 
Daten per GET in eine mySQL Datenbank schrieben
 
by Tobias Guggenberger
guggenberber.me
 
*/
 
// POD Verbindung zur Datenbank
$datenbank_name 		= "NAME_DATENBANK";
$datenbank_username 	= "USER";
$datenbank_passwort		= "PASS";
 
// Datenbankverbindung aufbauen
$pdo = new PDO('mysql:host=localhost;dbname='.$datenbank_name, $datenbank_username, $datenbank_passwort);
 
// Neuen Datensatz schreiben
$neuer_datensatz = array();
$neuer_datensatz['WERT1'] = time();
$neuer_datensatz['WERT2'] = $_GET['temperatur'];
$neuer_datensatz['WERT3'] = $_GET['sensor'];
$statement = $pdo->prepare("INSERT INTO TABELLE (wert1, wert2, wert3) VALUES (:wert1, :wert2, :wert3)");
$statement->execute($neuer_datensatz);
?>

Der passende Sketch sieht so aus:

 
#include <ESP8266WiFi.h>
const char* ssid     = "SSID";      // SSID
const char* password = "PASS";      // Password
const char* host = "SERVER_DB";  // IP ServeP
const int   port = 80;            // Port
const int   watchdog = 5000;        // Schreibefruenz
unsigned long previousMillis = millis(); 
 
void setup() {
  Serial.begin(115200);
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
 
  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
 
void loop() {
  delay(5000);  
    unsigned long currentMillis = millis();
 
  if ( currentMillis - previousMillis > watchdog ) {
    previousMillis = currentMillis;
    WiFiClient client;
 
    if (!client.connect(host, port)) {
      Serial.println("connection failed");
      return;
    }
 
    String url = "/arduino/FILE_zum-SCHREIBEN.php?wert1=wer1&usw";
    url += String(millis());
    url += "&ip=";
    url += WiFi.localIP().toString();
 
    // Envoi la requete au serveur - This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
      if (millis() - timeout > 5000) {
        Serial.println(">>> Client Timeout !");
        client.stop();
        return;
      }
    }
      while(client.available()){
      String line = client.readStringUntil('\r');
      Serial.print(line);
    }
  }
}

Projektdatein zum Download

Der Arduino und das Ethernet Shield

Inhaltsverzeichnis WordPress

Von Haus aus kommt der Arduino Uno ohne eine Netzwerklösung daher. Dies kann man recht einfach mit einem Arduino Ethernet Shield aendern. Einfach aufstecken und der Arduino hat eine LAN Anschluss.

Damit nun der Arduino in deinem Netzwerk funktioniert bedarf es noch einem Sketch.

Dank dem gut Dokumentierten Arduino Projekt gibt es auch gute Ethernet Libray’s.

Arduino LAN Sketch

/*
 Web Server
  */
 
// Diese beide Libraries sind erforderlich
#include <SPI.h>
#include <Ethernet.h>
 
/*
Hier die MAC Adresse des Shields eingeben
Meistens gibt es einen Aufkleber auf der Rückseite des Shields
*/
byte mac[] = { 
 0x90, 0xA2, 0xDA, 0x00, 0xFB, 0x80 };
 
/*
Nun noch eine freie IP auf aus deinem Netzwerk angeben. Dazu
ist es am einfachsten die IP des Rechners auszulesen.
ifconfig ist hier das Stichwort.
*/ 
IPAddress ip(192,168,1,177);
 
// Ethernet Library als Server initialisieren
// Verwendet IPAdress und den Port 80 für http
EthernetServer server(80);
 
void setup() {
 /*
Serielle Kommunikation starten 
*/
 Serial.begin(9600);
 
 // Ethernet Verbindung und Server starten
 Ethernet.begin(mac, ip);
 server.begin();
 Serial.print("Server gestartet. IP: ");
 // IP des Arduino-Servers ausgeben
 Serial.println(Ethernet.localIP());
}
 
 
void loop() {
/*
server.available() schaut, ob ein Client verfügbar ist und Daten
an den Server schicken möchte. Gibt dann eine Client-Objekt zurück, sonst false
*/
 EthernetClient client = server.available();
 
// Wenn es einen Client gibt, dann...
 if (client) {
 Serial.println("Neuer Client");

/*
Jetzt solange Zeichen lesen, bis eine leere Zeile empfangen wurde
HTTP Requests enden immer mit einer leeren Zeile 
*/
 boolean currentLineIsBlank = true;
 // Solange Client verbunden 
 while (client.connected()) {
 // client.available() gibt die Anzahl der Zeichen zurück, die zum Lesen
 // verfügbar sind
 if (client.available()) {
 // Ein Zeichen lesen und am seriellen Monitor ausgeben
 char c = client.read();
 Serial.write(c);
 // In currentLineIsBlank merken wir uns, ob diese Zeile bisher leer war.
/*
Wenn die Zeile leer ist und ein Zeilenwechsel (das \n) kommt,
dann ist die Anfrage zu Ende und wir können antworten
*/
 if (c == '\n' && currentLineIsBlank) {
 // HTTP Header 200 an den Browser schicken
 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println("Connection: close"); // Verbindung wird nach Antwort beendet
 client.println("Refresh: 2"); // Seite alle 25 Sekunden neu abfragen
 client.println();
 // Ab hier berginnt der HTML-Code, der an den Browser geschickt wird
 client.println("<!DOCTYPE HTML>");
 client.println("<html>");
 client.print("Analogpin 0: <b>");
 client.print(analogRead(A0));
 client.println("</b><br />"); 
 client.println("</html>");
 break;
 }
 if (c == '\n') {
 // Zeilenwechsel, also currentLineIsBlack erstmal auf True setzen
 currentLineIsBlank = true;
 } 
 else if (c != '\r') {
 // Zeile enthält Zeichen, also currentLineIsBlack auf False setzen
 currentLineIsBlank = false;
 }
 }
 }
 // Kleine Pause
 delay(1);
 // Verbindung schliessen
 client.stop();
 Serial.println("Verbindung mit Client beendet.");
 Serial.println("");
 }
}

DynDNS Verbindung zu einer Fritz!Box 7490

In diesem Tutorial möchte ich einen Fernzugriff auf einen Apache Server einrichten der sich in meinem Heimnetzwerk befindet.

Da sich die IP meines Routers (Fritz!Box) immer wieder ändert, benötigt man einen Dienst der bei einer Anfrage aus dem www auf die aktuelle IP des Routers weiterleitet.

Im Prinzip gibt meine Fritz!Box jede Änderung der Provider IP an diesen Dienst weiter. Dieser stellt eine www Adresse zur Verfügung die nun immer auf die aktuelle Router IP weiterleitet. 

Aktuell verwende ich für diesen Dienst den kostenlosen Service von www.noip.com.

www.noip.com

Einfach auf Sign Up klicken und einen kostenlosen Account anlegen. Das dauert nicht länger als 3 Minuten.


Gib nun im Eingabefeld deine E Mail Adresse und ein Passwort ein. Bei Hostname kannst du dir eine Domain überlegen, von der in Zukunft der Dienst auf deinen Router weiterleiten soll.

Nun kommt die Fritzbox an die Reihe. 

Stelle als erstes die erweiterte Ansicht der Fritzbox an. Bei meinem Modell der 7490 findet man diese Funktion rechts oben bei den drei (Blinden- ) Punkten.


Geh nun in den Bereich Internet / Freigaben.


Nun müssen wir ein Gerät im Netzwerk aussuchen das in Zukunft „Ferngewartet“ werden soll. Klicke dafür auf „Gerät für Freigabe hinzufügen


Nun das entsprechende Netzwerkgerät auswählen.


Nun fehlt nur noch die Portfreigabe.Klick dazu auf „Neue Freigabe„.


In meinem Fall benötige ich nur die Portfreigabe für HTTP. Hier musst du die Freigaben an dein Projekt anpassen.




Nachdem nun alle Eingaben abgespeichert sind ist das entsprechende Netzwerkgerät uber das www zu erreichen.