Is embedded on the cheap possible?

I find that a lot of posts on this embedded group revolve around
finding cheap or free tools to build embedded devices. However, in my
experience, I've found that productizing real embedded products is
anything but cheap. It takes many thousands of dollars to build good
hardware, program that hardware, and debug it. You need all sorts of
gear from power supplies and logic analyzers to probes and pricey
software.

My question is, has anyone successfully deployed an embedded system
which was built cheaply? Is it possible to take GCC, linux, and a
hundred dollar wiggler to build and deploy an embedded system?

Thanks!

On Sat, 28 Jul 2007 01:50:52 -0000, speedplane
<michael.sander@gmail.com> wrote in comp.arch.embedded:

> I find that a lot of posts on this embedded group revolve around
> finding cheap or free tools to build embedded devices. However, in my
> experience, I've found that productizing real embedded products is

Developers don't "productize".  Marketing dweebs do.

> anything but cheap. It takes many thousands of dollars to build good
> hardware, program that hardware, and debug it. You need all sorts of
> gear from power supplies and logic analyzers to probes and pricey
> software.
> 
> My question is, has anyone successfully deployed an embedded system
> which was built cheaply? Is it possible to take GCC, linux, and a
> hundred dollar wiggler to build and deploy an embedded system?
> 
> Thanks!

Yes, it is still possible to develop cheap embedded systems, although
I don't know that gcc and Linux is necessarily the cheap route.

It is even possible to be financially successful selling them,
generally in limited volumes for specialized niche markets.

But it is by no means easy, and the methods don't scale to volume
products, or anything sold to the general public where all sorts of
legal issues are involved.

-- 
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

speedplane wrote:

> I find that a lot of posts on this embedded group revolve around
> finding cheap or free tools to build embedded devices. However, in my
> experience, I've found that productizing real embedded products is
> anything but cheap. It takes many thousands of dollars to build good
> hardware, program that hardware, and debug it. You need all sorts of
> gear from power supplies and logic analyzers to probes and pricey
> software.
> 
> My question is, has anyone successfully deployed an embedded system
> which was built cheaply? Is it possible to take GCC, linux, and a
> hundred dollar wiggler to build and deploy an embedded system?

It will rather depend on your definition of cheap. Some embedded systems
developed and deployed and costing a couple of million of whatever currency
units may be considered cheap in some quarters. On the other hand we do
have some people on here who can fully develop embedded systems products
that are churned out in their millions and cost less than $5 per pop. It
really is a question of how you view the end result.

The reason why we have a number of people on here who are looking for
innexpensive development tools and devices is because they have specific
aims in mind and it may be one or more of the following:-

    * They are a hobbyist with little money to spend on their hobby. We
      do still see such people who just like to play with this stuff.

    * They need a part which will meet a functional requirement as part 
      of a product but needs to also meet a cost per unit limit, especially
      as they are producing so many units.

    * Their development section is not very well funded and they always 
      have to churn out a quality product at minimum cost.

    * They are in the education sector.

    * They are in a Research Establishment where the embedded systems
      development is not a major part of their function but they need 
      to do it to get what they want.

Of course, some of us are still using tools that we have built up over years
of practice and continue to find useful hence their cost has been amortised
over the years and it costs us very little to continue to do new
developments.

-- 
********************************************************************
Paul E. Bennett ....................<email://peb@amleth.demon.co.uk>
Forth based HIDECS Consultancy .....<http://www.amleth.demon.co.uk/>
Mob: +44 (0)7811-639972
Tel: +44 (0)1235-811095
Going Forth Safely ..... EBA. www.electric-boat-association.org.uk..
********************************************************************

Paul E. Bennett wrote:
>
>speedplane wrote:
>
>> I find that a lot of posts on this embedded group revolve around
>> finding cheap or free tools to build embedded devices. However, in my
>> experience, I've found that productizing real embedded products is
>> anything but cheap. It takes many thousands of dollars to build good
>> hardware, program that hardware, and debug it. You need all sorts of
>> gear from power supplies and logic analyzers to probes and pricey
>> software.
>> 
>> My question is, has anyone successfully deployed an embedded system
>> which was built cheaply? Is it possible to take GCC, linux, and a
>> hundred dollar wiggler to build and deploy an embedded system?
>
>It will rather depend on your definition of cheap. Some embedded systems
>developed and deployed and costing a couple of million of whatever currency
>units may be considered cheap in some quarters. On the other hand we do
>have some people on here who can fully develop embedded systems products
>that are churned out in their millions and cost less than $5 per pop.

