Apr 02

OpenwebRX / WebSDR aufsetzen

Elektronik, Fun, Ham, Linux Kommentare deaktiviert für OpenwebRX / WebSDR aufsetzen

Ziel: Einen SDR aufsetzen, der per Browser erreichbar ist.

Am Ende dieser Anleitung hat man einen WebSDR wie bspw. diesen: https://sdr.dj7nt.de

Neben der eigentlichen WebSDR-Funktionalität, bietet openwebRX u.a. die Möglichkeit, dass WSPR/FT8/FT4/etc. Signale automatisch im Hintergrund dekodiert und auch an die entsprechenden Portale wie pskreporter.info / wspr.rocks weitergeleitet werden. Sehr schön um Langzeitstudien des eigenen QTHs / der eigenen Antenne durchzuführen.

Zutaten:

  • Raspberry Pi 3 oder 4
  • Netzteil für den Pi (5V / 1,5A)
  • SD-Karte (min. 4 GB)
  • SDR-Hardware (Auswahl)
    • RTL-SDR (Für den Anfang ok, aber recht instabil / unsensitiv)
    • SDRPlay (RSPdx bspw.)
    • HackRF
    • PlutoSDR
    • …
  • PanAdapter, sofern der SDR an derselben Antenne wie der Shack-TRX betrieben werden soll
  • USB-Kabel
  • Antennenkabel

Kochrezept:

Zunächst openwebrx herunterladen und das ZIP entpacken. Anschliessend den “Raspberry Pi Imager” herunterladen und starten. Dort dann unter “OS wählen” die image-Datei aus dem openwebrx-ZIP auswählen. Da es einige – wenige – Dinge gibt, die wir direkt auf dem Pi ohne das WebInterface zu Anfang erledigen müssen nun auf das Zahnrad unten rechts clicken.

Hier kann bspw. der Hostname u.a. angegeben werden. Wichtig ist aber, dass ein Haken bei “SSH aktivieren” angeclickt wird, und bei “Benutzername und Passwort setzen”. Benutzername/PW ist frei wählbar, sollte man sich jedoch merken 😉

Wer fit in der Linux-Welt ist, kann natürlich auch seinen SSH-PublicKey hinterlegen. WiFi-Konfiguration kann man machen, muss man aber nicht. Ich bin ein Freund von LAN-Kabeln. Ist stabiler als WLAN.

Nun kann man die SD-Karte einlegen und im Imager die korrekte Karte auswählen. Anschliessend auf “schreiben” drücken. Jetzt wird das openwebrx-Image auf die Karte geschrieben.

Aufbau der Hardware hier wie folgt:

Während all das passiert können wir uns der Hardware widmen. Ich nutze hier einen SDRPlay-RSPdx, aber wie oben beschrieben funktioniert auch ein günstiger (<20 Euro) RTL-SDR-Stick. Beim RTL-SDR wird – um die Kurzwellenbänder zu Empfangen – noch ein UpConverter benötigt. Beispielsweise der HamItUp von Nooelec.

Szenario: SDR soll die selbe Antenne wie der Transceiver nutzen:

Blockschaltbild

Kurze Erklärung: Der Panadapter sorgt dafür, dass der SDR zur Antenne durchgeschaltet wird, so lange der TRX nicht auf Sendung ist. Wird am TRX PTT gedrückt, trennt der Panadapter instant das Signal zum SDR. Wird nicht gesendet, so bekommen sowohl SDR als auch TRX das Antennensignal. Ich habe mich für einen simplen Panadapter aus China entschieden. Bei meinem Model musste noch ein Jumper umgesteckt werden, damit die Trennung auch vollzogen wird. Der Adapter verfügt über eine HF-VOX (ich traue diesen VOX-Dingern nicht) oder aber über einen PTT-Cinch-Anschluss womit man den Adapter mit dem TRX verbinden kann (die aktuellen Transceiver haben alle ein PTT-Out). Es empfiehlt sich das ganze unbedingt vor Anschluss des SDRs zu testen. Im Worstcase geht die volle Leistung des TRX nämlich sonst in den SDR – und das wird der garantiert nicht mögen

