STM32 Ersten Timer Wert festhalten bis Flag rückgesetzt

[STM (Gast)]

Hallo Mikrocontrollerer!
Durch externe Flanken lässt sich ja der Timerwert im STM32 festhalten 
und später auslesen. Das Problem ist dass dieser Wert bei einer späteren 
Flanke mit dem neuen aktuellen überschrieben wird, auch wenn noch kein 
Flag Rückgesetzt wurde. Gibt es eine Möglichkeit den Wert der ersten 
Flanke beizubehalten bis ein Flag rückgesetzt wurde? Momentan löse ich 
das über einen Interrupt der sich nach der ersten Flanke sperrt bis der 
Wert auslesen wurde. Das ist aber erstens umständlich und nicht 100% 
sicher denke ich und zweitens sollte es bei einem so mächtigen 
Controller doch eine besser bereits vorhandene Lösung geben. Vielleicht 
kann mir von euch jemand weiter helfen. Danke

[(prx) A. K. (prx)]

Schon an DMA gedacht?

[STM (Gast)]

Noch nicht. Du meinst also die Übertragung mittels DMA erst wieder nach 
dem Auslesen zulassen? Ist das nicht auch wieder eine Bastellösung?

[(prx) A. K. (prx)]

Capture Event ist DMA-Trigger
DMA: Capture Value => Memory Buffer

Mit einer DMA-Länge von 1 Wort hast du exakt das Gewünschte, solange das 
DMA fixer ist als die nächste Flanke. Aber damit das fehlschlägt müsste 
es schon eine verteufelt kurze Zeit für zwei Flanken sein (wenige 
Core-Takte).

Mit längerem Puffer, ggf. als Zirkularpuffer, kriegst du alle Flanken, 
solange das DMA schneller ist als deine Flanken.

[STM (Gast)]

Ok super... danke...

[STM (Gast)]

Ich habe das ganze jetzt mal aufgebaut, ohne es bisher getestet zu 
haben. Mir fällt jetzt gerade auf, dass ich davon ausgegangen bin dass 
der DMA nach der ersten Übertragung gesperrt werden kann. Mein 
eigentliches Problem war ja dass die nachfolgenden Werte den ersten 
überschrieben haben. Mir würde jetzt spontan einfallen die Zieladresse 
ansteigen zu lassen und nur die erste auszulesen, was wieder nur eine 
Bastellösung wäre. Es geht am Ende darum nur den Wert der ersten Flanke 
aufzunehmen und das überschreiben des Wertes erst nach ein paar µs 
manuell wieder freizugeben. Die DMA habe ich erstmal wie folgt 
konfiguriert:

  // DMA1 Channel1 Config 
  DMA_DeInit(DMA1_Channel1);

  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)TIM2_Value_CC3_Register;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SRC_Buffer;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize = 1;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

  DMA_Init(DMA1_Channel1, &DMA_InitStructure);

  // DMA1 Channel1 enable 
  DMA_Cmd(DMA1_Channel1, ENABLE


  // TIM1 Update DMA Request enable
  TIM_DMACmd(TIM2, TIM_DMA_CC2, ENABLE);

[(prx) A. K. (prx)]

Wenn der DMA-Kanal für eine Länge von einem Wort ohne automatischem 
Reload konfiguriert wird, dann wird auch nur ein Wort übertragen und der 
Kanal wird danach automatisch gesperrt.

Grundsätzlich ist das Verfahren deiner Interrupt-Lösung ähnlich, als es 
nicht narrensicher ist. Wenn die Zeit zwischen zwei aufeinanderfolgenden 
eingefangenen Flanken kürzer als die Latency vom DMA ist, dann fischt 
das DMA den Wert der zweite Flanke aus dem Register. Nur reagiert DMA 
schneller als der Interrupt und der so mögliche Zeitfehler liegt im 
einstelligen Bereich von Taktzyklen des Core.

DMA_Mode_Circular klingt nach automatischem Reload, was exakt das ist, 
was du nicht haben willst. Dieser Modus ergibt nur Sinn, wenn du in 
einem Zirkularpuffer alle Flanken gespeichert sehen willst.

[(prx) A. K. (prx)]

PS: Gegen allzu schnelle Pulsfolgen kannst du den Cature-Trigger mit 
einem Filter absichern. Der allerdings die Erkennung der Flanke etwas 
verzögern dürfte.

[STM (Gast)]

Ja, das Cirular habe ich bereits rausgenommen, das Problem was ich jetzt 
habe ist das neu setzen des Buffers. Laut Beschreibung muss erst die DMA 
deaktiviert werden, dann wird ein neuer Wert geladen und schließlich die 
DMA wieder aktiviert. Ich würde mir das jetzt so zusammen reimen?:

DMA_Cmd(DMA1_Channel1, DISABLE);        
DMA1_Channel1 -> DMA_CNDTR = 1;        
DMA_Cmd(DMA1_Channel1, ENABLE);

[STM (Gast)]

Nur noch mal zusammenfassend. Klappt jetzt alles super, ich lese jetzt 
direkt den Counter aus und habe zusätzlich noch den Filter der Timer 
aktiviert.

//Neu Laden: (deaktivieren, Neu-laden, aktivieren):
DMA_Cmd(DMA1_Channel1, DISABLE);
DMA1_Channel1 -> CNDTR = 1;
DMA_Cmd(DMA1_Channel1, ENABLE);

  // DMA1 Channel1 Config
  DMA_DeInit(DMA1_Channel1);

  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)TIM4_Value_Counter_Register;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)DMA_Wertespeicher;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize = 1;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;    //Kein Autoreload
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
      DMA_Init(DMA1_Channel1, &DMA_InitStructure);

Danke noch mal