1.38 Millimeter Microcontroller

At $0.20 in 1k quantities, this is TI's answer to the CH32V003, Puya PY32, and the STM32C0 series. It's great to see tier-1 silicon vendors participating in the race to the bottom for jellybean microcontrollers.

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.

This line of micros has been out for almost 2 years now but they only just took the 1.38mm^2 package out of pre-production. I started a design last year of a tiny earring with ~102 addressable LEDs on it, a microphone, a bunch of supporting circuitry and this micro. https://i.ibb.co/JWh57LLw/IMG-20260408-183807502-HDR.jpg Unfortunately by the time I was ready to order the boards I found the tiny package was unobtanium and had to resort to the second smallest package which isn't very small. Frustration!

Not worth changing the design now...

A silly question (from a non-HW guy). Why are digital bathroom scales so coarse? Some have a weight resolution of +/- 500 grams. Would a better microcontroller make a weight faster or more presise? I guess this TI micro controller is overkill for a bathroom scale.

Does anyone know what would the price of this be, roughly of course, given that a customer ordered some thousands or tens of thousands?

I have no grasp of even the magnitude of the price for something like this.

It seems awesome, but I'm having a problem with figuring out how can a "normal" person use it. How would YOU use it, reader of this comment?

Can it run Prince of Persia?

It's a bit low on RAM, otherwise it's similar to a game boy advance. Maybe after the GBA, GBA SP, and GBA micro, it's time for a GBA.. nano?

Could you put a few thousand of these on a PCB and have a super duper tiny compute cluster?

Does anyone know what would the price of this be, roughly of course, given that a customer ordered some thousands or tens of thousands?

I have no grasp of even the magnitude of the price for something like this.

The prices are right there if you click "ordering & quality". $0.19-0.23 depending on exact variant at quantities of 1000 and up. $0.6 for 1-99 although that will likely vary a lot if you are buying through a distributor instead of directly.

Price is listed on the site, the most expensive version is:

1-99 $0.720

100-249 $0.48925

0-999 $0.378

1,000+ $0.251

No more than 50 cents per CPU for this one.

Can get under 10 cents each for cheap minimalistic CPUs in high numbers.

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.

It's a bit low on RAM, otherwise it's similar to a game boy advance. Maybe after the GBA, GBA SP, and GBA micro, it's time for a GBA.. nano?

Can it run Prince of Persia?

It seems awesome, but I'm having a problem with figuring out how can a "normal" person use it. How would YOU use it, reader of this comment?

Not worth changing the design now...

Computing power is crazy cheap and does not help. The perceived slowness is because the taken measurements are averaged over second or so. When you step on the scale your weight shifts around and that affects the measurement by far more than half a kg. Averaging gives you better accuracy and more confidence in the result but it doesn't improve the measurement precision.

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.

Digital scales generally work by warping metal pieces and forcing a flex film resistor glued on the piece to be stretched along, causing its resistance to change, thereby breaking the balance of a Wheatstone bridge, creating force-proportional current to occur, which is finally read out with an ADC.

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.

Higher resolution would let the user see that your scale is zeroed badly, that repeatability sucks and that the measured weight is not even constant under a constant load.

Decreasing resolution hides all of those.

I remember that a friend told that the Nintendo Wii Balance board gave her the weight on gram resolution. Which is 10-100x better than most commercial bathroom scales. But keep in mind that precision is not the same as accuracy.

As others have said, the crap resolution is to mask the crap repeatability. Better processing can help, but good enough processing fits in the cheapest of microcontrollers. ADC quality is more important, signal conditioning and sensor quality more important still. The biggest factor for accuracy is likely calibration though. A sensor that's 2% accurate with a 2 point calibration can easily become a 0.25% sensor with a 5 point, 3 temperature calibration. But that all takes time, and unless you're running huge batches it adds too much to the bottom line of a low cost product. Source: Designed strain gauge sensors and manufacturing processes for a living

It's down to the quality of the sensor, the quality of the ADC translating the signals from the sensor, and the implementation of the software that deals with the ADC translation.

I've spent the last several years of building a very, very fancy scale (well, more of an industrial and R&D lab tool that can be used as a scale).

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.

I used to have a bathroom scale with a single strain gauge that was accurate. Accurate, as in weigh yourself, pick up a 1lb object, weigh yourself again and see an extra pound. That scale had a "lifetime" nonreplaceable battery in it and after 20 years or so, gave up the ghost.

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.

Mostly quality of the sensor, processing power is not a constraint. Also bear in mind that high range and high accuracy generally aren't very compatible, so to measure 100kg at a 1% accuracy is accuracy to the kg. to get +/-100g accuracy you need a +/-0.1% accuracy.

This is why highly accurate scales usually have very low max weights.

Not an expert here, but I doubt it is related to processing power, but quality of the sensor.

1KB isn't so bad unless you are making something complicated or need large buffers. You can do quite a bit of nontrivial stuff with it. Years ago I made universal remote with ATtiny13 + external EEPROM for storing remote data. It has only 64 bytes of RAM, that's what I would call very tight. Was still able to program it in C, 1KB flash and number of pins were bigger limiting factor than ram.

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.

