Where to begin? STM32F0 vs PIC32mx vs MSP432 vs ...

[HzMeister]

If you were just starting out, without knowing a single line of code or anything about microcontrollers, what would you pick? STM32F/L0, PIC32mx, MSP432 or other?

[ataradov]

Anything ARM-based. From this list STM32F.

[nctnico]

I'd definitely look at NXP's LPC series ARM Cortex microcontrollers as well. The peripherals are easy to work with and they all come with a bootloader which allows easy programming through the serial port (or even USB as a mass storage device). I know ST usually wins on price but IMHO that is about where their 'advantage' ends.

[mikeselectricstuff]

Depends entirely what you want to do, but in terms of ease of setting up the toolchain, PIC32 is very straightforward, in that MPLAB takes care of stuff like linker settings and including the right device-specific files for you.
 
If you just want to get into higher end MCUs it probably doesn't really matter which, and the core is probably the least important of all as the compiler takes care of it - it's much more about the peripherals.

[dannyf]

Unless you are already invested in pic, I wouldn't pick pic32 as a platform to learn;

STM32F0 is fairly feature limited. So I would start with F1 as a generic platform - it is older and slower. F3 for analog / mixed signal capabilities. The Nucleo boards there are great as it provides arduino compatible headers.

MSP432 is a weird platform, being new and with a mixed bag of ARM and TI/MSP430 peripherals. I would pick it if you are migrating up from MSP430 or are already familiar with Luminary / Tiva chips.

NXP's offerings aren't that exciting, and the software side is a mess. If you have to go down that path, pick LPC11xx (1114 for example) as simple beginner-friendly starting point, or LPC1768/69 for a full-featured chip.

LM4F120 launchpad is probably the most feature rich mcu out there. Great performance and lots of code. But unfortunately quite buggy.

If I were to do it again, I would go with a STM32F3 Nucleo. and then maybe STM32F1 minimalist board, or MSP432 just for the challenge.

[HackedFridgeMagnet]

After spending 2 hours helping someone get started on an STM32F4.

If they don't know how to code then I would suggest go Arduino.

[HzMeister]

Anything ARM-based. From this list STM32F.

Thanks for the reply. Would you recommend anything better that's not on the list?

I'd definitely look at NXP's LPC series ARM Cortex microcontrollers as well. The peripherals are easy to work with and they all come with a bootloader which allows easy programming through the serial port (or even USB as a mass storage device). I know ST usually wins on price but IMHO that is about where their 'advantage' ends.

Just checked their site and their software/documentation seems organized at first glance. Will be downloading their IDE to see what it's like. How would you compare their LPCXpresso IDE to ST's CudeMX+Keil? Btw, is configuring the bootloader and programming through a serial port easier/quicker than with the included stlink programmer that's on stm32 boards?

Depends entirely what you want to do, but in terms of ease of setting up the toolchain, PIC32 is very straightforward, in that MPLAB takes care of stuff like linker settings and including the right device-specific files for you.
 
If you just want to get into higher end MCUs it probably doesn't really matter which, and the core is probably the least important of all as the compiler takes care of it - it's much more about the peripherals.

That's why I included PIC in the list. I've seen several other forum posts mention how much easier PIC is compared to ARM - but those were over a year old and things change fast. With of the chip vendors updating their toolchains constantly, is that still the case?

Unless you are already invested in pic, I wouldn't pick pic32 as a platform to learn;

STM32F0 is fairly feature limited. So I would start with F1 as a generic platform - it is older and slower. F3 for analog / mixed signal capabilities. The Nucleo boards there are great as it provides arduino compatible headers.

MSP432 is a weird platform, being new and with a mixed bag of ARM and TI/MSP430 peripherals. I would pick it if you are migrating up from MSP430 or are already familiar with Luminary / Tiva chips.

NXP's offerings aren't that exciting, and the software side is a mess. If you have to go down that path, pick LPC11xx (1114 for example) as simple beginner-friendly starting point, or LPC1768/69 for a full-featured chip.

