SSH absichern mit Denyhosts

Denyhosts ist eine Software mit deren Hilfe man einen SSH Login auf einen Rechner sicherer machen kann. Im letzten Teile habe ich bereits 10 Punkte vorgestellt mit denen man einen Webserver, der in einem Rechenzentrum steht, vor Angriffen schützen kann. Denyhosts ist eine einfache, aber ...
SSH absichern mit Denyhosts

SSH Port ändern

Mit nur wenig Aufwand kann man den SSH Port ändern. In 5 Minuten Arbeit kann man den eigenen Server auf eine ganz neue Ebene der Sicherheit heben. Ich zeige euch wie das geht und Warum dieser Schritt so effektiv ist.
SSH Port ändern
Alle Änderungen zu SSH werden in der Konfigurationsdatei des SS...
SSH Port ändern

SSH absichern

In meiner Artikelserie zum Thema “SSH absichern” zeige ich euch mehrere Möglichkeiten wie ihr euren SSH Zugang zum Server sicherer machen könnt um so weniger Angriffsfläche für Hacker zu bieten. Sofern man nicht sehr wichtige Daten auf dem Server hat und ein hohes Level von Sic...
SSH absichern

10 Tipps wie man seinen Server absichert

Einen eigenen Server zu administrieren machst Spaß und man lernt sehr schnell viel dazu. Sobald man darauf wichtige Daten speichert oder Applikationen betreibt ist die Sicherheit Thema Nummer eins. Wenn auf diesem Server auch noch Webseiten von Kunden gehostet werden, dann muss der Server rund ...
10 Tipps wie man seinen Server absichert

eBlocker Kampagne war ein Erfolg

Anfang Oktober war die eBlocker Kampagne auf IndieGoGo zu Ende. Zuletzt war der angepeilte Zielbetrag von 50.000 Dollar sogar um 50% überschritten. Dieser Erfolg spricht nicht nur für die Kampagne selber, sondern vor allem für ein steigendes Sicherheitsbewusstsein der Benutzer im Internet. An...
eBlocker Kampagne war ein Erfolg

Roboter bewegen für Fortgeschrittene

In meinem Artikel “Roboter bewegen für Fortgeschrittene” zeige ich euch wie ihr das Python Skript für die Navigation eures Roboters aus dem früheren Artikel “Roboter bewegen für Anfänger” weiter verfeinert. Diesmal kommt die Geschwindigkeit hinzu. Diese wird beim Raspberry Pi über den PWM GPIO Pin gesteuert.

Roboter bewegen für Fortgeschrittene

Im vorangegangenen Anfängerartikel habe ich euch ja bereits ein fertiges Skript präsentiert über dieses man den Roboter bereits mit der Tastatur – wahlweise auch über SSH – in die 4 Richtungen steuern konnte. Das Problem war die Geschwindigkeit. Das Roboter Board besitzt 2 Pins über die man die Geschwindigkeit der Räder links und rechts Regeln kann. Diese Geschwindigkeit wird über ein analoges Signal eingestellt. Der Raspberry Pi hat jedoch nur digitale Pins, weshalb nur zwei Einstellungen möglich sind:

• 1: maximale Geschwindigkeit


• 0: Stillstand

Im ersten Moment könnte man meinen das ist nun mal so und man muss sich damit abfinden. Glücklicherweise gibt es einen Pin der GPIO Schnittstelle, der PWM unterstützt. Das ist der Pin mit der Nummer 12 beziehungsweise GPIO 18.

PWM Theorie

Unter PWM versteht man die schnelle Änderung der Spannung. Bei dem PWM Pin kann man angeben wie oft er ein- und ausgeschaltet wird. Das geschieht innerhalb kürzester Zeit sehr oft. So oft, dass manche Geräte wie Servo Motoren dieses Signal als analoges Signal interpretieren. Je nach Geschwindigkeit, also der Häufigkeit der Umschaltvorgänge ist das analoge Signal unterschiedlich stark. Genau das benötigen wir für die Ansteuerung des Motors um eine bestimmte Geschwindigkeit zu setzen.

