Ladekurve Kondensator, Analog Comparator, ACI

[Hugo P. (portisch)]

Hallo,

ich habe jetzt einige Zeit im Netz gesucht aber keine Lösung gefunden - 
vielleicht stehe ich auch einfach auf dem Schlauch...

Ich habe einen Atmega328p und möchte über den Analog Comparator den 
Ladezustand eines Kondensators messen um damit die Kapazität bestimmen 
zu können. Es sollen ca. 1pF-500pF gemessen werden.

Nun habe ich von dem ACSR Register und dem ACI Bit gelesen. Mir fehlt 
aber eine Vorlage um das auf Papier bringen zu können.

Ich möchte die interne ACBG Referenz verwenden und damit dann die Zeit 
messen bis der Kondensator (bis ACBG) aufgeladen ist.

Gibt es da ein Beispiel in C?

[Route_66 H. (route_66)]

Hugo P. schrieb:
> Gibt es da ein Beispiel in C?

Ein Beispiel für Zeitmessungen in C?
Nicht eins, sondern ganz sicher tausende und mehr!

Such dir eins aus.

[Wolfgang (Gast)]

Hugo P. schrieb:
> Ich habe einen Atmega328p und möchte über den Analog Comparator den
> Ladezustand eines Kondensators messen um damit die Kapazität bestimmen
> zu können. Es sollen ca. 1pF-500pF gemessen werden.

Ab gewisser Genauigkeitsanforderungen würde ich 1pF als "sportlich" 
bezeichnen.

[Hugo P. (portisch)]

Habe jetzt das probiert - jedoch macht der Atmega328 immer einen Reset!?

/*
 * AVRGCC1.c
 *
 * Created: 04.04.2018 15:02:16
 */ 

#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>

#define CHARGE_C PC0
#define DISCHARGE_C PC1

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define  util_GetBitMask(bit)          (1<<(bit))
#define  util_IsBitSet(x,bit)          (((x)&(util_GetBitMask(bit)))!=0u)

void io_init(void)
{
  /* disable pullup on analog channels */
  cbi(DDRD, PD6);
  cbi(DDRD, PD7);
  PORTD &= ~(1 << PD6);                      // no Pull-up
  PORTD &= ~(1 << PD7);                      // no Pull-up
  
  ACSR |=
    (0 << ACD) |    //Comparator ON
    (1 << ACBG) |    //Connect 1.1V reference to AIN0
    (1 << ACIE) |    //Comparator Interrupt enable
    (0 << ACIC) |    //input capture disabled
    (1 << ACIS1) |    //set interrupt on falling edge (AIN1 > AIN0)
    (0 << ACIS0);    
    
  ACSR |= (1 << ACI);
}

int main(void)
{
  cli();
  wdt_disable();
  wdt_reset();
  
  DDRB = 0xFF;
  DDRC = 0xFF;
  DDRD = 0xFF;
  
  PORTB = 0;
  PORTC = 0;
  PORTD = 0;
  
  io_init();
  
  // global interrupt enable
  sei();    
  
    while(1)
    {
    // discharge C
    // set to input
    cbi(DDRC, CHARGE_C);        
    // set to output
    sbi(DDRC, DISCHARGE_C);
    
    // switch to 0 for discharge
    cbi(PORTC, DISCHARGE_C);
    // wait until C is discharged  
    _delay_ms(100);
    
    // set to input
    cbi(DDRC, DISCHARGE_C);        
    // set to output
    sbi(DDRC, CHARGE_C);
    
    // start charging
    sbi(PORTC, CHARGE_C);  
    
    // wait for interrupt
    while(!util_IsBitSet(ACSR, ACI))
      wdt_reset();
    
    _delay_ms(100);
    }
}

ISR(ANA_COMP_vect)
{
  // clear interrupt
  sbi(ACSR, ACI);
}

Ich komme bis zu dem while(!util_IsBitSet(ACSR, ACI)) - dann gibt es 
einen Reset. Im Debugger sehe ich, dass das ACI Flag gesetzt ist.

[Boris O. (bohnsorg)]

Das Bit soll ja gesetzt sein, wenn der Komparator den gewünschten 
Zustand erkannt hat...was er vielleicht hat? Ich finde es auch ein wenig 
krude, die Ein- und Ausgabe-Steuerung auf die Makros zu verteilen und 
dahinter PC1 und PC0 zu legen. Ich hätte eher mit etwas in der Form DDRC 
= (1 << PC0) | (1 << PC1) gerechnet, irgendwie in Funktionen gekapselt. 
(Der Compiler macht daraus bei Bedarf ohnehin Inline-Konstrukte.)

[Hmmm (Gast)]

ist der gezeigte Code wirklich von dir?

[Hugo P. (portisch)]

Das ganze ist ja noch im Aufbau und nur für Tests gedacht. Jedoch komme 
ich nicht darauf warum der AVR einen Reset macht!?

In die ISR Routine kommt er gar nicht mehr.

[Reiner_Gast (Gast)]

Hugo P. schrieb:
> ISR(ANA_COMP_vect)
> {
>   // clear interrupt
>   sbi(ACSR, ACI);
> }
> Ich komme bis zu dem while(!util_IsBitSet(ACSR, ACI)) - dann gibt es
> einen Reset. Im Debugger sehe ich, dass das ACI Flag gesetzt ist.

Die While Schleife dürfte nie verlassen werden, weil laut Datenblatt das 
Bit bei Ausführung der ISR gelöscht wird:

