Analog Devices / ADT73xx-ADT74xx

Library files for ADT74xx, ADT73xx famile of products.

Dependents:  

adt7420.c@1:a86efb0ef0ad, 2019-08-28 (annotated)

Committer:
EndaKilgarriff
Date:
Wed Aug 28 15:37:55 2019 +0000
Revision:
1:a86efb0ef0ad
Initial Commit of ADT7420 noOS software

Who changed what in which revision?

UserRevisionLine numberNew contents of line
EndaKilgarriff 1:a86efb0ef0ad 1 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 2 * @file adt7420.c
EndaKilgarriff 1:a86efb0ef0ad 3 * @brief Implementation of ADT7420 Driver.
EndaKilgarriff 1:a86efb0ef0ad 4 * @author DBogdan (dragos.bogdan@analog.com)
EndaKilgarriff 1:a86efb0ef0ad 5 ********************************************************************************
EndaKilgarriff 1:a86efb0ef0ad 6 * Copyright 2012, 2019(c) Analog Devices, Inc.
EndaKilgarriff 1:a86efb0ef0ad 7 *
EndaKilgarriff 1:a86efb0ef0ad 8 * All rights reserved.
EndaKilgarriff 1:a86efb0ef0ad 9 *
EndaKilgarriff 1:a86efb0ef0ad 10 * Redistribution and use in source and binary forms, with or without
EndaKilgarriff 1:a86efb0ef0ad 11 * modification, are permitted provided that the following conditions are met:
EndaKilgarriff 1:a86efb0ef0ad 12 * - Redistributions of source code must retain the above copyright
EndaKilgarriff 1:a86efb0ef0ad 13 * notice, this list of conditions and the following disclaimer.
EndaKilgarriff 1:a86efb0ef0ad 14 * - Redistributions in binary form must reproduce the above copyright
EndaKilgarriff 1:a86efb0ef0ad 15 * notice, this list of conditions and the following disclaimer in
EndaKilgarriff 1:a86efb0ef0ad 16 * the documentation and/or other materials provided with the
EndaKilgarriff 1:a86efb0ef0ad 17 * distribution.
EndaKilgarriff 1:a86efb0ef0ad 18 * - Neither the name of Analog Devices, Inc. nor the names of its
EndaKilgarriff 1:a86efb0ef0ad 19 * contributors may be used to endorse or promote products derived
EndaKilgarriff 1:a86efb0ef0ad 20 * from this software without specific prior written permission.
EndaKilgarriff 1:a86efb0ef0ad 21 * - The use of this software may or may not infringe the patent rights
EndaKilgarriff 1:a86efb0ef0ad 22 * of one or more patent holders. This license does not release you
EndaKilgarriff 1:a86efb0ef0ad 23 * from the requirement that you obtain separate licenses from these
EndaKilgarriff 1:a86efb0ef0ad 24 * patent holders to use this software.
EndaKilgarriff 1:a86efb0ef0ad 25 * - Use of the software either in source or binary form, must be run
EndaKilgarriff 1:a86efb0ef0ad 26 * on or directly connected to an Analog Devices Inc. component.
EndaKilgarriff 1:a86efb0ef0ad 27 *
EndaKilgarriff 1:a86efb0ef0ad 28 * THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
EndaKilgarriff 1:a86efb0ef0ad 29 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
EndaKilgarriff 1:a86efb0ef0ad 30 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
EndaKilgarriff 1:a86efb0ef0ad 31 * IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
EndaKilgarriff 1:a86efb0ef0ad 32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
EndaKilgarriff 1:a86efb0ef0ad 33 * LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
EndaKilgarriff 1:a86efb0ef0ad 34 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
EndaKilgarriff 1:a86efb0ef0ad 35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
EndaKilgarriff 1:a86efb0ef0ad 36 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
EndaKilgarriff 1:a86efb0ef0ad 37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
EndaKilgarriff 1:a86efb0ef0ad 38 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 39
EndaKilgarriff 1:a86efb0ef0ad 40 /******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 41 /***************************** Include Files **********************************/
EndaKilgarriff 1:a86efb0ef0ad 42 /******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 43 #include <stdint.h>
EndaKilgarriff 1:a86efb0ef0ad 44 #include <stdlib.h>
EndaKilgarriff 1:a86efb0ef0ad 45 #include "platform_drivers.h"
EndaKilgarriff 1:a86efb0ef0ad 46 #include "adt7420.h"
EndaKilgarriff 1:a86efb0ef0ad 47
EndaKilgarriff 1:a86efb0ef0ad 48 static const struct adt7420_chip_info chip_info[] = {
EndaKilgarriff 1:a86efb0ef0ad 49 [ID_ADT7410] = {
EndaKilgarriff 1:a86efb0ef0ad 50 .resolution = 16,
EndaKilgarriff 1:a86efb0ef0ad 51 .communication = I2C,
EndaKilgarriff 1:a86efb0ef0ad 52 },
EndaKilgarriff 1:a86efb0ef0ad 53 [ID_ADT7420] = {
EndaKilgarriff 1:a86efb0ef0ad 54 .resolution = 16,
EndaKilgarriff 1:a86efb0ef0ad 55 .communication = I2C,
EndaKilgarriff 1:a86efb0ef0ad 56 },
EndaKilgarriff 1:a86efb0ef0ad 57 [ID_ADT7422] = {
EndaKilgarriff 1:a86efb0ef0ad 58 .resolution = 16,
EndaKilgarriff 1:a86efb0ef0ad 59 .communication = I2C,
EndaKilgarriff 1:a86efb0ef0ad 60 },
EndaKilgarriff 1:a86efb0ef0ad 61 [ID_ADT7310] = {
EndaKilgarriff 1:a86efb0ef0ad 62 .resolution = 16,
EndaKilgarriff 1:a86efb0ef0ad 63 .communication = SPI,
EndaKilgarriff 1:a86efb0ef0ad 64 },
EndaKilgarriff 1:a86efb0ef0ad 65 [ID_ADT7320] = {
EndaKilgarriff 1:a86efb0ef0ad 66 .resolution = 16,
EndaKilgarriff 1:a86efb0ef0ad 67 .communication = SPI,
EndaKilgarriff 1:a86efb0ef0ad 68 }
EndaKilgarriff 1:a86efb0ef0ad 69 };
EndaKilgarriff 1:a86efb0ef0ad 70
EndaKilgarriff 1:a86efb0ef0ad 71 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 72 * @brief Reads the value of a register SPI/I2C.
EndaKilgarriff 1:a86efb0ef0ad 73 *
EndaKilgarriff 1:a86efb0ef0ad 74 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 75 * @param register_address - Address of the register.
EndaKilgarriff 1:a86efb0ef0ad 76 *
EndaKilgarriff 1:a86efb0ef0ad 77 * @return register_value - Value of the register.
EndaKilgarriff 1:a86efb0ef0ad 78 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 79 uint16_t get_register_value(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 80 uint8_t register_address)
EndaKilgarriff 1:a86efb0ef0ad 81 {
EndaKilgarriff 1:a86efb0ef0ad 82 uint16_t register_value = 0;
EndaKilgarriff 1:a86efb0ef0ad 83
EndaKilgarriff 1:a86efb0ef0ad 84 //remap register map
EndaKilgarriff 1:a86efb0ef0ad 85 if (chip_info[dev->act_device].communication == SPI) {
EndaKilgarriff 1:a86efb0ef0ad 86 switch (register_address) {
EndaKilgarriff 1:a86efb0ef0ad 87 case REG_TEMP: register_address = ADT7320_REG_TEMP;break; // Temperature value
EndaKilgarriff 1:a86efb0ef0ad 88 case REG_STATUS:register_address = ADT7320_REG_STATUS;break; // status info
EndaKilgarriff 1:a86efb0ef0ad 89 case REG_CONFIG:register_address = ADT7320_REG_CONFIG;break; // Configuration
EndaKilgarriff 1:a86efb0ef0ad 90 case REG_T_CRIT:register_address = ADT7320_REG_T_CRIT;break; // Temperature CRIT setpoint (147'C)
EndaKilgarriff 1:a86efb0ef0ad 91 case REG_HIST: register_address = ADT7320_REG_HIST;break; // Temperature HYST setpoint (5'C)
EndaKilgarriff 1:a86efb0ef0ad 92 case REG_T_HIGH:register_address = ADT7320_REG_T_HIGH;break; // Temperature HIGH setpoint (64'C)
EndaKilgarriff 1:a86efb0ef0ad 93 case REG_T_LOW: register_address = ADT7320_REG_T_LOW;break; // Temperature LOW setpoint (10'C)
EndaKilgarriff 1:a86efb0ef0ad 94 case REG_ID: register_address = ADT7320_REG_ID;break; // ID value
EndaKilgarriff 1:a86efb0ef0ad 95 }
EndaKilgarriff 1:a86efb0ef0ad 96 register_value = adt7420_get_register_value(dev, register_address);
EndaKilgarriff 1:a86efb0ef0ad 97 } else {
EndaKilgarriff 1:a86efb0ef0ad 98 switch(register_address) {
EndaKilgarriff 1:a86efb0ef0ad 99 case REG_TEMP: {
EndaKilgarriff 1:a86efb0ef0ad 100 register_value = adt7420_get_register_value(dev,ADT7420_REG_TEMP_MSB) << 8;
EndaKilgarriff 1:a86efb0ef0ad 101 register_value |= adt7420_get_register_value(dev,ADT7420_REG_TEMP_LSB);
EndaKilgarriff 1:a86efb0ef0ad 102 break;
EndaKilgarriff 1:a86efb0ef0ad 103 }
EndaKilgarriff 1:a86efb0ef0ad 104 case REG_STATUS: register_value = adt7420_get_register_value(dev, ADT7420_REG_STATUS); break;
EndaKilgarriff 1:a86efb0ef0ad 105 case REG_CONFIG: register_value = adt7420_get_register_value(dev, ADT7420_REG_CONFIG);break;
EndaKilgarriff 1:a86efb0ef0ad 106 case REG_T_HIGH: {
EndaKilgarriff 1:a86efb0ef0ad 107 register_value = adt7420_get_register_value(dev,ADT7420_REG_T_HIGH_MSB) << 8;
EndaKilgarriff 1:a86efb0ef0ad 108 register_value |= adt7420_get_register_value(dev,ADT7420_REG_T_HIGH_LSB);
EndaKilgarriff 1:a86efb0ef0ad 109 break;
EndaKilgarriff 1:a86efb0ef0ad 110 }
EndaKilgarriff 1:a86efb0ef0ad 111 case REG_T_LOW: {
EndaKilgarriff 1:a86efb0ef0ad 112 register_value = adt7420_get_register_value(dev,ADT7420_REG_T_LOW_MSB) << 8;
EndaKilgarriff 1:a86efb0ef0ad 113 register_value |= adt7420_get_register_value(dev,ADT7420_REG_T_LOW_LSB);
EndaKilgarriff 1:a86efb0ef0ad 114 break;
EndaKilgarriff 1:a86efb0ef0ad 115 }
EndaKilgarriff 1:a86efb0ef0ad 116 case REG_T_CRIT: {
EndaKilgarriff 1:a86efb0ef0ad 117 register_value = adt7420_get_register_value(dev,ADT7420_REG_T_CRIT_MSB) << 8;
EndaKilgarriff 1:a86efb0ef0ad 118 register_value |= adt7420_get_register_value(dev,ADT7420_REG_T_CRIT_LSB);
EndaKilgarriff 1:a86efb0ef0ad 119 break;
EndaKilgarriff 1:a86efb0ef0ad 120 }
EndaKilgarriff 1:a86efb0ef0ad 121 case REG_HIST: register_value = adt7420_get_register_value(dev, ADT7420_REG_HIST);break;
EndaKilgarriff 1:a86efb0ef0ad 122 case REG_ID: register_value = adt7420_get_register_value(dev, ADT7420_REG_ID);break;
EndaKilgarriff 1:a86efb0ef0ad 123 }
EndaKilgarriff 1:a86efb0ef0ad 124 }
EndaKilgarriff 1:a86efb0ef0ad 125 return register_value;
EndaKilgarriff 1:a86efb0ef0ad 126 }
EndaKilgarriff 1:a86efb0ef0ad 127
EndaKilgarriff 1:a86efb0ef0ad 128 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 129 * @brief Reads the value of a register SPI/I2C interface.
EndaKilgarriff 1:a86efb0ef0ad 130 *
EndaKilgarriff 1:a86efb0ef0ad 131 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 132 * @param register_address - Address of the register.
EndaKilgarriff 1:a86efb0ef0ad 133 *
EndaKilgarriff 1:a86efb0ef0ad 134 * @return register_value - Value of the register.
EndaKilgarriff 1:a86efb0ef0ad 135 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 136 uint16_t adt7420_get_register_value(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 137 uint8_t register_address)
EndaKilgarriff 1:a86efb0ef0ad 138 {
EndaKilgarriff 1:a86efb0ef0ad 139 uint8_t register_value = 0;
EndaKilgarriff 1:a86efb0ef0ad 140 uint8_t data[2] = {0,0xFF};
EndaKilgarriff 1:a86efb0ef0ad 141
EndaKilgarriff 1:a86efb0ef0ad 142 if (chip_info[dev->act_device].communication == SPI) {
EndaKilgarriff 1:a86efb0ef0ad 143 /* Set the SPI command byte. datasheet page 17 */
EndaKilgarriff 1:a86efb0ef0ad 144 data[0] = ADT7320_READ_CMD | (register_address << 3);
EndaKilgarriff 1:a86efb0ef0ad 145
EndaKilgarriff 1:a86efb0ef0ad 146 return set_shift_reg(dev, register_address,data);
EndaKilgarriff 1:a86efb0ef0ad 147 } else {
EndaKilgarriff 1:a86efb0ef0ad 148 data[0] = register_address;
EndaKilgarriff 1:a86efb0ef0ad 149
EndaKilgarriff 1:a86efb0ef0ad 150 i2c_write(dev->i2c_desc,
EndaKilgarriff 1:a86efb0ef0ad 151 &register_address,
EndaKilgarriff 1:a86efb0ef0ad 152 1,
EndaKilgarriff 1:a86efb0ef0ad 153 NO_STOP_BIT); //add a repeat start
EndaKilgarriff 1:a86efb0ef0ad 154 i2c_read(dev->i2c_desc,
EndaKilgarriff 1:a86efb0ef0ad 155 &register_value,
EndaKilgarriff 1:a86efb0ef0ad 156 1,
EndaKilgarriff 1:a86efb0ef0ad 157 STOP_BIT);
EndaKilgarriff 1:a86efb0ef0ad 158
EndaKilgarriff 1:a86efb0ef0ad 159 return register_value;
EndaKilgarriff 1:a86efb0ef0ad 160 }
EndaKilgarriff 1:a86efb0ef0ad 161 }
EndaKilgarriff 1:a86efb0ef0ad 162
EndaKilgarriff 1:a86efb0ef0ad 163 /**************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 164 * @brief Write to input shift register SPI interface.
EndaKilgarriff 1:a86efb0ef0ad 165 *
EndaKilgarriff 1:a86efb0ef0ad 166 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 167 * @param register_address - Command control bits.
EndaKilgarriff 1:a86efb0ef0ad 168 * @param data - Data to be written in input register.
EndaKilgarriff 1:a86efb0ef0ad 169 *
EndaKilgarriff 1:a86efb0ef0ad 170 * @return read_back_data - value read from register.
EndaKilgarriff 1:a86efb0ef0ad 171 ******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 172 uint16_t set_shift_reg(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 173 uint8_t register_address,
EndaKilgarriff 1:a86efb0ef0ad 174 uint8_t *data)
EndaKilgarriff 1:a86efb0ef0ad 175 {
EndaKilgarriff 1:a86efb0ef0ad 176 uint8_t data_buffer[PKT_LENGTH] = { 0, 0, 0 };
EndaKilgarriff 1:a86efb0ef0ad 177 uint16_t read_back_data = 0;
EndaKilgarriff 1:a86efb0ef0ad 178 uint8_t numBytes;
EndaKilgarriff 1:a86efb0ef0ad 179
EndaKilgarriff 1:a86efb0ef0ad 180 switch (register_address) {
EndaKilgarriff 1:a86efb0ef0ad 181 case ADT7320_REG_STATUS:
EndaKilgarriff 1:a86efb0ef0ad 182 case ADT7320_REG_CONFIG:
EndaKilgarriff 1:a86efb0ef0ad 183 case ADT7320_REG_ID:
EndaKilgarriff 1:a86efb0ef0ad 184 case ADT7320_REG_HIST: numBytes = ONE_BYTE; break;
EndaKilgarriff 1:a86efb0ef0ad 185 default:
EndaKilgarriff 1:a86efb0ef0ad 186 numBytes = TWO_BYTE;
EndaKilgarriff 1:a86efb0ef0ad 187 break;
EndaKilgarriff 1:a86efb0ef0ad 188 }
EndaKilgarriff 1:a86efb0ef0ad 189
EndaKilgarriff 1:a86efb0ef0ad 190 if (numBytes == ONE_BYTE) {
EndaKilgarriff 1:a86efb0ef0ad 191 data_buffer[0] = data[0];
EndaKilgarriff 1:a86efb0ef0ad 192 data_buffer[1] = data[1] & ADT7420_LSB_MASK;
EndaKilgarriff 1:a86efb0ef0ad 193 spi_write_and_read(dev->spi_desc, data_buffer, ONE_BYTE);
EndaKilgarriff 1:a86efb0ef0ad 194 read_back_data = (data_buffer[0] & ADT7420_MSB_MASK) | data_buffer[1];
EndaKilgarriff 1:a86efb0ef0ad 195 }
EndaKilgarriff 1:a86efb0ef0ad 196 else {
EndaKilgarriff 1:a86efb0ef0ad 197 data_buffer[0] = data[0];
EndaKilgarriff 1:a86efb0ef0ad 198 data_buffer[1] = data[1] & ADT7420_LSB_MASK;
EndaKilgarriff 1:a86efb0ef0ad 199 data_buffer[2] = (data[2] & ADT7420_LSB_MASK) << 8;
EndaKilgarriff 1:a86efb0ef0ad 200 spi_write_and_read(dev->spi_desc, data_buffer, TWO_BYTE);
EndaKilgarriff 1:a86efb0ef0ad 201 read_back_data = data_buffer[1] << ADT7420_MSB_OFFSET | data_buffer[2];
EndaKilgarriff 1:a86efb0ef0ad 202 }
EndaKilgarriff 1:a86efb0ef0ad 203 return read_back_data;
EndaKilgarriff 1:a86efb0ef0ad 204 }
EndaKilgarriff 1:a86efb0ef0ad 205
EndaKilgarriff 1:a86efb0ef0ad 206 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 207 * @brief Sets the value of a register SPI/I2C.
EndaKilgarriff 1:a86efb0ef0ad 208 *
EndaKilgarriff 1:a86efb0ef0ad 209 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 210 * @param register_address - Address of the register.
EndaKilgarriff 1:a86efb0ef0ad 211 * @param num_data_bytes - Number of bytes.
EndaKilgarriff 1:a86efb0ef0ad 212 * @param data - Data to be written in input register.
EndaKilgarriff 1:a86efb0ef0ad 213 *
EndaKilgarriff 1:a86efb0ef0ad 214 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 215 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 216 void set_register_value(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 217 uint8_t register_address,
EndaKilgarriff 1:a86efb0ef0ad 218 uint8_t num_data_bytes,
EndaKilgarriff 1:a86efb0ef0ad 219 uint8_t *data)
EndaKilgarriff 1:a86efb0ef0ad 220 {
EndaKilgarriff 1:a86efb0ef0ad 221
EndaKilgarriff 1:a86efb0ef0ad 222 uint8_t data_buffer[PKT_LENGTH] = {0, 0, 0};
EndaKilgarriff 1:a86efb0ef0ad 223
EndaKilgarriff 1:a86efb0ef0ad 224
EndaKilgarriff 1:a86efb0ef0ad 225 data_buffer[1] = data[0];
EndaKilgarriff 1:a86efb0ef0ad 226 data_buffer[2] = data[1];
EndaKilgarriff 1:a86efb0ef0ad 227
EndaKilgarriff 1:a86efb0ef0ad 228 if (chip_info[dev->act_device].communication == SPI) {
EndaKilgarriff 1:a86efb0ef0ad 229 //simple address re-map for SPI devices
EndaKilgarriff 1:a86efb0ef0ad 230 switch (register_address) {
EndaKilgarriff 1:a86efb0ef0ad 231 case REG_TEMP: register_address = ADT7320_REG_TEMP; break; // Temperature value
EndaKilgarriff 1:a86efb0ef0ad 232 case REG_STATUS:register_address = ADT7320_REG_STATUS; break; // status info
EndaKilgarriff 1:a86efb0ef0ad 233 case REG_CONFIG:register_address = ADT7320_REG_CONFIG; break; // Configuration
EndaKilgarriff 1:a86efb0ef0ad 234 case REG_T_CRIT:register_address = ADT7320_REG_T_CRIT; break; // Temperature CRIT setpoint (147'C)
EndaKilgarriff 1:a86efb0ef0ad 235 case REG_HIST: register_address = ADT7320_REG_HIST; break; // Temperature HYST setpoint (5'C)
EndaKilgarriff 1:a86efb0ef0ad 236 case REG_T_HIGH:register_address = ADT7320_REG_T_HIGH; break; // Temperature HIGH setpoint (64'C)
EndaKilgarriff 1:a86efb0ef0ad 237 case REG_T_LOW: register_address = ADT7320_REG_T_LOW; break; // Temperature LOW setpoint (10'C)
EndaKilgarriff 1:a86efb0ef0ad 238 case REG_ID: register_address = ADT7320_REG_ID; break; // ID value
EndaKilgarriff 1:a86efb0ef0ad 239 }
EndaKilgarriff 1:a86efb0ef0ad 240 /* Set the SPI command byte. datasheet page 17 */
EndaKilgarriff 1:a86efb0ef0ad 241 data_buffer[0] = (register_address << 3) & ADT7320_WRITE_MASK_CMD;
EndaKilgarriff 1:a86efb0ef0ad 242 spi_write_and_read(dev->spi_desc, data_buffer, num_data_bytes);
EndaKilgarriff 1:a86efb0ef0ad 243 } else {
EndaKilgarriff 1:a86efb0ef0ad 244 //simple address re-map for I2Cdevices
EndaKilgarriff 1:a86efb0ef0ad 245 switch (register_address) {
EndaKilgarriff 1:a86efb0ef0ad 246 case REG_TEMP: register_address = ADT7420_REG_T_HIGH_MSB; break; // Temperature value
EndaKilgarriff 1:a86efb0ef0ad 247 case REG_STATUS: register_address = ADT7420_REG_STATUS; break; // status info
EndaKilgarriff 1:a86efb0ef0ad 248 case REG_CONFIG: register_address = ADT7420_REG_CONFIG; break; // Configuration
EndaKilgarriff 1:a86efb0ef0ad 249 case REG_T_CRIT: register_address = ADT7420_REG_T_CRIT_MSB; break; // Temperature CRIT setpoint (147'C)
EndaKilgarriff 1:a86efb0ef0ad 250 case REG_HIST: register_address = ADT7420_REG_HIST; break; // Temperature HYST setpoint (5'C)
EndaKilgarriff 1:a86efb0ef0ad 251 case REG_T_HIGH: register_address = ADT7420_REG_T_HIGH_MSB; break; // Temperature HIGH setpoint (64'C)
EndaKilgarriff 1:a86efb0ef0ad 252 case REG_T_LOW: register_address = ADT7420_REG_T_LOW_MSB; break; // Temperature LOW setpoint (10'C)
EndaKilgarriff 1:a86efb0ef0ad 253 case REG_ID: register_address = ADT7420_REG_ID; break; // ID value
EndaKilgarriff 1:a86efb0ef0ad 254 }
EndaKilgarriff 1:a86efb0ef0ad 255
EndaKilgarriff 1:a86efb0ef0ad 256 data_buffer[0] = register_address;
EndaKilgarriff 1:a86efb0ef0ad 257
EndaKilgarriff 1:a86efb0ef0ad 258 i2c_write(dev->i2c_desc,
EndaKilgarriff 1:a86efb0ef0ad 259 data_buffer,
EndaKilgarriff 1:a86efb0ef0ad 260 num_data_bytes,
EndaKilgarriff 1:a86efb0ef0ad 261 STOP_BIT); //no repeat start
EndaKilgarriff 1:a86efb0ef0ad 262 }
EndaKilgarriff 1:a86efb0ef0ad 263 }
EndaKilgarriff 1:a86efb0ef0ad 264
EndaKilgarriff 1:a86efb0ef0ad 265 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 266 * @brief Initializes the communication peripheral and checks if the device is
EndaKilgarriff 1:a86efb0ef0ad 267 * present.
EndaKilgarriff 1:a86efb0ef0ad 268 *
EndaKilgarriff 1:a86efb0ef0ad 269 * @param device - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 270 * @param init_param - The structure that contains the device initial
EndaKilgarriff 1:a86efb0ef0ad 271 * parameters.
EndaKilgarriff 1:a86efb0ef0ad 272 *
EndaKilgarriff 1:a86efb0ef0ad 273 * @return status - The result of the initialization procedure.
EndaKilgarriff 1:a86efb0ef0ad 274 * Example: -1 - I2C peripheral was not initialized or the
EndaKilgarriff 1:a86efb0ef0ad 275 * device is not present.
EndaKilgarriff 1:a86efb0ef0ad 276 * 0 - I2C peripheral was initialized and the
EndaKilgarriff 1:a86efb0ef0ad 277 * device is present.
EndaKilgarriff 1:a86efb0ef0ad 278 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 279 int32_t adt7420_init(struct adt7420_dev **device,
EndaKilgarriff 1:a86efb0ef0ad 280 struct adt7420_init_param init_param)
EndaKilgarriff 1:a86efb0ef0ad 281 {
EndaKilgarriff 1:a86efb0ef0ad 282 struct adt7420_dev *dev;
EndaKilgarriff 1:a86efb0ef0ad 283 int32_t status;
EndaKilgarriff 1:a86efb0ef0ad 284 uint8_t device_connected_check = 0;
EndaKilgarriff 1:a86efb0ef0ad 285
EndaKilgarriff 1:a86efb0ef0ad 286 dev = (struct adt7420_dev *)malloc(sizeof(*dev));
EndaKilgarriff 1:a86efb0ef0ad 287 if (!dev)
EndaKilgarriff 1:a86efb0ef0ad 288 return -1;
EndaKilgarriff 1:a86efb0ef0ad 289
EndaKilgarriff 1:a86efb0ef0ad 290 dev->act_device = init_param.act_device;
EndaKilgarriff 1:a86efb0ef0ad 291
EndaKilgarriff 1:a86efb0ef0ad 292
EndaKilgarriff 1:a86efb0ef0ad 293 if (chip_info[dev->act_device].communication == SPI) {
EndaKilgarriff 1:a86efb0ef0ad 294 status = spi_init(&dev->spi_desc, &init_param.spi_init);
EndaKilgarriff 1:a86efb0ef0ad 295 } else {
EndaKilgarriff 1:a86efb0ef0ad 296 status = i2c_init(&dev->i2c_desc, &init_param.i2c_init);
EndaKilgarriff 1:a86efb0ef0ad 297 }
EndaKilgarriff 1:a86efb0ef0ad 298
EndaKilgarriff 1:a86efb0ef0ad 299 /* Device Settings */
EndaKilgarriff 1:a86efb0ef0ad 300 dev->resolution_setting = init_param.resolution_setting;
EndaKilgarriff 1:a86efb0ef0ad 301
EndaKilgarriff 1:a86efb0ef0ad 302 /* Reset device to default values to ensure all internal circuitry is properly initialised*/
EndaKilgarriff 1:a86efb0ef0ad 303 adt7420_reset_interface(dev);
EndaKilgarriff 1:a86efb0ef0ad 304
EndaKilgarriff 1:a86efb0ef0ad 305 /*Register read to ensure that next read will be valid - acts as 200us delay while
EndaKilgarriff 1:a86efb0ef0ad 306 device resets*/
EndaKilgarriff 1:a86efb0ef0ad 307 get_register_value(dev, REG_STATUS);
EndaKilgarriff 1:a86efb0ef0ad 308
EndaKilgarriff 1:a86efb0ef0ad 309
EndaKilgarriff 1:a86efb0ef0ad 310 device_connected_check = get_register_value(dev, REG_ID);
EndaKilgarriff 1:a86efb0ef0ad 311 device_connected_check >>= GET_MANUFACTURER_ID;
EndaKilgarriff 1:a86efb0ef0ad 312
EndaKilgarriff 1:a86efb0ef0ad 313 if (device_connected_check != ADT7XXX_ID_CHECK)
EndaKilgarriff 1:a86efb0ef0ad 314 status = FAILURE;
EndaKilgarriff 1:a86efb0ef0ad 315 else
EndaKilgarriff 1:a86efb0ef0ad 316 status = SUCCESS;
EndaKilgarriff 1:a86efb0ef0ad 317
EndaKilgarriff 1:a86efb0ef0ad 318 *device = dev;
EndaKilgarriff 1:a86efb0ef0ad 319
EndaKilgarriff 1:a86efb0ef0ad 320 return status;
EndaKilgarriff 1:a86efb0ef0ad 321 }
EndaKilgarriff 1:a86efb0ef0ad 322
EndaKilgarriff 1:a86efb0ef0ad 323 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 324 * @brief Free the resources allocated by adt7420_init().
EndaKilgarriff 1:a86efb0ef0ad 325 *
EndaKilgarriff 1:a86efb0ef0ad 326 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 327 *
EndaKilgarriff 1:a86efb0ef0ad 328 * @return ret - The result of the remove procedure.
EndaKilgarriff 1:a86efb0ef0ad 329 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 330 int32_t adt7420_remove(struct adt7420_dev *dev)
EndaKilgarriff 1:a86efb0ef0ad 331 {
EndaKilgarriff 1:a86efb0ef0ad 332 int32_t ret;
EndaKilgarriff 1:a86efb0ef0ad 333
EndaKilgarriff 1:a86efb0ef0ad 334 ret = i2c_remove(dev->i2c_desc);
EndaKilgarriff 1:a86efb0ef0ad 335 free(dev);
EndaKilgarriff 1:a86efb0ef0ad 336
EndaKilgarriff 1:a86efb0ef0ad 337 return ret;
EndaKilgarriff 1:a86efb0ef0ad 338 }
EndaKilgarriff 1:a86efb0ef0ad 339
EndaKilgarriff 1:a86efb0ef0ad 340 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 341 * @brief Sets the operational mode for ADT7420/ADT7320.
EndaKilgarriff 1:a86efb0ef0ad 342 *
EndaKilgarriff 1:a86efb0ef0ad 343 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 344 * @param mode - Operation mode.
EndaKilgarriff 1:a86efb0ef0ad 345 * Example: ADT7420_OP_MODE_CONT_CONV - continuous conversion;
EndaKilgarriff 1:a86efb0ef0ad 346 * ADT7420_OP_MODE_ONE_SHOT - one shot;
EndaKilgarriff 1:a86efb0ef0ad 347 * ADT7420_OP_MODE_1_SPS - 1 SPS mode;
EndaKilgarriff 1:a86efb0ef0ad 348 * ADT7420_OP_MODE_SHUTDOWN - shutdown.
EndaKilgarriff 1:a86efb0ef0ad 349 *
EndaKilgarriff 1:a86efb0ef0ad 350 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 351 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 352 void adt7420_set_operation_mode(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 353 uint8_t mode)
EndaKilgarriff 1:a86efb0ef0ad 354 {
EndaKilgarriff 1:a86efb0ef0ad 355 uint8_t register_value [ONE_BYTE] = { 0, 0 };
EndaKilgarriff 1:a86efb0ef0ad 356
EndaKilgarriff 1:a86efb0ef0ad 357 register_value[0] = get_register_value(dev, REG_CONFIG);
EndaKilgarriff 1:a86efb0ef0ad 358
EndaKilgarriff 1:a86efb0ef0ad 359 register_value[0] &= ~ADT7420_CONFIG_OP_MODE(ADT7420_OP_MODE_SHUTDOWN);
EndaKilgarriff 1:a86efb0ef0ad 360 register_value[0] |= ADT7420_CONFIG_OP_MODE(mode);
EndaKilgarriff 1:a86efb0ef0ad 361
EndaKilgarriff 1:a86efb0ef0ad 362 set_register_value(dev,REG_CONFIG, ONE_BYTE, register_value);
EndaKilgarriff 1:a86efb0ef0ad 363 }
EndaKilgarriff 1:a86efb0ef0ad 364
EndaKilgarriff 1:a86efb0ef0ad 365 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 366 * @brief Sets the resolution for ADT7420/ADT7320.
EndaKilgarriff 1:a86efb0ef0ad 367 *
EndaKilgarriff 1:a86efb0ef0ad 368 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 369 * @param resolution - Resolution.
EndaKilgarriff 1:a86efb0ef0ad 370 * Example: 0 - 13-bit resolution;
EndaKilgarriff 1:a86efb0ef0ad 371 * 1 - 16-bit resolution.
EndaKilgarriff 1:a86efb0ef0ad 372 *
EndaKilgarriff 1:a86efb0ef0ad 373 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 374 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 375 void adt7420_set_resolution(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 376 uint8_t resolution)
EndaKilgarriff 1:a86efb0ef0ad 377 {
EndaKilgarriff 1:a86efb0ef0ad 378 uint8_t register_value[1] = { 0 };
EndaKilgarriff 1:a86efb0ef0ad 379
EndaKilgarriff 1:a86efb0ef0ad 380 register_value[0] = get_register_value(dev, REG_CONFIG);
EndaKilgarriff 1:a86efb0ef0ad 381
EndaKilgarriff 1:a86efb0ef0ad 382 register_value[0] &= ~ADT7420_CONFIG_RESOLUTION;
EndaKilgarriff 1:a86efb0ef0ad 383 register_value[0] |= (resolution * ADT7420_CONFIG_RESOLUTION);
EndaKilgarriff 1:a86efb0ef0ad 384
EndaKilgarriff 1:a86efb0ef0ad 385
EndaKilgarriff 1:a86efb0ef0ad 386 set_register_value(dev,REG_CONFIG, ONE_BYTE, register_value);
EndaKilgarriff 1:a86efb0ef0ad 387 dev->resolution_setting = resolution;
EndaKilgarriff 1:a86efb0ef0ad 388 }
EndaKilgarriff 1:a86efb0ef0ad 389
EndaKilgarriff 1:a86efb0ef0ad 390 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 391 * @brief Resets the SPI or I2C inteface for the ADT7420/ADT7320
EndaKilgarriff 1:a86efb0ef0ad 392 *
EndaKilgarriff 1:a86efb0ef0ad 393 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 394 *
EndaKilgarriff 1:a86efb0ef0ad 395 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 396 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 397 void adt7420_reset_interface(struct adt7420_dev *dev)
EndaKilgarriff 1:a86efb0ef0ad 398 {
EndaKilgarriff 1:a86efb0ef0ad 399 uint8_t data_buffer[] = { 0xFF, 0xFF, 0xFF, 0xFF };
EndaKilgarriff 1:a86efb0ef0ad 400
EndaKilgarriff 1:a86efb0ef0ad 401 if (chip_info[dev->act_device].communication == SPI)
EndaKilgarriff 1:a86efb0ef0ad 402 spi_write_and_read(dev->spi_desc, data_buffer, FOUR_BYTES);
EndaKilgarriff 1:a86efb0ef0ad 403 else {
EndaKilgarriff 1:a86efb0ef0ad 404 uint8_t register_address = ADT7420_REG_RESET;
EndaKilgarriff 1:a86efb0ef0ad 405 i2c_write(dev->i2c_desc,
EndaKilgarriff 1:a86efb0ef0ad 406 &register_address,
EndaKilgarriff 1:a86efb0ef0ad 407 1,
EndaKilgarriff 1:a86efb0ef0ad 408 STOP_BIT);//no repeat start
EndaKilgarriff 1:a86efb0ef0ad 409 dev->resolution_setting = 0;
EndaKilgarriff 1:a86efb0ef0ad 410 }
EndaKilgarriff 1:a86efb0ef0ad 411 }
EndaKilgarriff 1:a86efb0ef0ad 412
EndaKilgarriff 1:a86efb0ef0ad 413 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 414 * @brief Reads the temperature data and converts it to Celsius degrees.
EndaKilgarriff 1:a86efb0ef0ad 415 *
EndaKilgarriff 1:a86efb0ef0ad 416 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 417 *
EndaKilgarriff 1:a86efb0ef0ad 418 * @return temperature - Temperature in degrees Celsius.
EndaKilgarriff 1:a86efb0ef0ad 419 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 420 float adt7420_get_temperature(struct adt7420_dev *dev)
EndaKilgarriff 1:a86efb0ef0ad 421 {
EndaKilgarriff 1:a86efb0ef0ad 422 uint16_t temp = 0;
EndaKilgarriff 1:a86efb0ef0ad 423 float temp_c = 0;
EndaKilgarriff 1:a86efb0ef0ad 424
EndaKilgarriff 1:a86efb0ef0ad 425 temp = get_register_value(dev, REG_TEMP);
EndaKilgarriff 1:a86efb0ef0ad 426
EndaKilgarriff 1:a86efb0ef0ad 427 if(dev->resolution_setting) {
EndaKilgarriff 1:a86efb0ef0ad 428 if(temp & 0x8000)
EndaKilgarriff 1:a86efb0ef0ad 429 /*! Negative temperature */
EndaKilgarriff 1:a86efb0ef0ad 430 temp_c = (float)((int32_t)temp - 65536) / 128;
EndaKilgarriff 1:a86efb0ef0ad 431 else
EndaKilgarriff 1:a86efb0ef0ad 432 /*! Positive temperature */
EndaKilgarriff 1:a86efb0ef0ad 433 temp_c = (float)temp / 128;
EndaKilgarriff 1:a86efb0ef0ad 434 } else {
EndaKilgarriff 1:a86efb0ef0ad 435 temp >>= 3;
EndaKilgarriff 1:a86efb0ef0ad 436 if(temp & 0x1000)
EndaKilgarriff 1:a86efb0ef0ad 437 /*! Negative temperature */
EndaKilgarriff 1:a86efb0ef0ad 438 temp_c = (float)((int32_t)temp - 8192) / 16;
EndaKilgarriff 1:a86efb0ef0ad 439 else
EndaKilgarriff 1:a86efb0ef0ad 440 /*! Positive temperature */
EndaKilgarriff 1:a86efb0ef0ad 441 temp_c = (float)temp / 16;
EndaKilgarriff 1:a86efb0ef0ad 442 }
EndaKilgarriff 1:a86efb0ef0ad 443
EndaKilgarriff 1:a86efb0ef0ad 444 return temp_c;
EndaKilgarriff 1:a86efb0ef0ad 445 }
EndaKilgarriff 1:a86efb0ef0ad 446
EndaKilgarriff 1:a86efb0ef0ad 447 /**************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 448 * @brief Write to a setpoint register.
EndaKilgarriff 1:a86efb0ef0ad 449 *
EndaKilgarriff 1:a86efb0ef0ad 450 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 451 * @param register_value - Command control bits.
EndaKilgarriff 1:a86efb0ef0ad 452 * @param data - Data to be written in input register.
EndaKilgarriff 1:a86efb0ef0ad 453 *
EndaKilgarriff 1:a86efb0ef0ad 454 * @return read_back_data - value read from register.
EndaKilgarriff 1:a86efb0ef0ad 455 ******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 456 uint8_t adt7420_wr_setpoint_reg(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 457 uint8_t register_value,
EndaKilgarriff 1:a86efb0ef0ad 458 uint16_t data)
EndaKilgarriff 1:a86efb0ef0ad 459 {
EndaKilgarriff 1:a86efb0ef0ad 460 uint16_t read_back_data = 0;
EndaKilgarriff 1:a86efb0ef0ad 461 uint8_t address, num_bytes;
EndaKilgarriff 1:a86efb0ef0ad 462 uint8_t data_buffer[PKT_LENGTH] = { 0, 0, 0 };
EndaKilgarriff 1:a86efb0ef0ad 463
EndaKilgarriff 1:a86efb0ef0ad 464 switch (register_value) {
EndaKilgarriff 1:a86efb0ef0ad 465 case REG_T_CRIT:
EndaKilgarriff 1:a86efb0ef0ad 466 case REG_T_HIGH:
EndaKilgarriff 1:a86efb0ef0ad 467 case REG_T_LOW: {
EndaKilgarriff 1:a86efb0ef0ad 468 num_bytes = TWO_BYTE;
EndaKilgarriff 1:a86efb0ef0ad 469 data_buffer[0] = ((data & ADT7420_MSB_MASK) >> ADT7420_MSB_OFFSET);
EndaKilgarriff 1:a86efb0ef0ad 470 data_buffer[1] = data & ADT7420_LSB_MASK;
EndaKilgarriff 1:a86efb0ef0ad 471 break;
EndaKilgarriff 1:a86efb0ef0ad 472 }
EndaKilgarriff 1:a86efb0ef0ad 473 case REG_HIST: {
EndaKilgarriff 1:a86efb0ef0ad 474 num_bytes = ONE_BYTE;
EndaKilgarriff 1:a86efb0ef0ad 475 data_buffer[0] = data & ADT7420_LSB_MASK;
EndaKilgarriff 1:a86efb0ef0ad 476 break;
EndaKilgarriff 1:a86efb0ef0ad 477 }
EndaKilgarriff 1:a86efb0ef0ad 478 }
EndaKilgarriff 1:a86efb0ef0ad 479
EndaKilgarriff 1:a86efb0ef0ad 480 set_register_value(dev, register_value, num_bytes, data_buffer);
EndaKilgarriff 1:a86efb0ef0ad 481 read_back_data = get_register_value(dev, register_value);
EndaKilgarriff 1:a86efb0ef0ad 482
EndaKilgarriff 1:a86efb0ef0ad 483 if (register_value == REG_HIST) {
EndaKilgarriff 1:a86efb0ef0ad 484 data &= 0x000F; //msbits are all low for HIST register
EndaKilgarriff 1:a86efb0ef0ad 485 read_back_data &= 0x000F; //msbits are all low for HIST register
EndaKilgarriff 1:a86efb0ef0ad 486 }
EndaKilgarriff 1:a86efb0ef0ad 487
EndaKilgarriff 1:a86efb0ef0ad 488 return read_back_data == data ? SUCCESS : FAILURE;
EndaKilgarriff 1:a86efb0ef0ad 489 }
EndaKilgarriff 1:a86efb0ef0ad 490
EndaKilgarriff 1:a86efb0ef0ad 491 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 492 * @brief Sets the Fault Queue option for ADT7420/ADT7320.
EndaKilgarriff 1:a86efb0ef0ad 493 *
EndaKilgarriff 1:a86efb0ef0ad 494 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 495 * @param mode - Fault Queue selection.
EndaKilgarriff 1:a86efb0ef0ad 496 * Example: 1 - 1 fault (default).
EndaKilgarriff 1:a86efb0ef0ad 497 * 2 - 2 faults.
EndaKilgarriff 1:a86efb0ef0ad 498 * 3 - 3 faults.
EndaKilgarriff 1:a86efb0ef0ad 499 * 4 - 4 faults.
EndaKilgarriff 1:a86efb0ef0ad 500 *
EndaKilgarriff 1:a86efb0ef0ad 501 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 502 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 503 void adt7420_set_fault_queue(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 504 uint8_t mode)
EndaKilgarriff 1:a86efb0ef0ad 505 {
EndaKilgarriff 1:a86efb0ef0ad 506 uint8_t register_value[1] = { 0 };
EndaKilgarriff 1:a86efb0ef0ad 507
EndaKilgarriff 1:a86efb0ef0ad 508 register_value[0] = get_register_value(dev, REG_CONFIG);
EndaKilgarriff 1:a86efb0ef0ad 509
EndaKilgarriff 1:a86efb0ef0ad 510 register_value[0] &= ~ADT7420_CONFIG_FAULT_QUEUE(ADT7420_FAULT_QUEUE_4_FAULTS);
EndaKilgarriff 1:a86efb0ef0ad 511 register_value[0] |= ADT7420_CONFIG_FAULT_QUEUE(mode);
EndaKilgarriff 1:a86efb0ef0ad 512
EndaKilgarriff 1:a86efb0ef0ad 513 set_register_value(dev,REG_CONFIG, ONE_BYTE, register_value);
EndaKilgarriff 1:a86efb0ef0ad 514 }
EndaKilgarriff 1:a86efb0ef0ad 515
EndaKilgarriff 1:a86efb0ef0ad 516 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 517 * @brief Sets comparator/interrupt (CT/INT) mode for ADT7420/ADT7320.
EndaKilgarriff 1:a86efb0ef0ad 518 *
EndaKilgarriff 1:a86efb0ef0ad 519 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 520 * @param setting - Mode selection.
EndaKilgarriff 1:a86efb0ef0ad 521 * Example: 0 - Interrupt (default).
EndaKilgarriff 1:a86efb0ef0ad 522 * 1 - Comparator.
EndaKilgarriff 1:a86efb0ef0ad 523 *
EndaKilgarriff 1:a86efb0ef0ad 524 *
EndaKilgarriff 1:a86efb0ef0ad 525 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 526 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 527 void adt7420_set_ct_int_mode(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 528 uint8_t setting)
EndaKilgarriff 1:a86efb0ef0ad 529 {
EndaKilgarriff 1:a86efb0ef0ad 530 uint8_t register_value[1] = { 0 };
EndaKilgarriff 1:a86efb0ef0ad 531
EndaKilgarriff 1:a86efb0ef0ad 532 register_value[0] = get_register_value(dev, REG_CONFIG);
EndaKilgarriff 1:a86efb0ef0ad 533
EndaKilgarriff 1:a86efb0ef0ad 534 register_value[0] &= ~ADT7420_CONFIG_INT_CT_MODE;
EndaKilgarriff 1:a86efb0ef0ad 535 register_value[0] |= (setting * ADT7420_CONFIG_INT_CT_MODE);
EndaKilgarriff 1:a86efb0ef0ad 536
EndaKilgarriff 1:a86efb0ef0ad 537 set_register_value(dev,REG_CONFIG, ONE_BYTE, register_value);
EndaKilgarriff 1:a86efb0ef0ad 538 }
EndaKilgarriff 1:a86efb0ef0ad 539
EndaKilgarriff 1:a86efb0ef0ad 540 /***************************************************************************//**
EndaKilgarriff 1:a86efb0ef0ad 541 * @brief Sets output polarity for the pins CT/INT (Critical Temp - Over/Under Temp).
EndaKilgarriff 1:a86efb0ef0ad 542 *
EndaKilgarriff 1:a86efb0ef0ad 543 * @param dev - The device structure.
EndaKilgarriff 1:a86efb0ef0ad 544 * @param polarity - Polarity selection.
EndaKilgarriff 1:a86efb0ef0ad 545 * Example: 0 - Active Low (default).
EndaKilgarriff 1:a86efb0ef0ad 546 * 1 - Active High.
EndaKilgarriff 1:a86efb0ef0ad 547 *
EndaKilgarriff 1:a86efb0ef0ad 548 *
EndaKilgarriff 1:a86efb0ef0ad 549 * @return None.
EndaKilgarriff 1:a86efb0ef0ad 550 *******************************************************************************/
EndaKilgarriff 1:a86efb0ef0ad 551 void adt7420_set_ct_int_polarity(struct adt7420_dev *dev,
EndaKilgarriff 1:a86efb0ef0ad 552 uint8_t polarity)
EndaKilgarriff 1:a86efb0ef0ad 553 {
EndaKilgarriff 1:a86efb0ef0ad 554 uint8_t register_value[1] = { 0 };
EndaKilgarriff 1:a86efb0ef0ad 555
EndaKilgarriff 1:a86efb0ef0ad 556 register_value[0] = get_register_value(dev, REG_CONFIG);
EndaKilgarriff 1:a86efb0ef0ad 557
EndaKilgarriff 1:a86efb0ef0ad 558 register_value[0] &= ~ADT7420_CONFIG_CT_POL;
EndaKilgarriff 1:a86efb0ef0ad 559 register_value[0] &= ~ADT7420_CONFIG_INT_POL;
EndaKilgarriff 1:a86efb0ef0ad 560 register_value[0] |= (polarity * ADT7420_CONFIG_CT_POL);
EndaKilgarriff 1:a86efb0ef0ad 561 register_value[0] |= (polarity * ADT7420_CONFIG_INT_POL);
EndaKilgarriff 1:a86efb0ef0ad 562
EndaKilgarriff 1:a86efb0ef0ad 563 set_register_value(dev,REG_CONFIG, ONE_BYTE, register_value);
EndaKilgarriff 1:a86efb0ef0ad 564 }