DEV Community: DarioCasciato

Software Realtalk: Is Content and Code Quality Declining (Also on dev.to)? My Honest Opinion

DarioCasciato — Tue, 31 Dec 2024 11:27:51 +0000

Intro

Hey fellow developers!

This is a topic i always wanted to talk about (and im sure also some of you too), but i was somewhat of reserved about it because of the potential reactions. Please read it thoughtfully.

AI for good

In the first year of the drop of ChatGPT, i was flabbergasted how incredibly advanced our technology has got and how powerful it was. I almost used it every day (still to this day, but not particularly for coding). It helped me a lot by teaching me how to code, and how to apply insights i learned. Especially since a 10 month firmware developer job was waiting for me after my apprenticeship.

The decline

After 2 years, I didn’t see a reason to code as much anymore since ChatGPT was doing much of the work for me. Of course, i always made some adjustment or wrote some snippets by myself, but coding didn't feel the same anymore, since i could always ask ChatGPT for the right and working answer. This began really to hit, when i noticed that every day, everything started to slightly sound not authentic anymore. GitHub repos with questionable comments which no person would ever write, coding styles which seemed a little off, logic which quite didnt make sense. It felt like the personal touch was disappearing.

dev.to

I joined dev.to in 2022. ChatGPT/AI was very new for this time and not a lot of people knew what it really was. For me, this was the golden times on dev.to. Everyone wrote about their insights on new things they learned, authentic opinions, authentic posts, authentic comments, and the list goes on.
Sadly, this spirit of authenticity started to fade proportionally to the growth of ChatGPT. The Dead Internet Theory really began to grow on me with all the inauthentic content that was pushed on blogsites (not only dev.to). Every second post was/is like "top 10 git commands" or "portfolio page with x and y" or "top open source tools" or "xyz for beginners". Don't get me wrong, even i wrote a post similar to these categories (Optimize Embedded Development: Must-Have VSCode Extensions). But the dev.to homepage just started to be posts on these categories, which started to become uninteresting, If i compare it with the posts that were on the homepage in 2022. The real life insights are just missing.

Conlusion / Your opinion

ChatGPT/AI really pushed the speed of the development of new technology, while also making our content inauthentic ad unoriginal, since we don't have to think hard anymore. This whole AI thing has gotten out of control in my honest opinion, and it won't slow down from here on.

I'd love to hear your opinions about this topic below in the comments. Do you support my statements, are ou against them, or what do ou think in general? Let me know!

Remain authentic!
Regards

Leaving the Comfort Zone Behind: The Journey to Developing a Plugin for Obsidian.md

DarioCasciato — Tue, 06 Aug 2024 13:43:57 +0000

In my daily work use of Obsidian.md, something started to stress me out more and more: the way folders behaved when navigating through the vault. If you know Obsidian, you know how valuable it is to keep a clean and organized workspace, especially with a large number of files. But, there was a small feature that was noticeably not there – folders didn’t automatically collapse their subfolders when the parent folder was collapsed. This lack of automatic folder management led to a cluttered and overwhelming sidebar, and it was something I couldn't ignore.

The "Wouldn't It Be Great If..." Moment

One day, after manually collapsing what felt like the number 1'547 nested folder, I had the classic developer thought: Wouldn’t it be great if Obsidian had a feature that automatically collapsed all child folders when the parent folder is collapsed? The idea was simple but practical, and I could see how it would improve the workflow for many users (like myself).

But, there was no existing feature or plugin that addressed this. That’s when the seed of developing a plugin started to take root in my mind.

The Nervousness of Starting Something New

I was both excited and nervous about diving into the development of a plugin. I had developed software before, but creating a plugin that would integrate smoothly with Obsidian felt different. The main challenge was being sure that when a parent folder is collapsed, all its child folders would collapse too without having any other efforts to do so manually.

There was an underlying anxiety: I have never used the Obsidian API. The idea seemed simple, but the implementation was a different story. I was worried about the potential roadblocks and the the fear of not knowing enough to make it work.

Getting My Hands Dirty: Developing the Plugin

Despite the nerves, I decided to take the plunge. I started by familiarizing myself with Obsidian’s plugin API and thinking about the rough processes that would be needed to have the desired functionality. The goal was clear, but the implementation needed to be just right.

After some trial and error – a version with a refresh command that was removed - and more than a few moments of head-scratching – I finally got the core functionality working. The plugin I developed, which I named "Auto Folder Collapse," made sure that whenever a parent folder was collapsed, all its child folders would also collapse. It was a small tweak, but it had a veeery noticeable impact on the overall usability of Obsidian.

Demonstration:

The Pull Request: A New Kind of Anxiety

With the plugin (finally) functioning as intended, the next step was to share it with the world. This meant forking the official obsidian-release repo, adding my plugin, and creating a pull request to have it included in the official community plugins list.
(a more detailed description on how to publish a plugin: Obsidian: Submit your plugin)