That would be me.  :)

I have been in charge of developing products that ended up being 
produced at a rate of 100,000 units per hour at a cost of...that's 
a secret I can't reveal, but the electronics had a total cost of 
well under a dollar.  We didn't use any expensive test equipment 
or software.  Here is *everything* we used to develop the software:

[1] One good programmer who "gets" embedded software development.

[2] An assembler that runs on DOS or Linux (BASH, no GUI) that he 
    wrote himself.  Any number of free assemblers would have
    worked just as well.

[3] A prototype of the hardware, hand-built on perfboard and powered
    by a $5 "wall wart" power supply (we could have used batteries).

[4] An old Tektronix 465B Oscilloscope.

[5] An inexpensive EPROM burner and eraser.

[6] The FORTH programming language (custom variant written from 
    scratch for the processor we used).  Or, in some cases, 
    straight assembly language.

That's it.

-- 
Guy Macon
<http://www.guymacon.com/>

Jack Klein wrote:
> On Sat, 28 Jul 2007 01:50:52 -0000, speedplane
> <michael.sander@gmail.com> wrote in comp.arch.embedded:
> 
>> I find that a lot of posts on this embedded group revolve around
>> finding cheap or free tools to build embedded devices. However, in my
>> experience, I've found that productizing real embedded products is
> 
> Developers don't "productize".  Marketing dweebs do.
> 
>> anything but cheap. It takes many thousands of dollars to build good
>> hardware, program that hardware, and debug it. You need all sorts of
>> gear from power supplies and logic analyzers to probes and pricey
>> software.
>>
>> My question is, has anyone successfully deployed an embedded system
>> which was built cheaply? Is it possible to take GCC, linux, and a
>> hundred dollar wiggler to build and deploy an embedded system?
>>
>> Thanks!
> 
> Yes, it is still possible to develop cheap embedded systems, although
> I don't know that gcc and Linux is necessarily the cheap route.
> 
> It is even possible to be financially successful selling them,
> generally in limited volumes for specialized niche markets.
> 
> But it is by no means easy, and the methods don't scale to volume
> products, or anything sold to the general public where all sorts of
> legal issues are involved.
> 
gcc is a fine compiler, and I've used it in cases where a vendor has 
made it part of their tool set (WindRiver and Analog Devices 28xx).  I 
would expect that Linux is as good as Windows CE.

My take on this is that tools and operating systems _always_ have bugs, 
they _always_ have a learning curve, and they _never_ leave one 100% 
satisfied.  The grief _always_ costs more in man-hours than the product 
did in dollars.  Having to pay for a product and track licenses under 
those circumstances just adds insult to injury, so I look for free tools 
when I can...

-- 

Tim Wescott
Wescott Design Services
http://www.wescottdesign.com

Do you need to implement control loops in software?
"Applied Control Theory for Embedded Systems" gives you just what it says.
See details at http://www.wescottdesign.com/actfes/actfes.html

On Jul 27, 7:38 pm, Jack Klein <jackkl...@spamcop.net> wrote:
> On Sat, 28 Jul 2007 01:50:52 -0000, speedplane
> <michael.san...@gmail.com> wrote in comp.arch.embedded:
>
> > I find that a lot of posts on this embedded group revolve around
> > finding cheap or free tools to build embedded devices. However, in my
> > experience, I've found that productizing real embedded products is
>
> Developers don't "productize".  Marketing dweebs do.
>
> > anything but cheap. It takes many thousands of dollars to build good
> > hardware, program that hardware, and debug it. You need all sorts of
> > gear from power supplies and logic analyzers to probes and pricey
> > software.
>
> > My question is, has anyone successfully deployed an embedded system
> > which was built cheaply? Is it possible to take GCC, linux, and a
> > hundred dollar wiggler to build and deploy an embedded system?
>
> > Thanks!
>
> Yes, it is still possible to develop cheap embedded systems, although
> I don't know that gcc and Linux is necessarily the cheap route.
>
> It is even possible to be financially successful selling them,
> generally in limited volumes for specialized niche markets.
>
> But it is by no means easy, and the methods don't scale to volume
> products, or anything sold to the general public where all sorts of
> legal issues are involved.
>
> --
> Jack Klein
> Home:http://JK-Technology.Com
> FAQs for
> comp.lang.chttp://c-faq.com/
> comp.lang.c++http://www.parashift.com/c++-faq-lite/
> alt.comp.lang.learn.c-c++http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