Szenario: SDR bekommt eine eigene Antenne:

Das alles entfällt natürlich, wenn man dem SDR eine eigene Antenne gönnt. In dem Falle wird die (eigene) Antenne einfach an das SDR-Gerät geklemmt, und der SDR per USB an den RaspberryPi und fertig.

Der erste Start / Boot:

Nachdem alles wie oben beschrieben verkabelt/angeschlossen ist (LAN nicht vergessen ;), können wir den Pi das erste mal mit Strom über die USB-Buchse versehen. Sobald der Raspberry hochgefahren ist, suchen wir uns die IP-Adresse die das Gerät bekommen hat. Hier gibt es mehrere Wege, die von der Architektur des (Heim-)Netzwerks abhängen:

  • Suchen des Geräts in der Fritzbox/Speedport/Plastikrouter der die IPs im LAN vergibt und jeweilige IP merken.
  • Je nach Netzwerk ist der Pi sogar schon über den o.g. Hostnamen (siehe Kochrezept, zweiter Absatz) erreichbar.

Ein kurzer Test ob das Gerät anpingbar ist (ping [hostname] (s.o.) bzw. ping [IP] auf der Kommandozeile des PC’s/Mac) gibt Aufschluss ob die Maschine erreichbar ist. Jetzt wird es – für nicht Linuxer – ganz kurz etwas komplexer, denn wir müssen auf dem Pi einen neuen Nutzer/Kennwort für das Websdr anlegen.

Nutzer anlegen

Linux und Mac-User haben es einfach, hier wird ein Terminal/Shell aufgemacht und anschliessend kann man sich per ssh [user]@[hostname] (user/hostname bitte den verwenden, der unter Kochrezept Absatz 2 vergeben wurde) auf den Pi verbinden.

Als Windowsnutzer wird noch ein SSH-Client benötigt. Als Leichtgewichtig hat sich Putty herausgestellt. Also herunterladen und unter Host den Hostnamen bzw. die IP-Adresse eintragen, sowie anschliessend unten im Fenster auf “Connect”/”Verbinden” drücken.

Ist man auf der Shell des Pis angekommen, lässt sich nun ein Nutzer anlegen. Das geschieht durch die Eingabe des folgendes Befehls/Kommandos:

sudo openwebrx admin adduser adminuser

Es wird also ein neuer (Web-)Nutzer mit dem Namen “adminuser” angelegt. Andere Namen sind natürlich auch möglich. Nach dem Abschicken des Befehls fragt das Tool nach einem zu vergebenden Passwort. Ist das erledigt, kann man die Shell wieder schliessen (logout).

Damit wäre das komplizierteste geschafft.

Login/SetUp/Test

Unter http://[hostname oder IP] kann man sich nun auf dem WebSDR einloggen. Der zuvor genannte Admin-Nutzer wird für den Login der Settings-Seite (oben rechts im Webinterface) benötigt. Dort lassen sich Bänder/Profile und Co. für die jeweiligen SDR-Empfänger einstellen. Wer hier tiefer einsteigen mag, dem sei die Doku von openwebRX ans Herz gelegt. Auch Funktionen wie die eingangs erwähnte Dekodierung der DigiModes ist dort erklärt.

Weitere Dinge, wie bspw. Update des Raspberries oder explizite Konfiguration der SDRs sind in der Regel nicht erforderlich. Die Images von openwebRX werden sehr häufig aktualisiert, sodass man an sich immer eine aktuelle Version bei der Installation vorfindet. Die SDRs werden direkt beim booten erkannt, Feineinstellungen können über die bereits erwähnte Settings-Seite (Zahnrad oben rechts) erledigt werden.

Settings-Seite von openwebRX

Viel Spass mit dem eigenen WebSDR

Fallstricke:

Ein kleiner “Annex” über die Fallstricke, die es beim aufsetzen geben kann:

Problemggf. Abhilfe
Stick wird nicht erkannt– Stick im Webinterface nicht aktiv(iert) -> Aktivieren
– Pi neu booten
– tiefere Analyse auf der Shell durchführen (lsusb, syslog, etc.)
– Stick ggf. inkompatibel
WebSDR nicht aus dem Internet erreichbarWar auch nicht Teil dieser Anleitung 😉
Stichpunkte zum googlen / selber erarbeiten:
portforwarding, fritzbox, dyndns, ...
Bänder in der Auswahl fehlenBänder unter Setttings / passender SDR hinzufügen
Wasserfall zu “rot”/”dunkel”In Settings / “SDR Devices & Profiles” / passender SDR mit dem Wert “Gain” herumspielen
SDR wird erkannt, aber es wird kein/ein zu gedämpftes Signal angezeigtIn Settings / “SDR Devices & Profiles” / passender SDR über “Additional / Optional Settings” den richtigen Antenneneingang wählen (bspw. bei SDRPlay oder Geräten mit mehreren Antenneneingängen)
Dekodierung/Spotting funktioniert nicht.In Settings die Einstellungen zum “Background-Decoding” sowie “Spotting und Reporting” prüfen. Ferner unter “SDR Devices & Profiles” / passender SDR einen “Scheduler” hinzufügen und bei “Run Background-Services” einen Haken setzen.
Tagged with: • • • • • • • • • •
Jan 18

TTT – Trampel to Talk mit dem iCOM SM-30

Elektronik, Fun, Ham Kommentare deaktiviert für TTT – Trampel to Talk mit dem iCOM SM-30

Wenn es mal hektisch im PileUp wird, nervt es ziemlich, dass man die Hände nicht zum mitscribbeln/loggen frei hat.

Von einigen erfahrenen DXern hörte ich bereits von Fusspedalen. Kurz gegoogled und festgestellt dass es nichts bezahlbares “aus dem Regal” gibt. Aaaaaaber: Wofür hat man die Lizenz zum Löten? Selbstbau ist also angesagt. Vorweg: Der folgende Spaß hat unter 30 Euro gekostet.

Kurz mal das Innenleben und den Schaltplan des SM-30, sowie die iCOM-Steckerbelegung angesehen: Aha:

Wir wollen also Pin6 und Pin5 haben. Jetzt gibt es zwar fertige Kabel & Co. die die Pins herausführen, alllerdings scheinen da auch die Kontakte vergoldet zu sein – anders kann ich mir die Preise nicht erklären.

Mein Ansatz: Auf der Platine des SM30 ist ein Steckverbinder, wo alle Adern ankommen. Diese durchmessen. Bei mir war dann “blau” = PTT und der “obere schwarze” GND. An diese beiden Punkte habe ich mir eine Mono-3,5mm-Klinkenbuchse angelötet und diese im SM-30-Gehäuse festgeschraubt. Schaut dann so aus, und ist wirklich “minimalinvasiv” (Funktion des Mics in seiner Urform nachwievor gegeben):

Parallel habe ich mir – für einen schlanken Taler – einen Fusstaster für gerade mal 20 Euro geordert. Hier sollte man darauf achten, dass dieser möglichst schwer/massivst ist. In der Standardausführung kommt aus dem Taster eine Leitung mit drei Adern mit denen man den Taster wahlweise als “öffner” oder auch “schliesser” benutzen kann. Bei mir war “weiss” gegen “rot” die Schliesserfunktion. Sollte man – bei Nachbau – noch mal mit einem Multimeter prüfen. An das Ende der Leitung habe ich mir also einen 3,5mm Klinkenstecker gelötet und diesen dann in die neue Buchse des SM-30 gesteckt. Fertig ist der Fusstaster (TTT) mit dem man nun beim QSO die Hände frei hat.

Tagged with: • • • • • • • • •
Feb 28

WS2812B Wecker

Elektronik No Comments »

Lange nichts mehr aus der Welt der Elektronik hier gepostet. Also dann mal 🙂

