C question on this line of code ."while (--delay > 0);"

Question

I am using a PIC to control a 28BYJ-48 stepper motor using a ULN2003 driver board. I have found a code that works perfectly but trying to understand what one line of code is doing.

Having searched I have not come across this being raised in the past. I am a new comer to C programming and learning from other peoples code. I came across this in a code which works as I would expect it to.

if(Wait > 0) /* Wait is set in the void main void which calls this in the function*/
{
    delay = Wait;  /*delay takes the value of wait*/
    do {
       while(INTCONbits.T0IF == 0) {} 
       INTCONbits.T0IF = 0;
    } while (--delay > 0);
}

The while (--delay > 0);.

Has me stumped as the delay is taken from a know value and passed into a function call so what does the -- have to do with it.

I know is some languages its used to decrement the variable either after it has been read but as far as I am aware the value is not being lowered.

Any help or pointer would be appreciated.

Edited to show more of the code.

void StepMotor(int16_t Count, uint8_t Wait)
{
    static uint8_t state = 0;
    /*  values for half step             0001, 0011, 0010, 0110, 0100, 1100, 1000, 1001*/
    static const uint8_t HalfSteps[8] = {0x01, 0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x09};
    uint8_t delay;

    do
    {
        if (Count > 0)
        {
            PORTC = HalfSteps[state];   /* drive stepper to select state */
            state++;                    /* step one state clockwise */
            state &= 0x07;              /* keep state within HalfStep table */
            Count--;                    /* update step count */
        }
        else if (Count < 0)
        {
            PORTC = HalfSteps[state];  /* drive stepper to select state */ 
            state--;                   /* step one state counterclockwise */ 
            state &= 0x07;             /* keep state within HalfStep table */ 
            Count++;                   /* update step count */ 
        }
        /* Wait between steps */
        if(Wait > 0) /* Wait is set in the void main void which calls this in the function*/
        {
            delay = Wait;  /*delay takes the value of wait*/
            do {
               while(INTCONbits.T0IF == 0) {} 
               INTCONbits.T0IF = 0;
            } while (--delay > 0);
        }
    } while (Count != 0);
}

void main(void) 
{
    /*
     * Application initialization
     */
    Init_PIC();
    /*
     * Application process loop
     */
    while(1)
    {
        StepMotor(4076, 4);     /* step about 1/2 a revolution clockwise at 4.096 milliseconds per step (about 8 seconds) */
        __delay_ms(1000);
        StepMotor(-2038, 2);    /* step about 1/2 a revolution counterclockwise at 2.048 milliseconds per step (about 4 seconds) */
        __delay_ms(1000);
        StepMotor(-2038, 2);    /* step about 1/2 a revolution counterclockwise at 2.048 milliseconds per step (about 4 seconds) */
        __delay_ms(1000);
    }
}

Maybe this is more helpful to get an answer to my question what is the "while (--delay > 0); "

doing.

Answer 1

It decrements the delay value, then checks to see if the value is still greater than zero. If it is, the body of the loop executes again.

Answer 2

