ATtiny 0/1-series: Use DAC output as input to Analog Comparator (AC)

[ArnieO]

I'm working on an application with an ATtiny1614 where I need to compare an input to a fixed voltage level.

The documentation correctly says that DACREF cannot be used on the 0/1 series.

However, the datasheet (section 29) indicates that also the DAC output can be used as input for the comparator:

Side note: DACREF seems to have been mentioned in earlier issues of the datasheet, as I find this in the Revision history:

(AC = Analog Comparator)

Am I correct to assume that the feature to use DAC output as comparator input is just not implemented here yet?
It would be great to see it in a future revision!

[hmeijdam]

You could try setting the AC positive MUX manually via

AC0_MUXCTRLA |= _BV(ADC_MUXPOS_DAC0_gc) ;

[ArnieO]

Thank you for your response!
I have now tried in my code to set the MUX manually, but am not able to make it work as I want.
What I want to do is detect / count flanges on a signal that swings between Vcc/GND and decays towards Vcc (blue trace on below scope picture).
I have successfully implemented such counting using Vref on the negative input of the Comparator, the issue is I have only some few distinct Vref levels to choose from.
I would like to do the detection at a selectable level, which is why I want to use DAC as input to the Analog comparator. It should be possible to fine tune the DAC output that is input to the comparator using what I assume is an 8-bit attenuator (set by my setDACReference() function in below code).
The yellow trace on the below scope plot is the DAC output, we see that it correctly detects flanges on the input signal.
However, I see no change on the DAC output when I change

• DAC reference voltage (currently set to VREF_DAC0REFSEL_4V34_gc) or ....
• The attenuator (currently set to 127, which should give detection around 2.15V when using VREF_DAC0REFSEL_4V34_gc).

Any idea what I could try?

I am coding in Arduino IDE v2.3.3 using megaTinyCore v2.6.10.

This is my code. The blue signal is generated on my board from the trig pulse generated in loop().

/*
  Runs on ATtiny1614
*/

#include <Comparator.h>

// Pin definitions
#define LED_PIN PIN_PA6
#define PIN_COIL_TRIG PIN_PA1
#define PIN_COIL_SENSE_AC PIN_PA7     // This is connected to AC input 0 (in0)
#define PULSE_DURATION 140            // microseconds
#define PULSE_INTERVAL 500            // milliseconds

// DAC reference value (0-255)
#define DAC_REF_VALUE 127            // Approximately mid-supply voltage

// Variables to track timing
unsigned long lastPulseTime = 0;

void setup() {
  // Configure pins
  pinMode(LED_PIN, OUTPUT);
  pinMode(PIN_COIL_TRIG, OUTPUT);
  digitalWrite(PIN_COIL_TRIG, LOW);
  digitalWrite(LED_PIN, LOW);

  // Initialize DAC without output to external pin
  VREF.CTRLA = VREF_DAC0REFSEL_4V34_gc;     // Set DAC reference to 4.34V (can be 2.5V, 0.55V, etc.)

  DAC0.CTRLA = DAC_ENABLE_bm;               // Enable DAC (DO NOT use DAC_OUTEN_bm to keep output internal only)
  setDACReference(DAC_REF_VALUE);           // Set initial DAC value

  // Configure the comparator using the library
  Comparator.input_p = comparator::in_p::in0; // Use positive input 0 (PA7)
  Comparator.hysteresis = comparator::hyst::small; // Use 10mV hysteresis
  Comparator.output = comparator::out::disable; // Disable output pin

  // Explicitly set DAC as negative input (internal routing)
  AC0.MUXCTRLA = AC_MUXNEG_DAC_gc | AC_MUXPOS_PIN0_gc; // Set AC to use DAC as negative input, PA7 as positive

  // Initialize comparator
  Comparator.init();

  // Attach interrupt to directly reflect comparator state on LED
  Comparator.attachInterrupt(compInterrupt, CHANGE);
  Comparator.start();
}

void loop() {
  unsigned long currentTime = millis();
  
  // Time for a new pulse?
  if (currentTime - lastPulseTime >= PULSE_INTERVAL) {
    generatePulse();
    lastPulseTime = currentTime;
  }
}

// Interrupt handler for comparator
void compInterrupt() {
  // Directly reflect comparator output on LED
  if (Comparator.read() == HIGH) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
}

// Generate trigger pulse
void generatePulse() {
  digitalWrite(PIN_COIL_TRIG, HIGH);
  delayMicroseconds(PULSE_DURATION);
  digitalWrite(PIN_COIL_TRIG, LOW);
}

// Function to adjust DAC reference value (0-255)
void setDACReference(uint8_t value) {
  DAC0.DATA = value; // Set DAC output value
}

[grandaspanna]

Pretty sure that:
Comparator.init();

Will override:
AC0.MUXCTRLA = AC_MUXNEG_DAC_gc | AC_MUXPOS_PIN0_gc;

Since the init function resets the inputs.

Simple idea would be to put your input line after the init() function?

