Genauer ungenau Counter

#define STATE_RISING   0

#define STATE_FALLING  1

#define STATE_EVALUATE 2

static unsigned char icp_state = STATE_RISING;

static unsigned int dutycycle_value;

static volatile unsigned int periode_value;

static volatile unsigned char periode_value_changed = 0;

/*

 * Liefert neue Periodendauer oder 0 falls nicht Neues

 */

unsigned int getNewPeriodValue(void)

{

    unsigned int ret_val = 0;

    cli();  // atomare opertation

    if(periode_value_changed)

    {

        periode_value_changed = 0;

        ret_val = periode_value;

    }

    sei();

    return ret_val;

}

/*

 * Zu beachten ist, dass die Periodendauer natürlich kleiner als die 

 * Zeit eines vollen Zählerdurchlaufes ist.

 * Der Zähler muss nicht auf 0 gesetzt werden.

 * Die Diskussion ob a-b == -(-a - (-b)) ist, 

 * wurde bereits in der Schule geführt ;) 

 */

SIGNAL (SIG_INPUT_CAPTURE1)

{

  //cli() ist absolut überflüssig, sind im "SIGNAL" disabled.

  //TCCR1B|= (1<<CS11); Input Capture stoppt doch den Zähler nicht;

Oder? Also weg damit!

  switch(icp_state)

  {

    case STATE_RISING:   

        TCCR1B &= ~(1<<ICES1);  // Falling edge will trigger capture.

      icp_state++;

        break;

    case STATE_FALLING:  

        dutycycle_value = ICR1;

          // Alle mir bekannten AVRs haben ICRH+ICRL so dass man sie als

          // als 16Bit Wert auslesen kann.         

      TCCR1B|= (1<<ICES1);  // Rising edge will trigger capture.

      icp_state++;

        break;

    case STATE_EVALUATE:  

        periode_value = ICR1 - dutycycle_value;

        periode_value_changed = 1;

      TCNT1= 0x00; // Warum???

      TCCR1B&= ~(1<<ICES1);  // Falling edge will trigger capture.

      icp_state = STATE_FALLING;

        break;

    default:  

        errorcount++;

            periode_value_changed = 0;

      icp_state = STATE_RISING;

        break;

  }

  sei();  // Wird von "SIGNAL" sowiso wieder gesetzt, als weg

}

#define STATE_RISING   0 /* Initialisierungsphase */

#define STATE_FALLING  1 /* Warten auf fallende Flanke */

#define STATE_EVALUATE 2 /* Warten auf steigende Flanke */

/* Alle Werte gelesen und nichts Neues zu melden ;) */

#define NEW_VALUE_NONE  0

/* Dauer obere/untere <Anführungszeichen>Halbwelle</Anführungszeichen>

*/

#define NEW_VALUE_UPPER 1

#define NEW_VALUE_LOWER 2

static unsigned char icp_state = STATE_RISING;

static unsigned int dutycycle_value;

static volatile unsigned int periode_value;

static volatile unsigned char periode_value_changed = NEW_VALUE_NONE;

/*

 * Liefert neue Periodendauer oder 0 falls nicht Neues.

 *

 * Die Dauer der oberen "Halbwelle" wird als positiver,

 * die Dauer einer unteren "Halbwelle" als negativer

 * Wert geliefert.

 */

signed long getNewPeriodValue(void)

{

    signed long ret_val = 0L;

    cli();  // atomare opertation

    if(periode_value_changed == NEW_VALUE_UPPER)

    {

        ret_val = periode_value;

        periode_value_changed = NEW_VALUE_NONE;

    }

    elseif(periode_value_changed == NEW_VALUE_LOWER)

    {

        ret_val = periode_value;

        ret_val = -ret_val;

        periode_value_changed = NEW_VALUE_NONE;

    }

    sei();

    return ret_val;

}

/*

 * Zu beachten ist, dass die Periodendauer

 * natürlich kleiner als die

 * Zeit eines vollen Zählerdurchlaufes ist.

 * Der Zähler muss nicht auf 0 gesetzt werden.

 * Die Diskussion ob a-b == -(-a - (-b)) ist,

 * wurde bereits in der Schule geführt ;)

 */

SIGNAL (SIG_INPUT_CAPTURE1)

{

    unsigned int temp;

  switch(icp_state)

  {

    case STATE_RISING:

        temp = ICR1;

        // Falling edge will trigger capture.

        TCCR1B &= ~(1<<ICES1);

      icp_state++;

        break;

    case STATE_FALLING:

        temp = ICR1;

        periode_value = temp - dutycycle_value;

        periode_value_changed = NEW_VALUE_UPPER;

        // Rising edge will trigger capture.

      TCCR1B |= (1<<ICES1);

      icp_state++;

        break;

    case STATE_EVALUATE:

        temp = ICR1;

        periode_value = temp - dutycycle_value;

        periode_value_changed = NEW_VALUE_UPPER;

        // Falling edge will trigger capture.

      TCCR1B &= ~(1<<ICES1);

      icp_state = STATE_FALLING;

        break;

    default:

        errorcount++;

      icp_state = STATE_RISING;

            // Wait for rising edge to start over

      TCCR1B |= (1<<ICES1);

        break;

  }

    dutycycle_value = temp;

}