Laugenbrötchen werden gemacht

Heute versuche ich mal Laugenbrötchen selber zu machen. Das Rezept habe ich von folgender Webseite: https://www.lecker.de/laugenbroetchen-selber-machen-so-gehts-78202.html

Hydroplane im Maßstab 1:8 ( Teil 1)

Nach langer Zeit strebe ich wieder ein Bauprojekt an. Diesmal ist es ein Hydroplane im Maßstab 1:8. Es ergibt sich somit eine reine Rumpflänge von ca 108cm. Es ist also schon ein Brummer.

Warum entschied ich mich für solch ein Boot und warum in diesem Maßstab

Ein Hydroplane ist ein Schiff, welches, wie es der Name schon andeuetet mehr in der Luft als im Wasser ist. Daraus ergeben sich von Haus aus hohe Geschwindigkeiten.

Beispiel eines Unlimited Hydroplanes. Quelle: https://en.wikipedia.org/wiki/Hydroplane_(boat)#/media/File:MissMadisonHydroplane2007.jpg

Eines meiner ersten Modellboote war ein Hydroplane ( die Viper von H&M: https://www.hydromarine.de/Ruempfe-Modellbaukaesten/Hydroplanes/Hydro-Rennboote-700-mm/Viper-WE::140.html) . Es war sehr gutmütig und ha tmir sehr viel freude bereitet. Ich mag es, wenn ein Schiff tendenziell etwas schneller ist und ich finde den Übergang zwischen Verdränger und Gleitfahrt/Flug einfach klasse. Deswegen musste es ein Hydroplane werden. Was den Maßstab anging, war mir eines auch sehr schnell bewusst, dass es “groß” sein muss. Die Viper mit 61 cm war mir deutlich zu klein. Ich wollte etwas mit >=6S betreiben. Des Weiteren haben größere Schiffe den Vorteil, dass das Wasser nicht ganz so glatt sein muss.
In meinem Archiv von Bauplänen standen mir zahlreiche Modell zur Verfügung, aber ich entschied mich für die Atlas van Lines.

Das linke Schiff ist die U1, die soll es werden.

Der Weg zum Modell

Obwohl mir schon seit Ewigkeiten ( ich denke es sind an die 20-25 Jahren) CNC-Fräsen zur Verfügung stehen, habe ich bisher nie ein Modell komplett per CNC-Fräseteile aufgebaut. Diesmal sollte es anders sein.

Der Plan lag mir zwar bereits als PDF vor, jedoch importierte ich diesen zuerst ins Corel Draw ( man kann auch beliebig andere Tools, aber ich mad Corel eben). Der ursprüngliche Plan, sah wie folgt aus:

Bild des orginal Plans.

Als CAM-Tool nutze ich ESTL-CAM. Es stellte sich jedoch heraus, dass der Plan noch entsprechend bearbeitet werden musste. An manchen Stellen waren Hilfslinien zu sehen, die die Konturenfindung störte, an anderen Stellen war die Kontur nicht geschlossen. Eine nicht geschlossene Kontur kann man sich als 2 Linien vorstellen, die sich nicht berühren, sprich es eine kleine Lücke gibt.

Eine Hilfslinie stört das Konturenmapping im ESTL-CAM

Eine weitere Anpassung die ich machen musste, war das Teilen des Stringers. Im Plan ist dieser 108cm lang, meine Fräse schafft diese Länger aber nicht. Also musste ich aus einem langen Teil, 2 kurze Teile machen, die ich im Nachgang durch Kleben wieder auf Maß brachte.
EIN BILD FOLGT NOCH.
Nun konnte es ans Fräsen gehen !

Nach guten 3 Stunden war ich mit allen Balsaholzteilen fertig, inkl. Bearbeitung des Plans und Verkleben der Stringerteile. In meinen Augen kann sich das Ergebnis sehen lassen. was noch gemacht werden muss ist die Anpassung der Innenkonturen. Laut Plan müssen die Einbuchtungen 90grad winkel haben ( mit einer klaren Ecke). Wenn ich jedoch Fräse, so habe ich immer Radien. Dies muss ich händisch bearbeiten oder beim nächsten mal lasern :-).

Vergrößerter Ausschnitt einer Einbuchtung. Das Schwarze ist die “Solllinie” des Plans. Das Rote ist die gefräste Bahn mit meinem definierten Fräser.

