ciesie.com

Parsing JSON-RPC in C

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 31 Jan 2026

Yeah you’re not convincing me that JSON-RPC is a real protocol <

Let’s deal with JSON-RPC in C! Something I don’t ever want to hear when sipping an iced coffee, during a sunny, June afternoon. Fortunately, it’s January and I haven’t seen the sun in a while! This article is sponsored by my lack of vitamin D!

I have been building my own Moonraker GUI client. Inspired by Mainsail and Fluidd but not a web application. I want to get more experience in immediate GUI paradigm and memory management through different types of allocators. I’ll write about that project soon, but today I’ll be focusing on a small part of it. That part is “parsing JSON-RPC messages using C, but honestly not fully even, just a part of them”.

Things I'm looking forward to in 2026

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 19 Jan 2026

AI wheels coming off <

Do you remember people loudly proclaiming we’ve built a sentient intelligence?

Because you should. Those people should be remembered as the first line of “intellectuals” that has fallen to the onslaught of AI propaganda. AI is a marketing term and in the last few years it has become a test, just like NFTs, testing your resilience to corporate propaganda.

'Slightly' is doing a lot of heavy lifting here...

Many have fallen, many are still in the trenches, slowly falling for the trick that are LLMs. I do recognize I might need to employ more empathy here. Seems AI triggers literal psychosis in some people.

Ender 3 and the power of 3D printing community

ciesielskimm@gmail.com (Michał Ciesielski) — Wed, 16 Jul 2025

I really like my Ender 3. After several necessary upgrades, I think I’ve reached a place where it’s dependable and I know it well enough to fix most of the issues. Moving apartments forced me to pull it apart. That became a perfect opportunity to build it back up into something better.

I’ve always had an issue with leveling the bed - me, and everyone else who bought this printer. For a short period I have managed with a glue stick. It was time to look into bed probes. At this point there are some very precise solutions, like the Cartographer 3D, but that felt like too much complexity and too much fidelity for such an unsophisticated printer.

Well, it seems you just don't like programming

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 03 Feb 2025

I already tried to write a blog post about AI. An article, discussing AI generated art, still festers in my drafts folder. As someone who enjoys 3D modelling, drawing, animating, someone who believes in art lifting our spirits, I find it pointless and distasteful. Not much to discuss.

Here are some loose thoughts about AI, mostly from software development perspective, but not unique to it.

I see coding as both a skill, which enables me to build things I want to build, and an intellectual exercise. Like any other discipline, it doesn’t have sharp borders. If you’re receptive, if you pay attention, you’ll learn things that apply outside of computer science. Underlying principles behind coding tell a bigger story, about systems, math, logic, or effective communication of ideas. Diving deeper into these ideas can become a source of great, personal satisfaction.

Update for December, 'here we go again' 2024

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 01 Dec 2024

It’s been a while since I have written one of these. There’s definitely a cadence to these. That cadence would be something between once and thrice a year. 2024 will have to make with just one.

I have spent a bit of time understanding the ggwave project, which allows for sending data over sound. It’s not an extremely complicated protocol. I think the most difficult part to understand is the Reed-Solomon error correction, which is still something I have not delved deep into. I have first started by understanding Fourier Transform well. This started with a Jupyter notebook, but I have quickly moved to using Marimo. You can find my repo here, but don’t expect it to be polished and guests friendly.

Tagged Unions - bag them and tag them

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 25 Jun 2024

I have recently tried to update my Zig project from 0.11.0 version of Zig, to 0.12.0. Zig compiler brings in its own build system. Since Zig is still under development, that API changes. The 0.12.0 changes forced me to dive a bit deeper into Zig’s source code. I went through Build.zig and Step.zig. What caught my attention was the usage of Tagged Unions.

Tagged unions aren’t nothing new. C has them… kind of. In C, the tagged unions are more of a design pattern than a language feature.

Custom Linux build for Raspberry PI with Buildroot

ciesielskimm@gmail.com (Michał Ciesielski) — Wed, 20 Mar 2024