WiringPi kommt ins Spiel

Vor einiger Zeit habe ich euch die WiringPi2 Bibliothek vorgestellt, die unter anderem auch für Python portiert wurde. Mit dieser kann man recht einfach mit der GPIO Schnittstelle arbeiten. Als besonderes Feature stellt diese Bibliothek auch eine Funktion bereit um ein PWM Signal zu erzeugen.

wiringpi.pwmWrite(18, 550)

Die Funktion pwmWrite hat 2 Parameter. Das ist zum einen die Nummer des GPIO Pins (18 ist die einzig mögliche Eingabe!) und einen Wert für die Frequenz. Dieser muss zwischen 0 und 1024 liegen.

Anpassungen an der Hardware

Die schlechte Nachricht zuerst: wir müssen eine Modifikation an der Verkabelung vornehmen. Die gute Nachricht: es wird sogar etwas einfacher! Bis jetzt verwendeten wir 2 Pins für die Geschwindigkeit der linken und der rechten Seite. Dazu auch 2 Kabel (grün und gelb). Diese werden nun entfernt. Ersetzt werden diese durch einen einzigen Pin – wir erinnern uns: es gibt nur einen PWM Pin am Raspberry Pi. An diesen müssen wir nun 2 Kabel hängen und mit dem Roboterboard verbinden. Zu diesem Zweck benötigen wir ein Steckbrett – alternativ kann man diese Kabel auch zusammen löten.

Wie man gut sehen kann sind nun über den Umweg vom Steckbrett beide lila Drähte direkt mit dem PWM Pin verbunden.

Anpassungen an der Software

Bevor man mit Änderungen an der Software durchführen kann muss WiringPi installiert werden. Wie das funktioniert habe ich bereits in einem der letzten Artikel zu WiringPi gezeigt.

Auch bei der Software können wir vereinfachen. Statt 2 Pins und Outputs benötigen wir nun pro Bewegungsaktion nur einen. Der Unterschied zum Anfängerskript ist nun, dass wir den PWM Pin nicht über die Standard GPIO Bibliothek ansprechen sondern über die WiringPi2 Bibliothek. Der vollständige Code sieht wie folgt aus:

import RPi.GPIO as GPIO
import wiringpi2 as wiringpi
import time

#pins
M1     = 40 #rot
PWM    = 18 #rot-lila
M2     = 36 #weiss
FULLSPEED  = 1024 #between 0 and 1024
LOWSPEED   = 450
TURNSPEED  = 460
GPIO.setmode(GPIO.BOARD)
wiringpi.wiringPiSetupGpio() #also setup GPIO for wiringpi

GPIO.setup(M1, GPIO.OUT)
GPIO.setup(M2, GPIO.OUT)
wiringpi.pinMode(PWM, 2)     #also set Pinmode for WiringPi PWM Pin

def move():
 GPIO.output(M1, True)
 GPIO.output(M2, True)
 wiringpi.pwmWrite(PWM, FULLSPEED) #full speed

def reverse():
 GPIO.output(M1, False)
 GPIO.output(M2, False)
 wiringpi.pwmWrite(PWM, LOWSPEED) #half full speed

def left():
 GPIO.output(M1, True)
 GPIO.output(M2, False)
 wiringpi.pwmWrite(PWM, TURNSPEED) #quarter full speed

def right():
 GPIO.output(M1, False)
 GPIO.output(M2, True)
 wiringpi.pwmWrite(PWM, TURNSPEED) #quarter full speed

def stop():
 GPIO.output(M1, False)
 GPIO.output(M2, False)
 wiringpi.pwmWrite(PWM, 0)       #engine off

def init():
 stop()

def getch():
 import sys, tty, termios
 old_settings = termios.tcgetattr(0)
 new_settings = old_settings[:]
 new_settings[3] &= ~termios.ICANON
 try:
 termios.tcsetattr(0, termios.TCSANOW, new_settings)
 ch = sys.stdin.read(1)
 finally:
 termios.tcsetattr(0, termios.TCSANOW, old_settings)
 return ch