Es gibt seit 2-3 Jahren 5050-LED-Stripes (oder auch einzelne LEDs) mit aufgelötetem Controller (in SMD). zB diese hier. Das Coole an den Dingern ist, dass die über 3 Anschlüsse verfügen (+5V/GND Data-In, bzw. Data-Out) und man mit diesen 3 Anschlüssen zig Stück aufmal ansteuern kann. Technisch funktioniert die Schnittstelle so, dass man auf den D-In-Port des Strips ein 800kHz-Signal gibt, mit dem man dann jeder LED einzelnd den R/G/B-Wert mitgeben kann. Lauflichter, Uhren, alles was sich blinkt und bewegt sind damit also kein Problem. In der Community gibt es zig Libraries, die das Leben mit dem Ding etwas einfacher gestaltet. Hervorheben möchte ich die FastLED-Lib. Die ist zwar relativ gross (Ein Arduino/ATMEL mit min. 16kB Flash sollte es schon sein), man hat dafür aber an nahezu alles gedacht.

Im Code werden die LEDs per Array angesteuert. Das ist quasi ein Array of Arrays (untendrunter liegen noch jeweils 3 Elemente für RGB).

Jetzt hat der Arduino/ATMel als solches ein kleines Problem mit der Genauigkeit der internen Uhr. Um das zu umschiffen, gibt es RTC’s die per SPI ansteuerbar sind. 5er Pack am Fluss für ca. 10 Euro. Die Dinger sind deartig Präzise, dass ich – nach jetzt 1,5Monaten keinerlei (sichtbare) Abweichung feststellen kann. Zum Vergleich: Ohne RTC lief der Arduino nach etwa 24h um 30sek. falsch. Klar kann man versuchen den mC mit ein paar Tricks (bspw. dem OSCCAL) zu eichen. Aber sobald sich die Umgebungstemperatur ändert, war es das auch wieder.

Nun, was kommt raus? Kombiniert man, die bei Adafruit erhältlichen, 2812-Viertelkreise mit einem Arduino Pro micro, IKEA-Bilderrahmen, ein wenig Handarbeit und einem externen(!) 5V-Netzteil (die LEDs saugen da etwas) eine nette Uhr:


Den entsprechenden Code (schmutzig, as usual 🙂 ) hab ich mal bei  github abgelegt.

Tagged with: • • • • • • •
Apr 01

Garagentoröffner mit dem Arduino

Allgemein, Elektronik 4 Comments »

Ein wenig herumgespielt mit dem Arduino habe ich ja schon bei dem Rauchmelder und dem BetaBrite-Display. Nicht gebloggt wurde bisher über die Funksteckdosen, die derweil per Webserver an- und ausgeschaltet werden können (Dank dieser Library).

Das müsste doch ansich auch mit dem Garagentoröffner funktionieren. Der tut doch auch auf 433,92MhZ. Letztes Jahr hatte ich mir bei Watterod einen 433er Sender und einen Empfänger, der bisher noch nicht zum Einsatz kam, geordert. Den Empfänger also fix mal startklar gemacht und an den Arduino angeflanscht. Allerdings ist das auslesen eines Senders, bei dem man keinen Schimmer hat welche Codierung genutzt wird, alles andere als trivial. Habe es dann ersteinmal mit der 433MhZ-Wetterstation von Tchibo probiert. Nach diversen Bitfriemeleien purzelte da dann auch tatsächlich die Temperatur heraus. Nungut – wir wollen ja einen Garagentoröffner simulieren, nicht Funkthemometer auslesen.

Aus dem ollen Code bin ich allerdings nicht schlau geworden. Hier mal ein oszillografierter Ausschnitt (due to security reasons 🙂 ) des Senders:

Man erkennt insgesamt 3 Arten von Pulsen – kurze, lange und mittlere (WTF ?). Habe erst auf einen Manchester-Code getippt. War mir dann aber irgendwie zu doof den zu analysieren. Also fix mit gtkwave die Pulslängen in ein Array gepackt, und fertig ist der Garagentoröffner per Arduino. Hier der (Draft !) des Sourcecodes mit dem Pulslängenarray (Negativ = LOW, Positiv = HIGH):