However, your suggestion of making this a feature of the library appears sensible.

[ArnieO]

Thank you for responding! I have in the mean time slightly modified my board, to provide a reference voltage on a pin for the comparator. This changed the response when I run the same code (so the 1614 should not see that input, as it is not used in the code yet):

When I swap the two lines as per your suggestion, there is a distinct change - so it clearly does something:

But I still see the same as before: Changing VREF_DAC0REFSEL_4V34_gc or the attenuator value (now 127) gives no change.

The fact that the code seems to see the voltage I have applied on AINN0 indicates that the MUX setting is incorrect?
If so, it would make sense that DAC0.DATA = value; does nothing - because the comparator does not receive the DAC voltage.

Also, the first plot here above makes sense if comparator reads the external reference voltage, which is set at 90% of Vcc.

The library looks correct, here are the relevant definitions in iotn1614.h:

/* Negative Input MUX Selection */
typedef enum AC_MUXNEG_enum
{
    AC_MUXNEG_PIN0_gc = (0x00<<0),  /* Negative Pin 0 */
    AC_MUXNEG_PIN1_gc = (0x01<<0),  /* Negative Pin 1 */
    AC_MUXNEG_VREF_gc = (0x02<<0),  /* Voltage Reference */
    AC_MUXNEG_DAC_gc = (0x03<<0)  /* DAC output */
} AC_MUXNEG_t;

/* Positive Input MUX Selection */
typedef enum AC_MUXPOS_enum
{
    AC_MUXPOS_PIN0_gc = (0x00<<3),  /* Positive Pin 0 */
    AC_MUXPOS_PIN1_gc = (0x01<<3),  /* Positive Pin 1 */
    AC_MUXPOS_PIN2_gc = (0x02<<3),  /* Positive Pin 2 */
    AC_MUXPOS_PIN3_gc = (0x03<<3)  /* Positive Pin 3 */
} AC_MUXPOS_t;

So... what happens if I swap the two lines as per your suggestion?
The definition of the init function (in Comparator.h) is here:

megaTinyCore/megaavr/libraries/Comparator/src/Comparator.cpp

Line 304 in f0e5976

void AnalogComparator::init() {

But this is too complex for me to figure out whether it would override if placed after
AC0.MUXCTRLA = AC_MUXNEG_DAC_gc | AC_MUXPOS_PIN0_gc;

EDIT:
The code in my previous post definitively reads the reference voltage on AINN0. I confirmed it by shorting one of the resistors in the resistor divider while observing the scope. So the MUX setting is incorrect.

[MX682X]

1. Modifing Peripheral Registers without the knowledge of the library is always a bad idea.
   If you want to experiment, do the modifications after the peripheral was initialized. Or just set the registers yourself.

2. The 0/1 Series has no DACREF, that is correct, but the 1-Series has 3 DACs, connected correspondigly to the 3 ACs. DAC0 is the only one with an output buffer though. They moved the DAC to the AC register space on the later parts and renamed it to DACREF.

3. I've copy pasted some code together that uses the DAC0 as reference.

Comparator.input_p = comparator::in_p::in0; // Use positive input 0 (PA7)
Comparator.input_n = comparator::in_n::dacref;    // Connect the negative pin to the DAC0
Comparator.reference = comparator::ref::vref_4v096 ; // Set the DAC Reference voltage to 4.096V
Comparator.hysteresis = comparator::hyst::small; // Use a 10mV hysteresis
Comparator.dacref = 127;              // Gives us 2.048V
Comparator.output = comparator::out::disable;      // Disable output

Comparator.init();
Comparator.attachInterrupt(compInterrupt, CHANGE);
Comparator.start();

[ArnieO]

1. I am doing my best, and I admit this is a learning curve for me! Your input and advice is therefor valuable.
2. You write:
   They moved the DAC to the AC register space on the later parts and renamed it to DACREF.
   This is a bit confusing, as the latest datasheet ("(C) 2020" in the page footer) has only one reference to the term DACREF, and that is in the revision notes:
   

I will make an attempt during the week-end with the code snippet you propose and report back here.

[MX682X]

They named it first DACREF, but as the AC0 is using DAC0 as input, the DAC0 is not exclusive to the AC0 and has an ouput buffer. The Dx Series, for example, has a DAC exclusively for each AC.
I guess to avoid mix-ups, Microchip renamed the DACREF on the Tiny to simply DAC.

[ArnieO]

And ... your code snippet works!

It just needs one minor but important adjustment: You cannot use a "Comparator Vref", but must instead use a valid Vref for ADC, which is a different set of values. In my case (I am on an ATtiny1614, which is 1-series) I use:
Comparator.reference = comparator::ref::vref_4v3; // 4.3V internal reference

So to be clear:

• Even if the code looks as if we're setting a reference for the comparator, we cannot use the Vref values intended for the comparator, as specified here.
• Instead, we have to select valid ADC Vref values, as specified here.

It is in a sense logical, but makes the code a bit less readable.

Thank you very much for your kind help!