The test (--delay > 0) first decrements delay and compares the result with 0. The do/while loop iterates delay times exactly if it is entered with a value of delay that is > 0, hence the initial test if (Wait > 0) {

These do / while loops are confusing and error prone.

The first fragment in the question is more readable as:

    for (delay = 0; delay < Wait; delay++) {
        while (INTCONbits.T0IF == 0)
            continue;
        INTCONbits.T0IF = 0;
    }

Or possibly:

    for (delay = Wait; delay > 0; delay--) {
        while (INTCONbits.T0IF == 0)
            continue;
        INTCONbits.T0IF = 0;
    }

Similarly, because of the do/while loop, in the StepMotor, the function will wait even if the initial value of Count is 0, which seems unnecessary since the step motor does not move at all.

Here is an alternative:

void StepMotor(int16_t Count, uint8_t Wait) {
    static uint8_t state = 0;
    /*  values for half step             0001, 0011, 0010, 0110, 0100, 1100, 1000, 1001*/
    static const uint8_t HalfSteps[8] = {0x01, 0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x09};
    uint8_t delay;

    while (Count != 0) {
        if (Count > 0) {
            Count--;                   /* update step count */
            PORTC = HalfSteps[state];  /* drive stepper to select state */
            state++;                   /* step one state clockwise */
            state &= 0x07;             /* keep state within HalfStep table */
        } else {
            Count++;                   /* update step count */ 
            PORTC = HalfSteps[state];  /* drive stepper to select state */ 
            state--;                   /* step one state counterclockwise */ 
            state &= 0x07;             /* keep state within HalfStep table */ 
        }
        /* Wait between steps */
        for (delay = Wait; delay > 0; delay--) {
            while (INTCONbits.T0IF == 0)
                continue;
            INTCONbits.T0IF = 0;
        }
    }
}

Answer 3

--i is close to i --, or i = i - 1.

Although, it has differences! E.g.: (in this case)
while(i-- > 0) something(); is close to: while(i > 0) { i --; something(); }, but
while(--i > 0) something(); is close to: i --; while(i > 0) { something(); i --; }.

I'm sure there are some other weird differences between them, you can just look up pre-increment & post-increment, as was already suggested by Saxbophone.

while(--i > 0); simply decrements the value of i until it reaches 0.
do; while(--i > 0); does everything, then decrements i, so it loops until i reaches 0, however i is only 0 after the loop, minimum i inside of the loop is 1.

int i = 4; // uint8_t and int are SIMILAR
do {
  printf("%d, ", i);
} while(--i > 0);
printf("after: %d", i);

outputs: 4, 3, 2, 1, after: 0.

uint8_t is unsigned 8 bit integer. In this case, unsigned means the number is ALWAYS positive, it doesn't have minus sign.

Answer 4

Let's do it another way, I hope that will help.

if(Wait > 0) /* Wait is set in the void main void which calls this in the function */
{
    delay = Wait;  /* delay takes the value of wait */
    do {
        while(INTCONbits.T0IF == 0) {} 
        INTCONbits.T0IF = 0;
        delay = delay - 1;
    } while (delay > 0);
}

Answer 5

The origin of John's question starts with this topic on the Microchip forum.

John seemed to be struggling with some of the fundamental syntax and concepts of the C programming language. To help John I created an MPLABX project to demonstrate how I would format the C language file and implement a process loop to perform the animation sequence described.

There are some concepts that John will need to consider to fully understand the code and the choices to use the specific syntax. In general there are three ways to loop in C:

• The for(sss;ccc;iii); statement
• The while(ccc){} statement
• The do {} while(ccc); statement

Consult any C language reference for more details on how these differ.

Having used the Microchip C compilers for a long time I have found they generate better code for counting down an unsigned value to zero using a do {} while(ccc); statement.

The reason for the less than clear } while (--delay > 0); syntax is the XC8 C compiler will generate slightly more efficient machine code. In all honesty I write this kind of looping structure so often it's just a reflex now. I apologize for using a syntax that is pushing you up the learning curve too fast.

It's really excellent that you received such good answers to your question. It seems a shame that some narrow minded bigots have down voted your question. To me it seems better written than a lot of questions that show up here.

To address the debugging issue raised in the comments. Microchip no longer sells the AC162052 hardware debug header for the PIC16F676. Without it In-Circuit-Debug of this target is impossible.

Answer 6

The reason I am adding my answer to this thread is from the initial question on the Microchip website which was a for loop question which got answered very quickly. I showed my first attempt at controlling the stepper motor. However this was starting the stepper motor in one direction and when I pressed a button the motor changed direction, on releasing the button the motor returned to its original rotation.

I then mentioned I would like to be able to set the steps and the speed of the stepper motor without the use of a button. I was after something similar to the Arduino stepper.h library.

Dan created the first version of his code to do a number of actions with the stepper motor. This solution was excellent and allowed me to have direction and steps and speed control of the stepper motor with the PIC16F676 chip.

Then I mentioned the use of a simple homing function so the motor would home first and then move in the direction and speed I could set in the code.

Dan quickly came up with that solution as well and this now has given me every thing the stepper.h library could do The code on his github will help others trying to work with the 28 BYJ-48 bi polar stepper motor using the ULN2003 driver module. Which makes it great for model animation.

It is working on a bread board at the moment but will be shown in the next week once I have created the diorama for it.

The are no doubt other functions that could be added in the future as so far it is using only 38% of the program words and 22% of the data memory of the PIC.

Dan's github page is https://github.com/dsoze1138/16F676_Frameworks

I have also added a video to my Youtube channel explaining with the help of Dan how to work with the Pic16F676 and the 28 BYJ- 48 stepper motor. This is version 2 before the use of the Homing function added by Dan. See https://youtu.be/XVpI7lcXJQg

Answer 7

The final version 2 code can be seen in my github page.

https://github.com/johnmholmes/PIC16F676_Basic_C-programming_Pickit_3_MPLAB_X_IDE

This cover getting started on my journey with the Pickit 3 and the Pic16F676 micro controller.

This is part 10