Raspberry Pi Archives - Technik - Blogbasis.net https://technik.blogbasis.net/category/linux/raspberry-pi Die Basis des freien Wissens – Technik Fri, 13 May 2016 19:09:20 +0000 de hourly 1 https://wordpress.org/?v=6.8.1 RaspberryPi + DS18B20 = ThermometerPi https://technik.blogbasis.net/raspberrypi-ds18b20-thermometerpi-13-05-2016 https://technik.blogbasis.net/raspberrypi-ds18b20-thermometerpi-13-05-2016#respond Fri, 13 May 2016 18:34:21 +0000 http://technik.blogbasis.net/?p=1393 Ich bin vor einigen Wochen über einen Blogpost gestoßen, in dem erklärt wurde, wie man aus einem RaspberryPi und einem Wärmesensor (DS18B20) sich ein eigenes Thermometer bauen kann. Dieser Idee bin ich nachgegangen und möchte in diesem Blogpost beschreiben, welche Tweaks dabei nötig waren.

Irgendwo auf Twitter oder einem anderen Medium habe ich ein Link zu dem Blogpost „[Tutorial] DS18S20 Temperatur Sensor an einem Raspberry Pi“ gefunden. Das hat mich so sehr fasziniert, dass ich das nachbauen wollte.

Dazu bestellte ich mir auf Amazon zunächst 10 solcher Sensoren mit entsprechend langem Kabel und Abdichtung: 10 x DS18B20 Digitale Temperaturfühler für ~15€. Dazu kamen noch ein paar 4.7k Ohm Widerstände. Nach ein paar Tagen war alles in meinem Briefkasten. Angeblich kann man sich von Maximintegrated ein kostenloses Sample zuschicken lassen. Allerdings kam bei mir bisher nichts an, vielleicht auch einfach Pech oder ein Fehler auf meiner Seite.

Aufbau

Für die Verkabelung des Sensors mit dem RaspberryPi bin ich den Schritten in dem oben genannten Blogpost gefolgt. Für mehr Informationen möchte ich dorthin verweisen.

Quelle: https://kopfkino.irosaurus.com/tutorial-ds18s20-temperatur-sensor-an-einem-raspberry-pi/

Quelle: https://kopfkino.irosaurus.com/tutorial-ds18s20-temperatur-sensor-an-einem-raspberry-pi/

Wichtig ist scheinbar nur, dass man den GPIO-Pin 4 nutzt. Ich habe es selbst nicht mit anderen GPIO-Pins probiert. Wenn es bei euch mit anderen klappt, bitte einen kurzen Kommentar hinterlassen.

Konfiguration

Ich habe auf meinem RaspberryPi Archlinux mit einem halbwegs aktuellen Kernel am Laufen. Das führte dazu, dass die weiteren Schritte in dem oben genannten Blogpost nicht funktionierten. Nachdem ich ein wenig recherchiert habe, kam ich zu einer klein wenig modifizierten Lösung.

Zunächst muss man in die /boot/config.txt folgende Zeile anhängen:

dtoverlay=w1-gpio,gpiopin=4,pullup=on

Danach muss man noch Kernelmodule laden. Dies erledigt man am Besten direkt beim Booten, in dem man folgendes in die Datei /etc/modules einträgt:

w1-gpio pullup=1
w1_therm

Nach einem Neustart sollte der Sensor unter  „/sys/bus/w1/devices/<sensor-id>“ verfügbar sein. Mit folgendem Einzeiler kriegt man die aktuelle Temperatur heraus:

$> cat /sys/bus/w1/devices/28-041621eb50ff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g"
21687

Automatisierung & Webseite

Ich wollte mir eine kleine grafische Ansicht über den Temperaturverlauf bauen. Dazu entschied ich mich, die Daten von zwei Sensoren (1x Indoor, 1x Outdoor) alle 30 Sekunden auszulesen und in eine SQLite3-Datenbank zu schreiben.

Dazu habe ich zwei Scripte unter „/opt/thermo/“ zu liegen. Das Erste kümmert sich nur um das Auslesen der Daten und heißt „data.sh“:

#!/bin/bash

