9
\$\begingroup\$

Let's assume that the cost of goods is an insignificant factor. If a company lacks a team to produce a custom board for a particular product, but has success with an off-the shelf development platform like Arduino / Netduino / mbed, what sorts of things should be considered before going forward?

If I'm not mistaken, Arduino was originally targeting university students because of its low price and ease of use. It naturally became a popular platform for artists and makers. I see the Netduino as a logical extension of Arduino -- it allows people to use a robust and rich IDE (Visual Studio 2010) and get things done quickly via the .NET Micro Framework. mbed is another nice hobbyist platform because of its ease of use, free tools (online compiler), and hardware peripherals.

So my question is, why shouldn't companies adopt these development platforms for production usage? In other words, is it a bad idea to just buy several boards from Sparkfun, program each of them with the code, and then deploy the product to customers?

I'm specifically interested in Netduino, but arguments for / against Arduino and mbed are also welcome. On the flip side, would you, or have you done this before?

I personally look at the Netduino development as a "core module" that other processor manufacturers sell for product integrations, but maybe I'm missing something important here.

\$\endgroup\$

closed as primarily opinion-based by Nick Alexeev, PeterJ, Dave Tweed, Samuel, alexan_e Feb 6 '14 at 8:07

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise. If this question can be reworded to fit the rules in the help center, please edit the question.

5
\$\begingroup\$

Some of the things you might look at when sourcing a controller module are issue such as security of supply over time, any licensing issues, any inefficiencies in firmware loading process for production, any code security issues, and any manufacturing quality or regulatory compliance concerns. Some of those are going to be more of a concern for a proprietary module than a relatively open one you could have someone else make an equivalent to or eventually merge with other functionality in your product.

\$\endgroup\$
  • \$\begingroup\$ Supply could be an issue, but at least the designs for *duino are open source. \$\endgroup\$ – Dave Feb 7 '11 at 15:45
  • \$\begingroup\$ @Dave - You missed the point. Chris (I think) was talking mostly about problems with .NET, not with the hardware. \$\endgroup\$ – Kevin Vermeer Feb 7 '11 at 18:55
  • 1
    \$\begingroup\$ @reemrevnivek - hmm... sure sounded like hardware issues to me. Why would supply issues, firmware loading, and mfg. quality have anything to do with .NET? \$\endgroup\$ – Dave Feb 7 '11 at 20:00
  • 1
    \$\begingroup\$ You may or may not be able to get a license to load a particular runtime on an alternate sourced board. The various issues I was suggesting are an assortment not necessarily related to each other. \$\endgroup\$ – Chris Stratton Feb 7 '11 at 20:09
12
\$\begingroup\$

Yikes! Either you're thoroughly confused, or your idea of production is different from mine. I consider production to mean selling a product to the general public in quantities of thousands or more, then supporting and updating the design. Products which don't go to the general public are either internal or contract work, and products which sell in smaller quantities are special-purpose or otherwise different. 'Several boards from Sparkfun' wouldn't fulfill a production need.

First, the cost of goods is always a significant factor. Just how significant it is may differ from product to product, and it may be less significant if the particular item is only a small component of a larger system which has been optimized for cost. However, in any environment where you're in competition with other producers (which you must be because if you're in government or have a monopoly you wouldn't be asking this question), cost will be a factor. The $35 for the Netduino (in cost alone) could usually be reduced to $10 or less for most applications with a custom design. If you are convinced that the cost doesn't matter, there are further reasons against buying such a design.

Yes, all three boards were designed for students, designers, and hobbyists. They are designed to be reliable enough for a development kit which sits on a desk. That student should know a few things about safe handling procedures which the general population does not know or practice. Issues such as ESD, long-term power dissipation, and component derating were likely demoted below things which are less important for production like solderability and simplicity.

Your affinity for IDEs and prepackaged solutions is frightening. In my opinion, you place way too much trust in your tool providers. If the boards become more expensive, if the license terms are changed, if the server goes down, the software is declared obsolete, the board manufacturer goes out of business (etc. etc. etc...), your business is hosed. Also, you lack an understanding of what's going on behind the scenes. If something doesn't work the way the documentation says it should what is your plan? Your idea to buy a few Arduinos, program them, and deploy the product, for example, lacks any plan for code protection. Someone else could copy your code out of the microcontroller, duplicate the relevant parts of the design for a third the price, and outsell you.
Relying on an IDE and language for the stuff you don't understand is a recipe for disaster.

Using a development kit in your design will make your product overpriced, fragile, bulky, power-hungry, and inefficient. It will also be hard to debug, a pain to support, and you'll be at the mercy of your suppliers. It will make you look incompetent.

