Reddit mentions of The Definitive Guide to ARM® Cortex®-M3 and Cortex®-M4 Processors

+1 for Cortex-M (with FPUs). I'm building a guitar pedal with an STM32F407 and it handles 12x oversampled distortion and a bunch of biquads at 48kHz (mono). It is paired with a CS4272 audio codec with DMA handling the I2S data.

It won't handle any reasonable FIR filter and the RAM limits it to ~500ms delay. There is a discovery board with external RAM but I haven't tried using it.

The F7 series are clocked a bit faster and some come with a double precision FPU instead of single but they have the same instruction set as the F4s. The Cortex-M7 has a longer pipeline (6 Vs 3 stages, probably to support the higher clock rate) so branching is probably less of a penalty on the M4.

This book is an excellent guide to the low level guts of the Cortex-M3 & M4 chips and contains a chapter dedicated to DSP on the M4. Long story short is contains a bunch of DSP instructions such as saturating integer arithmetic, integer SIMD, floating point fused multiply-accumulate etc which makes it semi-competitive against "true" DSP cores. The book compares the M4 and Sharc DSP to show that there's a big jump between them but the M4 wins hands down for ease of learning & development (strong community, free (GNU) tools etc).

Edit: If you want hardware this audio codec can be paired with this STM32F7 kit or this motherboard paird with this STM32F4Discovery board can take it as well.

Hi,

I have two-part suggestion for you. Naturally, this is really just what I did to move from your shoes to where I am now (writing device drivers, and using real-time operating systems) on nice toolchains (sets of IDEs coupled with compilers and debugger interfaces).

The first thing you ought to do next is focus on learning C. ANSI C.

This is book to use: Introduction to Embedded Systems by David Russel

By actually stepping through the book, you'll get to learn what is embedded is all about, without having to learn a new debugging interface (because you won't have one), and without having to buy a new board.

The book uses the Arduino Uno board, and the Arduino IDE to teach you how to NOT use the Arduino API and libraries. This teaches you about the "building" process of C programs - the compilation, linking, bootlaoders, etc. You'll learn all the low level stuff, on a platform (The AT Mega 328p) that is easier to understand. You'll even get into making interrupt-based programs, a buffered serial driver, pulse-width modulation, input capture on timers etc.

Ever since having gone through the book, I've been able to move to other platforms, knowing that the ideas are essentially the same, but more involved. If you were to jump straight into the Arm Cortex-based 32 bit processors, you would feel rather overwhelmed by the complexity of the peripherals that typically get placed onto the same die. You would end up resorting to high level hardware abstraction libraries (like ST Microelectronic's horrid HAL) and MAYBE be able to use them, but you would have no idea what would actually be going on. As soon as a library stops working, you need to be able to know where it broke and why.

So do this patiently.

Start with the 8 bit micro on the Arduino using the book, using basic timers, basic interrupts, basic C types.


Only later, it is wise to pick up an ARM board to start experimenting with. These devices are powerful monsters that get work done. But you won't have an appreciation for what they and their powerful peripherals can do until you've wrestled with their simpler cousins on the AT Mega 328p.

You'll have to pick an IDE, (or none if you really want to know and understand the build process), a set of libraries to use (or none, if you want to learn the monster peripherals the hard way), and an operating system (or none, if you want to stick to bare-metal programs, but really, a 120 MHz cpu with all that power and no OS is sort of a waste).

I would recommend starting with the TIVA C series board from Texas Instruments. It's used in the very nicely paced Intro to ARM Microcontrollers by Jonathan Valvano.

That would be another book well worth the time to go through like a tutorial, because it is.

These book have also helped me along the way: Definitive Guide Cortex M3 Cortex M4 Processors by Joseph Yiu
and Computer Organization and Embedded Systems by Zvonko Vranesic.

If you want to explore this field, please be prepared to be patient. The learn curves here can be steep. But the things you'll be capable of making are incredible if you keep it up. I hope your exploration goes well!

https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/

Joseph Yiu's Definitive Guide to the Cortex M3/4 has some assembly, as does the ARM System Developer's Guide.

Or there's Hohl on ARM Assembly.

The books are possibly a bit dry also :)

http://www.amazon.com/Definitive-Cortex®-M3-Cortex®-M4-Processors-Edition/dp/0124080820

http://www.amazon.com/gp/aw/d/1558608745/ref=mp_s_a_1_1?qid=1449878782&sr=8-1&pi=SY200_QL40&keywords=arm+system+developer%27s+guide&dpPl=1&dpID=41JKM615IML&ref=plSrch

http://www.amazon.com/gp/aw/d/1439806101/ref=mp_s_a_1_2?qid=1449878829&sr=8-2&keywords=Hohl+arm+assembly&pi=SY200_QL40&dpPl=1&dpID=5180IPnBhvL&ref=plSrch

I enjoyed this book https://www.amazon.ca/Definitive-Guide-Cortex®-M3-Cortex®-M4-Processors/dp/0124080820, you're going to have to get acquainted with the technical reference manuals at arm's website also.

Fellow Embedded Engineer here.
You learn this from books: The Definitive Guide to ARM® Cortex®-M3 and Cortex®-M4 Processors.
And just RTFM of course: Cortex M4 technical reference manual.

And of course the chip vendors documentation, since there will be some implementation defined stuff (eg: which memory bank stuff will boot to).

Don't forget the compiler and linker documentation. Lot's stuff is there, just scrolling through once gives you so much more understanding, and what you might find there if your solving some problem later on. Like the special instructions, and the compiler flags and conditions for it to actually use the FPU.

If you're going to try this bare metal assembly programming, I'd recommend the Cortex M0, since an M4 often comes in a complex chip.