git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/driverlib/comp_e.c

   1 /*
   2  * -------------------------------------------
   3  *    MSP432 DriverLib - v3_10_00_09
   4  * -------------------------------------------
   5  *
   6  * --COPYRIGHT--,BSD,BSD
   7  * Copyright (c) 2014, Texas Instruments Incorporated
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * *  Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * *  Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * *  Neither the name of Texas Instruments Incorporated nor the names of
  22  *    its contributors may be used to endorse or promote products derived
  23  *    from this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  * --/COPYRIGHT--*/
  37 #include <comp_e.h>
  38 #include <interrupt.h>
  39 #include <debug.h>
  40
  41 static uint16_t __getRegisterSettingForInput(uint32_t input)
  42 {
  43     switch (input)
  44     {
  45     case COMP_E_INPUT0:
  46         return COMP_E_CTL0_IPSEL_0;
  47     case COMP_E_INPUT1:
  48         return COMP_E_CTL0_IPSEL_1;
  49     case COMP_E_INPUT2:
  50         return COMP_E_CTL0_IPSEL_2;
  51     case COMP_E_INPUT3:
  52         return COMP_E_CTL0_IPSEL_3;
  53     case COMP_E_INPUT4:
  54         return COMP_E_CTL0_IPSEL_4;
  55     case COMP_E_INPUT5:
  56         return COMP_E_CTL0_IPSEL_5;
  57     case COMP_E_INPUT6:
  58         return COMP_E_CTL0_IPSEL_6;
  59     case COMP_E_INPUT7:
  60         return COMP_E_CTL0_IPSEL_7;
  61     case COMP_E_INPUT8:
  62         return COMP_E_CTL0_IPSEL_8;
  63     case COMP_E_INPUT9:
  64         return COMP_E_CTL0_IPSEL_9;
  65     case COMP_E_INPUT10:
  66         return COMP_E_CTL0_IPSEL_10;
  67     case COMP_E_INPUT11:
  68         return COMP_E_CTL0_IPSEL_11;
  69     case COMP_E_INPUT12:
  70         return COMP_E_CTL0_IPSEL_12;
  71     case COMP_E_INPUT13:
  72         return COMP_E_CTL0_IPSEL_13;
  73     case COMP_E_INPUT14:
  74         return COMP_E_CTL0_IPSEL_14;
  75     case COMP_E_INPUT15:
  76         return COMP_E_CTL0_IPSEL_15;
  77     case COMP_E_VREF:
  78         return COMP_E_VREF;
  79     default:
  80         ASSERT(false);
  81         return 0x11;
  82     }
  83
  84 }
  85
  86 bool COMP_E_initModule(uint32_t comparator, const COMP_E_Config *config)
  87 {
  88     uint_fast8_t positiveTerminalInput = __getRegisterSettingForInput(
  89             config->positiveTerminalInput);
  90     uint_fast8_t negativeTerminalInput = __getRegisterSettingForInput(
  91             config->negativeTerminalInput);
  92     bool retVal = true;
  93
  94     ASSERT(positiveTerminalInput < 0x10); ASSERT(negativeTerminalInput < 0x10);
  95     ASSERT(positiveTerminalInput != negativeTerminalInput);
  96     ASSERT(
  97             config->outputFilterEnableAndDelayLevel
  98             <= COMP_E_FILTEROUTPUT_DLYLVL4);
  99
 100     /* Reset COMPE Control 1 & Interrupt Registers for initialization */
 101     COMP_E_CMSIS(comparator)->CTL0 = 0;
 102     COMP_E_CMSIS(comparator)->INT = 0;
 103
 104     // Set the Positive Terminal
 105     if (COMP_E_VREF != positiveTerminalInput)
 106     {
 107         // Enable Positive Terminal Input Mux and Set to the appropriate input
 108         COMP_E_CMSIS(comparator)->CTL0 |= COMP_E_CTL0_IPEN
 109                         + positiveTerminalInput;
 110
 111         // Disable the input buffer
 112         COMP_E_CMSIS(comparator)->CTL3 |= (1 << positiveTerminalInput);
 113     } else
 114     {
 115         //  Reset and Set COMPE Control 2 Register
 116         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL2,COMP_E_CTL2_RSEL_OFS) = 0;
 117     }
 118
 119     // Set the Negative Terminal
 120     if (COMP_E_VREF != negativeTerminalInput)
 121     {
 122         // Enable Negative Terminal Input Mux and Set  to the appropriate input
 123         COMP_E_CMSIS(comparator)->CTL0 |= COMP_E_CTL0_IMEN
 124                 + (negativeTerminalInput << 8);
 125
 126         // Disable the input buffer
 127         COMP_E_CMSIS(comparator)->CTL3 |= (1 << negativeTerminalInput);
 128     } else
 129     {
 130         // Reset and Set COMPE Control 2 Register
 131         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL2, COMP_E_CTL2_RSEL_OFS) = 1;
 132     }
 133
 134     // Reset and Set COMPE Control 1 Register
 135     COMP_E_CMSIS(comparator)->CTL1 = config->powerMode
 136             + config->outputFilterEnableAndDelayLevel
 137             + config->invertedOutputPolarity;
 138
 139     return retVal;
 140 }
 141
 142 void COMP_E_setReferenceVoltage(uint32_t comparator,
 143         uint_fast16_t supplyVoltageReferenceBase,
 144         uint_fast16_t lowerLimitSupplyVoltageFractionOf32,
 145         uint_fast16_t upperLimitSupplyVoltageFractionOf32)
 146 {
 147     ASSERT(supplyVoltageReferenceBase <= COMP_E_VREFBASE2_5V);
 148     ASSERT(upperLimitSupplyVoltageFractionOf32 <= 32);
 149     ASSERT(lowerLimitSupplyVoltageFractionOf32 <= 32); ASSERT(
 150             upperLimitSupplyVoltageFractionOf32
 151             >= lowerLimitSupplyVoltageFractionOf32);
 152
 153     BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_MRVS_OFS) = 0;
 154     COMP_E_CMSIS(comparator)->CTL2 &= COMP_E_CTL2_RSEL;
 155
 156     // Set Voltage Source(Vcc | Vref, resistor ladder or not)
 157     if (COMP_E_REFERENCE_AMPLIFIER_DISABLED == supplyVoltageReferenceBase)
 158     {
 159         COMP_E_CMSIS(comparator)->CTL2 |= COMP_E_CTL2_RS_1;
 160     } else if (lowerLimitSupplyVoltageFractionOf32 == 32)
 161     {
 162         COMP_E_CMSIS(comparator)->CTL2 |= COMP_E_CTL2_RS_3;
 163     } else
 164     {
 165         COMP_E_CMSIS(comparator)->CTL2 |= COMP_E_CTL2_RS_2;
 166     }
 167
 168     // Set COMPE Control 2 Register
 169     COMP_E_CMSIS(comparator)->CTL2 |= supplyVoltageReferenceBase
 170             + ((upperLimitSupplyVoltageFractionOf32 - 1) << 8)
 171             + (lowerLimitSupplyVoltageFractionOf32 - 1);
 172 }
 173
 174 void COMP_E_setReferenceAccuracy(uint32_t comparator,
 175         uint_fast16_t referenceAccuracy)
 176 {
 177     ASSERT(
 178             (referenceAccuracy == COMP_E_ACCURACY_STATIC)
 179             || (referenceAccuracy == COMP_E_ACCURACY_CLOCKED));
 180
 181     if (referenceAccuracy)
 182         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL2, COMP_E_CTL2_REFACC_OFS) = 1;
 183     else
 184         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL2, COMP_E_CTL2_REFACC_OFS) = 0;
 185
 186 }
 187
 188 void COMP_E_setPowerMode(uint32_t comparator, uint_fast16_t powerMode)
 189 {
 190     COMP_E_CMSIS(comparator)->CTL1 = (COMP_E_CMSIS(comparator)->CTL1
 191             & ~(COMP_E_CTL1_PWRMD_MASK)) | powerMode;
 192 }
 193
 194 void COMP_E_enableModule(uint32_t comparator)
 195 {
 196     BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_ON_OFS) = 1;
 197 }
 198
 199 void COMP_E_disableModule(uint32_t comparator)
 200 {
 201     BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_ON_OFS) = 0;
 202 }
 203
 204 void COMP_E_shortInputs(uint32_t comparator)
 205 {
 206     BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_SHORT_OFS) = 1;
 207 }
 208
 209 void COMP_E_unshortInputs(uint32_t comparator)
 210 {
 211     BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_SHORT_OFS) = 0;
 212 }
 213
 214 void COMP_E_disableInputBuffer(uint32_t comparator, uint_fast16_t inputPort)
 215 {
 216     ASSERT(inputPort <= COMP_E_INPUT15);
 217
 218     COMP_E_CMSIS(comparator)->CTL3 |= (inputPort);
 219 }
 220
 221 void COMP_E_enableInputBuffer(uint32_t comparator, uint_fast16_t inputPort)
 222 {
 223     ASSERT(inputPort <= COMP_E_INPUT15);
 224
 225     COMP_E_CMSIS(comparator)->CTL3 &= ~(inputPort);
 226 }
 227
 228 void COMP_E_swapIO(uint32_t comparator)
 229 {
 230     COMP_E_CMSIS(comparator)->CTL1 ^= COMP_E_CTL1_EX; // Toggle CEEX bit
 231 }
 232
 233 uint8_t COMP_E_outputValue(uint32_t comparator)
 234 {
 235     return COMP_E_CMSIS(comparator)->CTL1 & COMP_E_CTL1_OUT;
 236 }
 237
 238 void COMP_E_enableInterrupt(uint32_t comparator, uint_fast16_t mask)
 239 {
 240     // Set the Interrupt enable bit
 241     COMP_E_CMSIS(comparator)->INT |= mask;
 242 }
 243
 244 uint_fast16_t COMP_E_getEnabledInterruptStatus(uint32_t comparator)
 245 {
 246     return COMP_E_getInterruptStatus(comparator) &
 247     COMP_E_CMSIS(comparator)->INT;
 248 }
 249
 250 void COMP_E_disableInterrupt(uint32_t comparator, uint_fast16_t mask)
 251 {
 252     COMP_E_CMSIS(comparator)->INT &= ~(mask);
 253 }
 254
 255 void COMP_E_clearInterruptFlag(uint32_t comparator, uint_fast16_t mask)
 256 {
 257     COMP_E_CMSIS(comparator)->INT &= ~(mask);
 258 }
 259
 260 uint_fast16_t COMP_E_getInterruptStatus(uint32_t comparator)
 261 {
 262     return (COMP_E_CMSIS(comparator)->INT & (COMP_E_OUTPUT_INTERRUPT_FLAG |
 263     COMP_E_INTERRUPT_FLAG_INVERTED_POLARITY |
 264     COMP_E_INTERRUPT_FLAG_READY));
 265 }
 266
 267 void COMP_E_setInterruptEdgeDirection(uint32_t comparator,
 268         uint_fast8_t edgeDirection)
 269 {
 270     ASSERT(edgeDirection <= COMP_E_RISINGEDGE);
 271
 272     // Set the edge direction that will trigger an interrupt
 273     if (COMP_E_RISINGEDGE == edgeDirection)
 274         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_IES_OFS) = 1;
 275     else if (COMP_E_FALLINGEDGE == edgeDirection)
 276         BITBAND_PERI(COMP_E_CMSIS(comparator)->CTL1, COMP_E_CTL1_IES_OFS) = 0;
 277 }
 278
 279 void COMP_E_toggleInterruptEdgeDirection(uint32_t comparator)
 280 {
 281     COMP_E_CMSIS(comparator)->CTL1 ^= COMP_E_CTL1_IES;
 282 }
 283
 284 void COMP_E_registerInterrupt(uint32_t comparator, void (*intHandler)(void))
 285 {
 286     switch (comparator)
 287     {
 288     case COMP_E0_BASE:
 289         Interrupt_registerInterrupt(INT_COMP_E0, intHandler);
 290         Interrupt_enableInterrupt(INT_COMP_E0);
 291         break;
 292     case COMP_E1_BASE:
 293         Interrupt_registerInterrupt(INT_COMP_E1, intHandler);
 294         Interrupt_enableInterrupt(INT_COMP_E1);
 295         break;
 296     default:
 297         ASSERT(false);
 298     }
 299 }
 300
 301 void COMP_E_unregisterInterrupt(uint32_t comparator)
 302 {
 303     switch (comparator)
 304     {
 305     case COMP_E0_BASE:
 306         Interrupt_disableInterrupt(INT_COMP_E0);
 307         Interrupt_unregisterInterrupt(INT_COMP_E0);
 308         break;
 309     case COMP_E1_BASE:
 310         Interrupt_disableInterrupt(INT_COMP_E1);
 311         Interrupt_unregisterInterrupt(INT_COMP_E1);
 312         break;
 313     default:
 314         ASSERT(false);
 315     }
 316 }
 317