This was more challenging than i thought, since this was the first time for me to contribute to a open-source project. The process of creating a pull request was straightforward, but I couldn’t help but worry about the potential feedback. Would the maintainers find the plugin useful? What if they pointed out flaws I hadn’t noticed? and What if it doesn’t even fit the demands of Obsidian?

I submitted the pull request and then came the waiting game.

The Sweet Moment of Approval

Aftfer some description-fixing (and "Refresh-Command" removal), to my relief and excitement, the plugin was approved and merged into the official community plugins list. Seeing "Auto Folder Collapse" listed among other plugins in the community felt incredibly rewarding. It was a validation of the work I had put in and the idea that started as a small frustration.

This means, that the plugin is now available for anyone to download and use. To install it, you can simply go to the "Community Plugins" section in Obsidian, search for "Auto Folder Collapse," and click the install button.

Conclusion: Reflecting on the Experience

Developing and releasing "Auto Folder Collapse" was a learning experience in many ways. It wasn’t just about coding; it was about stepping out of my comfort zone, contributing to a community, and seeing an idea come to life in a way that could help others. The feeling of providing something that the world needs/wants is surely one of the best. After 6 days since the release, the plugin has been downloaded 132 times, which is a number I never expected to reach in this time.

Link to the Repository: Auto Folder Collapse

For anyone out there with a similar idea/itch – whether it’s a small feature you wish existed or a bug that needs fixing – I encourage you to take that leap. The journey might be a bit nerve-wracking, but the outcome can be incredibly rewarding. Plus, you never know how many people might benefit from that small idea you had. Always remember that your comfort zone is a nice place, but nothing ever grows there.

Thanks for reading! If you have any thoughts or questions, feel free to leave a comment. Happy coding!

Mini-exos: The IoT Web-based Access Control System

DarioCasciato — Wed, 27 Mar 2024 13:23:57 +0000

Project Sorce Code here

Introduction

Welcome to one of my biggest projects yet! The Mini-exos! The Mini-exos is an Access Control System designed to manage and control access to secure areas or rooms. It includes an interface for managing users, access points, access assignments, and logging access attempts. The system allows for real-time access requests from microcontrollers (specifically ESP8266 in this project) equipped with MFRC522 RFID reader, for a modern access control solution.

Concept and Design

The Mini-exos project is based on the access control exos 9300, which is far more complex and feature-rich. The Mini-exos is a simplified version that was developed as a part of the new program of the trial internship at dormakaba Schweiz AG as a "GebäudeinformatikerIn EFZ" (Building Automation Engineer) in 2024. This project would give the intern a good understanding of the IoT and the access solutions offered by dormakaba.

The whole project is also based on the design guidelines of dormakaba. The User Experience and User Interface are designed to be simple and intuitive, with a focus on ease of use for the end-user.

Software Architecture

The software architecture is rather simple. We have the reader (ESP8266) and the Frontend (Mini-exos Web panel) which the user can interact with. These are like the only "visible" parts of the system. The reader is responsible for reading an RFID Badge/Card and sending the data to the backend (Node Server).

The Web panel is responsible for displaying the configurations and logs of the system. Everything that is displayed on the Web panel is fetched from the Node Server. Also, when changing or creating configurations, the Web panel sends the data to the Node Server, which then stores it in the database.

The Node Server is the "brain" of the system. It is responsible for handling the data from the reader and the Web panel. It also stores the data in the database and sends the data to the Web panel when requested. The Server also handles the access requests from the reader and sends the result if it is allowed or not back to the reader.

User Interface

Home Page

The Homepage gives you an overview of all the functionalities of the system. The navigation is held rather simple.

Access Point Configuration Page

On this page, you can manage and configure existing or new access points. With the "Add Devices/Sync" button, the system will search for devices in the local network and list them to the user with the device ID and IP. If a device is found, the user can either add it directly to the system by also giving it a name, or the user can press the button "identify", which will make the found device light up to make it easier to identify it. When adding a device to the system, the node server sends its IP address to the device, so the device can now send its requests to the node server.

The existing devices are listed in a table with the name, description, IP address, the identify button, and a button to delete the device. The user can also edit the name and description of the device by clicking on the respective field in the table.

User Management

The user management page is straightforward. It lists all the existing users in a table with the name, family name, and their Card UID. Every User that is created has also to be associated with a Card UID. Since we mostly don't know the UID of the card, we have the possibility to scan the card with a registered access point. The user can then select the access point and scan the card. The UID will then be displayed in the input field. The Access Point also signals when it is ready to scan a card.

Access Assignment Page

Here is where the magic happens. The manager or administrator can assign access rights to users for specific access points. The manager or administrator can select a user from the dropdown menu, select an access point, and optionally even an expiration date. After the right is created, the user gets also listed in a table with the user, the access point, and the expiration date. From this moment on, the user can access the access point with its card.

Expired access rights are highlighted in red in the table.

Log Overview Page

The log overview page is a simple page that lists all the access attempts in a table. The table shows the user, the access point, the result of the attempt, and the date. It also features a filter to filter the logs by user and access point.