LM4F120 launchpad is probably the most feature rich mcu out there. Great performance and lots of code. But unfortunately quite buggy.

If I were to do it again, I would go with a STM32F3 Nucleo. and then maybe STM32F1 minimalist board, or MSP432 just for the challenge.

What are some negatives about PIC?

I chose the F0/L0 MCUs because you get Keil MDK free with them - apparently it's very good. The NUCLEO-F091RC/F072RB is near the top of my list. Besides, since I'm just starting out, I don't expect to be using anywhere near the available capabilities.

I considered the MSP432 because it's ARM and and since TI makes it, I expect the software, documentation, libraries, etc. to be top notch. Plus the code composer studio if free right now with their dev board. If the support isn't any good, then there is no way I would consider it.

I've read several other forum posts that NXP software is not the best. If that's the case, then it's a huge turn off. Having to deal with subpar tools when learning anything is a drag.

After spending 2 hours helping someone get started on an STM32F4.

If they don't know how to code then I would suggest go Arduino.

i considered arduino just like anyone else starting out, and they look awesome just to play around with. But once you get out of their proprietary IDE, all you're left with is an 8 bit AVR. Then I would have to relearn a new architecture, toolchain, etc. I would rather pick something I can grow in to and master, not something to grow out of.

[ataradov]

Thanks for the reply. Would you recommend anything better that's not on the list?

I personally would go for STM32F4.

Btw, is configuring the bootloader and programming through a serial port easier/quicker than with the included stlink programmer that's on stm32 boards?

If you are serious about doing this for living, then get real tools. What's the point of learning the easy thing, when in real life you will have to use proper programmers?

how much easier PIC is compared to ARM - but those were over a year old and things change fast.

Again, easy does not mean useful. I would say it is easier to find employment with ARM experience. And if you know the "harder" thing, it is always easier to figure out the "easy" thing.

With of the chip vendors updating their toolchains constantly, is that still the case?

For ARM, ARM themselves provide a toolchain and it is as good as it gets.

since TI makes it, I expect the software, documentation, libraries, etc. to be top notch.

That's just not true. There is no good software stack from any manufacturer. They all have problems that you will have to deal with.

If the support isn't any good, then there is no way I would consider it.

Then you've picked the wrong area

I've read several other forum posts that NXP software is not the best. If that's the case, then it's a huge turn off. Having to deal with subpar tools when learning anything is a drag.

That's how it goes in this industry, so you will have to deal with that.

[HzMeister]

If you are serious about doing this for living, then get real tools. What's the point of learning the easy thing, when in real life you will have to use proper programmers?

I'm serious about learning MCUs. I want to get up and running asap with the big easy steps and work my way towards the complicated ones.

Again, easy does not mean useful. I would say it is easier to find employment with ARM experience. And if you know the "harder" thing, it is always easier to figure out the "easy" thing.

That's true. But if you don't know anything, then I think it would be more helpful to know the easy thing first, don't you?

For ARM, ARM themselves provide a toolchain and it is as good as it gets.

Isn't it prohibitively expensive though? What would you say is second best?

[ataradov]

That's true. But if you don't know anything, then I think it would be more helpful to know the easy thing first, don't you?

I typically go straight for what I think I need. This does not always work out as expected, but in many cases it does. But that's my personal preference.

In any case, I strongly recommend to not use manufacturer libraries. Especially if you are learning. MCUs are actually way easier to understand if you look at a low level.

Sure, you will get blinking light faster with demo examples, but that does not make you any closer to understanding or knowing anything.

Cortex-M processors are brilliantly designed so that you can do everything with C, including the startup code.

And if you don't know C, I would strongly recommend to postpone playing with MCUs and get up to speed with C on the PC.

[ebclr]

http://www.silabs.com/products/mcu/32-bit/Pages/efm32-g8xx-stk.aspx

[HzMeister]

I typically go straight for what I think I need. This does not always work out as expected, but in many cases it does. But that's my personal preference.

In any case, I strongly recommend to not use manufacturer libraries. Especially if you are learning. MCUs are actually way easier to understand if you look at a low level.