outdoor=$(cat /sys/bus/w1/devices/28-041621eb50ff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g")
indoor=$(cat /sys/bus/w1/devices/28-041621fadbff/w1_slave | grep -oP "t=(\d+)" | sed -e "s/t=//g")
seconds=$(TZ=Europe/Berlin date +"%s")

echo "$seconds,$indoor,$outdoor"

Die IDs müssen natürlich entsprechend angepasst werden.

Das zweite Script „insertdata.sh“ ruft „data.sh“ auf und schreibt die Daten in eine SQLite3-Datenbank.

#!/bin/bash
olddir=$(pwd)
cd /opt/thermo/
sqlite3 thermo.sqlite3 "insert into temperatures VALUES ($(./data.sh));"
cd "$olddir"

Da Archlinux mit Systemd kommt, können wir dessen Timer nutzen, um die Aufgabe alle 30 Sekunden abzufeuern. Dazu legen wir zunächst den Service unter „/etc/systemd/system/thermo.service“ an:

[Unit]
Description=Thermometer data collector

[Service]
Type=oneshot
ExecStart=/bin/bash /opt/thermo/insertdata.sh

Der Timer „/etc/systemd/system/thermo.timer“ führt diesen Service dann periodisch aus:

[Unit]
Description=Thermo data collector timer

[Timer]
Persistent=true
OnUnitActiveSec=30s
OnBootSec=30s

[Install]
WantedBy=timers.target

Diesen muss man mit einem kurzem Kommando aktivieren:

sudo systemctl enable thermo.timer

Zuletzt fehlte nur noch eine kleine Webseite, die die Daten aus der SQLite-Datenbank ausliest und anzeigt. Dazu habe ich einfach Apache + PHP installiert und folgende „index.php“ im DocumentRoot abgelegt.

thermo-website

<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">

<!-- Optional theme -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap-theme.min.css" integrity="sha384-fLW2N01lMqjakBkx3l/M9EahuwpSfeNvV63J5ezn3uZzapT0u7EYsXMjQV+0En5r" crossorigin="anonymous">

<!-- Latest compiled and minified JavaScript -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.0.0/Chart.js"></script>
</head>
<body class="container">
<?php
$db = new SQLite3('/opt/thermo/thermo.sqlite3');
$beginOfDay = strtotime("midnight", time());

$current = $db->query('SELECT * FROM temperatures order by timestamp desc limit 1');
$row = $current->fetchArray();

$currentDate = date("H:i:s - d.m.Y", $row['timestamp']);
$currentIndoor = round($row['indoor']/1000,3);
$currentOutdoor = round($row['outdoor']/1000,3);

$minmax = $db->query("SELECT MIN(indoor) as minIndoor, MIN(outdoor) as minOutdoor, MAX(indoor) as maxIndoor, MAX(outdoor) as maxOutdoor FROM temperatures where timestamp >= $beginOfDay order by timestamp desc");
$row = $minmax->fetchArray();

$minIndoor = round($row['minIndoor']/1000,3);
$maxIndoor = round($row['maxIndoor']/1000,3);
$minOutdoor = round($row['minOutdoor']/1000,3);
$maxOutdoor = round($row['maxOutdoor']/1000,3);

echo "<h1>Last measurement: $currentDate</h1>";
echo "<table class='table'><tr><th>Location</th><th>Current °C</th><th>Todays Min °C</th><th>Todays Max °C</th></tr>";
echo "<tr><td>Indoor</td><td>$currentIndoor</td><td>$minIndoor</td><td>$maxIndoor</td>";
echo "<tr><td>Outdoor</td><td>$currentOutdoor</td><td>$minOutdoor</td><td>$maxOutdoor</td>";
echo "</table>";

?>
<canvas id="myChart" width="300" height="100"></canvas>

<?php
$minmax = $db->query("SELECT * FROM temperatures where timestamp >= $beginOfDay order by timestamp asc");
$labels = array();
$indoor = array();
$outdoor = array();
$diff = array();
while($row = $minmax->fetchArray()) {
    $labels[] = date("H:i:s", $row['timestamp']);
    $indoor[] = round($row['indoor']/1000,3);
    $outdoor[] = round($row['outdoor']/1000,3);
    $diff[] = abs(round((abs($row['indoor']) - abs($row['outdoor']))/1000,3));
}
?>

<script>
var data = {
    labels: <?php echo json_encode($labels); ?>,
    datasets: [
        {
            label: "Indoor",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgb(209,12,8)",
            borderColor: "rgb(209,12,8)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgb(209,12,8)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgb(209,12,8)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($indoor);?>,
        },
        {
            label: "Outdoor",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgb(8,209,8)",
            borderColor: "rgb(8,209,8)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgb(8,209,8)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgb(8,209,8)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($outdoor);?>,
        },
        {
            label: "Difference",
            fill: false,
            lineTension: 0.1,
            backgroundColor: "rgba(75,192,192)",
            borderColor: "rgba(75,192,192)",
            borderCapStyle: 'butt',
            borderDash: [],
            borderDashOffset: 0.0,
            borderJoinStyle: 'miter',
            pointBorderColor: "rgba(75,192,192)",
            pointBackgroundColor: "#fff",
            pointBorderWidth: 1,
            pointHoverRadius: 5,
            pointHoverBackgroundColor: "rgba(75,192,192)",
            pointHoverBorderColor: "rgba(220,220,220,1)",
            pointHoverBorderWidth: 2,
            pointRadius: 1,
            pointHitRadius: 10,
            data: <?php echo json_encode($diff);?>,
        }
    ]
};

var ctx = document.getElementById("myChart");
var myLineChart = new Chart(ctx, {
    type: 'line',
    data: data,
});
</script>
</body>
</html>

~ Sebastian

]]> https://technik.blogbasis.net/raspberrypi-ds18b20-thermometerpi-13-05-2016/feed 0 DMS – Simpler DLNA Server https://technik.blogbasis.net/dms-simpler-dlna-server-04-03-2015 https://technik.blogbasis.net/dms-simpler-dlna-server-04-03-2015#respond Wed, 04 Mar 2015 09:55:12 +0000 http://technik.blogbasis.net/?p=1313 Hallo Leute,

heute möchte ich ein kleines Tool vorstellen mit dem man direkt aus einem Ordner heraus einen DLNA Server aufsetzen kann. So kann man ohne umständliche Konfiguration oder Indexierung Videos auf den Fernseher streamen.

Ich hatte früher zum Streamen die Software „miniDLNA“ genutzt. Leider musste man bei einem neuen Titel die komplette Datenbank erneut aufbauen. Das war inbesondere auf dem Pi ein zeitaufwendiger und entsprechend langweiliger Prozess.

Zunächst wollte ich die Lösung als kleines Projekt in Python implementieren, jedoch gibt es keine wirklich tollen Bibliotheken für das DLNA-Protokoll.

