Reply by Andy Berney September 27, 20072007-09-27
On the RealView vs CARM debate it's quite straight forward, Keil started off
with CARM and were bought out to become an ARM company, as such inheriting
the RealView compiler as the default standard. CARM is therefore deprecated
and although it was perfectly acceptable (and in some ways superior - I
missed the __at definition for example) it's now not supported as such so
it's easier to start off with RealView for new projects if you're simply
choosing between the two.

That effectively leaves you a choice between RealView and Gnu. I've read
much debate both on this forum and others about which is best. Both camps
have their reasons for championing their winner however it's more a case of
which better fits your purpose. Being unwilling to accept people's comments
simply at face value I've tried both.

For someone with limited experience with the ARM processor or embedded
systems in general it may perhaps be easier to get to grips with RealView,
primarily because with uvision as the IDE a fair bit of the low end set up
is done for you meaning you can concentrate more on getting some form of
code written and tested quickly, the added value of the libraries associated
with the full versions of Keil / IAR etc obviously mark these out for ease
of use - and customer support although they come with a hefty price tag - I
was lucky enough to inherit this application from my predecessor so it
wasn't an issue.

On the other hand if you're more confident of your ARM skills or simply
don't want the IDE to hide some of the lower down mechanics as you're happy
you know what you're doing in changing them, (and lets face it you really
SHOULD want to know what they're doing), the GNU enviroment is ideal as you
will effectively define how you create your finished image from start to
finish - in some ways you're simply forced to figure everything out but in
the long run that's brilliant as when things go wrong (and they will) you're
far better prepared to know where to look.

In terms of effectiveness of compilation, there seems to be a difference of
opinion from the two camps. Suffice to say that with the RealView compiler
being owned by ARM it's likely to see more pertinent updates, although the
two compilers have now been out long enough for this to barely matter on an
ARM7 / ARM9 core. In terms of efficiency I've only personally done a few
tests, with the RealView output being slightly more efficient, however there
really wasn't a great deal in it to be honest and if you're worried about
that number of cycles saved then you've made a much bigger screw up in
choosing your hardware!

Some older versions of GNU, (including the one that ships with the demo
version of KEIL I believe - I used a later edition), exhibit some problems
with the optimisation level when compiling IRQ's however there's already
plenty of discussions both on here and elsewhere on how to overcome these
problems so it's more a case of needing extra knowledge in order to use the
tools well.

So to answer your question -

if cost is an issue but you can keep your image small enough to use the Keil
demo it's probably the way to go with RealView, if not use a free gnu chain
with cygwin.

If on the other hand you're lucky and you have the cash available for the
tools - and you're going to get the benefit out of them -then the full suite
of Keil is certainly an easy tool to use to make projects quickly and
efficiently.

As in so many things in life, you pays your money, you makes your choice.

Andy

-----Original Message-----
From: l... [mailto:l...]On Behalf Of
davidj.vpac
Sent: 24 September 2007 03:40
To: l...
Subject: [lpc2000] ARM 7 Compilers
Can I get some input as to the advantage/disadvantages of various
compilers.

If using uVision IDE then the choice is RealView, CARM or GNU.
Without going through the limitations of the "trial" version of
RealView & CARM, GNU would/could be the choice here given that the
others cost about $5K.

If doing a large number of projects then I guess that cost can be
spread but if only doing one or two projects then it is a significant
cost. Besides the limitations, what are the key reasons for using
RealView over CARM/GNU and other compilers?

By comparison the ImageCraft ARM compiler is a few hundred dollars
($200-600).
There is also the WINARM system based upon GNU

What other ARM7 compilers are there, especially, say, <$500?
My target system is LPC2119/2129

Is there a definitive discussion/comparison of these?

An Engineer's Guide to the LPC2100 Series

Reply by slawcus September 25, 20072007-09-25
--- In l..., 42Bastian wrote:

> I notice at least a 10% to 20% better code from IAR/RVCT/Keil, esp.
when
> compiling for Thumb mode compared to GCC (3.4.4, newer version might be
> better).
>
We moved from 3.x to 4.1 (GCC for H8S though) and result was 10 -15%
smaller output.
Reply by Tom Walsh September 24, 20072007-09-24
davidj.vpac wrote:
>
> Can I get some input as to the advantage/disadvant ages of various
> compilers.
>
> If using uVision IDE then the choice is RealView, CARM or GNU.
> Without going through the limitations of the "trial" version of
> RealView & CARM, GNU would/could be the choice here given that the
> others cost about $5K.
>
> If doing a large number of projects then I guess that cost can be
> spread but if only doing one or two projects then it is a significant
> cost. Besides the limitations, what are the key reasons for using
> RealView over CARM/GNU and other compilers?
>
> By comparison the ImageCraft ARM compiler is a few hundred dollars
> ($200-600).
> There is also the WINARM system based upon GNU
>
> What other ARM7 compilers are there, especially, say, <$500?
> My target system is LPC2119/2129
>