Nintendo releasing a new GB would be wild and awesome. Unfortunately it'd likely be overpowered and emulate games they downloaded off ROM sites themselves.

They'd be done already if they bought up or licensed Analogue though.

With a lot of code-golf, I would guess the answer is yes.

It's not intended for a normal person to use. If you're a normal person making something as a hobby project, you'll get a much nicer development experience by using a microcontroller that costs a few dollars rather than a few cents. For hobby purposes, I recommend either the Raspberry Pi Pico or the STM32 blue pill. A part like this is intended for inexpensive, high-volume consumer electronics that need some sort of simple control functionality. For example, let's say you're making an electric toothbrush. All it needs to do is turn the motor on, wait for 2 minutes, then pulse the motor to let the user know they're done brushing their teeth. This can do that. Or let's say you're making a promotional keychain, and you want it to blink a few LEDs in a specific pattern when the user presses a button. This can do that. If you take apart basically any piece of cheap (< $5) electronics that's been designed in the past 10-15 years, you'll usually see a tiny unmarked 8-pin microcontroller doing the control work. This part competes in that market.

Anything where a reasonable person would say "this doesn't even need a microcontroller, just do it analog".

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.

I have used a microcontroller from ST, very similar in size and also with a Cortex-M0+ core.

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.

I'd buy it and put it in the Drawer of Dreams aka unfinished projects.

Consumer electronics can be designed to extremely tight budgets for cost and power consumption. Designers will choose a chip based on a chip having precisely the features needed, zero current wasted on features they don't need, and seemingly tiny price differences.

I made something to ping an AWS service to tell me the uptime of my internet connection. The idea was to sprinkle them around our area, connected to various home WiFi’s, and get a better triangulation of outages. Eg is whole pipe out, just one ISP etc.

I made and tested it but didn’t care enough to continue.

From the datasheet:

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

Power sequencing or such in mobile electronics, using a pick-and-place machine.

This specific SKU has serious limitations due to the SRAM - TI limits the features (ROM bootloader IIRC, etc.) severely on these due to this.

I have action camera with retarded user interface. To turn it on I have to: press main button for at least 0.3s but no longer than 2s, then I have to wait until it beeps, then I have to wait for 3s, then I have to press second button for at least 0.3s but no longer than 1s. Then I observe main led, if it blinks the camera is recording, if not I need to press second button again.

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.

You write program(usually in C), compile it into machine code(to .hex or .bin file), then "flashing" it using debugger tool. This IC will execute your program.

And for people saying it is low on RAM and flash, you need to understand this is a low cost micro. You can also do a lot of work with a small amount of RAM by managing your memory manually. Through the use of C unions I have about 3kB worth of variables that get switched in and out depending on the mode we are in. I have enough space to record analog audio samples and perform a fourier transform over the samples and use the generated to data to drive algorithmically generated animations on the LED array.

You might enjoy this dime-sized earring I designed ~13 years ago - https://www.youtube.com/watch?v=XyBhdRp_5rY

My sleeper pick for a design like this was JL700N series. Intended for cheap TWS, ultra high integration. 3x3mm QFN20 package, and in it: BLE, USB, can be powered off 5v or 3.3v, built in battery support complete with a charger, almost no passives required. SDK was a bitch though.

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.

Earrings with microphones, another thing for privacy nerds to lose sleep over. Cool board though!

These earrings look awesome btw!

Could you put a few thousand of these on a PCB and have a super duper tiny compute cluster?

Yes, if you want all the drawbacks of distributed computing with none of the advantages: You'd probably be stuck with something UART based as interconnect, Every core is gonna have way too little RAM to do anything useful, you are missing like half the instruction set (floating point operations in software), and power draw at 4mW minimum per core adds up quickly to something that an efficient laptop-CPU would use.

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).

> Could you put a few thousand

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'm reminded of TIS-100, a game where you program a cluster of tiny, parallel CPUs using a custom assembly language. It's painful to get basic stuff done, but you can do some amazing things with some effort.

Yes, but also why would you? at 24MHz, you would be better off paying 100x the price ($25) for a 2.4GHz chip (easily doable). Something like a Raspbery Pi Zero 2 W already comes pretty close to that and without the penalty of memory communication/bandwidth.

https://hackaday.com/2025/07/07/160-core-risc-v-board-is-the...

I could only imagine the bringup fun for thousands of them. :P

You mean ... Like a Beowulf cluster of those?

No more than 50 cents per CPU for this one.

Can get under 10 cents each for cheap minimalistic CPUs in high numbers.

Not an expert here, but I doubt it is related to processing power, but quality of the sensor.

You write program(usually in C), compile it into machine code(to .hex or .bin file), then "flashing" it using debugger tool. This IC will execute your program.

Price is listed on the site, the most expensive version is:

1-99 $0.720

100-249 $0.48925

0-999 $0.378

1,000+ $0.251

Oh, I'm an idiot who didn't see that at all. Thanks.

Higher resolution would let the user see that your scale is zeroed badly, that repeatability sucks and that the measured weight is not even constant under a constant load.

Decreasing resolution hides all of those.

It's down to the quality of the sensor, the quality of the ADC translating the signals from the sensor, and the implementation of the software that deals with the ADC translation.

This is why highly accurate scales usually have very low max weights.