Zufälligerweise bin ich beim Googlen auf das Programm „DMS“ von anacrolix gestoßen. Dieses erfüllt genau meine Anforderungen:

  • Ohne Indexierung direkt aus einem Ordner heraus Daten streamen
  • Keine Konfiguration nötig

Unter Arch-Linux kann man sich das von bitwave erstellte, gleichnamige AUR-Package installieren.

yaourt dms

Ansonsten können folgende Befehle zur Installation verwendet werden. Voraussetzung dafür ist, dass man Go installiert hat.

> go get bitbucket.org/anacrolix/dms
> $GOPATH/bin/dms

Um einen bestimmten Pfad bzw. Ordner zu streamen, muss man nur den Parameter „-path“ angeben:

dms -path="/mnt/usbStick"

Dann wird auf Port 1338 ein HTTP Server geöffnet, dessen Nutzen habe ich allerdings noch nicht ganz verstanden. Wichtiger ist dann wohl, dass Port 1900 (UDP) belegt wird.

Man sollte natürlich nicht vergessen, die beiden Ports in der Firewall freizuschalten.

~ Sebastian

]]> https://technik.blogbasis.net/dms-simpler-dlna-server-04-03-2015/feed 0 Banana Pi als WLAN & LAN Router einrichten https://technik.blogbasis.net/banana-pi-als-wlan-lan-router-einrichten-01-03-2015 https://technik.blogbasis.net/banana-pi-als-wlan-lan-router-einrichten-01-03-2015#respond Sun, 01 Mar 2015 13:25:46 +0000 http://technik.blogbasis.net/?p=1303 Ich habe mir vor Kurzem einen BananaPi bestellt und wollte diesen probeweise als WLAN & LAN Router einrichten, wobei WLAN und LAN sich gemeinsam ein Netzwerk teilen.

Mit den Programmen hostapd, dnsmasq und Arch-Linux lässt sich das ohne größere Schwierigkeiten umsetzen.

Hardware & Betriebssystem

Wie schon angedeutet, handelt es sich um ein Banana Pi. Das Ding ist so ähnlich wie ein Raspberry Pi, nur kommt es mit einer DualCore CPU und 1 GB RAM, sowie einer 1GBit Netzwerkschnitstelle.

Die Wahl des Betriebssystems fiel auf das Arch Linux v2.0 Image. Dieses kann man, wie gewohnt, einfach herunterladen und auf die SD Karte spielen.

Des Weiteren benötigt man noch einen USB-Ethernet Adapter, sowie einen USB-WLAN Adapter. Die folgenden Produkte hatte ich bei mir noch rumliegen und können out-of-the-box genutzt werden.

  • LogiLink UA0025C
  • TP Link TL-WN722N

Ziel

Wenn wir die folgende Konfiguration annehmen:

  • eth0 : Schnittstelle zum Internet (WAN)
  • eth1 : Schnittstelle zum LAN
  • wlan0 : Schnittstelle zum WLAN

Dann möchten wir folgendes Setup erreichen:

  • eth0 bekommt seine IP per DHCP
  • eth1 & wlan0 teilen sich das Subnet 192.168.4.0/24
  • Die IPs aus dem Subnet werden per DHCP verteilt
  • Dem Subnet wird ein DNS Server zur Verfügung gestellt

Um das zu erreichen, werden wir das Setup in drei größere Konfigurationsabschnitte unterteilen:

  • Netzwerkschnittstellen konfigurieren (systemd-networkd)
  • Iptables konfigurieren
  • Dnsmasq & Hostapd konfigurieren

Kernel vs. Systemd

Die Kernelversion des Images ist bisher bei 3.4.x stehen geblieben. Jedoch werden die Systemd Pakete weiter aktualisiert. Ab systemd-216 führt dies zu Problemen beim Laden von Treibern. Systemd erwartet, dass der Kernel diese Funktion übernimmt, jedoch ist diese in dieser älteren Version noch nicht implementiert.

Folgende Fehler können auf dieses Problem hinweisen:

[ 119.592292] usb 1-1.2: ath9k_htc: Firmware htc_9271.fw requested
[ 180.172266] usb 1-1.2: ath9k_htc: Failed to get firmware htc_9271.fw
[ 180.302130] usb 1-1.2: ath9k_htc: USB layer deinitialized

Natürlich sollte die Datei „htc_9271.fw“ in „/lib/firmware“ bzw. „/usr/lib/firmware“ vorhanden sein.

Die Lösung des Problems besteht darin, dass man Updates für folgende drei Pakete zurückhält:

  • libsystemd
  • systemd
  • systemd-sysvcompat

Diese drei Paketenamen trägt man hinter „IgnorePkg=“ in der „/etc/pacman.conf“ ein.

Danach kann man sich von Archlinux-Rollback die drei Pakete in der Version „216-3“ herunterladen und mittels „pacman -U <Paket>“ installieren.

Netzwerkschnittstellen konfigurieren

Der erste Schritt besteht darin dem System mitzuteilen, wie wir unsere Interfaces konfiguriert haben möchten. Ein Interface soll eine dynamische IP haben und die zwei verbleibenden Schnittstellen sollen ein virtuelles Device bilden.

Hierzu stellen wir erstmal sicher, dass die Voraussetzungen gegeben sind, in dem wir „systemd-networkd“ aktivieren und „netctl“ (ggf. andere Netzwerkmanager) deaktivieren.

systemctl enable systemd-networkd
systemctl stop netctl
systemctl disable netctl

