Renamed based on suggestions, added DEF to ensure tcm only applies to…

… targets with USE_ITCM_RAM defined.

src/main/common/filter.c

@@ -33,7 +33,7 @@
 
 // NULL filter
 
-float CRITICAL_SECTION nullFilterApply(void *filter, float input)
+float FAST_CODE nullFilterApply(void *filter, float input)
 {
     UNUSED(filter);
     return input;
@@ -42,20 +42,20 @@ float CRITICAL_SECTION nullFilterApply(void *filter, float input)
 
 // PT1 Low Pass filter
 
-void CRITICAL_SECTION pt1FilterInit(pt1Filter_t *filter, uint8_t f_cut, float dT)
+void FAST_CODE pt1FilterInit(pt1Filter_t *filter, uint8_t f_cut, float dT)
 {
     filter->RC = 1.0f / ( 2.0f * M_PI_FLOAT * f_cut );
     filter->dT = dT;
     filter->k = filter->dT / (filter->RC + filter->dT);
 }
 
-float CRITICAL_SECTION pt1FilterApply(pt1Filter_t *filter, float input)
+float FAST_CODE pt1FilterApply(pt1Filter_t *filter, float input)
 {
     filter->state = filter->state + filter->k * (input - filter->state);
     return filter->state;
 }
 
-float CRITICAL_SECTION pt1FilterApply4(pt1Filter_t *filter, float input, uint8_t f_cut, float dT)
+float FAST_CODE pt1FilterApply4(pt1Filter_t *filter, float input, uint8_t f_cut, float dT)
 {
     // Pre calculate and store RC
     if (!filter->RC) {
@@ -69,18 +69,18 @@ float CRITICAL_SECTION pt1FilterApply4(pt1Filter_t *filter, float input, uint8_t
     return filter->state;
 }
 
-float CRITICAL_SECTION filterGetNotchQ(uint16_t centerFreq, uint16_t cutoff) {
+float FAST_CODE filterGetNotchQ(uint16_t centerFreq, uint16_t cutoff) {
     float octaves = log2f((float) centerFreq  / (float) cutoff) * 2;
     return sqrtf(powf(2, octaves)) / (powf(2, octaves) - 1);
 }
 
 /* sets up a biquad Filter */
-void CRITICAL_SECTION biquadFilterInitLPF(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate)
+void FAST_CODE biquadFilterInitLPF(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate)
 {
     biquadFilterInit(filter, filterFreq, refreshRate, BIQUAD_Q, FILTER_LPF);
 }
 
-void CRITICAL_SECTION biquadFilterInit(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate, float Q, biquadFilterType_e filterType)
+void FAST_CODE biquadFilterInit(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate, float Q, biquadFilterType_e filterType)
 {
     // setup variables
     const float omega = 2.0f * M_PI_FLOAT * filterFreq * refreshRate * 0.000001f;
@@ -130,7 +130,7 @@ void CRITICAL_SECTION biquadFilterInit(biquadFilter_t *filter, float filterFreq,
     filter->d1 = filter->d2 = 0;
 }
 
-void CRITICAL_SECTION biquadFilterUpdate(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate, float Q, biquadFilterType_e filterType)
+void FAST_CODE biquadFilterUpdate(biquadFilter_t *filter, float filterFreq, uint32_t refreshRate, float Q, biquadFilterType_e filterType)
 {
     // backup state
     float x1 = filter->x1;
@@ -152,7 +152,7 @@ void CRITICAL_SECTION biquadFilterUpdate(biquadFilter_t *filter, float filterFre
 }
 
 /* Computes a biquadFilter_t filter on a sample (slightly less precise than df2 but works in dynamic mode) */
-float CRITICAL_SECTION biquadFilterApplyDF1(biquadFilter_t *filter, float input)
+float FAST_CODE biquadFilterApplyDF1(biquadFilter_t *filter, float input)
 {
     /* compute result */
     const float result = filter->b0 * input + filter->b1 * filter->x1 + filter->b2 * filter->x2 - filter->a1 * filter->y1 - filter->a2 * filter->y2;
@@ -169,7 +169,7 @@ float CRITICAL_SECTION biquadFilterApplyDF1(biquadFilter_t *filter, float input)
 }
 
 /* Computes a biquadFilter_t filter in direct form 2 on a sample (higher precision but can't handle changes in coefficients */
-float CRITICAL_SECTION biquadFilterApply(biquadFilter_t *filter, float input)
+float FAST_CODE biquadFilterApply(biquadFilter_t *filter, float input)
 {
     const float result = filter->b0 * input + filter->d1;
     filter->d1 = filter->b1 * input - filter->a1 * result + filter->d2;
@@ -180,7 +180,7 @@ float CRITICAL_SECTION biquadFilterApply(biquadFilter_t *filter, float input)
 /*
  * FIR filter
  */
-void CRITICAL_SECTION firFilterInit2(firFilter_t *filter, float *buf, uint8_t bufLength, const float *coeffs, uint8_t coeffsLength)
+void FAST_CODE firFilterInit2(firFilter_t *filter, float *buf, uint8_t bufLength, const float *coeffs, uint8_t coeffsLength)
 {
     filter->buf = buf;
     filter->bufLength = bufLength;
@@ -196,12 +196,12 @@ void CRITICAL_SECTION firFilterInit2(firFilter_t *filter, float *buf, uint8_t bu
  * FIR filter initialisation
  * If the FIR filter is just to be used for averaging, then coeffs can be set to NULL
  */
-void CRITICAL_SECTION firFilterInit(firFilter_t *filter, float *buf, uint8_t bufLength, const float *coeffs)
+void FAST_CODE firFilterInit(firFilter_t *filter, float *buf, uint8_t bufLength, const float *coeffs)
 {
     firFilterInit2(filter, buf, bufLength, coeffs, bufLength);
 }
 
-void CRITICAL_SECTION firFilterUpdate(firFilter_t *filter, float input)
+void FAST_CODE firFilterUpdate(firFilter_t *filter, float input)
 {
     filter->buf[filter->index++] = input; // index is at the first empty buffer positon
     if (filter->index >= filter->bufLength) {
@@ -212,7 +212,7 @@ void CRITICAL_SECTION firFilterUpdate(firFilter_t *filter, float input)
 /*
  * Update FIR filter maintaining a moving sum for quick moving average computation
  */
-void CRITICAL_SECTION firFilterUpdateAverage(firFilter_t *filter, float input)
+void FAST_CODE firFilterUpdateAverage(firFilter_t *filter, float input)
 {
     filter->movingSum += input; // sum of the last <count> items, to allow quick moving average computation
     filter->movingSum -=  filter->buf[filter->index]; // subtract the value that "drops off" the end of the moving sum
@@ -225,7 +225,7 @@ void CRITICAL_SECTION firFilterUpdateAverage(firFilter_t *filter, float input)
     }
 }
 
-float CRITICAL_SECTION firFilterApply(const firFilter_t *filter)
+float FAST_CODE firFilterApply(const firFilter_t *filter)
 {
     float ret = 0.0f;
     int ii = 0;
@@ -239,7 +239,7 @@ float CRITICAL_SECTION firFilterApply(const firFilter_t *filter)
     return ret;
 }
 
-float CRITICAL_SECTION firFilterUpdateAndApply(firFilter_t *filter, float input)
+float FAST_CODE firFilterUpdateAndApply(firFilter_t *filter, float input)
 {
     firFilterUpdate(filter, input);
     return firFilterApply(filter);
@@ -248,7 +248,7 @@ float CRITICAL_SECTION firFilterUpdateAndApply(firFilter_t *filter, float input)
 /*
  * Returns average of the last <count> items.
  */
-float CRITICAL_SECTION firFilterCalcPartialAverage(const firFilter_t *filter, uint8_t count)
+float FAST_CODE firFilterCalcPartialAverage(const firFilter_t *filter, uint8_t count)
 {
     float ret = 0.0f;
     int index = filter->index;
@@ -262,25 +262,25 @@ float CRITICAL_SECTION firFilterCalcPartialAverage(const firFilter_t *filter, ui
     return ret / count;
 }
 
-float CRITICAL_SECTION firFilterCalcMovingAverage(const firFilter_t *filter)
+float FAST_CODE firFilterCalcMovingAverage(const firFilter_t *filter)
 {
     return filter->movingSum / filter->count;
 }
 
-float CRITICAL_SECTION firFilterLastInput(const firFilter_t *filter)
+float FAST_CODE firFilterLastInput(const firFilter_t *filter)
 {
     // filter->index points to next empty item in buffer
     const int index = filter->index == 0 ? filter->bufLength - 1 : filter->index - 1;
     return filter->buf[index];
 }
 
-void CRITICAL_SECTION firFilterDenoiseInit(firFilterDenoise_t *filter, uint8_t gyroSoftLpfHz, uint16_t targetLooptime)
+void FAST_CODE firFilterDenoiseInit(firFilterDenoise_t *filter, uint8_t gyroSoftLpfHz, uint16_t targetLooptime)
 {
     filter->targetCount = constrain(lrintf((1.0f / (0.000001f * (float)targetLooptime)) / gyroSoftLpfHz), 1, MAX_FIR_DENOISE_WINDOW_SIZE);
 }
 
 // prototype function for denoising of signal by dynamic moving average. Mainly for test purposes
-float CRITICAL_SECTION firFilterDenoiseUpdate(firFilterDenoise_t *filter, float input)
+float FAST_CODE firFilterDenoiseUpdate(firFilterDenoise_t *filter, float input)
 {
     filter->state[filter->index] = input;
     filter->movingSum += filter->state[filter->index++];

src/main/fc/fc_init.c

@@ -240,11 +240,13 @@ void spiPreInit(void)
 
 void init(void)
 {
+#ifdef USE_ITCM_RAM
     /* Load functions into ITCM RAM */ 
-    extern unsigned char critical_code_start; 
-    extern unsigned char critical_code_end; 
-    extern unsigned char critical_code; 
-    memcpy(&critical_code_start, &critical_code, (int) (&critical_code_end - &critical_code_start));
+    extern unsigned char tcm_code_start; 
+    extern unsigned char tcm_code_end; 
+    extern unsigned char tcm_code; 
+    memcpy(&tcm_code_start, &tcm_code, (int)(&tcm_code_end - &tcm_code_start));
+#endif
 
 #ifdef USE_HAL_DRIVER
     HAL_Init();

src/main/fc/fc_rc.c

@@ -52,22 +52,22 @@
 static float setpointRate[3], rcDeflection[3], rcDeflectionAbs[3];
 static float throttlePIDAttenuation;
 
-float CRITICAL_SECTION getSetpointRate(int axis)
+float FAST_CODE getSetpointRate(int axis)
 {
     return setpointRate[axis];
 }
 
-float CRITICAL_SECTION getRcDeflection(int axis)
+float FAST_CODE getRcDeflection(int axis)
 {
     return rcDeflection[axis];
 }
 
-float CRITICAL_SECTION getRcDeflectionAbs(int axis)
+float FAST_CODE getRcDeflectionAbs(int axis)
 {
     return rcDeflectionAbs[axis];
 }
 
-float CRITICAL_SECTION getThrottlePIDAttenuation(void)
+float FAST_CODE getThrottlePIDAttenuation(void)
 {
     return throttlePIDAttenuation;
 }

src/main/flight/mixer.c

@@ -321,7 +321,7 @@ uint8_t getMotorCount()
     return motorCount;
 }
 
-float CRITICAL_SECTION getMotorMixRange()
+float FAST_CODE getMotorMixRange()
 {
     return motorMixRange;
 }

src/main/flight/pid.c

@@ -278,7 +278,7 @@ void pidInit(const pidProfile_t *pidProfile)
 }
 
 // calculates strength of horizon leveling; 0 = none, 1.0 = most leveling
-static float CRITICAL_SECTION calcHorizonLevelStrength()
+static float FAST_CODE calcHorizonLevelStrength()
 {
     // start with 1.0 at center stick, 0.0 at max stick deflection:
     float horizonLevelStrength = 1.0f -
@@ -338,7 +338,7 @@ static float CRITICAL_SECTION calcHorizonLevelStrength()
     return constrainf(horizonLevelStrength, 0, 1);
 }
 
-static float CRITICAL_SECTION pidLevel(int axis, const pidProfile_t *pidProfile, const rollAndPitchTrims_t *angleTrim, float currentPidSetpoint)
+static float FAST_CODE pidLevel(int axis, const pidProfile_t *pidProfile, const rollAndPitchTrims_t *angleTrim, float currentPidSetpoint)
 {
     // calculate error angle and limit the angle to the max inclination
     float angle = pidProfile->levelSensitivity * getRcDeflection(axis);
@@ -359,7 +359,7 @@ static float CRITICAL_SECTION pidLevel(int axis, const pidProfile_t *pidProfile,
     return currentPidSetpoint;
 }
 
-static float CRITICAL_SECTION accelerationLimit(int axis, float currentPidSetpoint) 
+static float FAST_CODE accelerationLimit(int axis, float currentPidSetpoint) 
 {
     static float previousSetpoint[3];
     const float currentVelocity = currentPidSetpoint- previousSetpoint[axis];
@@ -373,7 +373,7 @@ static float CRITICAL_SECTION accelerationLimit(int axis, float currentPidSetpoi
 
 // Betaflight pid controller, which will be maintained in the future with additional features specialised for current (mini) multirotor usage.
 // Based on 2DOF reference design (matlab)
-void CRITICAL_SECTION pidController(const pidProfile_t *pidProfile, const rollAndPitchTrims_t *angleTrim, timeUs_t currentTimeUs)
+void FAST_CODE pidController(const pidProfile_t *pidProfile, const rollAndPitchTrims_t *angleTrim, timeUs_t currentTimeUs)
 {
     static float previousRateError[2];
     const float tpaFactor = getThrottlePIDAttenuation();

src/main/target/common_fc_pre.h

@@ -77,9 +77,9 @@
 #endif
 
 #ifdef USE_ITCM_RAM
-#define CRITICAL_SECTION __attribute__((section(".critical_code")))
+#define FAST_CODE __attribute__((section(".tcm_code")))
 #else
-#define CRITICAL_SECTION
+#define FAST_CODE
 #endif
 
 #define USE_CLI

src/main/target/common_osd_slave.h

@@ -33,6 +33,8 @@
 
 #define MAX_PROFILE_COUNT 0
 
+#define FAST_CODE
+
 #ifdef STM32F1
 #define MINIMAL_CLI
 #endif

src/main/target/link/stm32_flash_f7_split.ld

@@ -36,15 +36,15 @@ SECTIONS
 
   /* Critical program code goes into ITCM RAM */
   /* Copy specific fast-executing code to ITCM RAM */ 
-  critical_code = LOADADDR(.critical_code); 
-  .critical_code :
+  tcm_code = LOADADDR(.tcm_code); 
+  .tcm_code :
   {
     . = ALIGN(4);
-    critical_code_start = .; 
-    *(.critical_code)
-    *(.critical_code*)
+    tcm_code_start = .; 
+    *(.tcm_code)
+    *(.tcm_code*)
     . = ALIGN(4);
-    critical_code_end = .; 
+    tcm_code_end = .; 
   } >ITCM_RAM AT >FLASH1
 
   /* The program code and other data goes into FLASH */

src/test/unit/platform.h

@@ -32,6 +32,7 @@
 #define LED_STRIP
 #define USE_SERVOS
 #define TRANSPONDER
+#define FAST_CODE
 
 typedef enum
 {

src/test/unit/unittest_macros.h

@@ -17,5 +17,4 @@
 
 #pragma once
 
-
 #define UNUSED(x) (void)(x)