I've spent the last several years of building a very, very fancy scale (well, more of an industrial and R&D lab tool that can be used as a scale).

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.

Nintendo releasing a new GB would be wild and awesome. Unfortunately it'd likely be overpowered and emulate games they downloaded off ROM sites themselves.

They'd be done already if they bought up or licensed Analogue though.

With a lot of code-golf, I would guess the answer is yes.

Anything where a reasonable person would say "this doesn't even need a microcontroller, just do it analog".

I have used a microcontroller from ST, very similar in size and also with a Cortex-M0+ core.

The applications required only I2C to communicate with a bunch of other integrated circuits and a few general-purpose pins.

From the datasheet:

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 made and tested it but didn’t care enough to continue.

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.

You've described a load cell, which is commonly used in laboratory and industrial environments to resolutions exceeding 0.05% of full scale. I've used these in the past with great success:

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.

My fine spice recipe writing scale (20g max, 20k count) consistently over years of me having it keeps it's magnitude calibration of the 10g reference to a single digit count, i.e., comfortably within +-0.1%.

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'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.

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.

I'd buy it and put it in the Drawer of Dreams aka unfinished projects.

> Could you put a few thousand

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.

https://hackaday.com/2025/07/07/160-core-risc-v-board-is-the...

I could only imagine the bringup fun for thousands of them. :P

> Accurate, as in weigh yourself, pick up a 1lb object, weigh yourself again and see an extra pound.

That's resolution (or dynamic range), not accuracy. The scales could be 10lbs off of your weight and still do this.

> Fake. Every single 4-sensor scale (one in each corner post) that I've tried does 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.

It's been long enough ago that I don't use it as an interview answer anymore, but one of the most interesting things I built (technique-wise) was a Z-80 based serial multiplexer with no RAM. The only volatile memory it used was the device registers. The fun part was handling subroutine calls without a stack. The Z-80 has an indexed jump mode, so before calling a subroutine, I'd fill the jump register with the statement after the subroutine call, and when the subroutine was done, execute the jump with the (return) address prefilled.

Anything to save a few bucks on a 6264 SRAM component :-)

Yes, that's "bare metal" as opposed to programming in MicroPython, Javascript with Espruino, Lua/NodeMCU, Rust, or adding your C application on top of an off-the-shelf RTOS.

C support is basically universal these days, very few chips require you to program in only assembly anymore.

What a nice name for that particular box that keeps on growing and growing. Mine is called Why did I buy this, again?

DoD in short, to make it look like serious business

Ha! I'm going to rename my home office "The Room of Dreams"

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).

Using it as a cluster is probably a bad idea, but you could probably build a 2d sensor grid using these. The 8 pin restriction is extremely limiting though. If you have an FSR matrix, you could connect a 2x2 grid to each MCU and then connect each row in a daisy chain configuration.

Maybe not practical as a cluster configuration, but it could certainly be used as a voice-generating device for a synthesizer, or as a controlling device for MIDI I/O, or .. both even of course, configurable according to the users needs/patch idea.

I love TIS-100! I actually have a couple printed copies of the reference manual somewhere.

You've described a load cell, which is commonly used in laboratory and industrial environments to resolutions exceeding 0.05% of full scale. I've used these in the past with great success:

https://www.interfaceforce.com/products/load-cells/low-profi...

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.

> Fake. Every single 4-sensor scale (one in each corner post) that I've tried does this.

Anything to save a few bucks on a 6264 SRAM component :-)

DoD in short, to make it look like serious business

I love TIS-100! I actually have a couple printed copies of the reference manual somewhere.

Ha! I'm going to rename my home office "The Room of Dreams"

Earrings with microphones, another thing for privacy nerds to lose sleep over. Cool board though!

Power sequencing or such in mobile electronics, using a pick-and-place machine.

This specific SKU has serious limitations due to the SRAM - TI limits the features (ROM bootloader IIRC, etc.) severely on these due to this.

Oh, I'm an idiot who didn't see that at all. Thanks.

Ofc there's auto-zero on start involved, but translated to a people bathroom scale that'd be "comfortably better than +-100g".

Because building the scale to be linear in response good enough for 20k count of resolution is pretty straight-forward.

> Accurate, as in weigh yourself, pick up a 1lb object, weigh yourself again and see an extra pound.

That's resolution (or dynamic range), not accuracy. The scales could be 10lbs off of your weight and still do this.

I did test it with various known weights. It was a good scale.

What a nice name for that particular box that keeps on growing and growing. Mine is called Why did I buy this, again?

What even are these things?

Yes, that's "bare metal" as opposed to programming in MicroPython, Javascript with Espruino, Lua/NodeMCU, Rust, or adding your C application on top of an off-the-shelf RTOS.

C support is basically universal these days, very few chips require you to program in only assembly anymore.

I had no troubles targeting an ATTiny13A with Rust.

(had to disable debug symbols, though)

Why should that be any harder than C?

Rust compiles to bare metal (assembly aka machine instruction code), just like C does.

Yeah, but even for those applications you suffer from limited RAM a lot; with 16bit samples at 48kHz the thing has 10ms of audio buffer (stereo: 5ms) if you don't need RAM for anything else :S

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).