Für die dynamischen IP Adressen benötigen wir dann noch das Paket „dhcpcd“ und entsprechend den aktivierten Dienst:

pacman -S dhcpcd
systemctl enable dhcpcd.service
systemctl start dhcpcd.service

Als nächstes wechselt man in das Verzeichnis „/etc/systemd/network/“. Dort legen wir die Datei für unser WAN-Interface an. Die Datei nennt man „eth0.network“.

[Match]
Name=eth0

[Network]
DHCP=yes

Als nächstes ist unser WLAN-Device dran. Dieses bekommt keine IP zugewiesen, da sich hostapd darum kümmern wird. Die Datei „wlan0.network“ enthält folgendes:

[Match]
Name=wlan0

[Network]
DHCP=no

Als nächstes definieren wirin der Datei „br0.netdev“ die virtuelle Netzwerkbrücke:

[NetDev]
Name=br0
Kind=bridge

Dieser weisen wir unser Subnetz zu (br0.network):

[Match]
Name=br0

[Network]
Address=192.168.4.1/24
DHCP=no

Zuletzt wird noch direkt unser LAN-Interface an die virtuelle Netzwerkschnittstelle gebunden (eth1.network):

[Match]
Name=eth1

[Network]
Bridge=br0

Nun sollte die Konfiguration soweit abgeschlossen sein. Das lässt sich so überprüfen:

systemctl restart systemd-networkd #Netzwerk neustarten

Die Ausgabe von „ip a s“ sollte so ähnlich aussehen:

2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
 link/ether 02:86:08:82:75:2e brd ff:ff:ff:ff:ff:ff
 inet 192.168.2.208/24 brd 192.168.2.255 scope global eth0

4: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast master br0 state UNKNOWN group default qlen 1000
 link/ether 00:60:6e:42:57:d9 brd ff:ff:ff:ff:ff:ff

5: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq master br0 state UP group default qlen 1000
 link/ether f8:1a:67:17:66:e5 brd ff:ff:ff:ff:ff:ff

6: br0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
 link/ether 00:60:6e:42:57:d9 brd ff:ff:ff:ff:ff:ff
 inet 192.168.4.1/24 brd 192.168.4.255 scope global br0

Wie man sieht, hat eth0 automatisch eine IP von meinem Router bekommen. Das virtuelle Interface br0 hat das Subnetz 192.168.4.1/24 zugewiesen bekommen. Eth0 ist bereits ein Teil vom virtuellen Interface.

Iptables konfigurieren

Damit der Traffic nicht unkontrolliert zwischen den Interfaces fließt bzw. das NAT konfiguriert werden kann, müssen die Iptables genutzt werden.

Normalerweise sind diese schon installiert. Ansonsten muss man das gleichnamige Paket nachinstallieren.

Die im Arch Wiki vorgestellte Konfiguration sieht ungefähr so aus:

# Generated by iptables-save v1.4.21 on Sat Feb 28 02:05:21 2015
*nat
:PREROUTING ACCEPT [5:231]
:INPUT ACCEPT [1:61]
:OUTPUT ACCEPT [2:122]
:POSTROUTING ACCEPT [2:122]
-A POSTROUTING -s 192.168.4.0/24 -o eth0 -j MASQUERADE
COMMIT
# Completed on Sat Feb 28 02:05:21 2015
# Generated by iptables-save v1.4.21 on Sat Feb 28 02:05:21 2015
*filter
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [55:4554]
:TCP - [0:0]
:UDP - [0:0]
:fw-interfaces - [0:0]
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -p icmp -m icmp --icmp-type 8 -m conntrack --ctstate NEW -j ACCEPT
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable
-A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -j fw-interfaces
-A FORWARD -j REJECT --reject-with icmp-host-unreachable
-A TCP -p tcp -m tcp --dport 22 -j ACCEPT
-A TCP -i br0 -p tcp -m tcp --dport 53 -j ACCEPT
-A TCP -i br0 -p tcp -m tcp --dport 67 -j ACCEPT
-A UDP -i br0 -p udp -m udp --dport 53 -j ACCEPT
-A UDP -i br0 -p udp -m udp --dport 67 -j ACCEPT
-A fw-interfaces -i br0 -j ACCEPT
COMMIT
# Completed on Sat Feb 28 02:05:21 2015

Das speichert man sich in „/etc/iptables/iptables.rules“ und lädt die Regeln neu:

systemctl restart iptables.service
systemctl enable iptables.service

Die Iptables kann man bei diesem Schritt direkt für den Autostart markieren.

Die Regeln sind so aufgebaut, dass in der Input-Chain der Traffic in UDP/TCP unterteilt wird. In diesen Unter-Chains kann man dann Traffic zulassen oder ablehnen. Wir werden später udp/tcp Port 53,67 nutzen, um darüber DHCP/DNS zu verschicken.

Die Forward-Chain „fw-interfaces“ regelt, von welchen Netzwerken Traffic wohin weitergeleitet werden darf. Hier sagen wir ganz grob, dass alles vom br0 weitergeleitet werden darf.

Ansonsten kümmert sich das conntrack-Modul um die Verwaltung der Verbindungen, in dem es die Pakete zu einer „neuen/ähnlichen/verbundenen“ Verbindung zugeordnet wird.

Ganz wichtig ist die POSTROUTING-Regel im oberen Bereich. Diese kümmert sich um das NAT, in dem alle ausgehenden Pakete vom Subnetz 192.168.4.0/24 die IP vom eth0 verpasst bekommen.