Well, if you are developing on a Windows host, expect to spend some
amount of money on a solution. Or, you could go with one of the WinARM
packages which feature a GNU compiler, this would also require you to
install cygwin on your system. Cygwin is a un*x emulator for Windows
which allows you to use the un*x tools / utilities on a Windows box.

The question is not so much what compiler is best, they all score
differently across differing types of tests for code generation. IMO,
there is a lot of value in the GNU gcc / binutils solution, as in you
can now spend the extra money on a good JTAG unit (BDI2000) or oscilloscope.

However, there is one distinct advantage to using a Kiel or RealView or
? development package: the libraries. The proprietary licensed
development tools usually offer libraries that are no encumbered by a
license such as BSD or GPL. They would also offer you libraries / code
which would include TCP / UDP stacks, USB drivers, etc.

The proprietary packages do have some value-added that must also be
considered when making the choice.

TomW
--
Tom Walsh - WN3L - Embedded Systems Consultant
http://openhardware.net http://cyberiansoftware.com http://openzipit.org
"Windows? No thanks, I have work to do..."
----------------
Reply by 42Bastian September 24, 20072007-09-24
Arthur Khachatryan schrieb:

> I mean the
> Keil's own RealView compiler/linker generates more compact and effective
> code.

Same for IAR (I do not know ImageCraft).

I notice at least a 10% to 20% better code from IAR/RVCT/Keil, esp. when
compiling for Thumb mode compared to GCC (3.4.4, newer version might be
better).

>> If using uVision IDE then the choice is RealView, CARM or GNU.
>> Without going through the limitations of the "trial" version of
>> RealView & CARM, GNU would/could be the choice here given that the
>> others cost about $5K.

The cost for the maybe bigger Flash should also be taken into account.

BTW: AFAIK there are compiler-only version of IAR and RVCT, which are
cheaper (no fancy IDE).

--
42Bastian
Reply by rj_satterlee September 24, 20072007-09-24
Hiya-

I too have been playing with the LPC2119 chip. I have used the
evaluation version of the gnu compiler shipped with the Kiel and the
gnu/eclipse/odt toolchain with some mixed results.

The problem for me, even sticking with gnu, is that everybody seems
to have a different make environment! The IDEs almost seem to hinder
rather than help the development effort.

Please note that I come from a 'nix world so things like touch and
make are old hat to me and some of the tools like xdb I've used
for decades. So, some of my experiences will be tainted with my
history. Also, note that I do the ARM development work (so far) in
on a windoze box.

Cost is an issue for me. Whenever possible, I try to leave my client
with not only the developed project, but also a development system
that can be used for modifications in the future. So, leaving $5K
costs of software around in a history trail isn't a good solution for
me. However, if I can leave open source software along with a little
$50-$150 JTAG or say PIC ICD2 package, well, that's all to the good.
Also, if I leave them with *MY* development system, I usually can talk
them into NOT learning *THEIR* development system, along with the
learning curve of learning theirs......

If you are familiar with a particular IDE then it might be of interest
to you to save on the learning curve and go with an ARM compiler that
fits an existing IDE that you are used to.

Also, as mentioned in an earlier post on this thread, you should take
into account the "staying power" of the chosen compiler. I "feel"
that the gnu compiler will be with us for quite a while and not go
away. I also expect that the code will continue to be maintained.
Both very good things in my book.

Finally, I'm not too worried about optimization of binary code
generated. There are reports (and I can believe them) that the gnu
compiler is a little bit more verbose than some of the more targeted
compilers out there. So, this potential problem is not an issue with
me. Further, when in the debug phase, usually optimization is turned
off anyway, so all code size figures are blown away anyway. YMMV.

These are the "reasons" that I choose the toolchain that I did. Note
that this post has very little to do with the technical merits of a
particular set of tools. Hope that this helps shed light on the path
that you choose.

Cheers,

Rich S.

--- In l..., "davidj.vpac" wrote:
>
> Can I get some input as to the advantage/disadvantages of various
> compilers.
>
> If using uVision IDE then the choice is RealView, CARM or GNU.
> Without going through the limitations of the "trial" version of
> RealView & CARM, GNU would/could be the choice here given that the
> others cost about $5K.
>
> If doing a large number of projects then I guess that cost can be
> spread but if only doing one or two projects then it is a significant
> cost. Besides the limitations, what are the key reasons for using
> RealView over CARM/GNU and other compilers?
>
> By comparison the ImageCraft ARM compiler is a few hundred dollars
> ($200-600).
> There is also the WINARM system based upon GNU
>
> What other ARM7 compilers are there, especially, say, <$500?
> My target system is LPC2119/2129
>
> Is there a definitive discussion/comparison of these?
>
Reply by "FreeRTOS.org Info" September 24, 20072007-09-24
> > I use the Keil uVision evaluation version. As I told in my previous
> posts
> > the size of generated hex file was at least 2.3 times
> greater while the
>
> Is that comparison with both compilers in the same instruction set
> mode (ARM vs. Thumb) and optimization modes?

Also - what was contained in the binary? Did you include parts of the
library (calls to sprintf() for example), and did you remove unused symbols
(which GCC does not do by default).