You might enjoy this dime-sized earring I designed ~13 years ago - https://www.youtube.com/watch?v=XyBhdRp_5rY

How did you power it?

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.

Wearable MCU is sometime stupidly good. Recently i learned that the new Pepple watch use SF32lb55. It has dual mode bluetooth with LE Audio, all the fancy like pmic, battery charger, usb, 2.5D GPU etc, it also has insanely large memory(16MB flash/8MB PSRAM on some packages). The whole MCU costs like $3.

If you dive into even more niche, NDA-Only MCU, We have BES2700 MCU, which is even better

These earrings look awesome btw!

Thank you! I want to try and sell them but I just have a few bugs to squash and to finish off the mechanical design of the charging cradle.

You mean ... Like a Beowulf cluster of those?

I did test it with various known weights. It was a good scale.

What even are these things?

I had no troubles targeting an ATTiny13A with Rust.

(had to disable debug symbols, though)

Why should that be any harder than C?

If you dive into even more niche, NDA-Only MCU, We have BES2700 MCU, which is even better

How did you power it?

Rust compiles to bare metal (assembly aka machine instruction code), just like C does.

Bare metal refers to not using an rtos. I know that sounds weird but it is an industry convention. It does not refer to the language.

It also supports running in freestanding setups without an OS, and quite a lot of the language's features still work.

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.

In Embedded, it's usually agreed that "Bare Metal" means using no OS, not meaning using low level languages.

Check out the video introducing Swift for Embedded. Seems like a really nice devX for this kind of thing.

Yeah, but even for those applications you suffer from limited RAM a lot; with 16bit samples at 48kHz the thing has 10ms of audio buffer (stereo: 5ms) if you don't need RAM for anything else :S

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 have a fourier transform loop running on this micro which takes 64 samples and outputs 32 frequency bins. It works perfectly for generating inputs to algorithmically driven animations including a visual audio spectrum frequency analyser.

10ms of buffer is almost 512 samples @ 48kHz, it's quite a lot of buffer in audio terms!

True, you will have to write some tight code, but .. at that form factor and price, challenge accepted! Besides, 10ms is a LOT in that world ..

Thank you! I want to try and sell them but I just have a few bugs to squash and to finish off the mechanical design of the charging cradle.

Have you blogged about the earrings perchance? They really do look great, and I'd love to see some details of your process.

It also supports running in freestanding setups without an OS, and quite a lot of the language's features still work.

Check out the video introducing Swift for Embedded. Seems like a really nice devX for this kind of thing.

Bare metal refers to not using an rtos. I know that sounds weird but it is an industry convention. It does not refer to the language.

That's exactly what I said. Rust compiles to binary opcodes. Assembly is not an rtos, and does not require one. ASM isn't a standard "language". It's literally a fancy display of opcodes and registers that the CPU reads to execute operations. C does the exact same thing, ie compile to opcodes. You can convert binary back and forth from ASM to opcodes with a lookup table. At its core, ASM is just a convenient way to read and write cpu opcodes. I misspoke saying "to assembly" when I meant "to binary opcodes", but such a minor pedantic misspeak I didn't think anyone who understood embedded systems would not understand the meaning. Sorry about that.

In Embedded, it's usually agreed that "Bare Metal" means using no OS, not meaning using low level languages.

True, you will have to write some tight code, but .. at that form factor and price, challenge accepted! Besides, 10ms is a LOT in that world ..

10ms of buffer is almost 512 samples @ 48kHz, it's quite a lot of buffer in audio terms!

Either you do not understand what assembly is, or you are being pedantic about the very thin abstraction between assembly and opcodes. Just in case you didn't know, assembly is a convenient way to read the binary opcodes that the cou uses to move data between registers and execute logic.

Yes, I should have said binary opcodes instead of assembly. I just assumed anyone discussing embedded systems would know they are practically interchangeable.

Have you blogged about the earrings perchance? They really do look great, and I'd love to see some details of your process.

Yes, I’d love to see a video of them in action.

Yes, I should have said binary opcodes instead of assembly. I just assumed anyone discussing embedded systems would know they are practically interchangeable.

The other commenters are referring to bare metal interpreted Forth with no OS, or bare metal ROM Basic with no OS, as opposed to machine code with no OS.

Yes, I’d love to see a video of them in action.

I don't have a blog post up about them yet, it is in the works. The website is active though: https://www.reactiv.au

The other commenters are referring to bare metal interpreted Forth with no OS, or bare metal ROM Basic with no OS, as opposed to machine code with no OS.

ACTIVE

24MHz Arm® Cortex®-M0+ MCU with 16KB flash, 1KB SRAM, 12-bit ADC

User guides

Errata

CPU Arm Cortex-M0+ Frequency (MHz) 24 Flash memory (kByte) 16 RAM (kByte) 1 ADC type 12-bit SAR Features 5-V-tolerant I/Os, DMA, General purpose, LIN UART 1 Security Secure debug Number of ADC channels 3, 8, 10 SPI 1 Hardware accelerators 0 Edge AI enabled No Operating temperature range (°C) -40 to 125 Rating Catalog Operating system BareMetal (No OS) Nonvolatile memory (kByte) 16 Number of GPIOs 6, 14, 18 Number of I2Cs 1

