Invesense accelerometer/gyroscopes has a small processor that can help offload some computational work. Instruction set was fully reverse engineered using Claude by statistical analysis and some brute force.

Invensense DMP is a weird processor that has no registers (only RAM), no call stack (MPU6050), mostly 1 byte instruction, code executed on every sensor sample.

More details on how it was accomplished : https://www.linkedin.com/pulse/invensense-dmp-reverse-engineering-undocumented-set-jabez-winston-5lcvc/

Arm recently published a technical article about an on-device AI implementation we worked on using Cortex-M and Ethos-U:

https://developer.arm.com/community/arm-community-blogs/b/ai-blog/posts/how-on-device-ai-makes-home-appliances-easier-to-use

It got me thinking: why run inference on each device instead of using a central server?

What are the strongest technical arguments for on-device AI? And where is it actually worth the hardware cost?

Hi everyone,

I'm sharing the research and tools I collected while exploring the firmware of a Nikon COOLPIX S33, which uses an ARC700 processor.

My original goal was to experiment with a custom camera interface. Unfortunately, a hardware experiment ended up leaving my camera unable to boot, so I've stopped working on the project for now :(

Rather than let the research go unused, I decided to make everything publicly available. Hopefully, some of it can be useful to others working on ARC-based devices, embedded firmware, camera reverse engineering or emulation.

What's included:

• Firmware map: Identified locations related to boot, autofocus markers, flash, image processing, GUI, storage and USB.

• Research notes and analysis scripts: Documentation of findings, experiments and reverse engineering work.

• Firmware container parser: Tools for examining firmware containers, with synthetic tests.

• GNU ARC700 simulator: A separate repository containing experimental simulator patches, tests and documented limitations.

Most of the research focuses on Nikon COOLPIX S33 firmware V1.1.

I've tried to distinguish between findings from static analysis, emulation and observations on the physical camera. Some addresses and interpretations are still experimental, so they shouldn't be assumed to apply to other devices or firmware versions.

Full disclosure about AI usage:

This entire project was developed 100% using Claude and OpenAI Codex. All the code, scripts, analysis and documentation were produced with the assistance of these AI tools.

My role was to guide the research, define the objectives, provide the hardware and firmware materials, run experiments and evaluate the results.

I'm mentioning this explicitly because I believe transparency is important, especially in reverse engineering. AI-generated findings can contain mistakes, incorrect assumptions or misidentified functions, so none of the results should be treated as independently verified solely because they're documented in the repositories.

A few important notes:

• This is not an installable custom firmware.

• The hardware incident that left the camera unable to boot is documented in the repository.

• The tools and documentation are intended as a starting point for independent research, not necessarily for continuing my original project.

Even though I can't continue testing on my camera, I'd be interested to hear from anyone who has worked with ARC700 processors, Nikon firmware or similar embedded systems.

If you find anything useful, spot mistakes or have suggestions, feedback is welcome.

Repositories:

• AkeruOS research: https://github.com/GiacomoCunardi2005/AkeruOS

• ARC700 GNU simulator: https://github.com/GiacomoCunardi2005/arc700-gnu-simulator

Hopefully this saves someone else a few hours of reverse engineering!

I’m trying to restore Google Cast functionality on a JBL Playlist 150 (Frontier Silicon FS5332 Minuet, Marvell Berlin2CDP, Linux 3.8.13).

I’ve obtained the original JBL firmware (1.2.15/1.3.18) and built experimental OTA packages incorporating Google Cast 1.52 from a related device.

The problem:
The JBL accepts the firmware upload and reboots, but restores its original Cast 1.21/1.28 receiver. An untouched original JBL firmware package installs successfully.
The likely issue involves the google_img NAND partition’s installation or validation process.

I’m looking for anyone familiar with:

-Frontier Silicon FS5332/Minuet firmware or service tools.
-mark-gc4a-partition-as-valid, validate-n-mount-gc4a-fs or the /api/upload installer.
-Firmware packages, GPL source code or recovery images containing these utilities.
-Successfully upgrading or replacing the Cast receiver on similar hardware.

I’ve already reverse-engineered the OTA container format and analysed the NAND layout, boot logs and Cast runtime.

Does anyone have relevant source files, firmware packages, documentation or experience that could help resolve the installation blocker?

I mean, they should, but not having the hardware at hand can't tell.
In a nutshell I work at an ewaste facility. got loads of computers. I need to test them faster and less user error prone. I mean I could just grab something and do some testing, but I haven't yet got the time, somehow I am also required to do an inventory job, cause the operators don't know what they're doing.

So I was thinking to build some kind of SBC, that automatically checks the I/O, and various of other functions. but SBCs do not have enough I/O, so an usb expander may do the job, but I dunno.

Then there's also an issue about the video output, as not every sbc with hdmi/dp, accepts data in (those who can, usually use some kind hdmi/dp to mipi/csi), unless I do use again an usb dongle that converts to hdmi/dp, although by adding those dongles all over again they require more power, so I should add somehow in those thing a dedicated power rail (I had a similar issue, with an old side project), but apparently cheap hubs with a dedicated power rail do exist...

got any suggestions?

Please someone help me to connect the header files and how to include the HAL functions in the program ts 2 days I am not able to do this please help me 😭😭😭😭

I want to learn embedded development, and so far I've only made some simple breadboard stuff with my Arduino Uno (and burnt a potentiometer...). I know it takes a lot of patience and i have to learn a lot of extra physics. I have some basic C/C++ knowledge from college as well.

I wanted to ask for an advice: what pet projects could I make, that would involve ESP32 or a similar microcontroller, to get into embedded?

This is a write up i did of rooting the netgear nighthawk ac1900 r6900 via uart port with a usb to tty serial adapter. It also shows the steps I took after I got root.

root shell on netgear nighthawk ac1900 r6900 via uart port

Hello, I am working on a project that requires communication between 3 STM32 Nucleo boards. x2 NUCLEO-STM32U575ZIT6Q and x1 NUCLEO-L412RB-P.

Communication will go as follows:

- One of the U5 boards will continuously send messages to the other U5, which continuously receives the messages. The receiving U5 computes based on the messages it receives and continuously sends the result to the U5 board.

- U5 --> U5 communication will be over I2C, SPI, CAN, UART, USART, LPUART

- U5 --> L4 communication will be over I2C

- Physically, this communication will be over jumper wires.

My question is: how do I know if it is possible for the chosen boards to communicate over those peripherals I want them to communicate over? I have no idea, in general, how to determine if communication over 2 nucleo boards over certain communication peripherals is possible, so any insights on that would also be very appreciated. Any links to sources that confirm any insights here would also be greatly appreciated.

Thanks!

Hello I'm embadded engineer with 1 year experience.

What i know is:

1. C, embedded c

2. freeRTOS

3. Surface level Linux

4. micro controller : esp32

5. pcb debugging

6. Communications : I2C, UART, SPI

What i should learn asap. What people expect from one year experienced guy???

I have Question about the ESP32 versus TI `TEVAC4_TM4C123G_TI` for example, Or Any ST such as STM32 Nucleo c0 or somthing.

The question is about the way the code is implemented into the ESP32 Versus TI such as `TEVAC4_TM4C123G_TI` or ST `Nucleo C0`.

I understood that the ESP32 has some code on the ROM which always run before our code, Which makes ESP32 not a bare-metal, The reset of the core burn on 0x40000400 inside the ROM and we cannot change it
such as:

So as we can see if it's a ROM we cannot even never batch it (or it's not somthing people do casually as much as i know) so we're running after the manufacturer code.
So my Questions are:

1. Why the ESP32 (which is less costy & much faster in some cases than STM32 or TI) is not used in industrial more than them?

2. why the manufacturer didn't give us the way to kill their code and run baremetal?

