ARM IDE & kit similar to CCS for PIC's?

net.nit: "compiler, of which I am quite fond". Remember Winston Churchill.

Anyway:

Hard to understand why you are not "interested" in gcc when a large percentage of the world's fielded ARM code was built with it - but anyway, look at Rowley's CrossWorks for ARM. A personal license is $149, an education license $299. I am using it with Rowley's own USB JTAG adapter and it works well, I assume it works just as well with other supported adapters.

Of course CrossWorks for ARM is GCC plus their IDE and debugger. There is also as compiler from imagecraft. I've not used either it or Rowley's setup.

Robert

It used to be, but ISTR last time I spoke with Paul @ Rowley that this was no longer true - it's now using their own compiler engine.

Their website says GCC. They do supply libraries of course, including a C runtime library.

It looks as if ImageCraft's is cheaper, $200-$550 as compared to Rowely's $1000 for development versions.

Robert

I've been using the Imagecraft compilers for quite a while and have been pretty happy with them. (usual disclaimer applies -- just a customer -- but I do have their AVR, MSP430 and AVR compilers) Most of the Imagecraft development seems to be on the AVR compiler family; guessing that's where most of their customer base is, nowadays. The developers are quite responsive and there's also an active mailing list that they host.

They're free for a 45-day trial and then there's a fall-back to a code limited, non-commercial license.

Rowley's compiler IS the GCC compiler. You are paying for their IDE

I've just look at the release notes for version 1.7 (I'm running 1.6 at the moment) and one of the entries is:

"Updated versions of the C/C++ compilers from the GNU Compiler Collection and assembler, linker, librarian from GNU Binutils. These are built from the CodeSourcery arm-2006q3-26 source code release. The compilers are based on the GCC 4.1.1 release and the binutils on the

Was your conversation recent? Perhaps 1.8 is in the pipeline?

As I keep pointint out, only for ARM, not for MSP430, AVR, MAXQ. With a $149 personal license for ARM you get a non-commercial version of the software *and* a piece of hardware, the CrossConnect Lite, thrown in so you can do standard debugging. And you're not just "paying for their IDE", you are paying for the IDE, the library, and all the CPU and board support packages we have written and access to our support helpdesk. If you only got the IDE, I'd be disappointed.

$995 is the CrossWorks commercial version. $149 is the CrossWorks hobbyist version with hardware thrown in.

Comparing like with like with the top-end commercial tools, you will also need a debugger with the ImageCraft product, another $159. Ok, and if you want the ImageCraft compiler, a debugger, and the a USB JTAG adapter that's an additional $429 which brings the total to$978. This is a fair comparison.

Comparing a hobbyist purchase, you can get a CrossConnect USB JTAG adapter and CrossWorks software from us for $149, but ImageCraft is, oh, $199 + $429 which is $628 for the same thing.

So, in the round, I fail to see why ImageCraft works out cheaper, comparing like for like.

-- Paul.

In article , Paul Curtis writes

I thought we were discussing your ARM suite.

Enough with the commercials already ... :-)

What is a non-commercial version?

You do your own library?

Most compilers come with a multitude of BSP's and projects even on the free versions of the other commercial compilers.

Point taken but I thought support for GCC was free from the community? Or do people need support from you because you use a different library etc?

Regards Chris

There are a number of companies that sell configured packages of software that include GCC and GAS at their core. For example:

"Microcross is the leading international distributor of open-source embedded development tools based on GNU technology."

Frankly, I've purchased the tools from Microcross to save time. At the time, my price was about $150 for the set. (That was four years back, I think.) I don't believe any of the configured tools I got were their own product and they were not limited to non-commercial use

-- so long as I selected the right library to include. That project never did see the light of day, as we were evaluating a processor and tools at the time and the project didn't get fully funded in the end. So I can't speak from the point of view of a completed project.

I think one possible value of a 'different library' from a vendor like this is that you don't have to worry about the licensing. You have paid __them__ to vet this issue for you. Otherwise, you can be sure they would be quickly confronted about the license violation in their package. In using GPL'd tools, one has to be careful and it's nice that someone else is thinking about these issues, too, who is a bit more of an expert about it than most of us application programmers often are. Another is that when competing with other companies, the library can have a material impact on the performance of the compiler output, on the whole, and competing will generally mean some effort will go into providing a more effective library than what is freely available without restriction to GCC. None of this is a guarantee, of course. But it is not an unreasonable expectation.