DSBGA (YCJ) 8 1.3776 mm² 1.6 x 0.861 SOT-23-THN (DDF) 8 8.12 mm² 2.9 x 2.8 SOT-23-THN (DYY) 16 8.4 mm² 4.2 x 2 TSSOP (PW) 20 41.6 mm² 6.5 x 6.4 VSSOP (DGS) 20 24.99 mm² 5.1 x 4.9 WQFN (RUK) 20 9 mm² 3 x 3 WSON (DSG) 8 4 mm² 2 x 2

Core
- Arm 32-bit Cortex-M0+ CPU, frequency up to 24MHz
Operating characteristics
- Extended temperature: –40°C to 125°C
- Wide supply voltage range: 1.62V to 3.6V
Memories
- Up to 16KB of flash
- 1KB of SRAM
High-performance analog peripherals
- One analog-to-digital converter (ADC) with up to 10 total external channels, 1.7Msps at 10 bit or 1.5Msps at 12 bit with VDD as the voltage reference
- Configurable 1.4V or 2.5V internal ADC voltage reference (VREF)
- Integrated temperature sensor
- Integrated supply monitor
Optimized low-power modes
- RUN: 87µA/MHz
- STOP: 609µA at 4MHz, 311µA at 32kHz
- STANDBY: 5µA with SRAM retention
- SHUTDOWN: 200nA
Intelligent digital peripherals
- 1-channel DMA controller dedicated for ADC
- Three timers supporting up to 14 PWM channels
  - One 16-bit advanced timers with deadband support up to 8 PWM channels
  - One 16-bit general purpose timer with 4 capture/compares
  - One 16-bit general purpose timer with 2 capture/compares
- Windowed watchdog timer
- BEEPER generating 1kHz, 2kHz, 4kHz, or 8kHz square wave to drive the external beeper
Enhanced communication interfaces
- One UART interface supporting LIN, IrDA, DALI, smart card, Manchester and low-power operation in STANDBY mode
- One I2C interface supporting FM+ (1Mbps), SMBus, PMBus, and wakeup from STOP mode
- One SPI supporting up to 12Mbps
Clock system
- Internal 24MHz oscillator with an accuracy from -2% to +1.2% (SYSOSC)
- Internal 32kHz low-frequency oscillator (LFOSC)
Data integrity
- Cyclic redundancy checker (CRC-16)
Flexible I/O features
- Up to 18 GPIOs
- Two 5V-tolerant open-drain IOs
Development support
- 2-pin serial wire debug (SWD)
Package options
- 20-pin TSSOP (PW)
- 20-pin VSSOP (DGS)
- 20-pin WQFN (RUK)
- 16-pin SOT (DYY)
- 8-pin SOT (DDF)
- 8-pin WSON (DSG)
- 8-pin DSBGA (YCJ)
Family members (also see Device Comparison)
- MSPS003F4: 16KB of flash, 1KB of RAM
- MSPS003F3: 8KB of flash, 1KB of RAM
- MSPM0C1104: 16KB of flash, 1KB of RAM
- MSPM0C1103: 8KB of flash, 1KB of RAM
Development kits and software (also see Tools and Software)
- LP-MSPM0C1104 LaunchPad™ development kit
- MSP Software Development Kit (SDK)
Core
- Arm 32-bit Cortex-M0+ CPU, frequency up to 24MHz
Operating characteristics
- Extended temperature: –40°C to 125°C
- Wide supply voltage range: 1.62V to 3.6V
Memories
- Up to 16KB of flash
- 1KB of SRAM
High-performance analog peripherals
- One analog-to-digital converter (ADC) with up to 10 total external channels, 1.7Msps at 10 bit or 1.5Msps at 12 bit with VDD as the voltage reference
- Configurable 1.4V or 2.5V internal ADC voltage reference (VREF)
- Integrated temperature sensor
- Integrated supply monitor
Optimized low-power modes
- RUN: 87µA/MHz
- STOP: 609µA at 4MHz, 311µA at 32kHz
- STANDBY: 5µA with SRAM retention
- SHUTDOWN: 200nA
Intelligent digital peripherals
- 1-channel DMA controller dedicated for ADC
- Three timers supporting up to 14 PWM channels
  - One 16-bit advanced timers with deadband support up to 8 PWM channels
  - One 16-bit general purpose timer with 4 capture/compares
  - One 16-bit general purpose timer with 2 capture/compares
- Windowed watchdog timer
- BEEPER generating 1kHz, 2kHz, 4kHz, or 8kHz square wave to drive the external beeper
Enhanced communication interfaces
- One UART interface supporting LIN, IrDA, DALI, smart card, Manchester and low-power operation in STANDBY mode
- One I2C interface supporting FM+ (1Mbps), SMBus, PMBus, and wakeup from STOP mode
- One SPI supporting up to 12Mbps
Clock system
- Internal 24MHz oscillator with an accuracy from -2% to +1.2% (SYSOSC)
- Internal 32kHz low-frequency oscillator (LFOSC)
Data integrity
- Cyclic redundancy checker (CRC-16)
Flexible I/O features
- Up to 18 GPIOs
- Two 5V-tolerant open-drain IOs
Development support
- 2-pin serial wire debug (SWD)
Package options
- 20-pin TSSOP (PW)
- 20-pin VSSOP (DGS)
- 20-pin WQFN (RUK)
- 16-pin SOT (DYY)
- 8-pin SOT (DDF)
- 8-pin WSON (DSG)
- 8-pin DSBGA (YCJ)
Family members (also see Device Comparison)
- MSPS003F4: 16KB of flash, 1KB of RAM
- MSPS003F3: 8KB of flash, 1KB of RAM
- MSPM0C1104: 16KB of flash, 1KB of RAM
- MSPM0C1103: 8KB of flash, 1KB of RAM
Development kits and software (also see Tools and Software)
- LP-MSPM0C1104 LaunchPad™ development kit
- MSP Software Development Kit (SDK)