When I say productize, I really mean removing all of the bugs.

In article <hYOdna_Ia5fVNjbbnZ2dnUVZ_tajnZ2d@web-ster.com>, Tim Wescott 
<tim@seemywebsite.com> writes
>Jack Klein wrote:
>> On Sat, 28 Jul 2007 01:50:52 -0000, speedplane
>> <michael.sander@gmail.com> wrote in comp.arch.embedded:
>>
>>> I find that a lot of posts on this embedded group revolve around
>>> finding cheap or free tools to build embedded devices. However, in my
>>> experience, I've found that productizing real embedded products is
>>  Developers don't "productize".  Marketing dweebs do.
>>
>>> anything but cheap. It takes many thousands of dollars to build good
>>> hardware, program that hardware, and debug it. You need all sorts of
>>> gear from power supplies and logic analyzers to probes and pricey
>>> software.
>>>
>>> My question is, has anyone successfully deployed an embedded system
>>> which was built cheaply? Is it possible to take GCC, linux, and a
>>> hundred dollar wiggler to build and deploy an embedded system?
>>>
>>> Thanks!
>>  Yes, it is still possible to develop cheap embedded systems, 
>>although
>> I don't know that gcc and Linux is necessarily the cheap route.
>>  It is even possible to be financially successful selling them,
>> generally in limited volumes for specialized niche markets.
>>  But it is by no means easy, and the methods don't scale to volume
>> products, or anything sold to the general public where all sorts of
>> legal issues are involved.
>>
>gcc is a fine compiler,

IT is using old technology. It can get performance near the 32 bit 
compilers but is not as competitive at 16 bits and is not available fro 
many 8 bits

> and I've used it in cases where a vendor has made it part of their 
>tool set (WindRiver and Analog Devices 28xx).  I would expect that 
>Linux is as good as Windows CE.

??? Most embedded systems don't use an OS on the target let along large 
complex ones like  Linux or WINCE.  (Though I would suggest that Linux 
is a better bet than WINCE)

>My take on this is that tools and operating systems _always_ have bugs,

ALL software will have bugs.

> they _always_ have a learning curve, and they _never_ leave one 100% 
>satisfied.

Not always true

>The grief _always_ costs more in man-hours than the product

Not always true. Though this is true of FOSS as you don't pay anything 
for it usually...

> did in dollars.  Having to pay for a product and track licenses under 
>those circumstances just adds insult to injury, so I look for free 
>tools when I can...

Most free tools have licences (and bugs) too.  Also the support costs 
money.


-- 
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills  Staffs  England     /\/\/\/\/
/\/\/ chris@phaedsys.org      www.phaedsys.org \/\/\
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

