If you had to start over today with STM32... which toolchain? GCC? Kiel?  - Page 1
Forum section: electronics / general

author: jnz
author_rank: Frequent Contributor
timestamp: May 19, 2015, 09:29:52 pm
content: I'm kicking around Rowley and aside from a couple annoyances, I'm almost ready to pull the trigger on a commercial license. I like the idea of GCC and Clang being free, reliable, portable to other IDEs, etc. Rowley's CTL/RTOS is appealing.I'm hesitant because everything out there seems to support Kiel uVision and with ARM owning them, I don't see that changing. I'm migrating from PIC and don't want to chose "poorly" (face melt off and the whole nine). Kiel also has apparently great RTOS for free.I can find almost no modern comparisons of Kiel vs Rowley vs Atollic vs anything else (I know IAR is out there, but I don't like the 90s IDE, it's a factor). Everything I've been able to find is from 2010-2012 and for all I know Kiel's IDE that a lot of people complain about has gotten a lot better.Is mbed an option for serious projects?The price difference is at least 3x but I don't care IF it's the right tool. I want to choose "not poorly".What would you guys use today if starting fresh?

author: nctnico
author_rank: Super Contributor
timestamp: May 19, 2015, 10:06:47 pm
content: Good question. IMHO it's worth looking into an Eclipse based IDE. All the vendor provided IDEs I have seen so far seem to have originated from an afterthought. "Oh now we have built this great toolchain but hey, let's also give the user also something slightly better than notepad with lot's of eyecandy"

author: Christe4nM
author_rank: Unknown
timestamp: May 19, 2015, 11:53:16 pm
content: As I understand Keil uVision and IAR EWARM are equally good with either having a few minor things the other lacks. For example IAR has a nice hardware debugger tool that can be used to match current draw to your application. While Keil, being an ARM brand probably has the most optimized compiler for ARM MCUs.I don't know anything about Rowley Crossworks, but they are mentioned a lot together with Keil and IAR of you are looking for an IDE for ARM.If you want to put down (serious) money, do try working with the candidates for a while. That way you can experience how it works for you. At that level all compilers should be about equally good. So I think it comes down to which IDE you experience as working nice for you.When it comes to vendor IDEs I happen to use Freescale's Kinetis Design Studio which is Eclipse based and to me does not at all feel like an afterthought. It is Freescale Kinetis only though, but it's free, unlimited code size and I like those Kinetis MCUs anyway.Also NXP acquired CodeRed which is now branded LPCXpresso iirc. I don't think that formerly CodeRed can be named an afterthought. Though I don't know what NXP did with it.Just to say that there are also vendor provided tools that do work well.

author: zapta
author_rank: Super Contributor
timestamp: May 20, 2015, 04:02:34 am
content: Quote from: Christe4nM on May 19, 2015, 11:53:16 pmI am using lpcxpresso and am very happy with it. Easy to install (a single package includes the IDE and the toolchain) and works on Mac, Linux and Windows. It supports the standard eclipse C++ features as well an optional hardware debugger as well as other stuff I don't use.Not sure though what is available for ST.

author: mikerj
author_rank: Super Contributor
timestamp: May 20, 2015, 07:57:36 am
content: Keil every time, unless I had to pay for the licence out of my own pocketIt's one of the best development tools I've worked with, and produces very well optimised code. In the last 5 years we've only experienced one significant bug in the compiler as well.

author: gmb42
author_rank: Frequent Contributor
timestamp: May 20, 2015, 11:07:38 am
content: I keep punting this, but no-one else seems to comment. For STM32 on Windows,ChibiStudiois an all-in-one install of Eclipse\GCC\OpenOCD along with Eclipse plugins to give insight into the ChibiOS parts.I haven't tried, but I think it's also good for a non-ChibiOS project as well.

author: AndyC_772
author_rank: Super Contributor
timestamp: May 20, 2015, 11:16:21 am
content: I chose CrossWorks about a year ago, and certainly don't consider it a 'poor' decision.

author: neslekkim
author_rank: Super Contributor
timestamp: May 20, 2015, 03:21:10 pm
content: Quote from: mikerj on May 20, 2015, 07:57:36 amWhat is the price of Keil for Arm?, only way to find out is to request a quote, and as an hobbyist I guess it's to expensive anyway, but it would be nice to know what it cost.I guess if one buy the pro or standard, that one can compile to any arm mcu?, but do one have to pay yearly fee?

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 03:56:04 pm
content: Quote from: neslekkim on May 20, 2015, 03:21:10 pmFor me... I'm looking at $1500 for Rowley and $5000-6000 for Kiel.mikerj: That's good info and I guess I should look at getting the Kiel eval version today and see if there is anything signifigantly different. I had been concerned that if I stick with GCC now, I'll keep code portability to other tools, but in reality, the code should remain portable since I'm going to work off of the STM32 StdLib (pretty much sticking with STM32 for now, they offer the widest range of ARM parts that fit my needs for automotive)... The only things that would be unique are the startup and linkers, but the IDE pretty much handles those anyhow.There isn't anything I dislike about Rowley, I just want to make sure I'm on a platform that I can grow with. I'm slightly concerned about Rowley's forum being sparse, they don't get ANY love from STM at all, and I've been through 4 tool chains now, I'm ready to settle downAll the comments so far very appreciated!

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 04:06:13 pm
content: Quote from: gmb42 on May 20, 2015, 11:07:38 amTo be honest, I can't remember if Chibi or Coox is Chinese, but the documentation on one of them was enough to immediately deter me.As to Open and Free solutions, no offense, but that's the last thing I want. I want someone with a great sum of my money that I can bug if something has gone wrong. I pretty much require a paid solution. Eclipse in this instance is off-putting because it's great when it works but not ideal when you have to tinker with it.I'm migrating from 8bit PIC to 32bit ARM, I have ZERO time to tinker. I've got a project that I've got to get out the door and in production asap. The idea of using all free/open tools scares the crap out of me. I'm sure it's good stuff, but in this case I'm looking at Rowley or Kiel because I can have someone on the line.

