KL25Z Comparator library

Dependents:   ComparatorIn_demo TEMT6200_demo 05_comparator_demo 05_comparator_demo ... more

KL25Z Comparator library

Comparator features

  • Operational over the entire supply range
  • Inputs may range from rail to rail
  • Programmable hysteresis control
  • Selectable interrupt on rising-edge, falling-edge, or both rising or falling edges of the comparator output
  • Selectable inversion on comparator output
  • Capability to produce a wide range of outputs such as:
    • Sampled
    • Windowed, which is ideal for certain PWM zero-crossing-detection applications
    • Digitally filtered:
      • Filter can be bypassed
      • Can be clocked via external SAMPLE signal or scaled bus clock
  • External hysteresis can be used at the same time that the output filter is used for internal functions
  • Two software selectable performance levels:
    • Shorter propagation delay at the expense of higher power
    • Low power, with longer propagation delay
  • DMA transfer support not yet implemented in this library
    • A comparison event can be selected to trigger a DMA transfer
  • Functional in all modes of operation
  • The window and filter functions are not available in the following modes:
    • Stop
    • VLPS
    • LLS
    • VLLSx

Block diagram

/media/uploads/frankvnk/kl25z_comparator_block_diagram.jpg

Introduction

This library allows us to create comparator objects between different inputs.
The comparator + and - inputs can be routed to one out of eight reference inputs (see table).
Input selection

Pin name#MUX inputCMP0Comment
PTC6000IN0CMP0_IN0
PTC7001IN1CMP0_IN1
PTC8010IN2CMP0_IN2
PTC9011IN3CMP0_IN3
PTE30100IN4CMP0_IN412-bit DAC0
PTE29101IN5CMP0_IN5
110IN61V internal Bandgap*
NC111IN7internal 6-bit DAC0
(table 1)

* Not yet implemented

Using the library

Selecting pins on initialisation
Upon initialisation, the comparator registers are set to following values:

    CMP0->CR0   = 0x00;  // Filter and digital hysteresis disabled
    CMP0->CR1   = 0x17;  // Continuous mode, high-speed compare, unfiltered output, output pin disabled
    CMP0->FPR   = 0x00;  // Filter disabled
    CMP0->SCR   = 0x06;  // Disable all interrupts and clear flags (flags are cleared by this write)
    CMP0->DACCR = 0xE0;  // DAC enabled, Vdd is 6bit reference, threshold set to 1/2 of full-scale (1.65V)

The library accepts two input parameters:
example:

ComparatorIn compi(PTC8, NC);
  • First parameter : + input pin.
  • Second parameter : - input pin.
    Every pin from the 'Pin name' column in (table 1) can be selected.

notes

  • IN6 (internal 1V bandgap reference) has no pin name and is not selectable on init.
    However, we can use the SwitchPlus and SwitchMin functions to change the corresponding input to IN6.
  • There are two special cases for the input parameters:
    • NC : Connect the internal 6-bit DAC0 to IN7.
    • PTE30 : configures PTE30 as 12-bit DAC0 output and connect to IN4.
      IMPORTANT: Make sure no external output is connected to PTE30 when you declare this pin, otherwise you WILL destroy the external device and/or the CPU.

Example
Following code demonstrates interrupt callback and polling mode.
Note: Polling the comparator this way won't always trigger the printf because of the wait() instructions (if we go above and below the threshold during the wait() time, then the polling cannot not see this change).

/***********************************************************
CODE EXAMPLE FOR AMBIENT LIGHT SENSOR ON KL25Z + Wi-Go BOARD
 ***********************************************************/
#include "ComparatorIn.h"
#include "mbed.h"

DigitalOut blinker(LED_BLUE);
DigitalOut cmpled(LED_GREEN);
DigitalOut cmp_en (PTD5);
AnalogIn cmp_lvl (PTB0);
ComparatorIn compi(PTC8, NC); // in+ = PTC8, in- = internal 6-bit DAC 

// Comparator callback functions
void cmp_rise_ISR(void)
{
    cmpled = 0;
}

void cmp_fall_ISR(void)
{
    cmpled = 1;
}

int main()
{
    cmp_en = 1;
    cmpled = 1;

    compi.rising(&cmp_rise_ISR);                // Set pointer to rising interrupt function
    compi.falling(&cmp_fall_ISR);               // Set pointer to falling interrupt function
    compi.treshold(0.5);                        // Set comparator threshold to 1.65V = 32 * 3.3V / 64

    while(1)
    {
        printf("Light sensor : %7.5f Volt\n",cmp_lvl*3.3);
        blinker = 1;
        wait(1);
        blinker = 0;
        wait(0.2);
        if (compi.status() == 0x01)
        {
            printf("*** Treshold reached : %7.5f\n",cmp_lvl*3.3);
        }
    }
}


Notes

  • When we enable the comparator interrupt, we need to declare user callback function(s) (rising and/or falling interrupt) AND initialise the function pointer(s).
    example:

