<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="pandoc" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <title>Release Notes for STM32F0xx CMSIS</title>
  <style>
    code{white-space: pre-wrap;}
    span.smallcaps{font-variant: small-caps;}
    span.underline{text-decoration: underline;}
    div.column{display: inline-block; vertical-align: top; width: 50%;}
    div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
    ul.task-list{list-style: none;}
    .display.math{display: block; text-align: center; margin: 0.5rem auto;}
  </style>
  <link rel="stylesheet" href="_htmresc/mini-st.css" />
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="row">
<div class="col-sm-12 col-lg-4">
<div class="card fluid">
<div class="sectione dark">
<center>
<h1 id="release-notes-for-stm32f0xx-cmsis"><strong>Release Notes for STM32F0xx CMSIS</strong></h1>
<p>Copyright © 2016 STMicroelectronics<br />
</p>
<a href="https://www.st.com" class="logo"><img src="./_htmresc/st_logo.png" alt="ST logo" /></a>
</center>
</div>
</div>
<h1 id="license"><strong>License</strong></h1>
This software component is licensed by ST under BSD 3-Clause license, the “License”; You may not use this component except in compliance with the License. You may obtain a copy of the License at:
<center>
<a href="https://opensource.org/licenses/BSD-3-Clause">https://opensource.org/licenses/BSD-3-Clause</a>
</center>
</div>
<section id="update-history" class="col-sm-12 col-lg-8">
<h1><strong>Update History</strong></h1>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_6" aria-hidden="true"> <label for="collapse-section2_3_6" aria-hidden="true"><strong>V2.3.6 / 23-July-2021</strong></label>
<h2 id="main-changes">Main Changes</h2>
<ul>
<li>General updates
<ul>
<li>CAN updates
<ul>
<li>Remove extra CAN filters: bit fields 14..27</li>
</ul></li>
<li>Added new atomic register access macros in stm32f0xx.h file.</li>
<li>Add new defined value for LSI maximum startup time: LSI_STARTUP_TIME.</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_5" aria-hidden="true"> <label for="collapse-section2_3_5" aria-hidden="true"><strong>V2.3.5 / 06-November-2020</strong></label>
<h2 id="main-changes-1">Main Changes</h2>
<ul>
<li>General updates
<ul>
<li>Update stm32f030xc.h header file to be aligned with RCC_CFGR bit definition.</li>
<li>Rename the defined STM32 sub-family “STM32F048x6” to “STM32F048xx”</li>
<li>Add License.md and Readme.md files required for GitHub publication.</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_4" aria-hidden="true"> <label for="collapse-section2_3_4" aria-hidden="true"><strong>V2.3.4 / 12-September-2019</strong></label>
<h2 id="main-changes-2">Main Changes</h2>
<ul>
<li>General updates
<ul>
<li>Align ErrorStatus typedef to common error handling (stm32f0xx.h)</li>
<li>SystemInit(): update to don’t reset RCC registers to its reset values.</li>
<li>USE UL postfix for _Msk definitions and momory/peripheral base addresses for MISRA C 2012 Compliance</li>
</ul></li>
<li>Rename macro definition IS_USB_ALL_INSTANCE to IS_PCD_ALL_INSTANCE.</li>
<li>Add macro definition IS_GPIO_AF_INSTANCE for stm32f030xc devices</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_3" aria-hidden="true"> <label for="collapse-section2_3_3" aria-hidden="true"><strong>V2.3.3 / 25-August-2017</strong></label>
<h2 id="main-changes-3">Main Changes</h2>
<ul>
<li>Remove support of Atollic TrueSTUDIO STM32 (TrueSTUDIO) toolchain.</li>
<li>Performance improvement of the startup code for GCC.</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_2" aria-hidden="true"> <label for="collapse-section2_3_2" aria-hidden="true"><strong>V2.3.2 / 07-April-2017</strong></label>
<h2 id="main-changes-4">Main Changes</h2>
<ul>
<li>Rename GPIO_AFRH and GPIO_AFRL bitfields for alignment with all STM32 series.</li>
<li>Add macro definition : IS_TIM_ADVANCED.</li>
<li>Rename RTC_CR register bit definition to be aligned with STM32F0xx Reference Manual : RTC_CR_BCK ==&gt; RTC_CR_BKP</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_1" aria-hidden="true"> <label for="collapse-section2_3_1" aria-hidden="true"><strong>V2.3.1 / 04-November-2016</strong></label>
<h2 id="main-changes-5">Main Changes</h2>
<ul>
<li>Add TIM6_IRQHandler in vectors table for STM32F030x8 devices</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_3_0" aria-hidden="true"> <label for="collapse-section2_3_0" aria-hidden="true"><strong>V2.3.0 / 27-May-2016</strong></label>
<h2 id="main-changes-6">Main Changes</h2>
<ul>
<li>General updates
<ul>
<li>Updated CMSIS Device compliancy with MISRA C 2004 rules:
<ul>
<li>MISRA C 2004 rule 10.5 (bitwise operators ~ and &lt;&lt;).</li>
<li>MISRA C 2004 rule 10.6 (‘U’ suffix applied to all constants of ‘unsigned’ type).</li>
</ul></li>
<li>Updated system_stm32f3xx.h/.c files:
<ul>
<li>Added AHBPrescTable definition as external.</li>
<li>Added APBPrescTable definition as external.</li>
</ul></li>
</ul></li>
<li>EXTI updates
<ul>
<li>Added definitions of bit 31 in EXTI registers for STM32F04x, STM32F078xx and STM32F098xx devices.</li>
</ul></li>
<li>I2C updates
<ul>
<li>Added IS_I2C_WAKEUP_FROMSTOP_INSTANCE definition for I2C instances supporting Wakeup from Stop mode.</li>
</ul></li>
<li>I2S updates
<ul>
<li>Removed SPI_I2S prescaler register not supported by STM32F030x6 and STM32F030x8 devices.</li>
</ul></li>
<li>RCC updates
<ul>
<li>Added missing RCC_CFGR_PLLNODIV definition for STM32F030x4/6 devices.</li>
</ul></li>
<li>RTC updates
<ul>
<li>Removed cast from RTC_BKP_NUMBER definition.</li>
</ul></li>
<li>SYSCFG updates
<ul>
<li>Renamed SYSCFG_CFGR1_IRDA_ENV_SEL bit definitions to SYSCFG_CFGR1_IR_MOD for SYSCFG_CFGR1 register.</li>
</ul></li>
<li>TIM updates
<ul>
<li>Added IS_TIM_HALL_SENSOR_INTERFACE_INSTANCE definition.</li>
<li>Added IS_TIM_ETR_INSTANCE definition.</li>
</ul></li>
<li>UART updates
<ul>
<li>Renamed IS_UART_WAKEUP_INSTANCE to IS_UART_WAKEUP_FROMSTOP_INSTANCE.</li>
</ul></li>
<li>USART updates
<ul>
<li>Defined USART_ISR_RWU bit for all STM32F0xx devices.</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_2_3" aria-hidden="true"> <label for="collapse-section2_2_3" aria-hidden="true"><strong>V2.2.3 / 29-January-2016</strong></label>
<h2 id="main-changes-7">Main Changes</h2>
<ul>
<li>Added mention to STM32F091xB mcus missing in the list of mcus of stm32f0xx.h.</li>
<li>Updated CMSIS Device compliancy with MISRA C 2004 rule 10.6.</li>
<li>Updated CMSIS Device compliancy with MISRA C 2004 rule 5.1.</li>
<li>Added HSI48_VALUE definition in system_stm32f0xx.c file.</li>
<li>Put variable AHBPrescTable as external in system_stm32f0xx.h.</li>
<li>Added channel selection bit definitions for for DMA1_CSELR register.</li>
<li>Used RCC_CFGR_MCOSEL as reference in all the families.</li>
<li>Renamed RCC_CFGR_MCOSEL_PLL to RCC_CFGR_MCOSEL_PLL_DIV2 for alignment between all families.</li>
<li>Updated EWUPx pins defintions for STM32F042x6 and STM32F048xx devices.</li>
<li>Added FLASHSIZE_BASE and UID_BASE defines.</li>
<li>Added missing bits definition for RTC_TAFCR register.</li>
<li>Added missing bits definition for I2C_OAR2 register (I2C_OAR2 mask values).</li>
<li>Renamed I2C_CR1_DFN to I2C_CR1_DNF bit definition for I2C_CR1 register.</li>
<li>Removed __IO or __I on constant table declaration.</li>
<li>Used default DAC instance naming DAC1 in macro IS_DAC_ALL_INSTANCE().</li>
<li>Aligned EXTI registers Bits naming between all families.</li>
<li>Aligned WWDG registers Bits naming between all families.</li>
<li>Aligned COMP common instance definition.</li>
<li>Corrected CRC defines: Replaced POL field by RESERVED3 for STM32F030x6, STM32F030x8, STM32F031x6, STM32F038xx, STM32F042x6, STM32F048xx devices.</li>
<li>Corrected CRC defines: Removed Bit definitions related to Polynomial in CRC_CR and CRC_POL registers for STM32F030xC.</li>
<li>Updated for ADC: removed conditions on CCR_TS definition.</li>
<li>Corrected SYSCFG_RTC_WAKEUP and SYSCFG_RTC_ALRA Bits definition for SYSCFG_xxx ISR Wrapper register.</li>
<li>Added ADC_CHSELR_CHSEL Bit definition for ADC_CHSELR register.</li>
<li>Removed RCC_CSR_V18PWRRSTF Bit definition for STM32F0x8xx devices.</li>
<li>Corrected USART defines for STM32F030xx, STM32F070xx devices.</li>
<li>Removed IS_UART_AUTOBAUDRATE_DETECTION_INSTANCE macro definition.</li>
<li>Adapted IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE to device feature support.</li>
<li>Removed IS_UART_DRIVER_ENABLE_INSTANCE definition for STM32F030x8, STM32F030xC and STM32F070xB devices.</li>
<li>Corrected FLASH_OBR_nBOOT0 value.</li>
<li>Removed Synchronous mode support on USART5/6 for STM32F030xC.</li>
<li>Removed HW Flow Control support on USART5/6/7/8 for STM32F091xC.</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_2_2" aria-hidden="true"> <label for="collapse-section2_2_2" aria-hidden="true"><strong>V2.2.2 / 26-June-2015</strong></label>
<h2 id="main-changes-8">Main Changes</h2>
<ul>
<li>Add missing WUT bits in EXTI_IMR/EMR/RTSR/FTSR/PR/SWIER for different IT lines.</li>
<li>Add preprocessor compilation switch #define STM32F0 in stm32f0xx.h.</li>
<li>Correct FLASH_KEY name difference between STM32F0 and STM32F3.</li>
<li>Remove RCC_CFGR3_USART2SW from CMSIS, present only for STM32F07x and STM32F09x.</li>
<li>Modify EXTI/COMP defines from uint16 to uint32.</li>
<li>Add missing definitions of EXTI_IMR_MR31 used by PWREx in stm32f042x6 and stm32f048xx files.</li>
<li>Add FLASH_BANK1_END defines.</li>
<li>Remove WRP defines for few defines under devices swicthes.</li>
<li>Add FLASH_OBR_RAM_PARITY_CHECK and FLASH_OBR_BOOT_SEL CMSIS files.</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_2_1" aria-hidden="true"> <label for="collapse-section2_2_1" aria-hidden="true"><strong>V2.2.1 / 09-January-2015</strong></label>
<h2 id="main-changes-9">Main Changes</h2>
<ul>
<li>system_stm32f0xx.c: replace wrong compilation switch STM32F078xB by STM32F078xx.</li>
<li>stm32F070xb.h: correct wrong DMA remap mask value for STM32f070xB.</li>
<li>stm32F070xb.h, stm32F070x6.h, stm32F030xc.h: add missing macro IS_UART_DRIVER_ENABLE_INSTANCE()</li>
<li>stm32F070xb.h, stm32F030xc.h: add missing RTC periodic Wakeup register &amp; bits description</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_2_0" aria-hidden="true"> <label for="collapse-section2_2_0" aria-hidden="true"><strong>V2.2.0 / 05-December-2014</strong></label>
<h2 id="main-changes-10">Main Changes</h2>
<ul>
<li>Add CMSIS files for new STM32F0 value line devices: STM32F030xC and STM32F070x6/xB.</li>
<li>Add macro to check AF capability of gpio instance</li>
<li>uint32_t alignement done on all Peripheral registers structures &amp; bits definition</li>
<li>stm32f091xc.h: DMA channel remap register renamed for compatibility with other STM32 devices</li>
<li>startup_stm32f042x6.s &amp; startup_stm32f070x6.s: fix boot issue</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_1_0" aria-hidden="true"> <label for="collapse-section2_1_0" aria-hidden="true"><strong>V2.1.0 / 03-October-2014</strong></label>
<h2 id="main-changes-11">Main Changes</h2>
<ul>
<li>Add new CMSIS files for STM32F091xc and STM32F098xx products</li>
<li>VDDIO2 IRQ missing in F07xx/F09xx/F04xx product</li>
<li>IS_DAC_CHANNEL_INSTANCE macro removed as unused</li>
<li>uint32_t partial alignement done on peripheral Bit definition &amp; register structure</li>
<li>Bit definition name error for DMA_RMPCR1 register of STM32F091xC</li>
<li>Remove PDV feature on REGoff part</li>
<li>Remove POSITION_VAL macro as it uses RBIT, CLZ instructions, that are not supported by Cortex-M0</li>
<li>GPIOS BSRR regsiter should not be split in BSRRH/BSRRL</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_0_1" aria-hidden="true"> <label for="collapse-section2_0_1" aria-hidden="true"><strong>V2.0.1 / 18-June-2014</strong></label>
<h2 id="main-changes-12">Main Changes</h2>
<ul>
<li>General
<ul>
<li>Add new macros
<ul>
<li>IS_GPIO_LOCK_INSTANCE to check GPIO port with lock capability</li>
<li>IS_UART_HALFDUPLEX_INSTANCE, IS_UART_LIN_INSTANCE and IS_UART_WAKEUP_INSTANCE to check the UART instance supported features.</li>
</ul></li>
</ul></li>
<li>STM32F042x8 and STM32F048xx update
<ul>
<li>Rename DMA1_Channel4_5_6_7_IRQn to DMA1_Channel4_5_IRQn</li>
<li>Rename ADC1_COMP_IRQn to ADC1_IRQn</li>
<li>Remove SPI2 instance</li>
</ul></li>
<li>STM32F051x8, STM32F058xx, STM32F071xB, STM32F072xB and STM32F078xx update
<ul>
<li>Fix COMP2 instance base address</li>
<li>Add new macro IS_COMP_DAC1SWITCH_INSTANCE to check COMP instance with switch of DAC1 channel1 output to non inverting input</li>
</ul></li>
<li>STM32F051x8 and STM32F058xx update
<ul>
<li>Rename DMA1_Channel4_5_6_7_IRQn to DMA1_Channel4_5_IRQn</li>
</ul></li>
<li>STM32F078xx update
<ul>
<li>Remove CAN peripheral description</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section2_0_0" aria-hidden="true"> <label for="collapse-section2_0_0" aria-hidden="true"><strong>V2.0.0 / 28-May-2014</strong></label>
<h2 id="main-changes-13">Main Changes</h2>
<ul>
<li>Major update based on STM32Cube specification: new CMSIS device files release dedicated to <strong>STM32F030x4/x6, STM32F030x8, STM32F031x4/x6, STM32F051x4/x6/x8, STM32F071x8/xB, STM32F042x4/x6, STM32F072x8/xB, STM32F038xx, STM32F048xx, STM32F058xx and STM32F078xx devices</strong>.</li>
<li><strong>This version has to be used for STM32CubeF0 based development although files can be used independently too</strong>.</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_2_1" aria-hidden="true"> <label for="collapse-section1_2_1" aria-hidden="true"><strong>V1.2.1 / 22-November-2013</strong></label>
<h2 id="main-changes-14">Main Changes</h2>
<ul>
<li>stm32f0xx.h
<ul>
<li>Update STM32F030 devices definition:
<ul>
<li>Remove the STM32F030X8 and STM32FO30X6 defines and replace them with the STM32F030 define</li>
</ul></li>
<li>Update IRQn enum for STM32F030 devices</li>
</ul></li>
<li>system_stm32f0xx.c
<ul>
<li>SystemInit(): update to support STM32F030 devices</li>
</ul></li>
<li>Remove the startup files startup_stm32f030x8.s and startup_stm32f030x6.s and replace them by startup_stm32f030.s, for EWARM, MDK-ARM and Truestudio supported compilers</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_2_0" aria-hidden="true"> <label for="collapse-section1_2_0" aria-hidden="true"><strong>V1.2.0 / 01-August-2013</strong></label>
<h2 id="main-changes-15">Main Changes</h2>
<ul>
<li>Add support of STM32F030 devices (STM32F030x8 and STM32F030x6 microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)</li>
<li>stm32f0xx.h
<ul>
<li>Update STM32F0xx devices definition:
<ul>
<li>Add new definition STM32F030X8 and STM32FO30X6 for STM32F030 devices</li>
</ul></li>
<li>Update IRQn enum for STM32F030 devices system_stm32f0xx.c SystemInit(): update to support STM32F030 devices Add new startup files, startup_stm32f030x8.s and startup_stm32f030x6.s, for EWARM, MDK-ARM and Truestudio supported compilers</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_1_1" aria-hidden="true"> <label for="collapse-section1_1_1" aria-hidden="true"><strong>V1.1.1 / 31-July-2013</strong></label>
<h2 id="main-changes-16">Main Changes</h2>
<ul>
<li>stm32f0xx.h
<ul>
<li>Extend HSE_STARTUP_TIMEOUT and HSI_STARTUP_TIMEOUT values to 0x5000</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_1_0" aria-hidden="true"> <label for="collapse-section1_1_0" aria-hidden="true"><strong>V1.1.0 / 10-May-2013</strong></label>
<h2 id="main-changes-17">Main Changes</h2>
<ul>
<li>Add support of STM32F0xx Low-density devices (STM32F050xx and STM32F060xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)</li>
<li>stm32f0xx.h
<ul>
<li>Update STM32F0xx devices definition:
<ul>
<li>Define for STM32F0xx Medium-density devices changed from STM32F0XX to STM32F0XX_MD</li>
<li>Add new definition STM32F0XX_LD for STM32F0xx Low-density devices</li>
</ul></li>
<li>Update IRQn enum for STM32F0XX_LD devices</li>
<li>Add new bits definition
<ul>
<li>RCC_CFGR register: MCOPRE[0:2] and PLLNODIV</li>
<li>SYSCFG_CFGR1 register: FMP_I2C1, FMP_PA9 and FMP_PA10</li>
</ul></li>
</ul></li>
<li>system_stm32f0xx.c
<ul>
<li>SystemInit(): update to reset new bits added in RCC_CFGR register</li>
</ul></li>
<li>Add new startup files, startup_stm32f0xx_ld.s, for the supported compilers</li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_0_2" aria-hidden="true"> <label for="collapse-section1_0_2" aria-hidden="true"><strong>V1.0.2 / 13-July-2012</strong></label>
<h2 id="main-changes-18">Main Changes</h2>
<ul>
<li>stm32f0xx.h
<ul>
<li>Fix issue with gcc_ride7 startup file</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_0_1" aria-hidden="true"> <label for="collapse-section1_0_1" aria-hidden="true"><strong>V1.0.1 / 20-April-2012</strong></label>
<h2 id="main-changes-19">Main Changes</h2>
<ul>
<li>stm32f0xx.h
<ul>
<li>Add reference to STM32F050xx (Flash memory up to 32 Kbytes) and STM32F051xx (Flash memory up to 64 Kbytes) devices</li>
<li>RTC register bits definition: remove reference to Tamper3</li>
</ul></li>
</ul>
</div>
<div class="collapse">
<input type="checkbox" id="collapse-section1_0_0" aria-hidden="true"> <label for="collapse-section1_0_0" aria-hidden="true"><strong>V1.0.0 / 04-September-2012</strong></label>
<h2 id="main-changes-20">Main Changes</h2>
<ul>
<li>First official release for <strong>STM32F30x</strong> devices (Standard Library)</li>
</ul>
</div>
</section>
</div>
<footer class="sticky">
For complete documentation on STM32 Microcontrollers </mark> , visit: <span style="font-color: blue;"><a href="http://www.st.com/stm32">www.st.com/stm32</a></span> <em>This release note uses up to date web standards and, for this reason, should not be opened with Internet Explorer but preferably with popular browsers such as Google Chrome, Mozilla Firefox, Opera or Microsoft Edge.</em>
</footer>
</body>
</html>