Sure, you will get blinking light faster with demo examples, but that does not make you any closer to understanding or knowing anything.

Cortex-M processors are brilliantly designed so that you can do everything with C, including the startup code.

And if you don't know C, I would strongly recommend to postpone playing with MCUs and get up to speed with C on the PC.

I just started learning C this past week and for someone with no programming experience, it's a steep learning curve...

The only reason I'm learning C in the first place is to be able to program MCUs and a lot of the info out their is geared towards coding for software(which is useful but extraneous) I want to at least pick up a dev board so that I can apply concepts I learn and look at example code of how others did it. The platform with the best software and support will significantly take the edge off the aforementioned learning curve.

I made this thread looking for advice from people who have dealt with various platforms and know the strengths and weaknesses of each and can recommend the right stepping stone for beginners. While learning from scratch can certainly make a determined person into an MCU master, there are certainly quicker and less painful ways of doing it.

http://www.silabs.com/products/mcu/32-bit/Pages/efm32-g8xx-stk.aspx

I looked into the EFM32 gecko line of MCUs and even installed their Simplicity Studio IDE to take a look at. While they look pretty cool(especially their bluetooth SOCs), there doesn't seem to be a lot of community support for them. How are they better than others like like the STM32?

[ataradov]

I just started learning C this past week and for someone with no programming experience, it's a steep learning curve...

I personally would not layer the need to learn MCUs on top of that.

(which is useful but extraneous)

Not really. Almost everything from "desktop" C can be applied for embedded systems. Some of the things may be a bit heavyweight out of the box (like file operations), but they still will work.

I do MCU support for a living, and it is my general observation that official support will help you with questions on the MCU itself, but knowledge of C will be assumed. Official support people give up trying to teach general programming pretty fast. Community support may be a bit more tolerant, but still, trying to explain intricacies of the hardware to a person struggling to understand the language can be very hard.

[rstofer]

Learning C and learning embedded programming all at the same time is going to be fairly difficult.

I would suggest you start with the Arduino because it will let you write C & C++ programs for a platform that is very well known.  There are a ton of sample programs that come with the IDE and even more projects on the Internet.  There's nothing like success to build confidence.  I don't personally use the C++ approach, I am more of a C kind of programmer.  This is the easiest platform for getting started.

Next up, I would consider the mbed (LPC1768 version).  The toolchain doesn't need to be installed, all programming is done through a web browser.  Very clever!  There are many examples and a lot of library code.  www.mbed.org

Moving up, I am now working with the STM32F4 series devices.  In may ways, they are a PITA but I'm learning my way around.  Consider buying "Mastering the STM32" book because it will show you exactly how to set up the toolchain and get everything working.  It's important that the tools match the book.

You will notice on the mbed.org site that MANY STM32F boards use exactly the same approach to programming as the original mbed board.  Playing with the mbed is a nice way to transition for the STM32F Nucleo boards.  Definitely put these boards on back burner until you have a whole lot of experience.

[forrestc]

If you were just starting out, without knowing a single line of code or anything about microcontrollers, what would you pick? STM32F/L0, PIC32mx, MSP432 or other?

I'm not sure if I was starting where you described that I would start with the question you're asking.

A better question would be:   What is the easiest/fastest way to get up to speed learning about microcontrollers?

Picking a microcontroller for learning is completely different than picking a microcontroller for a project.   I use PIC microcontrollers professionally every day, and am pretty partial to them.   The other microcontrollers also have plusses and minuses.

But if someone says 'I want to get started and have no background', I'm going to point them toward an Arduino or similar with good 'getting started' documentation.  The reason?  There are some basics one need to master, and an Arduino is a good way to get started learning the programming basics.   I may even go as far as to point them toward something like https://www.sparkfun.com/products/12060 or https://www.adafruit.com/products/170 .   The other path is to find a good lesson manual and buy whatever they recommend.

Once you master that basic skillset, then you can move onto something bigger and badder.   

[HzMeister]

