Suggestions for a microcontroller (general-purpose)

[brucehoult]

RV32I or RV32E are the simplest and most orthogonal

I have nothing against RISC-V, and I can see its advantages, but for the first foray into 32 bit territory I still think a bit more mainstream is an easier path.
The regularity of the IS is a plus though, I have some RISC-V dev boards, but nothing with the support level of the Pico, are there any that you can suggest?

The Pico 2 is the obvious example if you like the Pico. You get all the same Pico documentation, same peripherals, same everything but with the possibility to write your code using RISC-V instead of Arm. You can even run one Arm core and one RISC-V core at the same time if you really want to.

The CH32V003 is a cool little simple cheap chip, with only a fraction of a features of the Pico, but perhaps as a result something you're more likely to be able to completely understand. THE Olimex RVPC is a cool little €1 kit using a CH32V003 in the 8 pin package as the only active component [1] but manages to provide a PS/2 keyboard input, a bit-banged VGA output, and sound. The chip comes preprogrammed with a reimplementation of the Apple I's WozMon which lets you examine memory, poke new values in, and run code starting as an arbitrary location. RV32E isn't as easy to hand-assemble code for as the 6502 was, but on the other hand most people now will have a PC handy to do that on, and then only have to type the hex codes in.

There are also some other demo programs e.g.



2k of RAM and 8 pins, baby!

The bare CH32V003 chip is also quite fun, in the same way as an ATtiny85, in that it can run on anything from 2.8V to 5.5V and once programmed doesn't need any external components such as crystal or capacitor, but just the power supply. So it's very easy to use on a breadboard (with an SOIC-8 breakout board), or dead-bug, or things like that.

[1] ok, there's a transistor to drive the piezo speaker

[Peabody]

I did a lot of assembly coding for the 6502 back in the day, but did some more recently with TI's MSP430 line.  They are 16-bit von Newmann processors, so assembly was pretty straightforward, and very similar to 6502.  They have internal oscillators, and use very little power.  TI's IDE however was more than I wanted to learn to use, so I just used a programmer's editor and the Naken assembler, which is free, tiny and fast.  Flashing was JTAG using TI's Launchpad, or in-circuit, using TI software.

But the big advantage of the likes of Arduinos and ESP32 is the abundance of "modules" from the Far East to do almost anything you would want on the hardware side.  Nothing like that exists for the MSP430.  And the software catalog for those lines is immense, just in case you ever want to go to higher level programming.  I just don't know what assembly is like for those chips.

Anyway, I think there's something to be said for using what everybody else is using, which tends to make things easier and cheaper.

[zapta]

If you want to program in assembler, I would stay away from 32 bit architectures, because of their complexity (not necessarily the instruction set itself but the peripherals, configuration, and so on), and go with 8 bit MCUs.  Also, I would also look for a hardware debugger or at least a simulator that support breakpoints and single stepping.

[Analog Kid]

Let me just clear up one point here, which is my choice of programming language:
Yes, I prefer to use assembler rather than C/C++/Python, etc.
It's not because of any raging "need for speed", although that is often the outcome;
it's just that I prefer using assembly language over a HLL. I've been doing it for a long time on x86 under Windows.
And my previous experience with a micro was programming the SX-28 in assembler, which worked nicely.
I'm a hobbyist, not looking to ever go into production with any of my li'l projects.
It appears from several responses that I'll be able to program most any micro in its native assembler, which is good.

[bobxyz]

I'd suggest buying a Raspberry Pi Pico board for $4 (https://www.sparkfun.com/raspberry-pi-pico.html) and trying it out with MicroPython (https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-python-sdk.pdf).  There are lots of good introductory tutorials, and a couple books, easily available.  See if you like the environment and the documentation.  If not, try a simple STM32 board, or post back here with what you liked and didn't like.

While there's a satisfaction in programming in Assembly and getting down-and-dirty with the CPU architecture, the days of needing to use Assembly are long gone.  Back in the day, memory was expensive and lower cost processors didn't have enough to easily support a C stack, nor were they fast enough to overcome inefficient C compilers and/or poorly written code.  Today, even the $4 pi pico board has 256KB of RAM and 2MB of flash, with dual Arm processors, and an Arm processor architecture that works well with compilers.