It seems working in embedded means you’ll, sooner or later, use a Raspberry PI. At my current work place we use Raspberry PIs, connected to the hardware we’re developing for, as Github CI runners. Anytime we want to add a new runner we need to flash an SD card and manually install all the dependencies and tools.

What I’m looking for is an ability to generate Raspberry PI images, pre-installed with all the necessary (+ some of my favourite) tools. That can be achieved thanks to projects like Yocto or Buildroot. This post relates to the latter, which is considered to be simpler and easier to get started with.

Emotional value of the bytes you don't own

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 08 Mar 2022

For a long while now I’ve been using Google Photos service to store my photos. Few years ago I’ve switched to using iOS devices and Apple’s ecosystem. That made me start using Apple Cloud service. I guess my life would be simple if not for the fact that these two places don’t store my entire photos collection. Some photos and videos are stored on my local drive, backed up on yet another cloud service.

Alternative social media and federation

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 30 Jan 2022

At this point most people are pretty cynical about social media. The worst offender in that space is Facebook, recently rebranded into Meta. In a world constantly incentivized by profit it’s difficult to imagine Meta optimizing for anything else. The striking part was always how cunning and ruthless they are in pursuing profit. Nevertheless, despite many controversies around privacy, usage of personal data and Meta’s political involvement services like Facebook grow year after year.

Update for September, year of the new hope 2021

ciesielskimm@gmail.com (Michał Ciesielski) — Wed, 22 Sep 2021

I’ve not written one of those at all this year. Not surprisingly, the most productive year for this website was 2020… thanks global pandemic…?

I’ve posted the RFID Explained blog post. I’m trying to gather everything I’ve learned, while working on my RFID project, in one place. This is an assumption but in the maker’s space a lot of technologies are just an Arduino libraries. What I mean by that is that very few people actually learn how a specific technology works. They build a device using Arduino, using the most popular library. I don’t think there is anything wrong with that. It was probably one of the goals of the Arduino creator: remove the technical obstacles to make technology more approachable for people without deep technical knowledge. What if you want to learn more? You need to read, often times badly written, documentation spread over multiple websites and documents. Sometimes, if you really want to understand something, you should read the documentation of the standard, which is a document you have to pay for… My RFID blog post is supposed to be a quickstart for those that want to understand the common RFID solutions.

[STM32] - part 4 - CPU goes brrrrr

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 24 Jul 2021

This is the final part of a series of articles. I’d suggest going through part 1, part 2 and part 3 first.

I’ve been working on a project (which you can find here), using Bluepill board with a STM32F103C8T6 microcontroller. It’s a USB keyboard project. It uses the libopencm3 project and I’d consider this a pretty minimalistic, baremetal project. It’s great for analyzing what happens when a ARM Cortex-M processor boots.

Let’s analyze the linker script and the final binary of that project to understand more about the boot up of a STM32.

You can’t create in a bad environment

ciesielskimm@gmail.com (Michał Ciesielski) — Thu, 10 Jun 2021

Recently I haven’t been as productive as I’d like. Sure, the pandemic took its toll. The summer is coming and if there is a time to consume what life has to offer, instead of producing what you have to offer, this is it. Productivity should never be the goal in itself.

Nevertheless, I could be better at focusing on what’s important. Significant amount of time gets wasted. It’s rarely caused by an unexpected, huge time sinks. It’s usually small things - one YouTube video here, one Twitter doom scrolling there. It’s not about replacing all those moments with work. Your time isn’t something you have to trade for money or self improvement, but it is something you should trade for positive/beneficial things. Before you buy something, you usually ask yourself “is this worth my money?”. The more important question is “is this worth my time?”.

[WIP] RFID Explained

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 08 May 2021

RFID is complex but It’s also fun. Personally I find this technology to be a bit underutilized. I’d like to explain it in a simple way so you don’t have to do the “wait, what?” through the many, many documentation PDFs. I hope to give you some confidence and maybe inspire you to do something fun with RFID.

My experience is that you either grab the cheapest, most popular MFRC522 based RFID reader and hook it up to Arduino or you go deep down the rabbit hole. I’d like to bridge that gap. Enough knowledge that you know where to look for the answers and if you put in a bit of work you’ll hopefully be able to write your own driver for a RFID reader. I won’t tell you how to design your own PCB with a custom antenna, which, I agree, is a bummer.

