Which IDE for STM32F4?? - Page 1
Forum section: electronics / general

author: Magnum
author_rank: Regular Contributor
timestamp: November 02, 2017, 07:53:55 pm
content: Hello,until now I was only working with Arduinos using their IDE and UECIDE.Now I bought a reference board with a STM32F415 and don't know which IDE to use. The examples for the board were made with KEIL MDK, but that software seems to be quite expensive if the code exceeds 32kb. Which (free) IDE can be recommended?Many thanks.Magnus

author: Kjelt
author_rank: Super Contributor
timestamp: November 02, 2017, 09:28:37 pm
content: Although not the best if you want free you are best off IMO with the STCube (peripheral configuration / library) and SW4STM (sytem workbench) which is a free IDE, compiler from ST.

author: ebclr
author_rank: Super Contributor
timestamp: November 02, 2017, 09:34:47 pm
content: You can run a free KEIL on the cloud with mbedhttps://www.mbed.com/en/You have many choiceshttp://www.st.com/content/st_com/en/extended-query.html?querycriteria=productId=LN1200$$associatedTo=SS1577

author: sevenTech
author_rank: Contributor
timestamp: November 02, 2017, 10:04:12 pm
content: I must also highly recommend System Workbench (aka AC6). If you are learning with ST mcus, you will probably download firmware pack for your board (STM Cube will download it for you)...inside you can find variety of examples for your discovery board for Keil, Attolic and system workbench (inside folder named SW4STM32).You can simply import these pre-created project, build and flash and it should work...no more work needed.If I shall write about power of IDEs like System workbench or Attolic I must note that they are both eclipse-based. It can be difficult to learn at first - eclipse is really huge IDE ecosystem - it can be used for HTML, java, PHP, python...Even in corporations these eclipse based IDEs are used frequently. Even in times I used to work in ST we used ARM modified eclipse IDE.Difference between Attolic and System workbench and other eclipse based IDEs is mainly that they use eclipse as the core IDE and pack it with set of plugins. Attolic is more commercial based for advanced tasks like profiling etc and system workbench is developed by ST to ease development with ST mcus. So you import project and after that debugger, compiler should work..no more hassle.Maybe Keil can be simpler for start...but the flexibility of eclipse based IDE cannot be beaten

author: rstofer
author_rank: Super Contributor
timestamp: November 02, 2017, 10:15:18 pm
content: Get a copy of "Mastering STM32" and follow along. You will install Eclipse and GCC. The toolchain will install easily.https://leanpub.com/mastering-stm32There is a PDF on the Internet. I think it is a subset but I didn't check carefully because I own the book.

author: Magnum
author_rank: Regular Contributor
timestamp: November 02, 2017, 11:19:55 pm
content: Thank you for all the feedback.I installed the Keil MDK, I can load the project but unfortunately it is too big. I can modify the code to make it smaller, but then I won't be able to go back to the original anymore.I installed now the System workbench, but I am not quite sure if it supports my processor (STM32F415).Many thanks for your replies.

author: donotdespisethesnake
author_rank: Super Contributor
timestamp: November 02, 2017, 11:25:28 pm
content: System Workbench from AC6. Eclipse is pretty much taking over as standard IDE for MCUs. It's not necessarily to everyone's liking, but once you find how to navigate the quirks you can apply the knowledge to other Eclipse based IDEs. You also have the choice of rolling your own from scratch, using a pre-package free version, or a pre-package subscription version. Erich Styger's blog is fantastic if you go anywhere near Eclipse, and even if you don'thttps://mcuoneclipse.com/Otherwise traditional IDEs such as Keil, IAR, Crossworks etc are more or less expensive but have good support and limited free/cheap versions.mBed is OK if you don't need debug, and don't mind losing all your work or having random service outages.

author: bobaruni
author_rank: Regular Contributor
timestamp: November 03, 2017, 04:14:56 am
content: Very fast to install and use and it's free.https://www.embitz.org/