int garage[45]={  // Block 1 (21 x das gepulse)
               -16382,-16382, // Blocktrenner (2)
               // Block 2 (22 x das gepulse)
};


void setup() {
  pinMode(8,OUTPUT);
  pinMode(13,OUTPUT);
  digitalWrite(8,LOW);
}

void loop() {
  fire(garage,0);          // Garage Toggeln
  digitalWrite(8,LOW);
  digitalWrite(13,HIGH);
  delay(10000);
  digitalWrite(13,LOW);
}

void fire(int what[],int corr) {  // what: PositiverWert: Dauer des HIGHPulses, NegativerWert: Dauer des LowPulses; corr = Korrekturzeit pro Puls
    for (int i=0;i<26;i++) {
      int del=what[i]+corr;
      if (del>0) {
        digitalWrite(8,HIGH);
        delayMicroseconds(del);
      } else {
        del=del*(-1);
        digitalWrite(8,LOW);
        delayMicroseconds(del);
    }
  }
}

Fazit: Funktioniert perfekt. Wenn allerdings jemand ‘ne Ahnung hat welches Protokoll (bzw. Leitungscode) das sein könnte – immer her damit 🙂

Update 22.08.2012 – Hier, auf Nachfrage, der Sourcecode für den Wetterstationsempfang. Das Ding ist echt nur ein “Proof of concept” – also alles andere als schön. Vom Aufbau her:

  • 433MhZ-Empfänger Serial-Out hängt an PIN2

-----------------------------------------------------------------------------
/*
  Liest dieses komische Tchibo-Wetterdingens per 433MhZ aus.
*/

boolean cnt=false;
int reader=0;
int cnter=0;
char reading[28];
void setup() {
  Serial.begin(9600);
  Serial.println("go!");
  pinMode(2, INPUT);
 // pinMode(13,OUTPUT);
}

void loop() {
    int LowVal=pulseIn(2,LOW);
    if (LowVal < 11000) {  // Kuezer als 1100ms Low ? Koennte unserer Sensor sein
      if (decodeTime(LowVal) == 'S') {  // Startsequenz ?
        cnt=true;                       // Dann go fuer die Sammlung
        cnter=0;                        // BitCounter auf 0
      }
      if ( (cnter<=27) && cnt && ((decodeTime(LowVal) == '0') || (decodeTime(LowVal)=='1'))) { // Stream noch nicht voll und ein Bit erkannt ?
//       Serial.print(decodeTime(LowVal)); 
       reading[cnter]=decodeTime(LowVal);  // Ab ins Array damit
       cnter=cnter+1;                      // Arraycounter fuers naechste Bit inkrementieren
      }
    } else {
      cnt=false;                           // Zurueck auf Anfang - nix fuer uns.
    }

      if ((cnter==28)) {                   // Arrray Voll ?
        Serial.print('/');
        Serial.print(reading);
        Serial.print('/');
        Serial.println(decodeTemp(reading));
        cnter=0;
        cnt=false; 
      }
  
}

float decodeTemp(String bitstream) {  // Versucht aus dem Bitstrom die Temp. zu berechnen
  int x=0;
  int chk=0;
  for (int i=16;i<24;i++) {      // Extrahiert das Byte zwischen Bit 16 und 24 und packt es als integer in "x"
    if (bitstream[i] == '1') {
      bitSet(x,(23-i));
    }
  }
  for (int i=4;i<15;i++) {      // Kenner aus den 3 Nibbles zwischen Bit 4 und 15 holen (koennte auch der Kanal sein ?)
    if (bitstream[i] == '1') {
      bitSet(chk,(14-i));
    }
  }
  if (chk != 136) {            // Kenner = 136 ? Dann ist es unserer Sensor !
    return(-999);              // Wenn nicht, dann -999 zurueck
  } else {
    return ((float)x/10);
  }
}