Perks and difficulties of tech blogging

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 01 Feb 2021

Having your own blog is a very interesting experiment. Like any other project it will teach you something. Your writing skills will improve (that’s an assumption but it’s difficult not to improve if you do it regularly). If you’re not writing in your native language, you’ll improve in the language you do write in. You’ll notice holes in your understanding of the subject you’re describing. You’ll draw attention of others to your work and, hopefully, you’ll help others. There is certainly more, good reasons to have a blog.

C as a scripting language thanks to TinyCC

ciesielskimm@gmail.com (Michał Ciesielski) — Thu, 21 Jan 2021

This year I’d like to play around with music. Mostly live looping. Live looping is a pretty specific way of making music. It’s about recording short, simple music clips and overlaying those to create more complex and interesting music.

A recent googling session took me to OpenAV’s website. It’s Harry Van Haaren’s initiative. He’s focusing on making open source application’s for live music performances. You can find the apps’ code on his Github page. I really recommend checking it out.

Update for December, year of total chaos 2020

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 06 Dec 2020

This will be the last update for 2020. We’re almost on the other side! We shouldn’t expect much out of 2021, since the time doesn’t care about our labels. Still, there is a feeling of hope that we’ll be able to, slowly, transition to post pandemic world. How will that world look like? Time will tell.

Last few months have been very productive for me. For better or worse. It’s nice to create and have a lot of fun ideas but… there is only so much time in a day. Self isolation, working from home, etc. help save time but that means I’m working way more than before pandemic. I’ll certainly need some quality vacation soon.

My terminal, coding workflow - i3, Kakoune, nnn

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 17 Nov 2020

If I’m working on code or tech related tasks, I’m doing it on Linux. That’s because I enjoy spending my time in terminal. I like playing around with new command line tools and fitting them into my workflow. Improving my process is important so I often try to update parts of my setup. The goal is to reduce the friction between my intention and execution.

Linux environment is full of various tools and utilities. I’ve always been a fan of Vim but quickly found NeoVim, which is an attempt to modernize Vim’s codebase. Vim itself is never enough so I’ve started integrating plugins, which in turn introduced me to a lot of smaller tools that further improved my process. Some of those tools have been substituted by a faster and more robust alternative (usually written in Rust).

Communication with Blender via Python RPC

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 25 Oct 2020

My current 3D graphics setup revolves around Blender, ZBrush and, less often, Marmoset Toolbag 3. Transferring the meshes between ZBrush and Blender is the constant dance of exporting and importing (yes, I know about GoB but it’s not good enough for me). I strongly dislike this back and forth. I feel it adds a lot of friction, throws me off and wastes a lot of time. That makes me experiment with inter process communication. This is one of those experiments.

Flexbile Python use in Blender

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 16 Oct 2020

This post is about using Python in Blender. It’s not a tutorial. It’s more of an inspiration to learn and experiment with Python.

Imagine you work on a piece. The first stage is very experimental. You look for what works and what doesn’t. At some point the piece and the process take shape. Some things become repetitive. It’s very useful to notice those patterns early and optimize them.

Lets say I’m working in ZBrush and I want to render in Blender. The geometry moves between those two pretty often. Exporting and importing takes quite a few clicks. All that clicking adds up and nibbles at my, that day’s, energy.

(Basic) Thoughts on Nim

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 31 Aug 2020

Warning: this is a very opinionated post. I’m not claiming I’m right. I’m describing my observations.

This is a great time when it comes to new, fun programming languages. Languages like Rust, Zig, Odin, Nim, Jai bring something new to the table. Those are only the languages I’m keeping tabs on. There is way more projects worth following.

This post is about Nim. I use a lot of Python and I enjoy it less and less everyday. It’s a good language with a great standard library. The community is thriving with great projects. Python2 has been put in the freezer which means that soon there will only be one, proper Python version. There is a lot of fundamental things about Python that just don’t overlap with my opinions.

Update for August, year of total chaos 2020

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 18 Aug 2020