author: Stigaard
author_rank: Contributor
timestamp: May 20, 2015, 04:12:53 pm
content: Following along with this thread does anyone have any experience with the Tasking compiler by Altium (http://www.tasking.com/products/arm/) is that any good ?

author: peter.mitchell
author_rank: Super Contributor
timestamp: May 20, 2015, 04:13:52 pm
content: if you're a hobbyist and you're just using STM32s, buy a set of discovery boards and activate the codes, and you get 3 years free keil, i can't remember what the size limit is for M4 but i know for M0/M0+ its 256k which is huge for m0

author: gmb42
author_rank: Frequent Contributor
timestamp: May 20, 2015, 04:52:35 pm
content: Quote from: jnz on May 20, 2015, 04:06:13 pmChibi is the RTOS, Giovanni, the ChibiOS dev, has produced ChibiStudio as an easy means of getting a full featured Eclipse\GCC based dev environment on Windows.Quote from: jnz on May 20, 2015, 04:06:13 pmChibiOS itself is available under a commercial licence with support, but the IDE\toolchain is your standard Open Source\GPL offering.Personally, I don't mind paying for good commercial tools as in-use they can make my life a lot easier, but I've always been disappointed when it comes to support for them. I've found that if you can get the vendor to take an interest in your case, then you often have to be prepared to wait a long time for a fix until it fits into their commercial release cycle.I've never used Crossworks so can't comment on their support for their own products, although I've looked at it from time to time as it does seem to offer a good environment.I have noted though that Crossworks usesstandard GCC\LLVM-Clangfor the toolchain (with a little patch for the section names and some debug info) so although the vendor might appear to offer support, I would suspect any bugs in the toolchain will be deferred to the GCC\LLVM maintainers.

author: nctnico
author_rank: Super Contributor
timestamp: May 20, 2015, 05:24:08 pm
content: Quote from: jnz on May 20, 2015, 04:06:13 pmIn that case you better spend your money on someone who can setup an environment and write some base code to give your project a head start. The people at Rowley and Keil won't be able to write code for your project. Either way you will have to spend time to learn how to work with the IDE whether it is Eclipse or not.

author: zapta
author_rank: Super Contributor
timestamp: May 20, 2015, 05:27:03 pm
content: Quote from: neslekkim on May 20, 2015, 03:21:10 pmUsing a free tool will make your hobby projects more useful if you will decide to open source them.

author: AlfBaz
author_rank: Super Contributor
timestamp: May 20, 2015, 05:50:49 pm
content: My 2 cents is what are you getting for those price tags when gcc and eclipse are free.Sure you may spend some time getting to know the compiler, gdb, openocd and eclipse but if you aren't in some business situation, spending a week learning the aforementioned tools to save your self 1500 bucks has to be worth it, especially since you nearly always get caught up with some problem that requires you to delve into the tool chain's innards and the settings for most ide's generally require you to know these things anywayGetting back to what you are getting for the price, how do the compilers compare in speed and size optimisation, what do they offer in tweaked pre-compiled libraries, for example microchip claim their math libraries are miles ahead of the standard libs with regard to speed.I've been using gcc and eclipse for a while now and one of the benefits that came with learning the tool chains was not having to wait for the supplier of the ide to update it so you can use new parts simply because you don't know how to set up the source files supplied by the chip vendors

author: AndyC_772
author_rank: Super Contributor
timestamp: May 20, 2015, 06:07:50 pm
content: I wasted far more than $1500 worth of time trying to set up Eclipse, gcc and a debugger, and failing.I don't doubt that the software is theoretically very capable, but I'd urge anyone advocating it to take the usual internet advice of "do a search", and take a look at what documentation a Google search actually returns. There's a huge amount of stuff out there that's irrelevant, outdated, hard to navigate, or otherwise just plain useless unless you already know what you're looking for and where to find it.If I were still 16 years old with a computer, no money, and a lot of free time on my hands, then maybe I'd have persevered for longer, but I'm not. I'm a professional engineer with a job to do, and time is money.I bought CrossWorks, installed it, and it worked. I was immediately able to plug my PC into a dev board, download some compiled C code to it, and debug it. No issues at all once I'd got beyond the "wow, that's a lot of icons" stage.A year later it still "just works", and when I do need tech support, I have someone to email or call, and it's actually their job to answer. None of this "post on a support forum and hope" crap.The underlying compiler is gcc, so its code should be identical to any other IDE that uses gcc.

author: neslekkim
author_rank: Super Contributor
timestamp: May 20, 2015, 06:26:26 pm
content: Quote from: peter.mitchell on May 20, 2015, 04:13:52 pmWow, which codes?, I have loads of discoveryboards and nucleoboards, I only found unlocked keil for the lower end nucleo's, nothing for m4 (I want to try to compile .net micro framework for .net)

author: neslekkim
author_rank: Super Contributor
timestamp: May 20, 2015, 06:27:49 pm
content: Quote from: zapta on May 20, 2015, 05:27:03 pmtrue, and I want to do that for most things, but rumours has it that gcc optimizes not enought for getting the .net mf on an netduino, but I have to try it.

author: neslekkim
author_rank: Super Contributor
timestamp: May 20, 2015, 06:31:02 pm
content: Quote from: AndyC_772 on May 20, 2015, 06:07:50 pmInterresting, and their prices are good also, for personal license, only $150, that is good for that kind of use, and upgrade if one go commercial (which I don't think I am going to do)But Keil have no prices on their site, and I don't want to get bothered with pushy email.

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 06:35:31 pm
content: Quote from: neslekkim on May 20, 2015, 06:26:26 pmI think he's talking about the $350 dev boards, not the discovery or Nucleo boards (which now own). I'd be willing to pick up the $350 boards and get rolling... But now I'm looking at Kiel and seeing they offer middleWare in the Pro edition that I could use almost immediately (USB Host and USB Device), then soon after that (TCP and Webserver).So now I just went from Rowley is great and only $1500 to, "I wonder if I can get my company to swing $9k/8k euro". This actually might be the cheapest solution for me... MDK Pro offers an RTOS, and all the middleware I could utilize (assuming it's good) and I don't need to shop other vendors.

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 06:38:46 pm
content: Quote from: AndyC_772 on May 20, 2015, 06:07:50 pmYou and I are 1000000% in agreement!!The only difference, and I'll elaborate in my PM response is that you are a hardware engineer and I'm a software. With my need for the middleware Kiel provides, that's actually looking like a far cheaper solution than Rowley + CTL or OpenRTOS + a TCP and Webserver stack + USB Host stack + FileSystem, etc.The other issue I feel is likely unique to me, is that I'm a one person team. Hardware, PC Software, Firmware, sourcing, development, prototyping, testing/validation are all on me. In this instance, I'm starting to feel that Kiel might be the go to.

author: nctnico
author_rank: Super Contributor
timestamp: May 20, 2015, 06:41:10 pm
content: Quote from: AndyC_772 on May 20, 2015, 06:07:50 pmYou wrote that a couple of times but if Eclipse was really that hard to setup it wouldn't be so extremely popular. When I setup Eclipse for the first time I just followed a tutorial and made sure I had the same versions. From there it's just copying and extending your knowledge.A random Google find:http://gnuarmeclipse.livius.net/blog/test-project/

author: Jeroen3
author_rank: Super Contributor
timestamp: May 20, 2015, 07:54:36 pm
content: Open source is only free if your time is worthless. Right?I use keil, because Keil is ARM. It's not free. MDK-standard is € 3950,-...back in 2012... for when I asked a single user non-profit license.Apart from the simplistic notepad it features, it does its job as it's supposed to. With plenty of documentation on the toolchain athttp://infocenter.arm.com.Keil also makes quality dev-boards for a variety of platforms. And uses very decent ulink or segger programmers. Also not free. (yet there are clones)I must admit, on x64 it sometimes suddenly stops rendering the ui. But I'm still on the latest uvision V4 for project compatibility reason. Why upgrade when it works?Why isn't this a poll?

author: nctnico
author_rank: Super Contributor
timestamp: May 20, 2015, 11:42:01 pm
content: 3950 euro for a gloryfied notepad? Shudder... I have used Keil's uVision4 as well but it really is stuck in the 80's. I know from my own experience it can do a little bit more than what notepad does but uVision4 doesn't stand a chance when compared to Eclipse. IMHO uVision4 is a prime example on an afterthought IDE tinkered together by interns.There are some really big companies behind Eclipse like IBM, Google and Oracle. They all had the same problem: no decent IDE so they joined forces and built one. There is proper documentation and if you want support then IBM is happy to sell you support for using Eclipse:http://www-03.ibm.com/software/products/nl/ratielitsuppforecliI'm pretty sure you can get paid support from other parties as well.

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 11:42:52 pm
content: Quote from: Jeroen3 on May 20, 2015, 07:54:36 pmGood info on Kiel. Currently the direction I'm leaning. A big factor I hadn't considered was the middleware in the Pro version. I looked at the examples source and it looked just too easy to pass up.Poll.... Yea. That would have been a good idea. I guess it's too easy to just click the poll for your favorite and not really add to the conversation though. For example, I'm not looking at $9500 for Kiel Pro with Middleware, which is outright ridiculous to a hobbyist, but if spending that lets me get my product going even a single month ahead of me coding everything it would be worth it. Although it would really end up being close to six months more realistically.Yea, I'll need to go to the CFO and propose we spend this, it'll be a battle, but in the end, all anyone will remember is that we have a great new product shipping and I did that. The pain of spending money now will soon be forgotten.I want to go with Rowley, but they are a little lite on examples and right now those are how I'm learning the fastest. I'd be starting a day1 search for the middleware I'll eventually need and when I find it - who even knows if it works right away in Rowley? If I was doing smaller projects OR I had a team of people working on it, Rowley seems the better solution. But just me responsible for every aspect of the product, I think I'm going to go with Kiel.

author: jnz
author_rank: Frequent Contributor
timestamp: May 20, 2015, 11:48:04 pm
content: Quote from: nctnico on May 20, 2015, 11:42:01 pmWell... Let's not be hyperbolic here... KIel's cost is for support, updates, the official ARM compiler, the RTX RTOS, debugger, etc etc, and then the IDE.Perhaps you can elaborate the specific features has that Eclipse has that Kiel does not?Does uV4 not balloon variable values on mouse over? Does it not have a code complete? Can you not quickly find function/variable declaration or instances? I've seen many people write how superior X is over Y and then fail to give specific tools or features they themselves use to come to that conclusion.

author: HackedFridgeMagnet
author_rank: Super Contributor
timestamp: May 21, 2015, 12:06:39 am
content: Nice thing about this thread is that most people are very happy with the tools they are using.I use eclipse cdt with gcc. Works for me.

author: c4757p
author_rank: Super Contributor
timestamp: May 21, 2015, 12:14:56 am
content: Quote from: jnz on May 20, 2015, 11:48:04 pmNone of those are worth money anyway...

author: nctnico
author_rank: Super Contributor
timestamp: May 21, 2015, 12:30:12 am
content: Quote from: jnz on May 20, 2015, 11:48:04 pmIIRC uVision4 can show a list with functions in a file and I think you can jump to a function by clicking on it. I forgot whether it can do the more advanced things you listed. The 5 minute video on this page sums up the 4 features of the uVision editor:http://www.keil.com/uvision/ide_edt.aspBesides the features you list Eclipse can do a lot more. For starters Eclipse supports many programming languages so you can have an FPGA project together with the embedded C code and C++ PC application projects in one environment (workspace). Add a web or Java application if you want. Except for the FPGA code all software debugs in the same environment in the same way. With Eclipse you only have to learn one environment for software development. Then there is integration with various version management systems, keeping a list of TODO tags, real-time syntax checking, variable renaming (refactoring), comparing files & shuffling changes back and forth, keeping a local history of changes to a file (and compare the changes you have made since a certain point), having multiple build targets, call hierarchy, highly configurable code formatting (Eclipse formats my code the way I want it while I type), matching brackets/braces/etc highlighting, coloring existing members of structs and classes, compiler settings per file or exclude a file from compiling, show the body of a function in a pop-up when you hover over the name so you don't have switch to a different file to look it up, smart struct/class member completion (even when it is a C++ template based variable), make sense of the Linux kernel and other huge C/C++ projects, being able to work with multiple people on one project. These are just a few features from the top of my head but there are so many other clever little things built into Eclipse which make life easier .For me it is also handy that Eclipse is cross-platform to the extreme. Because the projects are interchangeable between platforms I can open the same project in Windows to build a Windows executable from a project I develop in Linux.

author: zapta
author_rank: Super Contributor
timestamp: May 21, 2015, 04:02:01 am
content: Quote from: HackedFridgeMagnet on May 21, 2015, 12:06:39 amNot good enough, you also need to ridicule the other products.

author: donotdespisethesnake
author_rank: Super Contributor
timestamp: May 21, 2015, 09:34:21 am
content: At work we use both Keil and Eclipse based tools. Keil has aways been solid and reliable, if a bit "old fashioned". There was one issue I had, which I raised a ticket for, and a few weeks later they fixed it and invited me to download a new version, so I was quite pleased with the support.Eclipse OTOH has been a lot more problematic, even though it is a version provided and supported by Freescale with Freescale plugins. We've had lots of funny issues, colleagues and I spend hours sifting through maze of options and settings, trying to get it to build right. Sometimes we have to rebuild the workspace to get projects working again, after some weird thing happens. Debugging can get into a right mess.With Keil, I can write code and trust it does the right thing. With Eclipse, I'm never quite sure. Eclipse does have some nice sugar features, none that I really need. Some prefer Eclipse, that's fine, but I think objectively it has taken us a lot more effort driving the tool compared to other tools.

author: nctnico
author_rank: Super Contributor
timestamp: May 21, 2015, 10:24:12 am
content: It depends on the version of Eclipse. The last couple of versions are stable without quirks so it could help to update Eclipse. I have also used Freescale's Eclipse based Codewarrior 10.3 but I have a feeling they messed a couple of things up in Eclipse or it is an older version of Eclipse.

author: Kjelt
author_rank: Super Contributor
timestamp: May 21, 2015, 11:40:13 am
content: I think there are two points in this discussion that needs seperation:- Compiler- IDEI have used the Keil and IAR compilers the last years on the job and both are excellent IMO.The IDE is a personal preference, and you can use Eclipse on top of Keil or IAR as long as you let it call the make files or scripting, works fine.Debugging is different there you will have to use the compilers IDE AFAIK.

author: Jeroen3
author_rank: Super Contributor
timestamp: May 21, 2015, 01:29:01 pm
content: Quote from: Kjelt on May 21, 2015, 11:40:13 amThe correct term would be:-Project Environment, the makefile.-Editor, with the fancy autocomplete and syntax highlighting and analysis.-Toolchain, the compiler/linker/debuggerAn IDE features all of them in oneIntegratedDevelopmentEnvironment.Eclipse is only the first two, and is molded into an IDE by anyone interested, to get LPCExpresso, Chibistudio or CodeWarrior.Keil uVision is an inseparable IDE. (due to licensing you cannot use the toolchain without project environment)

author: Christe4nM
author_rank: Unknown
timestamp: May 21, 2015, 08:47:08 pm
content: I read through the thread and just for a clear discussion: Keil (not Kiel btw) uVision 5 is the current version.In the end what counts for me when deciding to put down money on such a product is what it costs vs. what it will solve. For example I bought a professional license for Altium because I want to focus on my job and don't want to tinker with the tool's inabilities and quirks. Not to say Altium or in this case Keil, IAR, GCC or Rowley tools don't have quirks, but when I run into a problem I pick up the phone, or if less urgent send a mail to the support team and they respond to get me going.Be aware that costs you a yearly support fee. But for a company that should be next to nill compared what it costs if an engineer can't continue their work. Or for example when errors are made or overlooked due to characteristics of a certain tool.That's also the way to sell it to the boss or CFO. It's an investment to gain in the end.I'm a more of hardware guy, so if I really needed to spend a lot of time on firmware development I wouldn't hesitate to aquire one of the mentioned IDEs and look for middleware libraries that are proven and have good support.In the end it's your own opinion that matter a if a certain IDE works for you. So again: do test them.On a final note, it is true that I do see a lot of MCU vendor provided example code and demos that have at least a version for Keil next to the vendor's own IDE.edit: typos (stupid autocorrect)

author: AlfBaz
author_rank: Super Contributor
timestamp: May 21, 2015, 10:18:10 pm
content: While we're breaking it down to simple constructs there's-Engineering and-BusinessMany an ideal engineering practice has been screwed over by business constraints and as this is, generally speaking, an engineering forum, I would of thought most would be espousing the virtues of knowing what the tools are doing, creating and how they are creating/translating their intentions in firmware rather than creating an idea in some high level abstraction, pressing a button on the toolbar and watching shit magically happen on your pcb.The latter sounds more like a consumer tool than an engineering oneInvesting time and money on knowing your engineering craft seems like good engineering to me

author: Christe4nM
author_rank: Unknown
timestamp: May 21, 2015, 11:24:08 pm
content: Quote from: AlfBaz on May 21, 2015, 10:18:10 pmI have no idea if your post is a direct reply to what I said. But I'd like to elaborate anyway.When it comes to design I would want my tools to work exactly as I need them to. In the case of a PCB design tool I need control from footprint to lengthmatching and everything in between. While I am in control so that I can do my design to the best I know how, I want a tool that works with me, supports what I want and fits my workflow in a way that enhances the process.Now I am not really experienced when it comes to embedded programming. So all the more reason for me to want to know what's going on. While I focus on my task at getting my MCU running I need to know that I can trust my compiler. Moreover I want an IDE that fits my workflow so I can focus on getting my code designed to the best I know how without being frustrated by quirks of the tool. For me as not hardcore/fulltime firmware/software developer I don't have a need to know the depths of the IDE and compiler. My embedded programming colleagues however do. In that I completely agree with knowing what happens under the hood.What I'm trying to say is that I'd rather pay (more) for the right screwdriver that never fails me so I can focus on where and how to put what screws in, instead of one that requires me to think about how to handle that &#%$! driver in such a way that it actually does the the job it was suposed to do in the first place: it should be an extension of my arm, right? (Please don't apply this example directly to any program mentioned in the thread as I intended this just as example)QuoteAgree 100%

