Ask Hackaday: Arduino In Consumer Products

Speak with those who consider themselves hardcore engineers and you might hear “Arduinos are for noobs” or some other similar nonsense. These naysayers see the platform as a simplified, overpriced, and over-hyped tool that lets you blink a few LEDs or maybe even read a sensor or two. They might say that Arduino is great for high school projects and EE wannabes tinkering in their garage, but REAL engineering is done with ARM, x86 or PICs. Guess what? There are Arduino compatible boards built around all three of those architectures. Below you can see but three examples in the DUE, Galileo, and Fubarino SD boards.

This attitude towards Arduino exists mainly out of ignorance. So let’s break down a few myths and preconceived biases that might still be lurking amongst some EEs and then talk about Arduino’s ability to move past the makers.

Arduino is NOT the Uno

When some hear “Arduino”, they think of that little blue board that you can plug a 9v battery into and start making stuff. While this is technically true, there’s a lot more to it than that.

  1. An Arduino Uno is just an AVR development board. AVRs are similar to PICs. When someones says “I used a PIC as the main processor”, does that mean they stuck the entire PIC development board into their project? Of course not. It’s the same with Arduino (in most cases), and design is done the same way as with any other microcontroller –
    • Use the development board to make, create and debug.
    • When ready, move the processor to your dedicated board.
  2. What makes an Arduino an “Arduino” and not just an AVR is the bootloader. Thus:
    • An Atmega328P is an AVR processor.
    • An Atmega328P with the Arduino bootloader is an Arduino.
  3. The bootloader allows you to program the AVR with the Arduino IDE. If you remove the bootloader from the AVR, you now have an AVR development board that can be programmed with AVR Studio using your preferred language.

There Is No Special Arduino Language

Arduino "blink" sketch should run on any Arduino compatible board.
Arduino “blink” sketch should run on any Arduino compatible board.

Yes, I know they call them sketches, which is silly. But the fact is it’s just c++. The same c++ you’d use to program your PIC. The bootloader allows the IDE to call functions, making it easy to code and giving Arduino its reputation of being easy to work with. But don’t let the “easy” fool you. They’re real c/c++ functions that get passed to a real c/c++ compiler. In fact, any c/c++ construct will work in the Arduino IDE. With that said – if there is any negative attribute to Arduino, it is the IDE. It’s simple and there is no debugger.

The strength comes in the standardization of the platform. You can adapt the Arduino standard to a board you have made and that adaptation should allow the myriad of libraries for Arduino to work with your new piece of hardware. This is a powerful benefit of the ecosystem. At the same time, this easy of getting things up and running has resulted in a lot of the negative associations discussed previously.

So there you have it. Arduino is no different from any other microcontroller, and is fully capable of being used in consumer products along side PICs, ARMs etc. To say otherwise is foolish.

What is the Virtue of Arduino in Consumer Products?

This is Ask Hackaday so you know there’s a question in the works. What is the virtue of Arduino in consumer products? Most electronics these days have a Device Firmware Upgrade (DFU) mode that allows the end user to upgrade the code, so Arduino doesn’t have a leg up there. One might argue that using Arduino means the code is Open Source and therefore ripe for community improvements but closed-source binaries can still be distributed for the platform. Yet there are many products out there that have managed to unlock the “community multiplier” that comes from releasing the code and inviting improvements.

What do you think the benefits of building consumer goods around Arduino are, what will the future look like, and how will we get there? Leave your thoughts below!

