Kevin Braun / htu21d

Library for the Measurement Specialties' HTU21D Humidity and Temperature sensor. Code includes device's heater on/off control, serial number access, dew point calculations and RTOS hooks. To date, code tested on GR-PEACH, K64F and KL25Z boards with and w/o RTOS, SDFlash and USB serial Rx interrupts.

Dependents:   BLE_soil_humidity

Library for the Measurement Specialties / Honeywell HTU21D Humidity and Temperature sensor. Code includes device's heater on/off control, serial number access, dew point calculations and RTOS hooks. To date, code tested on K64F and KL25Z boards with and without RTOS, SDFileSystem and USB serial Rx interrupts.

The HTU21D's serial number is an odd cookie. There are two 16 bit registers and a 32 bit register are combined to generate the serial number. Some of the serial number bit fields are fixed for all devices and some change from part to part.

htu21d.cpp@3:5c0f8e91d319, 2015-04-30 (annotated)

Committer:
loopsva
Date:
Thu Apr 30 00:34:03 2015 +0000
Revision:
3:5c0f8e91d319
Parent:
2:8fbe84ed61e6 
Removed RTOS mutex dependencies, put onus back on calling program.  Option to use hi-level i2c commands, needed for the GR-PEACH which has bugs using low-level i2c commands. Add the line #define HTU21Di2cLOWLEVEL   1  in htu21d.h to use low-level i2c

Who changed what in which revision?

