MP1584 buck converter module

This small module MP1584 buck-converter module seems to be a good solution to power small circuits from higher voltages. Especially cool with this chip is that it accepts input voltages up to 29V. This makes it a perfect candidate for additional circuits that connect to a KNX bus. But it’s not limited to KNX buses. If you want to build a WiFi interface for your Roomba, you also have to down-regulate the 15V battery voltage to 5V or even 3.3V. You want to something to power a circuit from a car battery? This seems to be a perfect circuit for there use cases.

mp1584With it’s tiny dimensions of 17 x 22mm it’s size is around the size of 2 MicroSD cards (and much smaller than a single SD card).

The output voltage of the module is controlled by a tiny potentiometer. You will need a multimeter to check the output voltage before connecting it to a circuit.

While the plain voltage range data seems to be quite good, how does the circuit behave on different loads? Some Chinese dealers claim that similar modules should handle 3A load. If you just look at the size of the inductor you might already start thinking that this most likely isn’t true. However, DC resistance of the inductor is approximately 10mOhm (I miss my Kelvin probes and therefore could only measure this very roughly).

Let’s start with 29V input voltage – this will bring everything to the limit. Output voltage is fixed to 5V in this experiment. Without any current drawn, it still looks a bit rough:

29_0

However, a voltage swing of (Vpp) 98mV is no problem at all. Between 0.1A and 0.9A the circuit behaves quite well. Vpp is around 0.2V (a bit lower on low currents, higher in higher currents)

29_0.5

We reach the end at 1A. Now the regulator doesn’t provide a stable output voltage anymore:
29_1

But what about lower input voltages? Let’s go the the other “extreme”: 9V (it will work with even less, but let’s give it a bit headroom).

Almost perfectly clean with no load:
9_0

A bit more stable than at 29V for currents between 0.1A and 0.7A:

9_0.4

And at 0.7A we reach the end of the useable current range:

9_0.7

Conclusion: This module works fine for almost every embedded use case: Arduino, ESP8266 WiFi modules and even a Raspberry Pi without any additional USB devices plugged in.

Here are 2 animation that shows the output voltage under different loads:

29V input, 5V output, 0-1A in 0.1A steps:

29v_animated

9V input, %V output, 0-0.7A in 0.1A steps:

9v_animated

Stromversorgungen für LED-Installationen

Im Internet findet man viele spannende Selbstbaulösungen mit LEDs. Die beiden häufigsten Anwendungen sind LED-Streifen für Beleuchtungszwecke und Ambilight-Nachbauten. In der letzten Woche fand ich auf einer Selbstbauseite eine sehr gute Beschreibung zum einem Ambilight-Eigenbau. Ich werde diese hier aber nicht verlinken, denn meiner Meinung nach ist dieser Aufbau nicht sicher.

Das entsprechende Projekt und viele andere Projekte nutzen Spannungsversorgung, die ähnlich aussehen, wie diese hier:

pl8886134-short_circuit_protection_standard_led_display_power_supply_100w_5v_20a_ip20_60hz_en1122

Warum? Dieser Typ ist auf Chinesischen Webseiten recht günstig zu erhalten. Dieser Netzteiltyp ist nicht grundsätzlich unsicher. Die Bauqualität ist in der Regel sogar recht hoch, da man die Bauteile von aussen sehen kann und die Hersteller sich daher Mühe geben, dass alles gute und gerade verlötet ist. Das sagt zwar nicht generell etwas über die Qualität aus, aber es kann ein erster Hinweis sein. Warum sollte man diesen Netzteiltyp dennoch nicht nutzen? Was ist das Problem?

Das Problem fängt an, wenn man ein derartiges Netzteil an einem Platz installiert, den man mit den Fingern erreichen kann. Ein Beispiel sieht man z.B. hier:

powersupply-unsafe

Auch wenn dieses Netzteil auf der Rückseite des TVs installiert ist, besteht dennoch die Möglichkeit, dass man z.B. beim Putzen mit Netzspannung in Kontakt kommt. Und das kann tödlich enden!

Es gibt eine ganz einfache Möglichkeit, solche Probleme zu vermeiden. Man muss nur ein Netzteil nutzen, wie man es z.B. von Laptops kennt:

laptop-adapter-ac-adapter

Solche Netzteile sind in allen gängigen Spannungen erhältlich und können je nach Typ bis zu 100W Leistung bereitstellen – mehr als genug für übliche LED-Installationen.

Batteriebetriebener Sensor auf ESP8266-Basis

Der ESP8266 ist ein leistungsfähiger und günstiger Mikrocontroller. Während früher noch oft proprietäre Funkprotokolle wie z.B. nRF24-basierte Chips genutzt wurden, kann man viele heute für viele Anwendungsfälle gleich auf WLAN setzen. Es gibt allerdings ein grosses Problem mit WiFi: der Stromverbrauch.