Microcontroller Functionality

An unregistered access point could be titled as "stupid": It doesn't know where to send the data to, so it sends it to nobody. And so it doesn't ever allow access.

But even registered access points don't do a lot of work. If it is registered, it just sends a payload to the node server and waits for a response. The Access Point ultimately acts as a bridge between the RFID reader and the Node Server. The code of the Access Point is rather simple and looks like the following:


void stateIdle()
    {
        if(RFID::tagAvailable.getEdgePos()) // checks if a tag is available
        {
            Logging::log("\nTag detected! UID: %x", RFID::getUID());

            Logging::log("Requesting access...");

            // Send an access request to the server with the UID of the tag/card
            Access::ResponseStatus response = Access::request(String(RFID::getUID()));

            // Handle the response
            switch (response)
            {
            case Access::ResponseStatus::Ok:
                Logging::log("Access granted!");

                // Signal the user that the access is granted
                Signal::granted();
                break;

            case Access::ResponseStatus::Denied:
                Logging::log("Access denied!");
                Signal::denied();
                break;

            case Access::ResponseStatus::ConnectionFailed:
                Logging::log("Connection failed!");
                Signal::connectionError();
                break;

            case Access::ResponseStatus::ParseError:
                Logging::log("Parse error!");
                Signal::connectionError();
                break;
            }
        }

        // Handle host requests
        Host::handleClient(); // Check if the host has sent a request
    }

The Microcontroller basically is just sitting in this code snippet and waits for a tag to be scanned. If a Card/Badge is scanned, the following payload is sent to the Node Server:

{
    "deviceId": "0x12345678",   // The ID of the Access Point
    "uid": "1a2b3c4d"           // The UID of the Card/Badge
}

With this information, the Node Server can now check if the user has access to the access point and send the result back to the Access Point.

Security Measures

WARNING: The Mini-exos is not designed to be safe against attacks. It is a simple project to learn about IoT and Access Control Systems. So it should only be used in a local network for educational purposes.

Project Repository

The Project is stored on GitHub and is publicly available. You can find the repository here: Mini-exos. There is also a more detailed README file in the repository on how to set up the project.

The hardware that was used for this project, can be found here.

Conclusion

I think this was the most complex and educating project I have done so far. I learned a lot about IoT, Networks, API routes, and much more! I am very happy with the result and I hope you enjoyed reading about it! If you have any questions or feedback, feel free to comment below!

TLV: A Powerful Tool for handling Data in Embedded Systems

DarioCasciato — Thu, 02 Nov 2023 12:43:33 +0000

Today's article in the firmware 101 series is about TLVs. TLVs are a way to store or organize data. Since I've known about TLVs, I use them in almost every project, because of their simplicity and flexibility. In this article I will explain what TLVs are, how they work and how/where to use them.

What are TLVs?

The first time I've heard about TLV's, was about 2.5 months ago, when I started to work as a full-time embedded developer. (I firstly confused it with the Windows VLC media player).
TLV stands for Tag-Length-Value. If you illustrate them, they look something like this:

TLV's are just a way to organize data and make it easy to interpret. TLV formats allows a compact representation of data, which is needed in embedded systems, where memory and storage are limited.

how do TLVs work?

As mentioned before, a TLV is made up of 3 Parts: Tag, Length and Value:

Tag

The Tag is like the ID of the data. It tells you what kind of data is stored in the TLV. For example, if you are searching for a specific data, you can just look for the corresponding tag. For example, if you have a device-number and a password, and you want to store them, you can just assign them tags. The tags could be something like this:

Tags:

Device-ID: 0x01
Password: 0x02

Length

The length is the length of the value. It tells you how many bytes the value is long.
For example, if you have a 32-bit integer as value, the length would be 4 (bytes). The length is needed, because the value can be of any length. It could be a single byte, or a 32-bit integer, or even a string. The length is needed to know how many bytes you have to read for the value.
The length is also needed when searching for a specific tag or value in a flash storage, for example. If you know the length of the value, you know how many bytes you have to skip to get to the next TLV.
Here, for example, we are searching for a number that is stored in a flash storage with the TLV-Tag 0x03:

When we reach the TLV with the tag 0x03, we know that the value is 4 bytes long, so we can just read the next 4 bytes and we have the number!

Value

The Value is the actual data. It can be of any length and any type. It can be a single byte, a 32-bit integer, a string, or even another TLV. The value is the actual data that you want to store or transmit.

You can also store more than 1 value in a TLV. In a communication-protocol, it's very common to do so. This could look something like this:

Since the receiver of the data knows what kind of command is received (because of the tag), it knows how to interpret the values. For example, if the tag is 0x01, the receiver knows that the first value is for example the device-number and the second value is a pin-code. The length of the TLV is just the sum of the lengths of these values.

Where to use TLVs?