If you like playing at the hardware level, the RP2040 includes a couple PIO modules that are programmed in assembly using a tiny instruction set.  Quoting the manual:

"Programs for common interfaces, such as UART, SPI, or I2C, are available in the PIO library, so in many cases, it is not necessary to write PIO programs. However, the PIO is much more flexible when programmed directly, supporting a wide variety of interfaces which may not have been foreseen by its designers."

[Analog Kid]

While there's a satisfaction in programming in Assembly and getting down-and-dirty with the CPU architecture, the days of needing to use Assembly are long gone.

You're not getting what I'm writing.
I don't need to use assembly language:
I prefer to use it.
So Python? Thanks but no thanks.

[peter-h]

I did megabytes of  code in asm too, Z80 etc. Then went to C. Much more productive...

Basically, most micros can do most jobs. You can make choices on various criteria. Some people hate STM. I use STM but made progress only because somebody else set the project up (Cube IDE). But from where I am now, I will carry on and the 32F4 will do me for the rest of my life (~20 years left ). I would not use Atmel AVR because of poor product life. Various things like that from different people. I would not use a chinese chip (ESP32) because of the obvious political risk. I have a lot of experience of doing business with China...

Now what can really drive a chip decision are things like

- low power (note: you can make any chip low power if you are able to run it on a small duty cycle)
- special peripherals
- previous experience (can be hugely significant if you own the business )

So think about that.

[jpanhalt]

Can we stick to common lexicon:

Assembly is the process of writing programs in assembly language, while an assembler is a program that translates assembly language into machine code.

Please excuse the pedagogy.

[Tation]

RV32I or RV32E are the simplest and most orthogonal

I have nothing against RISC-V, and I can see its advantages, but for the first foray into 32 bit territory I still think a bit more mainstream is an easier path.
The regularity of the IS is a plus though, I have some RISC-V dev boards, but nothing with the support level of the Pico, are there any that you can suggest?

The Pico 2 is the obvious example if you like the Pico. You get all the same Pico documentation, same peripherals, same everything but with the possibility to write your code using RISC-V instead of Arm. You can even run one Arm core and one RISC-V core at the same time if you really want to.

I'm not, in fact, a heavy supporter of the RP MCU's, but from the OP goals, I think that Pico 2 boards are the ones best fitting his needs.

[Analog Kid]

Can we stick to common lexicon:

Assembly is the process of writing programs in assembly language, while an assembler is a program that translates assembly language into machine code.

Please excuse the pedagogy.

You're absolutely correct here, and your pedantry is excused.

[bobxyz]

You're not getting what I'm writing.
I don't need to use assembly language:
I prefer to use it.
So Python? Thanks but no thanks.

OK, since you're set on using assembly language, why don't you try a simple search on youtube to see if you can find what you're looking for?  For instance:
https://www.youtube.com/results?search_query=arm+assembly+language  or
https://www.youtube.com/results?search_query=rp2040+assembly+language

[Analog Kid]

Because I don't use YouTube for obtaining that kind of information. I prefer text.
So far you're 0 for 2.

[squadchannel]

I would recommend tinyAVR and megaAVR series. They are inexpensive with a reasonable pin counts, and development boards (Curiosity nano, Explained nano etc...) can be purchased at low cost.
I think ASM can be used as well. But I never used ASM.

[brucehoult]

I think ASM can be used as well. But I never used ASM.

Blind leading the blind.

Yes, OF COURSE asm can be used on EVERY microcontroller.

The issue is that some ISAs make it very difficult to write a compiler that can produce small and fast code, and so you HAVE to use asm -- or suffer inefficiency.

Back in the old days we used to implement small virtual machine in asm that presented a better compiler target, and then had a Pascal or C etc compiler emit some more or less nice (and compact) bytecode or threaded code for most of the program, and then write the speed critical parts in asm.

Tokenised BASIC and Python are the same idea, but even less efficient.

[Analog Kid]

Yes, OF COURSE asm can be used on EVERY microcontroller.

OK, I totally believe you on that.
However, question: are all the assembly languages used by microcontrollers pretty well documented? That would be one of my requirements if it's an asm that I don't already know. (Basic reference manual.)