char decodeTime(int time){  // Wandelt die Pulse in Bits um.
  if (time > 1500 && time < 11000) { // passendes Signal (zwischen 150ms und 11000ms) ?
        if (time < 2500) {           // kleiner 250ms ? Dann LOW
          return '0';
        } 
        if (time < 5000 && time >3000) {  // Zwischen 500ms und 1000ms dann HIGH
          return '1';
        }
        if (time >8000) {                // Groesser 800ms dann Startsequenz !
          return 'S';
        }
  } else {
    return 'X';
  }  
}

Tagged with: • • • • • • • • • • • •
Dez 10

Wegen der Brandgefahr

Allgemein, Elektronik 13 Comments »


Seit geraumer Zeit sind Rauchmelder in Neubauten ja Pflicht. Macht ja auch durchaus Sinn. Gerade wenn man an solche USV-Aktionen denkt 🙂 Also muss ein Rauchmelder her. Der Otto-Normal-Nerd möchte aber mindestens irgendwas haben, was sich auch in die Standardhaustechnik integrieren lässt – am besten noch ein Set von mehreren Rauchmeldern. Da gibts es zig Varianten:

  1. Die Billigrauchmelder (um die 5-10 Euro)
  2. Die Billgrauchmelder die per 433MhZ miteinander sprechen (ab 60 Euro im Set mit 4 Stück)
  3. Die teueren Systemrauchmelder die nichts anderes als (2) machen, nur das G*ra oder sonstwas draufsteht.
  4. Die sündhaft teueren Rauchmelder mit eingebauten GSM-Modul (ab ca. 150 Euro aufwärts…)

Gelinde gesagt: Alles doof – da es entweder meinen Ansprüchen nicht genügt, oder massivst zu teuer ist.

Nun denn erstmal Dinge sichten – also ab zum Baumarkt und mal einen Rauchmelder der Kategorie “1” gekauft. Schimpft sich RM120 und hat schlappe 8,- gekostet. Laut ist das Ding ja, wenn man Zigarettenrauch reinbläst, oder mal den Testknopf drückt – bringt nur nix, wenn niemand zu hause ist 🙁 Nach dem öffnen des Geräts, schaut einen ein wenig SMD-Technik (Oha) an, darunter ein IC mit der Aufschrift “CS2105go“. Wie sollte es anders sein, dazu gibts leider kein Datenblatt. Aber Moment, vielleicht ist der CS2105GO-M12 ja Pinkompatibel mit dem MC145010 – Bingo, ist er ! Der MC145010 (manchmal auch MC145012) wird in fast allen Rauchmeldern der Kategorie 1 und 2 (teilweise auch 3) verkauft.

Der aufmerksame Leser merkt was: Bei 2 ist doch eine Vernetzung möglich ! Korrekt, so ist es. Mit anderen Worten: In den Rauchmeldern der Kat.1 ist derselbe IC verbaut, wie in 2, nur das in 1 halt das 433MhZ Modul fehlt. Brauch ich (zumindest jetzt zum Testen) eh erstmal nicht –  doch dazu später. Der MC145010 verfügt über einen sog. I/O Pin, der bei 2er Rauchmeldern dann das 433MhZ-Modul per TTL-High triggert, sobald es qualmt. Beim 1er liegt PIN7 (I/O) tot herum. Perfekt. Also fix den Ground (-) und PIN7 per Kabel rausgeführt und an den Arduino geklemmt:

 

Links (Schwarz) die Masse – Also GND direkt mit dem GND des Arduino’s verbinden,

Recht (Rot), etwas fuckeliger, den PIN7 (I/O) des CS2105GO-M12 auf einen Analogen Input-PIN des Mikrocontrollers legen.

