3D Print your own book ornaments

For an index to all my stories click this text.

As you might know I have several hobbies. electronics is one of them and bookbinding another.

For the decoration of a book I needed some ornaments. Bookbinding shops are hard to find. And I did not want to wait for one of the few bookbinding fairs in the Netherlands. So I decided to try to build some myself.

I am not a metalworker or woodworker but I do have a 3D printer. And I set out to make the ornaments with that.

Search ornaments on the web

I started by using Google to search for corner-ornaments. And that turned out well, I found many.



Copy the image with ctrl print-screen and paste it in your favorite
image editor. I use The Gimp for that: https://www.gimp.org/



Cut out the picture you want and save that to your harddisk.



Use convert.io to convert it to SVG



Import the svg into tinkercad and scale it to whish.
Mine was about 4 cm width and depth. I scaled the height to 1mm and then exported the STL.



Next I imported it in my slicer. For simple things like this I use the Creality slicer.

I sliced this at .3 mm.
That meant that it will have 3 layers and prints fast about 10 minutes for 2 pieces



Next step was printing them. I used white PLA as that is the easiest color to paint afterwards.



The printed ornaments were placed on an old newspaper and I sprayed them with gold and silver acrylic paint. I used a spraycan for this and of course did it outside.



And here is the result. I placed them on a book (pen for scale) with an artificial leather cover and they look quiete nice !!! At the time I did not glue them on as I was not yet shure which color would match best.



At closeup you can see the printing artefacts. But you will not notice them from a distance. Next time I'll try the ironingsetting in my slicer. For now this is good enough for me.

Till next time,
have fun


Luc Volders

Getting the right time: another method

For an index to all my stories click this text

Getting the right time is often a requirement for IOT and other projects.
Usually we use an NTP server for this like described in a previous story on this weblog which you can find here: http://lucstechblog.blogspot.com/2023/04/getting-right-time-with-micropython.html

There is just a small problem with this. If you have read that story you will know that you need to make a manual adjustment in the software for the Daylight Savings Time to get the right time. And that is annoying with a finished project. This means that you must update your program twice a year.

What if you want your program to automatically adjust to the right time ??
Well here is how to do that with MicroPython.

The pitfall.

There is no way to automatically get the right time if your finished project is regularly placed in another location, unless you are sure they are in the same timezone.
Your exact time is dependent on your geographic location. The local time in London is different from the time in Amsterdam for example.

So when your project is moved internationally an adjustment must be made for the location where it is at.
There is a trick for getting your location and we are going to use that here. However when the project moves from London to Amsterdam undoubtedly the microcontroller needs to contact another router for wifi access. And to achieve that you need to fill in the routers credentials. And there is your manual involvement.

Getting your location.

For getting the right time your program needs to know your location. And here is a nice trick for getting your location.

Your router is likely connected to a local internet provider. So you will get an internet IP address that is likely to be from your own timezone.
By connecting to the ip-api.com service you will get your internet IP address.

Let's try this first.



Just point your browser to https://ip-api.com/
scroll a bit down and there is your information.

I camouflaged my own IP number as I want some privacy.
But look at the info and you can see that IP-API.COM estimates that my IP number originates from the town Boekel in the Netherlands.

Well actually that is not my location but the important part is that this is in the same Time-Zone as I am. So using my Internet IP number indeed points to the right timezone.

When you move your project to a different location you only have to point your browser to https://ip-api.com/ to know if your program will automatically get the right timezone. If that is so you do not need to make any changes to your program.

We will need the IP address in the next step which is getting the right time. But to achieve that we first need our program to fetch the IP address from the ip-api.com website.

Using the Internet IP address to get the right time

Now let's have a look at the ip-api.com documents page: https://ip-api.com/docs



Above shows the part from the documentaion that tells how to use the api to get the response in JSON code.

http://ip-api.com/json

So this is the only part we need to translate into MicroPython. And here it is.

import network
import urequests

# Router credentials
ssid = "YOUR-ROUTERS-NAME"
pw = "YOUR PASSWORD"

print("Connecting to wifi...")

# wifi connection
wifi = network.WLAN(network.STA_IF) # station mode
wifi.active(True)
wifi.connect(ssid, pw)

# wait for connection
while not wifi.isconnected():
    pass

def get_public_ip_address():
    response = urequests.get('http://ip-api.com/json')
    json_data = response.json()
    return json_data['query']

ip_address = get_public_ip_address()

print(ip_address)

Running this program will put the Internet IP-address into the variable ip_address and prints it out in Thonny's shell.

I dont think this needs any explanation. The received data is JSON code and we distill the information from the line "query" from that and that presents us the IP address.

If you need more information on how to program in MicroPython and how to use the requests library or to distill JSON information I can recommend my book: Raspberry Pico W simplified. These things are discussed in details in the book.