Close to month and a half has passed since the last update. So many things have happened during that time. I’ll only write about tech related topics. It’s not a hard constraint but it’s also not a personal blog about my life.

The project that takes most of my free time is the custom controller for CG artists. Unfortunately the BLE version is on hold. I have not been able to fix Windows pairing problems. I have bought The Bluefruit LE Friend and uploaded the sniffer firmware. That helps me to fix the advertising packets. I was inspired by the Logitech mouse’s sniffed, advertising packets.

Song practice app concept

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 07 Jul 2020

If you’ve ever tried to get better at playing a particular song you want to learn, you might want to first learn it in chunks. After you feel good with those chunks you start putting it all together. Then you realize, you still suck at some of those chunks, so you practice them.

It would be nice to have a tool that works well for that process. I didn’t feel like coding today but I needed to export this idea out of my mind so here is a quick concept I’ve put together.

Update for July, year of total chaos 2020

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 06 Jul 2020

I’m trying something new. I’d like to regularly write some sort of an update which explains what I’m working on. Since this website doesn’t generate any meaningful traffic, I’m doing this for myself. I’m not imposing any strict time frame on this. I don’t want to do this too often, since I don’t want my blog to be full of posts like this one. I want the blog section to be useful for weary travellers who look for answers, in this world full of questions! Anyway, lets get to it.

Adding comments system to this website

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 12 Jun 2020

I’ve started this website with the Beautiful Hugo theme. At that point in time I was learning how Hugo works. I knew I wanted to design my own theme, only because I like customizing and designing. The theme I’m currently using was designed and written by me. I’m not a web developer so it’s not professional quality. It’s made by me - that’s what matters. I’ve never implemented a comments system in my own theme. That has recently changed! This website doesn’t generate, what people in this lovely place called “internet” call, traffic. This doesn’t change a thing though. The goal was always to share what I’ve learned. Some problems don’t deserve to be solved twice. If I’ve struggled with something silly, you shouldn’t. What if you struggle with something I didn’t consider to be problematic? Then you should be able to easily ask me about it. That’s the reason why introducing comment system seemed to be worth my time.

Connecting Ender3 to WiFi with ESP32

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 15 May 2020

If you dabble in 3D printing, you’ve probably stumbled upon the OctoPrint project. It’s a web interface for your printer. It’s a very cool project with lots of features. The typical use case is to host OctoPrint on a Raspberry PI. That requires a bit of fiddling around if you want to power it from the printer’s power supply. It’s a very popular project so finding instructions on how to do it isn’t difficult.

Microphone stand for Novox NC-1 microphone

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 02 May 2020

I like the idea of small, weekend projects. Something small you can make in a weekend. I’ve used the last two days to play around with an idea for a microphone stand. That’s because the microphone stand I’ve got when buying the microphone is really, really bad. It’s unstable and can barely hold the weight of the microphone, which in my case is the Novox NC-1 microphone. It’s a good entry level microphone, which I’ve used to record most of my YouTube videos.

Learning Zig - first hour...

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 31 Mar 2020

Today I’ve played around with Zig, the new, hip (is it hip?) programming language. I find it pretty neat. I’m going to walk you (and myself) through my first, very short, piece of code.

Below you can see the entirety of it. It basically allocates a 2MB buffer and reads a file into it… Yep, not particularly impressive, but this is a judgment free, learning zone, ok?!

const std = @import("std");
const warn = @import("std").debug.warn;
const Allocator = std.mem.Allocator;

fn readFile(allocator: *Allocator, filename: []const []const u8) ![]u8 {
    // Get the full path to the file.
    const path = try std.fs.path.resolve(allocator, filename);
    defer allocator.free(path);

    // Open file, allocate memory of the same size as the file, read file contents into that memory.
    const f: std.fs.File =
        try std.fs.openFileAbsolute(path, .{ .read = true });
    const f_stat = try f.stat();
    const result = try allocator.alloc(u8, f_stat.size);
    errdefer allocator.free(result);

    const read_result = try f.read(result);

    return result;
}