There are a lot of applications that use TLVs. A common application is in communication protocols. For example, if you have a device that communicates with a host, you can use the TLV encoding to transmit the data, so it's easy to interpret for the host. It's also possible to set up a server that can handle TLVs. So if you want to request something from the server, you can just send a TLV with the tag of the request without any data (the length would be 0), and the server could then respond with the same tag and the requested data as value.

Also, a common application is in flash storages. If you want to store a devices data, scores, credentials or something else, you can just store them in TLVs, and when you want to read them, you can just search for the corresponding tag and read the value. So it's also possible to update the data, by just overwriting the TLV with the same tag. But you have to be cautious! Because if the new value is longer than the old one, you have to make sure that there is enough unused space after the TLV, so you don't accidentally overwrite the next TLV (if there is one).

Not long ago, I wrote an ID-Storage Library in C++ for Arduino, that exactly uses the principle of TLVs. It's a library that allows you to store and retrieve data in a flash/EEPROM storage. You can find it here: ID-Storage Library

Finale

Thank you for reading! I hope you learned something new from this article.

Feel free to leave any comments or questions below, and I'll do my best to help you out!

May your code be bug-free!

Is it worth creating an Udemy course?

DarioCasciato — Tue, 10 Oct 2023 12:31:06 +0000

I am considering creating an Udemy course about "Real Embedded C++ development on Arduino."
However, I am concerned that I will put a lot of effort into the course, but that it will not be worth it in the end.

Do you have any experience with something like this? What is your opinion?

Optimize Embedded Development: Must-Have VSCode Extensions

DarioCasciato — Wed, 20 Sep 2023 13:44:38 +0000

And welcome back to a new article in the firmware 101 series! In this article, we won't focus on how to do things, but more on with what to do things. I will list the best VS-Code extensions for embedded development. I will also list some other extensions that are not directly related to embedded development, but are very useful.

Disclaimer

The Extensions that I will list are my personal favorites. These extensions are a must-have for me and I use them in every project. I am not sponsored by any of the extension developers.

Extensions

C/C++ Extension

This is the most important extension. It is developed by Microsoft and is the official C/C++ extension for VS-Code. It is a must-have for embedded development. It provides IntelliSense, debugging, and code browsing capabilities. The IntelliSense aspect of this extension is the most important one. It provides code completion, parameter info, and member lists.

PlatformIO

If you are developing firmware for commonly used boards like Arduino, ESP8266 or ESP32, PlatformIO is a must-have. This extension allows you to directly upload your code to the board, and it also provides a serial monitor. It also has a library manager that allows you to easily add libraries to your project. PlatformIO also has a very nice feature called "Project Tasks". This allows you to run common tasks like building, uploading, cleaning, etc. with a single click. After you get comfortable using PlatformIO, you will never go back to the Arduino IDE.

Error Lens

The Error Lens extension is one of my favorite extension for VS-Code. Instead of showing errors with squiggly lines, it shows the error message directly on the line of code where the error is. The error is more visible, and you don't have to hover over the squiggly line to see the error message and save time.

Notes

The Notes extension adds a new tab in the left sidebar. In this tab, you can add general notes that are not related to a specific file. These Notes are markdown friendly, and you can add links, images, etc. to them. I like to use it when I am working on a project and need to design the structure of the flash memory, or allocating pins for peripherals. e.g.:

GitHub Copilot

Copilot is the only extension in this list that is a paid service. Copilot is an artificial intelligence that knows your workspace and gives you completions based on your code. It costs you $10 a month, but it's worth it, and it saves you a lot of time. Here is an example of copilot in action in one of my newest projects:

Logic completion:

Function completion:

Even if these are small snippets, over the project they save you a lot of time.

Finale & your favorite extensions

These are my favorite extensions for VS-Code. I hope you found some new extensions that you can use in your projects! Comment down below what your favorite extensions are for embedded development. I hope you enjoyed this article and see you in the next one!

May your code be bug-free!

ATtiny85 Programming: Your Complete Guide with Arduino and PlatformIO!

DarioCasciato — Sat, 05 Aug 2023 13:59:26 +0000

The Pain of Undocumented Programming

I think finding out how to program a new microcontroller for the first time without proper documentation can be one of the most painful tasks in embedded systems. This task mostly involves finding YouTube videos that explain almost your case but not exactly, scrolling through websites and not finding any relevant information, and finally thinking you found the solution, but then an error pops up that has never been recorded in human history, so you don't find anything about it on the web.

That's why I want to close a gap with this article about how to program an ATtiny85 with an Arduino via PlatformIO.

Code Snippets Repository

All code snippets used in this article can be found in the accompanying GitHub repository, making it easy to access.

Disclaimer

This article focuses only on how to program an ATtiny85. So it is not a complete guide on also how to set up and program an Arduino. In this article, I will do all examples with an Arduino Nano.

Overview

These are the general steps on how to program the ATtiny85:

Set up the Arduino as ISP programmer
Wiring up the ATtiny85
Setting up the PlatformIO Project
Program it!

1. Set up the Arduino as ISP programmer