Nach meiner ersten Fräsarbeit habe ich mal alles zusammengestekct, um zu sehen wie es wirkt. Wirft selber einen Blick drauf:

Outrigger Grundlagen

Im heutigen Artikel geht es Outrigger im Allgemeinen. Es sollen ein paar Grundlagen über deren Aufbau vermittelt werden.
Outrigger sind von sich aus, sehr schlicht im Aufbau. Man unterscheidet jedoch die Outrigger von der Anzahl der Auflagepunkte im Fahrbetrieb.

Mein Predator 3S Outrigger

Die Auflagepunkte bei einem Outrigger können die Folgenden sein:

  • 2 Auflagepunkte sind die vorderen Kufen ( grün markiert)
  • 1 Auflagepunkt ist der Antrieb ( orange markiert)
  • ( für einen 5 Punkt outrigger zusätzlich): 2 Auflagepunkte sind die hinteren Kufen, die bei mir am Rumpf montiert sind (gelb markiert) . Diese können auch mittels Ausleger weiter vom Rumpf entfernt sein,

In einem alten Forum (Quelle Alte Hydroworld Formum: Rigger Grundlagen) fand ich ein paar nette Daumenregeln die ich Euch hier auch mitgeben möchte:

Die Kufenbreite

Die Kufenbreite sorgt maßgeblich für den Auftrieb während der Fahrt ( in Verbindung mit dem Anstellwinkel). Im Stillstand sorgt eine breite Kufe auch für einen größeren Auftriebskörper, so dass das Schiff nicht absäuft. In Schiffen bis ca. 1000 Gramm (ca. 6-8 Zellen NiCd/NiMh bzw. 3S) Gewicht reichen etwa 35mm Breite. In einem 12 Zellen Outrigger mit etwa 1500 Gramm werden 40-45mm Kufenbreite benötigt. Ein 20 Zellen Outrigger mit 2500 Gramm Kampfgewicht sind 50-60mm Breite notwendig.

Der Anstellwinkel der Kufen


Bei schwacher Motorisierung sollten es etwa 7 Grad betragen, das Ziel ist es dynamischen Auftrieb zu erzeugen um das Schiff entsprechend aus dem Wasser zuheben. Das reduziert den Wasserwiderstand erheblich. Steht einem mehr Motorleistung zur Verfügung, so kann man den Anstellwinkel auf 3-5 Grad reduzieren. Durch einen geringeren Anstellwinkel reduziert man den Wasserwiderstand und das Schiff wird schneller ( wenn es weit genug aus dem Wasser ist).

Das V der Kufen

Schaut man von hinten auf das Schiff, so kann sehen, in welchem Winkel die Kufenunterkante auf das Wasser trifft. Das heisst, für ein Flachwasseroutrigger / highspeed-Outrigger kann man die Unterkanten der Kurven auf 0 setzen ( also parallel zum Wasser). Erzeugt man ein kleines V ( sprich die Außenkante ist etwas höher, wie bei einem Mono) so erzeugt das mehr Stabilität für das Boot, kostet allerdings etwas Speed. Ein Richtwert ist einen Winkel von 2mm über Wasserkante der Außenkante der Kufe. ( und ja ich weiß, ein Längenmaß ist kein Winkel)

Dies ist mit dem V-Winkel gemeint. Lasst Euch nicht wegen des Bildes irritieren, bei Outrigger und Hydroplanes gelten die gleichen Grundprinzipien

Die Flughöhe des Schiffs

Für rauheres Wasser wird etwas mehr Flughöhe benötigt, bei Glattwasser reicht etwas weniger. Ein guter Wert sind ca. 1,5 – 2,5cm. Der Wert bezieht sich auf den Großteil des Rumpfes.

Das Breiten / Längenverhältnis

Je Breiter das Boot, desto besser kommt man durch die Kurven. Ein SAW Outrigger ( geradeaus) wird schmaler sein. Ein guter Ausgangswert ist das Verhältnis 2 zu 3 ( Breite zu Länge). Von wo aus wird die Breite und die Länge gemessen? Als Breite wird die Breite zwischen den Kufen(innenseiten) bezeichnet. Und vom Ende der Kufe (was ein Auflagepunkt auf dem Wasser ist) bis zum Propeller ist die Länge zu nehmen.

Der Schwerpunkt

Der Schwerpunkt liegt IMMER hinter dem Auflagepunkt der vorderen Kufen. ca. 2-3 cm hinter dem Kufenende kann man nehmen.