Auf dem Arduino selbst habe ich derzeit die gute Wohnzimmerinfo-Anzeige am laufen, da ist also schon ein “Ethernet-Shield” drauf. Da dort noch diverse Analoge Ports frei sind, und der Rauchmelder auch direkt deben dem Display wohnen soll, also optimal. Vom Code her gestaltet sich das ganze relativ simpel (siehe unten). Das allerfeinste ist jedoch, dass man nichtmal gegen irgendwelche Vorschriften verstösst, wenn man sich anstelle von Variante 1 für einen Rauchmelder der Variante “2” entscheidet. Denn alle Rauchmelder bleiben so wie sie sind (sprich: Die piepen trotzdem). Nur einen, in dem 433MhZ-“Netz”, muss man dann an den Arduino anklemmen. Der verbaute Standalone-RM120 piept übrigens auch noch – denn genau dafür ist PIN7 gedacht: I/O !


#include
#include

#define SmokePIN 0

int Smoke=0;
boolean mailsent=false;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192,168,0, 100 };

void setup () {
Ethernet.begin(mac,ip);
}

void loop() {
// Read Smokedetector
Smoke=analogRead(SmokePIN);

// GGf. RESET der Variable mailsent

if (Smoke > 900) {
if (mailsent==false) {
firemail();
mailsent=true;
}
}
}

void firemail() {
// IP des Mailservers
byte mserver[] = {192,168,0,101};
Client Mail(mserver,25);
if (Mail.connect()) {
Mail.println(“HELO arduino.domain.tld”); /* say hello (statement after helo is needed but irrelevant)*/
Mail.println(“MAIL From: et_brennt@domain.tld”); /* identify sender, this should be the same as the smtp server you are using */
Mail.println(“RCPT To: et_brennt@domain.tld”); /* identify recipient */
Mail.println(“DATA”);
Mail.println(“To: et_brennt@domain.tld”); /* identify recipient */
Mail.println(“Subject: Burning down the House”); /* insert subject */
Mail.println(“WARNING – Smoke detected !”); /* insert body */
Mail.println(“.”); /* end email */
Mail.println(“QUIT”); /* terminate connection */
Mail.println();
Mail.stop();
}
}

Tagged with: • • • • • • • • • • • • • • •
Mrz 26

BetaBrite autonom via Arduino ansteuern

Allgemein, Elektronik, Linux, Wetterstation 2 Comments »

Sehr cool was mit dem Arduino so alles machbar ist. Um es vorweg zu nehmen: Mit dem Ding habe ich eine Ansteuerung eines BetaBrite LED-Moduls via Netzwerk gebaut (also im “Live-Betrieb” OHNE Rechner benutzbar).

Doch vorne angefangen:

Vor ein paar Jahren hatte ich mir bei eBay ein BetaBrite geschossen – Das ist so eine nette Laufschrift, die man zum Leute quälen draussen an seinen Copyshop hängen kann, so man(n) den einen hat. Die Idee war damals die Temperaturdaten meiner Wetterstation und ein paar andere Dinge anzeigen zu lassen. Ist aber nie so richtig umgesetzt worden, da mein “Serverpark” im Keller steht, und die Anzeige dort natürlich null Nutzwert hat. Vor ein paar Tagen bin ich dann auf das Arduino-Projekt gestossen – klang (und ist auch) alles sehr vielversprechend:

Eine simple Plattform incl. Entwicklungsumgebung für die ATMEGA-Microcontroller Serie mit massenweise Zubehör. Wer das Ding nicht kennt, einfach mal bei arduino.cc umschauen. Bezugsquellen sind u.a. watterod, komputer.de oder auch farnell.com, sofern man (bei farnell) denn im Besitz eines Stundentenausweises ist (Die Spareffekte dort sind vernachlässigbar). Der Knaller an dem Ding ist jedoch der Preis. So gibt es den Arduino für ca. 20-28 Euronen incl. Versand zu haben. Der Microcontroller lässt sich über die USB-Schnittstelle (sowohl auf Mac, PC oder Linux) in einer Art C-Dialekt für Kids programmieren (Ist wirklich extremst Easy). Das ganze geht so in Richtung SPS – daher heisst der Dialekt wohl auch “Processing”. Man hat im Template quasi 2 vorgefertigte “Prozeduren”:

  • void setup – wird einmalig aufgerufen, wenn der ATMEGA hochgefahren wird und dient zum initialisieren der Ports, etc.
  • void loop – wird, wie der Name schon sagt, im Loop kontinuierlich durchlaufen – bei mir kamen da direkt Errinerungen an die Lehrzeit wieder hoch (SPS – Merker setzen und sowas)