MSPM0C110x microcontrollers (MCUs) are part of the MSP highly-integrated ultra-low-power 32-bit MCU family based on the enhanced Arm Cortex-M0+ core platform operating at up to 24MHz frequency. These cost-optimized MCUs offer high-performance analog peripheral integration, support extended temperature ranges from -40°C to 125°C, and operate with supply voltages from 1.62V to 3.6V.

The MSPM0C110x devices provide up to 16KB embedded flash program memory with 1KB SRAM. These MCUs incorporate a high-speed on-chip oscillator with an accuracy from -2% to +1.2%, eliminating the need for an external crystal. Additional features include a 1-channel DMA, CRC-16 accelerator, and a variety of high-performance analog peripherals such as one 12-bit 1.5Msps ADC with VDD as the voltage reference, and an on-chip temperature sensor. These devices also offer intelligent digital peripherals such as one 16-bit advanced timer, two 16-bit general purpose timer, one windowed watchdog timer, and a variety of communication peripherals including one UART, one SPI, and one I2C. These communication peripherals offer protocol support for LIN, IrDA, DALI, Manchester, smart card, SMBus, and PMBus.

The TI MSPM0 family of low-power MCUs consists of devices with varying degrees of analog and digital integration let customers find the MCU that meets their project needs. The architecture combined with extensive low-power modes is optimized to achieve extended battery life in portable measurement applications.

MSPM0C110x MCUs are supported by an extensive hardware and software ecosystem with reference designs and code examples to get the design started quickly. Development kits include a LaunchPad™ kit available for purchase and design files for a target-socket board. TI also provides a free MSP Software Development Kit (SDK), which is available as a component of Code Composer Studio™ IDE desktop and cloud version within the TI Resource Explorer. MSPM0 MCUs are also supported by extensive online collateral, training with MSP Academy, and online support through the TI E2E™ support forums.

For complete module descriptions, see the MSPM0 C-Series 24MHz Microcontrollers Technical Reference Manual.

Download View video with transcript Video

star =Top documentation for this product selected by TI

No results found. Please clear your search and try again.

View all 49

Top documentation	Type	Title	Format options	Date
*	Data sheet	MSPM0C110x, MSPS003 Mixed-Signal Microcontrollers datasheet (Rev. D)	PDF	HTML
*	Errata	MSPM0Cxx Mixed-Signal Microcontrollers (Rev. C)	PDF	HTML
*	User guide	MSPM0 C-Series Microcontrollers Technical Reference Manual (Rev. C)		28 Jul 2025
	Application note	Low Cost AC Motor Control Design Based on MSPM0 and TRIAC (Rev. B)	PDF	HTML
	Application note	Leveraging 8-Pin MSPM0 MCU as Laptop PC Watchdog (Rev. A)	PDF	HTML
	Application note	Low-Cost AC Zero-Crossing Detection Design	PDF	HTML
	Application note	MSPM0 C-Series MCU Hardware Development Guide (Rev. C)	PDF	HTML
	Application note	Single Phase AC Shunt Energy Metrology with Low Cost MSPM0C	PDF	HTML
	Application brief	Applications of Low-Cost MSPM0 Series MCU in Water Purifiers	PDF	HTML
	Application note	EMC Improvement Guide for MSPM0 (Rev. A)	PDF	HTML
	Application note	MSPM0 ADC Noise Analysis and Application (Rev. A)	PDF	HTML
	Subsystem design	I2C IO Expander	PDF	HTML
	Application brief	Applications of Low-Cost MSPM0 Series MCU in Coffee Machines	PDF	HTML
	Application brief	Cost-Effective MCU MSPM0 Designs for Air Purifier Applications	PDF	HTML
	User guide	MSPM0 MCUs Development Guide (Rev. G)	PDF	HTML
	Application note	MCF8315D Control Based on MSPM0C1104	PDF	HTML
	Subsystem design	Subsystem Reading From Sensors Through I2C	PDF	HTML
	Subsystem design	IO Expander With SPI, I2C, and UART (Rev. A)	PDF	HTML
	Subsystem design	Using MSPM0 as a Watchdog Timer	PDF	HTML
	Subsystem design	Emulate EEPROM with FLASH (Type A) (Rev. A)	PDF	HTML
	Subsystem design	Emulate EEPROM With FLASH (Type B) (Rev. A)	PDF	HTML
	Subsystem design	MSPM0 MCU as Watchdog (Rev. A)	PDF	HTML
	Application brief	TI's Smallest M0+ MCU Package Enables Room to do More in Your Design (Rev. A)	PDF	HTML
	Application note	Wide Range and High Resolution PWM Signal Capture with MSPM0C1104	PDF	HTML
	Product overview	MSPM0 MCUs: More Options, Unlimited Possibilities (Rev. B)	PDF	HTML
	Application note	Capturing PWM 0% to 100% Duty Cycle with MSPM0 MCU	PDF	HTML
	User guide	Migration Guide From Microchip to MSPM0 (Rev. A)	PDF	HTML
	Application note	Migration Guide From MSP430 MCUs to MSPM0 MCUs (Rev. B)	PDF	HTML
	User guide	Migration Guide From Renesas RL78 to Arm-Based MSPM0 (Rev. A)	PDF	HTML
	Application note	Migration Guide From STM8 to MSPM0 (Rev. A)	PDF	HTML
	Application note	Cooling FAN Controller with MSPM0	PDF	HTML
	Technical article	小巧卻強大：MCU 的小型封裝與整合功能如何最佳化空間受限的設計	PDF	HTML
	Technical article	작지만 강력한 성능: MCU를 위한 작은 크기의 패키징과 통합이 공간 이 제한된 설계를 최적화하는 방법	PDF	HTML
	Technical article	Tiny, but mighty: How small-size MCU packaging helping optimize design of space-constrained applications	PDF	HTML
	Application note	LIN Basics and Implementation on MSPM0	PDF	HTML
	Application note	Laser Speckle Reduction Solution in Projector based on MSPM0 MCU	PDF	HTML
	User guide	Migration Guide From NXP to MSPM0	PDF	HTML
	Application note	Closed Loop Constant Power Drive to Simplify Heater Element Control and Extend Battery Life	PDF	HTML
	Application note	MSPM0G3507 Low Power Test and Guidance	PDF	HTML
	Application note	Understanding the MSPM0 Debug Subsystem	PDF	HTML
	Application note	Sensored Brushed DC Motor Control Based on MSPM0	PDF	HTML
	Application brief	Automotive Seat Comfort Module Using MSPM0	PDF	HTML
	Application note	PGA460 Control Based on MSPM0 for Distance Detection	PDF	HTML
	Application note	Realization of Password-Protected Debug Based on Software	PDF	HTML
	Product overview	MSPM0C: A New Standard 32-Bit MCU for 8-Bit and 16-Bit MCU Applications	PDF	HTML
	Application note	MSPM0 - Advanced Control Timer Helps for Better Control and Better Digital Output	PDF	HTML
	Application brief	MSPM0Cx- Toothbrush and Shaver	PDF	HTML
	Application brief	Low-Cost MSPM0C MCUs as an I/O Expander	PDF	HTML
	Application note	Operating Time of MSPM0 Powered by a Capacitor	PDF	HTML

For additional terms or required resources, click any title below to view the detail page where available.

Evaluation board

LP-MSPM0C1104 — MSPM0C1104 LaunchPad™ development kit for 24-MHz Arm® Cortex®-M0+ MCU

The LP-MSPM0C1104 LaunchPad™ development kit is an easy-to-use evaluation module (EVM) based on the MSPM0C1104. It contains everything needed to start developing on the MSPM0C1104 M0+ MCU platform, including on-board debug probe for programming and debugging in a smaller form factor. The (...)

Not available on TI.com

Evaluation board

ALGO-3P-UISP1-TI — Algocraft μISP1 Programmer for Texas Instruments devices

μISP can either work connected to a host PC (RS-232, USB, LAN connections are built-in) or in standalone mode.

The programming cycle execution in standalone mode may occur by simply pressing the START button or through some TTL control lines.

This software is used for the application note Cooling FAN Controller with MSPM0

Supported products & hardware

Download options

Driver or library

STM8S-TO-MSPS-MIGRATION-TOOL — Simplify migrating your application code from STM8S003 to MSPS003

The STM8S003 to MSPS003 migration tool provides a collection of software, tools, and documentation to simplify the process of migrating applications from the STM8S003 device family to the pin compatible MSPS003 (MSPM0C110x) devices.

CCStudio™ SysConfig is part of TI's extensive CCStudio™ development ecosystem and is a configuration tool that simplifies hardware and software configuration challenges to accelerate software development.

SysConfig provides an intuitive graphical user interface for configuring pins, peripherals, (...)

Supported products & hardware

IDE, configuration, compiler or debugger

TSK-3P-VX-TOOLSET — TASKING VX-toolset for Arm

VX-toolset for Arm is certified for safety critical embedded software development on Cortex-M and Cortex-R Arm based devices from leading silicon vendors. The toolset has been certified by the TÜV NORD to meet the functional safety standard ISO 26262 and Cybersecurity standard ISO (...)

Visit partner site

Operating system (OS)

GHS-3P-UVELOSITY — Green Hills Software u-velOSity Safety RTOS

The µ-velOSity™ Safety RTOS is the smallest of Green Hills Software's real-time operating systems and was designed especially for microcontrollers. It supports a wide range of TI processor families using the Arm® Cortex-M or Cortex-R cores as a main CPU or as a co-processors (...)

Visit partner site

Software programming tool