author: nctnico
author_rank: Super Contributor
timestamp: May 22, 2015, 01:23:01 am
content: Quote from: Christe4nM on May 21, 2015, 11:24:08 pmUnfortunately paying more doesn't always get you a better tool. Note the remark I made earlier about IDEs developed by compiler vendors are usually an afterthought. Power users usually have their own build tools and workflow in place so for them a vendor specific IDE doesn't add any value to the product.

author: AlfBaz
author_rank: Super Contributor
timestamp: May 22, 2015, 01:57:14 am
content: I think it's reasonable not to want to futz around with the IDE. Unfortunately the IDE hides most of the compiler's workings (there's only so much GUI check boxes canconvenientlydo to handle all the command line flags and switches).Understanding the compiler, assembler, linker and it's scripts, the startup file, library linkage etc, etc isn't something that will come for free when purchasing a commercial offering... This will take time regardless of wether you pay or don't as surely paid support doesn't cover not reading the manual

author: Kjelt
author_rank: Super Contributor
timestamp: May 22, 2015, 07:45:32 am
content: Quote from: Jeroen3 on May 21, 2015, 01:29:01 pmok i stand correctedPersonally I don't understand why Keil and IAR have to cost that much money. For a large business the cost can even be a major pain if you look at the Keil license agreements (no global licenses, so pay for each continent)Esp. Keil which is part of Arm make their money from licensing the processor architectures the more free tools the more enthousiasts will jump on the wagon.Probably they don't want to kill competition from other compiler vendors.

author: miguelvp
author_rank: Super Contributor
timestamp: May 22, 2015, 08:40:25 am
content: How big is your program? because the free version of keil allows up to 32K I believe.

author: neslekkim
author_rank: Super Contributor
timestamp: May 22, 2015, 11:07:57 am
content: Quote from: miguelvp on May 22, 2015, 08:40:25 amBuilding things like these:https://github.com/netduino/netmfhttps://github.com/NETMF/netmf-interpreterwill not be an option, and is supposedly not working to well with gcc due to resulting size because of lack of optimizations. Maybe the newer gcc is better though.Not tried myself, but others in discusionthreads have sort of convinced me that it would not work, so I haven't put time into it yet..

author: nctnico
author_rank: Super Contributor
timestamp: May 22, 2015, 11:18:36 am
content: The latest ARM GCC (made by ARM) does optimise better but don't expect other tools to create smaller code. AFAIK ARM's own compiler is the only compiler which produces smaller code than GCC. I don't know if that still holds true for ARM's version of GCC.

author: Jeroen3
author_rank: Super Contributor
timestamp: May 22, 2015, 11:21:51 am
content: Keil and IAR are expensive because they are made by people working at a company.People are not free. A open source community is "free" and a foundation has paying members.If you're ever done a PC software project you will know how much time goes into one, and into the support after it.Keil could lower the price, but I doubt they'll expand their market. The market are mostly companies, and for companies keil isn't expensive.For home users half the price is still too high.For home, get gcc or get a sparrow license. (at your own risk of course)It's a myth that arm-gcc is far inferior to rvct.Here is someone comparnig them:http://tinyurl.com/nfa2qt5(C compilers for ARM benchmark AN0052 - Raisonance)

author: neslekkim
author_rank: Super Contributor
timestamp: May 22, 2015, 11:33:51 am
content: What is the price level on IAR?Crossworks seems to be in a better pricerange, everything up to $250ish I think is ok prices for hobbyists, at least I would pay that (unless you need to pay that each year), but $5000? no way..The newest netduino have an mcu with more memory, so it might not be an issue, I'm still waiting for it, plan is to try it after I get it. The point for netduino/micromf, is that its.. intepreted .net code, but one can hook up native code, if one recompiles the whole framework (seems like there are plans to make this easier later, so the problem might go away), but so far, for using say ws2812 strips, the best option is to go native like this:https://learn.adafruit.com/using-neopixels-with-netduino/overviewThey refer to gcc there, but on the netduino forum, the promote the rvct(or some letters like that, atleast some old version), but I guess I need to just try gcc to see how far I get (They also say that they haven't made all code compatible with gcc, only some parts that they stopped maintaining for some time ago, if I understand them correctly)Some comments about that here:http://forums.netduino.com/index.php?/topic/11856-native-development-options/?p=62730but it's also discussed elsewhere on that forum.