Jon

P.S. I have recently been using Rowley's toolset for the ARM (LPC2148, in my case) and he was very generous with me in the process of getting started, so realize that I am speaking from an existing, friendly relationship:

Rowley offers a strong, value-added package for the ARM, Paul is very technically informed on myriad details as well as the marketplace, and Rowley is one of the better service-oriented businesses I've worked with. His offer of tools for $149 for non-commercial use, including the JTAG unit he provides, is fine. It's about what you'd expect to pay for a with-demo-board-only special version of JLINK (or ULINK-2) or other modest JTAG device. His JTAG tool includes a feature you may not get with those and may need -- following variable clock rates under JTAG debugging, I think (but my knowledge is not comprehensive here, so take this with a grain of salt.) And you get non-commercial, unlimited use of a pretty easy to use toolset.

Looking backwards, if I were doing hobby work with ARM processors, I wouldn't bat an eye about accepting that deal knowing what I now know. The struggle in learning about and the cost in getting a good JTAG unit along with all the rest would be short-circuited and at a price that is probably no different than I'd otherwise spend, anyway. Paul is offering more than just good value, in my opinion, to hobbyists.

Jon

I was comparing based on the licensed for producing code for use in a product. The other items certainly add value, but it's not necessarily what everyone is looking for. Whether they should be is another question.

Robert

The licensing is definitely an issue. Even newlib has some restrictions despite not being (L)GPL. However the killer problem is that the freely available libraries are huge and slow(*) and so totally unsuitable for embedded systems. As you say, you can get a lot more out of a compiler by using high quality libraries. AFAIK most companies selling GCC based tools use their own (closed source) libraries.

Wilco

(*) As an example, long long divide in GCC's libraries takes in total 5KBytes on ARM. My fast version (ie. performance, not codesize optimised) takes 528 bytes...

Licensing is certianly an issue. Although we use GCC as the compiler and binutils as the underpinnings of linking, the libraries, board support packages, flash code, and everything else is certainly not covered by any style of GPL/LGPL license because we wrote the rest in-house with properly licensed software (Visual Studio and Qt).

With a Personal (non-commercial) license you can use our tools to write non-commercial software. We make no claims on the source code you write and you are free to distribute the sources to others if you wish. We provide the source code for GCC and binutils and the patches we've made so you can rebuild the tools should you need to.

We have already been through the issues involved with the FSF; I don't think we're any different from other companies in some regards. I can't speak for Microcross, I do not know whether they provide their own closed source libraries or not.

The issue for commercial customers is that they can purchase (from us) a standard Commercial licence for our tools and know that their end application is not covered by any GPL or LGPL license. If we had used LGPL code in the library we distribute to customers then they would be bound to provide relinkable object code. This is obviously undesirable for many customers and, gee, they may not even be aware of the mess they could land themselves in.

-- Paul Curtis, Rowley Associates Ltd

CrossWorks for ARM, MSP430, AVR, MAXQ, and now Cortex-M3 processors

You made a statement that the Rowley Compiler is GCC. In fact, it's not--the "Rowley Compiler" is something that I wrote and which generates code for a number of targets, not only the ones that we've turned into products. I made the decision that I did not wish to write an ARM code generator because I had already done so for Rowley Modula-2 and didn't feel the need to do it again. There was also another very good reason to integrate GCC rather than our own toolset into CrossWorks, and that reason has never seen the light of day outside of Rowley Associates and a single silicon company.

A more accurate statement is that "The compiler provided with CrossWorks for ARM is derived from the GNU Compiler Collection".

I won't recite the agreement, but simply put, it states that you will not derive a profit from the use of our tools. This covers hobbyist, educational, and research use of our tools. Now, in the case of CrossWorks for ARM, we are not restricting the use of GCC and binutils, far from it--you can use those freely. However, if you wanted to do that, you would not need to purchase a Personal License--you just download and use GCC and binutls from us or elsewhere. What you can't do is use our IDE and you can't use our libraries without purchasing CrossWorks because those are covered by our own license.