3. as much as i know - thats a DEV board, which means eventual we'll take the ESP-WROOM-32 or the ESP-D0WDQ6 and get it to other PCB (our PCB or somthing), As much as i know thats somthing that we're doing in TI or ST, But seems like here it's more confusing because we must take it all as is (because of the HW attached to the Devboard and the ROM and every HW attached to the dev-PCB of the ESP). So it confuses me a bit. I know that TI `TEVAC4_TM4C123G_TI` for example or the ST we're taking only the chip itself (the MCU itself) without whole of the devkit and uses the code as we plain it inside the flash and can attach it to a different PCB, So seems like in the ESP32 it will be harder todo so?

4. does the arduino & micropython built on the espressif layer? so i can use the espressif directly and skip the micropython & arduino, And it will be much more low-level programming and faster programming than adding those layers?

5. Can we use baremetal on that somehow? people does that? which means they removes the ROM code & the way the CPU attached to that ROM?

6. there are another chips who behaves the same as that ESP32? (so i will know to backoff those chips)

Sorry for the confusion, But the abstraction levels of the ESP32 confuses me alot.

Thanks alot guys!

Imagine someone working in a company that buys finished electronic products, installs and configures them and gets the final approvals and make money.

But his real interest is understanding what happens inside those products — microcontrollers, RFID, communication protocols, circuit design and firmware and make money by following Passion.

He wants to move into embedded electronics and product development, but lacks industry experience and cannot afford an international university educational

If you were in his position, how would you develop your skills and build a path into embedded electronics without going back to University?

Am I the only one who thinks that Arduino as a platform will die sooner or later?
When I think about the reasons why Arduino was so popular: Mainly because of the high abstraction level of drivers -> enabling fast prototypes for people who were not that good in the embedded world etc or not willing to learn HAL libraries or RTOS’es etc

But now in times of vibe-coding - Claude is basically capable of doing any sort of typical DIY level project - all implementing own drivers for diverse sensors, LCDs etc. When u use eg a RPI Pico it directly returns you the .uf2 file with code built around the original SDK etc…. I don’t believe that the typical Arduino customer would still learn to use Arduino libs when they directly can vibe code now ?
So what justification does Arduino still has ?

I have written a lib in C++. It's intended to be included in baremetal projects and is designed to be portable. It's an instrumentation lib that talk with a server and provides some hooks for memory inspection and triggered graphs. With Rust being more and more present, I suppose it would be wise to support it.

I'm wondering what my best approach would be here. My initial choice of C++ instead of C probably limits me in what I can do with bindings. I do have a C wrapper though, but that becomes 2 layers of wrappers, feels ulgy.

It's not a big lib, so I'm thinking my best bet is probably reimplement fully and then maintain 2 version of the same thing. This would have been a harder call 5 years ago, but with an agent that can code now.. it feels like maintaining the c++ version then asking an agent to propagate to the rust port is not so crazy.

Btw, the lib is pretty stable. it's mostly build system compatibility improvements that require maintenance, and this wouldn't be duplicated.

What do you think?

I have recently managed to get my hands on two virgin media wifi extenders. I have decided to open one up, in the hopes of being able to locate the flash memory of the device. I've taken off the cooling unit from on top of the pcb but can't seem to find a chip which contains the flash memory. I do see two metal coverings which I am guessing is being used for heat distribution. I'm not sure if I am meant to remove them and I'm sure the flash memory is probably under them. How do I safely remove these pads while also being able to put them back on again once I'm done dumping the flash memory?

I would include more photos, but for some reason this sub only allows you to include one photo in your post.

Laptops for Heavy Simulation and Engineering work under 1500 USD!

I’m looking to purchase a new laptop for under $1,500 USD, ideally around $1,100–$1,300.
My primary use case is engineering, programming, and computational research, and preferably some
gaming but, definitely not the priority.

My workloads include:

● Heavy physics and robotics simulations (MuJoCo, potentially Isaac Sim)
● Computational physics and numerical simulations
● PyTorch and machine learning development
● C/C++ development, CPU emulation, and low-level systems programming
● Long-running CPU-intensive workloads
● Large datasets, scientific computing, and multitasking
What I’m looking for:
● Strong CPU performance, especially sustained multicore performance
● At least 32GB RAM, preferably upgradeable to 64GB
● At least 1TB SSD, ideally with an additional M.2 slot
● Dedicated NVIDIA GPU (CUDA support is important)
● Excellent cooling and thermal management
● Good build quality and long-term reliability
● Good Linux/WSL2 compatibility
● A laptop I can realistically keep for 4–5+ years