148 thoughts on “Ask Hackaday: Arduino In Consumer Products

  1. I actually disagree that it’s the boot loader that makes it “Arduino.” You can add boards.txt entries to your Arduino IDE to support programming bare chips with AVR ISP programmers with no boot loader at all.

    What’s Arduino at that point? Nothing more than an IDE, a series of libraries, and a little bit of glue code that bridges the gap between main() and setup()/loop() (and also does some of the legwork for some of the capabilities of the library, such as setting up timer0 to support millis() and delay()).

    Given that, I believe there’s nothing pejorative at all about using the Arduino IDE to develop a commercial or consumer product. What you get out of it is a ton of third party library support. The only thing you have to worry about at that point is respecting all of the licenses involved.

    I’ve developed products with straight AVR-GCC and the AVR libc too. That has benefits when you don’t need a lot of sophisticated library support, but you need minimalist code – particularly when you’re using ATTiny parts with limited flash available.

    1. Hear hear.

      What Arduino actually is to the 99.99% of its users is actually the ecosystem of specific pin-compatible boards and shields and pre-made code snippets that allow one to simply connect some wires and press a few buttons without prior experiece in EE or embedded programming. It’s aimed for people who need an instructables article on how to strip a wire and which side of a battery is plus.

      Once you take that away, the “Arduino” dissapears. It isn’t the IDE, it isn’t the bootoader, it isn’t the boards – it’s all of them – because it’s not really really meant to be a teaching tool or a stepping stone into embedded development. Quite the opposite: it’s a product you sell to abject amateurs in order to make them buy more of the same.

      1. It’s something people buy who want to use microcontrollers without having to learn too much about electronics or programming. It’s supposed to just work. It’s a tool. Not a religion, a way of life, or some bizarro thing to pin your self-respect on.

        Some people want a computer because it actually performs a useful function for them. They simply don’t care about the rest. As a result there’s a very cheap / dirt-cheap set of microcontroller boards anyone can buy. Even if they are incredibly clever and want to toggle their code in in hex. But for people who want to make art, or something to make their life easier, to connect things to networks, that’s what they get, with the minimum effort and brainpower needed beyond that relevant to the job.

        It’s a tool to fit a purpose. Many purposes. That’s what Arduino is. And it’s brought the prices of dev boards crashing down by providing a competitor. Which it could only do from being massively popular. Which requires ease of use, for a user base beyond the people who were programming PICs from serial ports 20 years ago.

        It’s a social invention, more than a technical one. And what a fantastic idea. And all those experts benefit from it too. Even if they do think one’s choice of development tools somehow makes one a worthwhile human being.

        1. “It’s something people buy who want to use microcontrollers without having to learn too much about electronics or programming”

          And as such, you would not build a commercial product with it. If you can’t use Keil/develop natively for ARM or similar architectures, then you should not be the EE for a commercial product.

          That’s the point. Because someone who has experience in EE is not going to pick the Arduino bootloader for their product. Especially since it comes with no guarantees. What kind of company wants that?

          1. Why not?

            Let’s start with this. I’m not an EE, I’m a product designer. I design a prototype that “just works” in my free time using a cheap Arduino bootloader AVR chip. Are you telling me that when I took that in to work and said “Hey, Mr. EE, we could use 1000 of these in two weeks, here’s the code, schematic, and the breadboard I used. I wouldn’t mind having my breadboard back after we get this on a board.” that the EE would tell me “F^*( off, it’s not a small ARM, I’ll spend a week redesigning everything!”?

            Of course the Arduino might not be what the EE uses all the time; but EEs are not the only ones who have design-able ideas and in a big company setting aren’t generally even the idea people.

          2. Similarly, what company wants to spend several thousands of dollars per seat on a commercial IDE that offers functionality they don’t need, complexity that slows them down and bigger learning curves?
            To be honest, many commercial IDEs are only just barely better than Eclipse on the ease of usability scale.
            It should not take an hour from first installation to toggle an output. It should not take writing from scratch or endlessly tweaking existing make files and basic set up headers just to compile the included demo code.

            I swear.. It seams like many commercial IDE companies ontentionally make their stuff a little shit, just to get you to buy tickets to seminars.

          3. But man does Keil suck. At least the version I used. You could not close a multi project without waiting forever.
            Before anyone makes a throw hardware at it comment. It took forever on a Dell Precision T3610 with an SSD and 32gb of ram aka it is not a slow system.
            We use unos for some testing stuff.
            You are correct as far as a big company goes. Where you are wrong is for a small start up with an idea. While I would not use an UNO for a product I could see someone using the IDE and bootloader with a custom board with an AVR to do a product.

          4. I think it depends. There might be a bit of crossover between hobbyist one-offs, and small volume production for companies serving niche markets. Or perhaps you’d make a few products with an Arduino, then scale up to something more specialised if it starts to sell well.

            It’s the way software’s going these days. A lot of stuff is done RAD, just a database with a front-end coded in Visual Basic or the like, I’ve seen it done to control multi-million pound machines. A lot of applications are 90% front-end. If you’re writing an OS for mass use, you do it in C and make a good job of it. If you’re writing an app for one client, you use more tools.

            While using Arduino costs a little money and some of the CPU’s resources, you can just spend the extra dollar and buy the next better chip. Programmer (human) time is expensive! CPU time is cheap. If you’re mass-producing, where saving 10c is worth thousands of dollars, it makes sense to use the time of a team of talented programmers and get the most out of your hardware. It’s a straight tradeoff. Dividing the effort and money between the hardware and the human beings.

            Arduino isn’t much more than a bare AVR anyway (except when it’s an ARM). They’ve taken a big chunk of the difficulty out of it, in return for losing a little functionality. And, probably important, you can move from Arduino to straight AVR step by step, using less of the Arduino libraries as you go, til you drop the last of them and are working purely from your own resources. It’s not much apart from C++, so your Arduino skills are definitely adaptable to other MCU stuff.

          5. I’m an EE with a degree and a masters, I use it every day.
            We’re designing and producing low volume production robotics platforms for nuclear decommissioning. You write me a load of ROS libraries for (insert name here) micro / arm and i’ll happily use them.
            Arduino / mbed all the way!
            Anybody that codes bare metal in the design process or low volume production, for anything even remotely complex is an absolute anorak, and would probably be a pain in the ass to work with. Not to mention that even if they were hot shit at their job, they’d probably take longer to do it than me and my trusty arduino IDE.

          6. The op is either:
            a) Starting a flame war just for the sake of it spreading FUD
            b) a fool

            Arduino is basically the set of libraries, the abstraction layer that makes it easy to work with the micro-controller.
            Debug and test facilities with Arduino are a joke and you need to have your code debugged before sending your product to the wild.

            @Quin “I’m a product designer. I design a prototype that “just works” in my free time using a cheap Arduino bootloader AVR chip.”

            LOL. You are not a product designer, if anything, you are just a hobbist working on prototypes. Arduino is great for that. it is ok, for most companies, to design a first prof of concept/prototype using an arduino since no user will ever get to see/use it.

            by the other hand, when you have to hand over a product, be it a one off or a mass produced one, you have liabilities and specifications. so when you hand over you prototypes the EE won’t say “F^*( off, he will say: oh thanks, and it might help as a prof of concept to pitch to the boss. But in won’t really help in the way of real product.

      2. I agree. While the IDE is basic, and Chinese clones can be sold off as throw aways, it’s powerful in the right hands. I’ve done a fairly cool project using an arduino micro. I have a saltwater reef tank and I purchased a Marineland reef capable light that includes a digital clock for turning daylight and moonlight on or off at set times. It was actually a small display on the side of the unit. I saw there was room to stuff the board inside so I basically interfaced between the 5v digital signal lines to fade the light strips in and out smoothly versus a harsh on or off. Basically when it saw a logic high, it would use a pwm signal to fade the lights on another pin. I also got crazy with it and did a rolling cloud effect. These are features commonly found in very expensive lights. I did it for a few dollars, some solder and a program. This isn’t something I would have been able to do in an afternoon with traditional electronics hacking.

    1. I second what derp said. My biggest objection to the Arduino is the lack of a modern debugger. Being unable to set breakpoints really limits the complexity of your project, thus making it less likely that Arduino would be used in many applications.

      1. The inability to do robust debugging keeps the Arduino off of my list for anything intended for production. My 3d printer uses an Arduino derivative and tracing down problems in it makes me that more resolute in my decision that Arduino isn’t capable in it’s current form for a rock solid product.

      1. Were you aware that Texas Instruments has a “clone” of Arduino called “Energia” that can be debugged with their Code Composer Studio IDE? Combine that with an MSP432 (ARM Cortex M4F@48MHz) and their new Energia MT (Multithreaded) and you have all the power missing from the ATMEGA Arduino, plus real Hardware Debugging, plus a Multitasking RTOS. Why this platform gets no love is baffling!

        1. I don’t use MSP432 but I know that MSP430 doesn’t get the attention it deserves either. I use it on one project to read encoders, a couple buttons, control a few devices via I2C and a couple other things via GPIOs. It easily does all this on very low power which was one of the main requirements as it’s a mobile device. Also: nice and inexpensive dev boards (many models to chose from), free and uncrippled dev tools (no silly code size restrictions), etc.

          Then again, everything that isn’t Arduino or Raspberry Pi doesn’t get much attention from hobbyists (or otherwise, PICs for long timers who don’t want to learn anything new). Doubly so if the dev boards are $100+ like the BeagleBone. There’s *tons* of nice things out there from other companies, like the Kinetis line which I’m also using on another new project.

          1. Hi Meh – Great to hear you are using Kinetis line for one of your new products!! I’m a product marketer for Kinetis at Freescale and love hearing that people are using and enjoying their experience with our solutions. Thank again :)

        1. Of course, there are *many* different libraries that you can run on an AVR that offer much better performance.

          There are also other hardware development tools that you can use to provide proper debugging.

          There are also other software development tools (editors, IDEs) that provide a far richer development environment.

          But when you implement all of those you’ve got absolutely nothing “Arduino” left, except perhaps a PCB with the word “Arduino” silkscreened onto it.

        1. I suspect that’s NOT (exactly) the case.
          All port/pin names are defined in device headers for each cpu/board combination. So by the time its all linked and ready to compile, it should be defined constants.
          However, multiple names are allowed (such as digital wrote(led) where you have given pin 13 a name). The compiler needs some code to translate that at run time. You take the hit. It’s gotta at least check. Would have to dig the code to see how much is going on.

          Also, he mentions near the end that in doing hard bit manipulation, he’s writing the whole port…
          And that’s sort of the POINT: you’ll always take a perfmance hit to mask out bits.
          If you ever do anything REAL (not just blinking an LED) then you will have to do masks and bit manipulation. There is always going to be code overhead. Perhaps you’ll write a cleaner/tighter version that is case specific.. But any generalised/flexible version is going to take roughly the same amount of time.

          So.. IMO, this is not really a fair comparison/complaint.

          And as demonstrated, you can always just Chuck the Arduino code aside whenever you need your own faster versions.

    2. There are a few simulators like simulavr that you can connect to gdb. Granted, not as good as a hardware debugger, but it fills part of the gap. Personally I’ve found the longer I’ve been coding the less I use a debugger. Also, with imbedded there are many situations where you break protocols if you stop the code execution. So my recommended debugging tools for AVR development are objdump and a cheap logic analyzer. If you can afford a scope, even better.

    3. Is there a reason somebody couldn’t add one to it? Is it just a software problem?

      If extra lines are needed, could they connect to the RS323-USB adaptor chip some of the Arduinos use?

    4. @derb,
      You don’t understand what Arduino is. It doesn’t target persons educated in EE or computer science. It target those who are not, like artists. Those persons don’t want to spend hours learning how to use Arduino IDE. Arduino IDE is perfect for them. Arduino is great for them, not for me so I don’t use it.

  2. While I agree Arduino is great for quick prototyping when you don’t want to waste time setting things up and just need a well documented easy to use library, bit I would not use it in a commercial product. You really loose control in the sense that you are dependent on the library developer for big fixes, speed optimizations etc etc

  3. Oh, but hating Arduino is so much fun!
    Knock-offs can be had for a few bucks on eBay, but I still contend that by & large the official stuff is overpriced.
    The IDE is great, because it’s so easy even a n00b could use it. The IDE sucks, and only a n00b would use it. ;-)
    That said, I keep a stock of Chinese-made Micro boards for those quick & dirty little projects that pop up every now and then.

    The biggest problem IMHO is that the name “Arduino” is often conflated with “embedded computing”.


    Show me how to pause execution, or do any other basic debugging action without Serial.print, and then we can start talking.

    1. What’s wrong with serial.print? Dumping variables to the screen is often handy in PC programming. It’s not single-step but it’s helpful. You can always cut out the serial.print for the finished product.

      1. It ruins timing-critical parts of your code, hogs a huge amount of the available RAM and flash, and generally takes so much of the slower CPUs that they become unable to perform the task you’re trying to debug.

          1. How hard would it be to program an Arduino to be a JTAG debugger for another Arduino? I bet there’s at least 5 projects out there that do that.

          2. And that’s the entire point of the argument. If you just want to throw together a quick prototype or make a quick one-off device, Arduino can be a very good solution.

            As soon as you start talking about consumer products in any kind of volume the equation changes completely.

    2. Presence or lack of a convenient developer feature is not the definition of a commercially applicable part. In the days before you were likely born, microcontrollers (or at least microprocessors, depending on your age) existed and were implemented in commercial products that lacked those features.
      I remember not long ago, NO microcontroller had analog inputs for example.

      Also, remember that the AVR series hadca long life in commercial products long before Arduino existed.

  5. Is there a good blog post somewhere that goes through the details of the various bootloaders on the Arduinos? Including the (possibly) tricky link/locate modification that have to be made.
    I want to compile a project totally outside of the arduino IDE, but still be able to drop it onto an Arudino board without needing a reflash. Surely someone has done that?

    1. Optiboot, the current AVR Arduino bootloader, is just a normal old AVR bootloader. At heart, it’s an Atmel STK500 clone, and the original codebase way predates the Arduino.

      I know there’s been some clever work to streamline it into the Arduino IDE. Bill Westfield, its maintainer, who reads HaD, should pop up and take a bow. :)

      That said, you’re not changing the code without “reflashing”. Programs live in flash memory in AVRs. All the bootloader does is reflash the chip’s program memory using the serial lines instead of the (“normal”) SPI lines. You’re reflashing either way.

      As for compiling/flashing Arduino code w/o the Arduino IDE, there’s been a bunch of interest in that lately. I played around with this ( only to discover that it’d already been done better and more robustly ( A couple weeks ago, popped up in my twitter feed.

      In short, yeah, that’s a multiply re-invented wheel. :)

    2. The ATMega328P has a dedicated bootloader area of flash; you can write, compile, and link your code without regard to whether the target processor has a bootloader or not.

    1. Nope, it is C++. The Arduino IDE (based on the makefiles anyway) uses both avr-gcc and avr-g++, defaulting to -std=gnu89 and -std=gnu++89 for each. The IDE makefiles only specify -std=gnu99 for GCC.

      On top of that, the Arduino libraries define classes.

      All the Arduino IDE does is provide a framework, a bunch of libraries and the makefiles required to build the whole thing. Take a look in Arduino/hardware/arduino/avr/cores/arduino/.

      source for flag defaults (ctrl+f, -std=):

      1. What Arduino really does is confuse noobs with the .ino file, which makes you think you’re writing some magic with setup() and loop() function. “Ooh, it’s not C++!”

        But have a look at the /arduino/avr/cores/arduino/main.cpp that it’s linked against, and you’ll see something like this:
        int main(void){
        #if defined(USBCON)
        for (;;) {
        if (serialEventRun) serialEventRun();
        return 0;

        And the rest is straight C++ (with some C thrown in here and there).

        There is no “Arduino language”. Only some libraries.

  6. Wouldn’t having the arduino bootloader open up a can of worms for FCC regulations and what not? Meaning the consumer can change the code and make their IOT toaster into some sort of terrorist device?

    1. The chip can be reprogrammed regardless of weather or not there is a boot loader installed, since the chip can still be programmed over SPI (In Circut Serial Programming) or by using a high voltage (12V) parallel programmer. SPI programming can be disabled by a programmable fuse, but HVPP is always an option, just in case you fat finger the fuse setting while uploading.

    2. If the FCC decides to crack down on bootloaders, not being able to use arduinos is going to be the least of your concerns. Basically every computer, much less embedded device, has some form of bootloading going on.

  7. You are attempting to make a statement about real engineers using Arduino, yet you use a large picture of your own product that isn’t for sale and has design no-nos visible in the picture. Then you show the Galileo…well that’s a development board, so that doesn’t count as a “commercial product” just because it was made and sold by Intel.

    I have been in electronics manufacturing for 24 years now (the last 15 in contract mfg) and have literally seen a few thousand designs of boards. Only once have I seen a development board or module used in a released product. As ankit1985 stated, they may get used for prototyping, but stating they are used in real product is simply wrong without having a lot more data to back it up.

    On a side note, I am curious as to the name of your product. My wife’s china that she collects is named Liberty Blue.

    1. Including ‘dev boards’ is quite common in low volume production, it is getting less popular now that things like stm32 are so readily available, but it used to be that if you wanted more than a few kb of ram you had to build up an entire 68k computer, so there are a wide variety of ‘computer on a board’ boards that are designed to get incorporated into commercial products. has a history of the x86 based ones. I have also cracked open a good number of pieces of scientific equipment that are built internally as a FPGA dev boad and some modules plugged into it for expansion, it is all a matter of development cost vs production cost. If you are only planning to sell 10 units a year for $100k a piece then spending a week laying out a 4 layer board for your FPGA+SRAM to save the $35 price difference between the raw parts and entire dev board really does not make much sense

      1. PC104 is a form factor commonly used in a variety of products to enable use of SOC and expansion modules specificaly for the form factor. PC104 is a form factor, not a dev board design. That is like saying all SO-DIMMs are dev boards.

        All FPGA boards I have built in the past 15 years were designed by the customers we built them for; never dev boards. Even the ones using $2200 FPGAs were self-designed. I am sure that code verification and prototyping was done on a dev board, but not product to be sold.

        I am in the low-mid volume high mix category as well so I can’t agree with your statement about it being common to use dev boards in low volume product. We have several PCBAs that could be done with an off the shelf Arduino or Propeller board, but that would never happen with designers doing things correctly.

        For a $100k product, I would never use something off the shelf to save $35. A real company would require much tighter controls on product quality, reliability, design longevity, etc. Dev boards are cheap for a reason. Would you buy a new $25k car if the electronics inside were built with dev boards?

      2. This is especially true in the pre “$20 China PCB” house days. When a dev board was over $100, but making 30 of your own design required expensive CAD software, a $1000 setup fee and minimum runs.
        A few places were lucky to have good contacts with PCB fsb shops or their own division.. Otherwise single digit prototypes were $500 plus.

        These days, using a dev board in a commercial product makes no sense other than time constraints. Kicad is free and very functional, and boards are often cheaper than the chips.

      3. In my industry ,bespoke electronics for oil and gas industry, due to the last minute nature we may only have 1-2 weeks (if lucky ) to design and build a final unit. Although we have a collection of designed boards, if using a dev board gets us out of trouble so be it. We will sell for $100,000’s but as long as it works relaibly the customer doesn’t care what is inside. I’ve used FPGA dev boards, and could design my own, but that is time away from something else.

    2. Really? What are the design issues? I just used the eagle auto router. It’s not a commercial product, but an accessory to be used to test one of our machines. We do use AVRs with bootloader in few things though.

      1. Will, just to be clear, I meant no disrespect in regards to your design but intended to make the comparison against “commercial products” designed by “hardcore engineers” based upon my understanding of the intent of the article.

        However, the issues I see with your board is the 90 degree trace corners, the minimal spacing between some vias and traces, and the trace spacing from nearby items, such as the trace running below R2 and the FTDI. While Eagle may route this way and you may not ever have form, fit, or function issues, from a design perspective, these would be items I would definitely list on a DFM report if a customer asked me to build this board.

        I haven’t used Eagle in a while (I use DipTrace personally and Altium for work), I believe you can make adjustments in the auto router and DRC rules so that these issues would be prevented automatically.

          1. Good design practices always apply and should always be followed. Plus 90 degree or less corners can create quality risks with the fab house in etching processes, so regardless of the function of the board, doing the right thing is simply smart engineering. However, I did state that, in his case, he may not ever have any issues with the design.

          2. 90 degree corners can cause overetching issues with some board fabrication processes. Typically not a big risk, but why take it when it is easily avoided.

      2. Also, internally to our production environment, I have designed 3 test fixtures that run from Propeller based dev boards. So, used in a production environment to test commercial products, but not sold as commercial products.

      3. Multiple design issues. Certainly this is at a junior engineer level. Why do I think it is a junior engineer’s work? There is no considerations for signal integrity.

        – First off the USB signal are not routed as diff pairs. Not that it is too important for 12Mbps.
        – The decoupling caps are not replace optimally nor that short fat tracks are used to connected the caps.

        I would place one of the caps next to the USB connector. Always decouple right at the connector to minimize EMC issues. The other caps should be place next to the power pins of the chips they are supposed to be decoupling. You are sprinkling it on as if they are decor…

        As for the article, it is a click bait. It is an opinion piece passed off as a question. You have already made up your mind before “asking” a question. As others have said no real life data on # of consumer boards stats. As conventional reddit wisdom, any piece that starts with with form of a question can be answered as a “No”.

    1. It’s not really as bloated as it looks. It might be 1K for blinking an LED, but if your code is 100 times more complex than blinking an LED, that doesn’t mean it will take 100K. There’s an initial hit when you pull in the libraries, but once they’re linked in, your application can grow without seeing ridiculous increases in code size.

    2. I think the problem is actually that you don’t know what libraries are going to have bloat in them. For me it’s speed and not programming space that is the concern.

      For twiddling IO I go straight to PORT and PIN commands, bypassing the digitalWrite(), etc.

      1. Actually, because Arduino’s compiler is a modern C++ compiler, it is possible to create digitalWrite(), etc. functions that are exactly as fast (same number of instructions/clock ticks) as those “MYPINPORT &= ~MYPINMASK” statements.

  8. Tbe arduino is perfect to quickly test a chip or sensor. I would put it into the same region as a buspirate,

    For a commercial product i would use an other platform (PIC, but that is just what I’m used to; could have been AVR or other) and write most of the stuff my own. .That give more insight of how things work.and will help in providing service later on. I would not rely on some dodgy overcomplicated library someone else wrote :)

  9. Arduinos are great for showing a sales and marketing team a product concept so they can show a customer. However, in all consumer, white goods and toys that I have worked on, the push is to squeeze every penny and even 10ths of pennies (in high volume products) out of the cost of the product.

    They have their place, don’t get me wrong, we wouldn’t have as many 3D printers and so on. There are certain platforms they make absolute sense. However, anything you are going to build millions of? Nope…micros are always the way to go.

  10. I wouldn’t guess that you’d see much Arduino in large-scale production devices. Few reasons.

    1) Watchdog timer. Using it right helps reliability a bunch, but can require thinking pretty hard about your specific problem / system. That’s not what Arduino is about.

    2) millis() ties up one of the AVR’s scarce timers for a system tick. Maybe you need that, maybe you don’t. Maybe you want a different frequency or something interesting to happen on the tick interrupt.

    3) The whole digitalWrite() abstraction takes 20-40x longer than flipping I/O pins directly. Maybe you care about speed, maybe you don’t.

    I’m sure there’s more. I’m not an Arduino expert but these are the bits that hit me when looking over other folks’ code.

    In short, the Arduino library is meant to be easy to use in a wide range of general circumstances, and not much of it is optimized for performance or tailored for specific cases. This is not a complaint — that’s just what you want for quick prototypes.

    For permanent / designed products, I would expect to see more purpose-built firmware. But who knows?!?!?

  11. My problem with Arduino, besides the bloat, is the GPL license. If you use Arduino code then you have to open source your code. Not many companies want to invest $1000’s of dollars developing code for a product just to then give it away to competitors.

    1. How are they spending thousands of dollars on dev?!?!
      It’s a free IDE.
      Free compiler.
      Free libraries.
      Only expense billable here is the programmer’s hours and the hardware dev cost.
      At $30 per hour (I’d not feel good about charging 50 for Arduino code) you’d have to spend 30+ hours on code directly.

      1. There are so many more costs to releasing a high volume product than writing the code. Hardware design, Validation, environmental testing, manufacturing equipment, support material (field repair docs, owners manuals) etc. and $30/hr is low but factor in 3-5 people doing portions of the design over the course of a year and it adds up fast.
        Before a company invests in all that they want be sure they can protect the design from copy. At best you only have 2-3 years before someone reverse engineers it so open sourcing via Arduino just exposes all that a lot sooner.
        And then add in the lack of real debug support, crude IDE, things going on inside some libraries that are better off re-written from scratch and you begin to lose any advantage Arduino offered.

    2. No you don’t. The IDE is covered under the GPL, but the library code is licensed under LGPL, which means you can link to it from your own code with no problems.

      Besides which, your last statement is begging the question; a great number of maker businesses license their products open-source; it’s not the same as “giving it away to your competitors”.

      1. Fine print in LGPL says your app should be release in a form that would allow the user to “upgrade” it to a newer version of the LGPL’ed libraries.

        In an embedded application where all code is combined into a single binary file, how exactly do you make that upgradeable without releasing the full source?

        1. That’s true, it does. You can do so by distributing object files of your compiled source, so users can link it with a newer version of the library if they wish. You only have to distribute the object files to those licensed to use your code, and the LGPL places no restrictions on what the license of your portion of the code is – so you don’t have to OSS license it if you don’t want to.

          It’s an important distinction, too, to note that giving your users the source (Which the LGPL doesn’t require) is not the same as open-source licensing it.

          1. That may be a way around it but now you’ve introduced another layer of complexity and potential retesting of the final product (which can be costly) that can be eliminated by just not using code with any open source license of any kind. Hence Arduino advantage is lost. It’s easier and cheaper in the long run to build your own libraries and protect them. So companies tend to stay away from going down the Arduino path. It’s fine to prove out a quick prototype or proof of concept with Arduino but then re-write everything in smaller more efficient code that can be packed into a smaller lower cost code protected device.

          2. I’m not really moving the goal posts as these are all part of the microcontroller decision when designing a consumer product for any kind of large volume (10k or higher). So that is why companies and therefore professional programmers tend to stay away from Arduino for anything more than a prototype or small run of product.

  12. Anyone else checked out the new PIC Harmony/Configurator stuff? I’m a fan; I hope embedded stuff will go in that direction.

    You should be able to use an IDE GUI to select what peripheral functions go to your pins instead of cribbing notes on a datasheet or worse. Bonus points if you can output more detail on what you’re planning for a part to a schematic symbol, which Microchip hasn’t done. Then it writes some code to set up SFRs for those peripherals and hands it to you. Much less referencing the datasheets, and I hope to not get caught on the tiny differences between processors.

    Arduino is just an early idea. Things have quite a way to evolve if the momentum stays behind it.

  13. It’s not “[t]he same c++ you’d use to program your PIC”, C++ is only supported for PIC32s (if you register for the free license, or crack the compiler). So score one for the Arduino.

  14. I always see so much hate for the IDE and other aspects of the arduino, so what do you guys use?

    I’ll admit there is a crazy number of people who just leave the dev board in their project and go off and buy another one, but ignoring them what exactly is wrong with the arduino?

    Everything I make I’ll test out on my old duemilanove board, make a schematic/board in Eagle, etch using the photoresist method and solder in a 328p with the arduino boot loader. Isn’t this how a development board is supposed to be used?

    1. You can get things like the Teensy, just a little board with through holes with the layout of a DIP chip. You can get them so cheap you may as well solder the thing in. A middle-ground between a full Arduino board and a bare chip, for not much more money.

    2. > I always see so much hate for the IDE and other aspects of the arduino, so what do you guys use?
      The AVR toolchain under Linux, full C++, VI and my own WAF based make system with avrdude and an AVR USB debugger box. The main problem with the IDE is proper dependency management, if you have a lot of files, #defines and different modules it’s almost impossible to use the arduino ide.

  15. I have seen a lot of people around here who claim that they are proficient in using microcontrollers and used only arduino. There is nothing wrong with it, except most of them haven’t read the datasheet. Can you freaking believe what’s happening? A generation of future wanabe EE’s who have never read the datasheet of the part they are using! Don’t know what fuse or configuration bits are. When they design a consumer product, how can we expect them to do a good job at it (other than blinking an LED). Using arduino board as a development board is perfectly fine if they are not using the arduino’s software framework (but using an actual Atmel development tools). Just go around a maker shop and ask for
    -what brownout voltage is.
    -why and how to use watchdog timer
    -state machines and interrupts
    -what is DMA
    -….. and so on
    You will be baffled with the reply you hear. Then its upto you an individual to decide weather to use a consumer product designed by someone with such a proficiency. Its a good learning and quick fix platform. Anything beyond that.. not sure.

    1. If you are hiring EEs who aren’t part of IEEE and haven’t passed the FE exam . . . well, that might be the problem. Sure, there are unaccredited schools out there that crank out “EE-lite” degrees with no knowledge of the real field, same as CS-lite who only know Java and one IDE and don’t think they could learn another language cause “java was so hard to learn the first time, another would take just as long!”

      Maker’s aren’t all EEs, or CS, or CE, or anything else. They are makers, they make stuff. If they think that puts them on the level of the engineers and accredited degree holders in those fields, that’s a flaw in the way society has propped up “making”. CompSci and programming in general took the other route, and insulted all of the “almost programmers” as script-kiddies. There can be a middle ground where we recognize the ideas and artistic talents of the makers without inflating egos all around and making it seem like making is the same as full certified EE+PE work.

    2. Sadly a lot of EE’s I know wouldn’t know either… They don’t really teach “electronics” in Electrical Engineering. That’s what people don’t seem to understand. Good EE’s that DO KNOW what they hell they are doing generally either went back to school after doing a technicians degree and working in the field a little while, did electronics as a hobby and decided to go on to an EE degree because they wanted to turn it into a career or bothered to take non-mandated labs and projects in school to actually get an understanding or took specific classes beyond the degree requirements. EE degrees are basically math degrees with some electron theory tossed in. But as far as any of it relating to real world electronics, hardly. And it’s not terribly hard to fake your way through the cert exams.

      Want to know abstract theory, go ask an EE. Want to know how something actually works and how to fix it, ask a tech…

  16. I think the Arduino is great for beginners however just because it is great for them doesn’t mean it can’t be usedfor some serious projects. Arduino might take a shortcut into EE but is that bad? The amount of people who have found an entry point into EE through arduino is more than anything else. The price of official boards are obscene I bought one to help the community but I stick to cones because the pricing is so high. I think they would make more money if they reduced the price to around $15 because people will pay for official if the price isn’t too much more.

  17. what an arduino is isnt very much. its an mcu and a means for programming it, a crystal, a voltage regulator and a few leds. these things are not hard to spin into your own project/product and many are not even needed depending on the application (for example you can ditch the crystal if you dont need high performance or precise timing, one i did had an on-board smps rather than a linear regulator like arduino usually has).

    i use an adruino as a dev board as it was meant to be used. it gets the project up and running enough where i can cut my own boards and build things the way i want them. one of the first things i did after getting my first arduino (a duemilanove), was to buy a bunch of loose atmega328p chips so that i could make a stand alone version of whatever projects i was working on. after all if i use my arduino i cant very well use it to prototype the next project on strip board. and now im soldering those tqfp packages to home made circuit boards.

  18. No one I know in the industry, including myself, is going to use Arduino in a product. In my opinion, that’s not what it is meant for anyway. What you’ve shown besides the Liberty Blue board (don’t know what that is) are development boards or development related products.

  19. IMHO the problem with the “Arduino” is that the libraries, architecture, design, and UI (which are ultimately what separates an “Arduino” from an AVR with support electronics on a PCB), are designed to be simple to use, but in a way that is incompatible with good embedded coding and design practices. If you want to optimize things cleanly in a final product, you often have to (I should say want to – there’s a wide range in product quality) tear down the bootloader and redo a good number of the libraries.

    It’s a great entry point, but as an experienced EE, it could be much better. You can tell there’s a lot of legacy support for relatively poor, platform-specific coding patterns because honestly, the Arduino founders started as a bunch of hobbyists rather than experienced EEs. The step between using Arduino libraries and knowing how to write good embedded code with your own libraries (preferably platform-independent), and designing in an ATMega328 into a custom design is really larger than it needs to be. As the top development platform in the hobbyist community raking in cash at, what, $25 a board for $10 of electronics (for many years now, too, and I’m sure they have the volume to approach that sort of pricing!) I think we should expect more…

    just my two cents…

    1. $25 retail for $10 of parts is a pretty good deal. And compare how much dev boards use to cost, for the same $10 of parts. Often hundreds, or the best part of a hundred.

      Plus it’s open source, so nobody makes money on the design of the Arduino. You make money by a mixture of price and quality, from the $3 pieces of Chinese shit, to the more expensive boards that come with a tutorial book, software on a CD, and some components and breadboard thrown in. That’s the ideal of open source, making money from providing good service, rather than ownership of ideas.

  20. Arduino is a brand.
    It goes on my résumé next to the Raspberry Pi to tell non-technical managers what kind of work I enjoy.
    If I make a project using #arduino, it gets a lot more attention by tech news websites than PIC or STM32.
    There’s a pretty blue sticker on a pin on my bag, which occasionally lets me start conversations with new friends who I didn’t know were equally geeky.
    Arduino is a level of abstraction: if an LCD is advertised as Arduino-compatible, I can expect to find decent documentation, it should “just work”, and it’s easy to test separately as a component.
    The difference between 1 KB and 400 bytes of code is irrelevant when comparing it to 200MB+ dependencies for apps developed for desktop using the .NET framework. Arduino is a like Bash script, while dedicated platforms are like C code. Which should you use? It depends. Estimate the total project lifespan: development time + code runtime. If it’s only going to be used once, slow runtime doesn’t matter as much – the development time spent making it faster outweighs the speed benefit in the end. If your project gets cancelled, the development time is lost. Release early, release often. Once you have the attention of the user thanks to an Arduino, you can gauge their feedback and port it to a new platform if necessary.

  21. As an artist, if i can buy a stretched canvas to begin painting, i sometimes do. Arduino brings fundamentally low level devices into the realm of “begin painting” which in my 12 year old sons view is a great way of opening the EE door to understanding how it all works. I think they have limited application in consumer devices however the likes of atmega328p chips are found in even industrial plc blocks for example.

  22. I work as a test engineer at a company that makes two different competitors to the Arduino. About half of us have arduinos on our desks, for prototyping, because we can have the ide open and code uploaded to the board before Eclipse or CCS has even finished opening. Somehow, stuff that works gets kept, so we have arduinos running things all over the place: 40 amp high speed power amplifiers with their cooling systems run by arduino nanos, tachometers running on 328’s with arduino bootloaders, because they’re good enough and we want to spend our time developing chips rather than messing about with fuse settings in Eclipse. Sure, lack of a good debug system is a pain, but you can do a fair bit of debug over serial or dumping to an lcd, and for a lot of us that’s good enough.

    1. Exactly, like i said down there, just use what fits the purpose. Maybe you’ll change the paltform at some point, maybe not. If you wanted the most optimal solution, you’d compare all the different microcontrollers and environments and libraries and prices etc etc. and made your decision based on that, but that costs time and money. Arduinos have served you well, if they hadn’t you’d use something else.

  23. I made a product called Xronos Clock basically with my version of AVR chip running custom bootloader and I use Arduino IDE for all my programming. Is it a commercial product? Sure why not. While it’s not mass produced, I’ve been selling my clocks online for couple of years now.

  24. “In fact, any c/c++ construct will work in the Arduino IDE.”

    Nope, that’s not true, at least not for ‘sketches’. The IDE will do some rewriting, badly. Point 1: It doesn’t support lines longer than 1024 characters. It’s a Java program that has a fixed length array for a line buffer! (They may have fixed that since I last checked ~2 years ago.) Point 2: It doesn’t understand typedefs (and probably some other language features) and then messes up when trying to create forward definitions. For my code I try to create type safety and readability by using typedefs and structs whenever possible to write down what I was thinking and let the compiler do the checking and optimizing. But something like

    typedef uint16_t rgb565_color;
    static void set_color(rgb565_color color) { … }

    will be transformed by the IDE into

    static void set_color(rgb565_color color);

    typedef uint16_t rgb565_color;
    static void set_color(rgb565_color color) { … }

    and then explode when trying to be compiled.

    Henryk Plötz
    Grüße aus Berlin

  25. Advertisement brought to you by Arduino!

    “Look, all your favorite chips are being used on “Arduinos” too!” – Yeah, no thanks, I’ll just use those chips and a REAL IDE and forgo the silliness of Arduino altogether.
    If I’m doing serious production and my reputation is on the line, I’m using real tools. They pay for themselves anyway. People can’t seem to understand that. A good IDE and environment is going to pay for itself very quickly.
    If you can’t get over the pay hump then you probably can’t risk to be in business anyway.

    If you are doing a mass run of something simplistic, using custom boards and an AVR and don’t plan on going beyond your simple widget, then it might make sense to use Arduino software. But if you plan on doing anything beyond cookie cutter stuff, Arduino quickly becomes an obstacle.

  26. Like a gateway drug, or a free sample, the Arduino concept has an overall positive effect.

    My main industry is broadcast engineering. I dabble in programming, having written in RPG II, Cobol, Pascal, assembly and a myriad of other languages….not as proficiently as many on this site, but well enough to get the job done.

    One of the comments here made mention of people who use Arduino as not bothering to read the specifications…but I tend to think of the Arduino as the structured language of microcontrollers. Before you say “what??” hear me out. Back when I began programming in High School, using IBM punch cards to get data collation sets to work in RPG II, the instruction we had was the equivalent of reading the specifications of a microcontroller. We HAD TO KNOW the limitations and how to address the mainframe to even get the code to run. If you forgot to include the job run requirements at the beginning of your code, the cards were useless. Saw many people fail jobs over and over because they forgot maybe 3 or 4 punch cards. Later, as technology advanced, structured languages came into existence and knowing memory limitations and processor registry entries became something that the normal programmer no longer had to worry about. Code was easier to produce, and the number of people in the public who could learn and perform the task of writing a program grew almost exponentially.

    Equate that to what the Arduino and similar products have done for microcontrollers. A whole group of people who wouldn’t ever try to design a device running on a chip now understand the basics of how that’s done. Those that do well with it can make a living. Those who use it as a stepping stone can learn how to go into the guts of a microcontroller and do even more sophisticated stuff.

    I can think of about 3 projects I’ve had to construct for my employer that I could have done much faster and much more professionally if the Arduino was available at the time. Arduino is a tool. It will never be used for mass production of a product because as it was pointed out by another comment here, the manufacturers are looking to save as much money on the board as possible….every penny counts.

    1. I completely agree. I’m new to industry and a couple years out of school and now I’m playing the catch up game. When I first got into electronics I loved circuit building and thought that people just throw micros at projects were cheating the art of circuit design, and never wanted to program.

      Then as I got to the end of my EE curriculum I started to appreciate coding more. For me Arduino is a stepping stone as I learn to program in AVR C and start playing around with PICs. I’ve used Teensy 3.1s in quite a few projects in industry to create test jigs validate various sensors.

      Like any micro, they have their place. If the application doesn’t need to be particularly efficient, then using an Arduino is great because you can get everything set up and running without the need of flipping through a datasheet that’s a few hundred pages just trying to figure out which register you need to set up and how to set it up. In more timing sensitive applications where you need to have control over every last thing to get it working right, Arduino would be inappropriate.

  27. Seriously, some people in here.
    Why do you have to bash something, just because there might be a better something currently in existance, than there was when arduino was first introduced? Guess what, the world is not optimal. If it was, there would be 1 microcontroller manufacturer, 1 that sensor manufacturer, 1 this sensor manufacturer, 1 battery manufacturer, 1 car manufacturer, 1 computer manufacturer etc etc.

    One thing you need to keep in mind is that, you use what ever fits the purpose. There are many things were you need safety grade hardware, where you need fast or accurate or hw capable of handling high vibration conditions or high temperature conditions, but there are many, many more places where no special features are needed. Sometimes you can finish something with arduino (or some other low performance platform) than you can get by ordering a finished product from somewhere. Connect a sensor to arduino, put a modbus code into it and voila, you have a network sensor right there. Guess how much that shit costs from a “real” manufacturer? And guess what, if it fits, then it fits. What there’s a compiting platform? It’s faster? Oh my god. must abandon the current platform right NOW! Bullshit.

    If you know some other platform that’s currently better, then make an informed post about the pros and cons. Don’t bash. When arduino was born, what other easy platforms were there? 8 bit PICs are pretty bad, i have a box full of them, the MPlab was closed, windows only. 8bit PICs have weird memory model. Post about your projects you do with the other platforms. That’s the way to make other people consider choises. For some people arduinos are fine for the rest of their lives. Someone might want to get into more advanced embedded stuff. That’s fine. And who knows, arduino can still evolve into a more advanced platform.

    1. About those 8-bit PICs, sure there are cons with them, but there are pros too. And someone has used PICs for a long time, it’s not easy to change the platform, and just abandon everything just because someone says it sucks. There’s always the learning curve and all the time invested in getting the libraries, making code, HW you’ve bought and sometimes supporting what you’ve done before. Rarely there is a product, that wins in every category.

    2. I agree. I started using Arduino out of curiosity, because it is easy step in and it does its job. I am sure there are other platforms that do the same or better and I might try them just out of curiosity.
      I see people do great things with PIC’s and I see awesome stuff with other platforms, but fact is that most of that you could probably do on any of the platforms: Arduino, Pic, Launchpad, Beagle Bone, whatever.
      I see no need to suddenly start using say Beagle Bone, just as much as someone who is happy with PIC may see no reason to start using an Arduino.
      I didnt do numbers on it, but dare say that a lot more people -even including ‘completely atechnical girls’ who just want a costume to light up- are using it. Does that make it the best platform? who cares, it makes it the best platform for them for that specific project. And if someone runs into limitations that even a Due cant fix… well then maybe he/she will see a need for another platform. But fact is that for most people, even the techies Arduino suits them fine

  28. Arduino could be considered a religion, but I think for most, it’s an easy, well defined way to build a project, even though there are better, cheaper alternatives for software development.

    But “Arduino” can mean:

    1. The easy to install IDE.
    2. The library of routines that interface with hardware
    3. The standardized connector and collection of shields available

    It seems to me from what I’ve seen in various projects, the library of hardware interfaces could be one of the most important things. You can buy an STM Discovery board (or similar from NXP, Atmel, TI etc.) that has much better IDEs with built-in JTAG debugging and much more capable processor, but then you have to choose from 1 of 3 licensed software IDEs with either limits on project size or else try to use Eclipse/GCC, which has a complex installation process.

    But you don’t have the nice libraries for Arduino. Each vendor has their own, and some are overly complex, in my opinion. MBED seems to be a solution, but there aren’t yet good linkages between the online development and local IDE-debuggers. MBED works well (no install, online IDE) and has a way for the community to build hardware-software libraries, but mostly relies on special firmware for downloading code. In theory, MBED could be used with gdb (with/without IDE) and OpenOCD, but so far the interface doesn’t seem to be there.

  29. I am currently using Arduino in a commercial OOP+MVC architected project. So far the development process has been brilliant. I’m using Arduino-Makefile (, which lets me develop in a full-featured IDE–either CodeLite, CodeBlocks, or NetBeans depending on how I’m feeling. Development has been fast and smooth (just be sure you adhere to the licensing terms or third party libraries), and I haven’t encountered any meaningful performance limitations. I am a designer and an EE with a background in S/W development. While I’m not suggesting Arduino is a uC panacea, for this job Arduino is the proving to be the right tool.

  30. You should also note, the AVR chips are superior to the PIC chips at the same price points (even at same MHz, the AVR chips have better pipelining and, can execute between 1 to 4 instructions per clock cycle [depending on the instruction, and branching] whereas the PICs can only execute 1 per clock). Not to mention none of the weird memory mapping / hardware stack issues of the low-end PICs.

    I was using the AVR chips directly in a lot of hobby projects (VUSB is awesome btw) — because they’re mostly under $5 or $10, and if you have a breadboard and some components, it’s not that hard really…

    When I realized that most Arduino boards were just AVR prototyping boards, and that I didn’t have to use the Arduino software to work with them (and even better when I noticed the ICSP headers right there on the board), that was a pretty big wake up call for me. Arduino is awesome. :-)

  31. The criticism on Arduino’s is in fact often elitism. Apparently people seem to look down on things that are simple. Well, then stop using C++ as well and only use assembler if you think ‘complicated is better’
    Fact is that not everybody using an Arduino is interested in becoming a technician. Lots of people who would normally have never thought of using a microcontroller are now using it, simply to ‘make’ things.
    and at the same time the Arduino allows the ones that want to make really complicated things and even if it is not ‘Pure C++’ who cares. As if C++ is the holy grail of programming. I could just as well say ‘Real men program in assembler, C++ is for newbies’
    The Arduino has opened the world of microcontrollers to a completely new group of people and that is a good thing.
    I bet that when the first radios came that you could just tune in with a knob, the people that still were using Crystal receivers in which you had to poke a crystal with a piece of wire were complaining too that those new radios were for people that didnt know anything about electronics.
    I have been using various microcontrollers, build 8051 boards, programming them with assembler 30 years ago already and I welcome the Arduino. It is great and it is fantastic.
    I am suresome of the “newbies” that start using an Arduino because it is “simple and easy” develop an interest in technology they might not have gotten otherwise: writing more complicated programs, writing libraries, finding quicker ways to do something, add hardware, build own ‘arduino’, start using attiny’s. It is a fantastic development and i for one embrace it

  32. Wow, you guys are a bunch of clowns.

    I have degrees in both EE and CS- I’ve been bit-banging shit since 1978, and I use Arduinos (well, knockoffs) all the time. Why? For $3 I can put intelligence in a device quickly and easily. For another $7 I can have an Ethernet interface.

    There’s an economy of scale that makes using Arduinos impractical after a certain number of units in your production run, but for rapid prototyping it’s a great solution. Similarly, MS Windows totally sucks, but sometimes it’s the right tool for the job. One of the the marks of a professional is being able to suspend personal biases and get the problem solved asap.

    As far as the breakpoint capability, well, if you wrote code properly, you wouldn’t need it. :) j/k, there are ways around it.

    1. seriously, debuggers are overrated… it’s a great concept, don’t get me wrong… but… I mean, doesn’t it basically only work with simple programs, anyhow…? Every time I try to run one, I get stuck in some portion of code that waits for a timer-value or other peripheral, or interrupt, or response from a context-switch which just doesn’t happen when the processor’s halted. If you can’t do any of that stuff, then why do you need a debugger in the first place…? To figure out that you typecasted something wrong? Just look at the code and use a methodical method of improving it.

  33. Apart from just prototyping small stuff(for which arduino is great), I use arduino core libraries(and 3rd party ones) to fast-track many things. I don’t use the bootloader or the “IDE” because it doesn’t fit into how I work. I also use debugging with avr dragon/avarice on linux, with full breakpoint/source display etc, have been using a sudar/Arduino-makefile as the build system, and also mix in C code alongside C++(which for whatever reason Arduino makes a point not to call C++). All in all arduino has been useful as a developer now and as a beginner when I was starting out.

Leave a Reply to Peter Burkimsher Cancel reply
