What µC are you preffering

[Attobos]

Hi, which µC are you preffering and why?
Where to find a good reliable microcontroller, well documented, good debug features, fast to program, easy to learn good IDE, good programmer/debuger?
Or is there not the one and really depends on your needs what you prefer and which manufacturer you choose?

[balage]

Hi,

The microcontroller thing depends on your needs. But generally if you are a beginner and looking for something to start with than I would suggest Arduino. You can get familiar with programming and can learn electronics related thing as well. It is very well documented, there are a lots of sources.

For example in my projects I generally use Atmel MCUs (programmed in Atmel Studio in C), especially the Atmega series. If I want to do something for my own or a proof-of-concept than I use Arduino that is fast to program, easy to interface with things and cheap. If I need more I use something embedded e.g. Raspberry, but than I ask somebody to program it.

[wraper]

I prefer Silicon Labs EFM8. Particularly EFM8UB1 for USB HID devices. They are cheap, require no external components besides decoupling caps, have built in Vreg, free IDE, easy to debug.

[Siwastaja]

STM32 due to large selection of devices, most with fairly good set of peripherals, and affordable pricing.

Not interested in IDE/debugging environment.

Inconsistency in peripherals between devices (hindering code reuse), poorly maintained documentation (where the documentation matches the original design intent, not how the implementation actually works - see separate "errata" to partially find out what they actually sold you, reverse-engineer the rest) are definite cons, but not showstoppers.

[balage]

So my answer is, I pick whatever I found the most convenient for the job and fits the bill.

Yes, but to use a specific family (if they fits the spacs) or a specific vendor is better as you are familiar with the vendor specific things, isn't it? You also care about which one you have used earlier, right?

[Siwastaja]

So my answer is, I pick whatever I found the most convenient for the job and fits the bill.

Yes, but to use a specific family (if they fits the spacs) or a specific vendor is better as you are familiar with the vendor specific things, isn't it? You also care about which one you have used earlier, right?