Die Kufenstreben

Die Streben sollten sehr verwindungssteif und “stabil” sein. Sie sind hohen Belastungen ausgesetzt. Auch die Befestigung zwischen Strebe und Kufe, als auch zwischen Kufe und Rumpf sind besonders anfällig. Eine durchgängige Strebe ( durch den Rumpf durch) zwischen den Kufen bringt zwar mehr Stabilität, allerdings nervt die Strebe auch innerhalb des Rumpfes ( je nach Modell). Beim Selbstbau ist darauf zu achten, dass die Strebe möglichst “hoch” montiert ist, da sie beim beschleunigen aus dem Stand heraus dann nur “kurz” im Wasser ist. Das reduziert den Anlaufstrom.

Der Strut

Der Strut muss unbedingt verstellbar sein, am besten sowohl vom Winkel, als auch in der Höhe. Man sagt, dass der vordere Punkt der Welle ( an der Stelle wo der Propeller montiert ist) auf Wasserhöhe ist ( im Fahrbetrieb). Manchmal möchte man andere Propeller fahren ( z.B. größere), so kann eine Höhenverstellung praktisch sein. Durch die Anpassung des Winkels kann man die höhe des Hecks als auch den Druck auf die vorderen Kufen etwas modifizieren.

Assymetrie

Bedingt durch den Antrieb haben wir ein Drehmoment und dieser erzeugt, dass eine Kufe stärker ins Wasser gedrückt wird als die andere ( bei meinem Predator wird ab ca. 70km/h die eine Tatze aus dem Wasser gehoben). Zusätzlich müsste man das Ruder entsprechend trimmen um einen sauberen geradelauf zu haben. Und auch das kostet wieder Speed.
Eine Möglichkeit dem entgegen zu wirken ist es, den Antrieb nicht “mittig” zu montieren, ggf. auch die Antriebswelle etwas “schief” aus dem Rumpf kommen zu lassen.
Was ich auch gerne mache, ist die Kufen entweder unterschiedlich zu montieren, sprich der Abstand der Kufe zum Rumpf ist links und rechts unterschiedlich. Ebenfalls kann man auch den Anstellwinkel der rechten und linken Kufen etwas zu verändern.

Im Endeffekt kann man in der Theorie alles schreiben, in der Praxis sieht es doch anders aus, also muss man vie probieren.

Mein persönlicher Jahresrückblick

https://www.data-assessment.com/de/ruckblick-2018-und-ausblick-2019/

Ihr kennt es sicherlich auch, das Jahr neigt sich dem Ende zu und man fragt sich, was man so das ganze Jahr über getrieben hat. Konkret meine ich nicht, was beruflich geleistet wurde, sondern das Private wird fokussiert.

Konkret starte ich mit dem 31.12.2018, da wurde unser neues Heim mit einer Thermokamera untersucht, ein paar Interesannte Ergebnisse gab es.

Klar zu sehen sind die Heizschleifen der Fußbodenheizung, sowohl unter den Fleisen ( Vordergrund) als auch im Hintergrund unter der Holzdielung. Die 17.6°C sind mit Vorsicht zu genießen, da es genau an der Kante der Küchenmöbel sind. Die Aufnahme stammt aus dem Morgen, die Heizung war noch nicht sauber programmiert, somit war es sau kalt.

Gleich im Januar kümmerte ich mich um das Fertigstreichen unserer Treppe.

Bild der noch unfertigen Treppe

Mitte Januar gab es dann einen ersten Schnitt eininger Gehölze im garten

Vorgarten inkl. Grünschnitt

Ende Februar wollte ich ein Steak “beefen”, also besorgte ich mir im Baumarkt einen Baustrahler und bruzzelte 🙂 Es war ok, aber nicht so geil.

Anfang März wurde ein passender Wandschrank für eine Einbuchtung im Flur gebaut.

Mitte März wurde dann die Scheibe für das Obergeschoßbad eingesetzt, inkl. LED Beleuchtung. Des Weiteren wurde der große Spiegel in diesem Bad montiert.

Im gleichen Zeitraum wurde der Vorgarten beackert. D.h. der restliche Bauschutt wurde entfernt, der Gartenschnitt weiter verarbeitet (gehäckselt) und dann neuen Boden für den Rasen aufgebracht. Ein kleines Beet für Obst und Kräuter sind im Hintergrund zu sehen.

