Wemos D1 consumption and VCC pins

So this 6 min boring video was just an experiment to make a small consumption table comparing how the Wemos D1 mini behaves when receiving power through the 5v and 3v3  pins.

75.5 avg mA only Wifi
126.5 mA with relay on
2.5 mA on deep sleep mode

75.4 avg mA only Wifi
119.5 mA with relay on
2.4 mA on deep sleep mode

All code examples will be published in this repository:


Playing with a Wemos D1 (ESP8266)

After learning some Arduino and building some demos I decided to give it a try to another Chips. And this one is the ESP8266, you can find it in eBay or alixpress searching for “wemos D1”

Basically this little guy has kind of the same capabilities of an Atmel chip with less Digital outputs(9) but comes with WiFi built it. So that means you can use it as a station (STA) or a soft access point. That enables to do a lot of stuff, for example deploying this with sensors and being able to read from another device connected with the same Wifi all of them. In turn, you could control the digital outputs, and turn on / off stuff that are connected to the D1.

This is just a small example built in 5 minutes. I just connected a led with a proper resistance to D4. I still do not understand well with pin 2 turns on D4 but that is important now since it’s just a small demo.

UPDATE: Now I understand. You need to use the constants to get the right pins. So using D4 will automatically point it to the right pin that is 2 :) But it’s just much simpler to use the constants unless you want to go all the time to the datasheet. After building this simple example I build a bigger one that can send a message from the web to a simple display and show some weather measurements. Will share it later on a new post if there is any interest about it. You can comment here if it would be interesting for you to read it.

NOTE: I made a mistake here and connected the 3.7 V. to the 3.3V pin. That is incorrect! It should be connected to the 5V pin that in turn goes to the power regulator
* Based on ESP8266 LLMNR responder sample
* Copyright (C) 2017 Stephen Warren 
* Based on:
* ESP8266 Multicast DNS (port of CC3000 Multicast DNS library)
* Version 1.1
* Copyright (c) 2013 Tony DiCola (tony@tonydicola.com)
* ESP8266 port (c) 2015 Ivan Grokhotkov (ivan@esp8266.com)

* Instructions:
* - Update WiFi SSID and password as necessary.
* - Flash the sketch to the ESP8266 board.
* - Point your browser to http://ip-you-get-in-serial-monitor-arduino/


const char* ssid = "yourRouterSSID";
const char* password = "yourPassword";

ESP8266WebServer web_server(80);