However, all is not lost. If you implement your design on a development board, it will be straightforward to have someone (either on or off your team) customize it to remove these deficiencies. If you lack a team, you should hire one, bring in a contractor, or have it done by a design firm.

\$\endgroup\$
  • 1
    \$\begingroup\$ Production does not have to mean thousands. There's a lot of engineering in highly specialized equipment that may sell in orders of a few dozen to a few hundred pieces - and obviously it sells for rather high prices or no one would make money doing it. Such industries are focused on meeting the need rapidly, not on spending months getting every last dollar out of the BOM. \$\endgroup\$ – Chris Stratton Feb 7 '11 at 19:57
  • 2
    \$\begingroup\$ @reemrevnivek - I think you and I are working in completely different worlds. When I refer to a production part, it's anything that gets released to a customer, and it can be in quantities from 1 to 20, not tens of thousands, thousands, or even hundreds. I could care less if I could reduce a part from $50 to 5 dollars, if that means I'll have to spend an extra 3 months on development. I also don't mind if someone copies the code. \$\endgroup\$ – Dave Feb 7 '11 at 20:06
  • 1
    \$\begingroup\$ You've brought up really good points, though, and I value your input. I think your answer was a little extreme and you are clearly opinionated on this subject, but I can distill the key points from it. \$\endgroup\$ – Dave Feb 7 '11 at 20:08
  • 2
    \$\begingroup\$ @Dave - Sorry, I consciously tried to make it not opinionated or extreme. This is what it looks like after a few re-readings and edits :P. However, I stand by my statement that the word 'production' means (in every context I've operated in, which is mainly as an automotive OEM supplier) thousands of parts. Can you imagine opening your hood and seeing an Arduino hacked into your fan controller? No, and for good reason. I tried to give a few of those reasons. \$\endgroup\$ – Kevin Vermeer Feb 7 '11 at 20:50
  • 1
    \$\begingroup\$ @reemrevinek - haha! no offense taken. I was hoping to get a lot of viewpoints with this question. My environment is totally different. We sell a few customized products that are quite expensive, so a part like an embedded board is okay if it costs more, and offsets the development time. I'm using the Netduino right now only for prototyping concepts, but then it occurred to me that we could probably put it into the product, since it's just used with a display controller anyway. I certainly agree that it is better / more professional to have a custom board, but wanted to hear opinions. \$\endgroup\$ – Dave Feb 7 '11 at 20:53
4
\$\begingroup\$

I have use an Arduino board in a product (not large scale production) and I wouldn't do it again. The Arduino boards are geared towards a very closed ecosystem (in the non open-source software meaning of the word). For instance, if you 'step out' of the Arduino ecosystem by needing to use a pin that isn't brought out to a header on the development board, you immediately lose all the benefits of the Arduino. You have to modify the board to bring the pin to an existing header or add a new header somehow. This likely means you won't be able to use any existing shields or possibly even the software libraries for the Arduino. That's most of the benefit of the board gone. I have had to do this with an Arduino Mega.

Also, the boards are huge and not easy to integrate with other PCBs I made the main board for my application equivalent to a shield for the Arduino Mega that had mounting holes for the enclosure I chose. So I just plugged the Arduino Mega into the headers I put on my board. However, this was a lot of up and down size to accommodate, and there was a lot of wasted space due to the size of the development board. I didn't need half of what was on there and it only took up room. This required me to have a larger PCB and enclosure than I otherwise would have needed. That's wasted money.

\$\endgroup\$
  • 1
    \$\begingroup\$ The arduino (and even arm-powered) designs are simple enough that if you are going to be making a PCB suitable for digital logic to accessorize them, you might as well just include the processor too. They'd be more tempting if you were not going to be making a PCB at all, or were doing it single sided or in a special analog or RF technology where you didn't want digital parts on that board, and having to do a controller board too would be more expense than buying (and even reworking) them. \$\endgroup\$ – Chris Stratton Feb 7 '11 at 18:45
  • 1
    \$\begingroup\$ Chris-definitely. Everyone should know that if you're making a PCB yourself there's little point in adding an Arduino board as opposed to just recreating one on your PCB. \$\endgroup\$ – AngryEE Feb 7 '11 at 20:35
  • \$\begingroup\$ If Arduino environment becomes a limiting factor, you can always use any other AVR compiler like GCC, BASCOM, AvrCo and produce firmware that will live on the same Arduino board... \$\endgroup\$ – avra Feb 10 '11 at 9:15
4
\$\begingroup\$

Arduinos &co are prototyping and evaluation platforms. As such, they are simply not economically viable as a basis for even relatively small production runs. They're great for education and mocking up ideas, but a product would sink very quickly if it had to carry the cost of a ready-made sub-assembly that was not optimal in its final use.

It would be far better to create a new board including required elements of the 'duino and any ancillary circuitry than to have the cost of two boards and the risk of failing connections.

With regard to Visual Studio and anything .net, I wouldn't touch them with someone else's. Go for something platform and manufacturer agnostic - kind of in the spirit of the Arduino project itself.

\$\endgroup\$
  • 1
    \$\begingroup\$ I still believe it all depends on the cost of your product. Let's say that it's possible to create something really compelling with the *duino, and it's a small part of a 1M USD project, and you're only ever going to sell 3 of them. Why wouldn't that be economically viable? Would you prefer to spend thousands on development for something that's going to be used twice? \$\endgroup\$ – Dave Feb 9 '11 at 23:11
  • 2
    \$\begingroup\$ Regarding the .NET comment, I frequently run into people that don't like to use Visual Studio and / or .NET just because. I personally don't get it. Visual Studio is by far one of the best IDEs I have ever used. I am admittedly biased towards Microsoft tools because they let me get my work done quickly, and 99% of the time, they just work. Although I should really learn to use development boards with an ICE, I definitely appreciate the ease of using a familiar environment that lets me set breakpoints during debugging. AFAIK you can't do that with Arduino. \$\endgroup\$ – Dave Feb 9 '11 at 23:15
  • \$\begingroup\$ WRT your first comment, I did say relatively small runs. I would see a run of three large budget developments as ongoing prototypes. I imagine the client would, too. In that situation, I would happily use an Arduino. \$\endgroup\$ – Leo Feb 10 '11 at 9:06
  • 1
    \$\begingroup\$ The MS/.net thing is based on personal experience. Over the last twenty or so years I've used almost every platform out there. The biggest headaches have invariably come from MS products. MS seem to assume that their way is the only proper way. Currently I'm using OS X, Ubuntu and Windows 7, all in a development environment. Guess which one I have to reboot (at all)? \$\endgroup\$ – Leo Feb 10 '11 at 9:11
  • 4
    \$\begingroup\$ The ATMegas used on Arduino support debugging via debugwire- not sure if the Arduino reset pin hardware is compatible but if not wouldn't take much to hack as it's only one pin. Another potentially major issue about using other people's boards is if you care about stuff lie EMC, FCC cretification etc. \$\endgroup\$ – mikeselectricstuff Feb 10 '11 at 15:01
3
\$\begingroup\$

Generally speaking there is nothing wrong with using off-the-shelve products. We all do this at some level, I guess the Arduino-haters don't design their own chips, even tough at some higher volume level that would make economic sense.

It always boils down to cost, schedule and quality (and maybe long-term availability too). If an Arduino meets these criteria better than a custom board, the choice is a no-brainer.

The difficult part is to get the right figures, especially for your volume. But using the correct figures and little math will give you the break-even volume for the choice between uising let's say the Arduino versus a custom board. If that is way beyond what you expect, or way below, the choice is easy. So forget all advices that say either "by all means use an Arduino" or "always go for a custom board", they are both locked into a mindset that belongs to a specific volume level. Do your own calculations.

Note that I have no specific knowledge of the Arduino. You will have to decide for yourself whether it meets for instance your quality requirements.

\$\endgroup\$
2
\$\begingroup\$

Custom made boards are nice if you have a budget for this and production big enough to justify the work. Otherwise you stick with products of the shelf, like Arduino, Netduino, Fez Domino, and SBC boards (like in PC104 and various ITX formats). Making custom AVR/Arduino board is not too complex, but heavy modifications to Netduino or even designing (and later supporting) some linux board (like Gumstix) need a specialist(s) and cost tens of thousands of dollars and more. If you want to have most of the hard work done by someone else, and you want to customize just some parts of it, then module is the magic word for you.

\$\endgroup\$
  • \$\begingroup\$ I definitely agree with you, but at some point you still need a PCB. I have enough skill to make one for *duino and others to create a simple PCB for breaking out signals and power, so at least that's still pretty cheap. \$\endgroup\$ – Dave Feb 10 '11 at 14:35
  • \$\begingroup\$ It is cheap if you don't need thousands, and if you need more power then modules like the one from above link is nice, too. Beware that you will probably have to deal your self with brown out detection, power disturbance if writing to eeprom, reliable power supply, and many other things that depend on your specific application. \$\endgroup\$ – avra Feb 11 '11 at 11:34

Not the answer you're looking for? Browse other questions tagged or ask your own question.