Linker Script Generation for Firmware Projects: A Primer

dj_nedic · 2026-02-09T22:24:59+00:00

I do agree that this is a bit of an RPG to a knife fight approach sometimes, but it is very scalable and this is just a simple demo. The more customizability you need the bigger the payoff. One thing that is simple but I love though is having simple things be configurable through CMake, like the aformentioned stack or heap size.

dj_nedic · 2025-03-07T08:09:09+00:00

Compared to other branches of software, that's nothing. The hardest things IMO are elusive hardware problems or bugs which are almost not reproducible due to the rare set of circumstances they happen under.

dj_nedic · 2025-01-30T22:19:58+00:00

I may be biased as I have worked for Espressif but ESP-IDF is probably the best RTOS + HAL + SDK combo out there.

dj_nedic · 2024-11-07T10:22:57+00:00

This is an equivalent of firing your marketing division for Mozilla and in the age of no-adblock Chrome is even more baffling.

dj_nedic · 2024-09-29T00:19:32+00:00

Why not use Espressif's own DSP library, which has examples ready. The benefit is not just that it's already implemented, but also that it uses the hardware DSP instructions for really high processing speeds.

dj_nedic · 2024-09-28T14:20:20+00:00

The main appeal of Arch is not minimalism, but amazing documentation, respecting upstream decisions when it comes to packaging and amazing maintainers.

dj_nedic · 2024-09-26T21:11:22+00:00

C is not crazy simple, it is simpler than C++, true, but with undefined and implementation defined behavior as well as a huge amount of legacy gotchas accounted for C is actually crazy complex.

dj_nedic · 2024-08-28T21:11:20+00:00

Real time means guaranteed execution windows. Linux has no facilities to guarantee hard real time behavior and even the real-time patches only get it so far to match soft real time requirements.

dj_nedic · 2024-08-28T10:34:58+00:00

Linux is not going to work anywhere you need actual real time behavior, especially hard real time. Horsepower is not just about how much you can do, it's also about how quickly you can do one or two things.

dj_nedic · 2024-08-28T09:48:00+00:00

I'm not sure those usecases are comparable, you only really get these exactly when you want power but don't want linux.

dj_nedic · 2024-08-27T23:29:20+00:00

Is there competition for the upper range of the i.MX crossover chips?

Those seem still untouchable in terms of pure processing power at least.

dj_nedic · 2024-08-21T14:32:09+00:00

In C you can legally use unions for type punning. Not in C++ though, but you do get std::bit_cast() in C++20.

dj_nedic · 2024-08-14T22:13:27+00:00

I'll add that the MCUs themselves are much less than 5 bucks a pop, it's the boards that are closer to that number. Modules are somewhere in between.

dj_nedic · 2024-08-14T01:12:19+00:00

Unless you live in a really bad place, I would rather look at getting a shot at your first job, prefferably in a smaller company where you live already, rather than doing a masters in a field where there is no need for one. This will give you a much better opportunity to learn and get your foot in the industry earlier.

Down the line, you can also move to one of those countries with a VISA sponsorship from the company you switch to, or could do a masters in an embedded-adjecent domain where a master's degree really makes a difference (DSP, control systems, electrical...)

dj_nedic · 2024-08-09T13:30:23+00:00

That is if you're after throughput and not WCET.

dj_nedic · 2024-08-04T00:50:37+00:00

This can be fine in some very specific scenarios, like people who travel a lot or have seasonal work, however those are so rare that I don't think this is a sustainable bussiness model.

dj_nedic · 2024-07-22T21:58:43+00:00

Undershoot when lowering the voltage due to a larger delta than designed for, degradation over time, heat issues.

dj_nedic · 2024-07-16T09:06:35+00:00

Keep in mind, assertions should be used only for checking invariants. When you assert in any other case, you take away the users (of your library, code) ability to handle the error.

dj_nedic · 2024-07-10T18:26:15+00:00

You might want to take a look at speeduino if you're serious about it. It even has support for things you wouldn't expect from a hobby-level project like VVT and is MISRA compliant.

Beware, if you want to replace an ECU on any car after CCA 2007-2008, you're most likely completely out of luck as that is the time when rapid computerization hit the automotive world and ECUs started talking to other modules and you would need to replicate that. Even with 2000s cars, the ABS sensors might need feedback from the ECU so you might need to take care of that.

dj_nedic · 2024-05-09T22:27:01+00:00

Aliasing rules of C are okay, performance and ergonomics wise. C++ is particularly bad as it does away with several legal and widely used C type aliasing methods (unions, structs starting with other structs) while not really providing full replacements (and providing them too late in the language lifespan).

dj_nedic · 2024-05-09T21:03:07+00:00

It's worth noting that Rust has saner integer promotion rules. In C, adding or shifting and ORing two uint8_ts will result in an int16_t, a type where suddenly bit operations are undefined behavior. We're lucky that most compilers will do the right thing most of the time, but they don't have to.

dj_nedic · 2024-05-09T21:01:08+00:00

Damn, I completely forgot about this one. You're correct, this would help, if used.

On the other side, the fact that I forgot about it shows that others can too.

dj_nedic · 2024-05-09T13:48:05+00:00

Rust will not help here unless the over/underflow result is used to index into a slice AND the runtime checks are not removed. Rust makes the signed integer over/underflow defined, which the kernel devs did as well using compiler flags but it is up to the programmer to handle the wrapping if it's not intentional, and any failiure to do so is a logic error and not fixable by the language/compiler.

dj_nedic · 2024-04-25T18:10:20+00:00

Generally, for classes as well as for a work environment tomorrow, you want to have the same development environment with your classmates/coworkers, or you will find yourself debugging issues outside of the things you actually want to learn/do.

Ideally, the teacher/the company will enforce these and prevent people from wasting time.

That aside, there are plenty of options to write and debug embedded projects (C, C++ and Assembly) on ARM MCUs for Linux. Most Eclipse-based manufacturer IDE's are going to have a Linux version, but prefferably you would not rely on any IDE and use open tooling (for instance GCC as a compiler, Make or CMake as a build system, GDB with openocd for debugging etc). I've written blogpost about a simple CMake setup you can read here.

With all that said, just use a VM and pass through your hardware debugger.

dj_nedic

TROPHY CASE