How often/when does C execute content within if/else statements?

Question

I'm working on an embedded (avr) project, and basically I want to print out a few different things based on how long a pin has been pressed down. I can't figure out what happens as the value passes through and satisfies if statements along the way (button is still pressed so counter increments).

The setup is as follows:

if overflows is between 7-48 (button pressed for 30ms-200ms), print out a '.'
if overflows is greater than 48 (button pressed for greater than 200ms), print out a '-'
if overflows is greater than 97 (button has not been pressed in over 400ms), print out a ' '

My current code is as follows:

static inline void isr(char type) {
static unsigned int overflows = 0;
static unsigned char idx = 0;
if (type == 'e') { // edge captured
    if (TCCR1B & 0x40) { // rising edge
        if (overflows < 7) {
            // do nothing
        } else if (overflows < 49) {
            buffer[idx++] = '.';
            size++;
        } else {
            buffer[idx++] = '-';
            size++;
        }
    }
    overflows = 0; // restart counting overflows at each edge
} else { // overflow occured
    overflows++;
    if (buffer[idx-1] != ' ' && !(TCCR1B & 0x40) && overflows > 97) {
        buffer[idx++] = ' ';
        size++;
    }
}

I'm not sure if this is correct though, since it would seem that there would always be a '.' preceding a '-', since as the overflow value is incremented, it satisfies the <49 condition.

Any thoughts?

Answer 1

if you want to count no.of times switch pressed, you can use while loop. for example,

    if(sw==0) //sw is switch connected with I/O pin
    {
      while(sw==0)
      {
       led=1; //LED is output
       delay(); // use delay function
       led=0;
       delay();
       count++;
       }
     }

by using while loop, you can avoid from getting multiple times switch pressed. if you make one on and off switch, the count will be increased by one.

Answer 2

I'm not sure if this is correct though, since it would seem that there would always be a '.' preceding a '-', since as the overflow value is incremented, it satisfies the <49 condition.

But the tests are performed only on the rising edge - when both type == 'e' and (TCCR1B & 0x40) != 0. So the overflow count is evaluated only when the button is released, so you will not see the intermediate . before -.

So to answer your question, a conditional statement or block is executed when the condition is true. Here you have nested conditionals, so all preceding conditions must be true for the inner condition to be evaluated.

Answer 3

According to your description I assume you have a button on your pin, so in this case the first thing what I would recommend before doing anything is to implement a debounce for the button signal. I would solve the problem something like this:

#define BUTTON_UNKNOWN  0
#define BUTTON_DOWN     1
#define BUTTON_UP       2

#define FALSE           0
#define TRUE            1

static inline unsigned char debounce( unsigned char current_state)
{
static unsigned char ret_value;
unsigned char state_changed = FALSE;
// Counter for number of equal states
static unsigned char count = 0;
// Keeps track of current (de-bounced) state
static unsigned char button_state = 0;
// Check if button is high or low for the moment
if (current_state != button_state) 
{
    // Button state is about to be changed, increase counter
    count++;
    if (count >= 3) 
        {
        // The button have not bounced for four checks, change state
        button_state = current_state;
        // If the button was pressed (not released), tell main so
        count = 0;
        state_changed = TRUE;
        }
} 
else 
{
state_changed = FALSE;
// Reset counter
count = 0;
}

//if butten press or release detected
if (state_changed == TRUE)
{
    //check for the current state of the button
    if (current_state != 0) 
        {
        ret_value = BUTTON_DOWN;
        }
    else
        {
        ret_value = BUTTON_UP;
        }
}

return ret_value;
}

int main(void)
{
//perform proper initialization of your pin

unsigned char button = BUTTON_UNKNOWN;    
unsigned char cycle_count  = 0;
unsigned char idx = 0;
unsigned char buffer[255];
unsigned char current_state;
unsigned char no_activity;
//unsigned char current_state = (~BUTTON_PIN & BUTTON_MASK) != 0;

while(1)
{
//read the button state
current_state = (~BUTTON_PIN & BUTTON_MASK) != 0;
// Update button_state
button = debounce(current_state);
// Check if the button is pressed.
if (button == BUTTON_DOWN)
{
    //count cycles in which the button was pressed
    //one cycle is 10 ms - see delay below
    cycle_count++;
}
else
{
    //check if the button was pressed before
    if ((button != BUTTON_UNKNOWN) && (cycle_count != 0))
    {
        //if button was pressed for 200ms
        if (cycle_count <= 20)
        {
            buffer[idx] = '.';
            idx++;            
        }
        else
        {
            //if the button was pressed between 200 and 400 ms
            if ((cycle_count > 20) && (cycle_count <= 40))
            {
               buffer[idx] = '-';
               idx++;
            }
            //the button was pressed for more than 400ms, uncomment if you need it

            /*else
            {
               buffer[idx] = ' ';
               idx++;
            }*/

        }
        //reset counting mechanism
        cycle_count = 0;
        no_activity = 0; 
    }
    else
    {
        no_activity++;
        if (no_activity >= 40)
        {
            buffer[idx] = ' ';
            idx++;
            no_activity = 0;
        }
    }
}

// Delay for a while so we don’t check to button too often
_delay_ms(10);
}
}

You can adapt this code according to your needs: change the line current_state = (~BUTTON_PIN & BUTTON_MASK) != 0; so that to read your pin state, and change the declaration of the buffer to suite your needs unsigned char buffer[255];

Please note that due to the debounce the time measured is not exactly 200ms ( it is 200ms + 2*debounce_time = 260ms (debounce time is 3 cycles, each cycle is 10ms, see delay at the end), but you may compensate these errors by reducing the contants in the cycle_count comparisons in the end.

Hope this helps!

If you really stick to your solution, then to avoid the problem what you experience is to not evaluate the overflow value continuously, do not try to determine the length of the button push on the fly, try instead to measure the length of the push and after that evaluate it and put the char in the buffer. You need to wait for the 'release button' and then evaluate how much time the button was pressed. Something like this:

static inline void isr(char type) {
static unsigned int overflows = 0;
static unsigned char idx = 0;
unsiged char button_status;

if (type == 'e') { // edge captured
    if (TCCR1B & 0x40) { // rising edge
        //perform a debounce otherwise wont be good
        button_status = 1;

    }
    overflows = 0; // restart counting overflows at each edge
} else { // overflow occured  
    overflows++;
     //if button was pressed and its now released evaluate result
    if (!(TCCR1B & 0x40) && (button_status == 1))
    {
        if (overflows < 7) {
            // do nothing
        } else if (overflows < 49) {
            buffer[idx++] = '.';
            size++;
        } else {
            buffer[idx++] = '-';
            size++;
        }
        button_status = 0;
    }
    if (buffer[idx-1] != ' ' && !(TCCR1B & 0x40) && overflows > 97) {
        buffer[idx++] = ' ';
        size++;
    }
}