Petschbot

Abbruch Bunker Osterfeld

2014-06-08T12:47:00.001+02:00

Mit welchen Mühen der Abbruch eines Luftschutzhochbunkers verbunden ist, kann man derzeit in Oberhausen Osterfeld nachvollziehen. Mit maximal schweren Abbruchgerät wird hier der Bunker an der Bottroper Straße abgetragen. Aus den Fotos ergibt sich ein seltener Querschnitt durch einen solchen Bunker. Warum hier ein solcher Aufwand getrieben wird ist mir aber schleierhaft. Mit den Grundstückspreisen in dieser Ecke dürfte es kaum zusammenhängen...

Wald...

2014-06-07T16:08:00.001+02:00

How to export Evernote notes to plain text files via NvAlt

2014-05-13T22:03:00.000+02:00

Out of the box, Evernote can only export notes as a single XML-File (exml) or as multiple HTML files. Here a simple how to for exporting Evernote Notes to plain text files via NvAlt.

You will need:

Evernote Desktop Client for OSX

NvAlt

Export your notes from Evernote to HTML files (File -> Export)
Open the NvAlt Preferences and go to "Notes", "Storage". Select the Evernote Export Folder as Storage Folder and "Formatted HTML" as storage format. Close the NvAlt Preferences
NvAlt will now import the Evernote HTML-Export files.
Select all notes inside NvAlt and export them to plain text files via "File -> Export"

iOS7: Website für Präsentation offline verfügbar machen

2013-10-09T21:24:00.000+02:00

Heute mal wieder ein Post aus der Reihe praktische Herausforderungen des Arbeitsalltags. Mein Team hat einen HTML5 Prototypen gebaut, inkl. aufwändiger JavaScript Effekte und optimiert für das iPad. Der Kunde wünscht nun diesen Website-Prototypen in internen Runden auch ohne Netzzugang auf dem iPad präsentieren zu können.

Jailbreak-Webserver fallen hier raus und ausgänglich plante ich die Website mittels Dropbox oder Documents von Readdle auf das iPad zu bringen. Beide Lösungen rendern die Site aber nicht sauber. Rund 5 gruselige Offline-Reader aus dem AppStore später kam ich über Googlen und das stets verlässliche StackOverflow auf die richtige Fährte.

Die HTML5 Spezifikation sieht bereits vor über sogenannte Cache Manifest Dateien dem Browser des ausspielenden Devices anzuweisen die dort definierten Teile einer Website lokal zu cachen.

Die Manifestdatei selber wird einfach in der Index.html referenziert.

<html manifest="cache.manifest">

Die Datei cache.manifest wiederum ist inhaltlich im einfachsten Fall auch übersichtlich und umfasst neben einem Headerteil eine Auflistung der Lokal zu cachenden Dateien, relativ zum Manifest. Wichtig dabei ist die pro Revision der Website eindeutige Versionsnummer und das die Dateidefinition keine Wildcards umfassen darf.

CACHE MANIFEST
# Version 201310916251
CACHE:
/index.html
/images/image1.png

Um die Generierung dieses Manifests zu erleichtern habe ich ein kleines Rubyscript geschrieben.

#!/usr/bin/ruby -w
t = Time.new
timestamp = t.year, t.month, t.day, t.hour, t.min, t.sec
open('cache.manifest', 'w') do |fo|
  fo.puts "CACHE MANIFEST"
  fo.puts "# Version #{timestamp}"
  fo.puts "CACHE:"
  array = Dir["./**/*"].select{|f| !File.directory? f}
  array.each do |i|
    fo.puts "#{i}".gsub(/^\./, "")
  end
end

An sich ist damit alles vorbereitet damit der Mobile Safari auf dem iPad beim ersten Aufruf der Website eine lokale Kopie in den Cache schaufelt. Um diese Upzudaten muss der User entweder einen manuellen Reload forcieren oder die Versionsnummer in der cache.manifest inkremiert werden (was das Script über einen Zeitstempel erledigt). Um das ganze schön zu machen wurde in der Index.html noch über das passende metatag auf ein schickes Icon verwiesen und das Ganze kann dann über die entsprechende Funktion des mobile Safari als Bookmark direkt auf den Homescreen abgelegt werden.

Somit war nur noch eine Frage offen: Wie groß darf die Website sein. Apple schweigt sich dazu in seiner Developer Reference aus, im Netz finden sich angaben im Bezug auf iOS6 zwischen 5 und 10MB. Mittels Trail and Error konnte ich ermitteln, dass unter iOS 7 eine Website über die cache.manifest 20MB cachen darf. Geht die Summe der Dateien darüber hinaus wird interessanterweise radikal gar nichts gecacht!

Weitergehende Infos hier:

https://developer.apple.com/library/safari/documentation/iphone/conceptual/safarijsdatabaseguide/OfflineApplicationCache/OfflineApplicationCache.html#//apple_ref/doc/uid/TP40007256-CH7-SW1

https://developer.apple.com/library/safari/documentation/AppleApplications/Reference/SafariHTMLRef/Articles/MetaTags.html#//apple_ref/doc/uid/TP40008193-SW1

RUBY: Geo-Locations Referenzpunkten zuordnen

2013-04-22T15:07:00.000+02:00

Das folgende Script sieht vor im zu untersuchenden Gebiet ein oder mehrere Referenzpunkte zu setzen und darum einen Radius in Metern zu schlagen. Diese Referenzpunkte werden in der ersten CSV-Datei hinterlegt. Die Radien dürfen sich dabei überschneiden. In einer zweiten CSV-Datei findet sich die Geo-Locations.

Das Script kalkuliert anschließend die Distanz zwischen den Referenzpunkten und den Locations und vergleicht, ob die Location innerhalb der (pro Referenzpunkt individuell zu definierenden) Radien liegt. Dafür verwendet es eine Kalkulation nach Haversine wie in diesem Blogpost beschrieben: http://codingandweb.blogspot.de/2012/04/calculating-distance-between-two-points.html

Falls eine Location in den Radien mehrerer Referenzpunkte liegt wird der am nächsten liegende Referenzpunkt als Empfehlung bestimmt. Die Ergebnisse werden im Terminal und gleichzeitig als CSV-Datei ausgegeben. Anhand dieser Angaben lassen sich Locations gruppieren und z.B. eine Location-basierte Abarbeitung planen.

Datenfelder in der Locations-CSV

id (ID der Location)
lat (Location Latitude in der Form 59.1234)
long (Location Longitude in der Form 6.1234)
name (Name der Location)

Datenfelder in der Referenzen-CSV

id (ID des Referenzpunkts)
lat (Referenzpunkt Latitude)
long (Referenzpunkt Longitude)
radius (Gewünschter Radius um den Punkt im Meter)

Datenfelder in der Output-CSV

id (Location ID)
name (Name der Location)
lat (Location Latitude)
long (Location Longitude)
ref matches (Anzahl der Referenzpunkte, in deren Radius die Location liegt)
ref recommendation (Referenzpunkt am nächsten zur Location)
ref shortest distance (Distanz in Metern zu diesem Referenzpunkt)
ref %id% (Liegt Location im Radius des Referenzpunktes %id% (true/false))
ref %id% distance (Distanz in Metern der Location zum Referenzpunkt %id%)

#!/usr/bin/ruby -w

require 'rubygems'
require 'fastercsv'

# Dateien über Kommandozeilenargumente definieren
reference_csv = ARGV[0] # CSV-datei mit den Referenzpunkten (id;lat;long;radius)
locations_csv = ARGV[1] # CSV-Datei mit den Locations () (id;lat;long)
output_csv = ARGV[2] # Gewünschter Name der Output-Datei


# Mathematische Funktionen um Distanz zwischen zwei Punkten definieren zu können
# http://codingandweb.blogspot.de/2012/04/calculating-distance-between-two-points.html

def power(num, pow)
  num ** pow
end

def haversine(lat1, long1, lat2, long2)
  dtor = Math::PI/180
  r = 6378.14*1000

  rlat1 = lat1 * dtor 
  rlong1 = long1 * dtor 
  rlat2 = lat2 * dtor 
  rlong2 = long2 * dtor 

  dlon = rlong1 - rlong2
  dlat = rlat1 - rlat2

  a = power(Math::sin(dlat/2), 2) + Math::cos(rlat1) * Math::cos(rlat2) * power(Math::sin(dlon/2), 2)
  c = 2 * Math::atan2(Math::sqrt(a), Math::sqrt(1-a))
  d = r * c

  return d
end

# Referenzpunkte in Array einlesen

references = []
reference_line_counter = 0