Eine relativ gute Übersicht über alle Regeln bekommt man mit:

sudo iptables -L -vn

Zusätzlich muss das IP-Forwarding im System aktiviert werden:

sudo sysctl -w net.ipv4.ip_forward=1

Dnsmasq & Hostapd konfigurieren

Kommen wir nun zum letzten Teil. Zunächst installieren wir die nötigen Pakete:

sudo pacman -S dnsmasq hostapd

Dnsmasq ist ein kleiner DHCP/DNS Server und hostapd ein Tool zum Erstellen von Access Points.

Dnsmasq

Für Dnsmasq editieren wir die Datei „/etc/dnsmasq.conf“ und setzen dort diese Optionen:

interface=br0
dhcp-range=192.168.4.100,192.168.4.200,24h

Für einen erfolgreichen Betrieb reichen die o.g. Einstellungen aus. Allerdings sollte man sich die Konfigurationsdatei durchlesen, um ggf. Sicherheitsvorkehrungen zu treffen oder weitere Features zu aktivieren.

Mit der ersten Zeile wird festgelegt, dass nur Anfragen vom Interface br0 verarbeitet werden. Die zweite Zeile legt den zu vergebenden IP-Bereich bzw. die Leasetime fest.

Danach muss man dnsmasq neustarten und im Autostart verankern:

systemctl enable dnsmasq.service
systemctl restart dnsmasq.service

Hostapd