author: nctnico
author_rank: Super Contributor
timestamp: May 22, 2015, 11:43:16 am
content: As an addition to my earlier post: A mistake often made is comparing code size results while using GCC with a standard C library inteded for desktop and server applications. The document linked to by Jeroen3 also steps into that trap. If you pair GCC with a small C library (or even a micro-printf) you can create really small code. This is also an area where commercial microcontroller compiler vendors try to make a difference compared to their competitors.

author: neslekkim
author_rank: Super Contributor
timestamp: May 22, 2015, 12:10:24 pm
content: Quote from: nctnico on May 22, 2015, 11:43:16 amOk, so libraries follows the compiler/toolchain, not the mcu?, so it can just as well be an bloated gcc library that gives the codesize?In old old day, one had compilers that optimized and linked in only code that was used (I used TopSpeed modula2), and thus could reduce codesize, isn't things implemented like this in the mcu world?, or is it because the architecture of the libraries ties in too much so one cannot optimize out all unused code in the linking?

author: c4757p
author_rank: Super Contributor
timestamp: May 22, 2015, 12:25:02 pm
content: The linker does not include unused functions. Still, many of the functions themselves - which youhaveused - are quite large when intended for desktop applications.

author: nctnico
author_rank: Super Contributor
timestamp: May 22, 2015, 12:36:59 pm
content: Quote from: neslekkim on May 22, 2015, 12:10:24 pmYes. Fortunately the ARM GCC targetted for microcontrollers (maintained by ARM) comes with a microcontroller C library which itself has two flavours: regular and nano.https://launchpad.net/gcc-arm-embeddedThe Readme.txt has a paragraph about choosing libraries:https://launchpadlibrarian.net/200699979/readme.txtQuoteEvery linker I know only links in functions from a library which are actually used. This depends on how the library is compiled though (each function should be in it's own 'section').