author: newbrain
author_rank: Super Contributor
timestamp: November 03, 2017, 07:57:04 am
content: For free IDEs you've already got a number of good suggestions.One thing to add about Atollic True Studio vs. System Workbench is that the former supports many different (ARM) MCUs, while he latter is STM32 specific. If one decides to switch vendor or widen one's MCU knowledge, there's no need to relearn the quirks of a vendor specific IDE.If you are on Windows and not opposed to fork out a reasonable amount of money, my personal preference isVisualGDBonVisual Studio: VS is a top level IDE (Community edition is free as in beer), and VGDB bridges it towards GDB and GCC in a mostly seamless way.If a large and complex IDE is not to your liking, you might also considerVisual Studio Code: it's an Open Source, multi platform (Windows, OS-X and Linux) editor, lightweight, fast and very flexible.To use it as a MCU development environment, though, one needs to do some plumbing: install an ARM gcc/gbd, OpenOCD, the STM Cube and a couple of needed extensions, and also prepare a basic project and Makefile.

author: martinayotte
author_rank: Regular Contributor
timestamp: November 03, 2017, 01:41:30 pm
content: There is also stm32duino.com

author: mbless
author_rank: Regular Contributor
timestamp: November 03, 2017, 03:33:11 pm
content: Quote from: rstofer on November 02, 2017, 10:15:18 pmI second this.

author: Magnum
author_rank: Regular Contributor
timestamp: November 04, 2017, 01:41:24 pm
content: Thanks for all the suggestions. But it seems I am stuck. All IDEs I tested don't support the STM32F415. As this one is on the board I have to use I have to get KEIL running. The code is approx 2kB too large for the free edition to compile.I am also trying to find a different board but with no success yet.The board I am using is a MAXIM MAXREFDES67. It can measure voltage, current and temperature (type K). It has a 24bit ADC with a effective resolution of approx. 22bits. The boards needs keyboard inputs via serial for the setup, I want to modify the code that I can communicate with it via SPI. Shouldn't be a big deal if I get Keil running.

author: mubes
author_rank: Regular Contributor
timestamp: November 04, 2017, 01:49:32 pm
content: I'm surprised no one has mentionedhttps://gnu-mcu-eclipse.github.io...or perhaps I missed it. It's very powerful and will do everything you need. By definition it's Free.RegardsDave

author: alterbaron
author_rank: Contributor
timestamp: November 04, 2017, 07:36:10 pm
content: I'd suggest using OpenOCD, gcc/gdb and Visual Studio Code.I'd also suggest using CMake for build tooling.VS code can integrate with gdb, so you can do in-circuit debugging, inspection of variable values, stepping, breakpoints .etc from within the GUI, though personally, I prefer to use gdb from the shell.If you use CMake, you can get a free extension for VS code that can read your CMakeLists file, automatically populate info for intellisense, and allow you to build with the push of a button. It's also easy to script post-build operations using CMake, for instance, reporting the executable size, generating annotated assembly, flashing firmware, .etc

author: mrm2007
author_rank: Contributor
timestamp: November 08, 2017, 12:07:58 pm
content: Quote from: Magnum on November 04, 2017, 01:41:24 pmHi,Are you sure?With STM32SW , i can easily create a new project with STM32F415 ,OGY , RTG,VGT ,ZGT Series MCUs.I also use EmBitz and it support STM32F415 like STM32SW.I also checked the Keil, and Keil support for stm32F415 is also same as SWM32SW.

author: Gabri74
author_rank: Regular Contributor
timestamp: November 08, 2017, 01:40:56 pm
content: Quote from: Magnum on November 04, 2017, 01:41:24 pmAtollic True Studio supports it on the latest update (8.1).The free version does not have any compile/debug limitation but will display an nag screen from time to time asking you to upgrade to the pro version (which has some advanced debugging/profiling capabilities)It's multi platform (I'm using it on Linux).A side node regarding Keil uVision: you can easily find keygen to unlock it on the internet, but Ihighlydiscourage to do so because at least one is known to be a trojan and with all the free tools available I don't think it's worth the risk.Moreover the Keil project format, although being in xml readable format, it's a complete mess and is really difficult to use under version control or to export to build on other tools in the future.

author: Magnum
author_rank: Regular Contributor
timestamp: November 10, 2017, 12:11:08 pm
content: Thanks for the info, I'll recheck Atollic and STM32SW.

author: apurvdate
author_rank: Contributor
timestamp: November 11, 2017, 06:15:12 am
content: there is also CooCox IDE..i tried it for blinky n serial comm for my stm32F401 nucleo board..but i shifted to TI's TM4C so didn't spend much time with it later..

author: knapik
author_rank: Regular Contributor
timestamp: November 11, 2017, 06:46:35 am
content: I bought an STM32F4 board a little while back and have recently gotten the time to play around with. I couldn't stand the ads in Atollic, but I'm quite happy with System Workbench.

