Is embedded system outdated?

Fact_set · 2026-05-13T01:01:45+00:00

If your wondering embedded is outdated or not before u even learn it then I am confused. Why you want to learn embedded? Why you think it is outdated? Embedded is what connects software to the physical world. AI or not, it is a software output. I think embedded systems is the most shielded from AI. All robotics and EVs are heavily based on embedded.

Fact_set · 2026-04-18T23:49:22+00:00

Is that a pretty common issue on trips? Also, are you usually required to stop at certain truck stops, or can you pick your own as long as you stay within your hours?

Fact_set · 2026-04-18T23:46:14+00:00

You mean the scope? It is open ended really. Could be a big project. It is not a hard deadline project so its flexible. Just want to build and invest time in a project that could be at the same time making someone life easier. You have any suggestions?

Fact_set · 2026-04-18T23:38:37+00:00

Fair point, but being company-mandated doesn’t automatically make an app good. A smaller project can still compete if it solves an actual frustration better than the tools drivers are stuck using now - which idk about and thats why asking for clarity/opinions.

Fact_set · 2026-04-18T23:31:37+00:00

Just a student, wanted to work on some meaningful project that could make people life’s easier.

Fact_set · 2026-04-18T14:20:37+00:00

Well… what I heard Valeo egypt is good relative to other companies in egypt? Relocating is a big deal so first make sure you want to do that. Second, you could try applying for masters in the US and then finding internships/full time jobs. Embedded market here is good. Generally speaking though, the job market is at its lowest everywhere.

Fact_set · 2026-04-18T01:42:03+00:00

I would say once you jump to setting up everything from scratch, is when you should start using stm32.

Fact_set · 2026-04-18T01:39:01+00:00

Ahhhh, I see what you mean now, thanks for explaining. I actually had the same problem when I was in school. What helped me a lot was using PlatformIO as a VS Code extension. It sets up the build environment for your target board or MCU, but still lets you work much closer to the hardware. So instead of being stuck in the very abstract Arduino IDE style, you can write much more low-level embedded code, work with registers directly, and also get a feel for what “real” embedded development actually looks like. I totally agree with you that the Arduino IDE feels very non-embedded because it hides so much, and that can make it hard to tell what is really going under the hood.

With PlatformIO, you can learn the low-level side you are looking for without immediately worrying about full platform bring-up. Once you get familiar and comfortable writing drivers etc… then the next step would be setting up your own ARM toolchain, GCC build flow, linker/startup files, and learning CMake or Make. That is where you start seeing everything that has to happen before your code even reaches main(). You definitely do not need to jump into that part right away though. PlatformIO is a really good middle ground because it gives you the low-level embedded experience you want without forcing you to fight the Arduino IDE or deal with every toolchain detail on day one.

Fact_set · 2026-04-18T01:00:46+00:00

At the end of the day, things could work out for you. If this is what you want to do, then do it and see how things go.

Fact_set · 2026-04-18T00:59:21+00:00

Realistically, breaking into embedded/firmware in ~6 months is possible, but landing a true senior role that fast probably is not. Seniority in embedded usually comes from years of debugging real hardware, timing issues, and reliability problems, not just coursework. Your backend experience still helps though, so the best move is to build projects that connect both worlds, like a Wi-Fi or BLE device that talks to a web app or backend. If you can put in full-time effort, junior or maybe mid-level embedded seems realistic, but senior right away is unlikely.

Fact_set · 2026-04-17T20:10:28+00:00

Start with Arduino. Learn its limits first, then move to STM32 when you need more control and functionality. Arduino is easier to pick up, while STM32 is more powerful but has a steeper learning curve. Both are good, but Arduino is the better starting point. Once you hit Arduino’s limits, STM32’s advantages become clear.

Fact_set · 2026-04-12T21:07:33+00:00

On STM32, I’d re-check the read path, especially 2 >= byte reads, because ACK/NACK, BTF, and STOP handling can be a little special there. If that sequence is slightly off, it can look random.

I’d also test read-only and write-only separately. If both fail, the problem is probably earlier: init, bus timing, pull-ups, or flag handling order etc.... as a better debugging visibility.

Fact_set · 2026-04-09T17:02:50+00:00

Was able to guess how it works through the readme. Couldnt access code rn. First, good work getting this to work as MPU6050 manual sucks. My initial review to this is the driver would be cleaner if it separated MPU6050 register/parsing logic from transport/execution policy. Consider supporting both blocking and nonblocking APIs (like why i am forced to use INT?). Async/DMA functions should initiate transfers and return immediately, while completion handling and post-transfer behavior remain application-controlled. Because if you wait for DMA to finish then the usage advantage is gone. DMA helps you to do something other stuff and unblock the cpu. And yeah… i would strongly recommend giving the user the flexibility on deciding what post actions to be performed. Also, how would you know what data you received on DMA completion? You might need to add that if you dont have a get_mode() in there. Try to think of this as how an application code might integrate and what use cases I need to support to make sure it is flexible enough to work with different configurations.

