ARM IDE

Greetings all,

I posted a while back concerning help choosing an MCU/DSP and I greatly
appreciated the input you guys gave me so I'm back with more questions.

I've decided to go the ARM9 way.  More specifically, I went with ST's STR9
series since it had the correct processing and ADC sampling rates.   

Anyhow, I ordered a kit from IAR to test things out and so far so good. 
My question is should I stick with IAR or go with something like EMBEST
(they look like they have a good prices for their dev kits) or GNU.

Looks like GCC is pretty well regarded but seems like it is more complex
to install / use than other solutions.

On Wed, 12 Nov 2008 12:35:00 -0600, "flash011" <sylvainlarive@gmail.com>
wrote:

>Greetings all,
>
>I posted a while back concerning help choosing an MCU/DSP and I greatly
>appreciated the input you guys gave me so I'm back with more questions.
>
>I've decided to go the ARM9 way.  More specifically, I went with ST's STR9
>series since it had the correct processing and ADC sampling rates.   
>
>Anyhow, I ordered a kit from IAR to test things out and so far so good. 
>My question is should I stick with IAR or go with something like EMBEST
>(they look like they have a good prices for their dev kits) or GNU.
>
>Looks like GCC is pretty well regarded but seems like it is more complex
>to install / use than other solutions.

Take a look at Rowley's CrossWorks. Not terribly expensive; it uses gcc
but its own libraries (no L/GPL issues).

IAR is great but the costs can add up. Used it years ago on an MSP430
project; bug fixes weren't free and the annual maintenance fee was
pricey.

-- 
Rich Webb     Norfolk, VA

In message <oa9mh4dr7u7ebh53cer5itfsrdtrad03i9@4ax.com>, Rich Webb 
<bbew.ar@mapson.nozirev.ten> writes
>On Wed, 12 Nov 2008 12:35:00 -0600, "flash011" <sylvainlarive@gmail.com>
>wrote:
>
>>Greetings all,
>>
>>I posted a while back concerning help choosing an MCU/DSP and I greatly
>>appreciated the input you guys gave me so I'm back with more questions.
>>
>>I've decided to go the ARM9 way.  More specifically, I went with ST's STR9
>>series since it had the correct processing and ADC sampling rates.
>>
>>Anyhow, I ordered a kit from IAR to test things out and so far so good.
>>My question is should I stick with IAR or go with something like EMBEST
>>(they look like they have a good prices for their dev kits) or GNU.
>>
>>Looks like GCC is pretty well regarded but seems like it is more complex
>>to install / use than other solutions.

GCC is well regarded by some but not by others. The people who do our 
compiler validation would not give it house room. But that is not the 
specific GCC that Rowley use. Not sure how theirs is different.


>Take a look at Rowley's CrossWorks. Not terribly expensive; it uses gcc
>but its own libraries (no L/GPL issues).

Rowley's prices have gone up somewhat of late. From their web site:-

Shared-Developer Commercial License with Sentinel Dongle. 1,555.87 GBP

Compared to IAR at 1540 GBP

That makes Rowley 15 GBP MORE EXPENSIVE than IAR.

And that is for a GCC compiler from Rowley.

The IAR compiler uses the EDG front end and the Dinkumware libraries 
both of which are very highly regarded and fully tested by both 
Perennial and Plum Hall.   IAR compilers have been validated for Safety 
Critical use at SIL3.  You can't say that about GCC

BTW IAR have over 30 dev kits and many many examples and BSP's  they 
also support a very wide range of debuggers and RTOS awareness in the 
debugger.

>IAR is great but the costs can add up. Used it years ago on an MSP430
>project;

Check the pricing.... from what I have seen the new Rowley pricing is 
not far off that of IAR  if not the same these days. From the Rowley web 
site

Shared-Developer Commercial License with Sentinel Dongle. &#4294967295;1,521.29

The IAR system is 1400 GBP for the compiler and IDE or 1800 GBP with the 
debugger.  (There is even an IAR version at 600 GBP)

Also the IAR supports a LOT more of the MSP430 versions than Crossworks 
does.

> bug fixes weren't free and the annual maintenance fee was
>pricey.