pub fn main() !void {
    var memory: [2 * 1024 * 1024]u8 = undefined;
    const allocator = &std.heap.FixedBufferAllocator.init(&memory).allocator;

    warn("Lets open a file...\n", .{});

    const file_contents = try readFile(allocator, &[_][]const u8{".", "Box.gltf"});
    warn("{x}\n", .{file_contents});
}

It starts with adding files to the build process with @import built-in function. What’s interesting is that source files are implicitly structs. That’s why a typical syntax for declaring variables applies. In Zig you can define methods inside a structure definition. That basically puts the function in a namespace with the name of that struct. So if std is a struct, the methods accessed via std are just functions in that structure namespace.

Cool, new language for 2020

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 28 Mar 2020

A lot of new programming languages pop up here and there. It’s a very interesting moment to pick a new one up. The ones I’m interested in are Rust, Nim and Zig.

Rust? Might be a good choice but it’s intimidating. I’m not convinced yet that what it brings to the table justifies its difficulty… Nim is pretty cool. Don’t have that much experience writing Nim though. It has a garbage collector, which you can turn off and use your own memory management system. I’m not a fan of garbage collection. Zig? C without its problems. At least that’s how it markets itself. I’m intrigued. There is actually a lot of interesting things Zig does. I’d like to mention some of those here and explain we Zig is my pick for what to learn 2020 edition.

Derotating image with EXIF orientation

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 21 Mar 2020

If you want to overlay a rendered graphics on top of an image or a static video in Blender you should use the fSpy tool. It matches the camera to specified frame of reference. Unfortunately it doesn’t support EXIF meta information. That means that it sometimes fails to properly orient an image.

When it comes to an image orientation there are two factors: how image is encoded and the EXIF orientation value. A great explanation can be found here.

Pointers to pointers in C

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 21 Mar 2020

Pointers seem to be the most confusing part about C. It takes a while to fully understand them. As soon as you start feeling what they are about you stumble on a pointer to a pointer. Technically not that much changes but, again, it takes a while to create a solid understanding of what’s going on. As they say: you don’t understand something if you can’t explain it in a simple way.

Communication with Blender via sockets

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 15 Feb 2020

I’m always curious about expanding functionality and improving workflow by connecting devices to software that I already enjoy using. I love using Blender and making custom controllers for creating computer graphics is something very interesting to me.

As long as a program has a scripting environment or a plugin support, you can usually connect anything you like to it. In one of my previous experiments I’ve added a serial communication between Blender and a custom device. It was a bit clunky, obviously. Serial communication isn’t something you want to be run as a Blender’s subprocess.

What problem does it solve?

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 08 Feb 2020

My experience in tech industry isn’t that big. It would be something around 5 years working as a coder. This industry moves fast, things change, new technologies emerge on daily basis. In order to do my job well I have to constantly learn something new. I enjoy that a lot. Learning is great. It allows you to look at the world differently than you did before.

Sometimes it’s exhausting and frustrating. It’s easy to be negative towards a new framework, programming language or a build system, when it’s new and alien to you. In this industry you should be sceptical. We are already drowning in a sea of a complexity, and when we can barely keep our heads above the water we tend to save ourselves by adding another layer of abstraction.

SparkFun Thing Plus - Ambiq Apollo3 - part 1

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 29 Nov 2019

Driven by the idea of building a Bluetooth keyboard like device, I’ve bought the SparkFun Artemis Thing Plus board. It’s a board designed for small, power efficient devices with Bluetooth capability.

The board carries an Ambiq Apollo3 processor. It’s an ARM Cortex-M4F chip. Runs at 48MHz but can, for a brief amount of time, go up to 96MHz. Here you can read more about the whole Apollo line-up.

Blender - text with scanlines

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 20 Sep 2019

With the release of Blender 2.8 I went back to messing around with graphics. I would like to be able to replicate some of the, already existing, effects. Nothing fancy. Nothing new. At the same time looking… good! I also would like to explain the process to learn and improve.

Lets look at a text with some scanlines.

The scene is pretty basic, text object and a scaled cube with an array modifier. Both objects have their own Collection. Each of them are also living in their own View Layers. That allows for separate rendering of the objects and easier composition.