compi.rising(&cmp_rise_ISR);
compi.falling(&cmp_fall_ISR);
  • Currently, following functions are not yet implemented:
    • On the fly MUX switching for + input (SwitchPlus function).
    • On the fly MUX switching for - input (SwitchMin function).
    • DMA transfer.

Files at this revision

API Documentation at this revision

Comitter:
frankvnk
Date:
Sun Aug 25 18:00:42 2013 +0000
Parent:
18:efa8d41b738f
Commit message:
_fptr names were too generic. Added comparatorin_ to each name.

Changed in this revision

ComparatorIn.cpp Show annotated file Show diff for this revision Revisions of this file
--- a/ComparatorIn.cpp	Sat Jul 20 18:56:26 2013 +0000
+++ b/ComparatorIn.cpp	Sun Aug 25 18:00:42 2013 +0000
@@ -9,9 +9,9 @@
 
 #include "ComparatorIn.h"
  
-void (*rise_fptr)(void);     // Pointer to user function - called after rising IRQ assertion.
-void (*fall_fptr)(void);     // Pointer to user function - called after falling IRQ assertion.
-AnalogOut *_dac12;           // Pointer to AnalogOut
+void (*comparatorin_rise_fptr)(void);     // Pointer to user function - called after rising IRQ assertion.
+void (*comparatorin_fall_fptr)(void);     // Pointer to user function - called after falling IRQ assertion.
+AnalogOut *_dac12;                        // Pointer to AnalogOut
 
 const PinMap ComparatorIn::PinMap_CMP[] = {
     {PTC6,  CMP0_IN0, 0},
@@ -26,8 +26,8 @@
 
 ComparatorIn::ComparatorIn(PinName pinP, PinName pinM)
 {
-    rise_fptr = NULL;
-    fall_fptr = NULL;
+    comparatorin_rise_fptr = NULL;
+    comparatorin_fall_fptr = NULL;
     CMPnumberP = (CMPName)pinmap_peripheral(pinP, PinMap_CMP);
     if (CMPnumberP == (uint32_t)NC)         // When NC, use DAC0
         CMPnumberP = 0x07;
@@ -218,12 +218,12 @@
     {
         CMP0->SCR &= ~CMP_SCR_IER_MASK;  // Disable rising int.
         CMP0->SCR |=  CMP_SCR_CFR_MASK;  // clear flag
-        if(fall_fptr == NULL)
+        if(comparatorin_fall_fptr == NULL)
             NVIC_DisableIRQ(CMP0_IRQn);
     }
     else
     {
-        rise_fptr = fptr;
+        comparatorin_rise_fptr = fptr;
         CMP0->SCR |= (CMP_SCR_IER_MASK | CMP_SCR_CFR_MASK);  // Enable rising int. and clear flag
         NVIC_EnableIRQ(CMP0_IRQn);  // enable CMP0 interrupt
     }
@@ -235,12 +235,12 @@
     {
         CMP0->SCR &= ~CMP_SCR_IEF_MASK;  // Disable falling int.
         CMP0->SCR |=  CMP_SCR_CFF_MASK;  // clear flag
-        if(rise_fptr == NULL)
+        if(comparatorin_rise_fptr == NULL)
             NVIC_DisableIRQ(CMP0_IRQn);
     }
     else
     {
-        fall_fptr = fptr;
+        comparatorin_fall_fptr = fptr;
         CMP0->SCR |= (CMP_SCR_IEF_MASK | CMP_SCR_CFF_MASK);  // Enable falling int. and clear flag
         NVIC_EnableIRQ(CMP0_IRQn);  // enable CMP0 interrupt
     }
@@ -252,15 +252,15 @@
     // Rising edge
     if (((CMP0->SCR & CMP_SCR_IER_MASK)==CMP_SCR_IER_MASK) && ((CMP0->SCR & CMP_SCR_CFR_MASK)==CMP_SCR_CFR_MASK))
     {
-        CMP0->SCR |= CMP_SCR_CFR_MASK;                              // Clear the flag
-        if (rise_fptr != NULL) rise_fptr();                         // call user function
+        CMP0->SCR |= CMP_SCR_CFR_MASK;                                // Clear the flag
+        if (comparatorin_rise_fptr != NULL) comparatorin_rise_fptr(); // call user function
     }
 
     // Falling edge
     if (((CMP0->SCR & CMP_SCR_IEF_MASK)==CMP_SCR_IEF_MASK) && ((CMP0->SCR & CMP_SCR_CFF_MASK)==CMP_SCR_CFF_MASK))
     {
-        CMP0->SCR |= CMP_SCR_CFF_MASK;                              // Clear the flag
-        if (fall_fptr != NULL) fall_fptr();                         // call user function
+        CMP0->SCR |= CMP_SCR_CFF_MASK;                                // Clear the flag
+        if (comparatorin_fall_fptr != NULL) comparatorin_fall_fptr(); // call user function
     } 
 }