author: AndyC_772
author_rank: Super Contributor
timestamp: November 11, 2017, 07:20:27 am
content: For completeness, I'd highly recommend checking out CrossWorks.Not free, but at US$150 for the personal non-commercial licence it's extraordinarily good value for what you get:http://www.rowley.co.uk/arm/

author: Siwastaja
author_rank: Super Contributor
timestamp: November 11, 2017, 11:30:08 am
content: A capable text editor of your choice, make, and gcc.Plusses:- Quick and easy start- Well standardized, well known and documented- Perfectly portable in any workflow, easily shared with others- No time wasted trying to reverse engineer through what the IDE does behind your back- What you learn is directly applicable with any computer or MCU architectureMinuses:- Can't think of any

author: technix
author_rank: Super Contributor
timestamp: November 11, 2017, 12:51:40 pm
content: My personal favorite stack is stock Eclipse CDT + GNU MCU Eclipse + GCC ARM Embedded + OpenOCD + GDB.The code generated by Cube tend to be fairly bloated. You can take hints from their code, but third party libraries and a rewrite usually results in much smaller code (at the same optimization level. First-hand experience on STM32F042 USB stack which takes 13kB using Cube but 5kB using third party USB stack and rewritten pin mux driver.)

author: AndyC_772
author_rank: Super Contributor
timestamp: November 11, 2017, 06:52:08 pm
content: Quote from: Siwastaja on November 11, 2017, 11:30:08 amPlease can you post a link to a clear, up-to-date and accurate description of how to get started compiling and debugging code on a specific processor using this method?

author: Siwastaja
author_rank: Super Contributor
timestamp: November 11, 2017, 10:06:59 pm
content: Quote from: AndyC_772 on November 11, 2017, 06:52:08 pmNo! Now that you say that, I realize I was 100% bullshitting right there without even realizing it. For example, with STM32, it took about half a year of absolute and total pain I thought I'd never forget, but somehow apparentlydidforget after all. I wish I could go back in time and tell the past myself: "you'll be okay, don't give up, and psst: the issue is that the linker scripts on that Swedish Ubuntu guy's website are broken, initializing the stack pointer incorrectly aligned!"Yeah, I think I was delusional while writing that, mixing up reality and wishful thinking.I think what I wrote is kind of idealistic, but due to total lack of simple, up-to-date documentation and simple installation packages, the inherentlymore complexchoice of multitude of often vendor specific IDEs end up giving a much quicker and less painful start. Probably simply because that's what they are developed for and tested against.So, what I said should never be said to a beginner. I grew up through the IDEs, too, and I guess today the path is kind of Arduino --> bloat libraries & bloat IDEs --> questioning them --> learning.(Lately, my projects have been becoming so complex and big, that any setup time has become irrelevant. At the same time, I have gained more experience, and I'm starting to find the "bare" ways most efficient, forgetting that when I was a beginner, itwaseasier to just click a few buttons without knowing what's going on.)Sorry.

author: AndyC_772
author_rank: Super Contributor
timestamp: November 12, 2017, 09:22:16 am
content: LolI'msoglad it's not just me that's had no success at all getting a free IDE up and running in a timely manner.CrossWorks uses gcc under the hood, but that's not what you're paying for. You're paying for the UI which allows you to just specify what you want to do, and it works out the arcane and cryptic syntax needed to make things happen.My customer, after all, is paying for (say) an STM32 project with a boot loader and some reserved Flash memory for persistent configuration settings - not three weeks learning where to put the dots in the right place in a linker script.