Debugging image resources

ciesielskimm@gmail.com (Michał Ciesielski) — Thu, 27 Jun 2019

I work a lot with image processing. There is a lot of transformations and sub images extraction. Often, it would be great to actually see those images when debugging. Quick Google search pointed me to the dump command present in gdb.

In short, to get the memory dump, you would do something like this:

set $source=pointer_to_the_memory
set $size_of_the_dump=4096
dump memory filename.bin $source $source+size_of_the_dump

You have to know the size of your data. For an image it means: width, height, color depth.

Node based GUI app

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 16 Jun 2019

Inspired by a horrible Jenkins CI workflow I thought about a GUI app that could help compose and request/monitor CI jobs. Node based GUI seemed like an interesting option for that. I’ve tested several technological stack to develop something like that and here are my observations.

Nodes in Haxe/Heaps <

I’ve started with testing Haxe + Heaps. I like the flexibility Haxe gives. Outputting a web app based on JavaScript is pretty easy. Unfortunately Heaps engine can’t be easily outputted as a C++ target.

Black magic probe out of cheap STLink programmers

ciesielskimm@gmail.com (Michał Ciesielski) — Thu, 03 Jan 2019

If you have ever worked with ARM Cortex M processors you’ve probably used GDB + OpenOCD combo for debugging. If you didn’t: OpenOCD connects to the processor via a STLink programmer and opens a socket to which GDB can connect. It will push data necessary for debugging (and understandable for GDB) through this socket. That means that if you connect GDB to this socket (so called remote debugging) you can debug processor’s software like any other application on your PC.

Using txti.es + Python as a data dashboard

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 30 Dec 2018

Have you ever heard about txti.es? It’s a basic web page creator. You can basically create a very simple website by typing content into a form. I thought it might be used as a very simple frontend.

I always dabbled with automation. An example would be a scraping script that gets the job postings from a specific website or one that checks when the bus I take every morning leaves and sends this information by e-mail.

Creators responsibility

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 04 Dec 2018

Recently I’ve enjoyed reading blog posts by Nikita. You can find the blog here. One blog post I see quoted often is this one (you can read it in 6 languages - that says something). It’s about the disastrous state of current software development.

The author brings a lot of good points. The message is that no one puts effort into making software performant. We solve problems by adding complexity, never actually solving the root cause. This comes at a cost. It’s all a slow, bloated and complicated mess. Hard to disagree.

Setting up a PiHole

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 17 Nov 2018

What’s a PiHole? <

It’s basically a DNS sinkhole. DNS servers resolve domain names into IPs. DNS sinkholes are basically faulty DNS servers. For example when you go to a website your web browser will also download ads. In order to get them it has to resolve the domain name of the ads provider into an IP. That’s what DNS server does. PiHole is just a local DNS server which say ’nah’ when you ask it to serve a content from a blacklisted provider. You can add domains to the blacklist banning their content but you can also whitelist those you want to support.

Setting your pc for remote access

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 13 Oct 2018

I’m not sure I need it. Maybe you will. It is an exercise in excess. I rarely need something from my home PC because nowadays it’s so easy to store things in the magical cloud. Still, it’s a nice exercise.