The first step is to modify the Arduino's behavior, transforming it into a capable ISP (In-System Programmer). This step is relatively simple: you just need to upload a code to the Arduino. It doesn't matter if you upload the code with the Arduino IDE or via PlatformIO.

The Code can be found here: Arduino as ISP Code.

After this is done, you are ready to wire up the ATtiny85 with the Arduino!

2. Wiring up the ATtiny85

The wiring requires one additional part: a capacitor with a minimum capacity of 1µF is needed between the Reset and Ground Pin of the Arduino. The capacitor prevents the Arduino from resetting while programming the ATtiny85.

These are the connections:

Arduino	ATtiny85
5V	VCC
Ground	Ground
Digital pin 13	GPIO 2
Digital pin 12	GPIO 1
Digital pin 11	GPIO 0
Digital pin 10	Reset

Here's an illustration of all connections:

Image Sources

Note

Even if there is an Arduino Nano in the illustration, you can use another Arduino (e.g., Uno, Mega, etc.) as long as you use the same digital Pins mentioned above.

3. Setting up the PlatformIO Project

Now comes the important step: setting up the project. Open VSCode (in my case) and access the PlatformIO Home. In the "quick access" tab, select "New Project." There, you'll find three input fields:

Name
Board
Framework

Give your project a suitable name.

In the "Board" input field, type "ATtiny85". You should see one result called "Generic ATtiny85 (Atmel)," and select it. Ensure that the Framework is "Arduino."
Optionally, you can change the Location of the Project on your computer by unticking the checkbox and selecting a location.
If everything is done, click "Finish". PlatformIO will set up the Project, which usually takes a maximum of 20 seconds.

After the Project is set up, the "platform.ini" file should open automatically. If not, you can find it in the main directory of the Project.
In this file, you'll find all configurations for the project, such as how it should be uploaded, which framework it uses, which microcontroller it's for, etc.

This is the critical file that needs to be changed to program the ATtiny with the Arduino. Delete the content of this file, and paste in the following snippet:

[env:program_via_ArduinoISP]
platform = atmelavr
framework = arduino
board = attiny85
upload_protocol = stk500v1
; each flag in a new line
upload_flags =
    -P$UPLOAD_PORT
    -b$UPLOAD_SPEED

upload_speed = 19200
upload_port = COMX ; Set the port to the Arduino COM Port

(You can find this snippet in the GitHub repository)

Here you have to make one customization. In the last line, you need to change "COMX" to the right COM Port of your Arduino. E.g., if your Arduino is connected to the COM Port 3, you have to change it to "COM3."

Now the Project setup is finished, and the ATtiny can be programmed!

4. Program it!

In the src directory, you can find the main.cpp with the basic example code of the Arduino. Write your code into this file, and then you should be able to upload it.

You can upload it in the PlatformIO tab on the left and click "Upload".

The console output should look something like this:

Building in release mode
Checking size .pio\build\program_via_ArduinoISP\firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM:   [==        ]  16.4% (used 84 bytes from 512 bytes)
Flash: [==        ]  15.0% (used 1230 bytes from 8192 bytes)
Configuring upload protocol...
AVAILABLE: stk500v1
CURRENT: upload_protocol = stk500v1
Looking for upload port...
Uploading .pio\build\program_via_ArduinoISP\firmware.hex

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.02s

avrdude: Device signature = 0x1e930b (probably t85)
avrdude: erasing chip
avrdude: reading input file ".pio\build\program_via_ArduinoISP\firmware.hex"
avrdude: writing flash (1230 bytes):

Writing | ################################################## | 100% 1.81s

avrdude: 1230 bytes of flash written
avrdude: verifying flash memory against .pio\build\program_via_ArduinoISP\firmware.hex:
avrdude: load data flash data from input file .pio\build\program_via_ArduinoISP\firmware.hex:
avrdude: input file .pio\build\program_via_ArduinoISP\firmware.hex contains 1230 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.88s

avrdude: verifying ...
avrdude: 1230 bytes of flash verified

avrdude: safemode: Fuses OK (E:FF, H:DF, L:62)

avrdude done.  Thank you.

You have successfully programmed your ATtiny85!

Finale

Thank you for reading this article! i hope it has been helpful for you with the programming of your ATtiny. I have plenty of other ideas for this series, so stay tuned!

Feel free to leave any comments or questions below, and I'll do my best to help you out!

May your code be bug-free!

Bits and Bytes: A Comprehensive Guide to Bit Manipulation

DarioCasciato — Thu, 23 Feb 2023 12:20:25 +0000

Ah, bit manipulation. Another classic when learning to develop embedded software. It saved me half of my lifetime once when I found out that I could concatenate values that are saved in an array. This was the piece of code:

unsigned long UID = 0;

UID = (tempUID[0] << 24) | (tempUID[1] << 16) | (tempUID[2] << 8) | tempUID[3];

This is an example of bit manipulation. The tempUID array holds one byte in every index. To concatenate them, you can use bit manipulation like this one.