BTW Rowley only give support for people on a paid up maintenance 
contract just like everyone else. No difference there


-- 
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills  Staffs  England     /\/\/\/\/
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

On Wed, 12 Nov 2008 12:35:00 -0600, "flash011"
<sylvainlarive@gmail.com> wrote:

>Greetings all,
>
>I posted a while back concerning help choosing an MCU/DSP and I greatly
>appreciated the input you guys gave me so I'm back with more questions.
>
>I've decided to go the ARM9 way.  More specifically, I went with ST's STR9
>series since it had the correct processing and ADC sampling rates.   
>
>Anyhow, I ordered a kit from IAR to test things out and so far so good. 
>My question is should I stick with IAR or go with something like EMBEST
>(they look like they have a good prices for their dev kits) or GNU.
>
>Looks like GCC is pretty well regarded but seems like it is more complex
>to install / use than other solutions.
>

Download the free RIDE Ide from Raisonance. It uses gnuarm as the
compiler. Very easy to get going with the STR9. The free support
library provided by ST is fully integrated within the Raisonance
environment, and getting a project started for a specific STR7 or STR9
variant is trivial and very quick. The debugger is limited in code
size on the free version.

Regards
  Anton Erasmus

In message <rtdmh41gin8f7fi4l3e2u8bvdanan6h5gb@4ax.com>, Anton Erasmus 
<nobody@spam.prevent.net> writes
>On Wed, 12 Nov 2008 12:35:00 -0600, "flash011"
><sylvainlarive@gmail.com> wrote:
>
>>Greetings all,
>>
>>I posted a while back concerning help choosing an MCU/DSP and I greatly
>>appreciated the input you guys gave me so I'm back with more questions.
>>
>>I've decided to go the ARM9 way.  More specifically, I went with ST's STR9
>>series since it had the correct processing and ADC sampling rates.
>>
>>Anyhow, I ordered a kit from IAR to test things out and so far so good.
>>My question is should I stick with IAR or go with something like EMBEST
>>(they look like they have a good prices for their dev kits) or GNU.
>>
>>Looks like GCC is pretty well regarded but seems like it is more complex
>>to install / use than other solutions.
>>
>
>Download the free RIDE Ide from Raisonance. It uses gnuarm as the
>compiler. Very easy to get going with the STR9. The free support
>library provided by ST is fully integrated within the Raisonance
>environment,

I thought EVERYONE has integrated free  the ST libraries in with their 
compilers?




-- 
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills  Staffs  England     /\/\/\/\/
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

Chris H wrote:
> In message <oa9mh4dr7u7ebh53cer5itfsrdtrad03i9@4ax.com>, Rich Webb 
> <bbew.ar@mapson.nozirev.ten> writes
>> On Wed, 12 Nov 2008 12:35:00 -0600, "flash011" <sylvainlarive@gmail.com>
>> wrote:
>>
>>> Greetings all,
>>>
>>> I posted a while back concerning help choosing an MCU/DSP and I greatly
>>> appreciated the input you guys gave me so I'm back with more questions.
>>>
>>> I've decided to go the ARM9 way.  More specifically, I went with ST's 
>>> STR9
>>> series since it had the correct processing and ADC sampling rates.
>>>
>>> Anyhow, I ordered a kit from IAR to test things out and so far so good.
>>> My question is should I stick with IAR or go with something like EMBEST
>>> (they look like they have a good prices for their dev kits) or GNU.
>>>
>>> Looks like GCC is pretty well regarded but seems like it is more complex
>>> to install / use than other solutions.
> 
> GCC is well regarded by some but not by others. The people who do our 
> compiler validation would not give it house room. But that is not the 
> specific GCC that Rowley use. Not sure how theirs is different.
> 
> 
>> Take a look at Rowley's CrossWorks. Not terribly expensive; it uses gcc
>> but its own libraries (no L/GPL issues).
> 
> Rowley's prices have gone up somewhat of late. From their web site:-
> 
> Shared-Developer Commercial License with Sentinel Dongle. 1,555.87 GBP
> 
> Compared to IAR at 1540 GBP
> 
> That makes Rowley 15 GBP MORE EXPENSIVE than IAR.
> 
> And that is for a GCC compiler from Rowley.
> 
> The IAR compiler uses the EDG front end and the Dinkumware libraries 
> both of which are very highly regarded and fully tested by both 
> Perennial and Plum Hall.   IAR compilers have been validated for Safety 
> Critical use at SIL3.  You can't say that about GCC
> 
> BTW IAR have over 30 dev kits and many many examples and BSP's  they 
> also support a very wide range of debuggers and RTOS awareness in the 
> debugger.
> 
>> IAR is great but the costs can add up. Used it years ago on an MSP430
>> project;
> 
> Check the pricing.... from what I have seen the new Rowley pricing is 
> not far off that of IAR  if not the same these days. From the Rowley web 
> site
> 
> Shared-Developer Commercial License with Sentinel Dongle. &#4294967295;1,521.29
> 
> The IAR system is 1400 GBP for the compiler and IDE or 1800 GBP with the 
> debugger.  (There is even an IAR version at 600 GBP)
> 
> Also the IAR supports a LOT more of the MSP430 versions than Crossworks 
> does.
> 
>> bug fixes weren't free and the annual maintenance fee was
>> pricey.
> 
> BTW Rowley only give support for people on a paid up maintenance 
> contract just like everyone else. No difference there
> 

Have a look at CodeSourcery:

<http://www.codesourcery.com/gnu_toolchains/arm>

These are the guys who actually write and maintain the gcc ports for 
ARM, ColdFire, and a few other targets - they don't just distribute 
ready-made code.  They are also a lot cheaper (free if you just want the 
command-line stuff, $400 for more libraries, the IDE and better debugger 
support, and a few thousand for the full package, unlimited support, etc.).

They are also happy to run Plum Hall and other such validation suites on 
  their tools.  I don't know what results they have, or certifications, 
or what validation they have for the different parts of their toolkits - 
that's more in the realms of "professional" support.

<http://www.codesourcery.com/gnu_toolchains/semiconductor_vendors.html>

In message <491bf7c9$0$20337$8404b019@news.wineasy.se>, David Brown 
<david@westcontrol.removethisbit.com> writes
>Chris H wrote:
>> In message <oa9mh4dr7u7ebh53cer5itfsrdtrad03i9@4ax.com>, Rich Webb 
>><bbew.ar@mapson.nozirev.ten> writes
>These are the guys who actually write and maintain the gcc ports for 
>ARM, ColdFire, and a few other targets - they don't just distribute 
>ready-made code.

This is part of the problem there are many who asynchronously maintain 
GCC ports so not two GCC are the same.  Then there are others who just 
distribute some one else's port with their own bits and add-ons.

So it can be very difficult to know exactly what version of the compiler 
you have.

>They are also a lot cheaper (free if you just want the command-line 
>stuff, $400 for more libraries, the IDE and better debugger support, 
>and a few thousand for the full package, unlimited support, etc.).

So for a professional package the cost the same as a professional 
commercial compiler?  Without all the trace ability history and testing 
you get for a commercial compiler.

>They are also happy to run Plum Hall and other such validation suites 
>on their tools.

Why don't they? Plum Hall or Perennial

> I don't know what results they have, or certifications, or what 
>validation they have for the different parts of their toolkits - that's 
>more in the realms of "professional" support.