I have set up remote access on Void Linux and I will describe the process of doing so for that OS. You might encounter some problems if you are using Windows… but if you do you have bigger things to worry about (writing this around the time M$ update for Windows bricked some users’ computers.

[STM32] - part 3 - Start your engine!

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 19 Jun 2018

I think it’s time to go through what happens when you power on the STM32 Cortex-M microcontroller. There is a lot of resources on this topic (if you are reading this one… thank you!). I will explain this process in my own words.

You have powered on your microcontroller. Less than a second has passed and it is already munching through data, sending and receiving messages, controlling motors and blinking leds. In less than a second (waaaay less) the micro sets everything up for it, to do everything you programmed it to do. So what’s the process?

Shortcomings of todays human-computer interaction

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 11 Jun 2018

I have spent a lot of time in front of a computer. That’s because you can do a lot of amazing stuff with it. I don’t think I enjoy the process that much though. Sometimes there is so much clicking and pointing to do simple stuff. I don’t think I would code without using VIM or at least adding VIM bindings to the text editor I’m using. I just can’t use mouse when I code. Coding is discrete. Smallest unit of code is a letter. If you use the mouse to move the cursor in your text editor you actually move over space that doesn’t interest you, like letters themselves. What you are actually after are the spaces between letters. Using only keyboard puts you in this discrete space you are after - with keyboard you can move exactly one letter at a time by adding, removing or moving over a letter. VIM bindings expand this by giving you motions, simplest being moving over words. When you code, your tool is the keyboard. We all know how keyboard looks and what should it do… do we?

[Knowledge snippet] - STM32 bootloader

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 09 Jun 2018

You programmed STM32 microcontroller using Nucleo or Discovery boards. That means you used Serial Wire Debug (SWD) for programming/debugging. Now, you are designing a PCB with a STM32 microcontroller on it, which means you have to be able to program it. One solution is uploading the code through a bootloader - a small piece of software, made by ST that has been saved in the protected (read-only) memory of the microcontroller. It’s a simple program which reads data, sent from the host (PC) using a specific protocol, and saves it into FLASH memory.

[STM32] - part 2 - Lets look inside!

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 27 Apr 2018

Still wondering why it all works? Why this black square does things? Lets go deeper.

Previously I explained a bit about processor architecture. It’s the basis of the chip. It’s a fundament. You won’t find anything about an UART in a Technical Reference Manual of Cortex-M4. It’s just not a part of this fundament.

When you get an STM32 microcontroller based on the Cortex-M4 architecture you just get microcontroller made by ST which uses this specific architecture. What stops them to add to it? Nothing. That’s why you can find so many different models of families and models of processors. Just look at ST’s F and ST’s L series. They are both ARM Cortex-M but they do differ in many ways.

[STM32] - part 1 - Cortex what...?

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 10 Apr 2018

Recently I wrote a short article about setting up an environment for programming STM32 microcontrollers with the libopencm3 library. You can read it here.

I wanted to write the second part as soon as possible but I found out that even though I could, I didn’t understand everything well enough. I just didn’t feel comfortable with the subject. That’s why I started this series. I want to explore what actually happens when you program a STM32 microcontroller.

Adventures in libopencm3 - part 1

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 31 Mar 2018

Recently, I’ve started working on a new project. It will take some time before the goal of the project is even worth mentioning. The important part is that it is an electronics/hardware project and it needs an energy efficient computing unit.

For early development I chose an ARM Cortex M3 STM32F3 microcontroller. More precisely STM32F303K8T6, mostly because I have a Nucleo board, with this chip, laying around. It’s also a good time to try a new framework. Choices worth considering:

Compiling Raylib programs with SCons

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 18 Mar 2018

If you like writing programs in C, are interested in game development and don’t enjoy all those complicated and ancient build systems I think I’ve got something of interest to you. I belive there is something enjoyable in the simple setup I’m describing below. Hope you will enjoy as well.

Raylib <

Raylib is a C library made by @Ray San. On the Raylib’s website it says ‘raylib is a simple and easy-to-use library to learn video games programming’. Whole API can be browsed here. It does abstract a lot of things important for game developement. It’s important to note because if you chose to write something in C, performance is something you might care about. High level abstraction usually takes a toll on performance. In this case mostly because you are not tuning small parts of your code to suit your needs. Raylib wants to abstract those parts to make the learning easier. In the end you have the power of C (which basically allows you to write performant code) and high level abstraction Raylib library provides you. That’s a good starting point to write cool software, enjoyable for the end user.

Naive comments system

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 02 Dec 2023

This website used Cactus comments system, which leverages Matrix protocol. It was a nice little experiment but it’s a half baked project, which didn’t grow in the last few years. I have decided to make my own comment system. Something as simple as possible, where comments are stored in the most universal way possible. Because systems change, but data? Data is forever.

The simplest comment system is an interface to send text data, a way to store it in a structured manner and an interface to retrieve that data or its subset, to present it.

1S Li-Po battery charger

ciesielskimm@gmail.com (Michał Ciesielski) — Mon, 10 Oct 2022

One day I hope to design a product with quality of a commercial product. I do not feel I can go through the entire process by myself. While I might never be able to do that, I still want to close as much of that gap as possible.

This time the exercise was to design a PCB that can charge a 1S Li-Po battery. The design is not a product of my lacking, electronics knowledge. It’s a modified design of the Particle Xenon board. Unfortunately, Particle doesn’t produce these boards anymore. I managed to buy two of them some time ago. I find those great for BLE prototyping.

MagKnob

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 05 Nov 2021

Let’s control volume with a (moderately) fancy knob!

AS5601 might be my favourite sensor right now. It’s an on-axis magnetic rotary position sensor. It generates a signal typical for encoders, but it does it by detecting the change in a magnetic field of a diametrically magnetized, rotating magnet.

The knob acts as a USB HID device. That means that, currently, it can do everything that a 2 button keyboard could do.

Website... this website

ciesielskimm@gmail.com (Michał Ciesielski) — Fri, 05 Nov 2021

You should start a website. It’s quite fun!

Bluetooth Graphics Controller

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 06 Jun 2020

Process <

Time tracker

ciesielskimm@gmail.com (Michał Ciesielski) — Tue, 21 May 2019

THIS IS A WORK IN PROGRESS <

Below you will find log entries that describe the design/thinking process.

Idea <

The goal is to build a device that could allow me to comfortably measure time spent on a project. I want to have a full history of the time spent on particular project. The time log needs to be plain text, easily queried and human readable.

Process <

2023-08-23

And here we go with another attempt at prototyping this device. 3D printing is great, as long as it works. Any 3D printer issues can derail the entire process - I’m not here to practice my 3D printing troubleshooting skills. Another thing about 3D prints is that they’re not a good base to further refine the printed prototype. It’s a plastic shell and there’s not much you can do to modify its shape, without redesigning and reprinting. There’s definitely way more to prototyping than 3D printing.

Fuel gauge - Godot Engine

ciesielskimm@gmail.com (Michał Ciesielski) — Sun, 07 Apr 2019

I’ve made a small visualization of a motorcycle fuel gauge in Godot engine. It allows you to disassemble the gauge and learn what’s inside without actually buying a motorcycle… I did that for you…

Wii Nunchuk as a USB HID controller

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 02 Feb 2019

TL;DR <

You can find the source code here.

I used the Wii Nunchuk controller to prototype one handed controller for creating computer graphics. I used the Blue Pill board which carries a STM32F1 microcontroller with a built-in USB peripheral. That allowed me to implement it as a true USB HID (Human Interface Device) for the Windows OS.

The results were disappointing. My USB HID implementation was poor. I have fixed several important bugs in another project.

Capacitive buttons keyboard

ciesielskimm@gmail.com (Michał Ciesielski) — Thu, 05 Jul 2018

A video showing the a keyboard made with capacitive buttons.

Source code

Blender analog controller

ciesielskimm@gmail.com (Michał Ciesielski) — Wed, 13 Jun 2018

In the digital age you stumble on concepts analog in their nature. Modern graphics are created on a computer yet they originate in an analog process. You constantly change the brush size yet the computer allows you to do it in an increments. Do you actually care your color is R=53, G=123, B=200 in numerical values except when moving the data?

Concept of making an analog controller for art creation on the computer was always interesting for me. An exercise in this was this small controller built with Arduino. It’s just a 3 potentiometers dividing voltage. Arduino reads this voltage and sends the numeric values to Blender which can use them in various ways thanks to built-in Python environment. I used it to control color values.

Portable power for Yamaha Amplifier

ciesielskimm@gmail.com (Michał Ciesielski) — Sat, 21 Apr 2018

Voltage converter in 3D printed casing

I’m using Yamaha THR5 electric guitar amplifier. It’s possible to power it with batteries. It isn’t economically good solution though. Something rechargeable would be way better. Since I had a Li-Po battery lying around I made a small dongle which regulates the voltage.

Voltage converter in 3D printed casing

The dongle in a 3D printed casing. Two switches allow breaking input and output circuit independently.