You can buy it from Amazon. Click here or the above picture for the link.

Using the IP-Address to get the right time.

Now we have our Internet IP-Address we can use that to get the right time for our time-zone. We are going to use the https://timeapi.io/ service for that.



https://timeapi.io/ is a free service that will provide us the right time for our location. To do so we use their API call and provide our Internet IP-address. You can find all documentation on this site: https://timeapi.io/swagger/index.html



As you can see there are a lot of possibilities. We can use our IP address to get the right time and we can also use our latitude and longitude if they are known. Let's stick to getting the time by using the just found IP address.



The page offers you the possibility to try it out. And if you do you will get an example on how to code the API and the results are displayed further on. We are interested in how the API call should be used and the page shows how it is done:

https://timeapi.io/api/Time/current/ip?ipAddress=237.71.232.203

The provided internet IP=address is just a sample. We will have to replace that with our own IP address.

This is how that is done:

response = urequests.get('https://timeapi.io/api/Time/current/ip?ipAddress='+ip_address)

json_data = response.json()

print("Hour  : "+str(json_data["hour"]))
print("Time :  "+str(json_data["minute"]))

The urequests library calls the API and in the call we added our own just found IP-address.



And here is the information shown in Thonny's shell. And believe me the time was accurate.

The complete code.

For your convenience I hereby give you the complete program

import network
import urequests

# Router credentials
ssid = "YOUR-ROUTERS-NAME"
pw = "YOUR-PASSWORD"

print("Connecting to wifi...")

# wifi connection
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(ssid, pw)

# wait for connection
while not wifi.isconnected():
    pass

def get_public_ip_address():
    response = urequests.get('http://ip-api.com/json')
    json_data = response.json()
    return json_data['query']

ip_address = get_public_ip_address()

print(ip_address)

response = urequests.get('https://timeapi.io/api/Time/current/ip?ipAddress='+ip_address)

json_data = response.json()

print("Hour  : "+str(json_data["hour"]))
print("Time :  "+str(json_data["minute"]))

Power Failure

I am sure you will notice that this is a great way to get the accurate time for your IOT and other projects. Get the significant part of this program and use it in your own project so you will automatically get the right time even after a power failure.

Till next time
Have fun

Luc Volders

MicroPython bytecode speed test

For an index to all my stories click this text

In the previous story I wrote how you can make your MicroPython sourcecode unreadable for most users. I did that for trying to protect my program. The way to do this is to convert your program into bytecode. You can read that story here: 
https://lucstechblog.blogspot.com/2025/06/protect-your-micropython-sourcecode.html

After I published that story here on my weblog I received a mail from a reader that asked if the bytecode was actually faster as standard MicroPython. The question is valid as bytecode is actually easier to interpret as MicroPython code.

So I did some tests.

Prime numbers

I took a smal program that calculated and printed a few thousand prime numbers. Here is the code.

import time

start_time = time.ticks_ms()

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

count = 0
n = 2
while count < 5000:
    if is_prime(n):
        print(n)
        count += 1
    n += 1

end_time = time.ticks_ms()
elapsed_time = time.ticks_diff(end_time, start_time)

print("Elapsed time:", elapsed_time, "milliseconds")

This code took 32993 miliseconds to run on an ESP8266 with MicroPython V1.20.1.

Then I converted the program to bytecode and it took 32149 microseconds to run. So it was 844 miliseconds (almost a full second) faster.

That is 2.5% faster.

So it is a bit faster but not a lot to gain..

Without print

A lot of time is consumed by the print statement. Print is dependend on the serial communication between the microcontroller and your computer. So let's see what we gain if we leave the print command out.

import time

start_time = time.ticks_ms()

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

count = 0
n = 2
while count < 5000:
    if is_prime(n):
        count += 1
    n += 1

end_time = time.ticks_ms()
elapsed_time = time.ticks_diff(end_time, start_time)

print("Elapsed time:", elapsed_time, "milliseconds")

It's the same program without the print command in the while loop.

The program now took 32385 miliseconds to run.

Again I converted it to bytecode and then it needed 31570 miliseconds to run.
That is 815 miliseconds faster. Again almost a second faster.

And that makes it also 2.5% faster.

This is just a small test but this already shows that bytecode is a bit faster as MicroPython code. So you might gain some speed in certain projects.

Conclusion

Byte code is not real native machine language but an in-between step. This small test already shows that bytecode is a bit faster as MicroPython code. So you might gain some speed in certain projects.

This is not a scientific test just a small test to see if there is any speed to gain. Your results might vary depending on the Microcontroller you are using (ESP8266, ESP32, Raspberry Pi pico etc.) size of the program, libraries used and commands used. So make some tests for yourself.

Till next time,
have fun


Luc Volders