Ende März wollte ich mal ein Steak sous vide zubereiten, als rann an den Speck. Zu erst habe ich intensiv mein Thermomix verschnitt vermessen. Die Temperaturen haben gepasst, von der Dauer habe ich mich im groben an die Regel von einer Stunde pro cm Fleischdicke. Das Fleisch sieht sehr unappatitlich aus, als ich fertig war. Mit dem Gasbrenner, konnte ich die Oberfläche antoasten. Jetzt kann man es essen und es war LECKER!

Anfang April wurde im Obergeschoss-Badezimmer die Eckwanne eingebaut, dazu musste auch ein entsprechendes Podest gebaut werden um den Mischer zu montieren. Dann durften die Fliesen drann.

Mitte April baute ich dann ein Sideboard für den Flur.

Ende April gab es dann eine Rutsche für den Sohnemann. Es wurde eine bestehende Rutsche “umgebaut”, d.h. die Leiter wurde entfernt und durch eine kleine Holztreppe ersetzt. Danke auch an den edlen Spender der Rutsche! Und in diesem Zuge wurde auch der Obligatorische Baumgepflanzt ( Haus und Sohn gibts ja schon)

Im Mai und Juni ging es dann los mit dem Bau einer Werkbank für den Keller . NUr als Hinweis, bei der Werkbank kommen noch Echtholzkanten um die Arbeitplatte ( ich habe mich nicth vermessen, oder habe zu wenig eingekauft).

Anfang Juli wurde dann die Deckenbeleuchtung im OG Bad fertiggestellt und Inbetrieb genommen.

Von Juli bis in den August wurden dann die Türzargen gebaut. Es ist ein eigenes Design und sollte auch passend zu den Sockelleisten sein. Es war eine extrem Zeitaufwendige Arbeit

Im September wurde dann der Saugroboter ordentlich unter der Kochinsel verpackt, die Vorbereitungen (Ausschnitte sägen in den Schrank ) wurden bereits Anfang des jahres gemacht, aber die Sockelleisten fehlten noch. Jetzt ist er sauber verstaut, und wenn man ihn braucht ist er (genannt “Sam”) sofort zur Stelle.

Anfang November wurde dann ein Kaminofen montiert und im Keller ein Serverraum gemauert.

Die Zeit im November bis Anfang Dezember nutzte ich um das Thema Sockelleisten zu beenden.

Und kurz vor Weihnachten, habe ich noch fix einen Schwibbogen gefräst. Einen zur Küche passenden Topfuntersetzer gibt es auch.

Das war mein persönlicher Rückblick. Wenn ich das jetzt mal genauer betrachte war das Jahr 2019 auch wieder ein sehr “aktives” Jahr. Es wirkt immer so, als passiert nicht soviel.
Schauen wir mal was das jahr 2020 so bringt 🙂

HC-SR04 (Ultraschall-Entfernungssensoren) an Arduino

Die HC-SR04 Ultraschallsensoren sind günstige Sensoren zur Erfassung von Distanzen per Ultraschall (woher sonnst kommt der Name). Kostenmäßig liegen diese bei etwa 4-5 EUR wenn man Sie in Deutchland kauft, bezieht man diese aus China, so liegt man bei etwa 1 EUR.

HC – SR04

Technische Daten

  • Betriebsspannung: DC 5V
  • Stromverbrauch: ~2mA
  • Sensorwinkel: <15°
  • Detektionsbereich: 2cm – 450cm
  • Präzision: 0,3cm

Anschlüsse und Verwendung

Pins:
1. VCC (5V)
2. trig (T)
3. echo (R)
4. GND

Die Grundsätzliche Funktionsweise ist wie folgt. Es muss ein Impuls auf dem Triggerpin gelegt werden, und auf dem Echo-Pin gibt es dann den Rechtecksignal, welches Proportional zur Distanz ist. Um sich Berechnung der Luafzeiten zu ersparen, gibt es zahlreiche Biliotheken. Ich selber habe die von Erik Simones verwendet https://github.com/ErickSimoes/Ultrasonic. Auf dieser Seite ist auch eine entsprechende Anleitung zu finden. In dieser Anleitung wird auch beschrieben, wie man die Bibliothek installiert.

In meinem Sketch habe ich 6 Ultraschall-Sensoren an den Arduino angeschlossen (mehr DIO-Pins habe ich beim Arduino-Nano nicht zur Verfügung gehabt).