author: Siwastaja
author_rank: Super Contributor
timestamp: November 12, 2017, 11:32:02 am
content: Quote from: AndyC_772 on November 12, 2017, 09:22:16 amOn the other hand, once you have done it a few times, you start to understand how it works, and after that, something great happens:gcc, ld and make (and gdb, but I don't use debugger very often) have been there for decades, and there are no signs whatsoever that they would be phased out in the MCU development; quite the opposite, everybody seems to be migrating towards them (as a backend).Now,ifyou know how to use them directly, you are free from the confusion caused by:* Multitude of totally differently working IDEs depending on which product family you end up with-> knowhow of direct usage of GNU tools allows you to better jump between families* Changing "this years trend IDE" culture* New versions working differently to the old ones* Front end bugs* Front end doing things people "usually want" behind your backI admit this is kind of idealistic and simplified goal, but I took the bullet and amveryhappy right now that I did.The one guy who recently did themassiveand totally awesome comparison of sub $1 MCUs of 2017 got me thinking: there must be a better way.Mostof the article was comparing how the development flow of writing C code goes in different product segments even though it was basically all doing the same job: writing C code. Today, we depend too much on code generation and tools that assist typing, when we should concentrate on creatinghigh-quality code, including high-quality headers, libraries etc. that solve the problem on the source level (C is good enough for that, really!) instead of interactive text editing level.So really, I feel like this is an issue where:* Direct, raw use of the backend tools have a steep learning curve, but it really gives valuable experience, and itreallygets easier after that (I'm surprised at this myself):Code:+---------------------------||||||||----+* Using them through IDEs softens the learning curve quite a bit, but then you need to keep learning new IDEs, new details about them, and, worst, each time something doesn't quite work out automatically, you are yet again looking for help how to solve it through that IDE.Code:+------------|+------------|+------------|+------------|----+Yes, I fought about half a year to get the understanding how to use the backend tools directly and separately.But after that, it has been extremely simple, in fact, FUN, to do things people often consider difficult, like building custom bootloaders, utilizing secondary scratchpad memories, relocating vector tables, doing persistent flash storage, etc., all without help of device-specific libraries or device-specific tool documentation. In fact, if I had to do it the way people "usually" do it, I have no idea where I'd even start. There is no standard way. The way I do it is closest to universal, and anybody can modify the code and just run make without configuring anything, without having to install and learn the right "development environment".The funny thing is, all the pain and agony I went through could beeasilyfixed just by writing some basic tutorials, with simple examples. But since very few people are seeing it from the same viewpoint as I am, no one writes it (except that Swedish Ubuntu guy who made it too complex and had it completely wrong. Still, I'm very grateful). (It's worth noting there never was any issue with the actual installation of the tools; my source files were faulty since I had no idea how to do them - but now I have. It's great when you don't depend on the actual tool installation being right, but everything is contained in your actual sources as much as possible!)But everyone writes tutorials on what IDE buttons to click - which should be something not needing an explanation at all if the IDEs were properly designed to do the job they exist for - be an user interface to soften the backend usability.--Today, my customers are paying for experience, so I want to gather even more of it. After being a hobbyist for a long time, I started at very low hourly rates, barely getting something to eat, in non-time-critical projects, gaining experience, compensating for the fact that sometimes I was stuck, maybe for weeks, learning how to do it in a sustainable way, instead of just doing a "quick solution". Now I consider myself "mid-experienced". I'm starting to see the extrapolation that after a few years, I can provide very quick, flexible services exactly because of the experience and knowhow, relying on any specific tool as little as possible - I never want to be a one trick pony. (OTOH, you have to rely on something; but I find it'smuch more sustainableto understand and memorize a few common gcc flags, than to understand what hidden buttons to click in a this years favorite IDE to achieve the same, or to depend on code generation tools, which tend to be seriously broken year after year.)But I understand very well that talking about steep learning curves and giving promises like: "it will get easy after that big mountain!!" is not motivating. In school we were learning the German language, and our teacher mostly wanted to focus on all the details of grammar, making it sound more complex than it really was, and people didn't like it. We were given motivational speeches roughly like this:"Afterthisgrand grammar hurdle, it gets super duper easy and we'll have fun speaking German fluently and everybody's singing and dancing in class".But when the same pattern repeated year after year, we realized that the fun times weren't coming, the "big mountain" was always in the front of us, again and again.So I promise, going without any IDEs will get easy, unlike our German classes! Trust me..... or maybe just follow the majority and forget about what I'm doing. Maybe I just like to work differently.

author: CM800
author_rank: Frequent Contributor
timestamp: November 12, 2017, 06:23:56 pm
content: I've really enjoyed using Visual GDB, very reasonably priced + student discount.