FasterCSV.foreach(reference_csv, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|
  unless reference_line_counter == 0 then
    references.push ("#{row[0]}|#{row[1]}|#{row[2]}|#{row[3]}")
  end
  reference_line_counter += 1
end

puts "#{(reference_line_counter - 1)} Referenzen eingelesen."
puts " "

# Locations einlesen und berechnen, ob sie innerhalb des definierten Radius der einzelnen Referenzpunkte liegen

location_line_counter = 0
reference_to_check = []
reference_result_string = ""
reference_match_counter = 0
reference_shortest_distance = 0
reference_nearest_to_location = ""

FasterCSV.foreach(locations_csv, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|
  unless location_line_counter == 0 then
    location_id = "#{row[0]}"
    location_lat = "#{row[1]}"
    location_long = "#{row[2]}"
    loctaion_name = "#{row[3]}"


    puts " "
    puts "==============================================================================================="
    puts "Prüfe #{location_id} (#{location_name}, Lat #{location_lat}, Long #{location_long})"
    puts " "

    references.each do |ref|
      ref_string = "#{ref}"
      reference_to_check = ref_string.split("|")
      reference_to_check_id = reference_to_check[0]
      reference_to_check_lat = reference_to_check[1]
      reference_to_check_long = reference_to_check[2]
      reference_to_check_radius = reference_to_check[3]

      puts "---------------------"
      puts "Referenzpunkt #{reference_to_check_id}: Lat #{reference_to_check_lat}, Long #{reference_to_check_long}, Radius #{reference_to_check_radius} m"

      distance = (haversine(location_lat.to_f,location_long.to_f,reference_to_check_lat.to_f,reference_to_check_long.to_f)).round
      puts "Distanz zwischen Location und Referenzpunkt: #{distance} m"

      if distance < reference_to_check_radius.to_f then
        puts "#{location_id} (#{location_name}) in Radius von Referenzpunkt #{reference_to_check_id}: true"
        puts " "
        reference_result_string += "true;#{distance};"
        if reference_match_counter == 0 then
          reference_shortest_distance = distance
          reference_nearest_to_location = "#{reference_to_check_id}"
        else
          if distance < reference_shortest_distance then
            reference_shortest_distance = distance
            reference_nearest_to_location = "#{reference_to_check_id}"
          end 
        end
        reference_match_counter += 1
      else
        puts "#{location_id} (#{location_name}) in Radius von Referenzpunkt #{reference_to_check_id}: false"
        puts " "
        reference_result_string += "false;#{distance};"
      end
    end

    puts "Location liegt im Radius von #{reference_match_counter} Referenzpunkten"
    unless reference_match_counter == 0 then
      puts "Der am nächsten liegende Referenzpunkt ist #{reference_nearest_to_location} (#{reference_shortest_distance} m)"
    end

    reference_result_string = reference_result_string.chop

    open(output_csv, 'a') do |f|
      f.puts "#{location_id};#{location_name};#{location_lat};#{location_long};#{reference_match_counter};#{reference_nearest_to_location};#{reference_shortest_distance};#{reference_result_string}"
    end
    reference_result_string = ""
    reference_match_counter = 0
    reference_nearest_to_location = ""
    reference_shortest_distance = 0

  else
    reference_id_header = ""

    references.each do |ref|
      ref_string = "#{ref}"
      reference_to_check = ref_string.split("|")
      reference_to_check_id = reference_to_check[0]
      reference_id_header += "ref #{reference_to_check[0]};ref #{reference_to_check[0]} distance;"
    end
    reference_id_header = reference_id_header.chop

    open(output_csv, 'w') do |f|
      f.puts "id;name;lat;long;ref matches;ref recommendation;ref shortest distance;#{reference_id_header}"
    end
  end
  location_line_counter += 1
end

puts " "
puts "==========================================="
puts "==========================================="
puts " "
puts "Operation abgeschlossen. #{(location_line_counter - 1)} Locations verarbeitet und Ergebnisse in #{output_csv} geschrieben."

Fotografie: Winterliche Impressionen aus dem Revierpark Vonderort

2013-02-10T13:20:00.002+01:00

Einige winterliche Bilder aus dem Revierpark Vonderort in Oberhausen

Fotografie: Architekturpanorama mit dem iPhone 5

2013-02-07T17:07:00.000+01:00

Heute mal ein Härtefalltest für jede Stitching-Software: Architektur. Aus meiner Sicht schlägt sich hier das iPhone 5 gar nicht mal so übel, eine ruhige Hand vorausgesetzt halten sich die perspektivischen Fehler in Grenzen

Fotografie: Panoramaaufnahmen mit dem IPhone 5

2013-02-04T22:37:00.002+01:00

Früher habe ich Panoramen umständlich mit der Kompaktkamera und Stitchingsoftware angefertigt, und gerade bei detailreichen Aufnahmen - z.B. im Wald - waren saubere Übergänge eher schwierig. Und heute findet sich solche Funktionalität dank ausreichender mobiler Rechenleistung und halbwegs brachbarer Kameras direkt im Handy...

Fotografie: Winter-Makro

2013-01-13T15:27:00.000+01:00

Zwei winterliche Makro-Aufnahmen aus dem Naturpark Hohe Mark

Fotografie: Regenbogen am Heidesee

2012-12-02T20:24:00.000+01:00

OK, ich bin bei der Aktion maximal nass und von Hagelkörnern verschrammelt worden, aber das Foto vom Regenbogen über dem Heidesee in Bottrop-Kirchhellen war es wert.

Notiz an mich: Bestand an Regenbekleidung optimieren
Erkenntnis des Tages: Mit der Lüftung im Skoda Yeti kann man sich die Haare trocken föhnen

Fotografie: Winteranfang am Heidhof

2012-12-02T00:25:00.000+01:00

Die Wandersaison neigt sich dem Ende zu und wenn ich so auf die "Wanderuhr" schaue kommen da dieses Jahr bei mir so rund 500km in den heimischen Forsten zusammen. Der Großteil entfällt dabei auf dei Hohe Mark und insbesondere auf mein "Stammrevier" rund um den Heidhof. Neben vielen erholsamen Stunden in der Natur habe ich dort dieses Jahr auch mein Kartenmaterial ergänzt und präzisiert, nicht jeder OSM-Weg ist noch gangbar, das prominenteste Beispiel dürfte der Wegfall der Schwarzbachbrücke sein...

Quasi zum Abschluss noch ein eine Rutsche spätherbstliche/frühwinterliche Fotos

Der Heidhofsee

Bedingt durch den geringen Nährstoffgehalt der sandigen Heideböden sind die Naturwaldzellen rund um den Heidhof hauptsächlich mit niedrigeren Eichenbäumen bewachsen. Diese lassen viel Licht für Unterholz, in diesem Fall ein schon verdorrter Teppich aus Farn.

Wintergrün auf den angrenzen Äckern

Ruby: Dateien mit Daten aus CSV umbenennen

2012-11-22T15:42:00.003+01:00

Heute mal wieder ein Beispiel aus der Praxis wie wir mit Hilfe eines Ruby-Scripts Dateien gemäß den Angaben in einer CSV-Datei umbenennen können.

Die Ausgangslage sah folgendermaßen aus: Zum einen hatte ich einen Order (fotos2) mit Bildern, die nach dem folgenden Muster benannt waren:

001_außen.jpg
001_innen.jpg
002_logo.jpg

Zum anderen hatte ich eine CSV-Datei (namen.csv) mit folgendem Inhalt:

"id";"name"
"001";"Cafe Schaefer"
"002";"Brauhaus"

Die Anforderung war es jetzt, die Dateinamen in diese Form zu ändern:

001_Cafe Schaefer_1.jpg
001_Cafe Schaefer_2.jpg
002_Brauhaus_1.jpg

Die Lösung ist das unten gezeigte Script. Zunächst habe ich zwei Hashes angelegt und mit Hilfe von FasterCSV befüllt. Die Keys in beiden Hashes bilden die ID aus Spalte 1 (row[0]). merchant_names_hash speichert dabei die Namen nach dem Muster "002 => Brauhaus", merchant_foto_amount ist einfach ein Counter mit dem Startwert 1, also z.B. "001 => 1". Anschließend werden die Dateinamen aus dem Verzeichnis in einen Array geschrieben und durch iteriert. Dabei extrahiere ich zunächst die ID aus dem Dateinamen und schaue ob diese als Key im Hash merchant_names_hash enthalten ist. Wenn ja wird mit den Informationen aus diesem Hash und dem Wert aus dem Counter ein neuer Dateiname gebildet, der Counter einen hochgezählt und abschließend die Datei umbenannt.

require 'rubygems'
require 'fastercsv'

basedir = "./fotos2/"
csv_file = "namen.csv"

merchant_names_hash = Hash.new
merchant_foto_amount = Hash.new

FasterCSV.foreach(csv_file, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|
  merchant_names_hash.store ("#{row[0]}","#{row[1]}")
  merchant_foto_amount.store ("#{row[0]}",1)
end

files = Dir.glob("#{basedir}*")

files.each do |file|
  name = "#{file}"
  filebasename = File.basename(file)
  
  if filebasename =~ /^(\w*)_/ then
    foto_id = $1
  end
  
  if merchant_names_hash.has_key?(foto_id) then
    newname = "#{basedir}/#{foto_id}_#{merchant_names_hash [foto_id]}_#{merchant_foto_amount [foto_id]}.jpg"
    merchant_foto_amount [foto_id] += 1
    File.rename(name, newname)
  end

end

Fotografie: Herbst in der Mark

2012-11-18T20:41:00.000+01:00

Hier mal ein paar herbstliche Impressionen, aufgenommen in Bottrop Grafenmühle (Naturpark Hohe Mark). Mehr Bilder gibt es in meinem Tumblr-Blog.

Ruby: Der Unwetter-Bot mit Twitter- und Arduino-Anbindung

2012-11-07T11:12:00.000+01:00

tldr; (Abstract)

In diesem Blogpost zeige ich, wie man mit einem Ruby-Script über Regular Expressions statische Webseiten automatisiert auswertet und abhängig vom Ergebnis über das Twitter Gem eine Direct Message verschickt.

Die Warnseite des Deutschen Wetterdienstes hatte bei mir schon immer einen festen Platz auf der Bookmarkliste. Wer will schon mit offenen Fenstern vom Sturm überrascht werden und als Bahnfahrer ist man in der Regel eh "unwettersensitiv".

Das Problem: Man muss die Informationen selber einholen. Besser wäre es natürlich, wenn man die Informationen automatisch als Direct Message bekommt und am allerbesten wenn diese Infos für weitere Automatisierungen herhalten könnten. Genau das ermöglicht das folgende Script.

Vorab aber zwei Warnhinweise:

Die Wetterdaten des DWD unterliegen dem Urheberrecht. Sich selber eine DM oder Notification auf Basis frei verfügbarer Informationen zu senden oder für weitere Heim-Automatisierung zu verwenden ist eine Sache, die via Script gewonnen Daten anderweitig zu veröffentlichen eine (wohl kaum durch die DWD-AGB gedeckte) andere Sache. Und das mit Recht, denn:
Unwetterschutz ist eine ernste Sache. Das Script ist mehr ein Proof-of-Concept und sollte nicht in Bereichen eingesetzt werden, in dem Leib und Leben von einer 100% korrekten Funktion abhängt. Dazu später auch noch mehr... Wenn ihr eine "ernsthafte" Anwendung plant könnt ihr euch direkt an den DWD wenden, die bieten ein breites Produktportfolio. Ich habe mir deren Warnseiten hier aufgrund ihres recht statischen Charakters exemplarisch rausgepickt.

Nun aber zur Funktion des Scripts. Zuvor sollte man wissen, dass der Deutsche Wetterdienst seine Warninformationen individuell für Kreise auf eigenen statischen Webseiten ohne jQuery-Schischi anbietet, soweit ich das sehen kann decken sich diese Kreise mit den Landkreisen, ggf. noch einmal wetterrevelant unterteilt, und werden vom DWD mit 3-Buchstaben-Kürzeln versehen. Beispiele:

Stadt Bottrop: http://www.dwd.de/dyn/app/ws/html/reports/BOT_warning_de.html

Cuxhaven Binnenland http://www.dwd.de/dyn/app/ws/html/reports/CUI_warning_de.html

Das Script macht sich nun zunutze, dass der DWD die Warnlage auf diesen Landkreisseiten immer gleich aufbaut. Wenn keine Warnung vorliegt findet sich der entsprechende String "keine Warnungen" im Seitenquelltext, ansonsten werden Warnmeldungen mit "Amtliche Warnmeldung" begonnen.

Diesen relativ statischen Aufbau macht sich das Script zunutze und steuert nicht nur seinen eigenen Prozesslauf, sondern extrahiert auch die folgenden relevanten Informationen über Regular Expressions aus dem Seitenquelltext:

Name des Landkreises
Titel der Warnmeldung
Zeitlicher Beginn der Warnlage
Zeitliches Ende der Warnlage
Veröffentlichungszeitpunkt

Insbesondere die Extraktion des Veröffentlichungszeitpunkt ist für den Prozesslauf von besonderer Bedeutung:

Zunächst prüft das Script, ob überhaupt eine Warnmeldung vorliegt.
Ist das der Fall werden die o.g. Daten extrahiert und in eigene Variablen weggeschrieben
Aus dem Veröffentlichungszeitpunkt wird unter der Annahme, das pro Landkreis eine individuelle Warnmeldung über den minutengenauen Veröffentlichungszeitpunkt determiniert werden kann, eine ID gebildet.
Diese ID wird mit den IDs aus einer CSV-Datei verglichen. Diese enthält alle bereits durch das Script für diesen Landkreis registrierten Warnmeldungen.
Ist die ID bereits in der Liste enthalten endet das Script hier.
Ist die ID noch nicht enthalten wird sie zusammen mit den anderen extrahierten Informationen der CSV-Datei hinzugefügt.
Als weitere Aktionen wird mir zum einen der Titel der Warnmeldung als Direct Message via Twitter zugestellt.
Zudem prüft das Script optional, ob laut Titel die Warnmeldung vor einem Regenereignis warnt. Wenn ja wird über den seriellen Monitor eine "1" geschrieben. (Diese Information könnte wiederum von einem Arduino genutzt werden, um im Rahmen der Heimautomation ein Rückschlagventil im Keller zu schließen. Zum Thema Ruby<>Arduino Kommunikation siehe u.a. meinen älteren Blogpost Arduino, das Restclient Gem und bidirektionale Kommunikation).

Um korrekt zu funktionieren benötigt das Script ein paar Konfigurationsparameter, die am Anfang definiert werden:

Den DWD-Citycode, der über die Bundeswarnkarte via Durchklicken ermittelt werden kann.
Den Dateinamen der CSV-Datei zum loggen der Warnmeldungen
Den Intervall für die erneute Prüfung der Warnseite in Sekunden.
Die API-Keys für die Twitter-API, näheres siehe dazu auf der Seite des Twitter-Gems und auf dem Developerportal von Twitter
Konfigurationsparameter für das Schreiben auf dem seriellen Port.

Soweit so gut hat das Script doch einen kleinen Schönheitsfehler. Es wertet immer nur die die erste Warnmeldung auf der Warnseite auf. Der DWD fügt die neueste Warnmeldung immer oben auf der Seite hinzu, wenn eine alte Warnmeldung noch Bestand hat rutscht diese weiter herunter. Insofern ist die Einstellung für den Aktualisierungsintervall mit Bedacht zu wählen, auf der einen Seite wollen wir die DWD-Seite nicht fluten, auf der anderen Seite keine Warnmeldung verpassen. Eine Einstellung von 5 Minuten (300 Sekunden) sollte dabei einen guten Mittelweg darstellen. Die technisch saubere Lösung würde daraus bestehen alle Warnmeldungen auf der Seite wie oben beschrieben zu parsen und nicht nur die erste Meldung. Aber zum einen würde das über das Proof-of-concept-Ziel "Abhängig von einer Meldung auf einer Webseite führen wie eine Aktion aus" hinausgehen und zum anderen wäre es bedeutet einfacher, dafür den eMail-Newsletter des DWD zu analysieren. Wie das geht werden wir uns in einem späteren Beitrag zu Gemüte führen, sobald ich mich mit den entsprechenden email-Ruby-Gems beschäftigt habe ;-)

Zuletzt noch ein Dank an den Deutscher Wetterdienst für seine Arbeit. Besucht mal deren Webseite, für Wetter-Nerds ist das eine wahre Fundgrube :-)

require 'rubygems'
require 'rest-client'
require 'fastercsv'
require 'twitter'
require 'serialport'

### Konfiguration ###

# DWD Citycode  
city = "BOT"

# Logging CSV
csvfilename = "logging.csv"

# Sleep-Intervall in Sekunden
intervall = 300

# Twitter
Twitter.configure do |config|
  config.consumer_key = ''
  config.consumer_secret = ''
  config.oauth_token = ''
  config.oauth_token_secret = ''
end

# Arduino Serial Monitor
serial_support = false

if serial_support == true then
  serial_port = "/dev/tty.usbmodem411"
  serial_baud_rate = 9600
  serial_data_bits = 8
  serial_stop_bits = 1
  serial_parity = SerialPort::NONE
  # init serial port
  sp = SerialPort.new(serial_port, serial_baud_rate, serial_data_bits, serial_stop_bits, serial_parity)
end

#########################################


loop do
 begin

    response = RestClient.get "http://www.dwd.de/dyn/app/ws/html/reports/#{city}_warning_de.html"
  
    if response =~ /keine Warnungen/ then
      puts "DWD: Keine Warnung in #{city}"
    
    elsif response =~ /Amtliche WARNUNG/ then
      if response =~ /(Amtliche WARNUNG vor [\D]+)(<\/.*>)$/ then
        message = $1.gsub(/\n/," ").gsub(/(<.*>)/,"").gsub("  "," ").strip
      end

      # Startdatum ($3) und Uhrzeit ($5)
      if response =~ /(gültig von: )(\w*,\s)(\d*\.\d*\.\d*)(.)(\d\d:\d\d)/ then
        startdate = $3
        starttime = $5
      end
    
      # Enddatum ($3) und Uhrzeit ($5)
      if response =~ /(bis: )(\w*,\s)(\d*\.\d*\.\d*)(.)(\d\d:\d\d)/ then
        enddate = $3
        endtime = $5   
      end
    
      # Ausgabedatum und Zeit
      if response =~ /(am: )(\w*,\s)(\d*\.\d*\.\d*)(.)(\d\d:\d\d)/ then
        announcedate = $3
        announcetime = $5   
      end
      
      # Name der Stadt
      if response =~ /<title>(.*)-(.*)<\/title>/ then
        cityname = $2.strip
      end
    
      # Aus Ausgabedaten notification_id generieren, Muster: ddmmyyyyhhmm
      notification_id = (announcedate+announcetime).gsub(".","").gsub(":","")
    
      linenumber = 0
      notification_id_logging = 0
      notification_id_already_logged = false
    
      # Logging-Datei parsen
      FasterCSV.foreach(csvfilename, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|
        # Erste Zeile erhält nur Header
        unless linenumber == 0 then
          # notification_id_logging aus erster Zelle auslesen 
          # und mit aktueller notification_id vergleichen
          notification_id_logging = row[0].to_i
          if notification_id_logging == notification_id.to_i then
            notification_id_already_logged = true
          end
        end
        linenumber += 1
      end
    
      # Falls Warnung noch nicht im Log...
      if notification_id_already_logged == false then
        # Warnung der CSV-Datei hinzufügen
        open(csvfilename, 'a') do |fileop|
          fileop.puts "#{notification_id};#{announcedate};#{announcetime};#{message};#{startdate};#{starttime};#{enddate};#{endtime}"
        end
        Twitter.direct_message_create("petschbot", "DWD-Warnung für ##{cityname}: #{message}")
        puts "DWD-Warnung für ##{cityname}: #{message}"
        if serial_support == true then
          if message =~ /regen/i then
            sp.write "1"
          end
        end
      end
  
    else
      puts "Warnstatus für #{city} nicht auslesbar"
    end

  rescue => error
    puts "Error (Falscher Stadtcode?)"
  end

sleep(intervall)

end

Ruby: Daten strukturiert einlesen mit FasterCSV

2012-10-24T21:34:00.000+02:00

Heute mal ein kurzes Codebeispiel wie wir Daten mit Ruby strukturiert aus einer CSV-Tabelle auslesen und weiterverarbeiten können. Der unten stehende Codeausschnitt ist Teil aus einem größeren Script.

Die Anforderung bestand darin, dass die Rohdaten in einem CSV-File vorliegen und für eine Serie von API-Calls in einen XML-Payload umgewandelt werden müssen, jede Zeile sollte dabei getrennt behandelt werden:

Das CSV-File:

id;var1;var2
1;test1;test12
2;test2;test22
3;test3;test32

Hier ein Ausschnitt aus dem benötigten XML-Payload (am Beispiel des zweite Datensatzes):

<items>
    <code>id</code>
    <content>2</content>
</items>
<items>
    <code>var1</code>
    <content>test2</content>
</items>
<items>
    <code>var2</code>
    <content>test22</content>
</items>

Und hier mein Ruby-Codeschnipsel unter Verwendung des GEMs FasterCSV. Wie man sieht lese ich im ersten Schritt die Feldbezeichner aus der ersten Zeile des CSVs in ein Array (headerarray) und bestimme zugleich die Anzahl der Elemente über .length. Anschließend parse ich die Folgezeilen und baue die gewünschte Struktur durch Verketten eines Strings (items) auf.

linenumber = 0
headerarray = []
header_amount = 0

FasterCSV.foreach(csv_file, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|

  if linenumber == 0 then  
     # Item Codes für Input Items aus Headerzeile einlesen
     headerarray = row
     header_amount = headerarray.length
     header_amount -= 1
  else
    # Für Folgezeilen Input Items einlesen und Items-Teil des XML-Payloads durch verketten generieren
    items = ""
    0.upto(header_amount) do |i|
      items += "<items><code>#{headerarray[i]}</code><content>#{row[i]}</content></items>"
    end
  end

  linenumber += 1

end

Ruby: Verfügbarkeit von URLs checken

2012-10-05T19:53:00.001+02:00

Mal ebend schnell den Response-Status von einer Rutsche URLs checken? Geht einfach mit diesem kurzen Rubyscript unter Verwendung der Gems Restclient und FasterCSV. Das Script wird mit einer CSV gefüttert und erwartet in der zweiten Spalte die URL, die erste Spalte kann mit einer ID oder ähnlichem befüllt werden.

Die Rückgabe kann direkt in eine CSV gepipet werden, am Ende wird ein kurzer Bericht angefügt.

[UPDATE] Hier das ganze auch auf Github: https://github.com/petschbot/onlinechecker [/UPDATE]

#!/usr/bin/ruby -w

# Fast URL response checker
# Author: PS
# Date: 2010/10/05

require 'rubygems'
require 'rest-client'
require 'fastercsv'

# CSV File as first command line argument
# Must be look like this:
# id;url
# 01;http://www.example.com

csv_file = ARGV[0]

      
linenumber = 0
ok_counter = 0
error_counter = 0

FasterCSV.foreach(csv_file, :quote_char => '"', :col_sep =>';', :row_sep =>:auto) do |row|
  unless linenumber == 0 then
    begin
      response = RestClient.get row[1] 
      puts "OK;#{row[0]};#{row[1]}"
      ok_counter = ok_counter + 1
    rescue => error
        puts "Error;#{row[0]};#{row[1]}"
        error_counter = error_counter + 1
    end
  else
    puts "status;#{row[0]};#{row[1]}"
  end
  linenumber = linenumber + 1
end

puts "------"
puts "Report"
puts "OK: #{ok_counter}"
puts "Error: #{error_counter}"

Standbymodus auf dem Macbook Air optimieren und Einfrieren minimieren

2012-09-30T11:16:00.000+02:00

Seit Tagen kämpfe ich mit dem Problem, dass mein Macbook Air beim aufwachen aus dem Standby (genauer gesagt aus dem Suspend to Disk) immer wieder einfriert. Das Problem tritt auf, seitdem ich das EFI Update auf die Boot-ROM-Version MBA31.0061.B07 vorgenommen habe. Witzigerweise sieht Apple keine Möglichkeit vor, ein erfolgreiches EFI-Update wieder rückgängig zu machen und auch ein Reset des System Management Controllers brachte keine Besserung.

Also gut, steigen wir mal kurz tiefer in die Materie ein. Zunächst muss man wissen, dass Apple im großen und ganzen 3 Ruhezustandsmodi (hibernatemode) unterscheidet:

0 - Suspend to RAM only
1 - Suspend to Disk only
3 - Suspend to disk + RAM

Der Modus 3 ist dabei die Standard-Einstellung. Das Macbook Air wechselt erst in das weniger tiefe Suspend to RAM und nach einer bestimmten Zeit in den Modus Suspend to Disk (Deepsleep). Auf diese Weise kann Apple eine Standybyzeit von rund 30 Tagen versprechen, da das Air im Deepsleep kaum Energie verbraucht. Das Problem ist allerdings, dass das Aufwachen aus dem Deepsleep auf meinem Late 2010 MBA mit 4 GB RAM schon so rund 20 Sekunden dauert und zudem seit dem EFI Update in rund 25% der Fälle fehlschlägt.

Eine Möglichkeit wäre es nun den hibernatemode auf Modus 0 zu setzen, was für Desktop-Macs der Standard-Modus ist. Das geht auch ohne Probleme im Terminal mit dem folgenden Befehl:

sudo pmset -a hibernatemode 0

Der große Nachteil ist allerdings, dass das MBA danach nie wieder in den Deepsleep wechselt und im Falle des Leerlaufens des Akkus (Bei voller Ladung nach ca. 4 - 5 Tagen im Mode 0) die Gefahr des Datenverlusts droht.

Insofern ist es eigentlich interessanter anzupassen, wann das MBA vom Suspend to RAM zum Suspend to Disk wechselt. Der default Wert lässt sich ebenfalls recht einfach auslesen:

pmset -g

Ergibt folgende Rückgabe

Active Profiles: Battery Power -1* AC Power -1 Currently in use: standbydelay 4200 standby 1 halfdim 1 hibernatefile /var/vm/sleepimage darkwakes 0 disksleep 10 sleep 45 hibernatemode 3 ttyskeepawake 1 displaysleep 5 acwake 0 lidwake 1

Von besonderen Interesse ist dabei der Wert standbydelay. Er gibt in Sekunden an wann das Air vom Suspend to RAM nach Suspend to Disk wechselt und ist standardmäßig mit 70 Minuten vorbelegt. Um jetzt nicht vollkommen auf Suspend to Disk verzichten zu müssen habe ich diesen Wert nun einmal probeweise auf 36 Stunden verlängert:

sudo pmset -a standbydelay 129600

In der Regel hängt das AIR bei mir eh alle 24 Stunden irgendwann mal am Ladekabel und ich hoffe damit die Deepsleep-Probleme soweit zu verringern bis Apple ein weiteres EFI-Update rausbringt.

Freier Adobe Font Sourcecode Pro

2012-09-28T22:38:00.000+02:00

Adobe hat einen Monospace-Font "Sourcecode Pro" unter OpenSource-Lizenz rausgebracht, der besonders für die Verwendung im Entwicklungsumfeld gestaltet wurde. Interessant ist auch der Blogpost, wieviel Planungsarbeit in den Font gesteckt wurde. Ich finde den Font ihn wirklich sehr leserlich und auch mit Anti-Aliasing brauchbar:

Den Font selber gibt es als Paket in mehreren Variationen auf Sourceforge

Textdateien syncen

2012-08-28T21:56:00.000+02:00

Nach einigem rumschrauben und erheblichen rumprobieren habe ich nun für mich eine gangbare Lösung gefunden, um Informationen in Form von Plaintext zwischen meinen Rechnern und meinem Handy syncen zu können. Das ist mein Setup:

Als Eingabefrontend verwende ich auf dem Mac nvAlt. Dieser Notational Velocity Fork verbindet eine sehr einfache Dateiablage (Alle Datensätze werden als einzelne UTF-8 TXT-Dateien abgelegt und sind direkt in der Anwendung durchsuchbar) mit Markdown- und Datensatz-Verlinkungs-Funktionalitäten.[UPDATE] Im Gegensatz zum Original lässt sich zudem das Color Scheme und das CSS/HTML-Template für das Markdown-Preview Window anpassen sowie Klammern per Autopairing komplettieren. [/UPDATE] Hier werfe ich wirklich alles rein, von Code-Schnipseln über Meeting-Notizen und ToDo-Listen bis hin zu einer DVD-Datenbank.

Gesynct wird das über Dropbox (Affiliate Link). Dabei ist leider eine erhebliche Einschränkung, dass auf meinen Notebooks nur eine Instanz von nvAlt gleichzeitig laufen darf. Theoretisch ließe sich das über den SimpleNote-Support in nvAlt umgehen, mit dem ich aber keine gute Erfahrung gemacht habe: Die Performance ist mies und ich habe auch Daten verloren. Der große Vorteil...

Auf meinem Android-Smartphone kann ich einfach die Dropbox-App samt eingebauten Texteditor verwenden um auf meine Notizen zuzugreifen oder neue anzulegen.

Für mich ebenfalls wichtig: Ich unterliege keinem Lock-In, da die Daten letztendlich immer als Plain-Text Files vorliegen und sich mit jeder beliebigen Anwendung weiterverarbeiten lassen und auch in x Jahren noch verwertbar sein werden. Unter Windows habe ich z.b. früher den Outliner The Guide in Kombination mit Dropbox verwendet. Dort werden die Daten aber in einem anwendungsspezifischen Format abgelegt, aus dem man sie kaum wieder rausbekommt (letztendlich nur alle Notizen in einem RTF oder HTML-Dokument). Aus diesem Grund mache ich auch einen Bogen um Evernote oder Springpad, zudem halte ich diese Anwendungen auch für relativ unperformant, gerade wenn man nur Text-Informationen syncen will.

[UPDATE] In letzter Konsequenz ist das Frontend egal, man könnte ohne Probleme eine Windows-Maschine syncen indem man dort statt nvalt ResophNotes einsetzt. Im Extremfall würden es auch vim und grep auf einer beliebigen unxoiden Kiste tun, Hauptsache es gibt einen Dropbox-Client oder man schraubt sich eine passende API-Anbindung. Statt also eine Anwendung zu wählen und zu überlegen, wie man deren Datenformat über die Cloud gesynct bekommt, verwendet man hier ein möglichst universelles Format und sucht sich solche Anwendungen, die einfach Plain-Text Files aus einem definierten Ordner parsen. [/UPDATE]

Hansa Zentrum

2012-08-22T21:50:00.001+02:00

Frühstück auf dem Sonnendeck

2012-08-22T21:45:00.001+02:00

Arduino, das Restclient Gem und bidirektionale Kommunikation

2012-06-23T10:48:00.000+02:00

Ausgehend von meinem gestrigen Blogpost habe ich mein Rubyscript funktional erweitert. Ein puts an sich ist witzlos, mit einem Restclient kann ich aber beliebige REST APIs eventgesteuert befüttern. Das Ruby Gem rest-client bringt dafür schon alles Notwendige mit. Zudem habe ich nun die Konfiguration des seriellen Devices in ein Commandline Argument verschoben und die Übergabeparameter für den Restclient in Form der URL und des Request Bodys in ein YAML-File. Der Name dieses YAML-Files wiederum wird über ein zweites Commandline Argument übergeben.
Somit ist es möglich, im Sinne eines Plug-Ins eine ganze Reihe von YAML-Files für eine Sammlung von API-Services vorzuhalten.

Die vermutlich größte Einschränkung an dieser Stelle meines Aufbaus ist die mangelnde Implementierung einer Authentifizierungsmethode. Basic Auth lässt sich aber beim rest-client gem relativ schmerzlos in folgender Form direkt in die URL einflechten:

http(s)://username:password@urlofservice.com

Arduino-seitig habe ich nun den einfachen Zeit-Trigger um einen Button-Trigger erweitert. Zudem erfolgt die Kommunikation über den Serial-Port jetzt bidirektional: Wenn der REST-Client auf seinen Call einen Statuscode 200 vom Zielserver zurückerhält schreibt das Rubyscript eine "1" in den seriellen Port. Dies veranlasst den Arduino eine grüne LED für 5 Sekunden leuchten zu lassen. Falls es während des Calls zu einem Error kommt wird [UPDATE] ~~dieser über ein resuce abgefangen und~~[/UPDATE] stattdessen eine 0 über den seriellen Port geschrieben, was Arduino-Seitig eine rote LED leuchten lässt.

tl;dr:

This example combines a ruby script to trigger REST api calls via an event driven Arduino script. The api response triggers an event inside the Arduino script, too (bidirectional communication via the serial port).

[UPDATE] Die Scripte finden sich auch auf GitHub: https://github.com/petschbot/arduino-restapi [/UPDATE]

Ruby-Script

# This script combines the serialport gem with the rest-client gem
# purpose: trigger a REST-API-Call by a serial signal generated by a Arduino
# V1.1 Update: Alternative Exception handling


require "rubygems"
require "serialport"
require 'rest-client'
require 'yaml'


# reading the config yaml
config_file = ARGV[0] # first command line argument, e.g. config.yml
raw_config = File.read(config_file)
app_config = YAML.load(raw_config)


# params for serial port
port_str = ARGV[1] # second command line argument, e.g. /dev/tty.usbmodem411
baud_rate = 9600
data_bits = 8
stop_bits = 1

parity = SerialPort::NONE

# init serial port
sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)


# params for rest client
url = app_config[:restclient][:url]
request_body = app_config[:restclient][:request_body]

sleep 10
puts "Ready!"

while true do
  
  sp_string = sp.gets
  
  # If the arduino send an "a" via the serial port start the REST Call
  if sp_string.to_s =~ /a/ then

      response = RestClient.post(url, request_body, :content_type => 'application/xml', :accept => 'application/xml'){|response, request, result| response }
      puts response

      # if the REST Call was sucessfull ACK by the server send a "1" to the Arduino
      if response.code == 200 then
        sp.write "1"
      else
        sp.write "0"
      end

  end
end

sp.close

Arduino-Script

 // Initalize variables

 int led_red = 12;
 int led_green = 10;
 int button = 8;
 int incoming = 0;


 void setup() {                
   // initialize the digital pins as output and input.
   pinMode(led_red, OUTPUT);
   pinMode(led_green, OUTPUT);
   pinMode(button, INPUT);

   // initialize the serial port
   Serial.begin(9600);  
 }

 // the loop routine runs over and over again forever:
 void loop() {

   // turn booth leds off
   digitalWrite(led_red, LOW);
   digitalWrite(led_green, LOW);


   // if button is pushed send an a and wait two sec
   // so the button can be raised again
   if (digitalRead(button) == HIGH) {     
     Serial.print("a");
     delay(2000);
   }

   incoming = Serial.read();

   // if an "0" is received turn on the red led for 5 seconds
   if (incoming == 48) {
     digitalWrite(led_red, HIGH);
     delay(5000);
   }

   // if an "1" is received turn on the green led for 5 seconds
   if (incoming == 49) {
     digitalWrite(led_green, HIGH);
     delay(5000);
   }


 }

Und so sieht das ganze in der Hardware-Verdrahtung aus:

Arduino und Ruby verbinden

2012-06-20T19:00:00.000+02:00

Heute mal ein Tech-Basteleintrag. Die letzten Tage habe ich mit meinem Arduino aus der Fritzing-Box ein wenig rumgespielt. Neben dem Nachbauen der Schaltungen aus dem Video-Tutorial fand ich es persönlich interessant, eine Verbindung zwischen dem Arduino und einem lokalen Ruby-Script herzustellen. Diese ersten Schritten sollen die Basis für die Entwicklung eines Twitter-Statusbots sein, der abhängig von digitalen/analogen Messwerten entsprechende Nachrichten absetzt.

Das hier gezeigte erste Testsetup:

Simuliert von Seiten des Arduinos als Aktio das eventabhängige Absetzen eines Status via Serial.println (statt eines Messwerts ist hier einfach nur ein zeitabhängiger Trigger verbaut).
Auf Seiten des Rubyscripts als Reaktio eine einfache Quittierung über puts.

Arduino-Script:

void setup() {                
  Serial.begin(9600);  
}

void loop() {

  Serial.println("a");
  delay(5000);
  Serial.println("b");
  delay(5000);
  
}

Ruby-Script

#simplest ruby program to read from arduino serial, 
#using the SerialPort gem
#(http://rubygems.org/gems/serialport)

require "rubygems"
require "serialport"

#params for serial port
port_str = "/dev/tty.usbmodem411"  #may be different for you
baud_rate = 9600
data_bits = 8
stop_bits = 1
parity = SerialPort::NONE

sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)

#just read forever
while true do
  
  sp_string = sp.gets
  puts sp_string
  if sp_string.to_s =~ /a/ then
    puts "A empfangen"
  elsif sp_string.to_s =~ /b/ then
    puts "B empfangen"
  end

end

sp.close                       #see note 1

Von Vonderort nach Kirchhellen: Auf dem Wanderweg X11 durch Bottrop

2011-04-03T12:08:00.002+02:00

Nach längerer Pause will ich mich hier mal, passend zum Wanderauftakt, mit einer heimatnahen Route beschäftigen. Dem eingesessenen Bottroper dürfte die Route nicht neu sein, landläufig ist sie hier auch als "Vaddatachstour" in diversen Variationen bekannt. Die Route bietet sich aber gerade dem Wanderneuling als Einstieg an. Sie ist sehr gut markiert, es liegt eine gute KVR-Karte "Tourtipp Kirchhellener Heide vor und faktisch muss man nur dem Wanderweg X11 folgen. Die Einsteigepunkte sind fast beliebig, der Wanderweg führt so u.a. an den Stadtgärten, Bischofssondern und Grafenmühle vorbei. Der Hauptwanderweg X11 "Emscherpark" ist durchwegs kinderwagentauglich ausgebaut und die faktisch nicht vorhandene Steigung stellt auch den ungeübten Wanderer vor keine konditionellen Schwierigkeiten. Mein Toruvorschlag steht dabei unter dem Motto "Einmal von Süd nach Nord durch Bottrop" und startet deshalb bereits in Vonderort. Er folgt bis zum Heidesee dem Wanderweg X11 um erst im letzten Fünftel über den Wanderweg X19 in die Kirchhellener Innenstadt zurückzuführen. Insgesamt kommen so 20 Kilometer mit nur rund 190 zu "überwindenden" Höhenmetern zusammen. Also quasi die perfekte Saison-Auftakttour.

Brütende Fischreiher am Stadtteich.

Buschwindröschenblüte im Kölnischen Wald.

Der Klompenweg

Rustikale Kinderbespaßung an der Grafenmühle.

Nördlich der Grafenmühle. Einzelwanderer erkennt man sehr gut an den schlecht gestellten Selbstauslöserfotos ;-)

