Arduino Day Is Today


Did you know today is Arduino day? A day to pull that little teal board out of the bin and blink some LEDs or dive deeper to challenge your skills. There’s a map of local events, but unless you’re near Italy (the birthplace of the movement) events are a bit hard to find.

There can be a lot of hate for Arduino around here, but we consider it the gateway drug to learning hardware design so why not support wide-adoption of the platform? We’ve even seen Hackaday-associated projects adopting compatibility. Both the Mooltipass and the FPGA shield projects have the platform in mind. Break down the assumption that electronics require mythical-levels-of-wizardry to toy with and we’ll be on our way to a world filled with hardware hackers. If you do want to get some really cheap boards to hand out Sparkfun has Pro Mini’s for $3 today, as well as some other deals [Thanks Jeff].

Are you still unconvinced and ready to rage in the comments? Before you do head on over to our Arduino anger management site to exercise some of that aggression.

67 thoughts on “Arduino Day Is Today

  1. I never understood people hating Arduino platform itself. I mean, it self-identifies as being “intended for artists, designers, hobbyists and anyone interested in creating interactive objects or environments”.

    I emphasize how that list doesn’t include “engineers” of any kind or even “programmers”. (Unlike several dozens of projects and/or kickstarters featuring technology on similar level but intended for production use. Something something espruino…) It’s more or less a toy, and what an excellent toy it is!

    But as you don’t build houses for people out of LEGO bricks, you don’t push Arduinos to production. Though I don’t think anyone ever tried that with LEGOs…

    1. I’m not sure where the hate comes from either.

      On a personal level, I don’t like the speed-bump at the end of Arduino. It’s an easy platform to get into and learn quite a lot about electronics and programming for embedded systems. But to jump from the Arduino environment to being able to code for any microcontroller seems to be a no-man’s land. I suppose it’s the difference between a taste of something and knowing how to cook the entire mean.

      I still think it’s like crack for (non-hardware) engineers. If you’ve been software only and get your hands on one of these chances are you’ll get sucked into all kinds of cool hardware projects.

      1. Well Mike, I think that the hate is a response to that very speed-bump you mention. So much of the actual functionality in the hardware is abstracted away in layers of libs and includes, so the user never really interacts with the microcontroller on a ‘low level’. This means that if something weird happens, that user might not know what went wrong or how to fix it.

        1. Dr Heinz, the very same thing can be said about your desktop computer, the mobile phone in your pocket, and the smart watch on your wrist. But that does not stop us from writing programs, apps, and widgets.
          Desktop programmers have not had direct hardware access for well over 15 years, unless they were writing drivers. If something goes wrong, it must be the driver’s fault? Abstraction is natural, and WILL happen. The chip brands that avoid it have their brains firmly in the 90s, and will see their brands go the same way.

          Consider all of the amazing programs that have been written… the projects completed… and the hardware connected to by Arduino, that really DIDN’T need any of those features or hardware level access so many people talk about when attacking the arduino-like eco systems.

          It is VERY RARE that the abstraction layer actually gets in the way and hampers a project. In such cases, it still is not terribly difficult to take it upon one’s self to learn how to get around those issues and down into the hardware directly.

          1. If you restrict your application to simple things without any realtime requirements, then I would agree that the abstraction layer usually doesn’t get in the way. But in that case, a $25 Raspberry Pi seems to be a better choice than a $27.50 Arduino.

            Once you have any fast timing requirements, like driving WS2812’s, the Arduino abstraction layer (i.e. digitalWrite) makes it impossible. It doesn’t have to be that way. The recent versions of the Wiring framework (which Arduino is originally based on) have improved the library code so digitalWrite compiles to a single sbi or cbi when constant parameters like digitalWrite(10, HIGH) are used. Unfortunately lord Banzi seems more interested in flogging hardware than improving the software. And even though the original Arduino was a clone of the Wiring hardware, Banzi is crying foul now that the Arduino hardware is widely cloned.

          2. Ralph, Not denying that there is certainly a lot of room for improvement and streamlining the abstraction layer code. That whole 1.0 wire library fiasco was certainly a giant pain (major keywords in the library changed, breaking EVERY application and sub library written for it up to this point).

            That whole lord Banzi comment.. funny stuff. If I remember correctly, Banzi was the mentor professor for the guys who wrote wiring and designed the original hardware. Then he goes off and starts Arduino off his student’s work. Then forks and dismisses wiring entirely.


          3. RE RasPi vs Arduino coming in at the same price point:
            Purely a cost analysis for a hobbyist, sure it makes more sense to get more bang for your buck. But that ignores several factors that make the pi undesirable in certain situations:
            It is heavily subsidized by the chip maker. That is the only reason it comes in at such a low price (the Arduino is only slightly higher than it ‘should’ be). The real BOM on the pi is a likely a loss for the chip maker. This is also true of anything BeagleBone or Launchpad related. That being the case, you should always be aware of supply delays. BeagleBone is currently feeling that pressure in a BAD way, just like RasPi did in the beginning. You cant make projects with vapor hardware. Not in hand is not likely to be used.
            Second, is the very real point of being able to make your own. Launchpad gets prop here in that it is almost as easy as Arduino to roll your own board, or slap parts on a breadboard, or point to point wire it up on perfboard. Not so for BeagleBone/Pi.

            Sure, it costs me 35 for my first arduino. But less than 5 bucks in parts to make all my own projects with permanent, stand alone arduinos in them (and remains true so long as AVR keeps production. it is more ‘future proof’). Compare that to 35 bucks per project (while supplies last) with RPi.

        2. This is the issue I have with the Arduino platform. Much of the time I want that low-level control of the chip itself.

          But if you just need an embedded platform to do some light work, Arduino is pretty hard to beat. I threw together this NFC card reader extremely quickly because I used a few of the available libraries. This would have taken much long if I was coding without the Arduino packages.

      2. So, Arduino is the gateway drug. What is the real embedded jazz that you are referring to? I’m an electrical engineer and don’t bat an eye at using arduino, because it takes less time to get up and running that an fpga would. What is your bread and butter?

        1. I generally prefer bare-metal… I like to know exactly what the processor is doing. Arduino has an underpinning that I don’t fully understand which leaves questions in my mind.

          If you know that the Arduino is overkill for what you’re doing you can just ignore the overhead. But if I need precise timing, use of interrupts, timers, etc., then I’d rather start from scratch.

          1. Mike, Yeah, I get you. And a lot of pros would say the same thing. I am tempted to agree (especially on knowing whats going on for the sake of knowing/satisfying curiosity/being a better engineer, etc).
            BUT… how often do you REALLY need that kind of access? Of the three points you mentioned, only one is actually valid:
            Interrupts – super easy to configure under arduino, work exactly as advertised. It is just a cleaner interface. If you wrote the code yourself, it would look the same, 100% of the time. Wanting to “wrap it yourself” is just being masochist.. or you will be copy/pasting your own code all the time.
            Timers – again, easy enough to access and rewrite if you really need too. It is not nearly as well published how to do this, but a bit of google will uncover the how tos. And remember that anything you can do in AVRstudio, AVR-GCC, in C or assembler, you can do in Arduino. You can override just about everything, using code you would have used in those other environments.
            Precise timing – Here is where you have a point. But then, that too is a problem of GCC (to some extent) as well. Unless you are working directly in assembler and counting operations, you wont be getting that anyway.

          2. MRE, I was about to write pretty much the same comment. If someone needs low level access, just write your own code into a library. Arduino is just a bootloader and an IDE frontend to avr-gcc. The boards and shields are overpriced (never bought a shield) but I would never leave one in a project, anyway. A few parts and a bare AVR, and you have an “arduino.”

            And as far as being tough to go from Arduino to something else. Never had that trouble myself. It’s C++.

            “Bare-metal” programmers use libraries… well unless you are a masochist. I’d rather repurpose code than write my own just to say I did it. I don’t build my own IC blackbox from scratch every time I need one.

        2. Paul, presactly! A damn good gateway drug. The only REAL issue with it, is that with so many ‘arduino engineers’ coming into the workforce, us old-timers will have to worry about them taking our jobs!
          (these days, late 30s is starting to get old in this business. I remember when AVR didn’t exist and C on a PIC was a dream finally becoming reality. Back in my day….)

        3. > bat an eye at using arduino, because it takes less time to get up and running that an fpga would

          Comparing apples to oranges… no, actually, you’re comparing apples to offshore oil platforms or something like that.

          In general, there are plenty of reasons not to use AVRs and not to use Arduino IDE anywhere near production. It’s disturbing that none of the other commenters mentioned them. I’ll list a few:

          1) [here and after Cortex-M] ARMs are not necessarily cheaper than AVRs, especially in bulk, and seeing as there is much more vendors for ARMs, they’re more easily sourced.

          2) ARMs have much nicer performance-per-watt numbers, which can frequently justify
          higher cost.

          3) Related, AVRs have rudimentary in comparison power-saving features. Arduino libs diminish even that limited potential to an entirely laughable subset.

          For example, STM32L chips are specifically developed so that you can trigger complex sequences of actions by configuring peripherals, events and DMA (AVR doesn’t even *have* DMA) to trigger each other at just the right time. The firmware would be invoked maybe once every second, and spend just a few cycles setting up buffers. This is not just an elegance argument; STM32L has baseline idle power of 9 µA *while doing useful work*, and 280 nA in deepest sleep. With such numbers, you could conceivably power an environmental sensor by atmospheric temperature variation or through a piezo plate.

          Arduino platform actively makes it impossible to develop such an application by reducing all the nice API of the underlying hardware to the dumbest common denominator; worse, proliferation of Arduino APIs over different platforms (or this thankfully mythical usage of the platform in a professional setting) makes it less likely that people will learn and properly use these features.

          4) The absurd notion that it should be possible to attach any peripheral device to any set of pins, and the fact that libraries strive to be portable across platforms when provided only with an incoherently designed (for its de-facto usage) API, leads to a sad state of affairs where libraries mostly communicate with the peripherals by bitbanging, and usually by busylooping.

          This needlessly increases power consumption, this steals CPU time from more important tasks, and finally this is very much prone to error, because protocols are always intricate, and it’s much better to leave an experienced hardware designer to implement a module which is then verified rather than writing your own. When was the last time your homebrewn bitbanged SPI or UART handled overrun error? Yeah. Glitches happen, and it will cost you way too much time.

          I could continue for hours, but arguing with someone whose mind is closed to any technology except the simplest and who thinks that the entire industry should be dumbed down to lowest common denominator is pointless. We have hundreds and hundreds of different platforms mainly because they do different things well, not because their creators are greedy and/or idiots.

          1. whitequirk, many valid points to consider.
            I do think some aspects of your points are rather application specific though. MILLIONS of products have been brought to market using the lowly PIC and AVR chips you seem to dislike. Yes, in terms of power management, there are far better options. In terms of cpu speed, or memory, or peripherals, there are other options.
            But “simple” does not equal “invalid choice.” None of your points apply to, for example, the processor in my coffee maker, microwave, or washing machine. I would be SHOCKED to find an ARM in any of them.
            Look inside most of the vending machines in the world and you will find Z80, HC11 and PIC. Perhaps for the work you do, AVR is not the right choice. Fine. You, as the engineer, have to pick the best chip for the job. But your job does not equal everyone’s job.

            That last paragraph was totally counter productive. No one here was arguing anything, and implying so was somewhat close minded of yourself. Discussion yes. Point and counter point yes. Disagreeing, possibly. Argue? No.
            Your assertion that Arduino advocates are simple minded, dumb people who want to bring down the industry to their low level just so they can participate is INCREDIBLY close minded and disrespectful of you.
            You, the pot, have called the kettle (anyone using an Arduino productively), black.

          2. I do not dislike PIC, AVR, or any other architecture. I’m well aware that PICs and AVRs and whatnot are extensively used in consumer hardware. My laptop probably has a dozen of 8051 cores in it, and that’s just fine. In this particular case, I just see how AVR doesn’t advance in years and rapidly becomes obsolete.

            My point is that Arduino, as a concept, implies deliberately reducing design space to very few points, most of which aren’t optimal for anything. Even on AVR, Arduino libs don’t use timers except for PWM, doesn’t allow fine-grained management of peripheral power, and while there are libs for hardware SPI and I2C and UART, they’re too simplistic, and for some reason libraries tend to bitbang anyway…

            You yourself mention searching for an optimal solution. This is not an optimal solution by any scale except “least amount of things to learn”. Extensive knowledge of your system is important even for a coffee-maker, much less any more complex or critical device.

            If an engineer uses an Arduino-like platform in a production device while fully understanding the implications of doing so, knowing very well how all the abstractions beneath work and truly believing that this is an optimal solution to the problem on hand, I wish them all the best. So far I have met no such engineer.

            (While writing the above, I stare at what’s probably the poster child for this thread: osPID. An Arduino embedded in a production device… which uses software floating point for calculations, which is not only visible slow, but also leaves barely enough flash for out-of-the-box software, much less any extensions. The cheapest STM32F4 would have comparable cost and be oh-so-much-better.)

          3. A chip family going obsolete is certainly a consideration, but would happen anyway. Even ARM can/will.. in theory, become obsolete. I think we still have a long way to go before simple 8 bit micros will all be out of production. Your concerns there are valid, but chip makers could possibly apply power reduction strategies to these chip families, extending their life and usefulness. As someone who is not producing 10K+ of a product, which I hope will be in production for years to come, such concerns are WAY down my list though.

            Yes, Arduino is not optimal for the hardware. But then, neither is C. Remember that Arduino is JUST GCC, with some beginner friendly names, macros, and libraries. If Arduino lacks effective low power management, that is a fault in GCC or the chip. Not the environment. But, anyone with some knowledge under their belt or time to learn, will know that anything you see here: You have access to in Arduino, and all the other AVR GCC functions. That seems to me to be a pretty comprehensive list of power management for the chips at hand.

            Porting to other chips, you have a strong point. Libraries do NOT port well. The idea of “One language environment to rule them all” is noble, but perhaps ultimately impossible. As for the quality/functionality of those portings, it really comes down to the skill of the porting team. The library says “initiate SPI” and it is up to the port team to write the hardware level code to accomplish the goal. If it sucks, its bad abstraction.. not that abstraction is bad. For this reason, yes.. a lot of libraries end up bitbanging rather than taking advantage of the hardware (which may or may not exist on particular chips). At any rate, we all abstract. If you have written a library to do something you do a lot, and tucked it away in a file, you have done nothing different than the Arduino environment has done.
            But, again, you have a strong valid point, in that you KNOW what code you wrote, and completely understand its possible shortcomings. Not so on Arduino. But.. yea know.. we can always take the time to look. Several times I have had to investigate how a library was written, either to solve a bug, make something work better, or to rewrite my own library to be imho a bit more ‘proper’ or complete.

            I can agree with you that there are a lot of things to be desired (especially the IDE itself). What I debate is “how hard does it ACTUALLY need to be?” To characterize arduino users as dumb sheep is not giving them the chance to learn. I think it actually offers a LOT of launching potential to get into the harder aspects of embedded design, and certainly gets many more started, who would have been intimidated by the ‘hard way’ of learning about micros.

          4. I didn’t mean “obsolete” as “coming out of production”, although I witnessed an actual company which was hit hard by some older AVR going out of production; they had the entire codebase in assembly. Rather, I mean they’re “morally obsolete”. Sure, ARMs can be seen as overkill (but to someone starting to 8-bit PICs with 64 bytes of RAM and pages, AVRs are a huge overkill), but they have comparable or sometimes lower cost, and that “overkill” will save you when requirements suddenly change. It’s also simply more convenient to write software for ARMs.

            You correctly mention Arduino libraries. This is the main offender. Quite some of advantages of ARMs in power saving come from two facts: 1) you can turn off unused peripherals, 2) you can set peripherals up to trigger each other. On AVRs, 2) is not possible. However, 1) is; and AFAIK it comes with similar power saving benefits. However, I don’t think Arduino libraries allow even this trivial level of control, and certainly this doesn’t happen on other platforms, where a makeshift AVR-style peripheral API is emulated.

            Again, Arduino APIs are the problem. It is not possible to make a perfect abstraction, but it is certainly possible to get a much, much better one (example: Linux kernel device APIs, which extensively feature power management calls). Of course, this is not the fault of Arduino; Arduino was never designed for this. Rather, it is a fault of the user, who chose too simplistic an interface.

            I never made a blanket statement about all Arduino users, vast majority of which never come a mile near to production, and I’ve already outlined why blindly using Arduino platform in production is silly.

          5. “Morally obsolete”?!?!?! Haha.. ok explain that one to me. Do you mean it is morally objectionable in your opinion to use such a micro?
            (Given certain factors, they could be bad choices, and possibly detrimental to a company’s bottom line.. ?) You might want to run that one past AVR, and the thousands of companies that still use 8 bit pic and avr micros. They might have missed their church days.

            Yes, there are some.. quite frankly shitty libraries out there in Arduino land. Even a few in the core itself. Fault of the library coder. Fault of the user who does not peek under the hood. But not sure what you mean by ” I don’t think Arduino libraries allow even this trivial level of control” If by that you mean that the power saving control libraries are limited.. sure. But as I have linked before, it really is as simple as calling the GCC command. power_all_disable() anywhere in your code shuts every module down. power_all_enable() wakes it all back up.

            Do you mean some libraries don’t like it when their hardware shuts down? hmm.. that would be a combination of library coder / library user issue. I can see that being a problem. But I have never really seen that happen personally. I’d like some more specific examples that I can try out and see for myself if that is what you are saying.

            Then you say “and certainly this doesn’t happen on other platforms, where a makeshift AVR-style peripheral API is emulated” I assume you mean that when Arduino is ported to other micros, it is even worse. Am I correct in understanding?
            If so, I don’t think you fully understand how wiring/arduino is ported to other chips (I dont want to jump to conclusions and offend you, so correct me if I am wrong). It all boils down to the GCC implementation for that particular chip. The porter need only implement the same library function, by the same name, in the target micro’s GCC code.
            I am going to make an assumption here, as I have not actually tried it (but could, if you demand it): Let’s assume TI’s Tiva-C ARM cpu. The Arduino equivalent is Energia. I would assume that power_all_disable() would not only compile, but have the same effect. It is possible that the command on Tiva-C GCC is something different, but that is only a matter of research.

          6. “Morally obsolete” is a term for something that still works, but alternatives better in practically any way exist. You can use a stone hammer, but you probably want to use a steel one. While you can continue using AVRs for new projects, I see little technical reason for that. (Non-technical reasons, e.g. bought toolchains, existing firmware or even your own knowledge, can be aplenty.)

            I know how Wiring works. By the way, porting it doesn’t involve modifying target GCC.

            GCC itself doesn’t provide any library functions, except for very few it uses internally. It is in general the function of a C library. power_all_disable is specific to avr-libc (not Wiring) and will not be present as-is on any other libc.

            The problem is exactly in that power_* family of functions is not a part of Wiring, but of avr-libc. They’re specific for AVRs. There is no sense to restrict oneself by providing some cut-down implementations mimicking AVR on a non-AVR platform, and in fact, in some cases it is not even possible. E.g. on STM32, GPIO power can be controlled.

            While moderately good APIs exposing most of interesting features, such as power management, can be implemented, Wiring is not one of them.

            Surely, you can break this abstraction, but then why use it in the first place? In a setting where you want to use your chip’s features to the fullest, which is usually the case, Wiring provides negligible benefit, or in fact may just slow you down, since you need to both understand all of the underlying hardware, and the broken way Wiring presents it.

            Training wheels should go away at some point.

          7. Perhaps we are arguing at different points.

            Surely most if not all implementations of GCC for various micros have power management functions, with equally simple commands to access them. My point was not so much that “this exact command should work on any micro with GCC” but that, in theory, any chip with power management abilities would likely have equally accessible controls in GCC.

            Can you point me to a link on power management of the STM32, or better yet a function reference so I can make my own comparison? I’m not getting great results from google.

          8. This link: points to the kind of frustration that can be experienced by users trying to find deeper information about more complex hardware such as the STM32. It shows a bit about what happens under the hood of Maple (STM arduino env). And does mention the lack of anything similar to avr-libc. It is surprising to hear that gcc ports are missing such things. Understandably, it is a huge mountain of code to abstract low level hardware control into efficient, reusable libraries.
            Things like avr-libc are what make using micros so much easier. I don’t really consider that “training wheels” if it is functions you will call upon constantly to get things done.
            Maple created their own libmaple, which serves sort of the same function. would have to look inside to see how they implement power control and what function naming they use…

          9. Sorry, what? You are confused about the role of GCC. GCC does one thing and one thing only: translates C into machine code for target. All the standard library functions, including power management, are implemented by a C library, which is relatively independent from GCC. In fact, GCC developers mostly don’t care about embedded C libraries at all, it’s not their job.

            Power management in more complex SoCs is one of the most complex parts, with hundreds of switches all over the I/O space. There are, of course, some library routines for the simplest tasks (like turning peripherals on and off), but you aren’t achieving any great results without understanding of inner workings of a specific chip.

            STM in fact has support libraries similar to avr-libc; they’re CMSIS (common for all Cortex-M based chips) and STM32 SPL (Standard Peripheral Library). While they can be “frustrating to work with”, they’re not worse than Wiring.

            Documentation on STM32? Sorry, again, what? The documentation on a microcontroller (take a look at STM32L1 and STM32F1 series) can always be found in the same place: the datasheet and the reference manual provided by the vendor. It is really strange to see this question, as it’s one of the most basic things in embedded development, or in fact programming in general: if you want documentation, go straight to the vendor’s website. I’ll leave finding the actual link as an exercise. Hint: it is not hard.

            Libmaple exposes two interfaces: one lowlevel, quite similar to SPL (but less contrived, less flexible and less complete), and one highlevel, similar to Wiring (“wirish”). The lowlevel one leaves power management entirely to the user, whereas the highlevel one, as far as I can see, suffers from the same problems as Arduino wiring.

          10. Yep. I know that GCC simply makes machine code for a target.
            Yep. I know about datasheets and programmers reference (In fact, I googled specifically for the STM32 docs).
            The STM32 programming manual here: Only dedicates 2 pages to power management, before leaving off to wade through the instruction set on your own to figure it out. The point is that some things are not immediately obvious to people moving up to newer more powerful chips.
            At any rate; GCC makes machine code. Custom C Libs make access to target specific hardware easier (such as avr, CMSIS, libmaple, etc). If those libs dont exist, then either the team getting that target up with gcc do it, or the ide vendor (Arduino, etc), or finally the end coder.
            On just about every port of wiring/arduino to another chip, when you need granular access, you can do so. When you don’t you can easily use the libs (provided they exist).

            You have expressed why you would not use an 8-bit chip in a product. Ok fine. You seem to dismiss them outright, but at least have given justifiable reasons that could apply in many/most cases, and possibly every one of yours. Ok.

            The arduino IDE is trash for any professional, high paced development. We totally agree on that. There are ways out of using it, but whatever. I still think that for the vast majority of hobbyists and some developers, it is not a total waste. And for newbies, it is especially helpful to not be so overwhelmed. The instant gratification of loading and flashing a sample program is really important. But yeah. Lot’s to complain about.

            What I don’t get (agree with?) is dismissing the environment entirely. I think it serves well not only as a intro/beginner system but up to the level of semiprofessional as well. AS has been stated many times already, you can be as granular as you want. Bootloader. GCC. Scripts, libraries and macros on top of GCC to make most of the constant use work easier. That’s it. You are not limited by it. You are enhanced by it. You can CHOOSE to simply NOT use the provided libraries if they are not granular enough for what you need to do. Most IDEs now come with additional libraries, wizards and other gimmicks to make setting up the chip easier these days. It really is no different. Don’t like how it configs a piece of hardware, don’t use that library and write it manually.

            Your contention seems to me to be: “I see many different sizes of screws. I have one screw driver. I know it well. I will manually modify it or make new ones by hand to suit any situation required. This is the best way.”
            Whereas the arduino eco system says “I see many different sizes of screws. I will get many screwdrivers to fit the various types, and keep them in my tool box. I can then select the appropriate screwdriver. If one does not exist for a specific screw, only then will I put effort into manually making one. This is the best way.”

            The future is that more and more chip manufacturers WILL either support or fully fund Arduino ports to their chips. To not do so is to loose market share. To be an engineer you will have to become comfortable with this fact and accept it. You still maintain advantage in that you know a lot more about the low level hardware than the kids coming up to take your job.

      3. Mike, the speed-bump is less and less pronounced every day. We no have wiring/arduino style environments for:
        AVR, PIC (Pinguino), STM32-ARM(Maple), MSP430/Stelaris/C2000/Tiva C(Energia), Raspberry Pi, Intel Galileo, and the options keep growing. Many of these systems are funded and supported by the chip manufacturers themselves. They see the long and frustrating “bring up” time that even professionals experience trying to work with a chip for the first time as a major turn-off for their brands.
        In this day and age, there is absolutely no reason for a “hello world” to take more than 5 minutes, from install to blinking led. It should be as trouble free as possible, and without a mountain of config code needing to be prepared by the user. Software and desktop processing power have increased dramatically since the 80s. The ease of use expectations should increase to match.

      4. I personally feel Adruino hating is pretty silly. I’ve long struggled to try to understand what these people are really about. So far, I’ve seen at least these 4 themes….

        Much of the anger seems to revolve around Arduino’s ~$30 retail price. Some of the mindset seems to involve comparing to a raw ATMEGA328P chip, without attributing any value to the PCB, supporting parts, and especially the software. Disdain for financially supporting software development seems to be especially strong when the software is published for free.

        There’s also considerable frustration with Arduino’s feature-poor text editor, or lack of other advanced features. With that, I can relate to some degree, but it’s simple enough to use File > Preferences : external editor. There’s also several 3rd party platforms, like Visual Micro, which aim to provide a more advanced system.

        Some people seem to have a deeply rooted hatred of Java. Or perhaps specifically Java for desktop GUI-based applications. Despite the many sites that have claimed JIT-compiled Java and C are similar in speed, you’ve got to admit that GUI-based Java programs do consume pretty incredible amounts of RAM.

        A tiny fraction of the Arduino Haters, and the ones who I just can’t understand, seem to be genuinely upset that Arduino makes electronics easier than it “should” be. Why these people think this way, I just don’t know. Perhaps they had a hard time learning electronics and feel everyone else should too? Some express concern that novices aren’t learning enough before they are able to achieve some working results, which is somehow bad because they should have been required to learn much before before anything works. Crazy, but some of the Arduino hatred seems to be rooted in this sort of belief.

        Maybe I’ve missed other reasons people hate Arduino?

        Mike, that Arduino Anger Management game is the pretty awesome!!

      5. Exactly my situation. As a kid growing up I didn’t have the $$ for all of the tools, equipment and parts required to become a “hobbyist” in electronics (and lacked some of the resources – Google didn’t exist back then.)

        Fortunately, Mom had a computer. I’ve gone through plenty of computers since, and now program in … ? … a lot of different languages. As a grown-up bachelor without children, I find plenty of time to spend my money on those things I always wanted (wolf dog, dirtbikes, power tools, fast computers, big TVs, music gear, etc.) An Arduino UNO was the first ‘duino I ordered, and when I plugged it in and walked through some tutorials I was hooked – programming it was a piece of cake, and understood that I could now apply my programming skills to something tangible.

        I’ve ventured a little outside the Arduino world at this point (it’s only been about 1 1/2 years since I got started) so I’ve also played with 555 timers, OpAmps, transistor circuits and of course all of those fun little Arduino IR sensors, gyros, accelerometer, XBee, etc.

        I feel like I’ve come a long way. Two years ago I couldn’t even read a schematic to save my life. I’m happy to say that is not the case anymore!

        1. I feel the same way too. I got a lot of exposure to making TTL chips work in projects, worked on a unrelated job for years, and now am getting back into electronics as a hobby. I still can make use of a variety of TTL logic, but when I need compactness and/or don’t have the time to set up complicated schematics, I use Arduino to simplify it. Programming is work in itself, though, but that’s part of the experience and it’s not difficult to switch to programming in other languages with similar arrangement of syntax. I’m also learning the Raspberry Pi and I can see it more useful in certain projects. At least it’s a start with the time I have.

    2. Mostly I agree with you.. I at first was a ‘hater’ but eventually not only grew to love it, but wrote a book about it, and am planning another one now.
      The part I disagree on is ‘taking an arduino to production.’ Here are few reasons:
      1: Sure, using the original board, as is, would be the ultimate in stupid. This is not engineering. And sadly, I HAVE seen attempts at doing just that. Crazy sauce.
      2: But with respect to #1, it does not take much additional knowledge to strip it down to the core of required chip, support components and your own circuitry to lay out and fab custom boards. On this level, to deny that this is a ‘professional’ level product is to deny damn near every digital electronics product since the 1970s. Until a few years ago, PIC chips were in EVERYTHING. Good engineering is finding the chip best suited to the job. No more, no less. If an AVR will do what you need, you would be a poor engineer who chooses an ARM instead.
      3: Regarding code output, It makes no difference. C is C. Assembler is assembler. Whatever gets you to a code you can load onto the chip. Coding with wiring/arduino is a shortcut to that process, but no less ‘professional’ in the end. A good embedded engineer will have 90 percent of their startup software prehacked on any chip they worked with more than once. This just shortcuts that process, in that YOU are not the one setting all that code up the first time.
      4: As for the environment itself, yeah, the IDE is terrible for any “REAL” engineering. Or so we all think. But what, really, is missing? In circuit debugger. Breakpoints. Direct hardware access. In many ways, I dont really need them. And when I do, not having them only slows my process down, not stop it completely. And, there is always the AVR compiler to go to if I really get in a bind for those tools. Most of the time, using the Arduino IDE over any other gets me going faster.

      I think, moving forward, we are going to see a big shift in HOW embedded engineers work. We have to be more open minded about what methods and processes “Professionals” are allowed to take.

      There are MANY jobs opening up, in which the stated requirements includes skills with Arduino and other such environments. Regardless of popular opinion, once jobs are offered, paying for work done with it, is has become a professional environment. In some ways not ideal, but so none the less.

        1. It’s a matter of overkill. the cost of an AVR is much less than that of an ARM. So you don’t need a 32-bit processor when an 8-bit will do. When you go beyond spec, it isn’t impressive to to an employer, because it’s waste. An engineer’s job is to get something done to spec as cheap as possible and at as low power as possible.

          1. “Overkill” is a bad reason. “Number of bits” is a bad reason. Cost is a good reason, except that there are many ARM chips that are cheaper than similar AVR parts.

          2. Paul Stoffregen, Yes, IF: The cost of the toolchain (KEIL/Workbench) exceeds the cost reduction, such as when you anticipate a very small production run. As a freelancer doing one offs or prototypes on contract, you generally don’t use any tool chain you have to pay for. Nor do you work with new chips on contract unless you know you have the time to get up to speed, or that you can bill the learning curve. Generally you learn new chips on your own time, and introduce them as options when you are comfortable with them.

            I think one of the arguments anti Arduino people always bring into the conversation revolves around high volume production. These arguments are totally valid, but in such situations, there are MANY factors to consider when choosing a chip/tool-chain. It is not exactly applicable to anyone on the other side of the fence.

          3. @MRE: Since the ARM devices typically have a lot more performance under the hood, it’s usually no problem to implement the same problem using a free gcc toolchain for ARM that would require a commercial toolchain for AVR.

          4. True true. More and more chip makers are getting on the free toolchain bandwagon, and there are a lot of GCC ports to various chips now available. My point about the cost of a tool-chain is less valid now than it ever has been. You are right. ARM is becoming more attractive every day.
            But yes, there are still some very expensive toolchains out there, or crippled ‘demos’.

          5. I cant imagine any application that would REQUIRE a paid for AVR toolchain though.. unless you are talking about optimizations.
            AVR-GCC is pretty comprehensive at this point. If we limit our theoretical situation to only using GCC compilers, then it comes down to strictly hardware/cost/accessibility considerations in the ARM vs AVR decision.

            I think that third point; accessibility, is one that is oft overlooked in the arguments. That, and qualifying exactly the scenario we are making the choice in. If we are talking about learning, prototyping and personal projects, accessibility often trumps cost. Can I buy it locally? Is there a huge eco system of support available? How about example projects I can learn from? And how fast can I get up to speed on coding and working with the IDE?

            High volume production is a totally different ball game and has entirely different considerations.

        2. Let me clarify my statement:
          It would be poor engineering to simply choose an arm over avr without consideration to all of the many factors that go into selecting the appropriate chip for the job.
          Obviously, the device needs to meet at least the minimum requirements of the application. For many many such applications, lowly pic and avr (and other 8-bitters) can do it. But regardless..
          If the selected device is more than capable, that is fine, provided the cost for the chip, tool chain, minimum support components, board space and learning curve investment still falls under budget, time constraints and other limiting factors of the project.
          Even so, engineers are often forced to back peddle to a chip the company already has stock/invested in. Often the case is:
          “We invested in the tool chain and have used it for other projects. We are buying this chip in 50K units to get a lower price. So, whatever you do, it has to fit on this chip.” These and other such directives takes the decision out of your hands. In such a case, perhaps the arduino ide is not the best way to go, but that is another discussion (Yeah, I agree the IDE is trash, but not unusable).

          1. My point is that it is equally poor engineering to choose an AVR over an ARM without proper consideration of all the factors involved. I’ve used both AVR and ARM, with free gcc-based toolchains for both. Learning curve for ARM vs AVR core is similar. Learning curve for some ARM peripherals is steeper, but that only applies to peripherals you actually use, and then you can also benefit from powerful features. Also, ARM is better suited to running existing code (often 32 bit based, or using single address space). For board space, ARM probably wins, due to more packaging options available from a number of competing vendors. Many ARM chips do not require any support components.

        1. Hahah ok so maybe “MANY” is the wrong word..
          But I happen to know of at least three freelance engineers besides myself who have been paid to develop projects on AVR, with a stated preference by the contractor to use Arduino if possible, since they would need to maintain/update it themselves in the future, or the company that hired them would need to.

      1. The serial monitor is quite flaky. When I played with the arduino IDE I got frequent java exceptions when the avr on the other end was power cycled or reset.
        It doesn’t lend itself to integration with a code repository the way something like Eclipse does (if you want an IDE), The way libraries are handled is terrible, and some of the things the IDE does to hide the build process from the user breaks things like include processing. For example, add:
        to a sketch in the Arduino IDE, and compile it. You’ll get NO error.

        The great thing about Arduino is the hardware – it has brought basic AVR boards into mass production. Even though the $2.50 ATmega328 Pro Minis are pitched as arduino boards, they work perfectly fine for running AVR code compiled with avr-gcc and downloaded with a $3 USBasp.

        1. Its particularly bad on old PPC Macs. I have run it on a lot of different computers, and really only had serial issues with the ppc. So, I suppose you are right about the java exceptions, but have not experienced it myself (or in any of the hundreds of student I have taught for that matter). But yeah.. IDE.. grrr… But hey.. they chose Java for portability (mac ppc, mac intel, windows anything, linux. raspberry pi) Arduino IDE gets around due to java. good or bad thing?

          Again, the point was made before by someone else: Use the External IDE setting and be done with it. (But personally, Eclipse, for me, is a total F’n mess too. Eclipse Android is a nightmare).

    3. I’ll take a guess as to where the hate comes from — the Arduino and its kin make the cost of entry into microcontroller land cheaper. The “big boys” who used to have this land all to themselves see a bunch of “n00bs” coming into their land, blinking their LEDs and it makes them angry. It’s because it’s designed as a low cost easy to use device that people hate it. How dare anyone try to encroach on the land of the 1337!

      And who says you can’t take an Arduino to production? I can’t see any reason not to. Of course I’m not talking about a full blown Uno dev board being permanently embedded but why not a Pro Mini or a custom setup? There was a project featured on HAD I think where a guy showed how he replaced expensive custom controllers in some industrial equipment with Arduinos.

    4. Here is my point of view. I got into electronics with arduino, enjoyed it so much that I quit my job and started college full time for ECE. Now, I think the hate comes from the accessibility of it. I have spent about 2 years working around micros now and I may spend a month working on a project, designing the software and hardware “right”. Then comes along someone with a breadboard and arduino. They download a few premade libraries to make a patchwork of software and cobbled together hardware that accomplishes something similar to what I did, then they get front page of every blogging site. But you know what? When I just want to make a POV thermometer Twitter Facebook messaging back massager, I’ll use an arduino to make life easy.

    5. I completely agree. The arduino is great plug-and-play solution for (non-engineer) hobbyists like myself.

      I have one in my espresso machine because it was fraction of the price of replacing the control board, and took about an hour to setup.

      And I am currently building a coffee roaster controlled by an arduino and a raspi.

      I understand people get frustrated by people using arduinos to replace things like 555 timers or as a center piece in a senior design project. But you have to start somewhere and these boards help to bring hobby electronics to a larger audience.


    6. > But as you don’t build houses for people out of LEGO bricks,

      Also, Arduino’s are easy to program and you can use the IDE to probram a bunch of different micros. Some people don’t like it when they are used for blinking LEDs when youcould do it without one, but it makes it a lot easier to for example change the blinking speed. Instead of replacing components or trying to set a potentiometer to the value you want, you just change a number in the code and upload it.

    7. I don’t hate the Arduino platform, but I hate most Arduino evangelists. They have a hammer, and all they see are nails.

      Want to build a fake car alarm with a blinking LED? OMG ARDUINO
      Need to step down the voltage from 5V to 3V3? OMG USE ARDUINO

      I mean, come on. At least TRY to learn something new.

      1. hahahahah.. yeah it’s a problem. But people need to start somewhere. The trick is getting them to see that: a: There are other projects out there, more complex ones, and ultimately much more rewarding/fulfilling to accomplish, and b: there are other chips, other ways of programming, and other ways to make hardware work. Learning arduino is an entry point.

  2. I believe the “hate” thing is mostly pointed at those who spend $35 to make a LED blink, and think they are now an engineer. Or, those who build a line following robot, and think they are breaking new technological ground.

    Past that, it’s the old “what is appropriate technology” argument now being hooked up to a microcontroller… ; )

  3. Weird coincidence- I just sat down at the bench last night, unpacked an Arduino and a Galileo, and started learning the system. I got started in electronics a few years ago and purposely avoided the Arduino because I wanted to learn circuit design and Arduino seemed like cheating that early in the game. I’ve since met up with a group of folks and entered some hackathons, but I’ve always left the programming to others. Two things made me change my mind. First of all I’ve been tapped to manage a makerspace and I figured it was time to learn this so I can better serve the space. I also signed up for Make’s Galileo Hacks program and they sent me a really nice package of parts to complete the project of my choosing. The programmer I usually work with is swamped and therefor unavailable right now, so I decided that it was time to see what this is all about.
    I was surprised how easy it was. Thanks to Lady Ada’s tutorial I was up and running in no time. While I do shake my head at projects that use an Arduino where a handful of components will suffice, I really don’t understand the hate- it’s like a Nascar driver ridiculing a kid with a go kart. Everything has its place. If Arduino helps a newb accomplish something that’s a good thing. If it sparks a kid’s imagination to go farther and keep on learning the craft, even better. Information want’s to be free, and any tool that helps free it is a good thing.

  4. While $3 is a decent price for a Pro Mini, I see from the Sparkfun site that there is a limit of two. Meanwhile you can get the Baite Pro minis, which I think are a bit better than the Sparkfun versions, for $3.65, or $24.70/10 on aliexpress, shipping included.
    In the past couple weeks I’ve seen another version of the pro mini (also with a 16Mhz crystal instead of an oscillator) listed for only $23/10 on aliexpress.

  5. Well Arduino is not to be hated. Its a revolution meant to create a homely microcontroller that “everybody” (Kids,Designers,Makers,Designer etc ) can play around with and experience the joy of making with any of their problems just a Google search away.

  6. The whole point of the Arduino, is that it easy to use. Its not a supercomputer, its a low cost, low power, easy to program 8 bit microcontroller, and can do all of the things you expect from a low cost, low power 8 bit microcontroller.

    At a little over $2 per board, it outperforms most old school 8 bit machines, but unlike the Apple II or Commodore Pet, it wasn’t designed in the 1980s, doesn’t consume tens of watts, have dodgy ram sockets and fit in a case the size of a (pile of) shoe box(es).

    The ProMini for example is simply a tiny little board that can do a lot.

    You can do the same sort of things with a similar spec PIC, or an 8085 clone, or a 68XX, or … any number of other similar spec devices, but they don’t tend come on an easy an the wallet, easy to mentally digest ProMini form factor board.

    The Arduino concept has probably done more to popularise a CPU than pretty much any other idea since the 1980s. The AVR is far from perfect as a CPU, but the same can be said about them all, from the Z80 to the ARM, all have their quirks and their fanbois and haters.

    There.. I’ve got that off my chest, now I can go back to masochistically programming my PDP11 using the front panel toggle switches interfaced via some 555 timers to a rack of solenoids and a bank of old telephone relays :¬) .. actually I might have to substitute the 555s for a couple of OC71 germanium transistors wired up as a multistable vibrator.. or maybe I’ll use some 6SN7 thermionic valves, and wax paper “condensors”…. I’m sure with a bit of bare metal hacking I can get this thing to run brainf*ck.

  7. I used Arduino’s in an after school program – the shields are easy to work with and the libraries make scaffolding the software development process pretty easy. These boards allow students to quickly roll their own projects and have sparked numerous life long thinker/tinkerers to pursue engineering as a profession. I think that the Arduino was never meant for those in the field, but rather as a really good starting place for those at the start of the journey. They work well for capturing the imagination and introducing basic skills to the interested because so many talented people have created so many cool projects and then given their projects back to the community with well documented tutorials. Thanks to everyone who has posted a project and left sourcecode for others to follow!

  8. All these people complaining about what an Arduino CANNOT do are missing the point. The point is that it was always intended to be a device for beginners and people that don’t need professional quality output. It is a marvelous device for learning the basics of microcontroller coding, simple enough for children to use and easy enough for stubborn old guys like me that spent 30 years using BASIC and are now struggling to learn C.

    Comparing an AVR to an ARM is like comparing a Honda Civic to an Aston Martin DB9R. Just because one goes faster doesn’t invalidate usefulness of the other. We’re not all race car drivers, and we’re not all professional programmers working on production devices.

    By the way, I have a Parallax Propeller, 2 XMOS StartKits, and an Arduino UNO. Guess which one sees the most use…

  9. @whitequark :
    I would like to point out that one can significantly lower Arduino devices power consumption :

    Perhaps not as low as you (whitequark ) may want, but pretty low still. Of course, you could want lower power. But if you have to store the data, and/or send it wirelessly, like you probably will do with this kind of sensors, you will end up using significantly more power transmitting than measuring.

    Of course, i agree with you on the fact that other solutions may clearly be more efficient. However, we can do pretty advanced stuff with Arduino, not only blinky stuff, but also pretty highly optimized stuff, with low power consumption.

    As for me, the point of Arduino is that you can quicky learn enough to start such projects, whereas with other solutions you have a much harder time starting learning it.

    And that’s without even considering the use of Attiny with the Arduino software, and in this case, we can get pretty low power.

    My point here is that all in all, we can use Arduino for a very large amount of projects, including some very specific stuff. Other specialized solution are more fit for some problems, but hard to learn and/or only useful in specific problematics.

    However, i’m not an electrical engineer, i’m a pure computer scientist (research in AI), and i know little in production engineering. But one year ago i could only light a LED with a battery and resistors, now i have around 10 robots, i made a very low power meteo sensor (low power enough to have a lower power consumption than the battery self discharche rate), i have a few domotics project on the way, planning to build a CNC pretty soon, an underwater ROV, an extremely low power robot (low enough to be able to have “endless runtime” with a little battery and a small solar panel), i learnt to use SPI and I²C devices, radio modules, IR stuff, and a bunch of other stuff.

    All that, i did on my free time (i wrote and defended my thesis this year, plus i have a lot of teaching), without any prior knowledge, or help other than just googling.

    As for me, all of this is thanks to Arduino and Raspbery Pi. (I may have done with beaglebone black, but i bought a Pi and found a lot of ressources).

    I am in no means an expert, but anyhow it allowed me to start a small hackerlab in my university, and in on year we could incorporate robotics programming as an option for the first year students, none of who knew anything about robotics or even electronics.

    Now, thanks to Arduino, an IC is nothing special nor frightening to me, and i don’t mind trying to design a analog circuitery, i probably will try the HAM licence soon, and many other stuff. And when i look around me, i now see many stuff for which i have the feeling that “i could do better by myself, and/or cheaper”.

    If that doesn’t make Arduino a great platform, what does?

    PS : i still get some criticisms against it, and i don’t claim it to be perfect for everything! I just think it’s pretty efficient for a lot of stuff, and can even be pushed pretty far in some cases. But not perfect :)

      1. I agree that an arduino board would be inneficient for a project!
        However, once developped on an Arduino board, would it be problematic to
        design a Atmega board with an Arduino bootloader onto it?
        if so, why wouldn’t it be a good idea?
        As for me, a product based on an Arduino seems like a great idea, as i will be able
        to tweak it, upgrade, repair, etc… easily.

        Again, i’m not an electrical engineer, i’m really asking. I probably will keep doing my stuff with Arduino/Atmega/ATtiny rather than other solutions because i know it better, but i also like to know the limitation of the stuff i’m using.

        So, except for very specific products (hardened devices, ultra low power stuff, etc), why should one use something else than an Atmega with Arduino to design a final product, if created a specific board for the product is the plan?

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.