For some years, I have a homeautomation running in my apartment. I did not extend it over time by a lot, but I like to have reliable, low maintenance services, especially about temperature regulation and lighting. This is a story of radical reduction. I basically went from left to right in 5 hours (there are zoom-in pictures in the following article):

How did this even happen?#

Feature bleed. My home automation had those features:

• Heating thermostates (MAX) in every room
• Window sensors (HomeMatic) on most windows
• Temperature/Humidity sensors (Zigbee) in every room
• Some controllable power plugs (Zigbee)
• LED strips in office and living room
• ProxMox Virtualization Server (this is not permanently running, so it’s not able to run the homeautomation, but HA is controlling when it starts and stops automatically)

This doesn’t sound a lot, but it was.

This system evolved over time. I started with MAX Themostates and Homematic window sensors, which I connected to a Raspberry PI using acustom flashed Max CubeCUL (german link) andcod.m’s CC1101 Raspberry Module , andHomegear installed on Raspbian.

For UI, I installed (openHAB)[https://www.openhab.org/].

To connect openHAB and Homegear, I implemented a Flow in Homegears internal NodeRED - which is called NodeBLUE - to custom map my thermostates to“homie”-mqtt standard , because openHAB is able to autodetect Homie devices via MQTT.

So I needed an additional MQTT broker - mosquitto. The System was the following:

• Software (running on raspberry pi)
  • Homegear (incl NodeBLUE flows)
  • OpenHAB for visualization
  • mosquitto as MQTT broker
• Custom Protocols
  • “homie” thermostates mapped in MQTT
  • “homie” window sensors mapped in MQTT

This was around 2020, the first stage.

From here, the system grew quite big over time. Since I don’t want to elaborate each point with a own paragraph, I will just jot it down using bulletins:

• In 2020, I added 2 WLED striped in office and living room. Those stripes are connected to openHAB using custom MQTT homie integrations with NodeBLUE (Homegear) again…
• In 2021, I started adding Zigbee Devices. For that, I used cod.m’s greatRaspberry Pi Module (link to newer version). I installed Zigbee2MQTT, attached it to my mosquitto instance and built - again - custom homie mappings.
• Same year, I added Grafana for Monitoring and InfluxDB as da Database.
• Also same year, I tried to upgrade openHAB and had a unrecoverable error. Or, let’s say it like that - I’m usually willing to spend some time fixing broken things, but if a re-setup seems to be faster, I will do that. So I ended upswitching openHAB to HomeAssistant.

This system remained like this for long time, because I was severly annoyed by it’s complexity and didn’t want to touch it at all. Actually, in the occasions I tried to do something with it - for example updating the software components or Raspbian - I constantly broke the system. After a while, I just had absolutely no energy for it. It looked somehow like this (all running on a raspberry pi):

As you can see in the summary, this is just a grown system where you attach things one-by-one until you have an annoying monster. I have enough of this at work, but I don’t want to have that in my appartment. So you see, feature and complexity bleed is even happning in just a very simple home automation.

The big reduction#

When I introduced my homelab server this year, I moved HomeAssistant from the Pi to the homelab server. But I recognised that the server does absolutely not need to run 24/7 and actually consumes a lot more power compared to the raspberry pi 4 which runs the home automation - actually 10W compared to 4W (which is both perfecly fine - but we all try to save energy right). So I wanted to have scheduled boots and shutdowns for my homelab, but also have the HomeAssistant UI available all the time.This means, move HomeAssistant back to the raspberry pi.

At the same moment, I decided to update the OS, and all other software which…

obviously completely messed up my installation, especially Homegear. I spend 5-6 hours trying to fix everything, but as I mentioned earlier I’m usually not very eager to throw away stuff and do a clean sheet installation.

Starting from scratch on the Raspberry#

At this point, I wanted to do things very differently and use as little software as possible, so I don’t run into problems when updating the components. Let it be Homegear, zigbee2mqtt, HomeAssistant, grafana or influx, in the last years I had issues with each of them during software updates. Not to speak of raspbian itself. It might be due to the fact that I do not update very often and if so, I instantly jump multiple versions. So my goals for the new system were the following:

• Have automated updates (not yet done)
• Have a good backup mechanism (done)
• Use very little software, and as much “native software” as possible.

Since I wanted to keep the sheets clean in Raspbian, I decided not to install software via apk, but use docker and docker-compose instead to manage the actual automation system in a reproducable way. The docker compose project isavailable at my github account .

Outside of docker, I only want to have the backup system and the operation system running.

The backups problem I solved byjust using a shell script which does a gzipped tar backup of the whole docker-compose project folder, including all configurations which are mounted into the containers. This backup is triggered by a cronjob once a day. On my Macbook, I also run a cronjob every hour to check if there are new backups via ssh and save them to my local disk. To me, this sounded as the most straight forward and easiest solution, utilizing long proven software.

In the end, this means that in case of a reinstallation I just need to

• change 2 files in /boot to make my raspbian able to use the connected hardware. Those are even in the Git Repo.
• install docker
• git clone, restore backup and docker-compose up

to make the whole system work.

Homeautomation#

I just ended up with two containers are are part of the docker-compose file, and I will try as good as possible to keep it like that.

Homegear, I again use to connect to my MAX Thermostates using a CUL Cube and to my Homematic window sensors using the mentioned MAX CubeCUL andCC1101 Module . AFAIK, HomeAssistant is not capable of utilizing the Cube so I basically just did the very basic setup and paired all the devices to Homegear, and then connected Homegear to HomeAssistant since it can act like a normal Homematic CCU.

Btw, do you recognize that too many products in Homeautomation start with Home? This get’s really confusing by now.

HomeAssistant will be the main driver of my automation from now on, and to me this feels very well. I was actually surprised how much of my old implementations can be covered by HomeAssistant by now.

What it has done for me:

• Completeyget rid of MQTT and homie custom integrations (this is the best part):
  • Control MAX Thermostates via Homegear CCU
  • Monitor Homematic window sensors via Homegear CCU
  • Covers all my Zigbee Actor and Sensor Hardware (weather sensors, power plugs, window sensors, routers) via Zigbee Integration and the mentionedcod.m Raspberry Pi Module ,so I can get rid of zigbee2mqtt.
  • Can natively connect to WLED for my lighting
• Get rid of Influx+Grafana
  • Can monitor all Sensors and Actors (Entities)
  • Can monitor information about host system and docker containers
  • Collects statistics and histories
  • Can show this as a graph
• Can still do all automations I implemented with NodeRED/NodeBLUE natively (see below). Even though I have to mention that I particularly don’t like the automation flow of HomeAssistant yet. But I will try and see if I can get used to it.
• Automations I have been able to quickly implement yet:
  • Disable heating if windows are open
  • Shutdown homelab at 2am if no tasks are running (check by system load)
  • Wake-On-LAN homelab at 5:30pm (when I usually come home)

Summary#

I’m very happy with the last few days. I was able to drastically strip down my homeautomation they way I would like it to be. While doing this, I actually realized how this system was stressing me out. I was able to implement all automations I had before, use a lot less software and build a more robust backup and config management system at the same time.

Today I had the idea to extend myasync rust webserver demo with an additional feature of a chat. In this small post I want to discuss why I think a chat functionality is a useful showcase for a rust webserver, but also show how I did implement it, since it’s a very easy feature to develop using the tokio runtime.

You can easily try it out on your machine by downloading thedocker-compose.yaml (right click + save ), store it in a folder calledtokio-web-demo and typingdocker compose up in your terminal. Make sure you navigate to your created folder first. You can find the webserver athttp://localhost:8123.

Why#

A chat functionality serves as an excellent showcase for a Rust webserver because it utilizes different I/O patterns, which include sockets, locks, and broadcast channels. This variety of I/O patterns demonstrates the versatility and capabilities of the webserver in handling various types of data communication and synchronization. Moreover, implementing a chat feature allows us to demonstrate an important aspect of asynchronous programming: the ability to continue processing chat messages even when the runtime temporarily blocks and then resumes. This showcases the robustness and efficiency of the asynchronous model in handling concurrent operations, which is particularly valuable in real-time communication scenarios like chat applications.

Implementation#

The implementation of the chat functionality in this demo is intentionally kept very simplistic. This approach allows us to focus on the core concepts and functionality without getting bogged down in complex details. To achieve this, the implementation leverages htmx for dynamic HTML updates, WebSockets for real-time bidirectional communication between browser and webserver, and broadcast channels for efficiently distributing messages to multiple connected clients. This combination of technologies enables a responsive and interactive chat experience while demonstrating the power and simplicity of using the tokio runtime for asynchronous operations in Rust.

Disclaimer#

The article assumes that readers know a little bit about Rust and HTML and do have a general idea of the concepts ofasynchronous Rust programming ,HTMX andWebSockets . If you’re unfamiliar with these concepts, please click the links to learn more.

ChatMessage#

The ChatMessage struct represents a single ChatMessage and is very simple.

structChatMessage{timestamp:NaiveDateTime,username:String,message:String,}

It has a simple timestamp, a username and a message. It implements two functions:

implChatMessage{/// Used to generate message representations in the actual program logfnlog(&self)->String{/// ...}/// On the WebSocket, we reply with HTML to be used with the HTMX Rust extensionfnwebsocket_reply(&self)->String{/// ...}}

Chat#

To send a chatmessage between multiple clients, we use another struct calledChat. Different chats can be instanciated in one binary, but practically this is used as a singleton. If you would extend the tool later to support multiple Chat channels, you would likely renameChat toChannel.

pubstructChat{// The actual broadcast channeltx:tokio::sync::broadcast::Sender<ChatMessage>,// A set of unique users which are connected,// so two clients cannot claim the same nameusers:RwLock<HashSet<String>>,// A Fist-In-First-Out log of ChatMessages,// to also display for new connected userslog:RwLock<VecDeque<ChatMessage>>,}

For a tokio broadcast channel, it is sufficient to just store the “Sender” structure on creation, since new “Receivers” can be derived from the Sender callinglet recv = chat.tx.subscribe();. The users and log are stored in aRwLock structure, since multiple threads might be using the inner collections andread() andwrite() access need to be properly synchronized here. Also, it is important to usetokio::sync::RwLock instead ofstd::sync::RwLock, since the first one is a non-blocking and async implentation. Finally, I decided to use aVecDeque instead ofVec, so I can add messages withpush_back() and remove them on the other hand withpop_front() if the structure exceeds it’s limits.

Creating the WebSocket using HTMX#

The webserver is implemented using the libraryaxum. The design of the chat interaction between client and server is the following:

Logging into the Chatroom#

When a user submits the login form, it invokes thechat::chat() function.

pubasyncfnchat(State(chat):State<Arc<Chat>>,Form(f):Form<Chatform>)->implIntoResponse{// join chatiff.name.to_lowercase()=="system"{return"Username 'system' is not allowed".into();}ifletErr(e)=chat.join(f.name.clone()).await{returne.into();};format!(// magix HTMX response)}

The chat function first checks if the provided username is a case insensitive version of “system”, which is a reserved username. If this is the case, it will respond with an error. If the username is okay, the the user “joins” the chat room and therefore blocks any other clients joining with the same username.

Finally, the server will respond with HTML that is automatically injected into the browsers DOM by HTMX. Look at the HTML before the user clicks on “Join Chat”:

<divclass="card"><divclass="card-header"> Chat</div><divclass="card-body"id="chat"><formhx-post="/chat"hx-target="#chat"><inputid="name"name="name"type="text"class="form-control"/><labelfor="#tasks"class="form-label">Username</label><br/><buttonclass="btn btn-primary"type="submit">Join Chat</button></form></div></div>

The chat window is a typical bootstrap Card element, with “Chat” as a header and a body containing a form with a input field for a username and a “Join Chat” button. If you click that button, HTMX will intercept the browser event, and instead of sending a POST request and reloading the page, it will do an asynchronousPOST request to the webservers URL<server>/chat (see attributehx-post). HTMX will expect an HTML based response, and inject replace the content of the HTML element defined withhx-target. The servers response looks like this:

<divid="openChat"hx-ext="ws"ws-connect="/ws/chat/{user_hash}"><!-- ... Chat ... --></div>

Which results in the general content:

<divclass="card"><divclass="card-header"> Chat</div><divclass="card-body"id="chat"><!-- HTMX response --><divid="openChat"hx-ext="ws"ws-connect="/ws/chat/{user_hash}"><divclass="mb-3"><formws-send><divclass="input-group"><inputname="chat_message"type="text"class="form-control"placeholder="Type your message..."><buttonclass="btn btn-primary"type="button">Send</button></div></form></div><divid="chatBox"class="chat-container"></div></div><!-- /HTMX response --></div></div>

You can see, that after a chat join, the browser content has been exchanged with additional HTMX elements. The attributehx-ext tells the browser to toggle the WebSocket extensionws for this element and all child elements, which enables the call ofws-connect. This call establishes a connection to a WebSocket at the URL<server>/ws/chat/{user_hash} (blue part in the diagram above). We use a user_hash instead of the real username to make it more difficult to fake it. Hence you would have to provide a hash that’s already in the List of users to connect to the socket in the name of another user. Since the whole project is for demonstrational purpose and does not have a real user system in scope, this seems to be secure enough.

Exchange of chat messages (Frontend Side)#

Chat messages are exchanged via the WebSocket extension of HTMX. This extension has a very interesting internal decision. While in general HTMX encourages to use Query Parameters and WebForms over JSON, and expects HTML as responses, WebSockets do actually send data in JSON format, but do expect a HTML response. If a user types the chat message “Hello World”, the server receives a JSON chat message, and broadcasts it to all connected clients (including the sending client).

{"chat_message":"Hello World","HEADERS":{"HX-Request":"true","HX-Trigger":null,"HX-Trigger-Name":null,"HX-Target":null,"HX-Current-URL":"http://localhost:8123/"}}

If the server is sending a response to the client, it is received as HTML with HTMX attributes to give the library the opportunity to insert the message at the correct location:

<divid="chatBox"hx-swap-oob="afterbegin"><divclass="chat-message"><strong>{username}:</strong><spanclass="timestamp">{timestamp}</span><p>{message}</p><div></div>

The outer div instructs HTMX to add the element at thetop (afterbegin) of the element with the idchatBox. Which would after correct insertion look like this in the opened chat:

<divid="openChat"hx-ext="ws"ws-connect="/ws/chat/{user_hash}"><divclass="mb-3"><!-- Send form --></div><divid="chatBox"class="chat-container"><divclass="chat-message"><strong>{username}:</strong><spanclass="timestamp">{timestamp}</span><p>{message}</p><div><!-- older chat messages... --></div></div>

Exchange of chat messages (backend side)#

On the backend, the WebSocket connection is upgraded into a handler function with the namechat::websocket_handler(). This function is doing a few straight forward, but interesting things:

letSome(user)=chat.find(id).awaitelse{log::warn!("user with id '{id}' cannot be found");let_=ws.close().await;return;}

First of all, remember how the WebSocket connects with anid instead of a username for security. This function tries to find a fitting registered username for the id. If not found, it will respond with a “user cannot be found” message and close the socket. If a user was found, the variableuser is available in the following code.

After that, the WebSocket is split into two different elements, asend() and arecv() part. Both are to be used in two different asynchronous running tasks. Since we cannot clone the WebSocket, it’s important to split it to be able to send and receive from different tasks.

let(mutws_send,mutws_recv)=ws.split();

The same needs to be done for the publish and subscribe, or send and receive parts to the Chat backend. In the implementation of thebroadcast channel of rust, you can get a handle to the receiving partrx part by calling thesubscribe() function on the sending parttx.

let(chat_tx,mutchat_rx)=(chat.tx.clone(),chat.tx.subscribe());

Then, two tasks are spawned:

letmutws_to_chat_task=tokio::spawn(asyncmove{/// From WebSocket to Chat});letmutws_to_chat_task=tokio::spawn(asyncmove{/// From Chat to WebSocket});

The following part receives messages from the WebSocket, and sends it to the Chat Backend:

letmutws_to_chat_task=tokio::spawn(asyncmove{whileletSome(Ok(message))=ws_recv.next().await{matchmessage{Message::Text(msg)=>{chat.log(&msg).await;ifletErr(e)=chat_tx.send(msg){log::error!("Cannot send chat message: {e}");};}Message::Close(_)=>{log::warn!("Socket for user '{}' closed by client",ws_recv_user);return;}}}});

The first line if the spawned function is the most important one. It utilizes thews_recv receiving end of the WebSocket, and asynchronously waits for a message. If something different than a valid message is received, thewhile loop would terminate and therefore the whole task. If valid messages are coming in, the messages is matched on it’s type. If the received message is aClose request, the code writes a log message and closes the task. If a validText type is received, the message is being added to the chat log and after that sent to the Chat backend using the sending sidechat_tx. This means, that this side doeswebsocket receive -> send chat.

The other direction is even simpler:

letmutchat_to_ws_task=tokio::spawn(asyncmove{whileletOk(msg)=chat_rx.recv().await{ifws_send.send(Message::Text(msg.websocket_reply())).await.is_err(){break;}}});

This is basically the same thing, as long as the while loop receives correct messages from the receiving part of the chat backendchat_rx, it will serialize the message to a HTML websocket reply (see above) and send it to the websocket.

After both tasks are spawned, thewebsocket_handler function needs to wait for both tasks to finish. If one of them finishes, the other one should be closed as well. You can implement this functionality using thetokio::select! macro:

tokio::select!{_=&mutchat_to_ws_task=>ws_to_chat_task.abort(),_=&mutws_to_chat_task=>chat_to_ws_task.abort(),};log::info!("user '{user}' ({id}) left the chat");chat.leave(&user).await;

Tokio’sselect! will wait for the first of the tasks to finish. If so, it will kill the other task immediately. This way it makes sure that both tasks are regularly closed and do not remain in the system as zombies. After that, the user is removed from the chatroom to un-reserve the username and close the chat.

Further reads:#

• HTMX WebSocket
• tokio::sync::broadcast
• axum WebSockets

In the last several months, my iPhone 11 battery got worse and worse. I’m not really mad for that, because I think that a reduced battery after 4,5 years constant usage is perfectly fine. Before I bought that phone in late 2019, I was living for a long time in the Android/Windows world. Back then, I was not particularly unhappy, but I wanted to test something different and also wanted something that “just works”.

After using Apple throughout the whole pandemic and also switching with most of my devices to apple products I can only say that Apple pretty much fulfills what they promise. That stuff just works. Still, I’m not very happy for several reasons with the Apple ecosystem, which I will explain in this text. Still, I won’t dump all my apple products immediately.

What Goes, What Remains#

So, what I’ve bought in the last years from apple started with an iPhone 11, went on with Airpods Pro, then a Apple Watch Series 6, a used iPad from 2017, and the last thing I bought was a used Macbook Air M1 from 2020. I was quite happy with all of them, nevertheless, some I wouldn’t buy again. The main reason is the vendor-lock-in. Let me explain.

Airpods Pro#

Those, I actually did not buy again since they broke literally 2 month after my guarantee ended. As a replacement, I ordered Anker Soundcore Life P3 and I’m quite happy with the battery life and sound, for half the price. Also, the main selling points for Airpods, which is the seamless handover between Apple devices never really worked well for me. I didn’t really feel locked in with this device, since they also worked with Windows PCs and Android devices.

Apple Watch#

The Apple Watch is great, but it’s just not for me. All the smart features it has I basically never use. I don’t use Siri, I deactivated all notifications and uninstalled all apps possible except my sports tracking app Strava. I basically have a very expensive fitness tracker with a lot of additional features I never use, and which I need to recharge every day. And what I want to talk about here especially is vendor locking. If you have such an expensive device and the paired phone breaks, like mine just did, you basically have no choice than buying another iPhone, even if you don’t want to. Or you sell you Apple Watch as well which is not a financial desaster, but it feels unnecessary.

So I decided to switch to aGarmin Instinct 2 Solar . Even though I will keep my iPhone for now. One reason is, that I want to make a decision on a new phone in the upcoming year and I don’t want a vendor-lockin to influence my decision. The other reason is that the Instinct 2 is just available at a great price of 250€. On longer bike rides, my Apple Watch actually died multiple times already which is very unfortunate. The Garmin instead, with it’s limited display and Solar technology has at least 30 hours battery life on GPS and in theory “unlimited” battery life through it’s solar charge feature. This also seems very sustainable to me.

iPhone 11#

Positively I can say, that the phone and softwarejust worked. And in a very good way. I very rarely had any software issues, nor did I have any problems with the hardware. Now, when I wanted to replace the battery myself, I had to discover again that I’m just not made for electronics. Even though the instructions on iFixit were pretty clear, I managed to destroy the screen of the phone by cutting the display cables when removing the glue. So that was stupid, and that’s on me. So I now ordered another display to fix it as well.

But looking at the reparability of the phone I’m still not very happy. Sure, I could give it to apple and spend 150€ on a new battery or 300€ on a new display. But I think that replacing a battery should not be a task that involves this amount of work. Which by the way also counts for nearly all Android devices these days.

Also, monitoring the behaviour of Apple in the last years I’m not really happy how they act in fights with the EU. In the “charger war”, they tried to procrastinate switchting to USB-C for years. There were rumors already on the iPhone 12 to support it, and in the end it came with the 15. Also, Apple showschildish behaviour by artificially breaking working functionality for EU users as a revenge to the DMA which was enforced on Apple. Apple obviously does not want me to choose the browser I want to use, Apple does not want me to choose the Store I install apps from. And as a revenge, they just break functionality orheld up updates for major apps . It’s fine and good that their products just work and have good build quality, but I’m currently not willing to accept that I as a customer am constantly patronized by Apple.

I’m currently considering two phone brands from the EU. One is Fairphone from netherlands, and the other one is Shift from germany. Actually, when I bought my iPhone11 in 2019 I also considered both of them, I think the Shiftphone 5me and the Fairphone 3. Back then, the cpus, cameras and also displays were not really up to date, but seemed to be years behind the market. With theFairphone 4 andShiftphone 6mq , this changed a lot and both of them got really good feeback on what they did. Late 2023, Fairphone released theFairphone 5 which also got good feedback. Shiftphone will release it’sShiftphone 8 in August 2024.

My plan currently is towait for the Shiftphone 8, and then decide on a new phone.

iPad#

This device, I rarely use. It’s actually always around the sofa and I use it sometimes to surf while chilling around. I actually bought it used from a friend, but I also don’t have any issues with posessing it except the things I already mentioned around iOS and the phone. But I also would most likely not switch it.

Macbook#

Honestly, the Macbook I just love. This is the greatest laptop I ever owned. The build quality is awesome and and the M1 ARM processor is crazy fast. Also, the lock-in topics I mentioned on the iPhone are not remotely as bad on the Mac. I can freely choose a browse which is not running WebKit, I can get root access and even install a Linux OS if I like to.

The only thing which I maybe do not like that much is the look&feel of MacOS. I regularly use different computers with different operating systems and to me the different keyboad layout to Linux and Windows is just annoying. I would wish that apple would give users the opportunity to select between different keyboad layouts and also Window-Layouts etc. But I think that’s a wish that will never be fulfilled. We’re still talking about Apple.

Anyway, that’s still not reason for me to get rid of the device by now. I bought it, and I want to keep it for some time longer. I use another Macbook at work for programming, so if I switch my personal one to a linux machine, I still need to cope with the shortcut and keyboard differences all the time.

Still, similar to the Shift- and Fairphones, there’sFramework , which are building highly repariable computers for end consumers. Maybe, in a few years, when I have the chance to switch my work device, I will ask for a non-mac laptop and also switch to a frame-work as my private device then.

Conclusion#

In conclusion, my experience with Apple products over the years has been a mix of satisfaction and frustration. While I appreciate their reliability and durability, I’m increasingly wary of the limitations and costs associated with the Apple ecosystem. As I look towards the future, I’m inclined to explore alternatives that offer more flexibility and affordability. By gradually transitioning away from Apple, I hope to regain control over my device choices and minimize the influence of vendor lock-in.

• Tobi

Introduction#

I know there are several studies which show thatmultimonitor setups increase office workers’ productivity . I myself have often had doubts about those studies. In the linked case, the “study” was based on a survey of ~2000 people working in offices. The productivity was “measured” by self-evaluation of those people. So, you don’t know if they were really more productive or if they just felt that way.

Another question I have for this specific study is whether the “second monitor” is actually a real physical monitor with 24"+ added to the prior single monitor, which was the laptop. The press release does not make that clear. To me, it is obvious that if you add a mouse, a keyboard, and a monitor to your laptop, your productivity will increase, even if you stay in single-monitor mode on the larger screen and close the laptop, like I do most of the time.

Definitions#

Let me clarify some terms I will be using in the following text:

• 0.5 screen setup: The typical laptop. This is fine if you are currently traveling, but I don’t see how you can be productive for a longer time just on your laptop screen.
• 1 screen setup: One larger screen with good ergonomic positioning in front of your face.
• 1.5 screen setup: One larger screen with the laptop screen.
• multi-screen setup: 2+ larger screens.

Basically, I see a normal computer monitor as one screen and a laptop as 0.5. An ultrawide screen, to me, is also like 1.5 monitors.

Where’s the Benefit#

For many workloads, I totally see the benefit, especially if you compare things at all levels. Examples include:

• A frontend developer who has the code on one side and the open browser with live-refresh on the other.
• A support engineer who has logs on one side and code on the other.
• “Business-stuff” tasks, such as comparing an Excel sheet with a PDF or another Excel sheet.
• Online presentations where you share one screen and use the other to see your notes.

These are typical workloads I have, where I also use two monitors, and I totally see the benefit. But to me, this is maybe 10% of the day.

What’s the Cost#

Now, what’s the cost when using multiple monitors? I currently see three cost factors:

Initial cost: The cost to buy a monitor. I don’t think you should try to save a lot of money here since, in my opinion, a good monitor is crucial for a productive working day.

Running cost: Energy consumption. I think here you can and should actually save money. People often underestimate the running cost of a monitor, especially if they have higher refresh rates of 120Hz or more. So, if you are currently just using one of them, try turning off the other one for a moment. It will help your electricity bill, and it will help you with:

Stress cost: This is a very subjective thing, so I will write down my personal view here. Very often, having multiple monitors turned on while only using one of them causes me a lot of distraction and stress. This could be due to:

• Messages in Slack.
• Emails.
• News popping up.
• Other documents or code which I currently don’t look at, but are still constantly on my mind because I see them in peripheral sight.

My Setup#

So, I’m currently running the 1.5 monitors setup everywhere. I would say that 90% of the day, the laptop lid is closed, and I only use one monitor. But for some workloads, I totally see the benefit of two monitors, and that’s when I usually open the laptop lid and use it as a second screen.

To me, having two “real” screens always on was, in the end, more of a distraction and damaged my workflow than I had any benefits from. But I also don’t like working with only one screen all the time, so I currently see the 1.5 monitor setup as perfect.

Conclusion#

In my observations of other people I work with and mentor, I see that some are really keeping up productivity with three monitors and also often use all three of them. Usually, those are people who also have better capabilities to multitask than I have. But I also mentored someone who told me that they felt distracted all the time and had difficulties focusing on their tasks. So I recommended to them what helped me: Stop multitasking. Try to split your workday into slots of X minutes, whatever fits for you, and just work on a single thing during that time. If you choose something like 20-30 minutes, then there’s basically no message you can’t wait to respond to until your slot ends. If you then choose to use only one monitor, you are also not distracted by any Slack messages on the second one. What I also use a lot is workspaces. By now, Linux, Mac, and Windows all support them. Usually, I have a cluttered workspace with mail, Slack, and other programs. And when I work with code, I am on a separate workspace.

I think this is a very subjective topic, and everybody should do what fits their needs the most. To me, it turned out that multiple monitors are often just too distracting. Sometimes for unnecessary “media stuff,” but sometimes also the “work on idle” on the other screen is constantly putting jitter in my brain. That’s why I ended up using just one monitor with the optional laptop screen if needed.

disclaimer: I’m currently testing around a bit with AI generated content and thought it’s a good experiment to make ChatGPT write an article about the “idleness” topic. The inspiration for the topic I got from the german book called “Das Beste was wir tun können ist nichts”, which freely translates to “best we can do is nothing”.

In general, I like what ChatGPT wrote about idleness. In the first place, I wanted to also talk more about what consequences idleness can have on your personal life, but unfortunately, ChatGPT focussed a lot on career and work life. I know, that I could’ve continued talking to ChatGPT to make it implement those changes, but currently I try to minimize the talking in those prompts.

My 5 cents: I really liked the book I read about idleness, but I think the author is somehow praising the concept too high. There were situations in the past in my life, where I think I should’ve acted earlier, but thereare also many examples in which I shouldn’t have acted at all. Especially in work life and since I’m working in more kind of a “core role” in my company, I learned that I don’t need to act on every slack message I get, but sometimes you need to wait a little because the people will come a few minutes later saying “oh nevermind, I think it’s not that imporant right now”. So, sometimes, just stay calm and idle 😉.

ChatGPT (3.5):#

The Virtue of Idleness: Embracing Patience in Life#

In a world that celebrates productivity and action, the concept of idleness often receives a negative connotation. However, there is a profound wisdom in the art of idleness, in patiently waiting for things to unfold rather than rushing into immediate action. This essay explores the notion of idleness as a virtue, discussing its potential benefits in life while also addressing the dangers of prolonged inactivity.

At first glance, idleness may seem counterproductive, but upon closer examination, it reveals itself as a powerful tool for personal growth and development. Embracing idleness allows individuals to cultivate patience and mindfulness. By refraining from immediate action, one can gain a deeper understanding of oneself and the world around them. Idleness provides the space for reflection, introspection, and creativity to flourish. It allows ideas to germinate and solutions to emerge naturally, rather than being forced.

Moreover, idleness serves as a counterbalance to the relentless pace of modern life. In a society that glorifies busyness, taking moments of idleness can be a radical act of self-care. It offers respite from the constant pressure to achieve and allows individuals to reconnect with their inner selves. Books such as “The Art of Stillness: Adventures in Going Nowhere” by Pico Iyer delve into the transformative power of stillness and idleness in a fast-paced world.

While idleness has its merits, it is essential to acknowledge the potential dangers of excessive passivity. Prolonged periods of inactivity can lead to stagnation and complacency. Without goals or aspirations to pursue, individuals may find themselves trapped in a cycle of apathy and disengagement from life. This can ultimately result in missed opportunities for growth and fulfillment.

Furthermore, idleness can foster a sense of entitlement or unrealistic expectations. Waiting for things to happen without putting in the necessary effort can lead to disappointment and disillusionment. Books like “The War of Art: Break Through the Blocks and Win Your Inner Creative Battles” by Steven Pressfield explore the dangers of procrastination and the importance of taking action in pursuit of one’s goals.

In conclusion, the concept of idleness offers valuable insights into the nature of human existence. By embracing moments of stillness and waiting for things to unfold, individuals can cultivate patience, mindfulness, and creativity. However, it is essential to approach idleness with caution and awareness of its potential pitfalls. By finding a balance between patience and action, one can harness the power of idleness to lead a more fulfilling and meaningful life.

Link to ChatGPT Prompt .

In the last years I read a lot about the concepts of essentialism and minimalism and somehow identify with the ideas. But I would like to answer the question for me if I’m a minimalist or essentialist. For a while I’m wondering in how far both concepts can be distinguished. I have my on thoughts on it on how to do that, but I would like to check in this blog entry if I’m right or wrong about it. The generalized statement of both is pretty much the same:

Have a higher quality in life by doing and owning just what’s really important for you.

General#

Minimalism as a lifestyle is often accused to be more or less just a tool ofsurveillance or attention capitalism to keep people on consuming facebook, instagram and tiktok feeds of thebigger minimalism influencers . I’ve rarely seen minimalists recommending their listeners or readers to just quit the media they are delivering on. Which makes a lot of sense because most of those influencers by now make their money with social media content, so telling your audience to leave your platform can be very counter productive for your personal wallet. On the other hand, you’re a minimalist so money is not that important, is it? In fact, sometimes I get the impression that you cannot be a minimalist without having some kind of social media presence, blog or podcast to sell courses and books. And you find justlots of it.

On the other hand I rarely find something on the label essentialism, and rarely people identify as “essentialist”, at least it seems to be less common than for minimalists. One of my first books I read about those concepts was called “essentialism” by Greg McKeown. A book of which I have mixed feelings about because a huge part of why it tells you to try the essentialism lifestyle is your work. So the main question after reading the book was: what is thisreally about? Living a better life orbeing more effective at work? Yes, please understand this as another critique on capitalism buying and reselling lifestyles.

Fortunately, essentialism has a much longer track record than minimalism. Philosophically seen,essentialism is the view that every object has a set of attributes that are focal to their identity. This means that the essence is basically a combination of substance and form analog to ideas and forms in Platons idealism. So it’s basically a philosophical view that everything can be abstracted to some specific core attributes. Once you replace “everything” with “everyone” or even groups of people, this can easily drift into generalizations and thedanger of racism and fueling identity politics .

What I think#

I think, minimalism is aboutthings, and essentialism is about a wholistic view on your mind. Even if the influencer-minimalists would argue differently. Actually, I think that essentialism is, what minimalism want’s to be. Why?

Minimalism to me appears as a capitalist lifestyle which does basically identify by having just a few, but very intentional (and luxurious) things. Following minimalist influencers for a while, you will see that they do not own a lot of stuff, buf what they own is usuallyridiculously expensive and also show off with those a lot. Also, they usually justify each of their belongings by the quality of the product, how it is the best product in it’s category and how much it “brings joy” to their lifes. But most of it still seems to be aboutthings instead of work, private life etc. And the main reason for this is the big minimalism industry which basically - contrary to what they say - talk about things and stuff over and over.

Essentialism as a lifestyle instead seems to provide what minimalism fails to - by actually deliveringless content. I actually had a hard time finding online content on essentialism - which makes sense since the essentialists are probably focussing on essential things in their lifes instead of just producing video over video and hosting it on social media platforms which make their money by selling products to the audience. One thing you have to keep in mind when implementing a essentialist view on the world is that the belief that everthing is deducible to some core attributes can also lead to prejudice.

What ChatGPT thinks#

Wouldn’t this be interesting?

Essentialism and minimalism are two distinct concepts, often associated with different aspects of life, philosophy, and design. Here’s an overview of each term:

Essentialism:

• In Philosophy: Essentialism is a philosophical concept that suggests that entities have inherent, fundamental qualities or characteristics that define their essence. This view holds that things have a set of properties that make them what they are, and these properties are necessary for the existence of the entity.
• In Education: Essentialism in education advocates for a focus on essential skills and knowledge that are deemed necessary for students. It emphasizes a core curriculum that often includes subjects like mathematics, science, literature, and history.
• In Personal Development: Essentialism in personal development is a mindset that encourages individuals to identify and focus on what is truly essential in their lives. It involves prioritizing activities and commitments that align with one’s values and goals while eliminating non-essential distractions.

Minimalism:

• In Art and Design: Minimalism is an art and design movement characterized by simplicity, clean lines, and a focus on essential elements. It involves using the bare minimum of components, such as color, shape, and form, to convey a message or create an aesthetic experience.
• In Lifestyle: Minimalism as a lifestyle advocates for simplifying one’s life by decluttering physical possessions and focusing on experiences rather than material possessions. The goal is to eliminate the excess and only keep what is truly valuable or necessary.
• In Technology: Minimalism in technology refers to designing products and interfaces with a minimalistic approach, often emphasizing simplicity and ease of use. This can apply to both hardware and software design.

In summary, while essentialism is a philosophical concept that deals with inherent qualities and the core nature of things, minimalism is often a design or lifestyle choice that emphasizes simplicity and the elimination of excess. Essentialism is more about identifying and focusing on the essential qualities, while minimalism is about reducing to the essential elements or components.

So it seems that ChatGPT comes to an additional conclusion. Also notice, how the points in essentialism are about thoughts and ideas, while for minimalism it’s about things: art & design, technology. Both have “lifestyle”.

Articles#

• Death by a thousand microservices
• To listen well, get curious
• Attention is your scarcest resource
• You don’t need a modal window
• Radical simplicity in technology
• Just use Postgres for everything
• Recession and crisis in the IT industry
• Quitting My Job For The Way Of Pain

Blogs#

General#

• Jason Fried - I like Jasons concepts of how to structure companies and workload. He funded the company behind basecamp together with David Heinemeier Hansson.
• Ben Kuhn - I had an interview with Ben when he was the CTO ofwave , a finance startup from Senegal. He’s a really great and respectful guy and I really appreciate the hour talk that we had. Since then, I regularly check his blog.

Tech#

• David Heinemeier Hansson - 37signals co-owner and also long-year blogger. Some of his takes I like, some I don’t. But it’s always nice to read differnent opinions as well.
• Deniz Aksimsek - A guy who’s active in the indieweb and htmx community. Actually, when I bought theHypermedia Systems book he co-authored, I checked his website and discovered the indieweb. So Deniz, thanks a lot 🙇‍♂️.
• Jonathan Pallant - When you do things with Rust and embedded systems, you should have heard about Jonathan.
• fettblog.eu - I’m confused you can use fettblog.eu and oida.dev. Wondering with how many Domains Stefan can come up.
• Dirkjan Ochtman - Creator of Askama Templating engine
• Armin Ronacher - As well as Ben, Armin is a techie under the “general” section as well, because I absolutely love reading his takes on life and work.
• Nikhil Suresh - Really cool writing style and great tech articles such as “I Will Fucking Piledrive You If You Mention AI Again”

Indieweb & basic internet technologies#

Indieweb#

I’m currently reading a lot about the Indieweb. Basically the indieweb is the internet how it was meant to be. Decentralized and owned bymany people and nota hand full of companies . As the linked articles says, the internet hardware is bascially owned by very few telecommunication companies per country and it’s software (and also data!) is controlled by basically just a few companies (google, facebook, microsoft).

The indieweb is a movement against that. I’m currently exploring a lot and it’s just fascinating and great and brings back some early 2000s vibes for me.

Freelancing and Rust trainings#

I also try to do freelance projects using Rust and also get some gigs to do my async-Rust trainings based on mytokio-web-demo .

Basic tech#

Besides the Indieweb, I’m currently exploringbasic internet technologies. What I mean with this is that in the last years I got pretty disconnected with a huge part of web development which is the frontend.

I have thismqttpal side project, which is basically meant to be a debugging and statistics webserver for “mosquitto” and other mqtt brokers. My goal is to build a very dynamic website supporting technologies such as websockets for live debugging of MQTT Topics, while not making use of any single page application framework such as React or Vue. To do that, I make use of:

• Actix-Web for the backend
• Askama as templating engine
• HTMX andhyperscript to implement a dynamic frontend

General#

Today I switched the blogs page fromHugo toZola .

While Hugo was a great experience, I always thought that it might be very over the top of what I want to do. This is not some kind of simple content management system for me, but I also plan to fiddle around a little bit with the static site internet, especially HTML and CSS.

So the benefits to Hugo I see are:

• Due to my job I’m familiar with the greatTera templating engine.
• Zola is written in Rust 🦀! It’s probably not that I would ever need to make changes, but if so, it would be much easier for me to contribute.
• Simplicity. Hugo is great. But hugo is also just large. Zend isn’t.

ToDo#

This is a living document, so you can read my todo list here:

• About Page
• Blog Pages
• GitLab Integration (yes, this page is hosted onGitLab Pages )
• Taxonomies
• Top Navigation
• Basic CSS
• RSS feeds
• Extra: Dark mode(this was much easier than I thought!)

Summary#

A few hours later and I’m done. It’s basically crazy how few steps I needed to move my personal homepage from Hugo to Zola. The basic steps I took today:

• Savecontent/ folder, delete all hugo files.
• Install and init azola project.
• Realize that basically everything excepttags work. Great 😮!
  • this might be due to the fact that I used basically no hugo features. If you have bigger and more extensive sites, this might be much more difficult for you!
• try out some templates and realize I don’t like them.
• Read thegreat documentation about templates.
• spend a few hours writing a basic setup

What should I say? I’m pretty happy. While I was developing the template, I tried to read a lot about how to write a simplistic website and ended up with agreat website about brutalist web design . While I did not implement all points yet, I like how fast you can go forward if you apply simple principles and keep thecomplexity of your projects small.

This will be the first post for an ongoing series I want to write on what makes a software well designed or not. Of course, I’m clear that this is probably one of 1203901831 articles of this kind in the internet. But as everything in this blog, this is also just about writing things down which helps me personally to find my own opinion to those things.

As mentioned in theabout me page, “gude” is a typical colloquial language to say “hi” in german. Gude is rooted from “gut”, which is good in english.

There’s a whole philosophy on good and you can probably discuss this in a whole semester of philosophy courses and still discuss if we talking on good as in good food, or good as in public good? Let’s start with todays statement:

Barely complex enough, yet as primitive as possible#

This is somehow the obvious “KISS” statement. Don’t try to overcomplicate things. Also, one of my learnings is to not abstract too more than you need to. If you want to solve a specific business purpose, then solve it. Don’t think too much about what else could be solved if you would just make the whole code more abstract and generic, if you don’t have a specific usecase for it.

Example: My task is to write a little app which is able to store books into a database and has a web frontend for this. Nothing else needed since it’s just running on a single users local machine at the library next door.

Best design: I find an existing solution for it, which is well designed.

Good design: I chose my favourite tool and wrote a GUI which is able to give a simple local book database management to the librarian. Stored in a file, backed up on a NAS or Dropbox or whatever.

Bad design: I’m the best programmer in the world. So I added usermangement and additionally to that I made the storing of objects in the database generic, so you can store any object you like. This brings no obvious feature for the user, but we can later extend it easily. Data is stored in some SQL database on some cloud hoster so it’s accessible everywhere. It just took me 2 weeks.

What I solved with the bad design solution is a whole different task, which is: write an application with usermanagement which is able to store any kind of objects into a SQL database table, which is hosted in a cloud environment.

This is not just bad because I took more time for the implementation than necessary, but also because all those little features I added because I love my tools and I want to show what I’m capable of. One rule of thumb I learned is that features always lead to more features. And feature is complexity. So complexity leads to complexity. And asas we learned from grugbrain : complexity very, very bad.

By the way talking about features leading to features. I introduced usermanagement, right? What about permissions now? Do we need roles? You see, features lead to features. And features are complexity.

At the moment, I’m working both with Raspberry Pi Picos in Embedded projects and Rust in System Software Projects. Today, I would like to test out the embedded capabilities of the Rust programming language and deploy some Rust embedded#![no_std] code to aRaspberry Pi Pico .

One motivation I have for this tutorial is, that there are several good tutorials on embedded Rust, but all of them provide some kind of predefined repository. While I don’t want to complain about this at all and we all should be really greatful by the learning material that the Rust community is giving to us, I personally like it more to build up on a mostly empty repository, to learn exactly where we are coming from. So I personally plan to do this just as some kind of minimal project with a blinking example. Once I will go for more sophisticated projects, I will go and work with predefined repositories since they have much more capabilities than this project has.

Again, I’m writing this tutorial from a Macbook with Apple Silicon, so some things might be different in Linux or Windows.

Prerequisites#

Let’s assume you have the following installed:

• Rustup, the installer for the Rust programming language:Rustup
• A compatible code editor. With Rust, I had a lot of success withVisual Studio Code and it’sRust Extension Pack (including the very importantrust-analyzer).
• You’ve done theChapter 1. Quick Pico Setup from the official Raspberry Pi Pico installation Guide.

Done that? Good! Let’s roll!

Creating the Rust Project#

Rust projects are managed with a tool calledcargo. Cargo is a package and repository manager for the Rust ecosystem and gives you a lot of help around dependency management, testing, linting (clippy), and formatting (rust-fmt). I would always highly recommend going with cargo. So first, create a new project in a directory of your choice, for me it’s~/code/pico

cd ~/code/picocargo init blink-rs

Cargo should’ve created a folder now calledblink-rs. You can open that directory now with VSCodenvim blink-rs.

Open thesrc/main.rs file which is always the entry point for abinary crate. Acrate is a package in rust, and a binary crate is therefore a package which builds an executable. There are also library crates, which are supposed to build, yes you guessed it, libraries ;-). You will see this:

src/main.rs

fnmain(){println!("Hello, world!");}

Cargo.toml

[package]name="blink-rs"version="0.1.0"edition="2021"# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html[dependencies]

If you runcargo run in your console now, Cargo should compile a binary and writeHello World! to your terminal. If this is the case, all is good.

How to bring this to the Pico?#

In our current state, we have a Rust program which makes use of rustslibstd, which bringsa lot of capabilites to work together with operating systems. If we would use an Embedded System which runs Embedded Linux for example, this would already be enough because the Kernel would abstract all hardware for us:

 ┌───────┐ ┌──────┐ ┌──────┐ ┌────────┐
│main.rs├──►│libstd├───►│kernel├──►│hardware│
└───────┘ └──────┘ └──────┘ └────────┘

Since we want to run our software natively for the Raspberry Pi Pico, and usually there is no libstd implementation for single hardware, we need to skip the libstd by instructing rust to do#![no_std] in the first line of our code:

#![no_std]fnmain(){println!("Hello, world!");}

The first thing we’ll notice is that oncargo build, rust will immediately complain about println! not being known. Yes, that’s true, since it’s part oflibstd. You might ask now what you can still use, theEmbedded Rust Book has a really good chapter on this .

If you try to build now, you will see a couple of errors:

❯ cargo run Compiling blink-rs v0.1.0(/Users/ts/code/pico/blink-rs)error: cannot find macro`println` in this scope --> src/main.rs:4:5|4| println!("Hello, world!");| ^^^^^^^error:`#[panic_handler]` function required, but not founderror: language item required, but not found:`eh_personality`|= note: this can occur when a binary crate with`#![no_std]` ...= help: you may be able to compilefor a target that doesn't ...error: could not compile`blink-rs` due to3 previous errors

Obviously, println! is not available anymore, since we got rid of libstd. Additionaly, Rust does not know how to handlepanics since the#[panic_handler] function is not defined anymore. And finally Rust is also not able to compile for a target whereeh_personality (eh = exception handling) is not defined, which is in case for “standard environments” like linux/mac/windows automatically being done by rusts libstd.

So, what do we need to do now to bring this code to a Raspberry Pi Pico?#

First of all, define the right target. With rust, we can install it by writingrustup target install thumbv6m-none-eabi.

Then, we need to tell cargo to build for this target. Instead of usingCargo.toml, cargo uses.cargo/config.toml here. So we create a.cargo folder and crate a fileconfig.toml with the follwing contents:

[build]target="thumbv6m-none-eabi"

Once we’ve done this, we need to get the right crates into our system. The Embedded Rust community tries to standardize abstraction layers to streamline implementation for different board, driver and bus abstractions. These are the typical abtraction crates that we need for embedded development:

Architecture Support Crates#

Our Raspberry Pi Pico runs a RP2040 Microcontroller, which is a Cortex-M implementation. So our architecture support crate is calledcortex-m andcortex-m-rt (rt for runtime).

Peripheral Access Crate#

The PAL is based on your microcontroller. By using this crate, you can access internal periphals of the chip you are using. In our case - the Raspberry Pi Pico which runs on a RP2040, so the peripheral access crate is calledrp2040-pac.

Hardware Abstraction Layer#

So we’re running a Cortex-M. Good. But which cortex M? For this, we need to define theHardware Abstraction Layer, which in our case is the crate calledrp2040-hal.

Board Support Crate:#

We run a Raspberry Pi Pico, so there’s a board support crate available which is calledrp-pico. In case you build your own hardware, usually the board support crate is what you would need to write on your own (despite your layout is 100% compatible to an existing board). The board support crates usually contain the PAC and HAL.

Code │ Board │ Hardware │ Architecture │ Actual
│ Support │ Abstraction │ Support │ Hardware
│ │ ┌──────────┐ │ ┌───────────┐ │ ┌────────────────┐
│ │ │rp2040-hal│ │ │cortex-m │ │ │ │
┌───────┐ │ ┌───────┐ │ └──────────┘ │ └───────────┘ │ │ Microcontroller│
│main.rs│ │ │rp-pico│ │ │ │ │ │
└───────┘ │ └───────┘ │ ┌──────────┐ │ ┌───────────┐ │ │ rp2040 │
│ │ │rp2040-pac│ │ │cortex-m-rt│ │ │ │
│ │ └──────────┘ │ └───────────┘ │ └────────────────┘
│ │ Peripheral │ │
│ │ Access │ │
│ │ Crate │ │

Bring in the dependencies#

So, we want to add these dependencies into our project. For that, we edit the Cargo.toml file with the following contents:

Cargo.toml

[dependencies]# for the cortex microcontrollercortex-m="0.7.7"cortex-m-rt="0.7.3"# board support craterp-pico="0.7"# for GPIO traitsembedded-hal="0.2.7"# to handle panicspanic-halt="0.2"

Bring in the code#

At this point, I actually planned to do write down the exact code for the embedded rust project, but then I realized that the creators of therp-pico Board Support Create actually did a great job in providing aperfectly commented blink example .Please copy the codes content to your main.rs, since we will use it for now. Some general steps through the code:

Themain function is annotated with a#[entry] macro in line 41, to tell the controller where to start. At the start of the main function, youtake() the Periphals and Coreperiphals of your controller to the currents scope ownership. This is an important concept in Rust, whereownership of a value/variable is always clear .

Then, you setup a watchdog and clocks, get a delay functionality from the cortex’s hardware implementation and some other I/O structures. Finally, you end up in theloop, which in rust is equal to awhile(1) in C or theloop() function in Arduino.

// Blink the LED at 1 Hzloop{led_pin.set_high().unwrap();delay.delay_ms(500);led_pin.set_low().unwrap();delay.delay_ms(500);}

In this code, we blink the LED once a second.

Build the Code#

In Rust, building code is pretty simple, you just typecargo build orcargo build --release. We build the release code. You should find a file intarget/thumbv6m-none-eabi/release/ calledblink-rs. This is an ELF file, which you cannot just load to your RP2040 now.

There’s a tool calledelf2uf2 you can install withcargo install elf2uf2-rs. With this, you can translate the file (after you reload the terminal):

elf2uf2-rs target/thumbv6m-none-eabi/release/blink-rs

Wait, there’s an error?

Error: "Memory segment 0x010000->0x010094 is outside of valid address range for device"

Okay, it seems that the compiler did something wrong and used more memory than the pico is available to give to us.Googling tells us that we need to specify a memory.x file which is used by the linker to guarantee a correct output layout for a raspberry pi pico. So let’s take a look at what is happening here:

memory.x

MEMORY {
BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
FLASH : ORIGIN = 0x10000100, LENGTH = 2048K - 0x100
RAM : ORIGIN = 0x20000000, LENGTH = 256K
}
EXTERN(BOOT2_FIRMWARE)
SECTIONS {
/* ### Boot loader */
.boot2 ORIGIN(BOOT2) :
{
KEEP(*(.boot2));
} > BOOT2
} INSERT BEFORE .text;

This is a so calledLinker Script for the ld linker which is part of the Gnu Compiler Collection (gcc). What it is basically doing is defining boot, flash and ram locations in memory and then making sure that the BOOT2 section is kept where it already is.

Comparing this and the Memory Segment error from the elf2uf2-rs tool, I’m pretty happy that we were notified about invalid adress memory, because it seems that we would’ve overwritten the huge parts of the existing bootloader. Good, so we create a new file at the project root level calledmemory.x with the contents mentioned above, and change the.cargo/config.toml to include:

[target.thumbv6m-none-eabi]rustflags=["-C","link-arg=-Tlink.x",][build]target="thumbv6m-none-eabi"

Now, runcargo clean andcargo build --release followed by once moreelf2uf2-rs target/thumbv6m-none-eabi/release/blink-rs. If you see no error, boot your Raspberry Pi Pico into bootloader mode by attaching microusb while pressingBOOTSEL button on the board. Now rerun the last command with a -d at the end to flash the device and see your Raspberry Pi Pico blinking!Great job!

You can find the repository inmy github .

Where to go from here?#

So we made it work to blink a LED on a Raspberry Pi Pico using Rust. That’s great. From here you can basically go everywhere. Good learning resources for embedded rust you can find here:

• Awesome Embedded Rust
• Embedded Discovery Book
• RP Pico Crate with great examples

You can find the source for this code in Thank you for reading through this. If you have any questions or feedback for things I can do better, feel free to send me an email tohi@tobischmitt.net.

Did you ever wonder how to debug a microcontroller? With a Raspberry Pi Pico there’s a simple solution:Use another Raspberry Pi Pico 😉!

What I worked on today is being able to prepare two Raspberry Pi Picos (one W and one without W) to debug executables. The one without Wifi will be used as aPicoprobe , the WiFi version as target later.

Prerequisites#

• if not already done,install Homebrew
• install a serial terminal. My recommendation isCoolTerm

Building openocd#

In Raspberry Pi Pico’s Getting Started Document , they have a great explanation of how to build openocd (which is an open sourced on-chip debugger) and picoprobe. I will note down the Mac commands here, if you are on a different system please consult the linked Document:

# install dependenciesbrew install libtool automake libusb wget pkg-config gcc texinfo# create a pico directory whereever you like and navigate theremkdir -p ~/pico# clone openocdgit clone https://github.com/raspberrypi/openocd.git --branch rp2040 --depth=1cd openocd# export tex pathexportPATH="/usr/local/opt/texinfo/bin:$PATH"`# run bootstrapping script./bootstrap# run config script./configure --disable-werror# buildmake -j4# testsrc/openocd

You should see this output:

Open On-Chip Debugger 0.10.0+dev-gc231502-dirty (2020-10-15-07:48)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
embedded:startup.tcl:56: Error: Can't find openocd.cfg
in procedure 'script'
at file "embedded:startup.tcl", line 56
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Error: Debug Adapter has to be specified, see "interface" command
embedded:startup.tcl:56: Error:
in procedure 'script'
at file "embedded:startup.tcl", line 56

It works? Good!

Download and setup pico-sdk#

# navigate back to your pico directory# clone picoprobe and install submodulesgit clone https://github.com/raspberrypi/pico-sdk.gitcd pico-sdkgit submodule update --init

Building picoprobe#

# navigate back to your pico directory# clone picoprobe and install submodulesgit clone https://github.com/raspberrypi/picoprobe.gitcd picoprobegit submodule update --init# create build dir and switchmkdir build&&cd build# setup build filesPICO_SDK_PATH=../../pico-sdk cmake ..# buildmake -j4

If everything went well, you see a file calledpicoprobe.uf2 in your current directory.

Building the pico examples#

# navigate back to your pico directory# clone picoprobe and install submodulesgit clone https://github.com/raspberrypi/pico-examples.gitcd pico-examples# create build folder and navigatemkdir build&&cd build# setup build files using PICO_SDK_PATH env var and CMAKE_BUILD_TYPE compiler parameter, IMPORTANT!PICO_SDK_PATH=../pico-sdk cmake -DCMAKE_BUILD_TYPE=Debug ..# build hello serial:cd hello_world/serialmake -j4

Make sure you can see ahello_serial.elf file in your current directory.

Wiring up the two Picos#

Nothing as simple as an image:

The pico on the left using the yellow USB cable is your debuggingpicoprobe.Yellow andorange are for serial passthrough,teal andpurple are for the Debug bus.

Flashing Picoprobe#

When attaching a USB Cable to your Picoprobe-Pico, hold down theBOOTSEL button on the board to make the Pico run in bootloader mode. On your mac you should see a external volume popping up with the nameRPI-RP2. Copy the picoprobe software over and the device will restart automatically.

cd ~/pico/picoprobecp picoprobe.elf /Volumes/RPI-RP2/

Finally, Debugging!#

Now, openanother terminal[T2] and navigate to~/pico/openocd. To start the on-chip debugger service, run:

src/openocd -f interface/cmsis-dap.cfg -c"adapter speed 5000" -f target/rp2040.cfg -s tcl

At the end of the output you should read:Listening on port 3333 for gdb connections. Yes? good!

Now, switch back to the terminal which you used to build 3 steps before[T1], and runarm-none-eabi-gdb with thehello_serial.elf build file. This will connect to the on-chip debugger port you just opened and use thehello_serial.elf build for debugging.

arm-none-eabi-gdb -q -ex"target extended-remote :3333" hello_serial.elf

You should be able to see GDB output now.

❯ arm-none-eabi-gdb -q -ex "target extended-remote :3333" hello_serial.elf
Reading symbols from hello_serial.elf...
Remote debugging using :3333
warning: multi-threaded target stopped without sending a thread-id, using first non-exited thread
time_reached (t=...) at /Users/ts/code/pico/pico-sdk/src/rp2_common/hardware_timer/include/hardware/timer.h:116
116 uint32_t hi_target = (uint32_t)(target >> 32u);

In[T1], tell GDB to load the binary file to the remote pico by writingload into the gdb terminal:

(gdb) load
Loading section .boot2, size 0x100 lma 0x10000000
Loading section .text, size 0x44e8 lma 0x10000100
Loading section .rodata, size 0xfb4 lma 0x100045e8
Loading section .binary_info, size 0x28 lma 0x1000559c
Loading section .data, size 0x244 lma 0x100055c4
Start address 0x100001e8, load size 22536
Transfer rate: 16 KB/sec, 3756 bytes/write.

In the openocd[T2] Terminal you should see this output repeatedly, while the .elf file is loaded to the target chip:

target halted due to debug-request, current mode: Thread
xPSR: 0xf1000000 pc: 0x000000ea msp: 0x20041f00

Okay, perfect, switch back to[T1], and place a breakpoint tohello_serial.c:14:

(gdb) b hello_serial.c:14
Breakpoint 1 at 0x10000310: file /Users/ts/code/pico/pico-examples/hello_world/serial/hello_serial.c, line 14.
Note: automatically using hardware breakpoints for read-only addresses.

Open your Terminal software, connect to your usb attachedpicoprobe with settings BAUD 115200 8-N-1:

Switch back to your GDB[T1] and run the software. For this, just typer and pressENTER. GDB will ask you if it should start the software from the beginning. Write yes. Now you should see the following output since you run into a breakpoint:

(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /Users/ts/code/pico/pico-examples/hello_world/serial/hello_serial.elf
target halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x00000184 msp: 0x20041f00
[New Thread 2]
Thread 1 hit Breakpoint 1, main () at /Users/ts/code/pico/pico-examples/hello_world/serial/hello_serial.c:14
14 sleep_ms(1000);

In CoolTerm, you should see aHello World! output. If this is the case, everything worked fine! In case you are not familiar with GDB debugging, I can just recommendthis GDB cheat sheet . Some short commands:

• r for RUN the program, ctrl+c to stop the program
• l to print the code where you currently are
• b [filename]:[line] to set a breakpoint
• c to continue until the next breakpoint
• n to step to the next instruction

Congrats, you can now do on-chip debugging on a Raspberry Pi Pico by using another Raspberry Pi Pico.