It looks complicated at first, I know. But after this article, you will exactly know how this works and feel like this (this was my case):

What is Bit Manipulation?

Bit manipulation is the process of using bitwise operators to manipulate individual bits within a number or value. It is very powerful when you have to make very specific operations.

It's not to be confused with logical operations, which work on boolean values (e.g. true/false).

So let's get straight into it!

Operators

There are six different operators, of which the last two are very similar, to do bit manipulation. These are the operators:

AND Operator ( & )

The bitwise AND operator, as it is in the name, sets the bit to "1" if the compared bits are both "1".

Input A	Input B	Output
0	0	0
0	1	0
1	0	0
1	1	1

This operator is used for bit-masking. With bit-masking, you select specific bits to be read. Here is an example:

result = address & 0xF0 // 0xF0 -> 11110000b

With this mask (0xF0), the first four bits from the right do not have the possibility of becoming '1' because with the AND operator, both bits must be '1' to obtain a '1'.
So if address, for example, is 10100110, the result would be 10100000.

OR Operator( | )

The bitwise OR operator sets the bit to '1' if at least one bit is '1'.

Input A	Input B	Output
0	0	0
0	1	1
1	0	1
1	1	1

This operator is used a lot for combining values or concatenating them (for concatenation you would also need bit-shifting).

test |= 0x80 // 0x80 -> 10000000
test = test | 0x80 // same result

This will set the 8th bit of the variable 'test' to '1', regardless of the value of 'test'.

XOR Operator ( ^ )

The bitwise XOR operator is a very interesting one. In my previous article, I mentioned that this operator can be very powerful. The XOR operator sets a bit to '1' if the two compared bits are unequal.

Input A	Input B	Output
0	0	0
0	1	1
1	0	1
1	1	0

There are many different use cases for the XOR operator, such as encryption with a key, toggling, or change detection. But there are many more. I used the change detection for Edge detection. In this example, we are going to toggle values:

value = value ^ 0xFF // 0xFF -> 11111111

Every bit in value that is a '1' will turn to '0', since 1 XOR 1 will result in 0.

Every bit in value that is a '0' will turn to '1', since 0 XOR 1 will result in 1.

NOT Operator ( ~ )

The bitwise NOT operator is the easiest one to understand. It does exactly the same as in the example above for the XOR. It inverts every bit. The syntax is very simple.

Input	Output
0	1
1	0

This operator is very useful; for example, if you need to initialize a value inverted, you can use the bitwise NOT operator.

value = 0xF0; // 0xF0 -> 11110000

value = ~value;

After the operation, value is 00001111.

LEFTSHIFT Operator ( << )

Now the interesting ones begin. These operators do exactly the thing they are called. They shift! You only need to specify how many bits the value should be shifted.

As mentioned in the first example, this is very useful to concatenate values.

value = 0x0F << 2; // 0x0F -> 00001111

You have 2 inputs with this operator. The one on the left is the value that needs to be shifted, and the right one specifies how many bits it needs to be shifted. So the result of this example would be 00111100. You can also see that the new bits that are pushed in from the right are '0'. This is default and cannot be changed.

RIGHTSHIFT Operator ( >> )

The right-shift bitwise operator also shifts bits. The only difference is that it shifts bits to the right.

Also, this one can be used for concatenating values. It also comes in handy in encryption. You can shift a value in a direction by a known amount of times. Combining it with other operators makes this extremely powerful.

value = 0x50 >> 2; // 0x50 -> 01010000

I think you can already guess the result. If we shift 0x50 (01010000) to the right by 2, we get 00010100.

Understanding the first example

Now that the theoretical part is done, we should be able to understand the first example of bit manipulation I made. The goal is to concatenate them all together to get one value that contains all other values.

unsigned long UID = 0;

UID = (tempUID[0] << 24) | (tempUID[1] << 16) | (tempUID[2] << 8) | tempUID[3];

To illustrate this, we assign a value to each array index:

                    //  HEX     BIN
tempUID[0] = 0xA3;  //  0xA3    10100011
tempUID[1] = 0xFF;  //  0xFF    11111111
tempUID[2] = 0x67;  //  0x67    01100111
tempUID[3] = 0xF0;  //  0xF0    11110000

This bit manipulation involves two steps. The first step is to shift the values, and the second step is to combine them using the OR operator.

We need to shift all the values by the number given in the calculation:

tempUID[0]:     10100011 00000000 00000000 00000000 // shifted by 24
tempUID[1]:              11111111 00000000 00000000 // shifted by 16
tempUID[2]:                       01100111 00000000 // shifted by 8
tempUID[3]:                                11110000 // not shifted

The second step is to combine them using the OR operator:

UID = 10100011 11111111 01100111 11110000

So, That's it! When you first look at a calculation involving bit manipulation, it can be confusing. However, when you split up the whole process into steps, it becomes more comprehensible.

Finale

Thank you for reading! I hope you learned something new from this article. The series will continue soon with a new article about structuring your firmware.