Yeah that's why I mentioned getting a Raspberry Pi to learn basic programming in C, Python, Lua, C++.
Either your current PC or a Pi like LINUX SBC is best to learn C with because you don't have to learn MCU architecture on top of the C learning curve.  You can also freely use constructs like printf, fprintf, getenv, scanf, sprintf, sleep, getchar, putchar, allocate as much heap and stack memory as you can reasonably want, and you never have to worry whether you broke the hardware with your program or with your device programming manipulations.

#include <stdio.h>
#include <stdlib.h>

int main( int argc, char **argv ) {
   printf("Hello, World.\n");
}

Takes 60 seconds to experiment with a C program or new function call on a PC whereas there are several layers of library, device programming, I/O, and debugger / toolchain complexity with doing the same for a MCU.

Just follow through Kernighan & Ritchie and you'll be programming in C in a couple of months in your spare time no problem.

Maybe try Visual Studio community edition or something if you're bound to use MS Windows for an IDE with code completion and colorization and stuff though if you want to use MCU tools on MS Windows, use the free lite Keil MDK 5.

Thanks for your great replies, especially your previous post commenting on each platform. I didn't even consider cypress so I'll definitely check them out. While it would be great to buy several different dev boards and experiment with all of them(especially after I have some experience under my belt), my budget(both with time and money) is limited.

Btw, the raspberry pi looks really useful for learning C, albeit a little overkill and a little pricey. I'll check it out though.

Learning C and learning embedded programming all at the same time is going to be fairly difficult.

I would suggest you start with the Arduino because it will let you write C & C++ programs for a platform that is very well known.  There are a ton of sample programs that come with the IDE and even more projects on the Internet.  There's nothing like success to build confidence.  I don't personally use the C++ approach, I am more of a C kind of programmer.  This is the easiest platform for getting started.

Next up, I would consider the mbed (LPC1768 version).  The toolchain doesn't need to be installed, all programming is done through a web browser.  Very clever!  There are many examples and a lot of library code.  www.mbed.org

Moving up, I am now working with the STM32F4 series devices.  In may ways, they are a PITA but I'm learning my way around.  Consider buying "Mastering the STM32" book because it will show you exactly how to set up the toolchain and get everything working.  It's important that the tools match the book.

You will notice on the mbed.org site that MANY STM32F boards use exactly the same approach to programming as the original mbed board.  Playing with the mbed is a nice way to transition for the STM32F Nucleo boards.  Definitely put these boards on back burner until you have a whole lot of experience.

...
But if someone says 'I want to get started and have no background', I'm going to point them toward an Arduino or similar with good 'getting started' documentation.  The reason?  There are some basics one need to master, and an Arduino is a good way to get started learning the programming basics.   I may even go as far as to point them toward something like https://www.sparkfun.com/products/12060 or https://www.adafruit.com/products/170 .   The other path is to find a good lesson manual and buy whatever they recommend.

Once you master that basic skillset, then you can move onto something bigger and badder.   

Very good points. After thinking about it, Arduino may actually a good tool to get you feet wet in the beginning considering the complexity of the subject. I dismissed it because it's not ARM(or PIC) and I didn't want to waste time learning something I'll never put into use. Btw, which arduino version do you recommend?

mbed looks interesting. Lots of boards supported. How useful is it actually?

While I'll definitely be focusing most of my efforts into learning C, I wanted to have a 'real' mcu dev board or two on hand just try even the most basic of things - to the point where it wouldn't even matter what I'm using. However, as I gain more skill and slowly learn how to work with MCUs, that very platform I chose now will be increasingly more important since it's what I'll be investing the majority of my time in. So any and all opinions on why a platform is superior over another are welcome.

[jesuscf]

What a small world!  Recently I asked myself the same question.  I decided to answer it with a little experiment during my recent vacation:  buy a bare micro-controller from DigiKey and get running both a 'blinky' and 'hello world' using only free tools or other ICs that are easily obtainable by anyone.  I didn't want to buy any programmers, IDEs, debuggers, or any other pre-made hardware or software.   My first step was to build a simple USB to Serial adapter around the FT230XS IC from FTDI.  That little board turn out to be extremely useful as it allowed me to load program to to the micro-controllers I tried either using serial boot-loaders or in-system programming via the likes of SPI or JTAG.