#include <Ultrasonic.h>

Ultrasonic ultrasonic[6] = 
{
  Ultrasonic(3, 2),
  Ultrasonic(5, 4),
  Ultrasonic(7, 6),
  Ultrasonic(9, 8),
  Ultrasonic(11, 10),
  Ultrasonic(13, 12)
};
  
void setup() {
  Serial.begin(9600);

}

void loop() {
  for (int n=0; n<6; n++)
  {
    Serial.print("Sensor[");
    Serial.print(n);
    Serial.print("]: ");

    Serial.print(ultrasonic[n].read(CM)); // Prints the distance on the default unit (centimeters)
    Serial.println("cm");
  }
  delay(100);

}

DHT22 an ESP8622 + MQTT

Der DHT22 ist ein günstiger Sensor zur Messung der Temperatur und der Luftfeuchte. Dieser ist baugleich zum AM2302.
Der Sensor kann sowohl mit 3.3V als auch mit 5V betrieben werden. Also Ideal für gängige Microcontrollerplattformen wie Arduino, Rapsberry Pi, STM32 und weitere.
Der Anschluss ist wirklich simpel, Spannung, Masse und Signal. Der Datenaustausch erfolgt über einen Single-Bus, als seriell.

Technische Daten:

  • Digital Temperatur und Luftfeuchtigkeit ermitteln
  • DHT22 / AM2302
  • Betriebsspannung: DC 3.3-5.5V
  • Luftfeuchtigkeitsmessbereich : 0 bis 100% relative Luftfeuchte
  • Feuchtemessgenauigkeit: ±2% RH
  • Temperaturbereich: -40 bis +80 C
  • Temperaturmessgenauigkeit ±0.5
  • Single-Bus – Digitalsignalausgang, bidirektionale serielle Daten
  • Maße: 28mm x 12mm x 10mm

In meinem Beispiel habe ich den DHT22 an den ESP3266 angeschlossen. Dazu habe ich VCC and 3.3V angeschlossen, GND an GND und Data an den Pin D6 des Microcontrollers.

Im Endeffekt wird der DHT22 ausgelesen und die Werte an das Display geschrieben. Zusätzlich werden die Informationen per MQTT übertragen.
Das passende Codesnippet sieht wie folgt aus

/***************************************************
  This code uses the ESP8266 Kit8 with the following functionality
  @li [in] DHT22
  @li [out] some information at the display by I2C
  @li [out] MQTT
  @author Andreas Amann (quick and dirty)
 ****************************************************/
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

/*************************  Display stuff *********************************/
#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 16, /* clock=*/ 5, /* data=*/ 4);

/*************************  DHT22 *********************************/
#include "DHT.h"

#define DHTPIN 12     // Digital pin connected to the DHT sensor
// Feather HUZZAH ESP8266 note: use pins 3, 4, 5, 12, 13 or 14 --
// Pin 15 can work but DHT must be disconnected during program upload.

//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors.  This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

char strTmp[8]; // Buffer big enough for 7-character float

/************************* WiFi Access Point *********************************/
#define WLAN_SSID       "MYSSID"
#define WLAN_PASS       "123412341234"

/************************* Adafruit.io Setup *********************************/
#define AIO_SERVER      "192.168.180.101"
#define AIO_SERVERPORT  1883                   // use 8883 for SSL
#define AIO_USERNAME ""
#define AIO_KEY ""
//#define AIO_USERNAME    "...your AIO username (see https://accounts.adafruit.com)..."
//#define AIO_KEY         "...your AIO key..."

/************ Global State (you don't need to change this!) ******************/
// Create an ESP8266 WiFiClient class to connect to the MQTT server.
WiFiClient client;
// or... use WiFiFlientSecure for SSL
//WiFiClientSecure client;

// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.
// Notice MQTT paths for AIO follow the form: <username>/feeds/<feedname>
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
Adafruit_MQTT_Publish pub_humidity = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/uc/humidity");
Adafruit_MQTT_Publish pub_temperature = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/uc/temp");

/*************************** Sketch Code ************************************/
void MQTT_connect();

/****************************************************************************/
void setup() 
{
  Serial.begin(115200);
  delay(10);

  Serial.println(F("Adafruit MQTT demo"));

  // Connect to WiFi access point.
  Serial.println(); 
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(WLAN_SSID);

  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.println("WiFi connected");
  Serial.println("IP address: "); Serial.println(WiFi.localIP());

  // init display
  u8g2.begin();
  
  // init sensor
  dht.begin();

  // sendout message
  Serial.println(F("DHTxx test!"));
}