Feel free to leave any comments or questions below, and I'll do my best to help you out!

May your code be bug-free!

Edgy Firmware: The Only Edge Detection Solution You'll Ever Need

DarioCasciato — Wed, 22 Feb 2023 09:49:30 +0000

My first experience

I think this topic is a very classic, when you are writing your first more complex embedded program (rather than a blinking LED). E.g. You want to count how many times a button has been pressed. This was one of my first tasks I was ever given, when I was learning firmware development.
I thought that it was as easy as:

if(digitalRead(BUTTON)) counter++;

But this method resulted in the counter incrementing infinitely in a matter of seconds because it checked if the button was pressed and not if there was a change from not pressed to pressed.

In my apprenticeship as an electronics engineer, I had a teacher that spoke more about his political opinions rather than coding. But the few times he talked about coding, he really taught us something. He once taught me five lines of code that changed the way I see the world and how I write code. These are the following:

btn.old = btn.act;
btn.act = INPUT;
btn.edge = btn.act ^ btn.old;
btn.edge_pos = btn.edge & btn.act;
btn.edge_neg = btn.edge & btn.OLD;

I know this does not look like much, but after you read this article, you will realize that this is the perfect edge detection method.

How to set it up

Struct

To make it as much "clean code" as possible, it's very nice to use a struct for this case.

typedef struct
{
    uint8_t act;
    uint8_t old;
    uint8_t edge;
    uint8_t edge_pos;
    uint8_t edge_neg;
} edge_t;

Detection

Now the five sacred lines of code follow. They are inserted at the top of the while or infinite program loop. Don't forget to initialize the edge_t struct:

int main()
{
    edge_t btn = {0};

    while(1)
    {
        btn.old = btn.act;
        btn.act = digitalRead(BUTTON);
        btn.edge = btn.act ^ btn.old;
        btn.edge_pos = btn.edge & btn.act;
        btn.edge_neg = btn.edge & btn.OLD;


        // Inifinite loop, user code
    }
}

In this example, I am reading the input from a button that is connected to one of the digital pins on an Arduino.

Now we are set! At the beginning, it looks a bit clunky, but you will understand how easy it works below.

How to use it?

If you only have one button in your circuit/project, it's going to be incredibly easy to use this edge detection.

We have the possibility to detect/get the following properties of the button:

The current state
The state it had in the previous cycle
Change of state
Positive edge
Negative edge

Here is how you can detect/get these properties:

The current state

if(btn.act)
{
    Serial.println("Button is pressed!");

    //Detects if the button is pressed. equivalent of "if(digitalRead(BUTTON))"
}

The button state in the previous cycle

if(btn.old)
{
    Serial.println("Button was pressed last cycle!");

    //Detects if the button was pressed the cycle before
}

Change of state

if(btn.edge)
{
    Serial.println("Button State changed!");

    //Detects if the button changed from not pressed to pressed, and vice versa
}

Positive Edge

if(btn.edge_pos)
{
    Serial.println("Button pressed down!");

    //Detects if the button changed from not pressed to pressed (Positive Edge)
}

Negative Edge

if(btn.edge_neg)
{
    Serial.println("Button released!");

    //Detects if the button changed from pressed to not pressed (Negative Edge)
}

How does it work?

Now follows the explanation of these code lines:

btn.old = btn.act;
btn.act = digitalRead(BUTTON);
btn.edge = btn.act ^ btn.old;
btn.edge_pos = btn.edge & btn.act;
btn.edge_neg = btn.edge & btn.old;

To illustrate the states of the boolean values, I will be using Level Diagrams, where each square represents one iteration of the infinite program loop.

btn.act

btn.act = digitalRead(BUTTON);

(In this example, we are again reading a button input that is connected to a digital pin of an Arduino)

The act value is straightforward to understand, as it always has the same value as digitalRead(BUTTON). Throughout the rest of the explanation, I will refer to the current button state as act.

btn.old

btn.old = btn.act;
btn.act = digitalRead(BUTTON);

The old value refers to the state of the button in the previous iteration of the program loop. It is always the state of the button in the previous cycle. We save the value act into old, and then first we get the new value for act.

btn.edge

btn.edge = btn.act ^ btn.old;

Now it gets interesting. The "^" operator, also known as the XOR operator, detects whether two values are different. It returns true if the values are different and false if the values are the same. So now we have the possibility to detect a change in the state of the button, if we compare act and old.

btn.edge_pos

btn.edge_pos = btn.edge & btn.act;

So the edge_pos is the one we are all looking for! This detects the positive edge, or the change from not pressed to pressed.

We compare the value edge and act with an AND operator. The AND operator returns true if both values are true.

If edge is true, we know that we had a change in the button state. The change is detected if act and old are unequal.

If we have a change from not pressed to pressed, act is true and old is false. If we have a change from pressed to not pressed, act is false and old is true. That's why we can compare edge and act with the AND operator to get the positive edge.

btn.edge_neg

btn.edge_neg = btn.edge & btn.old;