My first pick was the LPC824 from NXP.  The chip is about $2 and comes with a serial boot-loader that was easy to activate.  The LPC824 is only available in surface mount packages, so I soldered it into an adapter to assemble the circuit in a breadboard.  The compiler I used is GCC for ARM.  I downloaded the latest version of GCC for ARM from https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads.  The serial down-loader I use  was lpc21isp downloaded from https://sourceforge.net/projects/lpc21isp/.  There was a problem with the down-loader that prevented downloading to all the memory of the LPC824, but it was easy to fix (SectorTable_8xx[] had only 16 pages defined instead of 32). I found some examples around the net that helped me get started with both 'blinky' and 'hello world'.   In all, it took me about 2 days to get the LPC824 going.

My second pick was the STM32F051 from ST .  Also around $2 from DigiKey.  I soldered the LQFP32 package into an adapter for bread boarding. This processor comes also with a serial boot-loader that is easy to activate. The down-loader I used was FLASHER-STM32 available from http://www.st.com.  The compiler I used was also GCC for ARM that I have already installed for the LPC824.  Once again I found examples around the net that allowed me to quickly get 'blinky' and 'hello world' going.  This one took me less than a day.

My third pick was the ATmega328 from Atmel (yes the same one in the Arduino board).  Around $4 from DigiKey.  I used also GCC, which I downloaded from the Atmel page http://www.atmel.com/tools/ATMELAVRTOOLCHAINFORWINDOWS.aspx.  For this one I wrote an ISP programmer using the FT230XS IC configured in bit-bang mode.  I got that going fairly quickly, although to be fare I should point out that I just adapted a programmer I wrote for the AT89LP family of micro-controllers from Atmel that have a very similar programing interface to the ATmega328.  For the ATmega328 I got both 'blinky' and 'hello world' going in about a day.

My fourth pick was the PIC32MX170F256B from Microchip.  Around $5 from Digi-Key.   This one was a nightmare!  First, there is no freely available GCC compiler you can download, except from Microchip.  So I decided to build the compiler from sources.  It took me about 3 days to build the compiler, but none of my compiled programs worked out.  Finally I gave up and downloaded the free-but-crippled XC32 compiler from Microchip.  For my initial tests I used a programmer built around an Arduino board: https://github.com/ppersia37/ardupic32.  The programmer is very slow but it got me started.  So after about week I got both 'blinky' and 'hello world' going.   I was not happy with the programmer, so I wrote a JTAG programmer around the FT230XS which is orders of magnitude faster than the one built around the Arduino.  I don't remember how long it took me to get the programmer done, but for sure it was at least a week (and several bricked PIC32s!).    At some point, after some discussions about XC32 in this forum, user 'Karel' posted instructions on how to un-cripple XC32 (https://www.eevblog.com/forum/microcontrollers/pic32-evolution/msg1007099/#msg1007099) which worked quite well.  After what seems a long time I ended up with a nice setup for the PIC32 which I quite like.

My fifth pick was the MSP430, but my vacation was over, so I didn't have time to try it out (reason: see paragraph above!).

So which one is my favorite?  All of them!  Once I got things going, they were very similar from the programmer's point of view.   I like the easiness of both the LPC824 and STM32F051, but the PIC32MX170F256 has a lot more memory and 'feels' powerful (may be I struggled so much with it that I 'appreciate' it more).  At some point trying to use printf() (via newlib nano) with the LPC824 I ran out of Flash memory.  There are many ways around this problem, so for me is not a deal breaker.  Even the Atmega328 felt right despite being an 8-bitter!  In the picture below are the bread boarded-micro-controllers, from left to right the AT89LP52 (which I use quite a bit, the Atmega324 programmer is based in the programmer I wrote for this one), LPC824, STM32F051 (with a pot attached, as I also tested the ADC), Atmega328, and PIC32MX170F256.

