corguy - Is the ATmega the only microcontroller that you have experience of?
Do you only use Arduino libraries, or program through some other libraries, or does your code go directly to the hardware registers?
Why are you considering migrating? What do you see as the benefit of the STM32F-based Maple of the ATmega?
The STM32F103 is a more complex device than an ATmega.
1. The way that attachinterrupt works, and calls your code is comparable between the two microcontrollers and libraries. It is feasible to use more efficient ways of handling interrupts (on both microcontrollers), but that hasn't been completed in the Maple libraries (though the mechanism is their if you want to dig into it, and shave off every 13.9nS :-).
BUT there is extra complexity. The STM32F103 has the concept of interrupt priorities, which the ATmega does not have. So you may need to deal with the Nested vectored interrupt controller (NVIC), and consider how interrupts interact.
When the STM32F takes an interrupt, the hardware saves more registers than the ATmega, so even though the STM32F processor is much faster than the ATmega core, interrupt latency will be similar because of the extra data automatically saved, and there is nothing that can be done about this. IMHO, it is unlikely to be an issue as I'd expect the interrupt handler will probably execute faster on an STM32F.
2. The STM32F103 timers are much more sophisticated than the ones on ATmega's. STM32F103 timers can do everything that an ATmega timer can do and more. Fortunately, something like a 1 second timer with an interrupt can be handled by the Maple libraries without having to delve into the details of the hardware. The STM32F timers are all 16 bit (and can be linked to emulate a 32-bit count). The prescaler which divides the clock is 16 bits, so there is more flexibility on setting the count frequency than ATmega timers. There are more modes too. The Maple libraries give mre flexibility than Arduino libraries, but if you need to dig into the hardware of the timers, there is more to understand than the ATmega timers.
3. How do you use the analogue input on your ATmega? Do you only use the Arduino analogRead library function?
If that is the case, then, as robodude666 says, the Maple library is comparable, and you won't see any major difference other than 12bit resolution, and something like 15x faster. Having a very fast analogRead might cause issues if your code relies on the delay caused by the Arduino analogRead (of about 100microSeconds). If you code directly to the Analogue to Digital Converter (ADC) hardware on the ATmega, then the STM32F103 ADC is much more sophisticated. For example, the STM32F103 has more than 1 ADC, each ADC can be programmed to automatically scan inputs. So if you want to do anything other than a simple analogRead you'll have more complexity to understand, but have much more capability than an ATmega.
4. As robodude666 and crenn say, the SPI has been around for a while, and there are multiple SPI peripherals on Maple's STM32F.
Other than crenn's I2C libray, the Maple I2C library does not use the I2C hardware, but is software based. The STM32F is quite fast, so this is not necessarily an issue, but it depends on what you are doing. There are a bunch of hardware bugs mentioned in the Errata for the STM32F103 for the I2C hardware with workarounds, some of which require the I2C interrupts to run at the highest level (which may be inconvenient for you), others strongly recommend using DMA, which may be a significant change from what you are used to doing (If you have only used an Arduino). As well as LeafLabs staff, I know at least two people who have had trouble getting the I2C hardware peripheral to work properly. It is not as straightforward as the ATmega.
I am hoping that crenn's library will fix this.
As all of the Maple library source code is available, it is feasible for people to get to grips with direct control of the peripherals by using the source as examples. There is also quite an extensive set of examples from ST Micro, who make the STM3F103, but their code tends to be more generic and verbose (they make a range of microcontrollers), and some people find it harder to understand than the Maple libraries.
(full disclosure: I am not a member of LeafLabs staff)