The standard GCC library is a lot bigger for sure (CrossWorks supplied
library is smaller), but 2.3 times greater binary image without including
great chunks of the GCC library is far far greater than I would expect to
see.

Regards,
Richard.

+ http://www.FreeRTOS.org
13 official architecture ports, 1000 downloads per week.

+ http://www.SafeRTOS.com
Certified by T as meeting the requirements for safety related systems.
Reply by stevech11 September 24, 20072007-09-24
--- In l..., "Arthur Khachatryan"
wrote:
>
> I use the Keil uVision evaluation version. As I told in my previous
posts
> the size of generated hex file was at least 2.3 times greater while the
Is that comparison with both compilers in the same instruction set
mode (ARM vs. Thumb) and optimization modes?
Reply by Arthur Khachatryan September 24, 20072007-09-24
I use the Keil uVision evaluation version. As I told in my previous posts
the size of generated hex file was at least 2.3 times greater while the
Keil has been configured to use the embedded GNU compiler. I mean the
Keil's own RealView compiler/linker generates more compact and effective
code.

Everyone can test the above written.

Thanks.

From: l... [mailto:l...] On Behalf Of
Tom Walsh
Sent: Monday, September 24, 2007 4:48 PM
To: l...
Subject: Re: [lpc2000] ARM 7 Compilers

davidj.vpac wrote:
>
> Can I get some input as to the advantage/disadvant ages of various
> compilers.
>
> If using uVision IDE then the choice is RealView, CARM or GNU.
> Without going through the limitations of the "trial" version of
> RealView & CARM, GNU would/could be the choice here given that the
> others cost about $5K.
>
> If doing a large number of projects then I guess that cost can be
> spread but if only doing one or two projects then it is a significant
> cost. Besides the limitations, what are the key reasons for using
> RealView over CARM/GNU and other compilers?
>
> By comparison the ImageCraft ARM compiler is a few hundred dollars
> ($200-600).
> There is also the WINARM system based upon GNU
>
> What other ARM7 compilers are there, especially, say, <$500?
> My target system is LPC2119/2129
>

Well, if you are developing on a Windows host, expect to spend some
amount of money on a solution. Or, you could go with one of the WinARM
packages which feature a GNU compiler, this would also require you to
install cygwin on your system. Cygwin is a un*x emulator for Windows
which allows you to use the un*x tools / utilities on a Windows box.

The question is not so much what compiler is best, they all score
differently across differing types of tests for code generation. IMO,
there is a lot of value in the GNU gcc / binutils solution, as in you
can now spend the extra money on a good JTAG unit (BDI2000) or oscilloscope.

However, there is one distinct advantage to using a Kiel or RealView or
? development package: the libraries. The proprietary licensed
development tools usually offer libraries that are no encumbered by a
license such as BSD or GPL. They would also offer you libraries / code
which would include TCP / UDP stacks, USB drivers, etc.

The proprietary packages do have some value-added that must also be
considered when making the choice.

TomW

--
Tom Walsh - WN3L - Embedded Systems Consultant
http://openhardware.net http://cyberiansoftware.com http://openzipit.org
"Windows? No thanks, I have work to do..."
----------------
Reply by "FreeRTOS.org Info" September 24, 20072007-09-24
> If using uVision IDE then the choice is RealView, CARM or GNU.

As far as I know, CARM is defunct, and has been for some time. I have never
tried GNU with Keil, but I have been told that the GNU version shipped is
old, I presume you could just updated to a later version though.
> By comparison the ImageCraft ARM compiler is a few hundred dollars
> ($200-600).
> There is also the WINARM system based upon GNU

...and GNUARM and Yagarto and CodeSourcery Lite, all pre-built free GNU
downloads.
>
> What other ARM7 compilers are there, especially, say, <$500?
> My target system is LPC2119/2129
CrossWorks is a good choice for an IDE ontop of GCC. The GCC version
shipped is up to date too. The price is a little over your target, but not
much.

IAR is another consideration. Expensive, but has a 32K limited version for
free.

You could also look at an Eclipse based environment. See
http://www.freertos.org/portlpc2368_Eclipse.html for an example setup,
although the cost of CrossWorks would pay for itself in time and ease of
configuration.
Regards,
Richard.

+ http://www.FreeRTOS.org
13 official architecture ports, 1000 downloads per week.

+ http://www.SafeRTOS.com
Certified by T as meeting the requirements for safety related systems.
Reply by "davidj.vpac" September 23, 20072007-09-23
Can I get some input as to the advantage/disadvantages of various
compilers.

If using uVision IDE then the choice is RealView, CARM or GNU.
Without going through the limitations of the "trial" version of
RealView & CARM, GNU would/could be the choice here given that the
others cost about $5K.

If doing a large number of projects then I guess that cost can be
spread but if only doing one or two projects then it is a significant
cost. Besides the limitations, what are the key reasons for using
RealView over CARM/GNU and other compilers?

By comparison the ImageCraft ARM compiler is a few hundred dollars
($200-600).
There is also the WINARM system based upon GNU

What other ARM7 compilers are there, especially, say, <$500?
My target system is LPC2119/2129

Is there a definitive discussion/comparison of these?