author: neslekkim
author_rank: Super Contributor
timestamp: May 22, 2015, 12:53:29 pm
content: Quote from: c4757p on May 22, 2015, 12:25:02 pmWhatdoyousay?, do you mean that the libraries for gcc mcu toolchains are made for DESKTOP applications?

author: neslekkim
author_rank: Super Contributor
timestamp: May 22, 2015, 12:55:54 pm
content: Quote from: nctnico on May 22, 2015, 12:36:59 pmAh cool, lots of usefull info there, should have read this earlier

author: nctnico
author_rank: Super Contributor
timestamp: May 22, 2015, 01:28:03 pm
content: Quote from: neslekkim on May 22, 2015, 12:55:54 pmThis is one of the points where some of the compiler's hidden magic bytes itself in it's rear. When a compiler (or better said: toolchain) is compiled the relative paths to the standard include directories and libraries are hard coded into the compiler toolchain (=pre-processor, compiler, assembler, linker, etc) binaries. This is the reason why the compiler doesn't trip up when you write #include <stdlib.h>. In the end the compiler needs to know where to find this file.If you use a generic ARM GCC package it will probably come with libraries tailored for desktop/server applications. The compiler is perfectly fine for microcontrollers but you need to pair it up with a small C library (and associated header files) to get small code. When an ARM GCC compiler package is targeted for microcontrollers this pairing will already be done for you.