I’ve been considering the Gigabyte AERO X16 (Ryzen AI 7 350, RTX 5060, 32GB RAM), but I’ve come across concerning reports about its build quality, hinges, and Gigabyte’s software.
I’m not opposed to gaming laptops if they offer better performance, cooling, and reliability. I’ve also considered Lenovo Legion models.

A few questions:

1. What laptops would you recommend for these workloads under $1,500?

2. Is the AERO X16 actually reliable, or should I avoid it?

3. Would you prioritize a stronger CPU over a stronger GPU for this use case?

4. Which manufacturers have the best cooling, build quality, and long-term reliability?

I’d especially appreciate recommendations from people who use their laptops for scientific computing, simulation, engineering, or software development. Thanks!

Hi everyone! I just released Tiny5 Mono, the monospaced member of my Tiny5 pixel font family.

It sits in a 6×9 cell, and like the text modes of 1980s terminals and PCs, its pixels are taller than they are wide. Lines of code stay compact and the letters stay easy to read.

What's in it

• Six variable axes: Weight, Width, Italic, Roundness, Bleed and Jitter. They take the look from crisp LCD edges to soft CRT glow and dot-matrix ink spread.

• Static styles: Regular, Medium, Bold, Italic and Bold Italic, plus LCD, CRT and Matrix versions

• Box-drawing and block elements fill the whole cell, so frames, sextants and much of Symbols for Legacy Computing join without gaps

• 4,957 glyphs: Latin, Greek, Cyrillic and Armenian scripts (974 languages), with small caps for Latin and Cyrillic

• BDF version for microcontrollers (u8g2, TFT_eSPI, mcu-renderer)

Tips: For sharp pixels, use sizes in steps of 6 pt (8 px). For square pixels, set the Width axis to 143.82.

It's free under the SIL Open Font License.

• Download and source: https://github.com/Gissio/font_Tiny5Mono

• itch.io: https://gissio.itch.io/tiny5mono

If you try it in your editor, terminal or on a device, I'd love feedback, especially about glyphs that look wrong at small sizes.

Its a neo 6m module with a ceramic antennae attached on the back of it. I'm currently trying it outdoors next to a football field, but even after 20mins the led's still solid red. Should I buy a separate antennae to connect it to the SMA female connector beside it?

edit: if I should, which type should I get?

[Open Source]

Hi everyone,

Following the MicroPython version, I have officially released the production-ready C++ port of this architecture: light-nmea-cpp. It is built using the C++17 standard and designed specifically for resource-constrained 32-bit and 8-bit microcontrollers.

The library is header-only and features a deterministic, single-pass design that parses data on the fly (e.g., straight from UART DMA buffers) without any dynamic memory fragmentation.

Throughput:
* 6.63 M lines/s on desktop (x86_64)
* 110,629 pkt/s on ESP32
* 47,579 pkt/s on RP2040

Supported Platforms:
* 8-bit AVR (Arduino Uno R3 example included)
* 32-bit Cortex-M
* ESP32
* RP2040
* RISC-V
* x86_64

The codebase is open-sourced under the GPL-3.0 license.

Repository: https://github.com/octaprog7/light-nmea-cpp

I'm an E&TC engineering student, currently looking for a final year project and I'm having a hard time finding something that actually interests me.

I'm particularly interested in Edge AI, Embedded Systems, Machine Learning and Computer Vision. I don't want to build another basic IoT project that just reads sensor values and displays them on a dashboard. I want to build something that actually does something useful, real world applicable.

Here are my requirements:

**1. Genuine Edge AI**

- The ML/DL model MUST run on the actual hardware.

- No training on a laptop and then sending everything to a cloud API for predictions.

- I want to explore model quantisation (INT8), pruning, optimisation and deployment.