It is quite difficult to do for GCC.  Also it would only be for a 
specific version and build. As so as you change anything  you have to 
re-test. Also it only applies to the binary.  If you release the source 
for some one lese to build it is not covered. (Because any one could 
change the source or build it with a different compiler.


-- 
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\ Chris Hills  Staffs  England     /\/\/\/\/
\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

On Nov 12, 7:54=A0pm, Rich Webb <bbew...@mapson.nozirev.ten> wrote:
> On Wed, 12 Nov 2008 12:35:00 -0600, "flash011" <sylvainlar...@gmail.com>
> wrote:
>
> >Greetings all,
>
> >I posted a while back concerning help choosing an MCU/DSP and I greatly
> >appreciated the input you guys gave me so I'm back with more questions.
>
> >I've decided to go the ARM9 way. =A0More specifically, I went with ST's =
STR9
> >series since it had the correct processing and ADC sampling rates. =A0
>
> >Anyhow, I ordered a kit from IAR to test things out and so far so good.
> >My question is should I stick with IAR or go with something like EMBEST
> >(they look like they have a good prices for their dev kits) or GNU.
>
> >Looks like GCC is pretty well regarded but seems like it is more complex
> >to install / use than other solutions.
>
> Take a look at Rowley's CrossWorks. Not terribly expensive; it uses gcc
> but its own libraries (no L/GPL issues).
>
> IAR is great but the costs can add up. Used it years ago on an MSP430
> project; bug fixes weren't free and the annual maintenance fee was
> pricey.
>
> --
> Rich Webb =A0 =A0 Norfolk, VA

Check out the Ride environment from www.raisonance.com. Their IDE is
free and integrates gcc very nicely, with native support for all STR9
peripherals.
Bruno

>
>Check out the Ride environment from www.raisonance.com. Their IDE is
>free and integrates gcc very nicely, with native support for all STR9
>peripherals.
>Bruno
>

You guys have convinced me to check the RIDE trial for a few days.  Their
dev kits seem rather nicely priced and as you've stated, seem to integrate
real well with ST products.

Chris H wrote:
> In message <491bf7c9$0$20337$8404b019@news.wineasy.se>, David Brown 
> <david@westcontrol.removethisbit.com> writes
>> Chris H wrote:
>>> In message <oa9mh4dr7u7ebh53cer5itfsrdtrad03i9@4ax.com>, Rich Webb 
>>> <bbew.ar@mapson.nozirev.ten> writes
>> These are the guys who actually write and maintain the gcc ports for 
>> ARM, ColdFire, and a few other targets - they don't just distribute 
>> ready-made code.
> 
> This is part of the problem there are many who asynchronously maintain 
> GCC ports so not two GCC are the same.  Then there are others who just 
> distribute some one else's port with their own bits and add-ons.
> 
> So it can be very difficult to know exactly what version of the compiler 
> you have.
> 

That is one of the reasons I use (and recommend) CodeSourcery as a 
source of embedded gcc compilers - then you *do* know who is working on 
it.  There are certainly other people who contribute to gcc - after all, 
it is a modular system with dozens of major cpu targets, dozens of host 
OS's, and vast numbers of professional and non-professional users. 
Major contributors include companies like IBM, Intel, Sun, and Freescale 
as well as Linux-oriented companies like Novel and Red Hat.  Much of 
this will be for gcc front-end and middle-end development (and backends 
for x86, amd64, and ppc), rather than the backend for ARM, ColdFire, or 
other embedded targets.

The advantage of having many maintainers is that all gcc ports can 
benefit from this sort of development.  It certainly does mean there is 
less coherence in the project - it can therefore take more time for 
improvements in different parts of gcc to make it through to tested and 
ready-to-use downloads (you can get them earlier if you want to patch 
and build yourself), and it is harder for the front-ends and back-ends 
to take advantage of changes - they must communicate using a common 
interface.

CodeSourcery are the official maintainers of the ARM and ColdFire (and a 
few other targets) backends, and they are also heavily involved in 
general gcc development.  This means they have a much better view of 
what is going on in gcc, and what parts or changes are suitable for 
embedded development.  They are also heavily involved in gdb development 
for debugging.

>> They are also a lot cheaper (free if you just want the command-line 
>> stuff, $400 for more libraries, the IDE and better debugger support, 
>> and a few thousand for the full package, unlimited support, etc.).
> 
> So for a professional package the cost the same as a professional 
> commercial compiler?  Without all the trace ability history and testing 
> you get for a commercial compiler.
> 

Have a look at 
<http://www.codesourcery.com/gnu_toolchains/sgpp/editions.html> and 
<http://www.codesourcery.com/gnu_toolchains/sgpp/components.htm> to see 
the differences.  Personally, I use the free ("lite") version of their 
tools normally - I'm not a fan of IDEs.  But I've also used the 
"personal" edition - it actually covers everything a professional user 
could want except that there is only limited official support (there are 
still support forums, frequented by the developers, installation 
support, bug support, and so on).  The "professional" version gives you 
unlimited support from the engineers that write the tools:

(from <http://www.codesourcery.com/gnu_toolchains/sgpp/components.htm>)

Unlimited Support

Sourcery G++ Professional Edition customers receive unlimited support 
from CodeSourcery, directly from CodeSourcery's engineers. This support 
&#4294967295; provided without any per-incident fees &#4294967295; covers much more than just 
installation and basic usage. CodeSourcery will happily answer questions 
about porting programs from other tools, the C and C++ programming 
languages, using GNU features like inline assembly, and all other topics 
related to use of Sourcery G++. Support is provided by the same expert 
developers who have contributed thousands of changes to the GNU 
toolchain over CodeSourcery's ten-year history.



With commercial closed source tools, it's a rarity that you can get in 
touch with the developers directly.  Often you deal with dedicated 
support staff who know less about the tools and target than expert users 
(on the other hand, they know a lot about licensing, dongles, license 
servers, and such like - that covers a substantial number of support 
issues).


I'm not sure what you mean by "trace ability history" - there are 
certainly no problems getting older versions of gcc (google for "gcc 
archives" and download the source from 1988 if you want), and the 
CodeSourcery website keeps releases directly available for download for 
several years.  Since all the source code is included, you have as much 
"history" as you could want.  And if you've paid for the unlimited 
support, I'm sure you'll get all the help you want too.

As for testing, gcc already has substantial test suites which 
CodeSourcery use (amongst other test suites).

>> They are also happy to run Plum Hall and other such validation suites 
>> on their tools.
> 
> Why don't they? Plum Hall or Perennial

I don't know if they do or not.  You could ask them if you like - I'm 
sure people who are happy to pay the large prices of commercial toolkits 
(or CodeSourcery's "professional" edition) are interested in this sort 
of thing, and will ask all potential tool vendors about validation 
before committing themselves.  For example, IAR's web site says they 
test with Plum Hall and Perennial - they don't give any results for 
these tests for their compilers.  I'm sure they would tell me if I ask, 
especially if I'm offering lots of money - and I'm sure the same applies 
to CodeSourcery.

Personally, I am not interested in such big-name test suites.  I have no 
a priori reason to think that an expensive closed-source test suite is 
any better than an open source test suite, and plenty of reason to think 
that open source test suites are better in some ways (for example, if a 
bug is found in gcc, then a test can be added to the regression test 
suite to ensure that the bug is not repeated in future versions).  Of 
course, it is always better to test with as many testsuites as 
conveniently possible (none of them will cover everything).

Certainly there are times when it is legally important to have 
certifications from independent well-known third parties - but I don't 
think it is likely to make any realistic difference to the reliability 
of the end product (it is *far* more likely that any bugs are do to *my* 
programming, not the compiler).

> 
>> I don't know what results they have, or certifications, or what 
>> validation they have for the different parts of their toolkits - 
>> that's more in the realms of "professional" support.
> 
> It is quite difficult to do for GCC.  Also it would only be for a 
> specific version and build. As so as you change anything  you have to 
> re-test. Also it only applies to the binary.  If you release the source 
> for some one lese to build it is not covered. (Because any one could 
> change the source or build it with a different compiler.
> 

CodeSourcery releases compiler builds - you download the pre-packaged 
binary and install it just as you would for any closed source tool. 
They release new versions about twice a year (with faster updates for 
paying customers), just like for closed source tools.  They run all 
their internal tests and validation (whatever these may be) on these 
builds, just like for closed source tools.

You can also, if you like, download the source code.  You can, if you 
like, rebuild it yourself with or without modification.  As you say, any 
such builds will no longer be covered by whatever certifications the 
binaries had - but that's your own choice.  By getting your gcc tools 
from CodeSourcery (or other serious gcc vendors), you have both options.


Have a look at this post - it explains pretty well why you don't see 
many gcc Plum Hall results published:

<http://gcc.gnu.org/ml/gcc/2003-02/msg00652.html>
<http://gcc.gnu.org/ml/gcc/2003-02/msg01206.html>