Wenn der ESP8266 mit einem WiFi-Netzwerk verbunden ist, verbraucht er mindestens 70mA, teilweise sogar deutlich mehr. Wenn man nur ein System mit einem 2400mAh-Akku betreiben will, ist dieser nach spätestens einem Tag leer. Und niemand möchte wohl für Sensoranwendungen eine Autobatterie nutzen.

Glücklicherweise müssen Sensoranwendungen in vielen Fällen nur selten Daten übertragen. Selbst Messungen müssen oftmals nicht ständig erfolgen. Das heisst, die meiste Zeit kann der Chip einfach schlafen. Um dies umzusetzen, geht man wie folgt vor:

  1. Daten sammeln. Das sollte geschehen, bevor das WLAN-Modul aktiviert wird (ausser, die Datenabfrage benötigt nur wenige Millisekunden)
  2. Mit dem WLAN verbinden
  3. Daten senden
  4. In den “Deep sleep”-Modus wechseln. Hierfür nutzt man die ESP.deepSleep() Funktion.

Bei der ESP.deepSleep() Funktion gibt es im übrigen einige Dinge zu beachten:

  1. Damit der Mikrocontroller nach der entsprechenden Zeitspanne wieder aufwacht, mit GPIO16 des ESP8266 mit dem RESET-Pin verbunden sein. Ansonsten schläft der Controller ewig.
  2. Der delay-Parameter ist in Mikrosekunden anzugeben. Wenn sich der ESP8266 also scheinbar nie schlafen legt, könnte es sein, dass man die Zeit versehentlich in Sekunden oder Millisekunden angegeben hat.
  3. Es gibt einen zweiten – optionalen – Parameter, der 4 Werte annehmen kann: WAKE_RF_DEFAULT, WAKE_RFCAL,WAKE_NO_RFCAL, WAKE_RF_DISABLED. Der Wert WAKE_RF_DISABLED sieht auf den ersten Blick vielversprechend aus, denn irgendwie sollte das WiFi-Modul ja abgeschaltet werden. Allerdings bezieht sich dieses Argument auf die Funktion nach dem Aufwachen. Übergibt man hier also WAKE_RF_DISABLED , ist der ESP8266 nach dem Aufwachen nicht mehr in der Lage über WLAN zu kommunizieren.

Hier noch ein paar zusätzliche Tips zum Stromsparen:

  1. LEDs als optische Signalisierung sollten nur sehr kurz eingeschaltet werden. Einige Millisekunden reichen i.d.R. aus, damit der Benutzer das Aufblitzen wahrnimmt.
  2. Müssen die LEDs etwas länger eingeschaltet bleiben, sollten sie gedimmt werden. Mit der analogWrite Funktion kann man das einfach umsetzen.

Hier ist ein einfaches Beispiel, das die Daten vom Analogeingang des Controllers liest und an einen MQTT-Broker übermittelt:

#include         // Generic ESP8266 WiFi routines
#include        // MQTT client
#include           // Local DNS Server used for redirecting all requests to the configuration portal
#include    // Local WebServer used to serve the configuration portal
#include         // WiFi Configuration Magic


const char* mqtt_server = "192.168.1.88";
const char* mqtt_channel_up = "active";
const char* mqtt_channel_data = "sensor/%d/adc";

const int pin_red = 15;
const int pin_green = 12;
const int pin_blue = 13;
const int pin_button = 4;
const int analog_ldr = 0;

const int sleepSeconds = 60 * 15;

WiFiManager wifiManager;
WiFiClient espClient;
PubSubClient client(espClient);


void send_sensor_data(void) {
  Serial.println("Sending sensor data\n");
  int data = analogRead(A0);
  char s_channel[50];
  char s_id[10];
  char s_data[10];
  sprintf(s_channel, mqtt_channel_data, ESP.getChipId());
  sprintf(s_id, "%d", ESP.getChipId());
  sprintf(s_data, "%d", data);

  digitalWrite(pin_blue, HIGH);
  client.connect("ESP8266Client");
  digitalWrite(pin_blue, LOW);
  if (! client.connected()) {
    Serial.println("Could not connect to MQTT broker, doing nothing");
  } else {
    digitalWrite(pin_green, HIGH);
    client.publish(mqtt_channel_up, s_id); // show that this device is up
    client.publish(s_channel, s_data); // send sensor data
    digitalWrite(pin_green, LOW);
  }
}