/************ ugly global variable *************************************/
uint32_t x=0;

/************** read out humidity and log messages ********************/
float GetHumidity()
{
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();

  // Check if any reads failed and exit early (to try again).
  if (isnan(h)) 
  {
    Serial.println(F("Failed to read from DHT sensor!"));
  }

  return h;
}

/************ read out temperatur and log messages *********************/
float GetTemperature()
{
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();

  // Check if any reads failed and exit early (to try again).
  if (isnan(t)) {
    Serial.println(F("Failed to read from DHT sensor!"));
  }

  return t;
}

/************** display provided values ***************************/
void DisplayValues(float t, float h)
{
   // printout to display
  u8g2.clearBuffer();          // clear the internal memory
  u8g2.setFont(u8g2_font_ncenB08_tr); // choose a suitable font
  u8g2.drawStr(0,10,"Humidity [%]: ");  // write something to the internal memory
  dtostrf(h, 6, 2, strTmp); // Leave room for too large numbers!
  u8g2.drawStr(90,10,strTmp);  // write something to the internal memory
  
  u8g2.drawStr(0,25,"Temperature [C°]: ");  // write something to the internal memory
  dtostrf(t, 6, 2, strTmp); // Leave room for too large numbers!
  u8g2.drawStr(90,25,strTmp);  // write something to the internal memory
  //u8g2.drawStr(0,31,"Heat index");  // write something to the internal memory
  u8g2.sendBuffer();          // transfer internal memory to the display
}

/******** send out data by MQTT *********************************/
void PublishTemperature(float t)
{
  if (! pub_temperature.publish(t)) 
  {
    Serial.println(F("Failed(__LINE__)"));
  } 
}

/******** send out data by MQTT *********************************/
void PublishHumidity(float h)
{
  if (! pub_humidity.publish(h)) 
  {
    Serial.println(F("Failed(__LINE__)"));
  } 
}

/************ loop **********************************************/
void loop() 
{
  // Ensure the connection to the MQTT server is alive (this will make the first
  // connection and automatically reconnect when disconnected).  See the MQTT_connect
  // function definition further below.
  MQTT_connect();

 const float t = GetTemperature();
 const float h = GetHumidity();
 PublishTemperature(t);
 PublishHumidity(h);
 DisplayValues(t,h);

  // ping the server to keep the mqtt connection alive
  // NOT required if you are publishing once every KEEPALIVE seconds
  /*
  if(! mqtt.ping()) {
    mqtt.disconnect();
  }
  */
}

// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() 
{
  int8_t ret;

  // Stop if already connected.
  if (mqtt.connected()) 
  {
    return;
  }

  Serial.print("Connecting to MQTT... ");

  uint8_t retries = 3;
  while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
       Serial.println(mqtt.connectErrorString(ret));
       Serial.println("Retrying MQTT connection in 5 seconds...");
       mqtt.disconnect();
       delay(5000);  // wait 5 seconds
       retries--;
       if (retries == 0) {
         // basically die and wait for WDT to reset me
         while (1);
       }
  }
  Serial.println("MQTT Connected!");
}

Heltec WiFi Kit 8 (ESP8266) mit Arduino IDE programmieren

Das Heltec WiFi Kit 8 ist ein kostengünstiges Entwicklungsboard, das mit der Arduino-IDE benutzt werden kann. Es besitzt folgende Eigenschaften:

  • ESP8266 (160MHz Tensilica L06 32-bits,SRAM, Wi-Fi)
  • UART x 2; SPI x 1; I2C x 1; I2S x 1
  • 10 – bits ADC
  • 17 general GPIO
  • 0.91″ 128*32 OLED display
  • 4MB(32M-bits) SPI FLASH

Um das Modul mit der Arduino IDE benutzen zu können, sind folgende Einstellungen notwendig:

Es gibt noch einen wichtigen Punkt zu beachten. Anscheinend gibt es wohl zwei verschiedene Versionen dieses Boards. Über folgende Links habe ich diverse zusätzliche Informationen erhalten:

  • https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series
  • http://stefanfrings.de/esp8266/
  • https://robotzero.one/heltec-wifi-kit-8/

Hilscher NetIO für Hausautomatisierung