Auch hier müssen wir eine Konfigurationsdatei bearbeiten. Beispiele und eine ausführliche Dokumentation finden sich diesmal hier: „/usr/share/doc/hostapd/*“

Die Einstellungen landen dann in der „/etc/hostapd/hostapd.conf“. Diese kann zum Beispiel so aussehen:

interface=wlan0
bridge=br0
driver=nl80211
ssid=PiWiFi
channel=1
ignore_broadcast_ssid=0
country_code=DE
ieee80211d=1
hw_mode=g
beacon_int=100
dtim_period=2
macaddr_acl=0
max_num_sta=20
rts_threshold=2347
fragm_threshold=2346
logger_syslog=-1
logger_syslog_level=2
logger_stdout=-1
logger_stdout_level=2
dump_file=/tmp/hostapd.dump
ctrl_interface=/var/run/hostapd
ctrl_interface_group=0
auth_algs=3
wmm_enabled=0
wpa=2
rsn_preauth=1
rsn_preauth_interfaces=wlan0
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
wpa_group_rekey=600
wpa_ptk_rekey=600
wpa_gmk_rekey=86400
wpa_passphrase=DASPASSWORT!

Wichtig hierbei ist nur, dass der „Interface=wlan0“ und der „Bridge=br0“ Eintrag vorhanden sind.

Zuletzt muss hostapd noch neugestartet und im Autostart verankert werden:

systemctl restart hostapd.service
systemctl enable hostapd.service

Abschließende Worte

Das von uns definierte Ziel ist nun erreicht. Wir haben einen funktionierenden kleinen Router.

Ich hatte noch probiert „traffic shaping“ umzusetzen, jedoch schien das der Treiber bzw. der Kernel nicht zu unterstützen.

~ Sebastian

]]> https://technik.blogbasis.net/banana-pi-als-wlan-lan-router-einrichten-01-03-2015/feed 0 Raspberry Pi: Stromkosten im Jahr https://technik.blogbasis.net/raspberry-pi-stromkosten-im-jahr-13-06-2013 https://technik.blogbasis.net/raspberry-pi-stromkosten-im-jahr-13-06-2013#respond Thu, 13 Jun 2013 22:02:57 +0000 http://technik.blogbasis.net/?p=695 Vor einigen Tagen erreichte uns ein Leser über die Suchanfrage „Raspberry Pi Stromkosten pro Jahr“. Da ich selbst einen Pi fast rund um die Uhr laufen lasse, wollte ich dem Gedanken nachgehen und eine Rechnung aufstellen.

Die Stromkostenrechnung

Laut der deutschen Wikipedia verbraucht das „Modell B“ bei 5V und 700mA ~3,5 Wh pro Stunde. Das hört sich zunächst relativ wenig an. Nehmen wir mal an, der Pi hängt an einem powered USB-Hub dessen Wirkungsgrad ~60% ist. Wenn keine weiteren Geräte daran hängen, dann wären wir bei ~6 Watt (stark gerundet).

Ein Jahr hat 365 Tage. Das sind 8760 Stunden. Nehmen wir an, der Raspberry Pi läuft wirklich Tag und Nacht, dann kommen wir auf 52560 Wattstunden. Das sind ~53 kWh.

Wenn wir des Weiteren annehmen, dass ein kWh ~20 Cent kostet, dann ergeben sich Kosten von 10€ pro Jahr Dauerbetrieb eines Raspberry Pis.

Fazit

Wenn man weitere Hardware am Raspberry PI bzw. am zugehörigen Hub, oder dessen Wirkungsgrad nicht so hoch ist, dann würde ich maximal noch 5€ draufschlagen. Somit wäre das ein monatlicher Preis von ~1,25€ im Monat. Das ist meiner Meinung nach völlig akzeptabel.

~Sebastian

]]> https://technik.blogbasis.net/raspberry-pi-stromkosten-im-jahr-13-06-2013/feed 0 Raspberry Pi: Node.js installieren und Fibonnacizahlen berechnen https://technik.blogbasis.net/raspberry-pi-node-js-installieren-und-fibonnacizahlen-berechnen-06-05-2013 https://technik.blogbasis.net/raspberry-pi-node-js-installieren-und-fibonnacizahlen-berechnen-06-05-2013#respond Mon, 06 May 2013 11:52:31 +0000 http://technik.blogbasis.net/?p=516 Der @vis7mac hatte mich vor einiger Zeit gefragt, ob ich für ihn seine Fibonnaci-Implementierung auf dem Raspberry Pi kurz ausprobieren könnte. Leider war „kurz“ zu viel versprochen, denn Node.js musste erstmal eingerichtet werden. Das dauerte eine Weile, doch am Ende hatten wir die gewünschten Zahlen berechnet.

Node.js installieren

Um Node.js auf dem Raspberry Pi zu installieren, benötigen wir git, sowie die build-essentials:

sudo apt-get install git-core build-essential

Danach erstellen wir uns ein Verzeichnis für die Node-Installation, laden den Sourcecode herunter und checken die 0.8.8 Version aus:

mkdir ~/node && cd ~/node && git clone https://github.com/joyent/node.git . && git checkout v0.8.8 -b v0.8.8

Jetzt müssen wir noch einige Patches einspielen:

curl https://github.com/joyent/node/commit/25c2940a08453ec206268f5e86cc520b06194d88.patch | git am
curl https://github.com/joyent/node/commit/1d52968d1dbd04053356d62dc0804bcc68deed8a.patch | git am
curl https://github.com/joyent/node/commit/f8fd9aca8bd01fa7226e1abe75a5bcf903f287ab.patch | git am
curl https://github.com/joyent/node/commit/7142b260c6c299fc9697e6554620be47a6f622a9.patch | git am

Zuletzt kommen wir zu dem schlimmsten Teil der Installtion, nämlich dem Compilen. Das dauerte bei mir mit 800MhZ Taktung über eine Stunde:

./configure
make
sudo make install

Fibonacci.js herunterladen und ausführen

Nachdem nun Node.js installiert ist, können wir die Fibonacci.js herunterladen und ausführen.

git clone git@github.com:vis7mac/fibonacci.git
node fibonacci.js -b 10000

Unser Pi kann berechnet nun die 10.000ste Fibonacci Zahl :)

~ Sebastian 

 

]]> https://technik.blogbasis.net/raspberry-pi-node-js-installieren-und-fibonnacizahlen-berechnen-06-05-2013/feed 0 Raspberry Pi: Moon-Buggy Kommandozeilenspiel https://technik.blogbasis.net/raspberry-pi-moon-buggy-kommandozeilenspiel-12-04-2013 https://technik.blogbasis.net/raspberry-pi-moon-buggy-kommandozeilenspiel-12-04-2013#respond Fri, 12 Apr 2013 21:56:53 +0000 http://technik.blogbasis.net/?p=431 Als ich mich mit meinem Studium anfing, wurde ich von einem Kommilitonen auf das Spiel namens „Moon-Buggy“ hingewiesen. Es handelt sich dabei um ein kleines Kommandozeilenspiel, welches selbst auf dem Raspberry Pi läuft.

Bei Moon-Buggy geht es darum, einen Kinderwagen über verschieden große Löcher springen zu lassen, sowie kleine Monster zu besiegen. Insgesamt also ein kleines Spiel für die Vorlesung Zwischendurch :)

Installation von Moon-Buggy

Moon-Buggy lässt sich einfach kompilieren. Dazu brauchen wir nicht mehr, als die folgenden Tools:

  • cd
  • mkdir
  • wget
  • tar
  • configure
  • make

Diese sollten auf den meisten Linux-Distributionen bzw. dem Raspian bereits vorhanden sein. Zur Installation erstellen wir uns im Homeverzeichnis erstmal einen neuen Ordner namens „moonbuggy“:

cd ~
mkdir moonbuggy
cd moonbuggy

Darin laden wir den Quelltext der Stable-Version herunter und entpacken das Tar-Archiv:

wget http://m.seehuhn.de/programs/moon-buggy-1.0.tar.gz
tar xfv moon-buggy-1.0.tar.gz 
cd moon-buggy-1.0/

Zuletzt müssen wir es konfigurieren, und danach zweimal make aufrufen. Das Ganze dauert insgesamt vielleicht maximal 5 Minuten:

./configure
make
sudo make install

Nachdem wir fertig sind, können wir Moon-Buggy über den gleichnamigen Befehl starten:

moon-buggy

Kleine Vorschau

Ich habe mal ein kurzes Video aufgenommen, in dem ich das Spiel zeige (Achtung: Langweilig)

http://www.youtube.com/watch?v=it4rTOcDLxQ

~ Sebastian

]]> https://technik.blogbasis.net/raspberry-pi-moon-buggy-kommandozeilenspiel-12-04-2013/feed 0 Raspberry Pi im Rechenzentrum betreiben https://technik.blogbasis.net/raspberry-pi-im-rechenzentrum-betreiben-08-04-2013 https://technik.blogbasis.net/raspberry-pi-im-rechenzentrum-betreiben-08-04-2013#respond Mon, 08 Apr 2013 11:59:48 +0000 http://technik.blogbasis.net/?p=401 Ich wurde gestern auf eine Seite aufmerksam gemacht, auf welcher einem angeboten wird, seinen Raspberry Pi in ein niederländisches Rechenzentrum einzuschicken. Der Service ist nahezu kostenlos.

Möchte man seinen Raspberry Pi als Webserver, FTPserver, DNSserver, Mailserver betreiben, und diesen von außen zugänglich machen, so muss man ggf. entsprechende Einstellungen am Router vornehmen. Zudem muss man selbst für die Erreichbarkeit sorgen, und die Stromkosten selbst bezahlen. Der größte Flaschenhals wird der Uplink des eigenen DSL-Anschlusses sein, welcher oft nicht sehr hoch ist und der Downloadgeschwindigkeit der Besucher entspricht.

Das Angebot für ein neues Zuhause

PCExtreme startet ein Projekt, was einem erlaubt, seinen Raspberry Pi in deren Rechenzentrum einzuschicken, und es dort zu betreiben. Man bewirbt eine 100 Mbit Anbindung, sowie fair-use Traffic in Höhe von 500GB/Monat. Inklusive Stromversorgung und Platz im Rechenzentrum kostet das einem 0€ für mindestens 12 Monate. Ich sehe da folgende Vor- und Nachteile:

Vorteile:

  • Schnelle Internetanbindung (100Mbit)
  • Ausreichend Traffic (500GB)
  • Keine Stromkosten (3-5 Watt/h)
  • Inklusive IPv4 bzw. IPv6 Adresse (statisch)
  • Max 4cm langer USB Stick zur Speichererweiterung

Nachteile:

  • Kein physischer Zugriff auf den Raspberry Pi
  • Reinstall des Betriebssystems kostet 20€
  • Rückversand kostet 7,5€ – 30€
  • Plastikgehäuse wird vorausgesetzt.
  • Nur Modell B, da Ethernet-Buchse vorausgesetzt.
  • Kein „Rumexperimentieren“, da hohe Reinstallkosten

Das Projekt verspricht, den Raspberry Pi für mindestens 12 Monate für die genannten Leistungen zu betreiben. Was danach passiert, wird nicht genannt.

Den Raspberry Pi einschicken

Auf der Internetseite werden einige Voraussetzungen genannt, welche man erfüllen muss, bevor man seinen Raspberry Pi einschicken sollte:

  • Modell B, da ein Ethernetanschluss gefordert ist. (Modell A besitzt keinen)
  • Plastikgehäuse für den Raspberry Pi
  • Konfiguration einer statischen IP Adresse (Wird nach Bestellung genannt)
  • SD Karte mit bootfähigem Betriebssystem

Erfüllt man diese Voraussetzungen, dann sollte man seinen Raspberry Pi ohne Problem einschicken können. Den Versand in die Niederlanden muss man selbst bezahlen. Bei der DHL sollte so ein Päckchen ~8,9€ kosten. Dies sollte bei den genannten Leistungen aber kein K.O-Kriterium darstellen :)

Einen Raspberry Pi direkt kaufen

Das Unternehmen bietet die Möglichkeit an, einen Raspberry Pi direkt zu kaufen, welcher dann vor Ort eingerichtet und online gebracht wird. Man braucht sich dann um nichts mehr kümmern. Dabei werden zwei verschiedene Angebote vorgestellt:

Angebot 1:

  • Raspberry Pi Modell B (512 MB RAM)
  • SD-Karte: Samsung 8 GB Klasse 6
  • Preis: 52,50€

Angebot 2:

  • Raspberry Pi Modell B (512 MB RAM)
  • Samsung 16 GB Klasse 10
  • Preis: 62,50€

Die Angebote unterscheiden sich nur in der SD Karte. Die Lieferzeiten werden mit ungefähr 14 Tagen angegeben, sodass man sich ein wenig nach seinem Kauf gedulden muss. Schaut man sich mal nach den Preisen um, dann ist das Angebot fair:

  • Raspberry Pi: 27,00€
  • Gehäuse: 5,50€
  • Summe: 31,50€

Rechnet man darauf noch die Kosten für einen Reinstall des Betriebssystems, dann landet man bei den genannten Preisen. 

Fazit

Für denjenigen, der seinen Raspberry Pi als Webserver o.ä. nutzen möchte, und auf eine schnelle Internetanbindung angewiesen ist, die man Zuhause nicht hat, kann dieses Angebot sehr interessant sein. 500 GB Traffic bei einer 100 Mbit-Anbindung inklusive Stromkosten für keinen einzigen Cent ist meiner Meinung ein wirklich gutes Angebot. Schade ist nur, dass einem damit der Spaß am Basteln (GPIO/Softwaremäßig) genommen wird, denn falls was schief geht, sind 20€ für eine Neuinstallation des Betriebssystems nicht sehr günstig.

~Sebastian

Quellen:

Projektseite: http://raspberrycolocation.com/
DHL: http://www.dhl.de/de/paket/pakete-versenden/weltweit-versenden/laenderseiten/niederlande.html

]]> https://technik.blogbasis.net/raspberry-pi-im-rechenzentrum-betreiben-08-04-2013/feed 0 Raspberry Pi – DropBox benutzen https://technik.blogbasis.net/raspberry-pi-dropbox-benutzen-10-03-2013 https://technik.blogbasis.net/raspberry-pi-dropbox-benutzen-10-03-2013#respond Sun, 10 Mar 2013 20:30:45 +0000 http://technik.blogbasis.net/?p=138 DropBox ist ein Dateisynchronisationsdienst den bestimmt jeder schon mal genutzt bzw. davon gehört hat. Diesen kann man über Umwege auch auf dem Rasperry Pi nutzen.

Die versuchte Installation

Zunächst versuchte ich den Sourcecode des DropBox-Clients zu kompilieren. Das funktionierte auch einwandfrei. Wer dies nachmachen möchte:

mkdir ~/dropbox
cd ~/dropbox
sudo apt-get install libnautilus-extension-dev python2.7-dev python-gobject-2-dev python-gtk2 python-docutils
wget "https://www.dropbox.com/download?dl=packages/nautilus-dropbox-1.4.0.tar.bz2"
tar xfv [Datei]
cd nautilus-dropbox-1.4.0/
./configure
make
sudo make install

Danach könnt ihr zwar „dropbox“ aufrufen, aber um es benutzen zu können, muss man erst den DropBox-Daemon installieren. Hier ist der Knackpunkt: Der Daemon ist proprietär und steht für ARM-Systeme leider nicht zur Verfügung, sodass ein Aufruf von „dropbox start -i“ mit der Fehlermeldung scheitert:

Error: Platform not supported

DropBoxl lässt sich über diesen Weg nicht nutzen. In diesem Fall müssen wir warten, bis DropBox einen Daemon für die entsprechende Architektur bereitstellt.

Der Lösungsweg über die API

DropBox bietet eine API an, sodass man auf gewisse Funktionen des Dienstes zugreifen kann. Ein schlauer Kopf hat damit einen Bash DropBox Client geschrieben. Damit kann man zwar nur grundlegende Funktionen, wie z.B. das Hochladen, Herunterladen, Löschen von einzelnen Dateien nutzen, doch das kann bereits ausreichen.

Installation und Konfiguration des DropBox Uploaders

Wir erstellen uns einen Ordner, klonen das Repository und führen das Script aus:

mkdir ~/dropbox
cd ~/dropbox
rm -rf *
git clone git@github.com:andreafabrizi/Dropbox-Uploader.git
./dropbox_uploader.sh

Nun müssen wir nur noch den Zugriff einrichten. Die Schritte dazu werden vom Script deutlich erklärt. Zusammengefasst müsst ihr auf die App-Developer Seite von Dropbox, um eine neue App zu erstellen. Die generierten Schlüssel müssen dann eingegeben werden. Zuletzt muss man noch den Oauth-Link bestätigen. Damit sollte die Konfiguration abgeschlossen werden.

Die Nutzung des DropBox Uploaders

Einmal den DropBox Uploader ausgeführt und man sieht, was man alles machen kann:

pi@raspberrypi ~/dropbox  ./dropbox_uploader.sh
Andrea Fabrizi - andrea.fabrizi@gmail.com
Usage: ./dropbox_uploader.sh COMMAND [PARAMETERS]...
Commands:
	 upload   [LOCAL_FILE]  <REMOTE_FILE>
	 download [REMOTE_FILE] <LOCAL_FILE>
	 delete   [REMOTE_FILE/REMOTE_DIR]
	 mkdir    [REMOTE_DIR]
	 list     <REMOTE_DIR>
	 share    [REMOTE_FILE]
	 info
	 unlink

For more info and examples, please see the README file.

Demnach kann man nur einzelne Dateien hoch- bzw. herunterladen. Ein Upload von Ordnern könnte man jedoch rekursiv durchführen. Man sollte jedoch beachten, dass in den Developer-ToS, welchen man zugestimmt hat, folgendes steht (1.3):

(b) We may limit the number of calls accepted by the API if we believe that the number of calls to the Dropbox API may negatively impact the Dropbox API or Dropbox service.

Demnach sollte man nicht zu viele API Aufrufe in einer geringen Zeit durchführen. Für die Synchronisation von einigen wichtigen Dateien reicht das Script jedoch vollkommen aus.

~Sebastian

]]> https://technik.blogbasis.net/raspberry-pi-dropbox-benutzen-10-03-2013/feed 0 Raspberry Pi – Begrüßung beim Login https://technik.blogbasis.net/raspberry-pi-begruessung-beim-login-08-03-2013 https://technik.blogbasis.net/raspberry-pi-begruessung-beim-login-08-03-2013#respond Fri, 08 Mar 2013 01:15:32 +0000 http://blogbasis.net/?p=88 Wenn man so ein gutes Verhältnis zu seinem Raspberry Pi hat, wie es bei mir ist ;), dann wäre es doch schön, wenn der Pi einen beim Login begrüßen würde.

Hello

Das Programm, welches wir suchen nennt sich „Hello“ und ist in den Repositorys zu finden. Wir können es ganz einfach mit apt installieren:

sudo apt-get install hello

Nachdem die Installation abgeschlossen ist, können wir das Programm testweise benutzen:

$ hello
$ hello -n
$ hello -g "Hallo DuDa!"

Das Programm macht eigentlich nichts anderes als „Hallo Welt“ bzw. den über -g übergebenen String auszugeben. Man könnte sowas natürlich auch selbst als kleines Script schreiben, doch das wäre zu einfach :)

Die Begrüßung

Wenn wir nun bei jedem Login von unserem Pi begrüßt werden wollen, müssen wir einfach einen entsprechenden Eintrag in der ~/.bash_profile anlegen:

echo '/usr/bin/hello -g "Hallo mein Großer!"' >> ~/.bash_profile

Die ~/.bash_profile wird bei jedem Login auf dem Raspberry Pi ausgeführt. Da unser hello-Kommando entsprechend darin platziert wurde, wird es ausgeführt und wir sehen unsere tolle Begrüßung :)

~Sebastian

]]> https://technik.blogbasis.net/raspberry-pi-begruessung-beim-login-08-03-2013/feed 0