Interrupts und Tasks - Codeoptimierung
-
Es ist ja schön, dass der Code verschönert wird, aber geht das ganze in HW nicht doch etwas eleganter?
- Was soll denn eigentlich gemacht werden?
- Welcher µC wird denn verwendet?
-
buell schrieb:
Das löst glaucb ich mein Problem, aber dann würde er immer noch im Interrupt stecken auch wenn 1000 weitere kommen.
Zum abstrakten Ablauf habe ich mir bisher überhaupt keine Gedanken gemacht, weil mir nicht bekannt ist, welche Art Gerät überhaupt programmiert wird.
Im Code wird von TASKs gesprochen. Reden wir handelt es sich hierbei um separate Threads? Oder arbeitet das Programm evtl. nur mit einem Idle-Loop, so dass die Abläufe sequentiell geordnet sind? Sind Interrupts unterbrechbar (andere Interrupts/Scheduler) und müssen die entsprechenden Routinen ggf. reentrant sein?
-
camper schrieb:
buell schrieb:
HWarum eigentlich folgendes const.? Was könnte im schlimmsten Fall passieren?
uint16_t EN_EPCx_CHs[] = {EN_EPC1_CH, EN_EPC2_CH, EN_EPC3_CH, EN_EPC4_CH};Wenn es nicht const ist, könnte jemand auf den Gedanken kommen, dass sich die Werte ändern können. U.U. hindert es auch den Compiler daran, bestimmte Optimierungen auszuführen, wenn er nicht sicher sein kann, dass die Werte unveränderlich sind.
buell schrieb:
#define DMA_CHANNELS 3 #define DataRdyAmount 3Die Arrays sind 3 lang, mit der 0 hat es eine Grösse von 4.
static DataRdy_t DataRdys[DataRdyAmount];Sagt dem Compiler, dass DataRdys ein Array mit DataRdyAmount Elementen sein soll (0...DataRdyAmount-1).
buell schrieb:
for(uint32_t i = 0; i < 500000; i++); // wait until TCDS Diese Zeile überlebt keinen optimierenden Compiler. Wenn keine geeignete Systemfunktion existiert, könntest du z.B. volatile-Writes zu Hilfe nehmen.Das verstehe ich nicht, warum einen dummy einbauen?
Grundsätzlich steht es dem Compiler frei, irgendwelchen Code zu erzeugen, sofern sich das beobachtbare Verhalten nicht ändert. Was als beobachtbar zu betrachten ist, wird ebenso vom Standard festgelegt (vereinfacht):
- Die Reihenfolge der Zugriffe auf volatile Objekte
- Reihenfolge von Input-/Output (die genaue Bedeutung hängt von der Implementation ab, aber im Allgemeinen ist das jeder Aufruf einer Systemfunktion, ggf. auch indirekt über Funktionen der Standardbibliothek).
Die Schleife verändert keine dieser beiden Aspekte, tut also im Sinne des so definierten beobachtbaren Verhaltens nichts. Der Compiler kann sie folglich einfach ignorieren. Der reine Zeitablauf als solcher ist im Allgemeinen kein Aspekt beobachtbaren Verhaltens.P.S. Auch mit dummy-Writes ist das nat. keine Schleife, die geeignet ist, eine bestimmte Zeitdauer zu überbrücken. Im Allgemeinen wird es ja so sein, das bekannt ist (Spezifikation, RL-Zeitmass), wie lange mindestens gewartet werden muss. Es ist allerdings keineswegs per se gesichert, dass pro Schleifendurchgang (+Write) eine bestimmte konstante Zeit vergeht. Dafür gibt es dann normalerweise Systemfunktionen, die den Programablauf mit irgendwelchen Uhrwerken synchronisieren.
So eine volatile write-Schleife ist also die schlechteste aller Möglichkeiten, die wirklich nur in Betracht kommen sollte, wenn keine Alternative besteht.Du hast mir heute sehr viel beigebracht. Ich danke dir vielmals. Vielen Dank aber auch an alle anderen.
Das mit der for-Schleife schaue ich mir morgen an.Ich habe noch eine letzte Frage:
Bei deinem Code:
void TIM1_UP_TIM16_IRQHandler (void) // LONG_PULS overflow interrupt to start Read Clocks of CH1 { while(TASK1) ; // wait until Task1 is done StartReadClocks = true; // start Task2 LongPulse = false; // both commands are needed to start TASK2 if (TIM1->EGR & TIM_EGR_UG) { while (TASK2) ; // wait until Task2 is done TIM15->SR &= ~TIM_EGR_UG; // clear UG Bit LongPulse = true; // starts TASK1 long pulse at the end of Repetition counter StartReadClocks=false; // TASK2 is stopped u8count1++; // increase counter } }habe ich folgendes Problem und zwar:
wenn der Task 1 durchgeführt wurde und Task1 false wird, sollte im Anschluss Task 2 aktiv werden. Wenn Task2 aktiv ist, ist Task1 sicher false.
Wenn aber der nächste Interrupt kommt, sollte er mir die folgenden Befehle nach der 1. while nicht ausführen.Beim Task1 benötige ich also die if, das ist der Code unten.
Jetzt besteht aber das Problem, dass er mir die Befehle nicht mehr ausführt, wenn Task1 false ist und ich komme nie in den Task2Entweder ist das so verzwickt oder ich stelle mich so blöd an
void TIM1_UP_TIM16_IRQHandler (void) // LONG_PULS overflow interrupt to start Read Clocks of CH1 { if (TASK1) { while(TASK1); // wait until Task1 is done StartReadClocks = true; // start Task2 LongPulse = false; // both commands are needed to start TASK2 } if (TIM1->EGR & TIM_EGR_UG) { while (TASK2); // wait until Task2 is done TIM15->SR &= ~TIM_EGR_UG; // clear UG Bit LongPulse = true; // starts TASK1 long pulse at the end of Repetition counter StartReadClocks=false; // TASK2 is stopped u8count1++; // increase counter } }
-
buell schrieb:
Beim Task1 benötige ich die if, weil er mir sonst die Befehle auch ausführt, wenn Task2 dran ist und Task1 false ist.
Jetzt besteht aber das Problem, dass er mir die Befehle nicht mehr ausführt, wenn Task1 false ist und ich komme nie in den Task21. Satz: du hast A (das if) eingeführt, um B (Befehlsausfüjrung, wenn Task2 dran ist) zu verhindern.
2. Satz: Problem ist, dass B verhindert wird.Du musst dich entscheiden, was du willst
-
camper schrieb:
buell schrieb:
Beim Task1 benötige ich die if, weil er mir sonst die Befehle auch ausführt, wenn Task2 dran ist und Task1 false ist.
Jetzt besteht aber das Problem, dass er mir die Befehle nicht mehr ausführt, wenn Task1 false ist und ich komme nie in den Task21. Satz: du hast A (das if) eingeführt, um B (Befehlsausfüjrung, wenn Task2 dran ist) zu verhindern.
2. Satz: Problem ist, dass B verhindert wird.Du musst dich entscheiden, was du willst
Ich entscheide mich dafür, dass Task1 im selbigen Interrupt einmal ausgeführt wird und dann vermieden wird bis der Repetition counter 0 erreicht (UG bit gesetzt wird). Das geht doch so mit einem Interrupt gar nicht oder?
Es ist ja so
1. EXTI15_10_IRQHandler kommt
2. Task 1 )Long Pulse) wird einmalig durch diesen Interrupt gestartet.
3. bei fallender Flanke des LongPulse kommt der Interrupt TIM1_UP_TIM16_IRQHandler zum 1. Mal.
4. Der uC kommt in diesen Interrupt und die 1. if im Interrupt --> da TASK1 = false ist, wird ausgeführt und TASK2 wird gestartet. Die Read Pulse werden erst mit dem Enable TIM1 im TASK2 aktiviert.
Ab diesem Moment folgen bei jeder fallenden Flanke der short pulses die Interrupts.
1,2,3,20,40, 100, 1000 --> Task1 = false und wird jedes Mal ausgeführt. Das sollte aber nicht so sein
Nach dem 1000. Puls wird der Rep. Count endlich 0 und UG wird gesetzt.
Jetzt wird die 1. If zum 1000sten Mal falsch ausgeführt und danach endlich die 1. Runde mit dem 2. If beendet.
Das geht 4. Runden so.
Das ist mein Problem.PS: Es ist das STM32L476RG Nucleo Board. Ich will einfach 4 Epcs seriell auslesen.
Auf S. 315 Tabellen Position 25 ist der einzige Interrupt, den ich verwenden kann von TIM1 aufgeführt. Die anderen wüsste ich nicht wie man diese verwenden könnte für mein Problem.
http://www.st.com/content/ccc/resource/technical/document/reference_manual/group0/b0/ac/3e/8f/6d/21/47/af/DM00151940/files/DM00151940.pdf/jcr:content/translations/en.DM00151940.pdfMein abgespeckter Code hier nochmals (Achtung nicht alles aufgeführt):
Ich wäre um Hilfe dankbar. Und vielen Dank nochmalsvoid TASK1_long_Pulse() { if (LongPulse && !TASK2 && !StartReadClocks) { TASK1 = true; volatile int dummy; // define a dummy to avoid compiler prevention of observable action SetTIM1Param(0, TRD_PULSE, LONG_TIM1_PULSE_REPETITION_COUNT_VALUE); Enable_EPCReadCLK_CH(EN_EPCx_CHs[u8count1]); /********** ab hier Zeit messen ********/ TASK1 = false; // if in ARR Interrupt reacts Enable_Timerx_Counter(TIM1); /********** Ende Zeit messen ********/ } } void TASK2_short_Pulse() { if (!LongPulse && !TASK1 && StartReadClocks) { TASK2 = true; select_ADC_Channel_to_Convert(u8count1); // set the ADC channel Set_Destination_DMA1_ADC(dmaArray[u8count1-1].buffer); // set the DMA destination SetTIM1Param(0, TRD_CLOCK, READ_CLK_TIM1_REPETITION_COUNT_VALUE); // configure TIM1 settings Enable_EPCReadCLK_CH(EN_EPCx_CHs[u8count1] | EN_ADC_TRG_CH); if(u8count1==4) { // while(TIM1->CR1 & TIM_CR1_CEN); // Disable_Timerx_Counter(TIM1); // make sure the timer1 is disabled Enable_Shutter_TIM15(); // set the start conditions u8count1 = 0; LongPulse=false; TASK1=false; TASK2=false; } StartReadClocks=false; TASK2 = false; // make sure that TASK1 gets active Enable_Timerx_Counter(TIM1); } } void EXTI15_10_IRQHandler (void) { // Interrupt on PC12 DATARDY 1 --> is generated once before reading out process if ((EXTI->PR1 & EXTI_PR1_PIF12)) { EXTI->PR1 &= ~EXTI_PR1_PIF12; //EXTI->PR1 = EXTI_PR1_PIF12; // schalte Led ein uint32_t ODR = GPIOA->ODR; GPIOA->BSRR = ((ODR & (1 << 5)) << 16) | ((~ODR) & (1 << 5)); Disable_Shutter_TIM15(); // for avoiding TCDS and Shutter time overlaps according to epc datasheet u8count1++; // increade the counter LongPulse = true; // starts Task1 } } void TIM1_UP_TIM16_IRQHandler (void) // LONG_PULS overflow interrupt to start Read Clocks of CH1 { if (!TASK1) { volatile int dummy; for(uint32_t i = 0; i < 500000; i++) // wait until TCDS dummy = 0; // commands to start Task2 StartReadClocks = true; LongPulse = false; // both commands are needed to start TASK2 } if (TIM1->EGR & TIM_EGR_UG) { while (TASK2); // wait until Task2 is done TIM15->SR &= ~TIM_EGR_UG; // clear UG Bit LongPulse = true; // starts TASK1 long pulse at the end of Repetition counter StartReadClocks=false; // TASK2 is stopped u8count1++; // increase counter } }