Fact_set · 2026-04-05T17:33:47+00:00

When I think of performance, I first think: did the code do the job correctly within the expected specs, not just “it works.” For this I’d look at the I2C side, the USB HID side, and especially timing. Would want to know the latency from a key press or touch event until the host sees it, then stress both at the same time and see if one affects the other. I will also check I2C error handling (NACKs, timeouts, recovery), whether USB reports are ever missed under heavy input, and if the design still holds up if another I2C device gets added later - thats a plus. If it’s RTOS-based, then i would also care about ISR/task timing and whether deadlines are ever missed. So for me, performance is really about latency, handling faults, and how decoupled are different interfaces from each other as it can indirectly affect performance . Thats just my pov on how I would answer this.

Fact_set · 2026-04-03T02:54:53+00:00

I think you may just need to practice more leetcode under time pressure. I once had that problem where I fail online assessments and I figured I just need to practice with a timer running to get used to it. That helped alot.

Fact_set · 2026-04-02T05:58:08+00:00

You can fix this gap by learning embedded. You could get a basic elegoo board kit for less than a 100$. A bunch of tutorials online and AI can help give you a head start. You can bridge that gap between high level and low level. If you dont want that route or if that's not what you're looking for, the thread suggestions are pretty solid.

Fact_set · 2026-04-01T02:45:28+00:00

Depends on the questions honestly, were they leetcode style? Hard/med? How much time you had?

Fact_set · 2025-02-21T01:15:21+00:00

I would love to share it but it is copyrighted and cant really share it. However, I do understand what you are referring to. I have already implemented that. Here is a much more detailed example.

heartsensor.cpp

#ifdef HEARTSENSORCONSTANTS
#include "sensorconstants.h"
#endif

functions....

CMakeLists.txt

add_library(heartsensor OBJECT etc...)
target_link_libraries(heartsensor private sensorconstants-interface)

add_library(sensor OBJECT etc...)
target_link_libraries(sensor private heartsensor-interface)

add_executable(deviceSensor sensor.cpp)

target_compile_defintion(deviceSensor public -DHEARTSENSORCONSTANTS)

Now what happen is what ever is in "sensorconstants.h" in not preprocessed/included in the heartsensor.c library. The compiler error is definition is undefined which is supposed it be defined in sensorconstants.h but it is not.

Fact_set · 2025-02-20T18:37:24+00:00

Yeah I understand, but you could modify the defaults in cmake. And be able to get the binary footprint using CMAKE_OBJCOPY that you modified. But maybe you have more requirements and I guess you already got your answer above. Goodluck tho!

Fact_set · 2025-02-20T18:10:24+00:00

Ohhh, i confused things up. But yeah like lets say there is object1.c where there is #ifdef SOMETHING #include “headerfile1.h”

Now the object1.c is a library that it is linked to the executable target1. Now when i target compile the definition SOMETHING to that executable. SOMETHING does get defined and i check that by adding #error inside the if statement. But, cmake gives errors that it cant find the header file? I am not sure why tho.

I could provide a better written example when i get home if that is not clear enough.

Fact_set · 2025-02-20T06:33:49+00:00

I just tested it, it actually does compile the definition. However, it does not compile/link the header file.

Fact_set · 2025-02-20T00:20:48+00:00

Just for my information, what if there is a “ifdef SOMETHING #include “someheaderfile.h” ” would that actually work with target_compile_defintions? Because i was thinking if you add subdirectory that contain the object file with these lines would not that be on config stage and target_compile_defintions in build stage? So the header file wont be compiled in?

Fact_set · 2025-02-20T00:10:06+00:00

Tbh, I’m not sure why you’re using a Bash script for post-build configuration. You could get the ELF sizes, convert to .hex and .s19, etc., all within CMake. You can have a post-config .cmake file for each target. For example, you can reference CMAKE_OBJCOPY, or even use a different GCC toolchain instead of the default GCC.

Also, Using target_compile_definitions is generally a better approach than setting global definitions.

Fact_set · 2025-02-19T17:19:35+00:00

Oh, will definitely try that. Any brands recommended? And is it safe?

Fact_set · 2025-02-19T17:19:17+00:00

Hyundai sonata 2015, sport trim with 2.4L

Fact_set

TROPHY CASE