Bergsenkung an der Schöttelhalde

Die große Bergsenkung am Schwarzbach. Was hier etwas trostlos aussieht ist jetzt ein neues und reichhaltiges Auen-Ökosystem mit Enten, Fischreihern und lautstarken Amphibien

Wie gesagt, Selbstauslöser.

Zwischen den Feldern auf dem Weg nach Kirchhellen.

Geocaching GC1C7FH: Lost Place in Werl

2010-06-05T16:08:00.001+02:00

Nach der ganzen Wanderei hier im Blog mal wieder was zum Thema Geocaching. Fronleichnam wurde von Tobibus und meiner Wenigkeit konstruktiv mit dem Lost Place Geocache in Werl genutzt. Genau gesagt handelt es sich um das ehemalige Fort Victoria der britischen Rheinarmee. Als die Tommy's 1994 abzogen haben sie praktisch nur die Möbel aufgeladen und das Tor hinter sich abgeschlossen, ansonsten aber genau nichts zurückgebaut. Das ganze geht soweit, dass in den vermodernden Vorratsschränken in den Baracken noch Ersatztoilettenpapier, Wischmop und Putzmittel stehen. "Zaunkarte" vorausgesetzt (wobei die rückwärtigen Tore sperrangelweit offen stehen) erschließt sich hier eine vollständige kleine Stadt inklusiv Kino, Kirche, Wohnbaracken, Garagen und Kraftwerk. Die Gebäude werden seit 16 Jahren nach und nach von der Natur zurückerobert, die Vandalismusschäden halten sich aber in Grenzen. Offensichtlich sind noch nicht einmal die sonst allgegenwärtigen Kupferdiebe auf das Gelände aufmerksam geworden.

Der Geocache an sich ist interessant gestaltet, wenn auch teilweise vom Schwierigkeitsgrad her nicht ohne. Abseilausrüstung und Helm ist nicht zwangsweise notwendig, meiner Meinung nach aber zur Selbstsicherung nicht verkehrt. So forderte eine der Stationen den Aufstieg auf den Kraftwerksschornsteinturm oder unter eine Hallendecke.

Insgesamt ein toller Lost Place, wem der Weg nach Prypjat zu weit ist, wer klettersicher, ausdauernd und ohne Kinder (!) unterwegs ist sei dieser Cache auf jeden Fall ans Herz gelegt

GC1C7FH auf Geocaching.com

Geocaching 03.06.2010