Code Metal: AI for translating code to hardware

Code Metal 👀 “Code Metal’s technology allows software engineers to write code once, then automatically translate it into any other programming language so they can ship new features faster and to a wider swath of users. Morales, who was previously technology chief at a gaming company, said Code Metal’s offering is particularly appealing to developers working on software to run appliances, consumer electronics, factory robotics, autos and medical devices.”

This is the real way of looking at embedded code (I think the only way) And that is not just talking to the hardware but negotiating with Physics. As developer we all proud ourselves achieving these - - Able to write the cleanest C code - Use frameworks, abstractions But the real world is not so forgiving The product can still fail in the field. Because embedded systems don’t run on the compiler - They run on voltage, temperature, timing, and tolerance. - The GPIO pin doesn’t care how elegant our ISR looks. - It cares whether your pull-up resistor is strong enough. That’s the gap between engineers and real embedded engineers. - The first think in functions. - The second think in faults. Because, Real domain knowledge is never the syntax but it is an intuition: - Knowing that a 20ms delay may hide engine halt. - Knowing why code passes at room temp but fails after reflow. - Knowing that your bus reads junk because someone added extra cable. The static analysis tool can't save us from physics. Only our domain understanding will. Let's bring in the real flavour of being embedded engineer Thank you. ♥️ P.S. Does your code attempts to connect with real life? (AI code, heck with that)

📚 Design Patterns in Embedded C: The “State Machine Struct” In embedded systems, 😡 messy if/else or switch statements are common - but they quickly become unmanageable as complexity grows. A State Machine Struct pattern offers a clean, scalable solution. Steps you need to follow: 1️⃣ Define the State Struct: Encapsulate each state’s behaviour with function pointers typedef struct State {   void ( *onEnter ) ( void );   void ( *onExit ) ( void );   void ( *onUpdate ) ( void ); } State; 2️⃣ Implement Each State: void idleEnter ( void ) { /* setup for idle */ } void idleUpdate ( void ) { /* idle behavior */ } void idleExit ( void )  { /* cleanup */ } void activeEnter(void) { /* setup for active */ } void activeUpdate(void){ /* active behavior */ } void activeExit(void) { /* cleanup */ } State idleState = { idleEnter, idleExit, idleUpdate }; State activeState = { activeEnter, activeExit, activeUpdate }; 3️⃣ Manage Transitions Cleanly: State* currentState = &idleState; void updateSystem ( void ) {   currentState->onUpdate ( );   //Transition example   if ( /* some condition */ ) {     currentState->onExit ( );     currentState = &activeState;     currentState->onEnter ( );   } } Why it matters: ✅ Modular & Scalable – Adding new states doesn’t break existing logic. ✅ Readable & Maintainable – Each state’s behavior is encapsulated. ✅ Testable – States can be unit-tested independently. ✅ ISR-Friendly - Reduces risk in timing-critical embedded code. Combine this with event queues to build event-driven FSMs, enabling highly responsive and predictable firmware; critical for robotics, motor control, or real-time embedded applications. 😊

𝐏𝐥𝐮𝐬𝐚𝐫𝐠𝐬 𝐯𝐬 𝐏𝐫𝐞𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐨𝐫 𝐃𝐞𝐟𝐢𝐧𝐞𝐬 𝐢𝐧 𝐕𝐞𝐫𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐓𝐞𝐬𝐭𝐛𝐞𝐧𝐜𝐡𝐞𝐬 Here is something I learned the hard way a while back. Verification engineers often control their testbenches from the command line, but it’s easy to confuse defines and plusargs. A 𝐝𝐞𝐟𝐢𝐧𝐞 (for example -define CLK_10KHZ) is resolved at 𝐜𝐨𝐦𝐩𝐢𝐥𝐞 𝐭𝐢𝐦𝐞. It decides 𝐰𝐡𝐢𝐜𝐡 𝐩𝐚𝐫𝐭𝐬 𝐨𝐟 𝐭𝐡𝐞 𝐜𝐨𝐝𝐞 𝐚𝐫𝐞 𝐜𝐨𝐦𝐩𝐢𝐥𝐞𝐝. You typically use it to enable or disable interfaces, toggle assertions, or select a DUT variant. Defines control the 𝐬𝐭𝐚𝐭𝐢𝐜 structure of your testbench. A 𝐩𝐥𝐮𝐬𝐚𝐫𝐠 (for example +CLK_10KHZ) is read at runtime with $test$plusargs("CLK_10KHZ"). It affects 𝐬𝐢𝐦𝐮𝐥𝐚𝐭𝐢𝐨𝐧 𝐛𝐞𝐡𝐚𝐯𝐢𝐨𝐫, such as the number of transactions, test or seed selection, or clock frequency. Plusargs control 𝐫𝐮𝐧𝐭𝐢𝐦𝐞 behavior. If your code expects a define but you pass a plusarg, the testbench will compile but nothing will change. You’ll waste time debugging something that never even ran. In short: Defines = compile-time switches Plusargs = runtime controls Different purposes, similar look, easy to mix up. Nightmare to debug in case you are not aware of these differences. #verification #debugging #learning #programming

I haven't shared updates on our core Dystr product recently because, for the past several months, we've been completely reimagining what Dystr could be and identifying the right surface for engineers who build hardware. The tools engineers use today weren't built with them in mind. Most are cobbling together Python scripts, datasheets, Excel calculations, and CSV parsing to make sense of results and share them with stakeholders. The new Dystr is a single engineering surface to analyze hardware data, generate reports, collaborate with teammates, and maintain the context of prior work, so you spend less time on repetitive, non-value setup. Interested in a sneak peak? I’m especially interested in chatting with my connections building complex hardware that work with a ton of data e.g. test engineers, design validation managers, manufacturing quality folks. Drop a comment or DM if you're game to try.

🚀 Ever wondered what actually happens when you “𝗰𝗼𝗺𝗽𝗶𝗹𝗲” 𝗲𝗺𝗯𝗲𝗱𝗱𝗲𝗱 𝗖 𝗰𝗼𝗱𝗲? 🧠 The toolchain goes through 𝗺𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝘁𝗿𝗮𝗻𝘀𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝘀𝘁𝗮𝗴𝗲𝘀 before your code runs on the microcontroller. Let’s break it down, step-by-step 👇 1️⃣ 𝗦𝗼𝘂𝗿𝗰𝗲 𝗖𝗼𝗱𝗲 (.𝗰)   • Human-written code in C. 2️⃣ 𝗣𝗿𝗲𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 (.𝗶)   • What happens: Expands #include, macros, removes comments.   • Command: arm-none-eabi-gcc -E hello.c -o hello.i 3️⃣ 𝗖𝗼𝗺𝗽𝗶𝗹𝗮𝘁𝗶𝗼𝗻 (.𝘀)   • What happens: Converts the preprocessed C code into assembly code (syntax + semantic checks).   • Command: arm-none-eabi-gcc -S hello.i -o hello.s 4️⃣ 𝗔𝘀𝘀𝗲𝗺𝗯𝗹𝘆 (.𝗼)   • What happens: Converts assembly into machine code, producing an object file (not executable yet).   • Command: arm-none-eabi-gcc -c hello.s -o hello.o 5️⃣ 𝗟𝗶𝗻𝗸𝗶𝗻𝗴 (.𝗲𝗹𝗳)   • What happens: Combines object files + startup code + libraries → executable.   • Command: arm-none-eabi-gcc hello.o -T linker_script.ld -o hello.elf 6️⃣ 𝗟𝗼𝗮𝗱𝗶𝗻𝗴   • What happens: The .elf is not flashed directly. The flash tool converts it into a flash-friendly format (.bin or .hex), then writes that image into the MCU’s flash memory.   • Flash tool examples: OpenOCD, ST-Link Utility and J-Link Commander   • Command (to convert to .bin): arm-none-eabi-objcopy -O binary hello.elf hello.bin #EmbeddedSystems #CompilationStages #FirmwareDevelopment #ARM #Microcontrollers

Using coding agents effectively is about brute-forcing. Your task is turn tedious coding tasks into something than be brute-forced by $5 worth of GPU time. You are setting up a loop which an agent can pass/fail itself against, and churn the loop until it passes.

✅ ISO 26262 ASIL D qualified for Rust and C/C++ ✅ A complete MetaWare ecosystem, including optimization libraries and math functions. ✅ Support to model-based development together with MATLAB ✅ Multi-architecture support: optimized for a wide range of automotive platforms ✅ Future-ready for SDVs: safe, secure, and efficient development for distributed and mixed-architecture environments

"The Bug That Wasn’t in the Code" Last week, we spent three nights chasing a bug in an embedded board that refused to boot properly. We checked - every line of firmware - probed every pin - even swapped the MCU twice. "Still dead." At 1 a.m., our intern quietly said: Could it be the reset switch? It felt a bit off BUT It was. The mechanical switch had oxidized, a fraction of a milliohm too high for the MCU’s startup current. Not a software bug. Not a design flaw. Just… life and humidity doing their thing. That night, I realized something. We engineers talk about precision, logic, and control. But embedded systems aren’t just lines of code and copper traces, they’re stories of imperfect materials, human oversight, and quiet intuition. Sometimes the real debugging isn’t about the system. It’s about slowing down enough to listen not to the compiler, but to the silence between blinks. Because the smartest tool in embedded engineering is still a patient human who refuses to give up at 1 a.m. #HardwareDesign #IoTDevelopment #EmbeddedSystems #Debugging #DiverseAutomation

Big news for CompactRIO users! We’ve just released a new version of Symplify Now! now fully compatible with NI CompactRIO 904x systems. This update is all about making real-time testing, headless monitoring and control easier without writing a single line of code. What’s new? - Trigger-based datalogging on AI modules - CAN signal recording via NI XNET - Python integration for controls and data processing Whether you're running field trials or monitoring industrial systems, Symplify Now! helps you deploy headless applications in minutes. And if you need more than the basics, you can dive into the LabVIEW source code to tailor the system to your exact needs. You can even logic in the FPGA. Built for engineers. Ready for the field. If you're working with CompactRIO and want to simplify your setup, explore what Symplify Now! can do. Reach out to your NI or Testforce account manager to learn more or request a demo. Let’s simplify testing—together.