UNIFLASH — CCStudio UniFlash for most TI microcontrollers (MCUs) and mmWave sensors

UniFlash is part of TI's extensive CCStudio™ development ecosystem and is a software tool for programming on-chip flash on TI microcontrollers and wireless connectivity devices and on-board flash for TI processors. UniFlash provides both graphical and command-line interfaces and can be run on (...)

Supported products & hardware

Reference designs

TIDA-010951 — 24V, 35W sensorless FOC BLDC reference design with 85 to 265VAC, 0.92PF single-stage PFC

For achieving energy efficiency, ceiling and ventilation fans are moving from simple AC induction motors to brushless DC (BLDC) motors. This reference design meets these challenges of higher efficiency and power factor by using a universal main power-supply input from 85 to 265VAC with a single (...)

Reference designs

TIDA-010268 — 5s to 7s battery pack monitor reference design with low-side MOSFET control

This reference design is a high-cell voltage-accuracy 5s to 7s lithium-ion (Li-ion), lithium iron phosphate (LiFePO4) battery pack design. The design monitors each cell voltage, pack current, cell and metal-oxide semiconductor field-effect transistor (MOSFET) temperature with high accuracy and (...)

Package	Pins	CAD symbols, footprints & 3D models
DSBGA (YCJ)	8	Ultra Librarian
SOT-23-THN (DDF)	8	Ultra Librarian
SOT-23-THN (DYY)	16	Ultra Librarian
TSSOP (PW)	20	Ultra Librarian
VSSOP (DGS)	20	Ultra Librarian
WQFN (RUK)	20	Ultra Librarian
WSON (DSG)	8	Ultra Librarian

Information included:

RoHS
REACH
Device marking
Lead finish/Ball material
MSL rating/Peak reflow
MTBF/FIT estimates
Material content
Qualification summary
Ongoing reliability monitoring

Information included:

Fab location
Assembly location

Recommended products may have parameters, evaluation modules or reference designs related to this TI product.

View all forum topics

Content is provided "as is" by TI and community contributors and does not constitute TI specifications. See terms of use.

If you have questions about quality, packaging or ordering TI products, see TI support.

Hacker Times

Hacker Times

1.38 Millimeter Microcontroller

Discussion

Discussion

24MHz Arm® Cortex®-M0+ MCU with 16KB flash, 1KB SRAM, 12-bit ADC

LP-MSPM0C1104 — MSPM0C1104 LaunchPad™ development kit for 24-MHz Arm® Cortex®-M0+ MCU

ALGO-3P-UISP1-TI — Algocraft μISP1 Programmer for Texas Instruments devices

TMDSEMU200-U — XDS200 USB Debug Probe

LB-3P-TRACE32-ARM — Lauterbach TRACE32® Debug and Trace System for Arm®-based Microcontrollers and Processors

SEGGR-3P-J-LINK — SEGGER J-Link family of debug probes

SEGGR-3P-J-TRACE — SEGGER J-Trace family of streaming trace probes

TSK-3P-BLUEBOX — TASKING BlueBox hardware debugger

BTV-3P-FMC — TI M0 Home Fitness Machine Self-powered Control and Communication solution

ACROVIEW-3P-AP6000 — AP6000 programmer support all TI programmable chips, including EP Product, Power ICs, and Gauge ICs

ACROVIEW-3P-AP8000 — AP8000 Universal Programming System, including all TI programmable chips.

ALGO-3P-WRITENOW — Algocraft WriteNow! Programmer

C-GANG — Fast and reliable gang programming solution for standalone and integrated flashing

MSPM0-SDK — MSPM0 Software Development Kit (SDK)

Supported products & hardware

MSPM0-COOLING-FAN-CONTROLLER-DEMO-APPSW — MSPM0 Cooling Fan Controller Demo

Supported products & hardware

STM8S-TO-MSPS-MIGRATION-TOOL — Simplify migrating your application code from STM8S003 to MSPS003

Supported products & hardware

LP-MSPM0C1104-OOBE — Out-of-box experience GUI for LP-MSPM0C1104

Supported products & hardware

CCSTUDIO-STARTHUB — Example application browser

Supported products & hardware

TI-DEVELOPER-ZONE — Start embedded development on your desktop or in the cloud

Supported products & hardware

CCSTUDIO — CCStudio™ IDE

Supported products & hardware

CCSTUDIO-OPENOCD — OpenOCD Binary Releases

Supported products & hardware

GHS-3P-MULTI-IDE — Green Hills Software MULTI Integrated Development Environment

MSP-ZERO-CODE-STUDIO — Graphical development environment for designing applications for MSP microcontrollers

Supported products & hardware

SYSCONFIG — Standalone desktop version of SysConfig

Supported products & hardware

TSK-3P-VX-TOOLSET — TASKING VX-toolset for Arm

GHS-3P-UVELOSITY — Green Hills Software u-velOSity Safety RTOS

UNIFLASH — CCStudio UniFlash for most TI microcontrollers (MCUs) and mmWave sensors

Supported products & hardware

TIDA-010951 — 24V, 35W sensorless FOC BLDC reference design with 85 to 265VAC, 0.92PF single-stage PFC

TIDA-010268 — 5s to 7s battery pack monitor reference design with low-side MOSFET control