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 }