UserRevisionLine numberNew contents of line
loopsva 0:2dab43acb3a4 1 /**
loopsva 1:d3ed713f8354 2 HTU21D / HPP828E031 driver for mbed.
loopsva 1:d3ed713f8354 3 - Includes RTOS hooks if RTOS is detected during compile.
loopsva 0:2dab43acb3a4 4 Author: Kevin Braun
loopsva 0:2dab43acb3a4 5 **/
loopsva 1:d3ed713f8354 6
loopsva 0:2dab43acb3a4 7 #include "htu21d.h"
loopsva 0:2dab43acb3a4 8
loopsva 2:8fbe84ed61e6 9 double theTempIs = 0.0;
loopsva 2:8fbe84ed61e6 10 double theHumIs = 0.0;
loopsva 2:8fbe84ed61e6 11
loopsva 3:5c0f8e91d319 12 #if not defined HTU21Di2cLOWLEVEL
loopsva 3:5c0f8e91d319 13 char htuBuffer[8];
loopsva 3:5c0f8e91d319 14 #endif
loopsva 3:5c0f8e91d319 15
loopsva 0:2dab43acb3a4 16 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 17 //Contstructor
loopsva 0:2dab43acb3a4 18
loopsva 0:2dab43acb3a4 19 htu21d::htu21d(PinName sda, PinName scl) : _i2c(sda, scl) {
loopsva 1:d3ed713f8354 20 _i2c.frequency(400000);
loopsva 1:d3ed713f8354 21 }
loopsva 1:d3ed713f8354 22
loopsva 1:d3ed713f8354 23 htu21d::htu21d(PinName sda, PinName scl, int i2cFrequency) : _i2c(sda, scl) {
loopsva 1:d3ed713f8354 24 _i2c.frequency(i2cFrequency);
loopsva 0:2dab43acb3a4 25 }
loopsva 0:2dab43acb3a4 26
loopsva 0:2dab43acb3a4 27 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 1:d3ed713f8354 28 //Destructor
loopsva 0:2dab43acb3a4 29
loopsva 0:2dab43acb3a4 30 htu21d::~htu21d() {
loopsva 0:2dab43acb3a4 31 }
loopsva 0:2dab43acb3a4 32
loopsva 0:2dab43acb3a4 33 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 34 //Perform a soft reset on the HTU21D. REturn of 1 = ok, 0 = timeout.
loopsva 0:2dab43acb3a4 35
loopsva 0:2dab43acb3a4 36 int htu21d::softReset() {
loopsva 0:2dab43acb3a4 37 int htu21 = 0;
loopsva 3:5c0f8e91d319 38 #if defined HTU21Di2cLOWLEVEL
loopsva 0:2dab43acb3a4 39 _i2c.start();
loopsva 0:2dab43acb3a4 40 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 0:2dab43acb3a4 41 if(htu21 == 1) {
loopsva 0:2dab43acb3a4 42 _i2c.write(HTU21DRESET); //soft reset, must wait 15mS
loopsva 0:2dab43acb3a4 43 _i2c.stop();
loopsva 1:d3ed713f8354 44 wait_ms(16); //must wait a least 15mS for reset to finish
loopsva 1:d3ed713f8354 45 htu21d::getSNReg(); //go load up the s/n registers
loopsva 0:2dab43acb3a4 46 }
loopsva 3:5c0f8e91d319 47 return(htu21);
loopsva 3:5c0f8e91d319 48 #else
loopsva 3:5c0f8e91d319 49 htuBuffer[0] = HTU21DRESET;
loopsva 3:5c0f8e91d319 50 htu21 = _i2c.write(HTU21Di2cWRITE, htuBuffer, 1, false);
loopsva 3:5c0f8e91d319 51 wait_ms(16);
loopsva 3:5c0f8e91d319 52 htu21d::getSNReg();
loopsva 3:5c0f8e91d319 53 return(!(htu21));
loopsva 0:2dab43acb3a4 54 #endif
loopsva 0:2dab43acb3a4 55 }
loopsva 0:2dab43acb3a4 56
loopsva 0:2dab43acb3a4 57 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 58 //Get the HTU21D user register. Returns 8 bit register.
loopsva 0:2dab43acb3a4 59
loopsva 0:2dab43acb3a4 60 uint8_t htu21d::getUserReg() {
loopsva 3:5c0f8e91d319 61 #if defined HTU21Di2cLOWLEVEL
loopsva 0:2dab43acb3a4 62 int htu21 = 0;
loopsva 0:2dab43acb3a4 63 uint8_t htu21data = 0;
loopsva 0:2dab43acb3a4 64 _i2c.start();
loopsva 0:2dab43acb3a4 65 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 0:2dab43acb3a4 66 if(htu21 == 1) {
loopsva 0:2dab43acb3a4 67 _i2c.write(HTU21DREADUSER);
loopsva 0:2dab43acb3a4 68 _i2c.start();
loopsva 0:2dab43acb3a4 69 htu21 = _i2c.write(HTU21Di2cREAD);
loopsva 0:2dab43acb3a4 70 htu21data = _i2c.read(0);
loopsva 0:2dab43acb3a4 71 _i2c.stop();
loopsva 0:2dab43acb3a4 72 }
loopsva 3:5c0f8e91d319 73 return(htu21data);
loopsva 3:5c0f8e91d319 74 #else
loopsva 3:5c0f8e91d319 75 htuBuffer[0] = HTU21DREADUSER;
loopsva 3:5c0f8e91d319 76 _i2c.write(HTU21Di2cWRITE, htuBuffer, 1, true);
loopsva 3:5c0f8e91d319 77 if(!(_i2c.read(HTU21Di2cREAD, htuBuffer, 1, false))) {
loopsva 3:5c0f8e91d319 78 return(htuBuffer[0]);
loopsva 3:5c0f8e91d319 79 } else {
loopsva 3:5c0f8e91d319 80 return(0);
loopsva 3:5c0f8e91d319 81 }
loopsva 0:2dab43acb3a4 82 #endif
loopsva 0:2dab43acb3a4 83 }
loopsva 0:2dab43acb3a4 84
loopsva 0:2dab43acb3a4 85 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 86 //Turn ON the heater the HTU21D user register.
loopsva 0:2dab43acb3a4 87
loopsva 0:2dab43acb3a4 88 int htu21d::heaterOn() {
loopsva 0:2dab43acb3a4 89 uint8_t htu21data = htu21d::getUserReg();
loopsva 0:2dab43acb3a4 90 htu21data |= HTU21DHEATER;
loopsva 3:5c0f8e91d319 91 #if defined HTU21Di2cLOWLEVEL
loopsva 0:2dab43acb3a4 92 int htu21 = 0;
loopsva 0:2dab43acb3a4 93 _i2c.start();
loopsva 0:2dab43acb3a4 94 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 0:2dab43acb3a4 95 if(htu21 == 1) {
loopsva 0:2dab43acb3a4 96 _i2c.write(HTU21DWRITEUSER);
loopsva 0:2dab43acb3a4 97 htu21 = _i2c.write(htu21data);
loopsva 0:2dab43acb3a4 98 _i2c.stop();
loopsva 0:2dab43acb3a4 99 }
loopsva 3:5c0f8e91d319 100 return(htu21);
loopsva 3:5c0f8e91d319 101 #else
loopsva 3:5c0f8e91d319 102 htuBuffer[0] = HTU21DWRITEUSER;
loopsva 3:5c0f8e91d319 103 htuBuffer[1] = htu21data;
loopsva 3:5c0f8e91d319 104 return(_i2c.write(HTU21Di2cWRITE, htuBuffer, 2, false));
loopsva 0:2dab43acb3a4 105 #endif
loopsva 0:2dab43acb3a4 106 }
loopsva 0:2dab43acb3a4 107
loopsva 0:2dab43acb3a4 108 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 109 //Turn OFF the heater the HTU21D user register.
loopsva 0:2dab43acb3a4 110
loopsva 0:2dab43acb3a4 111 int htu21d::heaterOff() {
loopsva 0:2dab43acb3a4 112 uint8_t htu21data = htu21d::getUserReg();
loopsva 0:2dab43acb3a4 113 htu21data &= ~HTU21DHEATER;
loopsva 3:5c0f8e91d319 114 #if defined HTU21Di2cLOWLEVEL
loopsva 0:2dab43acb3a4 115 int htu21 = 0;
loopsva 0:2dab43acb3a4 116 _i2c.start();
loopsva 0:2dab43acb3a4 117 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 0:2dab43acb3a4 118 if(htu21 == 1) {
loopsva 0:2dab43acb3a4 119 _i2c.write(HTU21DWRITEUSER);
loopsva 0:2dab43acb3a4 120 htu21 = _i2c.write(htu21data);
loopsva 0:2dab43acb3a4 121 _i2c.stop();
loopsva 0:2dab43acb3a4 122 }
loopsva 3:5c0f8e91d319 123 return(htu21);
loopsva 3:5c0f8e91d319 124 #else
loopsva 3:5c0f8e91d319 125 htuBuffer[0] = HTU21DWRITEUSER;
loopsva 3:5c0f8e91d319 126 htuBuffer[1] = htu21data;
loopsva 3:5c0f8e91d319 127 return(_i2c.write(HTU21Di2cWRITE, htuBuffer, 2, false));
loopsva 0:2dab43acb3a4 128 #endif
loopsva 0:2dab43acb3a4 129
loopsva 0:2dab43acb3a4 130 }
loopsva 0:2dab43acb3a4 131
loopsva 0:2dab43acb3a4 132 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 133 //Get the status of the heater the HTU21D user register. 0 = off, 4 = on.
loopsva 0:2dab43acb3a4 134
loopsva 0:2dab43acb3a4 135 uint8_t htu21d::getHeater() {
loopsva 0:2dab43acb3a4 136 uint8_t htu21data = htu21d::getUserReg();
loopsva 0:2dab43acb3a4 137 htu21data &= HTU21DHEATER;
loopsva 0:2dab43acb3a4 138 return(htu21data);
loopsva 0:2dab43acb3a4 139 }
loopsva 0:2dab43acb3a4 140
loopsva 0:2dab43acb3a4 141 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 142 //generic routine to get temp or humidity from HTU21D.
loopsva 0:2dab43acb3a4 143 //Returns 14 bits of data (anded 0xFFFC) or 0000 if i2c timeout occurs.
loopsva 0:2dab43acb3a4 144 //After a read temp or humidity command, HTU21D responds with NACKs until data is ready.
loopsva 0:2dab43acb3a4 145 //NOTE: Use non-hold commands
loopsva 0:2dab43acb3a4 146
loopsva 0:2dab43acb3a4 147 uint16_t htu21d::getData(uint8_t reg) {
loopsva 0:2dab43acb3a4 148 int htu21cnt = 0; //number of NACKs before ACK or timeout
loopsva 3:5c0f8e91d319 149 #if defined HTU21Di2cLOWLEVEL
loopsva 0:2dab43acb3a4 150 uint16_t htu21data = 0; //returned data
loopsva 3:5c0f8e91d319 151 int htu21 = 0; //ACK flag
loopsva 0:2dab43acb3a4 152 _i2c.start();
loopsva 0:2dab43acb3a4 153 htu21 = _i2c.write(HTU21Di2cWRITE);
loopsva 0:2dab43acb3a4 154 _i2c.write(reg); //read temp, no hold
loopsva 2:8fbe84ed61e6 155 _i2c.stop();
loopsva 0:2dab43acb3a4 156 if(htu21 == 0) return 0; //HTU21T not responding
loopsva 0:2dab43acb3a4 157 do {
loopsva 0:2dab43acb3a4 158 htu21cnt++;
loopsva 0:2dab43acb3a4 159 _i2c.start();
loopsva 0:2dab43acb3a4 160 htu21 = _i2c.write(HTU21Di2cREAD);
loopsva 0:2dab43acb3a4 161 if(htu21 == 1) {
loopsva 0:2dab43acb3a4 162 htu21data = _i2c.read(1) << 8;
loopsva 0:2dab43acb3a4 163 htu21data |= _i2c.read(0) & 0xFC;
loopsva 0:2dab43acb3a4 164 _i2c.stop();
loopsva 0:2dab43acb3a4 165 }
loopsva 2:8fbe84ed61e6 166 wait_us(1000);
loopsva 2:8fbe84ed61e6 167 } while((htu21cnt < 100) && (htu21 == 0)); //htu21cnt takes 55 to get temp, 16 for humidity (at 1mS loops)
loopsva 2:8fbe84ed61e6 168
loopsva 0:2dab43acb3a4 169 if(htu21 == 0) return 0; //HTU21D ACK response timed out
loopsva 0:2dab43acb3a4 170 return(htu21data); //return 14 bit value
loopsva 3:5c0f8e91d319 171 #else
loopsva 3:5c0f8e91d319 172 htuBuffer[0] = reg;
loopsva 3:5c0f8e91d319 173 _i2c.write(HTU21Di2cWRITE, htuBuffer, 1, false);
loopsva 3:5c0f8e91d319 174 do {
loopsva 3:5c0f8e91d319 175 htu21cnt++;
loopsva 3:5c0f8e91d319 176 if(!(_i2c.read(HTU21Di2cREAD, htuBuffer, 2, false))) {
loopsva 3:5c0f8e91d319 177 return((htuBuffer[0] << 8) | htuBuffer[1]);
loopsva 3:5c0f8e91d319 178 }
loopsva 3:5c0f8e91d319 179 wait_us(1000);
loopsva 3:5c0f8e91d319 180 } while(htu21cnt < 100);
loopsva 3:5c0f8e91d319 181 return 0;
loopsva 3:5c0f8e91d319 182 #endif
loopsva 0:2dab43acb3a4 183 }
loopsva 0:2dab43acb3a4 184
loopsva 0:2dab43acb3a4 185 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 186 //get temperature from HTU21D in degrees C. Returns with 255.0 if HTU21D had timed out.
loopsva 0:2dab43acb3a4 187
loopsva 0:2dab43acb3a4 188 float htu21d::getTemp() {
loopsva 0:2dab43acb3a4 189 uint16_t getData = htu21d::getData(HTU21DtempNOHOLD);
loopsva 0:2dab43acb3a4 190 if (getData == 0) return(255.0); //return with error
loopsva 0:2dab43acb3a4 191 double tempData = (double)getData / 65536.0;
loopsva 0:2dab43acb3a4 192 theTempIs = -46.85 + (175.72 * tempData);
loopsva 0:2dab43acb3a4 193 return(theTempIs);
loopsva 0:2dab43acb3a4 194 }
loopsva 0:2dab43acb3a4 195
loopsva 0:2dab43acb3a4 196 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 197 //get humidity from HTU21D in percentage. Returns with 255.0 if HTU21D had timed out.
loopsva 0:2dab43acb3a4 198
loopsva 0:2dab43acb3a4 199 float htu21d::getHum() {
loopsva 0:2dab43acb3a4 200 uint16_t getData = htu21d::getData(HTU21DhumNOHOLD);
loopsva 0:2dab43acb3a4 201 if (getData == 0) return(255.0); //return with error
loopsva 0:2dab43acb3a4 202 double tempData = (double)getData / 65536.0;
loopsva 0:2dab43acb3a4 203 theHumIs = -6.0 + (125.0 * tempData);
loopsva 0:2dab43acb3a4 204 return(theHumIs);
loopsva 0:2dab43acb3a4 205 }
loopsva 0:2dab43acb3a4 206
loopsva 0:2dab43acb3a4 207 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 0:2dab43acb3a4 208 //Calculate the Dew Point from getTemp and getHum. User must first execute both getTemp and getHum for an accurate result.
loopsva 0:2dab43acb3a4 209 //Calculations come from DHT library
loopsva 0:2dab43acb3a4 210 /* Copyright (C) Wim De Roeve
loopsva 0:2dab43acb3a4 211 * based on DHT22 sensor library by HO WING KIT
loopsva 0:2dab43acb3a4 212 * Arduino DHT11 library
loopsva 0:2dab43acb3a4 213 */
loopsva 0:2dab43acb3a4 214
loopsva 0:2dab43acb3a4 215 float htu21d::getDewPt() {
loopsva 0:2dab43acb3a4 216 // dewPoint function NOAA
loopsva 0:2dab43acb3a4 217 // reference: http://wahiduddin.net/calc/density_algorithms.htm
loopsva 0:2dab43acb3a4 218 double A0= 373.15/(273.15 + (double)theTempIs);
loopsva 0:2dab43acb3a4 219 double SUM = -7.90298 * (A0-1);
loopsva 0:2dab43acb3a4 220 SUM += 5.02808 * log10(A0);
loopsva 0:2dab43acb3a4 221 SUM += -1.3816e-7 * (pow(10, (11.344*(1-1/A0)))-1) ;
loopsva 0:2dab43acb3a4 222 SUM += 8.1328e-3 * (pow(10,(-3.49149*(A0-1)))-1) ;
loopsva 0:2dab43acb3a4 223 SUM += log10(1013.246);
loopsva 0:2dab43acb3a4 224 double VP = pow(10, SUM-3) * theHumIs;
loopsva 0:2dab43acb3a4 225 double T = log(VP/0.61078); // temp var
loopsva 0:2dab43acb3a4 226 return (241.88 * T) / (17.558-T);
loopsva 0:2dab43acb3a4 227 }
loopsva 0:2dab43acb3a4 228
loopsva 0:2dab43acb3a4 229 float htu21d::getDewPtFast() {
loopsva 0:2dab43acb3a4 230 // delta max = 0.6544 wrt dewPoint()
loopsva 0:2dab43acb3a4 231 // 5x faster than dewPoint()
loopsva 0:2dab43acb3a4 232 // reference: http://en.wikipedia.org/wiki/Dew_point
loopsva 0:2dab43acb3a4 233 double h21DtzA = 17.271;
loopsva 0:2dab43acb3a4 234 double h21DtzB = 237.7;
loopsva 0:2dab43acb3a4 235 double h21DtzC = (h21DtzA * theTempIs) / (h21DtzB + theTempIs) + log(theHumIs/100);
loopsva 0:2dab43acb3a4 236 double h21DtzD = (h21DtzB * h21DtzC) / (h21DtzA - h21DtzC);
loopsva 0:2dab43acb3a4 237 return (h21DtzD);
loopsva 0:2dab43acb3a4 238 }
loopsva 1:d3ed713f8354 239
loopsva 1:d3ed713f8354 240 //--------------------------------------------------------------------------------------------------------------------------------------//
loopsva 1:d3ed713f8354 241 //Get the HTU21D serial number registers. Returns 64 bit register.
loopsva 1:d3ed713f8354 242 //should return 0x4854 00xx xxxx 32xx
loopsva 1:d3ed713f8354 243
loopsva 1:d3ed713f8354 244 void htu21d::getSNReg() {
loopsva 1:d3ed713f8354 245 //get 16 bit SNC register, 8 bit SNC-CRC, 16 bit SNA register, 8 bit SNA-CRC
loopsva 3:5c0f8e91d319 246 #if defined HTU21Di2cLOWLEVEL
loopsva 1:d3ed713f8354 247 int htu21 = 0;
loopsva 1:d3ed713f8354 248 _i2c.start();
loopsva 1:d3ed713f8354 249 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 1:d3ed713f8354 250 if(htu21 == 1) {
loopsva 1:d3ed713f8354 251 _i2c.write(HTU21SNAC1);
loopsva 1:d3ed713f8354 252 _i2c.write(HTU21SNAC2);
loopsva 1:d3ed713f8354 253 _i2c.start();
loopsva 1:d3ed713f8354 254 htu21 = _i2c.write(HTU21Di2cREAD);
loopsva 1:d3ed713f8354 255 HTU21sn.HTU21D_snc = _i2c.read(1) << 8;
loopsva 1:d3ed713f8354 256 HTU21sn.HTU21D_snc |= _i2c.read(1);
loopsva 1:d3ed713f8354 257 HTU21sn.HTU21D_crcc = _i2c.read(1);
loopsva 1:d3ed713f8354 258 HTU21sn.HTU21D_sna = _i2c.read(1) << 8;
loopsva 1:d3ed713f8354 259 HTU21sn.HTU21D_sna |= _i2c.read(1);
loopsva 1:d3ed713f8354 260 HTU21sn.HTU21D_crca = _i2c.read(0);
loopsva 1:d3ed713f8354 261 _i2c.stop();
loopsva 3:5c0f8e91d319 262 } else {
loopsva 3:5c0f8e91d319 263 HTU21sn.HTU21D_snc = HTU21sn.HTU21D_crcc = HTU21sn.HTU21D_sna = HTU21sn.HTU21D_crca = 0;
loopsva 1:d3ed713f8354 264 }
loopsva 3:5c0f8e91d319 265 #else
loopsva 3:5c0f8e91d319 266 htuBuffer[0] = HTU21SNAC1;
loopsva 3:5c0f8e91d319 267 htuBuffer[1] = HTU21SNAC2;
loopsva 3:5c0f8e91d319 268 _i2c.write(HTU21Di2cWRITE, htuBuffer, 2, true);
loopsva 3:5c0f8e91d319 269 if(!(_i2c.read(HTU21Di2cREAD, htuBuffer, 6, false))) {
loopsva 3:5c0f8e91d319 270 HTU21sn.HTU21D_snc = (htuBuffer[0] << 8) | htuBuffer[1];
loopsva 3:5c0f8e91d319 271 HTU21sn.HTU21D_crcc = htuBuffer[2];
loopsva 3:5c0f8e91d319 272 HTU21sn.HTU21D_sna = (htuBuffer[3] << 8) | htuBuffer[4];
loopsva 3:5c0f8e91d319 273 HTU21sn.HTU21D_crca = htuBuffer[5];
loopsva 3:5c0f8e91d319 274 } else {
loopsva 3:5c0f8e91d319 275 HTU21sn.HTU21D_snc = HTU21sn.HTU21D_crcc = HTU21sn.HTU21D_sna = HTU21sn.HTU21D_crca = 0;
loopsva 3:5c0f8e91d319 276 }
loopsva 3:5c0f8e91d319 277 #endif
loopsva 1:d3ed713f8354 278
loopsva 1:d3ed713f8354 279 //get 32 bit SNB register, 32 bit SNB-CRC - regs are intermixed
loopsva 3:5c0f8e91d319 280 #if defined HTU21Di2cLOWLEVEL
loopsva 1:d3ed713f8354 281 htu21 = 0;
loopsva 1:d3ed713f8354 282 _i2c.start();
loopsva 1:d3ed713f8354 283 htu21 = _i2c.write(HTU21Di2cWRITE); //i2c, 1 = ack
loopsva 1:d3ed713f8354 284 if(htu21 == 1) {
loopsva 1:d3ed713f8354 285 _i2c.write(HTU21SNB1);
loopsva 1:d3ed713f8354 286 _i2c.write(HTU21SNB2);
loopsva 1:d3ed713f8354 287 _i2c.start();
loopsva 1:d3ed713f8354 288 htu21 = _i2c.write(HTU21Di2cREAD);
loopsva 1:d3ed713f8354 289 HTU21sn.HTU21D_snb = _i2c.read(1) << 24;
loopsva 1:d3ed713f8354 290 HTU21sn.HTU21D_crcb = _i2c.read(1) << 24;
loopsva 1:d3ed713f8354 291 HTU21sn.HTU21D_snb |= _i2c.read(1) << 16;
loopsva 1:d3ed713f8354 292 HTU21sn.HTU21D_crcb |= _i2c.read(1) << 16;
loopsva 1:d3ed713f8354 293 HTU21sn.HTU21D_snb |= _i2c.read(1) << 8;
loopsva 1:d3ed713f8354 294 HTU21sn.HTU21D_crcb |= _i2c.read(1) << 8;
loopsva 1:d3ed713f8354 295 HTU21sn.HTU21D_snb |= _i2c.read(1);
loopsva 1:d3ed713f8354 296 HTU21sn.HTU21D_crcb |= _i2c.read(0);
loopsva 1:d3ed713f8354 297 _i2c.stop();
loopsva 3:5c0f8e91d319 298 } else {
loopsva 3:5c0f8e91d319 299 HTU21sn.HTU21D_snb = HTU21sn.HTU21D_crcb = 0;
loopsva 1:d3ed713f8354 300 }
loopsva 3:5c0f8e91d319 301 #else
loopsva 3:5c0f8e91d319 302 htuBuffer[0] = HTU21SNB1;
loopsva 3:5c0f8e91d319 303 htuBuffer[1] = HTU21SNB2;
loopsva 3:5c0f8e91d319 304 _i2c.write(HTU21Di2cWRITE, htuBuffer, 2, true);
loopsva 3:5c0f8e91d319 305 if(!(_i2c.read(HTU21Di2cREAD, htuBuffer, 8, false))) {
loopsva 3:5c0f8e91d319 306 HTU21sn.HTU21D_snb = (htuBuffer[0] << 24) | (htuBuffer[2] << 16) | (htuBuffer[4] << 8) | htuBuffer[6];
loopsva 3:5c0f8e91d319 307 HTU21sn.HTU21D_crcb = (htuBuffer[1] << 24) | (htuBuffer[3] << 16) | (htuBuffer[5] << 8) | htuBuffer[7];
loopsva 3:5c0f8e91d319 308 } else {
loopsva 3:5c0f8e91d319 309 HTU21sn.HTU21D_snb = HTU21sn.HTU21D_crcb = 0;
loopsva 3:5c0f8e91d319 310 }
loopsva 1:d3ed713f8354 311 #endif
loopsva 1:d3ed713f8354 312 }
loopsva 1:d3ed713f8354 313