stm32f103c8 | c and c++ Makefile version | Build Tool library

I come across a problem when trying to run this code in order to blink the built-in LED (located at PC13) on the blue pill board (STM32F103C8, ARM Cortex M3):

I try to program an STM32F103C8 circuit. I use an ST-LINK V2 programmer. After running a sample of code that used special libraries, I was able to see the built-in LED ON, but now I want to program the board without using those libraries, and I don't know why I cannot see anything, the LED is OFF the whole time. Here is the code:

I'm using HAL_FLASHEx_Erase on stm32f103c8.

According to datasheet, Flash memory endurance is just 10k cycles.

my data is 16 bytes so i thought method how to use flash memory like little block with counter

before i notice it erase 1 page each time.

if i erase 1 page that having 16 bytes data at front

is all other bytes in page become lose there endurance cycle even it not written?

this is method what i thought

it use next frame when it lost there endurance

frame = data(16bytes) + counter(2bytes)

I'm learning low-level details of the STM32. I am puzzled by how the vector table is setup.

In the reference manual, table 63, it lists the STM32F103C8's vector table. It goes from 0x00000000 through 0x00000130. However, if you look at the generated files from STM32CubeMX (like startup_stm32f103xb.s), you notice it only lists entries until 0x00000108, and at this address is the magic number 0xF108F85F, which I eventually found information about here.

Why does the generated code's vector table have fewer entries than the reference manual's vector table? Are those last few entries not actually used, or they can somehow be omitted without consequence? Position 0x108 should be the handler for interrupt "TIM5 global interrupt". I don't know what this is but why is it that somehow the magic number above can be here instead of the actual handler?

It begs a related but different question, which is that on some bare metal STM32 code, the only entries defined in the vector table are the stack pointer and the reset handler. No other handlers. What happens here? Are those interrupts disabled by default? Or is that that since those handlers are undefined, the mcu behaviour will be undefined should those interrupts occur and the code just assumes those interrupts will not happen?

It seems that .NET (Core 3.1) supports custom curves in ECC. So I've defined the Curve25519, and generated key pair by below code:

How can the STM32F103C8 be configured to run with internal RC oscillator / HSI & PLL, i.e. without external crystal oscillator (as present on the "blue pill" board) with the Arduino framework in PlatformIO?

• https://docs.platformio.org/en/latest/boards/ststm32/bluepill_f103c8.html
• https://docs.platformio.org/en/latest/boards/ststm32/genericSTM32F103C8.html
• https://docs.platformio.org/en/latest/frameworks/arduino.html

platformio.ini:

I am trying to understand the placement of the vector table for Cortex-M3 processor.

According to the Cortex-M3 arch ref manual, the reset behavior is like this (some parts are omitted):

So, we can see that the vectortable comes from the VTOR (Vector Table Offset Register).

According to the Cortex-M3 tech ref manual, the VTOR is defined as:

So we can see, it has a reset value of 0x0. So based on the above 2 criteria, the Cortex-M3 processor expects a vector table at the absolute address 0x0 in the Code area after reset.

But in my MDK uVision IDE, I see my application is placed in the IROM1 area, which starts at 0x8000000, which is within the 0.5G Code memory area according to the Cortex-M3 memory map.

And since it has the Starup button checked, I guess that means the IROM1 area should contain the vector table (please correct me if I am wrong about this).

So I think the vector table should lie at the beginning of IROM1 area, i.e. 0x8000000. And it is indeed so. Below pic shows that at the beginning of IROM1, it is the vector table's 1st entry, the SP value.

And what's more strange, the VTOR register (at 0xE000ED08) still holds a 0x0 value:

So, how could my vector table be found with a 0x0 VTOR reset value?

And just out of curiosity, I checked the memory content at 0x0, there contains exactly the same vector table content as IROM1. So who did this magic copy??

I guess there must be something I don't know about the startup check box in below pic.

Thanks to @RealtimeRik and @domen. I downloaded the datasheet for STM32F103x8_xB(https://www.st.com/resource/en/datasheet/stm32f103c8.pdf). In section 4 Memory mapping, I saw below diagram:

So it seems the [0x0, 0x8000000) range does get aliased to somewhere else. But I haven't found how to determine where it is aliased to...

Now I found it!

I downloaded the STM32Fxxx fef manual (btw it's really huge).

In section 3.4 Boot configuration, it specifies the boot mode configured through the BOOT[1:0] pins.

And with different boot mode, different address aliasing is used:

Depending on the selected boot mode, main Flash memory, system memory or SRAM is accessible as follows:

• Boot from main Flash memory: the main Flash memory is aliased in the boot memory space (0x0000 0000), but still accessible from its original memory space (0x800 0000). In other words, the Flash memory contents can be accessed starting from address 0x0000 0000 or 0x800 0000.
• Boot from system memory: the system memory is aliased in the boot memory space (0x0000 0000), but still accessible from its original memory space (0x1FFF B000 in connectivity line devices, 0x1FFF F000 in other devices).
• Boot from the embedded SRAM: SRAM is accessible only at address 0x2000 0000.

What I saw is Boot from main Flash memory.

Well finally I can explain why 0x800 0000 is chosen...

The placement/expectation of the interrupt vector table at the address 0 is similar to the IA32 processor in real mode...

For a hobby project using the stm32f1xx-hal, I'm wanting to periodically read a sensor and then push the values such that I can graph them realtime in a webUSB app.

I have found an example in webusb_blinky by mvirkkunen which demonstrates the connectivity portion, but it's not clear to me how I would adapt it to publish sensor values. Should I be overriding control_in?

Any suggestions/help would be appreciated. Thanks!

I have the following problem. Once i generate Keil project using ST CubeMX and write project into STM32F103C8 MCU, everything goes well; However, after this first flashing i'am not able to flash it anymore as it throws the following error: