"Arduino" has become very popular because it's easy to get started with, but very unfortunately it is quite a kludge and I don't like the platform much.
* The form factor of the "classic" arduino's is atrocious (I sort of like the "arduino nano" which is breadboard compatible).
So what? It works just fine for getting started, and there's a huge ecosystem of expansion boards ("shields") designed around that form factor.
* C & C++ programs start with a main( ) function (after startup code). and "arduino" have hidden that and added a ridiculous "setup() and "loop( )".
Pointless elitism that has
zero merit from a technical standpoint.
The Arduino structure
setup()
{
//your code that runs once goes here
}
loop()
{
//your code that runs repeatedly goes here
}
is literally just shorthand for
main()
{
//your code that runs once goes here
while(true)
{
//your code that runs repeatedly goes here
}
}
They compile to the exact same thing, and frankly, the setup()/loop() syntax is easier to understand, especially for a beginner. Remember, Arduino was
literally designed as an educational tool for non-techies, and it does well at that goal.
* The Java contraption they call an "IDE" is hardly worth that abbreviation. (Apparently it has gained some improvements in the last few years).
The Arduino 1.x IDE is indeed very, very basic, but it works, and it works reliably. Experienced MCU programmers forget that configuring a "real" IDE and MCU project can be daunting, requiring MCU knowledge that a beginner doesn't possess. The Arduino IDE just works, allowing a beginner to focus on learning the concepts of MCU programming without getting bogged down with, discouraged by, or outright blocked by IDE/project configuration. Not to mention that before Arduino, most MCU toolchains were prohibitively expensive.
Arduino IDE 2.x is a big improvement, in that it now has autocomplete and hardware debugging support. But as I have explained already, one can also program Arduino using other IDEs, like the very popular PlatformIO.
* How does hiding compiler messages make it "simpler"? Those messages are valuable.
Where'd you get the idea that it hides compiler messages? It doesn't by default, and you can set the verbosity to even higher if you want.
A real issue is that compiler messages are often completely useless to a beginner -- and often are useless even to an experienced programmer. They often refer to things that are completely meaningless unless you are intimately familiar with the entire toolchain. Or how the error messages are often entirely wrong, in that the errors are
symptoms of a syntax error somewhere earlier in the code, so the line numbers in the errors
aren't actually where the error is! * The whole framework is an ugly hodgepodge of mixed C and C++.
Given that C++ is designed to be mostly a superset of C, how is this a problem? Who cares?
If you study it, you learn from bad examples.
Of your entire rant, this is one of only 2 parts that has a kernel of truth: there are a LOT of examples of really bad code out there. It's a simple consequence of there being a lot of Arduino users, some of whom are only casual programmers. But IMHO that's a small price to pay in exchange for the value of the massive ecosystem that exists around it, and the community support available.
Also, for learning C or C++, using only a PC (with software) is a much better option than any uC board.
OP didn't say their goal was to learn C/C++. Their goal is to learn MCU programming, and they mentioned C/C++ as a hurdle, not a goal.
When you use a decent IDE, it has an integrated debugger, and you can step though your code line for line effortlessly. This is a great extra tool during the learning process and helps with figuring out how the details work. Also, C and C++ are very much standardized languages (although the standards have evolved a lot over the last 50 years) I quite often design and debug algorithms on my PC, and only port them to an uC after the algorithm is debugged and working. If you know you want to port it later to a microcontroller, you can also do some extra tricks. For example, you can declare the special uC registers as simple variables. This does not get timers or uarts working, but if you start with the right names, you don't have to modify them when you port the code to an uC.
This is the other part that has a kernel of truth: writing and debugging algorithms running on your computer is indeed much easier than on an MCU. I do the same thing. (Often, I just use
www.onlinegdb.com rather than firing up Visual Studio or Xcode. Even if it didn't have debugging, which it does, the much shorter compile-run cycle saves tons of time compared to the compile-run-upload cycle of MCU programming.)
You can also use an RTOS such as FreeRTOS or ChibiOS. Often this is not really necessary for a small uC (think arduino), but for a bit more complex uC (ARM Cortex) it's a reasonable fit. Using an RTOS can give you some structure that helps with keeping the code better readable, and it also makes code re-use easier.
True, but as I've replied to the others who have suggested RTOS programming here: this isn't the time for that. Let people master the basics first!
(I also find it amusing that people bash Arduino for hiding the hardware beneath abstractions, supposedly preventing people from learning how things actually work, but then go on to suggest starting out with an RTOS, which... hides the hardware beneath abstractions!)
Home
Help
Search
Login
Register