void handle_http_not_found() {
  web_server.send(404, "text/plain", "Not Found");

void handle_http_root() {
  // NOTE: Including bootstrap here just to make fancy buttons
  String headers = "	";
  String html = "Server options:
  html += "<a class='btn btn-primary' href='4/1' target='frame'>D4 on</a>
  html += "<a class='btn btn-primary' href='4/0' target='frame'>D4 off</a>
  html += "";
  web_server.send(200, "text/html", headers + html);

void handle4off() {
digitalWrite(2, 0);
web_server.send(200, "text/html");
void handle4on() {
digitalWrite(2, 1);
web_server.send(200, "text/html");

void setup(void) {
pinMode(2, OUTPUT);
digitalWrite(2, 0);

// Connect to WiFi network
WiFi.begin(ssid, password);

// Wait for connection
while (WiFi.status() != WL_CONNECTED) {
Serial.print("Connected to ");
Serial.print("IP address: ");

// Start LLMNR responder
Serial.println("LLMNR responder started");
// Start HTTP server
web_server.on("/", handle_http_root);
web_server.on("/4/1", handle4on);
web_server.on("/4/0", handle4off);

Serial.println("HTTP server started");

void loop(void) {

So after uploading this little script to your Wemos and of course updating your SSID and password to your router it should act like a server. Notice that I’m using a hidden Iframe to keep things simple, since I see other examples that submit a Form to itself and analyze the arguments. That is cool maybe for a bigger applicaion, but for simple apps, is enough to just point to an URL and reply with a 200 Http status.

Starting again with Arduino and 3D design

About a month ago I joined the amazing community of Thingiverse and started uploading my first designs made on Blender.

One of the first projects is to control automatically the curtain blinds to ensure we don’t have to get up to turn them manually. Actually it’s just a great excuse to learn more about arduino and stepper motor controlling.

This is the basic schema to control light detection:

Then I just connected some leds to the digital output:

int ledPinMin = 2;
void setup() {
pinMode(ledPinMin, OUTPUT); // declare the ledPin as an OUTPUT
pinMode(ledPinMin+1, OUTPUT);
pinMode(ledPinMin+2, OUTPUT);
pinMode(ledPinMin+3, OUTPUT);
pinMode(ledPinMin+4, OUTPUT);
pinMode(ledPinMin+5, OUTPUT);
void loop() {
int sensorValue = analogRead(A5);
int ledPin = sensorValue/50 +2;
digitalWrite(ledPin, 1);
digitalWrite(ledPin, LOW);

I really like the projects like arduino and the power that brings 3D printing to the table. It’s a great combination. Anything can be done you just need to have an idea and be creative enough to make it happen.

How routing internally works in Symfony 4 framework

At the moment of writing this I’m testing the Symfony 4 Framework after reading the following article and also Fabian’s latest posts on Medium.  I’m testing weather the not yet officially released version, will be a future candidate for some new project or not. But the interesting part of this research is that I already realized what I won’t do in new projects. But let’s focus first on the mission of describing how routing works internally in the framework.
So we will go from the Frontend Controller up to the internal guts that say from the route /test let’s execute Controller:test()

http:// bestpractices.local/test

The front-end controller located in /web/index.php bootstraps the framework:

$kernel = new Kernel(getenv('APP_ENV'), getenv('APP_DEBUG'));
$request = Request::createFromGlobals();
$response = $kernel->handle($request);

As we already know all this framework is based on Request -> Response concept from the beginning to the latest controller action and the Kernel is no exception.  If we open this Kernel we can see that it’s mission is to setup Cache and Logs directories, register the bundles, configure the Container and Routing.

To go deeper in the chain we need to open HttpKernel with the mission described as:
HttpKernel notifies events to convert a Request object to a Response one.
There on the handleRaw method “Handles a request to convert it to a response” is where the whole framework workflow takes place:

namespace Symfony\Component\HttpKernel;

class HttpKernel implements HttpKernelInterface, TerminableInterface {
private function handleRaw(Request $request, $type = self::MASTER_REQUEST)
        // request
        $event = new GetResponseEvent($this, $request, $type);
        $this->dispatcher->dispatch(KernelEvents::REQUEST, $event);

  // At this point the routing is already resolved
  // dump($request->attributes);exit();

        if ($event->hasResponse()) {
            return $this->filterResponse($event->getResponse(), $request, $type);

        // load controller
        if (false === $controller = $this->resolver->getController($request)) {
            throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));

// ... Return a response

As we can see on the first lines, the Routing part, is resolved dispatching an Event called KernelEvents::REQUEST

namespace Symfony\Component\HttpKernel\EventListener;

class RouterListener implements EventSubscriberInterface {

public function onKernelRequest(GetResponseEvent $event)
        $request = $event->getRequest();


        if ($request->attributes->has('_controller')) {
            // routing is already done

        // add attributes based on the request (routing)
        try {
            // matching a request is more powerful than matching a URL path + context, so try that first
            if ($this->matcher instanceof RequestMatcherInterface) {
                $parameters = $this->matcher->matchRequest($request);
                // dump($parameters); // here to see it matched

            } else {
                $parameters = $this->matcher->match($request->getPathInfo());


And in this part of the code we can see that dumping the $parameters the Request attributes are already assigned

$parameters = array(
  "_controller" => "App\Controller\DefaultController::testAction"
  "_route" => "test"

Note: Request->attributes is used to store information about the current Request such as the matched route, the controller, etc
But more interesting is to replace this dump for a : dump($this->matcher);
Then we can see that the real matcher of the routing is done by srcDevDebugProjectContainerUrlMatcher since we are currently using DEV as an environment.

This file, that we can find in this path /var/cache/dev/srcDevDebugProjectContainerUrlMatcher.php , is the responsible of returning the request parameters with the right controller to be executed for this route.
Since doing all the routing on the fly will be a real show stopper and we are concerned with performance: reading the configuration from the filesystem may slow down the application.

That’s why there’s a PhpMatcherDumper class which can generate an implementation of UrlMatcherInterface with all configuration in an optimized way.

Even in DEV, this UrlMatcher file, is only rendered again if we update any part of the routing. That’s one of the reasons clearing all cache will make a slow first request.

Lessons learnt from this research are:

  • Keep your routes clean
    Not used / deprecated routes that are still there will make this UrlMatcher unnecessary long and hence slower to resolve.
  • Avoid at all costs using Annotations for the routing
    It’s generally considered a bad practice in OOP and contains much more Cons than Pros
  • Avoid using Assetic
    This generates fully unnecessary routes for every assset in your HTML templates. New versions of Symfony will not come with Assetic so it’s better to get along without it.

I never care to check this routing to the core before and I highly recommend from time to time to check the internals of Symfony. You will learn a lot of the framework essentials and also will be more cautious of how to take the best of it. In my personal case, I learnt much more doing this small research taking your own conclusions, than reading some other developer top 5 list on framework optimization.

The code to reproduce this can be downloaded from public repository:

Integrating SSO in a project using Shibboleth authentication

Shibboleth is an open-source identity federation solution that’s used in research and education communities worldwide.

Graphic by ncsu.edu

Basically is a federating agent that consists of 2 components:

1- Service Provider (SP)
 which request attributes, represented in this implementation als storage.luckycloud.de using Apache2-mod-shib 
2- Identity Provider(IDP)
 which broadcasts attributes, and will be implemented in the Login-logic of the site

Now the SP is actually out-of-the-box with apache2 module mod-shib. But my interest here is to do the Identity Provider part als Symfony module.


Is someone else out there interested on following the implementation ?

Friction powered Longboard

This is a redesign of the Rotor Flettner project. The effect works after testing it mounted on a windsurf board but it has a potential flaw: Magnus effect has a smaller force than the wind pulling you to the side. The result is that you go more in the wind direction than in the direction that you really want to go. The equivalent to having a very small sail.

But anyways it was a lot of fun to make it and having already the engine and the structure to mount it I thought, why not to try doing something with it :)

And it works, went about 2 kilometers back and forth after discovering I made some design errors and that friction is not my friend. Engineering lessons learnt:
1.- Control cables of the engine should not be touching the floor
2.- Engine should transmit power using some similar material as the wheel
3.- Friction generates heat and 50% of the battery or more is wasted (maybe good for the winter)

Skate and position detail

Wheel coupling with engine

Anderson.Paak dances with us in Berlin

Great concert in Lido with Herr Paak.

Only bad detail: The sound in LIDO. I know that in small shows is almost impossible to have a great acoustic. But I heard Robert Glasper in Festsaal Kreuzberg 2 years ago, and it was just awesome sound. Leaving out the differences, since Festsaal was 90% wood, and thus a great acoustic natural place this time the sound people at Lido did a poor job. Or just the sound system is not prepared for a show like this. Could hear his voice almost always in the background, without a different output channel and always mixed with the bass and the percussion.

Anyways a great performer with a cool band, great DJ and a highly recommendable show. Proud to be dancing with you Brandon!

Learning DOCKER #1

Docker ship with containers

Docker is an exciting technology since April 2013 when it started as open source project. But is only since last year or so that I started hearing more and more about it. And it’s mostly because some companies like Zalando (Berlin) , Spotify and Netflix started implementing it successfully in their servers.

The Docker Mantra is the following :

Build, Ship, Run

Any App, anywhere!


I’ve started trying in my Ubuntu 14 machine with this tutorial:


And what I will try to accomplish in the next entries after playing around with it, is to instance some basic WebServer dingie with some simple API, or just Apache+PHP 7+Symfony. Keep tuned!

Some interesting links:
https://denibertovic.com/talks/supercharge-development-env-using-docker/ Supercharge your environment using Docker (Presentation)

New project: Portable Flettner-Rotor (Longboard)

3D model available on tridiv.com

The idea come while reading “Symmetry of Sailing” by Ross Garret. The german engineer Anton Flettner was the first to use this physical principle as propulsion engine for a ship in 1922.

The still difficult part and open points to discuss that I have in this Winter project are:

  • Material to use in the main structure. The goal is that is light, when possible less than 10 Kilos,  but resistant since it needs to provide lift.
  • Motor weight: 170 g  Speed controller: 230 g  . Cables + Battery: Aprox.  2 K. Making a total of 2.5 Kilos weight.
  • Still open to discuss: At what speed needs the cilinder to roll and what would be the ideal diameter to provide enough momentum to move 70 Kg in a Longboard (I thought about 40 cm diameter).
    The chain relation between the motor and the cilinder to have the right speed and force. Ex: 10 spin motor: 1 spin cilinder
  • And to end the question: What kind of lift will this generate on a 10 Knots wind, coming from the optimal point, let’s say 90 degrees left or right from the cilinder.

The evolution of a sponsored Tweet

Mini-post with a tweet advertising test made 5 Nov. 2015 at 13:45.

Budget: 9,20 € ( 10 dollars is the minimun budget )

At the end of the day what it delivered is this:

696 organisch / 11.177 gesponsert
Interaktionen insgesamt
79 organisch


Medieninteraktionen 416
Detailerweiterungen 145
Profilklicks 60
„Gefällt mir“-Angaben 8
Retweets 7
Link-Klicks 7
Hashtag-Klicks 2
Folgt 1

I think that it can be a great way to make branding campaigns and to get visibility for a new product or startup.