Input capture and timers

Question

Microcontroller: STM32F401RE Doing input capture on TIM1's channel 1,2,3,4. ARR register value is 65536. The clock is 8Mhz. The 4 input capture channels are connected to 4 microphones. As soon as a sound(bang) occurs all of these channels change their state from 0 to 1. The input capture is set on the rising edge. Whichever microphone is closer to the bang that microphone changes it's state first and with respect to their distance the rest follow. So, let's say my counter is at 100 and a bang occurs causing 4 input captures. As soon as the input capture happens the counter value at that instance is stored in the respective channels CCRx Register.(let's say CCR1 stores 100,CCR2 stores 103, CCR3 stores 104,CCR4 stores 107) Once I get these 4 values I have to find the time between the first input capture and the rest of the input capture.

Eg- CCR2-CCR1=103-100 ; CCR3-CCR1=104-100; CCR4-CCR1=107-100;

As shown above there isn't a problem when these input captures happen at the 100th count. But when it happens at 65520 I get values such as 65520,65525,65535,5. In this scenario, the lowest value I get is actually the event that takes place last and because of the huge difference I don't get a proper answer. I can't use the overflow flag because the event can occur at any time. Even after 5 times it has overflown. The counter is always on and keeps on counting and the event(bang) can occur at any time. The maximum difference possible between the input captures is only 30 counts.

Is there some smart solution to this problem or I should write a code to actually identify this series of numbers and subtract numbers with 655xx with 65536 and numbers from 0 to 20 with 0 and then add the absolute differences?

Answer 1

Since you have a free running timer which restarts from zero after reaching 65535 (2^16-1), you are actually doing modular arithmetic. This means that when you subtract two values from each other you implicitly get two possible answers, and of the two you need to pick the one with a smaller absolute value.

---

Signed answer

Consider the following code:

#define PERIOD 65536
int32_t diff = (int32_t)a - b;
int32_t result = (diff + (PERIOD + PERIOD / 2)) % PERIOD - PERIOD / 2;

If a is from an event which happened after b, result will be positive, otherwise result will be negative. Note that this only works if the maximum possible delay between the two is less than half of the timer period. If you have delays greater than that, you will get results with the opposite sign and wrong magnitude. result will be a value in the right-open interval
[-PERIOD / 2, PERIOD / 2).
For example, if PERIOD is 65536 like above, -32768 ≤ result < 32768.

---

Unsigned answer

If you impose an additional constraint that a is guaranteed to always happen after b, you can use slightly different code:

#define PERIOD 65536
int32_t diff = (int32_t)a - b;
uint32_t result = (diff + PERIOD) % PERIOD;

Now the maximum possible delay between the two can be up to the full timer period. Reflecting that, result will be a value in the right-open interval [0, PERIOD).
For example, if PERIOD is 65536 like above, 0 ≤ result < 65536.

---

To illustrate how the first (signed) version of code works with a practical example, let's say capture a is 65515, capture b is 65530 and capture c happens 10 counts later still, so it will wrap around to a value of 00004 (given how the timer restarts from 0 upon reaching 65565).

Calculating b - a you would get
diff = 65530 - 65515 = 15
result = (15 + 98304) mod 65536 - 32768;
result = 98319 mod 65536 - 32768;
result = 32783 - 32768;
result = 15;

Calculating a - b you would get
diff = 65515 - 65530 = -15
result = (-15 + 98304) mod 65536 - 32768;
result = 98289 mod 65536 - 32768;
result = 32753 - 32768;
result = -15;

Calculating c - b you would get
diff = 4 - 65530 = -65526
result = (-65526 + 98304) mod 65536 - 32768;
result = 32778 mod 65536 - 32768;
result = 32778 - 32768;
result = 10;

Calculating b - c you would get
diff = 65530 - 4 = 65526
result = (65526 + 98304) mod 65536 - 32768;
result = 163830 mod 65536 - 32768;
result = 32758 - 32768;
result = -10;

---

A further note about your code:
TIM1 is a 16-bit timer. You can't set a 16 bit register (ARR) to
65536, as that is a 17 bit value. If you write 65536 anyway it will get masked to 0 and you end up with 0 in ARR. It might work anyway, with the maximum possible period, depending how the timer hardware is implemented. For a properly defined period of 65536 you need to set ARR to 2^16 - 1 = 65535.