Vor geraumer Zeit hatte ich einen Hilscher NetIO für die Hausautomatisierung beschafft. Jetzt endlich bin ich dazu gekommen, diesen in Betrieb zu nehmen. Aber fangen wir erst mit den Daten & Fakten an.

Das Gerät hat folgende technische Eigenschaften (entnommen der Herstellerseite):

  • Betriebsspannung 24V +-6V (DC)
  • 4 Kern 64bit ARM BCM2837
  • 1GB DDR3 RAM
  • 8GB industie MLC NAND Speicher
  • Stromverbrauch 170mA
  • Ethernet 10/100Mbit
  • 2 Sockets für Profinet / Ethercat ( Hilscher netx 51)
  • Wifi
  • Bluetooth
  • HDMI
  • Metallgehäuse
  • DIN-SChienenanschluss (Schaltschrank)

Also wie ihr seht, ist es quasi ein Raspberry-Pi 3 nur in Industrietauglicher Ausführung. Der Spaß kostet bei Amazon etwa 300 EUR. Jetzt muss jeder für sich selsbt entscheiden, ob einem das Wert ist.

Als Betriebssystem kommt ein Linux (out of the Box) zum Einsatz. Auf dem Device gibt es graphisches Frontend, welches einem die Konfiguration übernimmt. Der eigentlicehn Konsolen-Zugriff ist eigentlich nicht vorgesehen. Alle Softwareinstallationen erfolgen über Docker (also eigene getrennte Container).

Inbetriebnahme Dopplerradar OPS243

Im Zuge eines neuen Projektes wurde ein Dopplerradar der Firma OmniPreSense mit der Bezeichnung OPS243 angeschafft.
Technisch ist das hochinteresannt:

  • Detektionsbereich 1-100m
  • Geschwindigkeitsdetektion bis zu 348 mph
  • Richtungserkennung ( kommend oder gehend)

Weitere Informationen sind hier zu finden: https://omnipresense.com/product/ops243-doppler-radar-sensor/

Standardmäßig sendet der Sensor seine Daten per serielles Interface heraus. Mit folgenden Einstellungen, lassen sich die Daten abzapfen:

/dev/ttyACM0  9600 8N1

Folgender Datenstrom ergibt sich:

Die Ausgabestream gibt die Detektierten Objekte in m/2 an.

Nachdem dies nun zu funktionieren scheint, gilt es die Integration ins ROS zu vollziehen. Hierbei gehe zu http://wiki.ros.org/radar_omnipresense und folge der Installationsanweisung. Ich installiere das fehlende ROS Paket mit

sudo apt install ros-kinetic-radar-omnipresense

und nun kommt dier Erkenntnis, dass ich keine out of the Box-Visualisierung habe. Ich muss mich um was spezielles wohl kümmern.

Linux / UNIX minicom

Unter Linux hat man die Möglichkeit mit zahlreichen Tools auf die serielle Schnittstelle zuzugreifen. Wenn mir eine GUI zur Verfügung steht, so nutze ich am liebsten putty, da ich dieses Werkzeug auch unter Windows benutze, bin ich damit sehr vertraut. Jedoch habe ich nicht immer die Möglichkeit mit einer GUI zu arbeiten, oder wenn mal schnell besondere Rechte für den Konsolen-Zugriff benötigt werden, ist es auf der Shell einfacher

Mein Lieblingswerkezug hierfür ist dann minicom. minicom bietet alles was das Herz begehrt, ohne konkret darauf einzugehen.

Installieren von minicom

Unter Debian / Ubuntu lässt sich minicom mit folgenden Befehl installieren:

sudo apt-get install minicom

Benutzen von minicom

Bevor man minicom benutzen kann, muss es konfiguriert werden. Hierzu startet man minicom mit folgenden Parameter:

minicom -s

Möchte man stattdessen ein “buntes” minicom haben, so fügt man zusätzlich noch -c on der Parameterliste hinzu:

minicom -s -c on

Wenn ihr dauerhaft irgendwelche Parameter minicom mitgeben wollt, so könnt ihr gerne die MINICOM Umgebungsvariable überschreiben bzw. setzen ( minicom sucht nach dieser Variablen, Kommandozeilenparameter sind dominant)

export MINICOM="-c on"

Und so sieht jetzt mein minicom aus, wenn ich die Daten des Dopplerradars (OPS243) via seriellem Interface (/dev/ttyACM0) auslese