author: neslekkim
author_rank: Super Contributor
timestamp: May 23, 2015, 06:56:46 am
content: Btw, nobody is mentioning this?http://www.mikroe.com/mikroc/arm/Is it not worth it?

author: jerry507
author_rank: Regular Contributor
timestamp: May 26, 2015, 04:13:48 am
content: Work has Keil Pro. The middleware is great. If you just need to write some embedded code, gcc is fine. I personally don't really see the value proposition though. For 1k you can buy something and be up and running in a day with support. But if you want USB device, or especially host? TCPIP? Just get Keil Pro. Worth every dollar. The middleware is really where it's at.We also use IAR and I prefer it more. It has a great debugger interface that is better than uVision 4, can't say anything about 5.I think it's a waste of time to compare the editors of the different IDE's. We use Visual Studio Express to do all the editor stuff. Far easier to use than Eclipse with all the same features. We maintain both a solution and a IAR workspace, but the overhead is <30 seconds per file so the efficiency gained back from the editor makes it up. Besides, OP is asking about toolchains and not editors

author: Sal Ammoniac
author_rank: Super Contributor
timestamp: May 27, 2015, 07:02:04 am
content: I'm a big fan of Rowley CrossWorks. I've been using it for about 5 years now and it does everything I need. Since it's not based on Eclipse, it's very fast and the UI isn't as cluttered. The $150 personal license is also very nice.I wrote my own RTOS and write my own drivers, so I don't have any experience using the Rowley RTOS or drivers.

author: jimon
author_rank: Regular Contributor
timestamp: May 27, 2015, 09:42:06 am
content: With non embedded software development background, I've decided to stick with this humble setup :gcc-arm-none-eabiSTM32CubeFxOpenOCDQt Creator Bare Metalninja build systemgithubsourcetreeNotepad++Far File ManagerThis setup costs 0$ (+ 7$/month if you want private repos) and IMHO I'm much productive with it then with ARM Keil because :same IDE setup for AVR and x86 projectssame version control system across all projects regardless of architecturesame debugger across all architectures (even if I use lldb, is sort of gdb-ish)total understanding what's actually going on when I press build or runI understand that ARM Keil can cover some risks because you can say "it's not my problem, it's theirs (arm, avr, whatever)" and wait for arm to fix their ide/tools, but in my world I must deliver regardless if it's theirs or mine problem, so common shared setup helps with it because corner stones are also more or less shared

author: jnz
author_rank: Frequent Contributor
timestamp: May 27, 2015, 03:30:03 pm
content: Quote from: jerry507 on May 26, 2015, 04:13:48 amLuckily this is what I did. Kiel's IDE isn't as nice as Rowley's but imo for what I'm doing, Rowley was the wrong choice. I'm a one-man team responsible for everything electronic my company does. Keil Pro's middleware is a god-send so far. The RTX seems adequate and I won't be pushing all that hard. But to day one be up and running with USB Host with a FATsystem and have a Ethernet/TCP/Webserver on deck any time I want it... That's just not going to happen with almost anything else.I've had some stumbles in the past few days just wrapping my head around the new registers and all of the differences from PIC. But so far well worth the transition. I just finished PWM/Timers and I'll move over to CAN Bus next but I'm already laying out specs for the next round of products I'll make.uV5 is noticeably thin on extra features, but everything actually important seems to be there. Rowley was a VERY nice product, and if I was just doing easier stuff, like a micro per specific function (this one drives a motor, etc), that's what I would choose. Keil Pro is not cheap, but go big or go home, this isn't my hobby.Thanks to you and everyone else for the advice so far, I hope someone stumbling on this later will get something from it.