author: emax
author_rank: Contributor
timestamp: November 15, 2017, 07:45:48 pm
content: I haven't seen which platform shall be used.I am on linux.> A capable text editor of your choice, make, and gcc.Agree. I use emacs as my "IDE" and for everything else. Even for the current C++ project (> 340k lines of code).Siwastaja is totally right: It takes a while to get through all those backend-tools, make, scons, the gnu compolier, the linker whatsoever. But once you've made it, you're the king of the build.There is gdb, which has no buttons and no 'klicki-bunti' gimmicks, but it is very powerful. There is etags/ctags for quick-finding references. There is tags-query-replace, doxygen and a zillion other things which completely substitute and even outperform nowadays IDEs in terms of speed and flexibility.I am doing this for a living, and after having had a lot of hassle with new eclipse-versions, died IDE-projects, missing packages for a particular platform and many other obstacles, I decided to throw away all those fancy and smart IDEs, and to just use the basic things you really need.To be clear: I am mainly developing server-things. But the surprising thing was, that I was quickly able to adopt my knowledge to any embedded platform as well, and it took only very little time. I did this for stm32F104, for the 8051 family, and for ATmegas as well: Though there are variations, it is always the same workflow. I do not any more depend on code::blocks, netbeans, avrstudio, visual studio and all those other monsters (Eclipse basic-installation was more than 500 megabytes already then 10 years ago). I can even develop java-applications that way, always based on the same procedures and knowledge. There, you might use ant instead of make or scons, javac instead of gcc or g++, jar instead of linkable libraries. But the conecpt always stays the same and that makes you widely independent from any IDE - policies and compatibility issues.The only thing I was really missing was the code-coverage feature from Keil/Franklin. But I am quite sure, this can be done within the toolchain of emacs/gnu-c and c++/ld as well - if I'd spend the time to collect the tools.However: Just learning emacs is already a major task. One can use it within an hour, ok. But unleashing all the power is a thing I haven't yet completely mastered - after 25 years of utilization (my first emacs was version 17.36, today I use 24.5.1). It is in any case a long-term-investment which pays off.Stunningly, the editor works basically still the same after a quarter of a century. This tells a lot.But it's not only about the editor. I can combine any compiler with it, any build-system and any flash-loader. It can even run under windows (though not fun), it runs under solaris, aix and any *ix platform I know.Yes, there is no 'setup.exe'. But it's worth the effort, and I encourage everybody to give it a try (though one should be stubborn enough to overcome the unavoidable frustrations which this might bring at a first glance).And by the way: If some package or library is missing in a toolchain, it usually takes less then five minutes to get this installed from the repositories in question.And the community is tremendous - and beatsanyhotline.And now you know where my nickname comes from.

author: emax
author_rank: Contributor
timestamp: November 16, 2017, 01:01:08 pm
content: I want to second Siwastaja once more:Quote from: Siwastaja link=topic=97948.msg1347478#msg1347478This depicts depicts a problem of which many developers are just not aware: Compilers evolve with increasing speed. And in particular the c++ world is affected by a number of changes which makes it hard for companies like Keil/Franklin (is it still Franklin?) to keep up with the progress.It is simply too expensive to maintain an own compiler in that way that they can compete with the latest features of benchmarkers like g++/gcc. Ask them for C++11, C++14, C++17 or C++20. I don't believe that they will be able to support all that new stuff.Keil-C is a ultra-high optimizing compiler, probably more than gnu-c can be - as long as you look at the 8051 family. I do not know whether the arm-optimization is similarly good. But if it comes to more general requirements, and this is what I guess will become more and more important, the may be quickly out of the business. Software is nowadays a much more complex and costly thing than it was in times of a 'closed' embedded solution somewhere in a metal-box.Today, IoT is there, and zillions of embedded appplications will require connectivity and web-interfaces and the like in the future. I doubt that highest code-optimization will then have such a strong priority than connectivity and versatility. Processors are faster today, have more ressources and different challenges than a decade ago.To come back to topic: I guess, that going more and more to gnu-backends is kind of a capitulation in face of these trends. Why invest in a never ending-challenge if the solution is already there? The times of making money whith proprietary (non-) standards (Keil) is over in the open-source-software world.The conclusion is -of course- simple: Join the winners. I wouldn't (yet) say is such hard, but the basic message is perhaps "If you are sitting on a dead horse, you should dismount."As opposed to a (proprietary) IDE, an editor, a debugger and a de-facto standard compiler is timeless. It will always be the core of any workflow.