Of course. This is clearly stated as one of the benefits of using our tools. In this way commercial customers can be sure that their application will not be covered by a GPL or LGPL license inherited from the inclusion of GPL/LGPL code in the library they link in.

...but I'm pretty much sure they don't offer the range of BSPs that we provide. I regularly survey the development tools landscape. The fact that anybody can write and distribute a BSP for CrossWorks, which you can just plug in, pretty much nails us as fairly unique. We have customers that are developing proprietary ARM chips using CrossWorks and writing their own BSPs.

Whoever said that we only provide GCC support? Free support is worth every penny, but there is an expectation from a customer that has paid for our tools to receive support from the provider, not seek support from the community. We do not take customer's money and tell them to seek help elsewhere--there is an undertaking that we will support them.

To be frank, GCC support is the least of our problems. I would say that 95% of customer problems are related to operation of hardware, NOT software, from the processor right through the JTAG adapter to the OS it runs on. This is the reason that we are now distributing a low-cost JTAG adapter with each CrossWorks license purchase is because that adapter runs our own code and we then have zero excuse for any failings. In fact, the BIGGEST, hairyest problem is the way in which ARMs reset and control of them is gained after reset.

Most customers are new to ARM and want something easy to use. We provide that. Experience ranges from complete newbies to hardened engineers. Everybody has their own set of support requirements.

The reason to introduce a Personal License for CrossWorks is that my inbox became littered with requests to lower the price of the tools for people who are not interested in producing products but want to play about with microprocessors. Discussions over the Personal License took a long time at CrossWorks Central; in fact, all marketing and pricing takes a long time, this is much harder than writing software. Throwing in a JTAG adapter sweetens the deal.

The argument for a Personal License is clear: hobbyists want to play with micros and use a decent hassle-free piece of software when doing so. We had to balance this against the fact that some customers will purchase a personal license even though they are developing commercial code. The pragmatic way to view this is that, in all likelihood, we wouldn't sell a commercial license to these customers anyway, and if we witheld the introduction of a Personal License because of that we'd be spiting the hobbyists that genuinely want to use it.

Hence, we took the Eagle model of personal use--sign a piece of paper and we'll let you purchase a Personal License. That makes people think before proceeding and, should we wish to press things later because of license misuse, we have a signed agreement.

We take the same view of developers using cracked versions of our software--we're not going to sell to these "customers" anyway, so why get all bent out of shape when they do use it? Why not consider it confirmation of our product's quality that technoheads take the time to crack and use our products? Our focus remains on the class of customer we wish to establish and retain: those that delight in paying for great software and appreciate fantastic support.

-- Paul Curtis, Rowley Associates Ltd

CrossWorks for ARM, MSP430, AVR, MAXQ, and now Cortex-M3 processors

Hello All,

This is my first time posting in an usenet group, and I am using google reader, so if something goes wrong, I will appreciated your advice.. (good or bad)

Any way, let's go to the meat!

So seems that a good deal of these IDEs including Rowley and other is the library, because it could save you a lot of space due they are optimized to deep embedded systems, so providers state really clear this advantage.

In the case specify to Rowley, Paul, could you mind to compare your library vs keil's newest library microlib for ARM?

I have done some projects with the free tools and the are good but the C runtime lib is big, really big, and sometimes is not acceptable to have this extra space used for this big libs. One good example is when you jump from your vector and stack init section(asm) to __main... from here (without rewriting the C runtime libs ) I expect to do zero down, copy down, stack, heap(optional) and then main(), but what I have found is that the *argv, argc* section, and others sections are there adding a lot of space.

gcc works fine as a "bare metal" compiler - I just did a test with a trivial main() and a minimum of startup code. The total size is ~190 bytes.

If you use functions such as malloc or printf, you will bloat the code pretty quickly. This is true with all C libraries (but to a lesser extent with the commercial ones). I have found that these functions are all best avoided anyway on "small" systems (e.g. the single chip ARMS).

Both Hitex and Raisonance makes commercial IDEs that can integrate with GNU GCC. You do not need to write makefiles etc. Both have demo versions you can download. The basic difference between the demo and full versions is that the debug support is limited with the demo versions. Both sell development kits that has the IDE and gcc bundled with the kit with documentation on getting examples going on the development kits. The Hitex documentation looks better than the Raisonance documentations.

Regards Anton Erasmus