"Bit 4 – ACI: Analog Comparator Interrupt Flag
This bit is set by hardware when a comparator output event triggers the 
interrupt mode defined by ACIS1 and
ACIS0. The Analog Comparator interrupt routine is executed if the ACIE 
bit is set and the I-bit in SREG is set.
ACI is cleared by hardware when executing the corresponding interrupt 
handling vector. Alternatively, ACI is
cleared by writing a logic one to the flag."

Hast du auch einen Schaltplan zu deinem Projekt?

[Hugo P. (portisch)]

Der Fehler:

ISR(ANA_COMP_vect)

Es gehört:

ISR(ANALOG_COMP_vect)

Nun gibt es keinen Reset mehr!
Der Compiler hat aber nicht gemeckert...

[Hugo P. (portisch)]

Jetzt habe ich noch eine Frage. Ich habe nun den Source so umgebaut:

/*
 * AVRGCC1.c
 *
 * Created: 04.04.2018 15:02:16
 */ 

#include <avr/io.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include "uart/uart.h"
#define BAUD  9600L

#define CHARGE_C PC0
#define DISCHARGE_C PC1

#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define  util_GetBitMask(bit)          (1<<(bit))
#define  util_IsBitSet(x,bit)          (((x)&(util_GetBitMask(bit)))!=0u)

uint8_t average[100] = {0};
int actual_value;

void io_init(void)
{
  // all pins output
  DDRB = 0xFF;
  DDRC = 0xFF;
  DDRD = 0xFF;
  
  PORTB = 0;
  PORTC = 0;
  PORTD = 0;
    
  /* disable pull up on analog channels */  
  cbi(DDRD, PD6);      // switch to input
  cbi(DDRD, PD7);      // switch to input
  PORTD &= ~(1 << PD6);  // no Pull-up
  PORTD &= ~(1 << PD7);  // no Pull-up
  
  ACSR |=
    (0 << ACD) |    //Comparator ON
    (1 << ACBG) |    //Connect 1.1V reference to AIN0
    (0 << ACIE) |    //Comparator Interrupt enable
    (1 << ACIC) |    //input capture disabled
    (1 << ACIS1) |    //set interrupt on falling edge (AIN1 > AIN0)
    (0 << ACIS0);    
    
  ACSR |= (1 << ACI);
}

void discharge_c(void)
{
  // set to input
  cbi(DDRC, CHARGE_C);        
  // set to output
  sbi(DDRC, DISCHARGE_C);
    
  // switch to 0 for discharge
  cbi(PORTC, DISCHARGE_C);  
}

int main(void)
{
  cli();
  MCUSR = 0;
  wdt_disable();

  io_init();
  
  // timer 1 counter init
    TCCR1A =  0; //16 bit counter normal mode
  TCCR1B = (1 << ICNC1) | (1 << CS10); // INPUT CAPTURE EDGE DETECTOR SELECT TO RISING EDGE & and counter prescaler
  TIMSK1 = (1 << ICIE1);// enable input capture interrupt  
  
  // Clear all flags before beginning
  TIFR1 = (1 << ICF1);
  ACSR |= (1 << ACI);  
  
  // initialize uart  
  uart_init((UART_BAUD_SELECT((BAUD),F_CPU)));  
  
  uint8_t tifr;
  uart_putc(0xFF);
  
    while(1)
    {
    for (actual_value = 0; actual_value < sizeof(average); actual_value++)
    {
      // discharge C
      discharge_c();
      // wait until C is discharged  
      
      
      if (actual_value == sizeof(average) - 1)
        _delay_ms(20);
      else
        _delay_ms(10);
    
      // set to input
      cbi(DDRC, DISCHARGE_C);        
      // set to output
      sbi(DDRC, CHARGE_C);
      
      // start charging
      ACSR |= (1 << ACI);  
      
      // start counting
      ICR1 = 0;
      TIFR1 = _BV(ICF1) | _BV(OCF1A); // clear input capture and output compare flag bit
      PORTD |= ( 1 << PD5 );
      // start charging
      sbi(PORTC, CHARGE_C);  
      
      // wait until output is high
      while(! ( PINC & ( 1 << CHARGE_C )))
        ICR1 = 0;
    
      // wait for timer counter interrupt
      while(! (tifr = (TIFR1 & (_BV(ICF1) | _BV(OCF1A)))));
      
      if(!(tifr & _BV(OCF1A))) // check for overflow bit
      {
        // stop counting
        average[actual_value] = ICR1;        
        PORTD &= ~( 1 << PD5 );
        
        if (actual_value == sizeof(average) - 1)
        {
          uint32_t sum = 0;
    
          for (int loop = 0; loop < sizeof(average); loop++)
            sum = sum + average[loop];
      
          sum /= sizeof(average);

          uart_putc((sum >> 8) & 0xFF);
          uart_putc(sum & 0xFF);    
        }          
      }
      else
      PORTD &= ~( 1 << PD5 );  
    }      
    }
}

Mit dem Oszi messe ich eine Zeit von ~205µs. Ich habe einen 12MHz Quarz 
und einen Prescaler von 1. Somit sollte in ICR1 ein Wert von ~2500 
rauskommen. Ich bekomme aber bei 100 Werten im Mittel zwischen 120-140 
Counts.

Das sind dann 1/12000000 * 130 == ~11µs ??
Der PD5 wird nur als Trigger für das Oszi hergenommen (Channel 3, blau).
Channel 1, gelb, ist die Spannung am Kondensator.

[Hugo P. (portisch)]

EDIT: uint8_t average[100] = {0};
Kann nicht gehen in einem uint8_t array uint16_t Werte abzulegen.

Jetzt bekomme ich einen Wert von ~2475:
Das sind dann ca. 0,00020625 Sekunden. Passt also!