Single and Dual Zone Infra Red Thermometer
Embed:
(wiki syntax)
Show/hide line numbers
MLX90614.cpp
00001 /** 00002 * @brief MLX90614.cpp 00003 * @details Single and Dual Zone Infra Red Thermometer. 00004 * Function file. 00005 * 00006 * 00007 * @return NA 00008 * 00009 * @author Manuel Caballero 00010 * @date 26/December/2017 00011 * @version 26/December/2017 The ORIGIN 00012 * @pre NaN. 00013 * @warning NaN 00014 * @pre This code belongs to AqueronteBlog ( http://unbarquero.blogspot.com ). 00015 */ 00016 00017 #include "MLX90614.h" 00018 00019 00020 MLX90614::MLX90614 ( PinName sda, PinName scl, uint32_t addr, uint32_t freq ) 00021 : _i2c ( sda, scl ) 00022 , _MLX90614_Addr ( addr ) 00023 { 00024 _i2c.frequency( freq ); 00025 } 00026 00027 00028 MLX90614::~MLX90614() 00029 { 00030 } 00031 00032 00033 00034 00035 /** 00036 * @brief MLX90614_GetID_Numbers ( MLX90614_vector_data_t* ) 00037 * 00038 * @details It gets the ID numbers. 00039 * 00040 * @param[in] NaN 00041 * 00042 * @param[out] myID: ID numbers. 00043 * 00044 * 00045 * @return Status of MLX90614_GetID_Numbers. 00046 * 00047 * 00048 * @author Manuel Caballero 00049 * @date 26/December/2017 00050 * @version 26/December/2017 The ORIGIN 00051 * @pre NaN. 00052 * @warning NaN. 00053 */ 00054 MLX90614::MLX90614_status_t MLX90614::MLX90614_GetID_Numbers ( MLX90614_vector_data_t* myID ) 00055 { 00056 char cmd[] = { 0, 0, 0 }; 00057 uint32_t aux = 0; 00058 00059 00060 // It gets the ID 0 00061 cmd[0] = MLX90614_ID_NUMBER_0 ; 00062 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00063 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00064 00065 myID->ID[0] = ( ( cmd[1] << 8 ) | cmd[0] ); 00066 00067 00068 // It gets the ID 1 00069 cmd[0] = MLX90614_ID_NUMBER_1 ; 00070 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00071 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00072 00073 myID->ID[1] = ( ( cmd[1] << 8 ) | cmd[0] ); 00074 00075 00076 // It gets the ID 2 00077 cmd[0] = MLX90614_ID_NUMBER_2 ; 00078 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00079 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00080 00081 myID->ID[2] = ( ( cmd[1] << 8 ) | cmd[0] ); 00082 00083 00084 // It gets the ID 3 00085 cmd[0] = MLX90614_ID_NUMBER_3 ; 00086 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00087 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00088 00089 myID->ID[3] = ( ( cmd[1] << 8 ) | cmd[0] ); 00090 00091 00092 00093 00094 if ( aux == I2C_SUCCESS ) 00095 return MLX90614_SUCCESS; 00096 else 00097 return MLX90614_FAILURE; 00098 } 00099 00100 00101 /** 00102 * @brief MLX90614_ReadRawTA ( MLX90614_vector_data_t* ) 00103 * 00104 * @details It raw ambient temperature. 00105 * 00106 * @param[in] NaN. 00107 * 00108 * @param[out] myRawTA: Raw ambient temperature. 00109 * 00110 * 00111 * @return Status of MLX90614_ReadRawTA. 00112 * 00113 * 00114 * @author Manuel Caballero 00115 * @date 26/December/2017 00116 * @version 26/December/2017 The ORIGIN 00117 * @pre NaN. 00118 * @warning NaN. 00119 */ 00120 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadRawTA ( MLX90614_vector_data_t* myRawTA ) 00121 { 00122 char cmd[] = { MLX90614_TA , 0, 0 }; 00123 uint32_t aux = 0; 00124 00125 00126 // It gets the raw ambient temperature 00127 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00128 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00129 00130 00131 myRawTA->RawTA = ( ( cmd[1] << 8 ) | cmd[0] ); 00132 myRawTA->PEC = cmd[2]; 00133 00134 // Check if flag error is triggered ( faulty if so ) 00135 if ( ( myRawTA->RawTA & MLX90614_FLAG_ERROR ) == MLX90614_FLAG_ERROR ) 00136 return MLX90614_FAILURE; 00137 00138 00139 if ( aux == I2C_SUCCESS ) 00140 return MLX90614_SUCCESS; 00141 else 00142 return MLX90614_FAILURE; 00143 } 00144 00145 00146 /** 00147 * @brief MLX90614_ReadTA ( MLX90614_vector_data_t* ) 00148 * 00149 * @details It ambient temperature. 00150 * 00151 * @param[in] NaN 00152 * 00153 * @param[out] myTA: Ambient temperature in Celsius. 00154 * 00155 * 00156 * @return Status of MLX90614_ReadTA. 00157 * 00158 * 00159 * @author Manuel Caballero 00160 * @date 26/December/2017 00161 * @version 26/December/2017 The ORIGIN 00162 * @pre NaN. 00163 * @warning NaN. 00164 */ 00165 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadTA ( MLX90614_vector_data_t* myTA ) 00166 { 00167 char cmd[] = { MLX90614_TA , 0, 0 }; 00168 uint32_t aux = 0; 00169 00170 00171 // It gets the raw ambient temperature 00172 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00173 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00174 00175 00176 myTA->TA = ( MLX90614_KELVIN_CONVERSION * ( ( ( cmd[1] << 8 ) | cmd[0] ) ) ) - MLX90614_KELVIN_TO_CELSIUS; 00177 myTA->PEC = cmd[2]; 00178 00179 // Check if flag error is triggered ( faulty if so ) 00180 if ( ( cmd[1] & ( MLX90614_FLAG_ERROR >> 8 ) ) == ( MLX90614_FLAG_ERROR >> 8 ) ) 00181 return MLX90614_FAILURE; 00182 00183 00184 if ( aux == I2C_SUCCESS ) 00185 return MLX90614_SUCCESS; 00186 else 00187 return MLX90614_FAILURE; 00188 } 00189 00190 00191 /** 00192 * @brief MLX90614_ReadRawTObj1 ( MLX90614_vector_data_t* ) 00193 * 00194 * @details It raw object 1 temperature. 00195 * 00196 * @param[in] NaN. 00197 * 00198 * @param[out] myRawTObj1: Raw object 1 temperature. 00199 * 00200 * 00201 * @return Status of MLX90614_ReadRawTObj1. 00202 * 00203 * 00204 * @author Manuel Caballero 00205 * @date 26/December/2017 00206 * @version 26/December/2017 The ORIGIN 00207 * @pre NaN. 00208 * @warning NaN. 00209 */ 00210 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadRawTObj1 ( MLX90614_vector_data_t* myRawTObj1 ) 00211 { 00212 char cmd[] = { MLX90614_TOBJ_1 , 0, 0 }; 00213 uint32_t aux = 0; 00214 00215 00216 // It gets the raw object 1 temperature 00217 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00218 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00219 00220 00221 myRawTObj1->RawTObj1 = ( ( cmd[1] << 8 ) | cmd[0] ); 00222 myRawTObj1->PEC = cmd[2]; 00223 00224 // Check if flag error is triggered ( faulty if so ) 00225 if ( ( myRawTObj1->RawTObj1 & MLX90614_FLAG_ERROR ) == MLX90614_FLAG_ERROR ) 00226 return MLX90614_FAILURE; 00227 00228 00229 if ( aux == I2C_SUCCESS ) 00230 return MLX90614_SUCCESS; 00231 else 00232 return MLX90614_FAILURE; 00233 } 00234 00235 00236 /** 00237 * @brief MLX90614_ReadTObj1 ( MLX90614_vector_data_t* ) 00238 * 00239 * @details It object 1 temperature. 00240 * 00241 * @param[in] NaN. 00242 * 00243 * @param[out] myTObj1: Object 1 temperature in Celsius. 00244 * 00245 * 00246 * @return Status of MLX90614_ReadTObj1. 00247 * 00248 * 00249 * @author Manuel Caballero 00250 * @date 26/December/2017 00251 * @version 26/December/2017 The ORIGIN 00252 * @pre NaN. 00253 * @warning NaN. 00254 */ 00255 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadTObj1 ( MLX90614_vector_data_t* myTObj1 ) 00256 { 00257 char cmd[] = { MLX90614_TOBJ_1 , 0, 0 }; 00258 uint32_t aux = 0; 00259 00260 00261 // It gets the raw object 1 temperature 00262 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00263 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00264 00265 00266 myTObj1->TObj1 = ( MLX90614_KELVIN_CONVERSION * ( ( ( cmd[1] << 8 ) | cmd[0] ) ) ) - MLX90614_KELVIN_TO_CELSIUS; 00267 myTObj1->PEC = cmd[2]; 00268 00269 // Check if flag error is triggered ( faulty if so ) 00270 if ( ( cmd[1] & ( MLX90614_FLAG_ERROR >> 8 ) ) == ( MLX90614_FLAG_ERROR >> 8 ) ) 00271 return MLX90614_FAILURE; 00272 00273 00274 if ( aux == I2C_SUCCESS ) 00275 return MLX90614_SUCCESS; 00276 else 00277 return MLX90614_FAILURE; 00278 } 00279 00280 00281 /** 00282 * @brief MLX90614_ReadRawTObj2 ( MLX90614_vector_data_t* ) 00283 * 00284 * @details It raw object 2 temperature. 00285 * 00286 * @param[in] NaN. 00287 * 00288 * @param[out] myRawTObj1: Raw object 2 temperature. 00289 * 00290 * 00291 * @return Status of MLX90614_ReadRawTObj2. 00292 * 00293 * 00294 * @author Manuel Caballero 00295 * @date 26/December/2017 00296 * @version 26/December/2017 The ORIGIN 00297 * @pre NaN. 00298 * @warning NaN. 00299 */ 00300 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadRawTObj2 ( MLX90614_vector_data_t* myRawTObj2 ) 00301 { 00302 char cmd[] = { MLX90614_TOBJ_2 , 0, 0 }; 00303 uint32_t aux = 0; 00304 00305 00306 // It gets the raw object 1 temperature 00307 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00308 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00309 00310 00311 myRawTObj2->RawTObj2 = ( ( cmd[1] << 8 ) | cmd[0] ); 00312 myRawTObj2->PEC = cmd[2]; 00313 00314 // Check if flag error is triggered ( faulty if so ) 00315 if ( ( myRawTObj2->RawTObj2 & MLX90614_FLAG_ERROR ) == MLX90614_FLAG_ERROR ) 00316 return MLX90614_FAILURE; 00317 00318 00319 if ( aux == I2C_SUCCESS ) 00320 return MLX90614_SUCCESS; 00321 else 00322 return MLX90614_FAILURE; 00323 } 00324 00325 00326 /** 00327 * @brief MLX90614_ReadTObj2 ( MLX90614_vector_data_t* ) 00328 * 00329 * @details It object 2 temperature. 00330 * 00331 * @param[in] NaN. 00332 * 00333 * @param[out] myTObj2: Object 2 temperature in Celsius. 00334 * 00335 * 00336 * @return Status of MLX90614_ReadTObj2. 00337 * 00338 * 00339 * @author Manuel Caballero 00340 * @date 26/December/2017 00341 * @version 26/December/2017 The ORIGIN 00342 * @pre NaN. 00343 * @warning NaN. 00344 */ 00345 MLX90614::MLX90614_status_t MLX90614::MLX90614_ReadTObj2 ( MLX90614_vector_data_t* myTObj2 ) 00346 { 00347 char cmd[] = { MLX90614_TOBJ_2 , 0, 0 }; 00348 uint32_t aux = 0; 00349 00350 00351 // It gets the raw object 2 temperature 00352 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00353 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00354 00355 00356 myTObj2->TObj2 = ( MLX90614_KELVIN_CONVERSION * ( ( ( cmd[1] << 8 ) | cmd[0] ) ) ) - MLX90614_KELVIN_TO_CELSIUS; 00357 myTObj2->PEC = cmd[2]; 00358 00359 // Check if flag error is triggered ( faulty if so ) 00360 if ( ( cmd[1] & ( MLX90614_FLAG_ERROR >> 8 ) ) == ( MLX90614_FLAG_ERROR >> 8 ) ) 00361 return MLX90614_FAILURE; 00362 00363 00364 if ( aux == I2C_SUCCESS ) 00365 return MLX90614_SUCCESS; 00366 else 00367 return MLX90614_FAILURE; 00368 } 00369 00370 00371 /** 00372 * @brief MLX90614_GetEmissivity ( MLX90614_vector_data_t* ) 00373 * 00374 * @details It gets the Emissivity correction coefficient. 00375 * 00376 * @param[in] NaN 00377 * 00378 * @param[out] myEmissivity: Emissivity correction coefficient. 00379 * 00380 * 00381 * @return Status of MLX90614_GetEmissivity. 00382 * 00383 * 00384 * @author Manuel Caballero 00385 * @date 26/December/2017 00386 * @version 26/December/2017 The ORIGIN 00387 * @pre NaN. 00388 * @warning NaN. 00389 */ 00390 MLX90614::MLX90614_status_t MLX90614::MLX90614_GetEmissivity ( MLX90614_vector_data_t* myEmissivity ) 00391 { 00392 char cmd[] = { MLX90614_EMISSIVITY_CORRECTION_COEFFICIENT , 0, 0 }; 00393 uint32_t aux = 0; 00394 00395 00396 // It gets the Emissivity correction coefficient 00397 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00398 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00399 00400 00401 myEmissivity->Emissivity = ( ( cmd[1] << 8 ) | cmd[0] ); 00402 myEmissivity->Emissivity /= 65535; 00403 myEmissivity->PEC = cmd[2]; 00404 00405 00406 00407 00408 if ( aux == I2C_SUCCESS ) 00409 return MLX90614_SUCCESS; 00410 else 00411 return MLX90614_FAILURE; 00412 } 00413 00414 00415 /** 00416 * @brief MLX90614_SetEmissivity ( MLX90614_vector_data_t* ) 00417 * 00418 * @details It sets the Emissivity correction coefficient. 00419 * 00420 * @param[in] NaN. 00421 * @param[in] myEmissivity: Emissivity correction coefficient. 00422 * 00423 * @param[out] NaN 00424 * 00425 * 00426 * @return Status of MLX90614_SetEmissivity. 00427 * 00428 * 00429 * @author Manuel Caballero 00430 * @date 26/December/2017 00431 * @version 26/December/2017 The ORIGIN 00432 * @pre NaN. 00433 * @warning NaN. 00434 */ 00435 MLX90614::MLX90614_status_t MLX90614::MLX90614_SetEmissivity ( MLX90614_vector_data_t myEmissivity ) 00436 { 00437 char cmd[] = { MLX90614_EMISSIVITY_CORRECTION_COEFFICIENT , 0, 0 }; 00438 uint32_t aux = 0; 00439 uint32_t ii = 0; 00440 00441 00442 // Check Emissivity range 00443 if ( ( myEmissivity.Emissivity >= 0.1 ) && ( myEmissivity.Emissivity <= 1) ) 00444 { 00445 // Erase EEPROM 00446 cmd[1] = 0; 00447 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 2, false ); 00448 00449 // It takes EEPROM about 5ms to write/read 00450 do 00451 { 00452 cmd[0] = MLX90614_FLAGS ; 00453 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00454 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], 3 ); 00455 ii++; // Increase the timeout 00456 } 00457 while ( ( ( cmd[0] & FLAG_EEBUSY_HIGH ) == FLAG_EEBUSY_HIGH ) && ( ii < MLX90614_TIMEOUT ) ); 00458 00459 00460 // If TIMEOUT, exit with failure. 00461 if ( ii >= MLX90614_TIMEOUT ) 00462 return MLX90614_FAILURE; 00463 else 00464 { 00465 // Update the new value 00466 cmd[0] = MLX90614_EMISSIVITY_CORRECTION_COEFFICIENT ; 00467 cmd[1] = _MYROUND( 65535 * myEmissivity.Emissivity ); 00468 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 2, false ); 00469 } 00470 } 00471 else 00472 return MLX90614_FAILURE; 00473 00474 00475 00476 00477 if ( aux == I2C_SUCCESS ) 00478 return MLX90614_SUCCESS; 00479 else 00480 return MLX90614_FAILURE; 00481 } 00482 00483 00484 /** 00485 * @brief MLX90614_GetIIR ( MLX90614_vector_data_t* ) 00486 * 00487 * @details It gets the IIR. 00488 * 00489 * @param[in] NaN. 00490 * 00491 * @param[out] myIIR: IIR. 00492 * 00493 * 00494 * @return Status of MLX90614_GetIIR. 00495 * 00496 * 00497 * @author Manuel Caballero 00498 * @date 26/December/2017 00499 * @version 26/December/2017 The ORIGIN 00500 * @pre NaN. 00501 * @warning NaN. 00502 */ 00503 MLX90614::MLX90614_status_t MLX90614::MLX90614_GetIIR ( MLX90614_vector_data_t* myIIR ) 00504 { 00505 char cmd[] = { MLX90614_CONFIG_REGISTER_1 , 0, 0 }; 00506 uint32_t aux = 0; 00507 00508 00509 // It gets the IIR 00510 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00511 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00512 00513 00514 myIIR->IIR = ( MLX90614_configregister1_iir_t )( cmd[0] & CONFIGREG1_IIR_MASK ); 00515 myIIR->PEC = cmd[2]; 00516 00517 00518 00519 00520 if ( aux == I2C_SUCCESS ) 00521 return MLX90614_SUCCESS; 00522 else 00523 return MLX90614_FAILURE; 00524 } 00525 00526 00527 /** 00528 * @brief MLX90614_SetIIR ( MLX90614_configregister1_iir_t ) 00529 * 00530 * @details It sets the IIR. 00531 * 00532 * @param[in] NaN. 00533 * @param[in] myIIR: IIR. 00534 * 00535 * @param[out] NaN. 00536 * 00537 * 00538 * @return Status of MLX90614_SetIIR. 00539 * 00540 * 00541 * @author Manuel Caballero 00542 * @date 26/December/2017 00543 * @version 26/December/2017 The ORIGIN 00544 * @pre NaN. 00545 * @warning NaN. 00546 */ 00547 MLX90614::MLX90614_status_t MLX90614::MLX90614_SetIIR ( MLX90614_configregister1_iir_t myIIR ) 00548 { 00549 char cmd[] = { MLX90614_CONFIG_REGISTER_1 , 0, 0 }; 00550 uint32_t aux = 0; 00551 uint32_t ii = 0; 00552 00553 00554 // It gets the IIR 00555 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00556 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00557 00558 // Erase EEPROM 00559 cmd[2] = cmd[1]; // MSB 00560 cmd[1] = ( cmd[0] & ~CONFIGREG1_IIR_MASK ); // LSB 00561 cmd[0] = MLX90614_CONFIG_REGISTER_1 ; // Command 00562 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 3, false ); 00563 00564 // It takes EEPROM about 5ms to write/read 00565 do 00566 { 00567 cmd[0] = MLX90614_FLAGS ; 00568 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00569 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], 3 ); 00570 ii++; // Increase the timeout 00571 } 00572 while ( ( ( cmd[0] & FLAG_EEBUSY_HIGH ) == FLAG_EEBUSY_HIGH ) && ( ii < MLX90614_TIMEOUT ) ); 00573 00574 00575 // If TIMEOUT, exit with failure. 00576 if ( ii >= MLX90614_TIMEOUT ) 00577 return MLX90614_FAILURE; 00578 else 00579 { 00580 // It gets the IIR 00581 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00582 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00583 00584 // Update the new value 00585 cmd[2] = cmd[1]; // MSB 00586 cmd[1] = ( ( cmd[0] & ~CONFIGREG1_IIR_MASK ) | myIIR ); // LSB 00587 cmd[0] = MLX90614_CONFIG_REGISTER_1 ; // Command 00588 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 2, false ); 00589 } 00590 00591 00592 00593 00594 if ( aux == I2C_SUCCESS ) 00595 return MLX90614_SUCCESS; 00596 else 00597 return MLX90614_FAILURE; 00598 } 00599 00600 00601 /** 00602 * @brief MLX90614_GetTemperatureSource ( MLX90614_vector_data_t* ) 00603 * 00604 * @details It gets the temperature source. 00605 * 00606 * @param[in] NaN 00607 * 00608 * @param[out] myTempSource: Temperature source. 00609 * 00610 * 00611 * @return Status of MLX90614_GetTemperatureSource. 00612 * 00613 * 00614 * @author Manuel Caballero 00615 * @date 26/December/2017 00616 * @version 26/December/2017 The ORIGIN 00617 * @pre NaN. 00618 * @warning NaN. 00619 */ 00620 MLX90614::MLX90614_status_t MLX90614::MLX90614_GetTemperatureSource ( MLX90614_vector_data_t* myTempSource ) 00621 { 00622 char cmd[] = { MLX90614_CONFIG_REGISTER_1 , 0, 0 }; 00623 uint32_t aux = 0; 00624 00625 00626 // It gets the temperature source 00627 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00628 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00629 00630 00631 myTempSource->TempSource = ( MLX90614_configregister1_temp_t )( cmd[0] & CONFIGREG1_TEMP_MASK ); 00632 myTempSource->PEC = cmd[2]; 00633 00634 00635 00636 00637 if ( aux == I2C_SUCCESS ) 00638 return MLX90614_SUCCESS; 00639 else 00640 return MLX90614_FAILURE; 00641 } 00642 00643 00644 /** 00645 * @brief MLX90614_SetTemperatureSource ( I2C_parameters_t , MLX90614_configregister1_temp_t ) 00646 * 00647 * @details It sets the temperature source. 00648 * 00649 * @param[in] myTempSource: Temperature source. 00650 * 00651 * @param[out] NaN. 00652 * 00653 * 00654 * @return Status of MLX90614_SetTemperatureSource. 00655 * 00656 * 00657 * @author Manuel Caballero 00658 * @date 26/December/2017 00659 * @version 26/December/2017 The ORIGIN 00660 * @pre NaN. 00661 * @warning NaN. 00662 */ 00663 MLX90614::MLX90614_status_t MLX90614::MLX90614_SetTemperatureSource ( MLX90614_configregister1_temp_t myTempSource ) 00664 { 00665 char cmd[] = { MLX90614_CONFIG_REGISTER_1 , 0, 0 }; 00666 uint32_t aux = 0; 00667 uint32_t ii = 0; 00668 00669 00670 // It gets the IIR 00671 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00672 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00673 00674 // Erase EEPROM 00675 cmd[2] = cmd[1]; // MSB 00676 cmd[1] = ( cmd[0] & ~CONFIGREG1_TEMP_MASK ); // LSB 00677 cmd[0] = MLX90614_CONFIG_REGISTER_1 ; // Command 00678 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 3, false ); 00679 00680 // It takes EEPROM about 5ms to write/read 00681 do 00682 { 00683 cmd[0] = MLX90614_FLAGS ; 00684 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00685 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], 3 ); 00686 ii++; // Increase the timeout 00687 } 00688 while ( ( ( cmd[0] & FLAG_EEBUSY_HIGH ) == FLAG_EEBUSY_HIGH ) && ( ii < MLX90614_TIMEOUT ) ); 00689 00690 00691 // If TIMEOUT, exit with failure. 00692 if ( ii >= MLX90614_TIMEOUT ) 00693 return MLX90614_FAILURE; 00694 else 00695 { 00696 // It gets the IIR 00697 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00698 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00699 00700 // Update the new value 00701 cmd[2] = cmd[1]; // MSB 00702 cmd[1] = ( ( cmd[0] & ~CONFIGREG1_TEMP_MASK ) | myTempSource ); // LSB 00703 cmd[0] = MLX90614_CONFIG_REGISTER_1 ; // Command 00704 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 2, false ); 00705 } 00706 00707 00708 00709 00710 if ( aux == I2C_SUCCESS ) 00711 return MLX90614_SUCCESS; 00712 else 00713 return MLX90614_FAILURE; 00714 } 00715 00716 00717 /** 00718 * @brief MLX90614_GetFLAGS ( MLX90614_vector_data_t* ) 00719 * 00720 * @details It gets the flags. 00721 * 00722 * @param[in] NaN. 00723 * 00724 * @param[out] myFlags: Flags. 00725 * 00726 * 00727 * @return Status of MLX90614_GetFLAGS. 00728 * 00729 * 00730 * @author Manuel Caballero 00731 * @date 26/December/2017 00732 * @version 26/December/2017 The ORIGIN 00733 * @pre NaN. 00734 * @warning NaN. 00735 */ 00736 MLX90614::MLX90614_status_t MLX90614::MLX90614_GetFLAGS ( MLX90614_vector_data_t* myFlags ) 00737 { 00738 char cmd[] = { MLX90614_FLAGS , 0, 0 }; 00739 uint32_t aux = 0; 00740 00741 00742 // It gets the flags 00743 aux = _i2c.write ( _MLX90614_Addr, &cmd[0], 1, true ); 00744 aux = _i2c.read ( _MLX90614_Addr, &cmd[0], sizeof( cmd )/sizeof( cmd[0] ) ); 00745 00746 00747 myFlags->Flags = ( MLX90614_flags_t )cmd[0]; 00748 myFlags->PEC = cmd[2]; 00749 00750 00751 00752 00753 if ( aux == I2C_SUCCESS ) 00754 return MLX90614_SUCCESS; 00755 else 00756 return MLX90614_FAILURE; 00757 }
Generated on Sat Jul 16 2022 10:32:24 by 1.7.2