[JPortici]

I recommend NXP as a starter for ARM.

*audience hold their breath*

- Yes, their demoboard cost a bit more than ST
- Yes MOST LPCs are not as attractive as a stm core (though i am making experiments with the M4F / M0+ dual core. i plan to use the M0 to make up for the absence of some peripherals like the FSMC/tft controller)

but

- available also in smaller packages
- comparable parts with a lot more program/data memory on board
- documentation is far more readable (and solid. no info scattered around the datasheet(s)), example circuits in the actual datasheet.
- the hal is easier to understand, cleaner, and with a blink of an eye you can go bare metal.
- their code examples do work and they are written in bare metal style.
- probably the most important of all they actually give you an IDE, which is of course another modified eclipse, that actually works out of the box. if you are a beginner or you don't want to waste time installing this and that and troubleshoot the occasional bug you have the complete package ready for you, for windows linux and osx. The modified eclipse actually has a couple of neat addons like the peripheral view

[dannyf]

What are some negatives about PIC?

I assumed, maybe incorrectly, you wanted to learn this as a marketable skill. ARM is all the raged and few cares about your PIC skills.

I chose the F0/L0 MCUs because you get Keil MDK free with them - apparently it's very good.

It is very capable. But also quite challenging for a newcomer, especially v5.x.

I considered the MSP432 because it's ARM and and since TI makes it, I expect the software, documentation, libraries, etc. to be top notch.

No correlation there.

I've read several other forum posts that NXP software is not the best. If that's the case, then it's a huge turn off. Having to deal with subpar tools when learning anything is a drag.

if you with lpcxpresso, the compiler is top notch, being gcc. the ide is very good, being eclipse.

the issue is with the proprietary debugger and debugging interface, and the half baked mess called lpcopen.

chip-wise, the lpcs are some of the least featured but most robust chips. so a trade off there.

As to starting out with a simpler-featured chip, as a "development board", you want it to have the most feature so you can keep learning on it. so F3 or F4 Nucleos if you want to go with ST.

[tszaboo]

Yes. For a beginner, setting up the toolchain IS the biggest issue, after that, getting information on how to do things.
So where to begin... Arduino. Setting up the toolchain is simple. Getting information on how to do stuff is simple. Making prototypes is simple. You learn "kinda-sorta" C programming, you learn about peripherals, you learn about protocols. Start there. Engineers will avoid the topic, or discourage you that it is not real programming or real electronics, dont listen.

I have to agree, starting with PIC is simple, I did that myself, with ASM language and almost only the datasheet as information. You know what? I've learned a lot. But even now, when I have to set up a GCC toolchain for ARM, it is magic pain in the ass issues with make files, links missing, path not set up correctly, etc. Microchip PIC32 with works out of the box. MBED works almost out of the box. Arduino is excellent.
Setting up a toolchain for ST, NXP is horrible. Libraries are pain to track down manage, make them work.
So the only time I design with them, is when someone else writes the code, and I only design the PCB.

[westfw]

Quote

without knowing a single line of code or anything about microcontrollers

Knowing NOTHING?

Start on a desktop (with an actual "programming for CS majors" type of class search.  Python, Java, C, C++... doesn't matter), or with something Arduino-like.   A TI Tiva Launchpad will get you a modern ARM chip, let you use Energia ((very)Arduino-like IDE), and set you up to be in the UTexas online "Microcontroller" classes (after you know at least one language (and preferably some C.))

Somewhere in there you should learn some electronics basics, too.

(Hmm.  I've taken (parts of) online python classes from three different schools relatively recently, and they've all been pretty good.  (Rice, Michigan, and MIT.)  OTOH, Learning python will teach you some neat stuff that isn't available in C, or (in general) on microcontrollers.)
Sort of half of a university curriculum:  (the other half would be science and math)
1) Programming 101 (UMichL:python), Electronics 101 (?)
2) Algorithms (princeton), C programming (?)
3) Microcontrollers (UTexas), Digital logic (?)
4) operating systems (Utexas?), user interface design (?)
5) practice...