Hardwaretechnisch verfügt das Ding über 14 Digitale I/O Pins, von denen 6 per PWM ansteuerbar sind (alles TTL-Pegel), sowie 6 Analoge ein/Ausgänge mit einer 8bittigen genauigkeit im A/D bzw. D/A Wandler. Sämtliche Anschlüsse sind auch für Wurstfinger, wie meine, leicht verfügbar, sodass Löten – wenn man es denn nicht gerade drauf anlegt – ausfällt.

Zurück zum Titel dieses Eintrags. Zusätzlich zum Board habe ich mir noch eine Ethernet-Shield gegönnt. Shields sind sowieso die Erfindung hier uberhaupt. Man kann sich das als “Huckepack”-Platine vorstellen, die bestimmte Pins des Arduinos belegen und dann weiter Funktionalitäten bereitstellen. Das eth-Shield stellt also einen Netzanschluss zur Verfügung, und genehmigt sich dafür 6 Pins. (Eine gute übersicht über den “Pinverbrauch” und verfügbare Shields gibts übrigens bei shieldlist.org). Das Shield selbst lässt sich dann im “Processing” über ein paar Simple Funktionen ansteuern / auslesen.

Problematisch beim BetaBrite war, dass dieses über eine RS232 (vulgo: Serielle) Schnittstelle verfügt, der Arduino aber nur TTL-Pegel verarbeiten kann. Es gibt für den Ard. eine Serial-Library, mit der man aus zwei weiteren Pins einen Seriellen Anschluss “emulieren” kann, aber ohne korrekte RS232-Pegel ist das suboptimal. Was tun ? Mal ein wenig gekramt, und dann ist mir ein MAX232 zwischen die Finger gekommen – quasi genau das was man braucht. Die Schaltung mit dem MAX232 ist mehr als simpel (Einfach ausgedrückt konvertiert der 232 die Pegel). Somit steht das ganze Hardwaremässig schonmal. Ethernet-Shield -> Arduino -> MAX232 -> BetaBrite. Fehlt nur noch die “Software”. Die Ansteuerung der BetaBrites ist schnell im Netz gefunden (z.B. hier, bzw. als PDF direkt beim Hersteller). Der Code auf dem Arduino umfasst gerade mal 2kB (incl. inline-Dokumentation !!!). Falls interesse besteht, stell ich den gerne mal hier ein.

Was kann das ganze jetzt ?

Nun, Der Microcontroller mit Ethernetanschluss “horcht” auf TCP-Port 23. Immer wenn sich etwas connected und eine Zeile schreibt, dann gibt der Controller das an das Betabrite weiter. Serverseitig kann ich nun, aus dem Keller heraus :-), das BetaBrite ansteuern, wo immer auch Netz verfügbar ist…

Tagged with: • • • • •
Jan 03

Wetterstation Königswinter / In eigener Sache

Allgemein, Elektronik, Rheinland, Wetterstation 2 Comments »

Endlich bin ich mal dazu gekommen die Wetterdatenseite neu aufzubauen. Was gibt es dort zu sehen ?

  • Aktuelles Wetter aus Oberdollendorf / Königswinter im Rheinland bestehend aus:
    • Luftfeuchtigkeit
    • Aussentemperatur
    • Das ganze als zusätzlich als Diagramm der letzten sechs Tage
    • Aktualisiert im 5 Minutentakt
  • Aktuelles Bild (Aktualisierung jede Minute) der Webcam mit Blick auf den Petersberg (wenn denn nicht zu nebelig ist 🙂

Hintergründe, wie das ganze technisch realisiert ist, gibt es auf der Seite “Meine Wetterstation“. Viel Spass beim abrufen der Wetterdaten aus dem Rheinland

Tagged with: • • • • • •
preload preload preload