Programmiervorgang

[D. I. (Firma: Fa) (buell)]

Hallo zusammen

Ich bin was das Programmieren angeht noch Neuling. Derzeit versuche ich 
gerade so zu programmieren, dass ich auch genau verstanden habe, wie 
welches Bit gesetzt werden muss, ohne die fertigen Funktionen von ST zu 
verwenden.

Das ging soweit gut, aber wenn ich jetzt zB einen externen Interrupt 
über einen Pin definieren will wird es schon kompliziert.
Zum Beispiel habe ich Folgendes habe ich in diesem Link gefunden:
https://stm32f4-discovery.net/2014/08/stm32f4-external-interrupts-tutorial/

/* Configure pins to be interrupts */
void Configure_PD0(void) {
    /* Set variables used */
    GPIO_InitTypeDef GPIO_InitStruct;
    EXTI_InitTypeDef EXTI_InitStruct;
    NVIC_InitTypeDef NVIC_InitStruct;
    
    /* Enable clock for GPIOD */
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
    /* Enable clock for SYSCFG */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    
    /* Set pin as input */
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_Init(GPIOD, &GPIO_InitStruct);
    
    /* Tell system that you will use PD0 for EXTI_Line0 */
    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOD, EXTI_PinSource0);
    
    /* PD0 is connected to EXTI_Line0 */
    EXTI_InitStruct.EXTI_Line = EXTI_Line0;
    /* Enable interrupt */
    EXTI_InitStruct.EXTI_LineCmd = ENABLE;
    /* Interrupt mode */
    EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
    /* Triggers on rising and falling edge */
    EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    /* Add to EXTI */
    EXTI_Init(&EXTI_InitStruct);
 
    /* Add IRQ vector to NVIC */
    /* PD0 is connected to EXTI_Line0, which has EXTI0_IRQn vector */
    NVIC_InitStruct.NVIC_IRQChannel = EXTI0_IRQn;
    /* Set priority */
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0x00;
    /* Set sub priority */
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0x00;
    /* Enable interrupt */
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    /* Add to NVIC */
    NVIC_Init(&NVIC_InitStruct);
}

Ich frage mich wie die Leute immer wissen, wie man die Interrupts etc. 
implementiert. Ich würde zB nie allein mittels des Reference Manuals 
drauf kommen, welche Interrupt Handler es gibt: die stehen ja nur in der 
startupxxx.s datei und warum ich den NVIC benötige bzw. wie ich auf 
diesen komme.

Neben der Tatsache, dass es bei meinem STM32L4 diese NVIC_InitStructs 
und den EXTI_InitStruct nicht gibt, [b]würde ich gerne erfahren, wie ich 
grundsätzlich als Anfänger beim Programmieren vorgehen soll und wie ich 
das womöglich ohne den fertigen Funktionen von ST bewerkstelligen kann. 
[b].
Ich wäre echt froh, wenn ich das erfahren könnte, da ich manchmal 
überhaupt keinen Überblick habe.

Vielen Dank für eure Hilfe

[Wolfgang (Gast)]

D. I. schrieb:
> ... und warum ich den NVIC benötige bzw. wie ich auf diesen komme.

Wenn du dir den Begriff "Nested Vectored Interrupt Controller", der 
hinter dem Akkronym "NVIC" steckt, übersetzt, wird es vielleicht klarer. 
Irgendwer muss sich letztendlich um die "Verdrahtung" der Interrupts 
kümmern.

Wenn man sich als Neuling gleich in einen µC stürzt, der soetwas alles 
hat, kommt da schon mal ein bisschen Neuland auf einen zu.

"Steile Lernkurve", oder wie heißt das heutzutage?
Früher (tm) wäre man mit einem kleineren Prozessor eingestiegen (z.B. 
AVR) und langsam reingewachsen.

[TestX (Gast)]

Naja...als Anfänger nimmt man die fertigen Bibliotheken..dein Beispiel 
von oben nutzt diese auch. Und selbst als Profi nutzt man das, da man 
bei komplexen Controllern nicht mehr jedes Bit einzeln setzen will.

Zum "Verstehen" sind solche "Monster Controller" der falsche Weg...ein 
8Bit AVR/PIC ist hier wesentlich umgänglicher.

Ansonsten nimmt man sich die Handbücher (Hersteller + ARM) und schaut 
sich halt die Architektur, Register usw. an - das setzt allerdings SEHR 
viel Vorwissen voraus.