There is less difference than you might think. ARM standardizes the core, and thus the compiler and the tools are the same as well (if this is not true for someone, it's their problem. I use gcc, make, gdb and so on, and completely avoid all "different tool" issues.)

Even the peripherals between different ARM vendors are kinda similar in design principles. If you have made ADC work on one, it will be very similar on the next one. It's either one-hour job of finding out which library usage example to copy-paste, or a two-hour job of going through the registers with the manual. (The latter way allows you to take actual control of things later when you need any advanced features of those peripherals play together with your system. For example, in ADC, this would be injected channels, triggers from another peripheral, etc.)

On the other hand, there are variations even inside product families; STM32 is notorious for the fact that almost every device you pick has re-implemented basic peripherals and they are broken in a different way than the previous one you worked with.

If you can handle different STM32 products and product lines, there is little difference going for other ARM Cortex-M manufacturers.

STM32 is quite a good for a beginner, because they give you the false impression of giving you a product family, ecosystem, unified tools and all that shit. And when once hit the bullet, you find out the hard way there is no consistency, and not even stable tools, let alone libraries, but something "new" every other year. Now committed to this pile of steaming shit, you need to get the things done, and learn how to cope. After graduating this harsh reality, you are ready for any MCU you'll ever find!

[RoadRunner]

I have worked with many STM32 at work. After messing with many silicon level bugs throughout the product range, crappy driver library. Won't touch STM32  even with stick. Production also always have issue with sourcing the right part because STM32 had 1Zillion variant of every chip.

If going with ARM i will take NXP. with MIPS will take PIC32.  For Low power go with MSP430 or XLP PIC.

[brucehoult]

Hi, which µC are you preffering and why?
Where to find a good reliable microcontroller, well documented, good debug features, fast to program, easy to learn good IDE, good programmer/debuger?
Or is there not the one and really depends on your needs what you prefer and which manufacturer you choose?

It depends on what your needs are!

How much I/O, and what types? How big will your program code be? How much data? What processing speed?

I keep a few 8 pin ATtiny85's on hand. There's a lot of places you can just poke one. They need zero external components, start up at 1 MHz from the factory but you can switch them to 16 MHz for a bit more ooomph. Six I/O pins (but be cautious about reusing the reset pin), up to 4 as ADCs, 8 KB FLASH, 512 bytes RAM, 512 bytes EEPROM. About a US$ each from Digikey etc in small quantity. Easy to download programs to using an Arduino as a programmer, using either the Arduino IDE or avrdude directly. Use Arduino libraries or bit bang the registers yourself -- it's all easy.

If you need more I/O then the good old ATmega328 has four times the I/O, program size, RAM for $2 each in DIP-28. And the ATmega2560 has another 4x the I/O and RAM and 8x the program size for $10. Sadly with so many pins they only come in BGA and 100-TQFP, so it's generally better to buy them on a $10 board -- same price as the bare chip, so why not? e.g. https://www.amazon.com/dp/B07TGF9VMQ

The only thing is all these run at exactly the same speed, run full speed only with 8 bit data, don't have an FPU etc. It's enough speed for many many purposes.

The next thing that's super easy to use, with lots of documentation, libraries, examples is the $20 Teensy 4.0. For that you get a 600 MHz 32 bit dual-issue ARM CPU with FPU, 1024 KB RAM, 2048 KB flash, 40 I/O pins (23 easier to use than the others) https://www.pjrc.com/store/teensy40.html

You might consider a Teensy-LC for $12. It's got the same RAM, less flash, less I/O than the ATmega2560 at the same price but maybe around 10x the CPU processing power (but 20x less than the Teensy 4).

Again, Teensy board have a fantastic out-of-the-box getting started experience, great documentation and examples, work with the Arduino IDE and libraries or not -- your choice.


The RISC-V CPUs and boards coming out of China are looking very interesting.

The Longan Nano is $5 bought from China, $10 on Amazon. For that you get a 108 MHz 32 bit CPU, 128 KB flash, 32 KB RAM, a similar amount of I/O to an ATmega328 (swings and roundabouts) but 10x to 20x the processing power. And you get a small LCD display and plastic case thrown in for your $5.

There are also other boards using the same GD32VF103 chip -- which is close to being a clone of STM ARM chips with suspiciously similar product codes (and is in fact physically pin compatible) but with RISC-V CPU instead of ARM.

There are also the Kendryte K210 based RISC-V boards. These have pretty incredible specs, but a reputation for being not very well documented and hard to work with.

I think beginners should probably stay clear of these Chinese RISC-V boards for a while yet, even though they're very cheap and powerful.

[balage]

Yes, but to use a specific family (if they fits the spacs) or a specific vendor is better as you are familiar with the vendor specific things, isn't it? You also care about which one you have used earlier, right?

I only use the ones with very good API libraries and preferably an RTOS, so I don't care how the registers are used.
To me, anything with a standard C API is good. It takes me a few minutes to learn a peripheral with C API, so porting an entire project takes less than an hour. That's the cost I can take.

Ah, yes, that is clear for me now. This is how I should do things also, instead of diving into registers of atmegas... I am planning to move to Texas Instruments' MCUs, but the beginning of learning path is always a pain. And time consuming. I've started twice, but it was so complex I gave it up.

[ali_asadzadeh]

For ultra low price  in single qty (under 0.1$) I would go with padauk MCU, like PFS173 (have 8-bit ADC too), nothing beat's that thing, as a bounce you can build the programmer with a STM32 too, there's a thread on that in eevblog too.

For higher performance ones I would go to STM32 , like STM32F030KT6 for 0.5$ and go up till STM32H750 for around 4$,you can get 480MHz M7 with lot's of Stuff, for even higher performance I would go into i.MXRT series from NXP.

Also there is the G0 and G4 series from ST, that I would consider soon, when they are easily sourced from china with good prices.
Right now,I'm design a cool product that contain several paduak parts and an i.MXRT part and a GOWIN FPGA

[luiHS]

 
The NXP i.MXRT series, are cheap and very powerful (cortex M7 500/600Mhz).

MCUXpresso is the NXP IDE for their ARM microcontrollers, totally free, including the GCC compiler. I think today is much better than the ST CubeMX environment for the STM32.

I like many things about MCUXpresso, and with each new version they release, they include very useful features. I really like the SDK with many examples of source code for the most common applications, which you can import and use directly from the IDE.

I started using the Microchip PIC32 many years ago, then I decided to migrate to ARM with the STM32 of ST, already within the ARM world I decided to try the Kinetis of NXP with its MCUXpresso IDE, and now I am migrating to the i.MXRT NXP RT1020.

I think that today the NXP i.MXRT is the best option for any project with microcontrollers. The MCUXpreso development environment is fantastic, very easy to use, you have practically everything you need to work optimally, and all for free.

[mark03]

What I see in this thread is that [duh!] the preference depends on your criteria.

I use a lot of STM32 at work, so for me as a hobbyist, it is almost always faster to choose an STM32 that I am familiar with than to learn the quirks of a different vendor's ARM Cortex-M.  For me It makes sense to pick a family that I like and stick with it, so I tend to pick STM32L4 series for almost all hobby uses.  (Parts cost is irrelevant for a hobbyist, so there is no reason to scale down to an M0 or M3 core when you are already familiar with another one.)

Other than familiarity, your software strategy should probably be the main deciding factor.  Most people seem to use the vendor driver libraries, so if that describes you too, you should be swayed toward families with better SW libraries, and detailed documentation is slightly less important.  Me, I cannot stand using vendor code, so I generally write everything from scratch.  In this context, proper documentation in readable, grammatically correct English is *essential*.  I recently sat down with the i.MXRT 1060 reference manual to answer some questions about a design I was contemplating.  Four hours later, I had decided to use an STM32H7 instead, even though I would have preferred the extra horsepower of the NXP chip.  I cannot abide poor documentation, and the NXP reference manual was among the worst I have seen.  I could tell I would be wasting countless hours reverse-engineering the part if I were to choose it.  (In truth, almost every vendor's documentation nowadays is terrible, when compared to the 1980s or 90s, but ST Micro "wins" here by earning a C- or D+, rather than an F.)

[Styno]

I make primarily low wireless power sensors and have used MSP430FR2433 and FR2155 quite a bit. I especially enjoy the MSP’s simple clock tree and peripherals (i.e. interrupts and pullups/downs on all I/O). FRAM is great as it handles more like battery backup SRAM than EEPROM/flash. For small/fast projects there is Energia (Arduino) and for more serious work there is CCS. Energytrace++ is great for optimizing power and Launchpads for programing.

I also worked wit STM32L0 but found that much more complex, e.g. only one interrupt on each unique pin number for all ports? C’mon thats just backward.

[ogden]

Or is there not the one and really depends on your needs what you prefer and which manufacturer you choose?

Right. One size do not fit all. That's why so many various microcontrollers exist. In case you are inexperienced hobbyist - just pick Arduino. After you done mastering it, *then* most likely you will have better idea of what you actually *need*.

This is recurring question which is the same as to ask one single kind & size of nail for every possible carpenter work.

[daqq]

There's no 'One MCU to rule them all, one size to fit them all', otherwise they would have an absolute monopoly since no one would want to buy anything else.

That said, the STM32 series covers a pretty broad range of applications while managing to be reasonably coherent within the family and having reasonable tools. Expect the occasional issue.

[MarkR42]

I'm using the "TinyAVR" Microchip/Atmel chips, attiny1614 (small+ easily hand solderable), attiny3217 (top of range, more tricky) etc, they are relatively new and there are not a massive number of examples. They're far less popular than the older AVR chips or the PIC chips, but I can actually understand the datasheets.

I haven't really compared enough to know how good is the cpu core, of course it's an 8-bit core, but Jay Carlson seems to like it compared to other 8-bits.

I find the 8-bit chips easier to understand than the 32-bit stuff which is so common nowadays.

[norand]

From a strictly learning point of view, I started learning from the Arduino (using Arduino Language  ). It has it's drawbacks, but will give you a high level understanding of how to do simple tasks on a microcontroller, and there are plenty of examples and YouTube tutorials.

Once I got the grip of Ardunio stuff I started working on any Atmel chips I could program with an Arduino e.g AtTiny85 and ESP8266 and started learning proper C. However when I got to Uni, we were taught C on ARM based chips such as mbeds, and STM32 discovery kits. I found I have a much better understanding doing it this way, and wished I'd gone from Arduino straight to an STM32. There's also a fair few YouTube tutorials for some of there HAL libraries, and the MXCube software (GUI interface for microcontroller configuration) can be quite good from a beginners point of view, however I do try to avoid it where possible as sometimes there are problems you can't see under the hood!

I have never used a PIC, but a lot of the old folks I have met in Industry love them , I would expect a similar level of tutorials/examples to the STM32 to be available for the PICs too, but I've never heard anything bad said about them!

[ogden]

wished I'd gone from Arduino straight to an STM32

Right. Going Arduino->stm32duino->stm32 is good idea, especially using "blue pill" for stm32duino. When done with *duino, "blue pill" can be used for for bare stm32 programming as well. Worth to mention that Arduino, "blue pill" stm32f103 board and ST-Link programmer do not cost much.

[NorthGuy]

Hi, which µC are you preffering and why?

When a chicken hatches from an egg, he thinks the first object he sees is his mother. This is called imprinting. Of course, the object may be anything and the chicken's opinion about how his mother looks like is terribly biased.

The same with MCUs. The first one you use, you're going to like (unless, of course, you do some terrible mistakes and decide to blame them on the poor MCU). Same happen to other people. And that's what they tell you.

Then through the years you will have different projects, will try different MCUs. New MCUs will appear as well. In the end, they're not so much different. And the differences between families lie mostly in your emotions, skills, preferences etc.

Of course, you choose MCU for your task, so the set of MCUs you ever use will depend on what your projects are. And that's how you should start. Decide what your project requires, do a search, and use what fits.

[ogden]

And the differences between families lie mostly in your emotions, skills, preferences etc.

This is true only if *all* MCU's can be classified as "chicken". To say that AVR and ATSAM differ only in your emotions, skills and preferences is 

[nigelwright7557]

I am into ADC and  USB so using a PIC micro with Harmony was about the easiest way to go.
Harmony has modules for basic system i/o and clock, USB and ADC built in so saves a lot of time and hassle.
MPLABX is the IDE for PIC's. Definitely not the easiest thing to use but is functional once you find your way around.

[luiHS]

 
To my previous comment, I forgot to mention that I also tested the ATSAME70 Cortex M7 from Atmel / Microchip, series S70, E70, V70.

I dismissed them immediately, because the development environment is very bad, horrible, I have not seen in my life something worse done and more neglected. Besides the documentation is also terrible.

I have also tried Teensy boards that work with Kinetis microcontrollers, under the Arduino development environment. The hardware is fine, but the Arduino environment is terrible, very basic, I prefer to work with MCUXpresso for these boards, or directly create my own hardware with Kinetis or RT1020.

My priority list would be this:
1.- NXP i.MXRT, RT1020
2.- NXP Kinetis MK66, MK26
3.- ST STM32

Completely discarded for a long time, PIC32 and ATSAMS70 (S70, E70, V70), both from Microchip.

[mcovington]

For the cheapest and simplest, I have seen here two mentions of ATtiny and none of the low-end PICs.  What is the advantage of ATtiny?  (Just asking, not debating.)

[amymcneil]

My current fav is the STM32 family in all their glorious idiosyncrasies.  Mostly because the documentation doesn't suck too badly and I've put the time into understanding members of the STM32F0/F3/F4 families. I've done a number of projects with them and have been happy with the results and the minimal pain involved. This has been using the GCC tool chain along with the Black Magic probe, running in a UNIX type environment. The direct connection between GDB and the Black Magic probe make things really easy (assuming you aren't repulsed by GDB). WARNING: When moving from one STM32 chip to another, read the documentation of the peripherals you are planning on using CAREFULLY! You'd think that the UART would have the same features across all of the STM32 family, but NO! Ditto some of the other subsystems. The ARM core & ARM specified peripherals are consistent, though.

My second choice is the Atmel/Microchip AVR family. I've used the ATmega32U4 in a USB connected application for my employer using the awesome LUFA USB library (http://fourwalledcubicle.com/LUFA.php) and a couple other work projects using the atmega328 chip. All of these projects have been done using the GCC tool chain (avr-gcc) running under Windows. The projects were relatively simple, staying with one tool chain makes things easier to document for future coworkers.

I don't usually use the chip manufacturers' libraries except as a reference on how to program the peripherals. Way too often adding one of those libraries results in far much bloat and not enough space for *my* stuff!

I prefer working with multiple text windows rather than an IDE, most probably because I'm an old school UNIX geek, that's the way I'm most comfortable with. 'make', properly set up (feels like more art than skill some days), can do wonders. If you use Windows and want a decent IDE for the AVR series parts, the Atmel AVR Studio offering is a great way to get up and running (price is right, too - free!), assuming you are already comfortable with direct programming of the chip and the 'C' programming language. The documentation that Atmel provided for the AVR series of chips is excellent. Very readable, easy to understand and detailed.

If you are just getting your feet wet, start with the Arduino environment. Great beginner's environment to get familiar with the world of microcontrollers (two of my children have learned programming and basic electronics this way). Once you start feeling like the environment is limiting you, you're ready to move on to something like AVR Studio, or bare metal programming with GCC.

[NorthGuy]

And the differences between families lie mostly in your emotions, skills, preferences etc.

To say that AVR and ATSAM differ only in your emotions, skills and preferences is 

LoL!

Absolutely so. If you want to pick up your first MCU to start fiddling with, whether you select AVR or SAM, will not make any difference whatsoever. And if someone thinks differently, this is because of his emotions, skills, preferences etc.