author: bombledmonk
author_rank: Regular Contributor
timestamp: May 27, 2015, 08:58:55 pm
content: It's only for posterity's sake now. From what I understand in talking to an FAE who works with ARM the 1 year licenses from Keil do not expire in the traditional sense. They simply stop providing upgrades/updates and restrict it from being reinstalled after the date of expiration. Otherwise it sounds like it's fully functional in perpetuity on the machine on which it was installed. Depending on the usage model this might make it much cheaper for someone.MDK-PRO-T-ND(1yr) $3,799.99 vsMDK-PRO-ND(perpetual) $9,499.98MDK-ARM-T-ND(1yr) $1,960.00 vsMDK-ARM-ND(perpetual) $4,894.99

author: photon
author_rank: Frequent Contributor
timestamp: June 01, 2015, 12:11:36 am
content: Quote from: nctnico on May 22, 2015, 12:36:59 pmRemoving dead code is not automatic in GCC. The exact flags to use are -fdata-sections -ffunction-sections -Wl,--gc-sections. It does not matter how the library is compiled. The option -ffunction-sections will put every function into its own section irregardless of how the library is compiled. Seehttp://stackoverflow.com/questions/6687630/c-c-gcc-ld-remove-unused-symbolsorhttps://www.eevblog.com/forum/microcontrollers/stm32f4-weird-disassembly-output/msg458876/#msg458876

author: nctnico
author_rank: Super Contributor
timestamp: June 01, 2015, 12:50:17 am
content: There are some drawbacks to using -ffunction-sections -Wl,--gc-sections because the linker is not always able to determine which code is really unused. That is why libraries (for any toolchain whether GCC or not I have seen so far) are always compiled like this (quoted from the Stackoverflow link):The standard libraries achieve the result you're after by splitting all of their functions into seperate object files, which are combined using ar. If you then link the resultant archive as a library (ie. give the option -l your_library to ld) then ld will only include the object files, and therefore the symbols, that are actually used.So yes, it does matter how the libraries are compiled.

author: AlfBaz
author_rank: Super Contributor
timestamp: June 01, 2015, 02:06:11 am
content: Quote from: nctnico on June 01, 2015, 12:50:17 amVery interesting.Having a quick look at the linker's map output I see the standard pre-compiled library functions have there own .section regardless having used -ffunction-sections or notQuoteI wasn't aware the compiler (or linker) could do this but looking at section headers of libgcc.a seems to show every function coming from it's own object file

author: photon
author_rank: Frequent Contributor
timestamp: June 01, 2015, 08:11:05 am
content: Quote from: nctnico on June 01, 2015, 12:50:17 amA .o file has sections and a symbol table. So if there are 2 functions, say alive and dead, in one section, the linker has the symbol name of the functions and the start address of the functions. But the linker does not know where either function ends because of jumps. Since the linker builds the final text section from the text sections of the .o files it links, it has no choice but to include the section containing both alive and dead even though dead is not used. Unless, of course, there is only one function in a section. Certainly one function in one .o file satisfies this. Another solution would be to have the library maintainer compile the library with -ffunction-sections.

author: AndyC_772
author_rank: Super Contributor
timestamp: June 01, 2015, 08:28:23 am
content: Quote from: jerry507 on May 26, 2015, 04:13:48 amIs that where the real value is in the more expensive tools, then?I've been using Rowley for the last year or so, and haven't had cause to think "I wish this tool had feature X". But then again, I'm writing single purpose, embedded code which runs on bare metal.What I am missing, is the ability to implement higher level functions without considerable effort. For example, a while back I bought an STM32F4 dev board, which can be programmed by plugging it into a USB port and dragging & dropping a firmware file straight to the drive icon which appears on the Windows desktop.I wouldn't have the first clue where to start implementing a feature like this on my own product. Suggestions?

