Bodet BT 6.30 Slave Flip Clock with ESP32 Control

I've done it again. This time, I found a very affordable Bodet BT 6.30 flip clock with a date display on a classifieds site and, of course, I snapped it up immediately. This clock is also a slave clock, so I retrofitted it with an ESP32 microcontroller to make it work without a master clock.

Unfortunately, the clock wasn’t in the best condition. The front was quite scratched, the logo was broken off, and apparently someone once painted the walls without removing the clock first.

Inside the clock, there was another nasty surprise. Two completely charred resistors next to two small batteries, which initially made me a bit worried about whether the clock would work at all. The previous owner mentioned he only used it for decoration, so he couldn't tell me if it was still functional. But before I could test that, I first had to understand how the mechanism actually works.

How does this flip clock work?

A look inside the clock reveals that the upper assembly with the time display is almost identical to the flip clock without a date display.

Only on the left side, there is an additional eccentric disc, which changes the day every 24 hours via a lever. During the transition from the 31st to the 1st, the month is then changed. If all months had 31 days, the mechanics would be complete at this point.

However, since this is not the case, the clock has an ingenious mechanism that controls how many days a month has. Since the flip digits have 31 days, there is a motor on the side that simply advances the days if the month has fewer than 31 days. A gear with exactly 31 teeth and sliding contacts is used to detect which day the mechanism is currently on.

On the other side of the date mechanism there’s a coding disk, which determines the number of days per month.

This disc, however, doesn't just encode one year, but four years at once, so that leap years also function correctly. With each month change, this disc turns a little further, making a complete rotation every four years. While this doesn't cover all leap year rules, it won't become a problem until the year 2100, so I'm very relaxed about it :-)

The motor that advances the date when necessary must somehow be supplied with power. Since it's a slave clock, there is no constant power supply, only pulses with alternating polarity. This small circuit board with the charred resistors is likely responsible for this.

The other component appears to be a rectifier, which is used to slowly charge the batteries with these pulses. This is just a guess, but it makes sense in my opinion. Since I don't need this part, I removed this circuit board.

Testing the date mechanism

I could easily test the function of the flip digits using the corresponding levers on the clock. They all worked without any issues. To test the motor, I tentatively applied a voltage of 3 volts directly to it. However, the motor didn't move at all.

Therefore, I removed the motor, took off the two sliding contacts, and cleaned them carefully. Additionally, I oiled the motor and the gears a little with precision mechanics oil. And sure enough, after reassembly, the motor worked wonderfully again.

Now that it was clear that the entire mechanism was still functional, I could turn my attention to the electronics.

Controlling the Flip Clock with the ESP32

Originally, I wanted to use the same control system for this clock as for my other flip clocks. However, the situation is a bit different this time:

The motor requires a voltage of about 3 volts, which the electronics must provide.
With flip clocks that only show the time, I could simply advance the time if it was running fast, for example, when changing from summer to winter time. Here, the time jumps from 3:00 to 2:00, so the clock simply flips forward 23 hours to show the correct time again. This is not possible with this clock, as it would have to flip through a full 4 years until the time and date are correct again.
This time I want to use my new Wi-Fi provisioning library, so I no longer need buttons on the microcontroller to set the clock to 0:00.
This clock also came with the wall mount, so I don't need to print a bracket to house the electronics.

Therefore, I developed both the electronics and the software for this clock from scratch.

The Electronics

I used the following components for the electronics:

A step-up converter that generates 12 volts from the 5 volts of the USB connection. Additionally, this converter can charge a battery, thus powering the clock even during a power outage.
A step-down converter that generates the 3.3 volts for the microcontroller and the motor from the 12 volts.
An L293D motor driver to generate the pulses for the stepper motor.
An ESP32-DevKitC V4 module.

The entire circuit looks like this:

I soldered the modules onto a perfboard and connected them on the underside. The result looks like this:

There is enough space on the right side of the clock to accommodate the circuit board along with the battery. For this, I designed a small holder that plugs into the pins that happen to be in this location inside the case.

The circuit board is simply inserted into the holder, and I attached the battery holder with double-sided tape. Finally, only the wires need to be connected. For the power supply, I use the lines that normally carry the signal for the slave clock.

What's still missing is the USB connector. For this, I used the cutout on the side of the mount and also designed a small adapter that simply plugs into this cutout.

Finally, the USB connector's cable is screwed into the terminal block.

Of course, the connections that are also used inside the clock for the power supply must be used.

Later, you simply place the clock onto this mount. This way, I didn't have to drill any holes in the clock or do anything similar, ensuring the original is not damaged in any way.

The Software

As mentioned above, controlling the clock via buttons is omitted this time, as the principle has changed slightly. The fundamental problem with the control is synchronizing the microcontroller's time with the time displayed on the clock. Since there is no mechanism for the microcontroller to read this mechanical time, it must be told once at the beginning. In the old control system, you had to set the flip clock to 0:00 with the buttons, and the microcontroller took that as the starting value.