On Jul 28, 1:53 pm, Tim Wescott <t...@seemywebsite.com> wrote:
> Jack Klein wrote:
> > On Sat, 28 Jul 2007 01:50:52 -0000, speedplane
> > <michael.san...@gmail.com> wrote in comp.arch.embedded:
>
> >> I find that a lot of posts on this embedded group revolve around
> >> finding cheap or free tools to build embedded devices. However, in my
> >> experience, I've found that productizing real embedded products is
>
> > Developers don't "productize".  Marketing dweebs do.
>
> >> anything but cheap. It takes many thousands of dollars to build good
> >> hardware, program that hardware, and debug it. You need all sorts of
> >> gear from power supplies and logic analyzers to probes and pricey
> >> software.
>
> >> My question is, has anyone successfully deployed an embedded system
> >> which was built cheaply? Is it possible to take GCC, linux, and a
> >> hundred dollar wiggler to build and deploy an embedded system?
>
> >> Thanks!
>
> > Yes, it is still possible to develop cheap embedded systems, although
> > I don't know that gcc and Linux is necessarily the cheap route.
>
> > It is even possible to be financially successful selling them,
> > generally in limited volumes for specialized niche markets.
>
> > But it is by no means easy, and the methods don't scale to volume
> > products, or anything sold to the general public where all sorts of
> > legal issues are involved.
>
> gcc is a fine compiler, and I've used it in cases where a vendor has
> made it part of their tool set (WindRiver and Analog Devices 28xx).  I
> would expect that Linux is as good as Windows CE.
>
> My take on this is that tools and operating systems _always_ have bugs,
> they _always_ have a learning curve, and they _never_ leave one 100%
> satisfied.  The grief _always_ costs more in man-hours than the product
> did in dollars.  Having to pay for a product and track licenses under
> those circumstances just adds insult to injury, so I look for free tools
> when I can...

> The grief _always_ costs more in man-hours than the product did in dollars.
So in that case, shouldn't one try to find the best tools regardless
of price?
It seems that embedded on the cheap may be theoretically possible, but
good (expensive) tools, and a good (expensive) OS, are probably the
way to go if you can afford it.

In article <1185742247.897505.156890@g12g2000prg.googlegroups.com>, 
speedplane <michael.sander@gmail.com> writes
>> The grief _always_ costs more in man-hours than the product did in dollars.
>So in that case, shouldn't one try to find the best tools regardless
>of price?
>It seems that embedded on the cheap may be theoretically possible, but
>good (expensive) tools, and a good (expensive) OS, are probably the
>way to go if you can afford it.

I have several customers who buy commercial tools, rtos, comms tacks etc 
without a second thought. When I asked why they said it is cost 
effective. The tools and SW work saving them much time and grief which 
far outweighs their cost.

I also have one customer in particular who bitterly regrets going the 
FOSS rout as it has cost them so much in time (which costs a lot in 
salaries) that the are seriously late to market.

Mind you I do also know a lot of people using free tools and SW (some 
FOSS and but most that isn't) who find it is OK for their needs.  Though 
in one case a free tool (not FOSS) actually caused a serious problem 
that cost a lot of time and money.

As John Ruskin's  oft quoted saying states (paraphrased) nothing in life 
or business  is free. Somewhere some one ALWAYS has to pay one way or 
another.

-- 
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills  Staffs  England     /\/\/\/\/
/\/\/ chris@phaedsys.org      www.phaedsys.org \/\/\
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

On Jul 27, 8:50 pm, speedplane <michael.san...@gmail.com> wrote:
> I find that a lot of posts on this embedded group revolve around
> finding cheap or free tools to build embedded devices. However, in my
> experience, I've found that productizing real embedded products is
> anything but cheap. It takes many thousands of dollars to build good
> hardware, program that hardware, and debug it. You need all sorts of
> gear from power supplies and logic analyzers to probes and pricey
> software.
>
> My question is, has anyone successfully deployed an embedded system
> which was built cheaply? Is it possible to take GCC, linux, and a
> hundred dollar wiggler to build and deploy an embedded system?

Not using GCC, but using the no-cost-license version of codewarrior
for HCS12 and a hundred dollar BMD pod, yes.  I saved some time by
testing the code on a development board, but could have waited for the
PCB, as the recommended circuit used there worked the first time.

I have all sorts of test equipment, but generally the first - and
quite often only - hardware debugging tool I reach for is a loose
LED.  It's nice to have a scope of some sort, but you can almost
always work around it if necessary.  Hooking up a logic analyzer is
such a pain that while there's one sitting next to my desk, it hardly
ever gets used.  And even when used, it generally hasn't helped solve
the (software) problem.  If the issues were with digital interfaces
between state-machine type devices that might be more helpful, but
software is usually ammenable to debugging by slowing things down and
inserting debug output, judicious use of breakpoints, etc.