The Apple Disk II Controller discussed yesterday used two 256-byte ROM chips and a shift register for dynamic memory.
https://news.ycombinator.com/item?id=48723102
The linked article of the Disk II Controller has great detail about the state machine encoded in one of the ROMs, and walks through the bootstrap code stored in the other one.
I haven't tried any microcontroller projects myself, but my first computer projects were on the small home micros of the early 1980s. I enjoy this kind of thinking.
Not worth changing the design now...
It will be much better if the OP link to the announcement news rather than straight to the datasheet for better context.
[1] TI introduces the world's smallest MCU, enabling innovation in the tiniest of applications:
https://www.ti.com/about-ti/newsroom/news-releases/2025/2025...
There are more pieces like this in "wearables" market now, things like "SmartBond" series. But for a while, weird off-label pieces like this wore the integration crown.
If you dive into even more niche, NDA-Only MCU, We have BES2700 MCU, which is even better
The 1KB of SRAM is admittedly very tight (even WCH's 10-cent RISC-V parts usually give you 2KB), so you are strictly in bare-metal, carefully-managing-your-stack territory.
Plenty of DIY projects used ATtiny2313 with V-USB. That's a pure software USB implementation bit banging the IO pins (not a USB stack on top of hardware USB support)+ your application logic squeezed into 2K of flash + 128 bytes of ram.
Chips like this are great for digital glue logic. Read a sensor, read a button press, blink some LEDs with simple state machine or control loop.
Anything to save a few bucks on a 6264 SRAM component :-)
C support is basically universal these days, very few chips require you to program in only assembly anymore.
(had to disable debug symbols, though)
Why should that be any harder than C?
I was extremely surprised by how much functionality is packed into "core", and runs without an OS when using freestanding rust. Even stuff that requires an allocator can run provided you provide your own heap!
A cool example of this was implementing fmt::Write for a memory mapped uart console thing. Then implementing a kprintln! macro that supports all of the formatting machinery that you are use to. This worked without even a heap available.
Compiled Rust code that relies on syscalls will not function on a “bare metal” microcontroller.
Rust's only requirement is that memcpy, memmove, memset, memcmp, bcmp, and strlen are available, and it can provide them if needed: https://github.com/rust-lang/compiler-builtins
Yes, I should have said binary opcodes instead of assembly. I just assumed anyone discussing embedded systems would know they are practically interchangeable.
In terms of projects that I would be inclined to try that are uniquely enabled by this, my mind goes towards wearables. It's small enough to be hidden in seams of fabric. If you wanted to have a bunch of temperature sensors all over your body, or have a complex arrangement of dimmable LEDs woven into clothing, each string going to its own controller hidden close by and communicating with a central controller, or maybe measure your skin conductivity all over your body or something, this is a great piece of tech to do that with style. You still need to run power and data wires everywhere (no RF on this chip), but flexible wires are a very solvable problem.
The applications required only I2C to communicate with a bunch of other integrated circuits and a few general-purpose pins.
An example of an application was a kind of hardware video converter, which received video input from a camera and then sent it wirelessly or on cables, where the MCU configured and reconfigured everything on the board, after reset or when certain buttons were pressed, and the configuration for some things, like a HDMI transmitter, was complicated, requiring the reading and the writing of many internal registers via I2C, so a MCU was really needed.
There are many types of complex integrated circuits that need to be configured with values written in internal registers to be usable, so, even if just for the initial configuration after reset, you need some small MCU that can write the registers via I2C or SPI. For this, the smaller the MCU is, so it will not take space on the PCB just for booting the other ICs, the better.
The L line and G lines have better ADCs, Comparators, better connectivity, and some of them even have on board OpAmps.
Tiny chips have a use of you are tying to build the absolute smallest devices. But hobbyists don't have the equipment to comfortably build things of this size.
Sizing up to VQFN packages and 0603 passives makes more sense for the typical hobbyist.
-----------
As far as how a professional would use this, there are plenty of good uses of chips inside of cables or other kinds of smarts. Like a chip controlling a bunch of LEDs for example, based on voltage measurements elsewhere (there is a 12-bit ADC after all, which means you have rather solid voltage sensing from a few pins).
Basic voltage comparisons + math + crude timer and then a few pins for in/out gets you to a lot of useful projects. Albeit dumb ones. I dunno why anything needs to be this small in particular though.
But like *really* tiny.
1KB is surely enough to store synthesizer patches. Several, probably.
It all adds up, especially if you want to implement a ladder filter properly.
16kB Flash and 1kB SRAM is plenty.
-------
However, the analog capabilities of this thing are nearly trash. One ADC?? No comparators? No OpAmps? Ehhhhhhhh, this is really bare bones by modern standards.
Modern cheap chips differentiate themselves with how many analog components they stuff into one package so that they are easily used in a wide variety of situations.
The only real feature offered here is size. Which is impressive but definitely limiting compared to the rest of TI's MSPM0 (or even MSP430) lineup.
The best this MSPM0-C seems to be able to do, is ADC input -> PWM output. Which is... the bare minimum necessary for mixed signal control.
Resistor+capacitor for anti aliasing on input, resistor+capacitor (smooth the PWM) + transistor for output, and yeah we have a true system with feedback here. But it won't be as reliable or quick as other tools (comparators, OpAmps, or the like)
Applications
• Battery charging and management
• Power supplies and power delivery
• Personal electronics
• Building security and fire safety
• Connected peripherals and printers
• Grid infrastructure
• Smart metering
• Communication modules
• Medical and healthcare
• Lighting
I'm not seeing any voltage comparators which are really useful for most of those use cases...
Now the MSPM0 series chips have a few OpAmps or a few better ADCs. TI also have proper power metering chips with 16-bit or 24-bit (!!!!!) ADCs for proper power metering.
---------
This is still a 12-bit ADC strapped onto a 8-pin chip. It's useful for something but not that whole list. Power metering? Heh, TI is smoking something or just using AI auto complete.
> Battery charging and management
> Power supplies and power delivery
> • Grid infrastructure
Those really want a comparator (100ns response time) rather than an ADC (10,000ns response time).
You also want zero-crossing detectors on grid infra, or other analog features that simply aren't available at this price point. Just no.
> • Smart metering
Lol very no. 16-bit ADC at a minimum, probably needs 24-bit delta sigma ADC instead (slower ADC but higher precision). TI has a bunch of MSP430 that do the job well.
Alternatively, an OpAmp or other amplifier can zoom into the current sensing circuits and make a 12-bit ADC work, but you need another bigger chip (the OpAmp), at which point you should be using an OpAmp+MCU solution instead.
Plus the "smart" part of metering needs a better communication module than bare bones basic UART. Maybe wireless of some kind or a DSP for custom modem work.
> • Communication modules
Just no. Waayyyyyyy to slow.
> • Personal electronics
> • Connected peripherals and printers
You have bigger, better chips for these.
> • Building security and fire safety
> • Medical and healthcare
> • Lighting
I think these three are legitimate good use cases.
I made and tested it but didn’t care enough to continue.
This specific SKU has serious limitations due to the SRAM - TI limits the features (ROM bootloader IIRC, etc.) severely on these due to this.
With tiny mcu like this one, I think it would be possible to add a bodge inside that would turn on recording automatically after single press of button. The MCU needs to be really tiny to fit inside camera.
The scale precision comes from calibration of the measuring mechanism done on factory line at certain weights. If your specific body weight is far from the weights used in calibration, or too much time passed, then the calibration doesn't help much.
A better microcontroller doesn't help at all. Even a cheapest uC from decades ago is good enough. Better ADC and gauge sensor would help, but even more important is good analog engineering to produce self-correcting circuits with decent noise rejection.
In general this category of products is more for tracking changes in your body weight than getting the precise absolute value. And the body weight changes a lot just from hydration level, so the ±.5kg tolerance is considered good enough.
Ofc there's auto-zero on start involved, but translated to a people bathroom scale that'd be "comfortably better than +-100g".
A precise bathroom scale just would want a bit more effort on drift prevention as a sample mass at this scale is rather unwieldy, and critically it'd need a toe-operated button to select that you've finished climbing onto the scale, upon which it starts averaging the load to progressively improve the weight measurement accuracy. I'd expect using a bounce-height-freefall-duration based length of timing uncertainty at the start and end of the averaging period to allow proper Bayesian uncertainty quantification of the shown result, say by displaying both the 10th and the 90th percentile on the display which grow closer as you wait while standing on it.
With some cleverness a compact calibration mass might be usable to calibrate absolute scale, transferring up to the "people" range using just a random assortment of stuff that fits on the platform, totalling around 10kg.
Because building the scale to be linear in response good enough for 20k count of resolution is pretty straight-forward.
I guess the overall finickiness of that can't be instantly improved by a better microcontroller alone? They drift and have linearlity issues and show temperature dependancy and all that.
Precise body weight measurement at bathrooms is also probably not that important, 500 grams is one full bottle of soda/water; body weights can easily change that much within a single day.
I would suspect that the "real" reason is combination of both. 100-500g can be a "good" compromise for cheap bathroom scales.
https://www.interfaceforce.com/products/load-cells/low-profi...
Click the "Specifications" tab to see the various error sources. Interface's technical library (linked at the top right of their shop) is a great training tool too, if you want to learn more. To keep your NIST certification - and to maintain accuracy after a high-stress...incident... you need to do occasional recalibration. That would be a problem for a consumer product, but with good mounting and overload protection they really don't change that much over time.
Then you've got the electronics, and the amplifier required to get the rated precision out of that load cell costs more than the load cell itself.
Achieving those performance targets costs money, and people buy the cheapest scale that says "Accurate High Precision Digital Bathroom Scale Glass" on the Amazon listing.
Decreasing resolution hides all of those.
For majority of use cases nowadays it's much easier to use a programmable chip than invent a complex device using discrete analog electronic parts.
The reason is that most people use a dirt cheap HX711 or cheaper. A fancier microcontroller doesn't help all that much.
I got to 100dB of dynamic range at 1ksps (1 gram of noise at 100kg max load), so it's very much doable.
Every scale I've tried since is wildly inaccurate, and they do have brains and they fake it. Step on, get a random weight within a 5lb range of the true weight. Step on repeatedly, even after the scale has timed out and had to be rezeroed, and get that exact weight again. Fake. Every single 4-sensor scale (one in each corner post) that I've tried does this.
I've since found another relatively vintage single strain gauge scale whose battery still works. And I have a mechanical scale in reserve for when it no longer does.
That's resolution (or dynamic range), not accuracy. The scales could be 10lbs off of your weight and still do this.
Huh. I have never experienced this and didn't even know this was a thing. My cheapo Chinesium scale that I bought from Amazon years ago occasionally jumps by a pound or so. I measure myself a couple of times to be sure. But it definitely doesn't "freeze" measurements, as I see a different measurements shoes on in back-to-back measurements.
Resolution of +/- 500g just means there's not enough "steps" values in your ADCs provided bit depth: for example the 10bits on an attiny85 gives you 1024 discreet values you can map to weight values etc.
This is why highly accurate scales usually have very low max weights.
They'd be done already if they bought up or licensed Analogue though.
On top of all this, latency for anything is gonna be abysmal because the cores are so slow...
I honestly don't see an application where this is even close to desirable.
Would be fun, tough, to have a 10-stack of PCBs with 10 by 10 CPUs each for a thousand cores (=> ~4W power @1.8V).
The ADC is really nice though, 1.5 MSPS is really good for such a small/low powered thing (fills the whole RAM in under half a millisecond).
I could only imagine the bringup fun for thousands of them. :P
If you had 1024 of these, you'd have a grand total of 1 MiB of RAM. You won't be compute clustering much with 1 MiB of RAM.
I have no grasp of even the magnitude of the price for something like this.
Can get under 10 cents each for cheap minimalistic CPUs in high numbers.