[hans]

http://www.silabs.com/products/mcu/32-bit/Pages/efm32-g8xx-stk.aspx

I looked into the EFM32 gecko line of MCUs and even installed their Simplicity Studio IDE to take a look at. While they look pretty cool(especially their bluetooth SOCs), there doesn't seem to be a lot of community support for them. How are they better than others like like the STM32?

I think the out-of-the-box experience is quite nice. The dev boards are competitively priced and versatile to use. The toolchain is all set up unlike most other vendors, which you must arrange all by yourself. This could be a massive winner.

However for the chips itself.. notice that the EFM32 are a niche MCU targeted for battery and IoT applications. This is reason why it doesn't win the pick for many community projects. If you find yourself needing ethernet connectivity, then EFM32 probably has little to offer with an integrated ethernet MAC. Or want to do some heavy number crunching? STM32 (but also NXP, TI, etc.) have CPU's that go up to 100 or 200MHz. These drop the requirement "low power"; so they can do that.

If I were you, I would go with the flow in order to get the most "community support" and find most info. And that is Arduino, then STM32.
That is if you really do know nothing indeed.

[newbrain]

Very good points. After thinking about it, Arduino may actually a good tool to get you feet wet in the beginning considering the complexity of the subject. I dismissed it because it's not ARM(or PIC) and I didn't want to waste time learning something I'll never put into use. Btw, which arduino version do you recommend?

Yes, as usual here, you have been provided with a lot of good advice: opinions differ of course but you have a lot of material to make up your mind.

My experience is from a hobbyist pow, I work in the SW field but not on embedded stuff.
I mostly use STM32Fxxx (depending on the specific needs) and a bit of ESP8266 (dirt cheap on "AliBay"), MSP432 and Atmega/tiny, coming all the way from 6502, 6809 and 68HC11.

My 2 cents:

• Focus on learning C: you state in your initial post "...without knowing a single line of code or anything about microcontrollers..." and going Arduino will not help much (it's actually C++, but one tends to just cobble together high(ish) level libraries...); try to learn good style in coding and work your way through a good book, keep you on ANSI standard C (no OS specific stuff) and you'll have a very portable set of C skills.
• To learn C, you don't really need a Raspberry Pi (though I love them, I have several): if you have a PC/MAC with Linux/Windows/OsX there plenty of free IDEs or command line compilers. I'm partial to Visual Studio (community edition is free and very complete) and now VS Code (that's even open source!), but that's just me, good alternatives abound.
• IMO, C++ is a different language that happens to use the same syntax: I would not try to learn both at the same time, lest you end up with some confusion.
• If you still want to program Arduino-style many ARM boards are supported by mbed (Nucleos are much cheaper than Arduinos!): same ease of use, but also more powerful if you use advanced stuff (I'm not a fan myself)
• Psoc is very interesting, but its programmable logic part will add another step to the learning process...
• Don't expect high quality and support in vendor provided libraries (see my ranting with Texas here), some are better, some are worse, none is stellar.
• Hardware-wise: In the STM32 field, if you want something more than a bare bone MCU (Nucleo style) there's a wide choice of Discovery boards, the mentioned F7 is very nice board, maybe a bit daunting for a newcomer (and very few I/Os are free for you to use). I'd settle on a cheap Disco F4 (MEMS accelaration sensor, audio DAC), or Disco F429 if you want a display.

[dannyf]

"when I have to set up a GCC toolchain for ARM, it is magic pain in the ass issues with make files, links missing, path not set up correctly, etc."

That's because you picked the difficult path.

For most ide, it is nothing more than downloading and installing the compiler and point your ide to it.

A 30 seconds job.

[nctnico]

"when I have to set up a GCC toolchain for ARM, it is magic pain in the ass issues with make files, links missing, path not set up correctly, etc."

Whatever you don't know how to do is hard. GCC is simple as soon as you know how the compilation process works under the hood. That isn't difficult but many IDEs like to hide that from the user and the compiler also seems to know things by magic. But like any magic trick: what really happens is simple.