void setup() {
  delay(500); // This makes it easier to upload new firmware and/or press the "clean" button

  pinMode(pin_red, OUTPUT);
  pinMode(pin_green, OUTPUT);
  pinMode(pin_blue, OUTPUT);

  digitalWrite(pin_red, HIGH);

  // Setup Serial interface for debugging
  Serial.begin(115200);

  //  Bring up WLAN
  WiFiManager wifiManager;

  //sets timeout until configuration portal gets turned off
  //useful to make it all retry or go to sleep
  //in seconds
  wifiManager.setTimeout(60);

  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);
  wifiManager.addParameter(&custom_mqtt_server);

  if (digitalRead(pin_button) == 0) {
    // reset settings
    wifiManager.resetSettings();
  }

  //fetches ssid and pass and tries to connect
  //if it does not connect it starts an access point with the specified name
  //here  "AutoConnectAP"
  //and goes into a blocking loop awaiting configuration
  if (!wifiManager.autoConnect()) {
    Serial.println("failed to connect and hit timeout");
    delay(100);
    // do nothing: deep sleep, but longer than usual. Something might be wrong and
    // we should save power
    ESP.deepSleep(sleepSeconds * 10 * 1000000, WAKE_RF_DISABLED);
  }

  mqtt_server = custom_mqtt_server.getValue();

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  // Setup MQTT client
  client.setServer(mqtt_server, 1883);

  digitalWrite(pin_red, LOW);
}

void loop(void) {
  send_sensor_data();
  Serial.printf("Sleeping deep for %i seconds...", sleepSeconds);
  ESP.deepSleep(sleepSeconds * 1000000);
  delay(100);
}

Ein minimaler KNX Testaufbau

Als erfahrener Elektronikbastler ist es auch interessant, mit KNX zu experimentieren. Leider hat KNX den Ruf, teuer zu sein. Ganz so schlimm ist es nicht, denn für einen kleinen KNX-Aufbau muss man nicht Tausende Euro bezahlen. Das braucht man:

  • Eine 29V Spannungsversorgung, die mindestens 300mA Strom liefern kann.
    Hierfür sollten fast alle Labornetzteile gut funktionieren, ein extra KNX-Netzteil muss es für einen Testaufbau nicht sein.
  • Eine KNX-Drossel.
    Ohne eine Drossel zwischen Netzteil und KNX-Bus wird keine Kommunikation auf dem Bus möglich sein, denn die Drossel entkoppelt die geregelte Spannungsversorgung von den Datensignalen auf dem Bus. Eine Drossel bekommt man neu ab ca. 35 Euro. Einige Benutzer berichten, dass ein 47-Ohm Widerstand zwischen Stromversorgung und Bus den gleichen Zweck erfüllt. Da ein Widerstand nur ein paar Cent kostet, kann man durchaus ausprobieren, ob das funktioniert. Für einen Einsatz in einer echten Haussteuerung sollte man aber auf keinen Fall auf die Drossel verzichten, selbst wenn in der Laborumgebung ein Widerstand funktioniert.
  • Ein KNS Sensor
    Ein paar Schalter und Taster hat sicher jeder Elektronikbastler herumliegen. In diesem Fall ist die günstigste Variante, diese mit dem KNX-Bus zu verbinden ein KNX Busankoppler. Oft findet man ältere Geräte auf eBay für weniger als 30 Euro.
  • Ein KNX Aktor
    Manche KNX-Sensoren haben bereits eingebaute LEDs, die über KNX gesteuert werden können. In diesem Fall ist es nicht einmal erforderlich einen zusätzlichen Aktor zu beschaffen. Ein “richtiger” Aktor ist natürlich trotzdem ganz nett, denn damit kann man dan richtig schalten. Alte Unterputz-Aktoren bekommt man auf eBay auch häufig für weniger als 30€.
  • Ein USB oder Ethernet-Adapter für KNX
    USB Schnittstellen sind meist günstiger zu bekommen, speziell auf eBay, wo man gebrauchte USB-KNX-Interfaces für weniger als 80€ findet. Allerdings würde ich diese heute nicht mehr empfehlen. Günstiger KNX/IP-Interfaces mit Ethernet-Schnittstelle bekommt man für weniger als 150€. Mit einem solchen Interface ist man wesentlich flexibler, da der Rechner mit der Haussteuerung nicht direkt neben dem KNX-Interface stehen muss.

Alles in allem muss man schon mit einer Investition zwischen 200€ und 300€ rechnen. Allerdings ist die teuerste Komponente das KNX/IP-Interface. Wenn man nach einigen Experimenten doch  beschliessen sollte, nicht weiter mit KNX zu arbeiten, kann man die meisten Geräte auf eBay verkaufen und wird keinen grossen Wertverlust haben (speziell KNX/IP Schnittstellen sind gebraucht kaum günstiger als neu).

Eine Minimalinstallation könnte dann so aussehen:

Minimal KNX installation