author: technix
author_rank: Super Contributor
timestamp: November 16, 2017, 05:13:49 pm
content: Quote from: emax on November 16, 2017, 01:01:08 pmEven to this day Keil have zero plan on supporting anything newer than the partial support of C99 in their compilers. The new ARMCC version 6 is really LLVM with a Keil branding and retargeted assembler. For me accumulated code since a good portion of it uses C11, I am locked out of Keil toolings and have to use GCC, LLVM or SDCC (for 8051.)Quote from: emax on November 16, 2017, 01:01:08 pmThere wasa benchmark by Raisonanceindicating that in most likelyhood Keil is the worst performing ARM compiler. GCC on the other hand is striking firsts in a good selection of benchmarks. GCC suffers from an less optimized C standard library but that can be done away with much easier than compiler itself being underperforming.Quote from: emax on November 16, 2017, 01:01:08 pmPeople even put Python and Lua onto microcontrollers... I think the efficiency argument is long out of the window when Python comes in play.Quote from: emax on November 16, 2017, 01:01:08 pmI second that. Although if you really want to use an IDE (for example if you us symbolic debugger a lot like I do) you can try stock Eclipse CDT plus GNU MCU Eclipse plugin, managing the GDB debugger.

author: andyturk
author_rank: Frequent Contributor
timestamp: November 16, 2017, 07:12:40 pm
content: Quote from: emax on November 15, 2017, 07:45:48 pmMe too.I've been using emacs regularly for the past 30+ years. I used to have two screens (27" Apple displays) at work and people would occasionally stand behind my desk and mumble when I had 8 emacs panes covering each display.The only recent problem I've run into with emacs as a development environment is getting it to mesh nicely with Clang/LLVM. Specifically, the support for LLDB isn't great (and R. Stallman believes LLVM is evil), so debugging C++ on macos is not quite as easy as I'd like.For embedded work, I've been using Segger's Ozone since it came out. It provides a really useful graphical debugger. The GUI part works well (even to my text-mode eyes) because it lets me see register contents and disassembly in real time. IMO, Ozone and J-Link are better than the openocd+gdb combo that I used to use.Maybe we should start an emacs thread. ;-)

author: hermit
author_rank: Frequent Contributor
timestamp: November 16, 2017, 08:08:17 pm
content: Quote from: andyturk on November 16, 2017, 07:12:40 pmMake it vi and I'm in.

author: IuriC
author_rank: Contributor
timestamp: November 17, 2017, 03:12:37 am
content: QuoteIt's really sad that no such tutorials are easily found... I did pass the same experience too.

author: Arjen_Arg
author_rank: Contributor
timestamp: November 22, 2017, 03:41:36 am
content: yeah, you guys got us all hooked, make that tutorial!

author: technix
author_rank: Super Contributor
timestamp: November 22, 2017, 07:19:35 am
content: Quote from: Arjen_Arg on November 22, 2017, 03:41:36 amI am going to write one but on my blog. Will update once I get the posts up.

author: IuriC
author_rank: Contributor
timestamp: November 22, 2017, 10:49:59 pm
content: Quote from: technix on November 22, 2017, 07:19:35 amRemember to post it here too!

author: technix
author_rank: Super Contributor
timestamp: November 23, 2017, 05:21:57 am
content: Quote from: IuriC on November 22, 2017, 10:49:59 pmI will only post links here, please read on my blog. (I don't have ads yet, but good analytics will boost my chances of negotiating a better deal.)

author: Totoxa
author_rank: Newbie
timestamp: November 23, 2017, 07:35:06 pm
content: I use Code::Blocks for PIC18 and ARM's programming, works fine and its lightweight

author: humbug11
author_rank: Newbie
timestamp: November 29, 2017, 10:44:21 am
content: I use Qt Creator with external make files. You can set it up to use GDB for debugging, it's quite neat.Sent from my A0001 using Tapatalk

author: Arjen_Arg
author_rank: Contributor
timestamp: November 29, 2017, 04:06:06 pm
content: I'm giving Eclipse + GCC a shot. So far I'm finding it interesting, but way more complicated to setup that the usual all in one compiling debugging IDE. I guess it boils down to how much time you have to invest in the journey. I have used IAR for STM32 before, the interface is horrible, but it's easy to get started. I'm moving away from that because of the code size limitation.

author: technix
author_rank: Super Contributor
timestamp: December 01, 2017, 08:19:50 am
content: https://en.maxchan.info/arm-development-with-eclipse-cdt-part-1.htmlThe first part of my GCC+Eclipse STM32F4 tutorial. This series will cover environment setup, processor startup (without assembler,) SysTick, GPIO, serial port (with newlib stdio support and thus printf,) I2C, SPI, FSMC EBI and USB, all without touching the ST libraries.