author: imanhp
author_rank: Newbie
timestamp: August 02, 2015, 10:45:55 pm
content: I would strongly consider using visulgdb (http://visualgdb.com/) for Visual Studio (uses GCC compiler). Note: I am not affiliated to visualgdb in any way.Look at these tutorials:http://visualgdb.com/tutorials/arm/stm32/adc/orhttp://visualgdb.com/tutorials/I think (correct me if am wrong) only Keil is the only other debugger that has built in visual graphing of live debug data as a part of the debugger. One of my favorite debugger features.I recently did a evaluation of all of the current ARM development tools for STMicros and visualgdb+VS came up on top.Visual Studio is bar none the best IDE for software development. And the VS debugger is very powerful.http://visualgdb.com/debugging/Debugging in my experience is the most important part of any toolchain. Writing 10k+ lines of code is easy. You spend most of you time trying to figure out what wrong with the code.We do pretty much all of our development i Visual Studio no matter the target platform today. We do Xamarin C# cross platform apps for tablets/phones, C/C++/C# windows/linux apps and recently we started working with the visualgdb addon for VS for STMicro and Nordic Semi chips. It works like a charm. I literally got started in 5-10 minutes. It installs all of the package for you.Its not uncommon that our developers make visualization/configuration software for most of the embedded projects that we do. With visualgdb there is no more context switching between different IDEs. I just love it and all of the developers here dropped the other IDEs/tools after giving this a go.Get it. Try it and hopefully you will like it.

author: Brutte
author_rank: Frequent Contributor
timestamp: August 03, 2015, 03:19:21 pm
content: Quote from: imanhp on August 02, 2015, 10:45:55 pmSorry, I cannot see how this visualGDB is different from any rawGDB.. I do not have VisualStudio so it is hard to say how it works by just reading their website, anyway - thanks for the links.First I thought VisualGDB is just a VisualStudio plug-in that prettyfies the semihosted output, displaying hex values as plots.. But now it seems this is a standalone software compiled for specific targets (cortex M, x86, MSP430, ARM11, etc). Does the tool instrument the code actually? If that is the case then it is an intrusive (data) tracing and the tracing available in uVision is non-intrusive thus that is like comparing apples and oranges.BTW,Atollic TrueStudio(Cortex-M), andSTMStudio(STM32) also doesnon-intrusivetracing.

author: technix
author_rank: Super Contributor
timestamp: August 03, 2015, 05:19:47 pm
content: I am not going to use either of them if I have the option. The go-to C/C++ compiler targeting ARM (and x86/amd64 BTW) for me is LLVM/clang. It compiles faster, have better optimization especially link time optimization, and have better debug output.I have once forced Arduino IDE to use the Apple-supplied version of clang to build code for ATSAM3X8E, another ARM MCU like STM32.

author: briselec
author_rank: Regular Contributor
timestamp: August 03, 2015, 09:16:49 pm
content: Quote from: nctnico on May 22, 2015, 11:43:16 amUm, did you actually look at the document - go straight to the conclusions and it states they didn't use printf with GNU coming out on top in 6 of the 8 tests.

author: nctnico
author_rank: Super Contributor
timestamp: August 03, 2015, 09:54:20 pm
content: Quote from: briselec on August 03, 2015, 09:16:49 pmYou mean this document:http://tinyurl.com/nfa2qt5?It's not about printf but the overall size of the library. Just removing printf doesn't remove every part linked in from the C library. You can argue whether a C library is part of a toolchain or not. You can basically bolt any C library onto a toolchain depending on whether you want the most features or reduced code size. In some of my projects I use a barebone printf which compiles to next to nothing in code size.

author: jnz
author_rank: Frequent Contributor
timestamp: August 05, 2015, 06:30:49 pm
content: THREAD UPDATE:So, I started this thread in May and I've been using Keil Pro for about 2 months now. I can confidently say, if I had selected Clang, or OpenWhatever, or GCC with free tools, there is just not a chance in hell I'd be where I am now. There have been huge challenges learning the new systems, getting to an RTOS, and all the peripherals I'm using. I can easily understand SFRs and datasheets, but it's just faster to learn with the libraries. The middleware so far has been great and "just works" (how often can we get to say that with micros!?). I do understand the limitations with Keil's IDE and some are annoying, but at the end of the day, I chose correctly. It was just too easy to pay the cash and jump ahead. I'm not even close to hitting performance walls, so take that for what it's worth. If I was an needed to optimize, I can go back and start working with SFRs and assembly again.This is my work tho, and the only thing I actually care about is being able to deliver a working and reliable product. If I was a hobbyist, or mainly a hardware guy, I think my time testing Rowley was great.Quote from: AndyC_772 on June 01, 2015, 08:28:23 amFlat out, I've been able to integrate USB Host which I had never done before within a month of switching to ARM from Microchip. I'm a one-man team, so I'm pretty pleased with Keil so far. Support could be faster, esp for the price, but I've only needed it once really.

author: Jeroen3
author_rank: Super Contributor
timestamp: August 05, 2015, 06:42:19 pm
content: Quote from: jnz on August 05, 2015, 06:30:49 pmThan indeed you have not have time to worry and debug the toolchain and open source libraries. Good choice. Is the client/boss also happy with the progress?They tend to be more cheapskate in terms of buying "non-physical" tools, not sure why. Most likely because the progress is difficult to see.And most important: did your ulink ever fail?

author: jnz
author_rank: Frequent Contributor
timestamp: August 05, 2015, 06:56:24 pm
content: Quote from: Jeroen3 on August 05, 2015, 06:42:19 pmYes, I'm happyIf anyone else at my company even knew what I did they would be happy too. I'm making good progress so, yea, that's all that's important. It wasn't super hard sell, because I pretty much said this is what it'll cost and that's that. I could have saved a few thousand with other options, but no I'm pretty sure I did what was best for everyone. I can imagine it would be an almost impossible sell at a lot of companies though.Never bought a ulinkI picked up a Segger Ultra+ on day one. There is a slight issue getting that to printf() over ITM, but once that was solved it's been a really great tool so far.

author: ilg
author_rank: Newbie
timestamp: October 06, 2015, 09:27:03 am
content: For a fair level of STM32 support, you can also consider the GNU ARM Eclipsehttp://gnuarmeclipse.github.ioproject.It provides not only managed build support for GCC under Eclipse, but also SEGGER J-Link debugging support, ready to run templates for all STM32 families, several STM32 boards emulated in QEMU, etc.A blinky project tutorial is available fromhttp://gnuarmeclipse.github.io/tutorials/blinky-arm/.The project is open source and is hosted on GitHubhttps://github.com/gnuarmeclipse.

author: richardman
author_rank: Frequent Contributor
timestamp: October 08, 2015, 09:14:43 pm
content: I have been bantering our tools over at the epic "5 pages and counting" thread on the for sale forum. Please check it out, there is a large segment between "We love GCC even if it is not free" and "We don't mind paying $8000 for IAR/Keil" and that's the market we are targeting (as long as you don't mind Windows). $99 get you started with complete hardware, software, and even a C reference book.http://c4everyone.com

author: miguelvp
author_rank: Super Contributor
timestamp: October 08, 2015, 10:36:06 pm
content: Does your compiler support all of the STM32 chips? M7, M4F, M3, M0+ & M0?I don't think the OP ever specified what flavour of the STM32 family he was planning to use.

author: richardman
author_rank: Frequent Contributor
timestamp: October 08, 2015, 11:55:02 pm
content: Quote from: miguelvp on October 08, 2015, 10:36:06 pmCurrently M0 and M3. You can use the M4 as a fast M3. We will add the M4 floating point support in Oct/Nov