init()
loop = True

_move = 0
_reverse = 0
_left = 0
_right = 0
while loop:
 c = getch()
 if c == 'a' and _left == 0:
 left()
 _left = 1
 _right = 0
 _move = 0
 _reverse = 0
 if c == 'd' and _right == 0:
 right()
 _left = 0
 _right = 1
 _move = 0
 _reverse = 0
 if c == 'w' and _move == 0:
 move()
 _left = 0
 _right = 0
 _move = 1
 _reverse = 0
 if c == 's' and _reverse == 0:
 reverse()
 _left = 0
 _right = 0
 _move = 0
 _reverse = 1
 if c != 'a' and c != 'd' and c != 'w' and c != 's':
 _move = 0
 _reverse = 0
 _left = 0
 _right = 0
 stop()
 if c == 'q':
 loop = False
 stop()
 time.sleep(0.5)

GPIO.cleanup()

Neu ist die Importzeile für WiringPi2:

import wiringpi2 as wiringpi

Bei der Definition der Variablen wurden die zwei PWM Zeilen entfernt und durch eine einzelne PWM Zeile plus drei unterschiedlichen Geschwindigkeitsvariablen ersetzt:

PWM = 18 #rot-lila
...
FULLSPEED = 1024 #between 0 and 1024
LOWSPEED = 450
TURNSPEED = 460

Die Nummer des PWM Pins ist 18. Das ist wie bereits erwähnt die einzig korrekte Nummer. Bei der Geschwindigkeit gibt es die Höchstgeschwindigkeit und danach zwei Werte für den Rückwärtsgang und dem Drehen des Roboters.

Für WiringPi muss genau wie für die normale GPIO Schnittstelle in einer Initialisierung gesagt werden, wie die Pins durchnummeriert sind.

wiringpi.wiringPiSetupGpio() #also setup GPIO for wiringpi

Für den PWM Pin müssen wir dann auch noch definierten ob er ein INPUT, OUTPUT oder PWM_OUTPUT Pin ist. Die 2 steht für PWM_OUTPUT:

wiringpi.pinMode(PWM, 2) #also set Pinmode for WiringPi PWM Pin

Zuletzt gibt es noch in jeder der 4 möglichen Richtungsfunktionen eine Änderung. Die beiden PWM Pins sind weg und durch einen einzelnen PWN Aufruf ersetzt worden. Der Funktion pwmWrite übergibt man neben der Nummer des GPIO Pins auch noch die Geschwindigkeit.

wiringpi.pwmWrite(PWM, FULLSPEED) #full speed

Fazit

Mit nur kleinen Änderungen verbessert man das Bewegungsskript für den Roboter sehr stark. Der Faktor Geschwindigkeit lässt den Roboter viel schöner bewegen. Dieser steuert sich realistischer und vor allem durch die niedrigere Umdrehungsgeschwindigkeit auch deutlich präziser.

Roboter bewegen für Fortgeschrittene

BSD installieren

In diesem Artikel zeige ich euch wie man BSD installieren kann. Steven und ich hatten vor einiger Zeit zu Artikelideen für eine Zusammenarbeit aufgerufen. Die meisten Vorschläge drehten sich um das BSD Betriebssystem und dessen Derivate. Steven hat den ersten Beitrag dazu zu den Unterschieden d...
BSD installieren

Domain Verzeichnisschutz für Multi-Domain Seiten

In diesem Artikel zeige ich wie man den .htaccess Domain Verzeichnisschutz auf eine bestimmte Domain einschränken kann. Das ist immer dann erforderlich, wenn man eine Mulit-Domain Seite gehostet hat. Mehrere Domains zeigen dabei auf den selben Webspace und verwenden ein und die selbe ...
Domain Verzeichnisschutz für Multi-Domain Seiten