Befehle hinter vorgefertigten Funktionen STM32

Der STM32 ist nunmal ein wenig Leistungsfähiger als das was du 
kennengelernt hast und somit auch komplizierter zu programmieren. uC 
Programmierung geht darüber hinaus einen Wert in ein Register zui 
schreiben, du musst erstmal die Architektur verstehen. Es zwingt dich 
niemand die Libs von ST zu nutzen, ich mache das auch nicht.

Allerdings glaube ich auch nicht, dass du mit dem Datasheet besser 
fährst, da du noch keine grundlegenden uC-Kenntnisse zu haben scheinst. 
Das Reference Manual von ST hat >1000 Seiten und dann brauchst du noch 
das Reference Manual vom Cortex M3.

Also dank dem Inhaltsverzeichnis kann man sich schon zurechtfinden, 
zumindest hab ich bis jetzt alles gefunden.

das eigentliche Problem ist ja Keil, ich würde gerne

void meininterrupt (void) interrupt 0xA4 {
//Code
}

schreiben, nur bekomme ich einen Fehler beim Compilen.
benutze ich die falsche syntax oder funktioniert das beim CortexM3 nicht 
mehr

Du hast eben nicht alles gefunden, das funktioniert beim STM32 völlig 
anders, eine Interrupt-Service Routine zu erstellen ist eben nicht ganz 
so einfach wie du dir das vorstellst. Dafür musst du diverse 
Einstellungen vornehmen. Du musst dich erstmal mit dem 
Interrupt-Controller vom Cortex M3 auseinandersetzen.

neuling schrieb:
> das eigentliche Problem ist ja Keil, ich würde gerne
>
> void meininterrupt (void) interrupt 0xA4 {
> //Code
> }
>
> schreiben, nur bekomme ich einen Fehler beim Compilen.
> benutze ich die falsche syntax oder funktioniert das beim CortexM3 nicht
> mehr

Na so ähnlich ist es schon, eher schon einfacher: Den Namen der ISR mußt 
du exakt nutzen (wird z.B. im Startupcode definiert). Für Timer0 beim 
LPC17xx heißt die ISR einfach
TIMER0_IRQHandler

Du schreibst einfach

void TIMER0_IRQHandler(void)
{
    // code
}

Natürlich mußt du noch den ganzen Rest beachten; also den Interrupt 
aktivieren, im NVIC priorisieren, den TIMER0 so konfigurieren, daß er 
auch wie gewünscht ausgelöst werden etc.

Hallo Neuling,

was Du beim STM erlebst ist einerseits verwirrend, andererseits in der 
Industrie gewünscht.

Im Prinzip kannst Du das mit Deiner Routine genauso machen, dann musst 
Du aber alles selbst neu erfinden, deine Routinen in die entsprechenden 
Tabellen einhängen, den Interruptcontroller und dess Vektortabellen 
sebst aufbauen. Das kostet Dich bei einem Minimalprogramm nicht soviel 
Zeit wenn du darin geübt bist und den Controller verstanden hast.

Wenn Du aber größere Umgebungen hast, den Controller häufig unter 
verschiedenen Umgebungen einsetzen willst ist es ratsamer eine 
Abstraktionsebene über die direkte HW zu legen: diese Funktion 
bewerkstelligt die STM32 Bibliothek die Du verwendest. Sie erlaubt dass 
die Programme schnell und portabel geschrieben werden können. Beispiel: 
Die unetrschiedlichen Bitpositionen für das Einschalten und einstellen 
der PLL sind in den STM32 Varianten unterschiedlich positioniert. Wenn 
Du wie in deinem Beispiel hart und direkt auf die Register gehst und das 
Programm dann von einer Variante auf die andere Varinate wechselst 
müsstest Du alle solchen Zielen finden und auf deren Korrektheit pürüfe 
- ob das sicher klappt kannst Du Dir selber überlegen.

Im übrigen werden die Funktionen shcon etwas Zeit fressen da sie zwar 
relativ minimal angelegt sind aber die Calls dazu auch Zeit brauchen. 
Dann kannst Du aber dort wo es zeiotkritisch ist immer noch über die 
Strukturen hart uf die Register gehen.

Die STM32 Bibilothek ist sicherlich etwas aufwendiger zu verstehen, sie 
gibt Dir aber die Möglichkeit, wenn Du mal drinnen bist UND den 
Controller verstanden hast innerhalb kürzester Zeit alle Blöcke einfach 
anszusteuern und felxibel damit umzugehen - und nachvollziehbarer Wird 
dein Code auch.

Im übrigen nochmal: den STM32 kannst Du acuh in Deiner Umgebung OHNE 
Bibliothek programmieren - ich halte es aber nicht für sinnvoll.

Grüße

Genau so sehe ich die Libs eigentlich auch.
Die zumindest bei mir übliche Vorgehensweise ist so: Zu Anfang benutze 
ich die jeweilige Lib, um parallel mit dem Datenblatt/Manual erstmal zum 
Ziel zu kommen. Dann schaue ich Stück für Stück nach, was sich 
eigentlich konkret im Libaufruf verbirgt und mische dann Lib und 
Direktzugriffe auf Register, um zum Schluß fast nur noch auf 
Registerebene zu arbeiten. Ausnahmen bleiben die echt komplexen 
Peripherien. Das will ich wirklich nicht immer verstehen.

Wegen der Codegröße und Ausführungszeit muß man immer bedenken, daß in 
der Lib üblicherweise idiotensicher jede mögliche Konstellation 
berücksichtigt ist. Die eigene Implementierung bzw. 
Registerdirektzugriffe kann dann im Einzelfall schon mal in dem einen 
Projekt funktionieren und im anderen nicht.