What is the else part in this code mean? - c

Question

I was browsing some embedded programming link
http://www.micromouseonline.com/2016/02/02/systick-configuration-made-easy-on-the-stm32/
[Note that the author of the code at the above link has since updated the code, and the delay_ms() implementation in the article no longer uses the solution shown below.]
and ended up with this following code. This is for ARM architecture but basically this is a function which will cause a delay of certain milliseconds passed as a parameter. So I could understand the if condition but why is the else condition necessary here? can someone please explain it to me?
void delay_ms (uint32_t t)
{
uint32_t start, end;
start = millis();//This millis function will return the system clock in
//milliseconds
end = start + t;
if (start < end) {
while ((millis() >= start) && (millis() < end))
{ // do nothing }
}
else{
while ((millis() >= start) || (millis() < end))
{
// do nothing
};
}
}

Answer 1

If start + t caused an overflow, end will be less than start, so the if part deals with that, and the else with the "normal" case.
To be honest, it would take some thinking about to determine whether it is actually correct, but it is hardly worth it since it is a somewhat over-complicated means of solving a simple problem. All that is needed is the following:
void delay_ms( uint32_t t )
{
uint32_t start = millis() ;
while( (uint32_t)millis() - start < t )
{
// do nothing
}
}
To understand how this works imagine start is 0xFFFFFFFF, and t is 0x00000002, after two milliseconds, millis() will be 0x00000001, and millis() - start will be 2.
The loop will terminate when millis() - start == 3. Arguably you might prefer millis() - start <= t, but then the delay will be between t-1 to t milliseconds rather than at least t milliseconds (t to t+1). Your choice, but the point is that you should compare calculate and compare time periods rather then trying to compare the absolute timestamp values - much simpler.

Answer 2

Note that the second while loop has || instead of &&. This is to handle overflow. What happens if start + t is a bigger number than end can hold? The answer is that you will get an overflow. When you add 1 to an unsigned integer that holds its maximum value, it overflows to 0.
Here is a short snippet to show the effects of overflow:
uint8_t c = 255;
uint8_t d = c+1;
printf("%d %d", c, d);
This will print 255 0
This overflow is not even an unlikely scenario in this case. The maximum value an uint32_t can hold is approx 4*10⁹. That is the amount of milliseconds that passes in 46 days.
Here is a code snippet to test it yourself:
#include <stdio.h>
#include <stdint.h>
int main()
{
uint32_t s = -2; // Initialize s to it's maximum number
// minus one via overflow
uint32_t e, t;
scanf("%d", &t);
e = s+t;
if(s<e)
printf("foo\n");
else
printf("bar\n");
}
And when I run it with different inputs:
$ ./a.out
0
bar
$ ./a.out
1
foo
However, the code is awful. See Cliffords answer for an explanation why.

Answer 3

This code is trying to deal with the rollover. Take an 8 bit counter/timer counts up lets say from 0x00 to 0xFF then rolls over to 0x00 again. If I want to use this timer to wait 16 timer ticks (0x10) (using polling) and when I start that delay the timer is at 0x1B, then I want to wait for 0x1B+0x10 = 0x2B.
Start = 0x1B, end = 0x2B, for the values 0x1B, 0x1C 0x1D...0x29, 0x2A we want to delay, start is less than end so there is no counter rollover in this code so long as t is not larger than the timer which it cant be we assume based on this code, so:
while((now>=start)&&(now<end)) continue;
Where now is sampled in that loop (while((millis()>=start).
As you pointed out, lets say
start = 0xF5, all the variables are the same size, 32 bits, mine they
are all 8 for this demonstration so 0xF5 + 0x10 = 0x05, end = 0x05 so we want to delay while now is 0xF5, 0xF6, 0xF7, 0xF8...0xFF 0x00 0x01 0x02 0x03 0x04. So we we have to split cases we have to cover, now >= start to cover the 0xF5 to 0xFF and now
while((now>=start)||(now
But as Clifford has pointed out, fundamental programming knowledge, some of the magic of twos complement the now being the first number (0xFD to 0x05):
(0xFD - 0xF5) & 0xFF = 0x08
(0xFE - 0xF5) & 0xFF = 0x09
(0xFF - 0xF5) & 0xFF = 0x0A
(0x00 - 0xF5) & 0xFF = 0x0B
(0x01 - 0xF5) & 0xFF = 0x0C
(0x02 - 0xF5) & 0xFF = 0x0D
(0x03 - 0xF5) & 0xFF = 0x0E
(0x04 - 0xF5) & 0xFF = 0x0F
(0x05 - 0xF5) & 0xFF = 0x10
Works perfect, we just need to subtract now - start for an up counter and mask the math to the size of the counter and/or variables whichever is smaller
while(((now-start)&0xFF)
For a downcounter use start - now.
The author of that code was trying to deal with the rollover without understanding twos complement. Back in the day before I learned this my code was even worse I was probably computing the math for the number of counts before the rollover then the number of counts after, whatever didnt last long I convinced myself that the rollover math works so long as you mask it right.
NOW SAYING THAT
If your timer does NOT rollover between all ones to all zeros or all zeros to all ones, which many microcontroller timers can be programmed to do and you are not using the timers features completely then the above wont work. If you have an 8 bit timer and it counts from 0x00 to 0x53 then rolls over to 0x00, because that is how you set it for some reason, or you are re-using a timer that you have set for a periodic interrupt as a polled timer, then you have to do in a better way, what the author of that code did:
while(now<0x53) continue;
while(now>end) continue;
sampling now each loop.
But the math for end does not roll over naturally you have to compute end as
end = start + t;
if(end>0x53) end = end - 0x54;
In that case though one would have to wonder why you are using a timer like that for polled timeouts, use a timer that counts all the bits and rolls over for polled timeouts use a timer that counts to N or counts to zero from N for regular periodic interrupts or can poll those as well, but in that case you are not doing generic delays necessarily....well...you could...set the timer to one millisecond, then count the rollover flags until you get to t. Easier than the now - start math. and can count as high as you want.
Millis() puts an abstraction layer between you and the timer though and we assume that millis rolls over from all ones to all zeros.
if you have a timer that counts from 0x00000000 to 0x55555555 for example and rolls over you also cannot clip it to try to get this math to work
while(((start-now)&0xFFFF)<t) continue;
that wont work because there is a point where 0xXXXX5555 rolls to 0xXXXX0000 giving you a short count that one time.
This shortcut of while(((start-now)&mask)
Otherwise you have to do something like the code you found with some modifications.
I also recommend as a habit not to sample the timer multiple times. I have seen this bug all to often:
while((timer()-start)<timeout)
{
if(read_register(n)&0x10) break;
}
if((timer()-start)>=timeout)
{
printf("Timed out\n");
return 1;
}
return 0;
Perhaps because the same coworker would implement it over and over again...
You want to sample the timer once for both use cases, if you re-sample it later
it may result in a different time. The condition may have passed within the timeout but then re-sampling the timer now times out.
instead something like
while(1)
{
delta=timer()-start;
if(delta>t) break;
if(register_read(n)&0x10) break;
}
if(delta>t)
{
printf(...
return 1;
}
return 0;
For the same reason you cant necessarily go back and read the register again to see if it was the reason why the loop was broken. Depends on that register.
And yes some folks may hate the coding style here, and consider that a bug too, point was minimize the number of times you sample the timer if you are re-using that timestamp more than once, in the case of the code you posted as written it is okay as C is supposed to evaluate left to right
millis() >= start
then
millis() < end
had it been written
while ((millis() < end) && (millis() >= start))
while ((millis() < end) || (millis() >= start))
for start
for the start>end case if the first read is less than end and it increments so it
is equal to or larger than end for the second read to compare to start, then same
deal you have to loop again to catch millis() not less than end.
So it is an extra sample but works fine. The code could have been simplified to
if(start<end)
{
while(millis()<end) continue;
}
else
{
while(millis()>=start) continue;
while(millis()<end) continue;
}
sampling once per loop.
And also note this kind of polled timer only works if you are for the most part outrunning the timer with your polling loop, you dont have interrupts that take a long time to bump you another rollover of the timer. If you are not sampling that fast, then you might want to put a limit on the size of t, make it so it cant be more than half the number of bits in the timer. How much you should limit it depends on how fast you can sample this thing.
Polled time loops should only be used for at that time or greater, if you want to time a specific amount of time the delay may run long unless you are careful, if you have interrupts or other things you may run long, maybe very long. So if you want to time say at least 10ms but 100ms now and again is okay, like bit banging i2c or spi, thats fine. But if you are trying to bit bang a uart a polled timer might not be the best way to go, depends on your system design.