There are cases where you have to read the negative edge of a signal.

As I explained before, if we have a change from pressed to not pressed, act is false and old is true. So now we can compare edge and old with the AND operator to get the negative edge.

More than one button?

So, you have more than one button in your project, and every button needs edge detection? Don't think that you have to do this:

edge_t btn1 = {0};
edge_t btn2 = {0};
edge_t btn3 = {0};
edge_t btn4 = {0};
...

Since every value in the struct is declared as uint8_t, we have 8 bits to use in every value! The only thing we have to do to have more than just one button is to redefine the act value.

I'm going to make an example where I have 8 buttons, and every button is connected to one digital pin of an Arduino from pin 1 to 8:

btn.act =   digitalRead(1) |
            (digitalRead(2) << 1) |
            (digitalRead(3) << 2) |
            (digitalRead(4) << 3) |
            (digitalRead(5) << 4) |
            (digitalRead(6) << 5) |
            (digitalRead(7) << 6) |
            (digitalRead(8) << 7);

My Article about Bit-Manipulation

Now, every bit of act corresponds to one button.

We can't use if(btn.edge_pos) anymore. We need to specify which button we want to detect. This can be done with a bit mask.

I like to create Defines for every button.

//                  HEX         BINARY
#define BUTTON_1    0x01    //  00000001
#define BUTTON_2    0x02    //  00000010
#define BUTTON_3    0x04    //  00000100
#define BUTTON_4    0x08    //  00001000
#define BUTTON_5    0x10    //  00010000
#define BUTTON_6    0x20    //  00100000
#define BUTTON_7    0x40    //  01000000
#define BUTTON_8    0x80    //  10000000

Every value I gave the defines represents one bit for the uint8_t act.

From here, it is straightforward. If we want to detect, for example, the positive edge of the third button, we can do this:

if(btn.edge_pos & BUTTON_3)

With this bit mask, we allow it to detect changes only for the specific bit.

Finale

Thank you for reading! I encourage you to continue exploring this topic further and see how you can apply it in your projects. I am excited to announce that I will be continuing this series on Firmware Basics!

Feel free to leave any comments or questions below, and I'll do my best to help you out!

May your code be bug-free!

Countdown to Chaos: What You Need to Know About the Unix Time Stamp Problem in 2038

DarioCasciato — Mon, 20 Feb 2023 13:04:12 +0000

(Title Picture)

We've heard about the Unix Time Stamp issue that's looming on the horizon. It's a problem that could impact a variety of computer systems in the year 2038, but why is this such a big deal?

Unix Time Stamp: The Basics

To start, let's go over the basics. The Unix Time Stamp is a system that measures the number of seconds that have passed since January 1st, 1970 at 00:00:00 UTC. This system is used by many different computer systems, including Linux, macOS, and various programming languages.

The Unix Time Stamp is stored as a 32-bit signed integer, which means it can only represent up to 2,147,483,647 seconds. This number corresponds to January 19th, 2038 at 03:14:07 UTC. After this point, the Unix Time Stamp will reset to zero and cause a malfunction in a variety of computer systems.

The New Y2K?

The Unix Time Stamp issue has been likened to the Y2K bug, which was a problem that occurred in the year 2000. The Y2K bug occurred because many computer systems used a two-digit representation of the year, which meant they couldn't tell the difference between the year 1900 and the year 2000. This caused a variety of computer systems to malfunction and led to concerns about significant disruption.

In the same way, the Unix Time Stamp issue will cause a variety of computer systems to malfunction after the year 2038. This is because the system will interpret the overflowed value as a negative number, which can cause problems with date calculations, software installations, and other crucial functions.

The Impacts of the Unix Time Stamp Issue

The effects of the Unix Time Stamp issue are difficult to predict, but they could be disastrous. The problem will impact a variety of critical infrastructure systems, including power grids, transportation systems, and financial systems. These systems depend on accurate time measurements to function correctly, and any disturbance could result in significant issues.

Additionally, the problem will also impact a variety of software systems, including web servers, databases, and mobile devices. This could cause crashes, data corruption, and other problems that could have an impact on the user experience.

What Can Be Done?

There are several different ways to address the impacts of the Unix Time Stamp issue. One solution is to switch to a 64-bit Unix Time Stamp, which would allow for much larger values and eliminate the overflow problem. Another solution is to switch to a different system for measuring time, such as the Network Time Protocol (NTP).

However, these solutions are not easy to implement and will require significant effort from software developers, system administrators, and other stakeholders. It's also possible that many legacy systems will not be updated in time, which could lead to widespread disruption.

Conclusion

The Unix Time Stamp issue is a problem that could impact a variety of computer systems in the year 2038. The issue will cause critical infrastructure systems to malfunction and could potentially result in significant disruption. Although there are solutions available to address the problem, they will require a significant effort from everyone involved. As we approach the year 2038, it's important that we take the necessary steps to prepare for this problem and ensure that our computer systems are ready for the next millennium.

(This Article was written with the help of AI)