So I'm going to ask for a little hand-holding help here if y'all don't mind:
I went to Microchip's web site to search for μprocessors. However, it's difficult to do so, since there's so much stuff there.

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

Another preference of mine would be for through-hold chips, if that's possible. If not, so long as the chip can be gotten on some kind of breakout board, that would be OK.

Thanks in advance.

[squadchannel]

I went to Microchip's web site to search for μprocessors. However, it's difficult to do so, since there's so much stuff there.

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

Curiosity nano and Xplained, the board has a debugger. you only need to connect it to USB and develop with Microchip (Atmel) Studio.

https://www.microchip.com/en-us/development-tools-tools-and-software/development-tools-category-explorer?category=curiosityboards&subcategory=8-bit-curiosity-nano-boards
https://www.microchip.com/en-us/development-tools-tools-and-software/development-tools-category-explorer?category=xplainedboards&subcategory=xplained

I recommend tinyAVR/megaAVR series. comparison chart is included.
https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ApplicationNotes/ApplicationNotes/Getting-Started-with-GPIO-DS90003229B.pdf

Not much difference between the different series - have a DAC, how many timers, pins etc.
There are very few modern MCUs with DIPs; for the AVR, I believe the ATmega4809 has a DIP.
tinyAVR, there are 8-pin, 14-pin, and 20-pin SOIC packages. QFPs are common.

The nice thing about new AVR series is that it has LUTs(CCL, Configurable Custom Logic), although there are not many. This is useful when you want to build a bit of logic.

also, as others have said, I would suggest programming in C.

[brucehoult]

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

https://www.aliexpress.us/item/1005004895791296.html

The $8 "Kit 1" will be fine.

See Dave's video I pointed to above for a slightly fumbling quick start.

Instruction set reference:

https://drive.google.com/file/d/1uviu1nH-tScFfgrovvFCrj7Omv8tFtkp/view?usp=drive_link

You only need to read the Introduction, RV32I, RV32E, and Zicsr sections.

Also:

https://drive.google.com/file/d/1Ja_Tpp_5Me583CGVD-BIZMlgGBnlKU4R/view?usp=drive_link

There are a lot of good examples at...

https://github.com/cnlohr/ch32fun

[westfw]

Quote

If you really want to stick to assembler, the AVR based MCU's (ATtiny - ATmega) will be easy to use.

