this post was submitted on 07 Oct 2023
15 points (94.1% liked)
Ask Electronics
3325 readers
1 users here now
For questions about component-level electronic circuits, tools and equipment.
Rules
1: Be nice.
2: Be on-topic (eg: Electronic, not electrical).
3: No commercial stuff, buying, selling or valuations.
4: Be safe.
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
There are a lot of differences, but I'll try and go over the high level ones. The RP2040 is a chip, and the others are boards -- so I'll compare the chips on them.
The RP2040 chip is really powerful overall, and does some odd things with I/O that let you do a bunch of very fast, precise things. You also get a lot of I/O pins and they are very well-behaved. The main advantage though is that it works well in both Python and C++, and is well-supported.
The ESP32 based board (Thing Plus) has integrated WiFi. The ESP32 is a great chip, I use it a lot, but it has some unfortunate quirks. First, it has a very high clock speed and decent memory, making it quite powerful. However, if you glitch out the network stack via your code, it can have some problems with unexpected resets. This was much worse with the earlier-generation ESP8266. Secondly, the I/O work much more slowly than the system clock (if I recall correctly), and they are picky about what state they have on startup -- some go high as part of the boot process, others must be high or low on boot but can be used after. This is actually quite a pain sometimes. It's a great chip overall though and works well in C++.
The Pro Micro uses an ATMEGA32 chip. I'm a huge AVR fan so I don't have many bad things to say, I like it a lot. It is much slower than the other two chips though, and has less memory. Probably it's best to use C++, but you ought to be able to use Assembly too if you like. The I/O on AVRs are really well-behaved and usually operate at the same speed as the chip, which is nice when you need precise timing! The best thing about it though, is it can use much less power than the other two options, if you use the sleep modes right. So you can build neat battery-powered applications. Finally AVRs have excellent datasheets -- there's rarely any ambiguity on exactly how any system on the chip works.
Overall, I'd choose an RP2040 board if I wanted to use Python and do IoT/Robots/whatever (you can buy boards with or without WiFi), an ESP32 based board if I wanted to do IoT stuff in C++, and the Pro Micro if I wanted to do low-level, low power embedded stuff in C++ or assembly (and maybe branch out into other AVR chips). The C++ options mean you can use the Arduino IDE and their libraries.
Holy shit (sorry)! You really know your stuff, or at the very least, I don’t know my stuff! I’ll keep in mind the stuff you said about the ESP32 and the ATMEGA, but I was more so referring to the editions of those dev boards that use the RP2040!
https://www.sparkfun.com/products/18288 https://www.sparkfun.com/products/17745
After reading a bit more, it seems that pretty much the only difference is the IO and other supporting hardware besides just the chips. If someone (me) were working on a project where solutions like these particularly-powerful microcontrollers are required, when would it make more sense to use one of these pre-made boards for computing rather than making your own PCB designs including the chip? Is it mostly for projects where extremely compact form factors (and/or other shenanigans) aren’t necessary?
Glad to help :)
Besides the I/O and supporting hardware, the clock speed is wildly different between these 3 chips -- that's worth considering. By that metric, the ATMEGA based designs are the slowest by far -- although somewhat faster than you'd estimate since they usually operate 1 instruction per clock cycle, whereas the other chips are a few clock cycles per instruction (they are still way faster than the ATMEGA line though).
Regarding pre-made boards vs. your own? I think there are three things to consider:
Pre-made boards are awesome for prototyping. Making sure the damn thing will work (feature-complete) before designing your own board is a good idea. Then, make your first board with all features added in (this is important), but expect to iterate at least once (make revisions and order boards a second time). There's no such thing as premature optimization in hardware design -- it's not like software where you can just design the core of an application and then build features as you go. This is why always designing prototypes to be feature-complete is a good workflow, and generic development boards are a good starting point for this.
Designing your own board is really easy for AVRs. I do this all the time, lately with the Attiny10. Honestly there are a ton of AVR chips out there, and not all of them have affordable / popular development boards, so often it's worth making your own for use in item 1 above (...really you just need at minimum power and a header to break out the pins for ISP programming). Then when you want to make your final widget, you just expand your development board design, which lets you make a really miniaturized and streamlined thing! You will need an ISP programmer though, like the AVR-ICE (which has a nasty but minor bug in the design -- ping me before buying one and I'll save you 2 days of headaches setting up).
A neat trick is to design your own boards and still use a dev board (so making your own boards and buying premade dev boards are not mutually exclusive options). This is especially useful with the Pi Pico and ESP32 (where making a dev board is less beginner-friendly) -- a cheatcode is "castellated mounting holes". These let you solder (for example) a Pi Pico dev board directly to your own design as a surface-mount component. You can do this by just adding a socket and using header pins too, but SMT + castellated mounting holes lets you keep the design small and reliable.
BTW when designing your own boards, committing to SMT parts (where possible) early on is one of the things I'm really glad I did. You don't need much tooling to do it. Just a solder paste syringe, a toothpick or pin, some tweezers, and a hot air rework station (included in some soldering stations). Even 0402 parts (about the size of two grains of salt) are pretty easy to do by hand. It's amazing the level of miniaturization that you can achieve these days this way, as a private individual with a very modest budget!
Finally, the Arduino products are generally very good dev boards, whether or not you're using the Arduino IDE (you can still program them ASM or non-Arduino C++). So for any chip that an Arduino exists for, it's an excellent starting point -- although you may want to design your own board one day to remove unnecessary stuff if it comes out cheaper and you go through a lot of them, or just for the experience.