In the new control system, it's the other way around. During Wi-Fi provisioning, the microcontroller is told what time is currently displayed on the clock. With this value, the delta to the actual time is calculated, and pulses are sent accordingly to set the correct time on the clock. The basic structure of the software is therefore very simple:

extern "C" void app_main(void) {
    ESP_LOGI(TAG, "Application starting...");

    FlipClock clock(PULSE_GPIO_ENABLE, PULSE_GPIO_INPUT1, PULSE_GPIO_INPUT2,
                    PULSE_WIDTH_MS, PULSE_INTERVAL_MS);

    WifiProvisioner provisioner;

    if (provisioner.is_provisioned()) {
        provisioner.get_credentials();
    } else {
        provisioner.start_provisioning("BT630 Setup", false);
    }

    provisioner.connect_sta("BT630 Clock");

    while(!provisioner.is_time_synchronized()) {

        ESP_LOGI(TAG, "Zeit ist noch nicht mit dem NTP-Server synchronisiert.");

        // Warte eine Sekunde bis zur nächsten Ausgabe
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
    
    clock.setTime(provisioner.get_provisioned_hour(), provisioner.get_provisioned_minute());

    // Hauptschleife: Einfach und sauber
    while (true) {
        clock.update();
        vTaskDelay(pdMS_TO_TICKS(1000));
    }

}

The logic for comparing the time and sending the pulses is located in the FlipClock class:

void FlipClock::update() {
    time_t now;
    time(&now);
    
    time_t current_minute_floored = (now / 60) * 60;

    if (_clock_time < current_minute_floored) {
        int minutes_to_flip = (current_minute_floored - _clock_time) / 60;
        ESP_LOGI(TAG, "Uhr geht %d Minute(n) nach. Sende Impuls(e)...", minutes_to_flip);
        
        _send_pulses_internal(minutes_to_flip);
        
        _clock_time = current_minute_floored;
        ESP_LOGI(TAG, "Zeit ist wieder synchron.");
    }
}

Since a flip clock cannot run backwards, pulses are only sent when the flip clock's time is behind the actual time. If it's the other way around, the control system simply waits until it matches again. This will be specifically noticeable during the switch from summer to winter time. When the time is set back one hour at 3:00, the clock will wait for one hour until the two times are synchronized again.

The complete source code for the control system is available on GitHub.

Fine-tuning

Since the clock was not in the best visual condition, I also thoroughly cleaned all the parts. I spent what felt like hours working on the front with a polishing paste. But it was worth it; practically no scratches are visible anymore.

Another problem was the logo. For this, I simply redrew the Bodet logo and 3D-printed it. It's not as fine as the original, of course, but from a distance, it's hardly noticeable.

The 0.4 mm nozzle is probably a bit too coarse for such fine structures. Maybe I'll try again later with a 0.25 mm nozzle.

Initial Setup

The Bodet BT 6.30 is not a clock you can just turn on and it runs. The date and time must be set beforehand. For this, there are several levers inside the clock that can move the flip tiles.

A specific sequence must be followed during setup:

Set the minutes to 00 with lever 1.
Set the hours to 0 with lever 2.
Set the day to 1 with lever 3.
Set the month to the current month in the correct year with lever 4. You can either keep flipping the month until the year is also correct, or, while holding down lever 4, turn the year disc with lever 5. The set year is visible behind lever 5 and must be set according to the values on the disc (1977, 1978, 1979, 1980) so that the difference to the current year is a multiple of 4 (e.g., for 2025 = 1977 + 4 * 12).
Now set the correct day with lever 3.
Set the hours with lever 2.
Set the minutes with lever 1.

After these steps, the clock's case can be closed and the power supply connected via the USB plug on the back.

Im nächsten Schritt erfolgt die Einbindung der Uhr in das eigene WLAN. Dazu verbindet man sich mit dem Smartphone mit dem WLAN BT630-Setup. Danach erscheint auf dem Smartphone die Provisioning Seite:

The next step is to connect the clock to your own Wi-Fi network. To do this, connect your smartphone to the "BT630-Setup" Wi-Fi network. The provisioning page will then appear on your smartphone:

Bodet BT 6.30 Flip Clock WiFi Setup

Here, you select your Wi-Fi network, enter the corresponding password, and input the hour and minute values that are displayed on the flip clock. After clicking on "Save & Connect," the clock connects to the Wi-Fi, and after successful synchronization with a time server, the clock sets itself automatically. From now on, the clock is running. Since the power supply is buffered by a battery, you can conveniently place the clock wherever it will hang in the future.

Conclusion

With that, this project is complete, and I have another new gem in my apartment. I absolutely love this clock; I just need to decide where to hang it.