The AVRs and TI's MSP430 series are both pretty nice to program in assembly language.
But the "most recent" AVRs you should be looking at are the AVRmmmFFpp families that have come out since the microchip acquisition.  (mmm is memory size.  FF is "family", DA, DB, DD, DU, EA, EB, and pp indicates the pin count.  I haven't quite figured out the "family" names, but roughly the Dx families are ATmega equivalents, the Ex are ATtiny equivalents, and the DU has native USB.  An AVR64DA28 (64k program memory, 8k RAM, 28pin SOIC or SSOP) will set you back about $1.50, in ones, from Digikey.  (DIP somewhat more expensive.))

Note that direct USB support in 8bit chips is pretty rare.  But program/debug had become easier and cheaper than it used to be.  (The above families all use UPDI, which can be implemented with USB/Serial converter and a diode.)

I'm going to disagree with all the people claiming that "you can program any chip in assembly" and "ARM assembly is nice."
The fact is that modern 32bit architectures do a really poor job of documenting their assembly languages - datasheet examples are all in C, books and tutorials use C, the development environments provide peripheral definitions in C, etc.

While the ARM32 instruction set isn't so bad, most of the low-end microcontrollers will be M0 or M0+ that implement the V6m architecture, which is a rather ugly thumb subset of the full ARM (ugly particularly WRT the size and availability of immediate operands.)   (M3 and M4 are considerably better.)

RISC-V would start out my figuring out exactly which "extensions" your particular chip implements, and which it doesn't, and having to remember that each time you refer to the instruction set references (published by the RISC-V folks, not the chip vendors.  So you won't get nice "instruction set summary" pages in your datasheet or chip reference manual.

ESP...  another "extensible" architecture. I don't know whether the chips actually implement any extensions. Good luck even tracking down the assembly language docs.  (Hmm.  I guess they do actually exist, from Espressif, without having to go all the way back to the Cadence Tensilica docs.)

And then there's converting the header files for the (complex) peripherals.  Because they're probably full of "struct" and "enum" stuff that won't parse in the assembler.  There was a discussion quite a while ago now about putting together a minimal assembly language environment for STM32F103.  Outcome (and pointers to the discussion) here: https://github.com/WestfW/Minimal-ARM

And mostly: there's no significant "user community" for assembly language on ESP, ARM Cortex M, or RISC-V.  Unlike AVR or i86. :-(  You can't pop up a question "why doesn't this instruction sequence work like I think it should; is there a better way?" without getting mostly silence and/or "Why don't you just use C?" as reply.

[brucehoult]

While the ARM32 instruction set isn't so bad, most of the low-end microcontrollers will be M0 or M0+ that implement the V6m architecture, which is a rather ugly thumb subset of the full ARM (ugly particularly WRT the size and availability of immediate operands.)   (M3 and M4 are considerably better.)

Agreed on that.

RISC-V would start out my figuring out exactly which "extensions" your particular chip implements, and which it doesn't, and having to remember that each time you refer to the instruction set references (published by the RISC-V folks, not the chip vendors.  So you won't get nice "instruction set summary" pages in your datasheet or chip reference manual.

A beginner has no need to go past RV32I (or the 16 register RV32E for the CH32V003) for a very long time. All documented together in one chapter.
 

ESP...  another "extensible" architecture. I don't know whether the chips actually implement any extensions. Good luck even tracking down the assembly language docs.  (Hmm.  I guess they do actually exist, from Espressif, without having to go all the way back to the Cadence Tensilica docs.)

ESP is a brand of Espressif, not an instruction set. Older ESPs used a couple of different Xtensa ISAs, newer ones (and all future ones they say) are RISC-V. ESP32-C3, ESP32-C6 etc.

And mostly: there's no significant "user community" for assembly language on ESP, ARM Cortex M, or RISC-V.  Unlike AVR or i86. :-(  You can't pop up a question "why doesn't this instruction sequence work like I think it should; is there a better way?" without getting mostly silence and/or "Why don't you just use C?" as reply.

There are plenty of people right here who can and do answer any such questions, on pretty much any ISA, as well as other places such as Reddit /r/riscv, /r/asm etc

[Analog Kid]

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

https://www.aliexpress.us/item/1005004895791296.html

The $8 "Kit 1" will be fine.

See Dave's video I pointed to above for a slightly fumbling quick start.

Instruction set reference:

https://drive.google.com/file/d/1uviu1nH-tScFfgrovvFCrj7Omv8tFtkp/view?usp=drive_link

You only need to read the Introduction, RV32I, RV32E, and Zicsr sections.

Well, I opened up that RISC-V PDF. Sorry, don't like the look of RISC programming at all. Too much for what I had in mind.
I think something more 8080-like would suit me better.

Thanks anyway.

[brucehoult]

Well, I opened up that RISC-V PDF. Sorry, don't like the look of RISC programming at all. Too much for what I had in mind.
I think something more 8080-like would suit me better.

Wow. You're going to hate Arm or MSP430 or AVR just as much then.

Things like 8080 are long gone for very good reason -- they're awful.

Maybe 8051 is for you. There are lot of them still available, but they're very much legacy devices.

Here you go:

https://www.adafruit.com/product/5960

[bobxyz]

Because I don't use YouTube for obtaining that kind of information. I prefer text.
So far you're 0 for 2.

Oh, ok, you're in the dinosaur old-school class.

Based on your questions, you're out of touch on what's easily available today.  Please ask your grand kids, or the neighborhood kids, what they're learning in their middle school STEM classes.  Go spend 20 bucks and buy a couple of their learning boards.  Go through the basic blink a LED tutorials for each.  Then, change the code to blink a morse SOS code.  Once you've actually done something, instead of just ......., feel free to ask better questions about vintage computing using assembly language.

[pcprogrammer]

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

The ATmega range of MCU's might fit you best. The assembly language may be less easy than 8080, but not that hard to learn. They also have through hole versions.

Here are some links to the documentation:
https://ww1.microchip.com/downloads/en/DeviceDoc/AVR-InstructionSet-Manual-DS40002198.pdf
https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf
https://ww1.microchip.com/downloads/en/DeviceDoc/doc7799.pdf

See this vendor on Aliexpress. It has several versions of the Arduino UNO, that make use of the ATmega MCU's:
https://www.aliexpress.com/item/1005002997846504.html

To program these without the Arduino IDE and the bootloader it likes, an USBASP is needed:
https://www.aliexpress.com/item/1005006759871321.html

Programming can be done with avrdude:
https://www.nongnu.org/avrdude/user-manual/avrdude.html#Introduction

The assembler to use can be AVRASM2 or the GNU avr-gcc suite and most likely others can be found.
http://www.rjhcoding.com/avr-asm-assemblers.php
https://gcc.gnu.org/wiki/avr-gcc

The GNU avr-gcc suite does it all. Assembly language, C and C++;

Well that is it for the AVR based MCU's.

If you are interested in ARM based MCU's, check out the documentation site on that. It ain't easy to find what you need due to the large amount of different version of cores they have.
https://developer.arm.com/documentation

I have to say you must be a die hard assembly programmer, to also do it on X86 under Windows. Some of the comments I have read here are about the peripherals and the examples in the documentation being based on C, and that C makes life easier, well that is partially true. Setting up the peripherals is not going to be any harder in assembly compared to in C. It is just memory addresses where you write configuration data to get it working in the way you need it. The peripherals in the more "modern" MCU's tend to be a bit more complex, and you need to study the manuals thoroughly to get how they work. That is, if there is good documentation to be found. That is not the case for some of the MCU's out there.

To each it's own I say, but I would still like to encourage you to look into C. It will make programming easier and the code is more reusable between different MCU's. C code that you write for an AVR based core can reused on an ARM based core, as long as it is not targeting peripherals of course. That can't be said for assembly language. Probably not a big selling point for a hobbyist like you, who is just looking for something new to play with.

That you "spit" on python I can fully understand. I don't like it either. 

[PCB.Wiz]

So if some of y'all would be so kind as to point me to specific μprocessors and the required programmer for that chip, say on Amazon or some other vendor, I would really appreciate. Just some links to get me started.

If you want simple assembler and DIP, that points to the 8051 families or AVR

8051 with english docs and debuggers:
https://www.silabs.com/mcu/8-bit-microcontrollers
https://www.nuvoton.com/products/microcontrollers/8bit-8051-mcus/
https://www.abov.co.kr/en/products/product_overview.php?category=8bit_mcu

Another preference of mine would be for through-hold chips, if that's possible. If not, so long as the chip can be gotten on some kind of breakout board, that would be OK.

DIP is certainly less common. Atmel/Microchip still have some DIP 8051, or these from STC, with many assembler examples included, You need an AI doc translator.

https://www.stcai.com/xpsc
and well stocked many DIPs - 48 hits  from DIP8 to DIP40
https://www.lcsc.com/brand-detail/151.html

These have UART (and some have USB bootloaders, just connect to USB and P3.2=L), so are easy to download/run.

The STC8H8K64U comes in DIP40 and DIP28 and modules, and the newer STC8051U/Ai8051U has more RAM and classic pinouts.

PCB's
https://www.aliexpress.com/item/1005005144706171.html
https://www.aliexpress.com/i/1005003688412658.html

https://www.aliexpress.com/item/1005006439568251.html
https://www.aliexpress.com/item/1005008064635231.html

[Tation]

Well, I opened up that RISC-V PDF. Sorry, don't like the look of RISC programming at all. Too much for what I had in mind.
I think something more 8080-like would suit me better.

The Risc-V Reference Card https://www.cl.cam.ac.uk/teaching/1617/ECAD+Arch/files/docs/RISCVGreenCardv8-20151013.pdf exposes the Risc-V assembly in just two pages. Me myself have made a similar doc for Cortex-M0 assembly, including many assembler directives, in three pages. There are in deep documents directly from risc.org and Arm in case of doubt. Both ISAs are WAY more orthogonal, simple and user friendly than any 80xx one. I guess that, if you do not "like" any of Risc-V or Arm ISAs, then you will not like any other.