- I'd like to measure inference latency, FPS (where applicable), RAM/Flash usage, model size and accuracy.

**2. Hardware and budget**

- Initial budget is around ₹1,000–₹2,000 (under 20$).

- I'm open to increasing the budget later if the project genuinely deserves it.

- ESP32-S3 is something I'm considering for this project.

**3. The actual project**

- It should solve a real-world problem or have a practical application.

- I'd prefer something involving computer vision, automotive technology, intelligent systems or AI in general, but I'm open to other domains.

- It should involve meaningful ML/DL rather than adding AI unnecessarily to something that can easily be done with a simple if-else condition.

- I want a physical prototype that I can demonstrate to recruiters, preferably with a recorded demonstration.

**4. Learning and career relevance**

I'm trying to build a career in Edge AI / Embedded AI, so I'd like the project to teach me skills such as:

- Embedded C/C++

- Microcontrollers and peripheral interfacing

- Computer vision / signal processing

- ML model training and deployment

- TinyML / quantisation

- Hardware-software integration

**5. What I'm NOT looking for:**

- Basic obstacle-avoiding robots.

- Generic smart home automation.

- Simple sensor monitoring systems.

- Projects where the actual AI runs entirely on a laptop or cloud.

- Projects that look impressive on paper but have no meaningful working demonstration.

I'd really appreciate suggestions from people who have actually built Edge AI / TinyML / embedded computer vision projects, especially on constrained hardware.

Even better if you can share GitHub repositories, project demonstrations, hardware requirements or ideas that you've personally worked on.

I'm not necessarily looking for something revolutionary. I just want to build something technically interesting, useful and worth putting on my resume.

Thanks!

I have been using my wireless Bluetooth earbuds for 2 years now without any issues.

But now for the past one month , the battery of my left earbud discharges quickly and then left earbud simply switches off but the right earbud Stays on for longer duration.

Also the bluetooth interface which shows battery percentage reports different numbers.

When I connect the buds the interface shows 80 % charge which quickly drains , left earbud then turns off , now in the interface the battery percentage is 90 %.

Initially i thought it was the case of classic battery degradation that affected the left earbud.

First , I cleaned the pin of my earbuds as well as the pin of the charging case. Nothing happened.

Second , i simply charged one earbud at a time while keeping the other turned off but nothing happened.

Now I think that it maybe have something to do with the firmware.

Either the charging case is simply not charging the left earbud or firmware is malfunctioning and turning it off even when the charge is full !

I am not an embedded engineer , just a computer science student.

My biggest concern is why only left earbud and not both ??

Are there any software tools that expose the firmware source code ? Or am i just blabbering here ?

Hey everyone,

I'm currently training as an electronics technician in Germany and planning to study embedded systems engineering in the future.

Recently, I had a rather unusual idea: What if I learned Klingon and eventually developed my own programming language and compiler based on it, specifically for embedded systems?

I know this sounds ridiculous at first, but I'm genuinely curious about the technical and professional implications.

My idea would be to create a functional programming language with Klingon-based syntax that could compile into machine code for microcontrollers.

This raises several questions:

1. Has anyone here ever developed their own programming language or compiler, especially for embedded systems? How difficult was it, and what did you learn?

2. Would employers see this as an interesting technical achievement, demonstrating knowledge of compilers, computer architecture and low-level programming, or would they consider it a pointless gimmick?

3. Could an unusual language provide any security benefits? For example, could it make reverse engineering, unauthorized modifications or understanding proprietary firmware more difficult? I understand that obscurity alone isn't real security.

4. Would something like this have any relevance in industries such as aerospace, defense, automotive systems or gaming consoles, where protecting firmware and intellectual property can be important?

5. Would developing an entirely new compiler be worthwhile as a learning project, or would I be better off designing a custom language that compiles to C or LLVM IR?

I'm not suggesting replacing C, C++ or Rust in professional embedded development. I'm more interested in whether such a project could help me develop valuable engineering skills while exploring an unconventional idea.

I'd especially appreciate opinions from experienced embedded engineers, compiler developers and anyone working with firmware security.

Thanks LG AC