Diff: main.cpp

Revision:

6:7946b5c2376a

Parent:

5:a946ef74a8c4

Child:

7:dd550a829ece

diff -r a946ef74a8c4 -r 7946b5c2376a main.cpp
--- a/main.cpp	Sat Sep 26 22:07:27 2015 +0000
+++ b/main.cpp	Wed Dec 09 21:35:00 2015 +0000
@@ -1,6 +1,6 @@
 /*************************************************************************
  * Dragonfly Example program for 2015 AT&T Government Solutions Hackathon
- * 
+ *
  * The following hardware is required to successfully run this program:
  *   - MultiTech UDK2 (4" square white PCB with Arduino headers, antenna
  *     connector, micro USB ports, and 40-pin connector for Dragonfly)
@@ -45,10 +45,23 @@
  * Go have fun and make something cool!
  *
  ************************************************************************/
- 
+/*
+Sample Program Description:
+   This Program will enable to Multi-Tech Dragonfly platform to utilize ROHM's Multi-sensor Shield Board.
+   This program will initialize all sensors on the shield and then read back the sensor data.
+   Data will then be output to the UART Debug Terminal every 1 second.
+
+Sample Program Author:
+   ROHM USDC
+
+Additional Resources:
+   ROHM Sensor Shield GitHub Repository: https://github.com/ROHMUSDC/ROHM_SensorPlatform_Multi-Sensor-Shield
+*/
+
+
+
 #include "mbed.h"
 #include "mtsas.h"
-#include "x_nucleo_iks01a1.h"
 #include "MbedJSONValue.h"
 #include "HTTPJson.h"
 #include <string>
@@ -85,19 +98,9 @@
 
 std::string url = "http://api-m2x.att.com/v2/devices/" + m2x_device_id + "/update";
 
-// handle to MEMs board object
-static X_NUCLEO_IKS01A1* mems = X_NUCLEO_IKS01A1::Instance();
-
-// Moisture sensor
-AnalogIn moisture_sensor(A0);
-
-// Button
-InterruptIn button(D8);
-bool button_pressed = false;
 
 // variables for sensor data
 float temp_celsius;
-float temp_fahrenheit;
 float humidity_percent;
 float pressure_mbar;
 float moisture_percent;
@@ -108,110 +111,348 @@
 // misc variables
 static char wall_of_dash[] = "--------------------------------------------------";
 bool radio_ok = false;
-static int thpm_interval_ms = 2000;
-static int motion_interval_ms = 250;
-static int print_interval_ms = 10000;
+static int thpm_interval_ms = 5000;
+static int motion_interval_ms = 5000;
+static int print_interval_ms = 5000;
+static int sms_interval_ms = 60000;
 static int post_interval_ms = 30000;
 int debug_baud = 115200;
 
+
+
+
+/****************************************************************************************************
+
+ ****************************************************************************************************/
+
+//Macros for checking each of the different Sensor Devices
+#define AnalogTemp  //BDE0600
+#define AnalogUV    //ML8511
+#define HallSensor  //BU52011
+#define RPR0521     //RPR0521
+#define KMX62       //KMX61, Accel/Mag         
+#define COLOR       //BH1745
+#define KX022       //KX022, Accel Only
+#define Pressure    //BM1383
+#define SMS         //allow SMS messaging
+#define Web         //allow M2X communication
+
+
+//Define Pins for I2C Interface
+I2C i2c(I2C_SDA, I2C_SCL);
+bool        RepStart = true;
+bool        NoRepStart = false;
+
+//Define Sensor Variables
+#ifdef AnalogTemp
+AnalogIn    BDE0600_Temp(PC_4); //Mapped to A2
+uint16_t    BDE0600_Temp_value;
+float       BDE0600_output;
+#endif
+
+#ifdef AnalogUV
+AnalogIn    ML8511_UV(PC_1);    //Mapped to A4
+uint16_t    ML8511_UV_value;
+float       ML8511_output;
+#endif
+
+#ifdef HallSensor
+DigitalIn   Hall_GPIO0(PC_8);
+DigitalIn   Hall_GPIO1(PB_5);
+int         Hall_Return1;
+int         Hall_Return0;
+int32_t     Hall_Return[2];
+#endif
+
+#ifdef RPR0521
+int         RPR0521_addr_w = 0x70;          //7bit addr = 0x38, with write bit 0
+int         RPR0521_addr_r = 0x71;          //7bit addr = 0x38, with read bit 1
+char        RPR0521_ModeControl[2] = {0x41, 0xE6};
+char        RPR0521_ALSPSControl[2] = {0x42, 0x03};
+char        RPR0521_Persist[2] = {0x43, 0x20};
+char        RPR0521_Addr_ReadData = 0x44;
+char        RPR0521_Content_ReadData[6];
+int         RPR0521_PS_RAWOUT = 0;                  //this is an output
+float       RPR0521_PS_OUT = 0;
+int         RPR0521_ALS_D0_RAWOUT = 0;
+int         RPR0521_ALS_D1_RAWOUT = 0;
+float       RPR0521_ALS_DataRatio = 0;
+float       RPR0521_ALS_OUT = 0;                    //this is an output
+float       RPR0521_ALS[2];                         // is this ok taking an int to the [0] value and float to [1]???????????
+#endif
+
+#ifdef KMX62
+int         KMX62_addr_w = 0x1C;          //7bit addr = 0x38, with write bit 0
+int         KMX62_addr_r = 0x1D;          //7bit addr = 0x38, with read bit 1
+char        KMX62_CNTL2[2] = {0x3A, 0x5F};
+char        KMX62_Addr_Accel_ReadData = 0x0A;
+char        KMX62_Content_Accel_ReadData[6];
+char        KMX62_Addr_Mag_ReadData = 0x10;
+char        KMX62_Content_Mag_ReadData[6];
+short int   MEMS_Accel_Xout = 0;
+short int   MEMS_Accel_Yout = 0;
+short int   MEMS_Accel_Zout = 0;
+double      MEMS_Accel_Conv_Xout = 0;
+double      MEMS_Accel_Conv_Yout = 0;
+double      MEMS_Accel_Conv_Zout = 0;
+
+short int   MEMS_Mag_Xout = 0;
+short int   MEMS_Mag_Yout = 0;
+short int   MEMS_Mag_Zout = 0;
+float       MEMS_Mag_Conv_Xout = 0;
+float       MEMS_Mag_Conv_Yout = 0;
+float       MEMS_Mag_Conv_Zout = 0;
+
+double      MEMS_Accel[3];
+float       MEMS_Mag[3];
+#endif
+
+#ifdef COLOR
+int         BH1745_addr_w = 0x72;   //write
+int         BH1745_addr_r = 0x73;   //read
+char        BH1745_persistence[2] = {0x61, 0x03};
+char        BH1745_mode1[2] = {0x41, 0x00};
+char        BH1745_mode2[2] = {0x42, 0x92};
+char        BH1745_mode3[2] = {0x43, 0x02};
+char        BH1745_Content_ReadData[6];
+char        BH1745_Addr_color_ReadData = 0x50;
+int         BH1745_Red;
+int         BH1745_Blue;
+int         BH1745_Green;
+int32_t     BH1745[3];  //Red, Blue Green matrix
+#endif
+
+#ifdef KX022
+int         KX022_addr_w = 0x3C;   //write
+int         KX022_addr_r = 0x3D;   //read
+char        KX022_Accel_CNTL1[2] = {0x18, 0x41};
+char        KX022_Accel_ODCNTL[2] = {0x1B, 0x02};
+char        KX022_Accel_CNTL3[2] = {0x1A, 0xD8};
+char        KX022_Accel_TILT_TIMER[2] = {0x22, 0x01};
+char        KX022_Accel_CNTL2[2] = {0x18, 0xC1};
+char        KX022_Content_ReadData[6];
+char        KX022_Addr_Accel_ReadData = 0x06;
+float       KX022_Accel_X;
+float       KX022_Accel_Y;
+float       KX022_Accel_Z;
+short int   KX022_Accel_X_RawOUT = 0;
+short int   KX022_Accel_Y_RawOUT = 0;
+short int   KX022_Accel_Z_RawOUT = 0;
+int         KX022_Accel_X_LB = 0;
+int         KX022_Accel_X_HB = 0;
+int         KX022_Accel_Y_LB = 0;
+int         KX022_Accel_Y_HB = 0;
+int         KX022_Accel_Z_LB = 0;
+int         KX022_Accel_Z_HB = 0;
+float       KX022_Accel[3];
+#endif
+
+#ifdef Pressure
+int         Press_addr_w = 0xBA;   //write
+int         Press_addr_r = 0xBB;   //read
+char        PWR_DOWN[2] = {0x12, 0x01};
+char        SLEEP[2] = {0x13, 0x01};
+char        Mode_Control[2] = {0x14, 0xC4};
+char        Press_Content_ReadData[6];
+char        Press_Addr_ReadData =0x1A;
+int         BM1383_Temp_highByte;
+int         BM1383_Temp_lowByte;
+int         BM1383_Pres_highByte;
+int         BM1383_Pres_lowByte;
+int         BM1383_Pres_leastByte;
+short int   BM1383_Temp_Out;
+float       BM1383_Temp_Conv_Out;
+float       BM1383_Pres_Conv_Out;
+float_t       BM1383[2];   // Temp is 0 and Pressure is 1
+float       BM1383_Var;
+float       BM1383_Deci;
+#endif
+
+/****************************************************************************************************
 // function prototypes
+ ****************************************************************************************************/
 bool init_mtsas();
-void read_temperature();
-void read_humidity();
-void read_pressure();
-void read_moisture();
-void read_magnetometer();
-void read_accelerometer();
-void read_gyroscope();
-void button_irq();
+void ReadAnalogTemp();
+void ReadAnalogUV ();
+void ReadHallSensor ();
+void ReadCOLOR ();
+void ReadRPR0521_ALS ();
+void ReadKMX62_Accel ();
+void ReadKMX62_Mag ();
+void ReadPressure ();
+void ReadKX022();
 
+/****************************************************************************************************
 // main
-int main() {
+ ****************************************************************************************************/
+int main()
+{
     mts::MTSLog::setLogLevel(mts::MTSLog::TRACE_LEVEL);
     debug.baud(debug_baud);
     logInfo("starting...");
-    
+
+
+    /****************************************************************************************************
+          Initialize I2C Devices ************
+     ****************************************************************************************************/
+
+#ifdef RPR0521
+    i2c.write(RPR0521_addr_w, &RPR0521_ModeControl[0], 2, false);
+    i2c.write(RPR0521_addr_w, &RPR0521_ALSPSControl[0], 2, false);
+    i2c.write(RPR0521_addr_w, &RPR0521_Persist[0], 2, false);
+#endif
+
+#ifdef KMX62
+    i2c.write(KMX62_addr_w, &KMX62_CNTL2[0], 2, false);
+#endif
+
+#ifdef COLOR
+    i2c.write(BH1745_addr_w, &BH1745_persistence[0], 2, false);
+    i2c.write(BH1745_addr_w, &BH1745_mode1[0], 2, false);
+    i2c.write(BH1745_addr_w, &BH1745_mode2[0], 2, false);
+    i2c.write(BH1745_addr_w, &BH1745_mode3[0], 2, false);
+#endif
+
+#ifdef KX022
+    i2c.write(KX022_addr_w, &KX022_Accel_CNTL1[0], 2, false);
+    i2c.write(KX022_addr_w, &KX022_Accel_ODCNTL[0], 2, false);
+    i2c.write(KX022_addr_w, &KX022_Accel_CNTL3[0], 2, false);
+    i2c.write(KX022_addr_w, &KX022_Accel_TILT_TIMER[0], 2, false);
+    i2c.write(KX022_addr_w, &KX022_Accel_CNTL2[0], 2, false);
+#endif
+
+#ifdef Pressure
+    i2c.write(Press_addr_w, &PWR_DOWN[0], 2, false);
+    i2c.write(Press_addr_w, &SLEEP[0], 2, false);
+    i2c.write(Press_addr_w, &Mode_Control[0], 2, false);
+#endif
+//End I2C Initialization Section **********************************************************
+
+
+// Initialization Radio Section **********************************************************
+
     radio_ok = init_mtsas();
     if (! radio_ok)
         logError("MTSAS init failed");
     else
         logInfo("MTSAS is ok");
-        
-    button.fall(&button_irq);
-        
+
+//End Radio Initialization Section **********************************************************
+
+//    button.fall(&button_irq);
+
+
     Timer thpm_timer;
-    Timer motion_timer;
+    thpm_timer.start();         // Timer data is set in the Variable seciton see misc variables    Timer motion_timer;
     Timer print_timer;
+    print_timer.start();
+    Timer motion_timer;
+    motion_timer.start();
+
+#ifdef SMS
+    Timer sms_timer;
+    sms_timer.start();
+#endif
+#ifdef Web
     Timer post_timer;
-    
-    thpm_timer.start();
-    motion_timer.start();
-    print_timer.start();
     post_timer.start();
+#endif
     
     while (true) {
+        if (thpm_timer.read_ms() > thpm_interval_ms) {
+#ifdef AnalogTemp
+            ReadAnalogTemp ();
+#endif
+
+#ifdef AnalogUV
+            ReadAnalogUV ();
+#endif
+
+#ifdef HallSensor
+            ReadHallSensor ();
+#endif
+
+#ifdef COLOR
+            ReadCOLOR ();
+#endif
+
+#ifdef RPR0521       //als digital
+            ReadRPR0521_ALS ();
+#endif
+
+#ifdef Pressure
+            ReadPressure();
+#endif
+            thpm_timer.reset();
+        }
+
         if (motion_timer.read_ms() > motion_interval_ms) {
-            read_magnetometer();
-            read_accelerometer();
-            read_gyroscope();
+#ifdef KMX62
+            ReadKMX62_Accel ();
+            ReadKMX62_Mag ();
+#endif
+
+#ifdef KX022
+            ReadKX022 ();
+#endif
             motion_timer.reset();
         }
-        
-        if (thpm_timer.read_ms() > thpm_interval_ms) {
-            read_temperature();
-            read_humidity();
-            read_pressure();
-            read_moisture();
-            thpm_timer.reset();
-        }
-        
+
         if (print_timer.read_ms() > print_interval_ms) {
             logDebug("%s", wall_of_dash);
             logDebug("SENSOR DATA");
-            logDebug("temperature: %f C\t%f F", temp_celsius, temp_fahrenheit);
-            logDebug("humidity: %f%%",  humidity_percent);
-            logDebug("pressure: %f mbar", pressure_mbar);
-            logDebug("moisture: %f%%", moisture_percent);
-            logDebug("magnetometer:\r\n\tx: %ld\ty: %ld\tz: %ld\tmgauss", mag_mgauss[0], mag_mgauss[1], mag_mgauss[2]);
-            logDebug("accelerometer:\r\n\tx: %ld\ty: %ld\tz: %ld\tmg", acc_mg[0], acc_mg[1], acc_mg[2]);
-            logDebug("gyroscope:\r\n\tx: %ld\ty: %ld\tz: %ld\tmdps", gyro_mdps[0], gyro_mdps[1], gyro_mdps[2]);
+            logDebug("temperature: %0.2f C", BM1383[0]);
+            logDebug("analog uv: %.1f mW/cm2", ML8511_output);
+            logDebug("ambient Light  %0.3f", RPR0521_ALS[0]);
+            logDebug("proximity count  %0.3f", RPR0521_ALS[1]);
+            logDebug("hall effect: South %d\t North %d",  Hall_Return[0],Hall_Return[1]);
+            logDebug("pressure: %0.2f hPa", BM1383[1]);
+            logDebug("magnetometer:\r\n\tx: %0.3f\ty: %0.3f\tz: %0.3f\tuT", MEMS_Mag[0], MEMS_Mag[1], MEMS_Mag[2]);
+            logDebug("accelerometer:\r\n\tx: %0.3f\ty: %0.3f\tz: %0.3f\tg", MEMS_Accel[0], MEMS_Accel[1], MEMS_Accel[2]);
+            logDebug("color:\r\n\tred: %ld\tgrn: %ld\tblu: %ld\t", BH1745[0], BH1745[1], BH1745[2]);
             logDebug("%s", wall_of_dash);
             print_timer.reset();
         }
-        
-        if (button_pressed) {
-            logInfo("Button was pressed");
-            button_pressed = false;
+
+
+
+#ifdef SMS
+        if (sms_timer.read_ms() > sms_interval_ms) {
+            sms_timer.reset();
+            logInfo("SMS Send Routine");
+printf("  In sms routine \r\n");
             if (radio_ok) {
                 MbedJSONValue sms_json;
                 string sms_str;
-                
-                sms_json["temp_C"] = temp_celsius;
-                sms_json["temp_F"] = temp_fahrenheit;
-                sms_json["humidity_percent"] = humidity_percent;
-                sms_json["pressure_mbar"] = pressure_mbar;
-                sms_json["moisture_percent"] = moisture_percent;
-                sms_json["mag_mgauss"]["x"] = mag_mgauss[0];
-                sms_json["mag_mgauss"]["y"] = mag_mgauss[1];
-                sms_json["mag_mgauss"]["z"] = mag_mgauss[2];
-                sms_json["acc_mg"]["x"] = acc_mg[0];
-                sms_json["acc_mg"]["y"] = acc_mg[1];
-                sms_json["acc_mg"]["z"] = acc_mg[2];
-                sms_json["gyro_mdps"]["x"] = gyro_mdps[0];
-                sms_json["gyro_mdps"]["y"] = gyro_mdps[1];
-                sms_json["gyro_mdps"]["z"] = gyro_mdps[2];
-                
+
+//                sms_json["temp_C"] = BDE0600_output;
+//                sms_json["UV"] = ML8511_output;
+                sms_json["Ambient Light"] = RPR0521_ALS[0];
+                sms_json["Prox"]      = RPR0521_ALS[1];
+//                sms_json["pressure_hPa"] = BM1383[1];
+//                sms_json["mag_mgauss"]["x"] = MEMS_Mag[0];
+//                sms_json["mag_mgauss"]["y"] = MEMS_Mag[1];
+//                sms_json["mag_mgauss"]["z"] = MEMS_Mag[2];
+//                sms_json["acc_mg"]["x"] = MEMS_Accel[0];
+//                sms_json["acc_mg"]["y"] = MEMS_Accel[1];
+//                sms_json["acc_mg"]["z"] = MEMS_Accel[2];
+//                sms_json["Red"]   = BH1745[0];
+//                sms_json["Green"] = BH1745[1];
+//                sms_json["Blue"]  = BH1745[2];
+
                 sms_str = "SENSOR DATA:\n";
                 sms_str += sms_json.serialize();
-                
+
                 logDebug("sending SMS to %s:\r\n%s", phone_number.c_str(), sms_str.c_str());
                 Code ret = radio->sendSMS(phone_number, sms_str);
                 if (ret != MTS_SUCCESS)
                     logError("sending SMS failed");
             }
         }
-        
+#endif
+#ifdef Web
         if (post_timer.read_ms() > post_interval_ms && do_cloud_post) {
+    printf("in web\n\r");
             if (radio->connect()) {
                 logDebug("posting sensor data");
 
@@ -222,115 +463,300 @@
                 int ret;
                 char http_response_buf[256];
                 HTTPText http_response(http_response_buf, sizeof(http_response_buf));
-                
+
                 // temp_c, temp_f, humidity, pressure, and moisture are all stream IDs for my device in M2X
                 // modify these to match your streams or give your streams the same name
-                http_json_data["values"]["temp_c"] = temp_celsius;
-                http_json_data["values"]["temp_f"] = temp_fahrenheit;
-                http_json_data["values"]["humidity"] = humidity_percent;
-                http_json_data["values"]["pressure"] = pressure_mbar;
-                http_json_data["values"]["moisture"] = moisture_percent;
+                http_json_data["values"]["temp_c"] = BDE0600_output;
+                http_json_data["values"]["UV"] = ML8511_output;
+                http_json_data["values"]["Ambient Light"] = RPR0521_ALS[0];
+                http_json_data["values"]["Prox"] = RPR0521_ALS[1];
                 http_json_str = http_json_data.serialize();
-                
+
                 // add extra header with M2X API key
                 http.setHeader(m2x_header.c_str());
-                
+
                 HTTPJson http_json((char*)  http_json_str.c_str());
                 ret = http.post(url.c_str(), http_json, &http_response);
                 if (ret != HTTP_OK)
                     logError("posting data to cloud failed: [%d][%s]", ret, http_response_buf);
                 else
                     logDebug("post result [%d][%s]", http.getHTTPResponseCode(), http_response_buf);
-                
+
                 radio->disconnect();
             } else {
                 logError("establishing PPP link failed");
             }
-            
+
             post_timer.reset();
         }
-        
+#endif
         wait_ms(10);
     }
 }
 
 // init functions
-bool init_mtsas() {
+bool init_mtsas()
+{
     io = new MTSSerialFlowControl(RADIO_TX, RADIO_RX, RADIO_RTS, RADIO_CTS);
     if (! io)
         return false;
-        
+
     io->baud(115200);
     radio = CellularFactory::create(io);
     if (! radio)
         return false;
-        
+
     Code ret = radio->setApn(apn);
     if (ret != MTS_SUCCESS)
         return false;
-        
+
     Transport::setTransport(radio);
-        
+
     return true;
 }
 
+
 // Sensor data acquisition functions
-void read_temperature() {
-    int ret;
+/************************************************************************************************/
+#ifdef AnalogTemp
+void ReadAnalogTemp ()
+{
+    BDE0600_Temp_value = BDE0600_Temp.read_u16();
+
+    BDE0600_output = (float)BDE0600_Temp_value * (float)0.000050354; //(value * (3.3V/65535))
+    BDE0600_output = (BDE0600_output-(float)1.753)/((float)-0.01068) + (float)30;
+
+//    printf("BDE0600 Analog Temp Sensor Data:\r\n");
+//    printf(" Temp = %.2f C\r\n", BDE0600_output);
+}
+#endif
+
+#ifdef AnalogUV
+void ReadAnalogUV ()
+{
+    ML8511_UV_value = ML8511_UV.read_u16();
+    ML8511_output = (float)ML8511_UV_value * (float)0.000050354; //(value * (3.3V/65535))   //Note to self: when playing with this, a negative value is seen... Honestly, I think this has to do with my ADC converstion...
+    ML8511_output = (ML8511_output-(float)2.2)/((float)0.129) + 10;                           // Added +5 to the offset so when inside (aka, no UV, readings show 0)... this is the wrong approach... and the readings don't make sense... Fix this.
+
+//    printf("ML8511 Analog UV Sensor Data:\r\n");
+//    printf(" UV = %.1f mW/cm2\r\n", ML8511_output);
+
+}
+#endif
+
+
+#ifdef HallSensor
+void ReadHallSensor ()
+{
+
+    Hall_Return[0] = Hall_GPIO0;
+    Hall_Return[1] = Hall_GPIO1;
+
+//    printf("BU52011 Hall Switch Sensor Data:\r\n");
+//    printf(" South Detect = %d\r\n", Hall_Return[0]);
+//    printf(" North Detect = %d\r\n", Hall_Return[1]);
+
     
-    ret = mems->ht_sensor->GetTemperature(&temp_celsius);
-    if (ret)
-        logError("reading temp (C) failed");
-        
-    ret = mems->ht_sensor->GetFahrenheit(&temp_fahrenheit);
-    if (ret)
-        logError("reading temp (F) failed");
 }
+#endif
+
+#ifdef COLOR
+void ReadCOLOR ()
+{
+
+    //Read color data from the IC
+    i2c.write(BH1745_addr_w, &BH1745_Addr_color_ReadData, 1, RepStart);
+    i2c.read(BH1745_addr_r, &BH1745_Content_ReadData[0], 6, NoRepStart);
+
+    //separate all data read into colors
+    BH1745[0] = (BH1745_Content_ReadData[1]<<8) | (BH1745_Content_ReadData[0]);
+    BH1745[1] = (BH1745_Content_ReadData[3]<<8) | (BH1745_Content_ReadData[2]);
+    BH1745[2] = (BH1745_Content_ReadData[5]<<8) | (BH1745_Content_ReadData[4]);
 
-void read_humidity() {
-    int ret;
-    
-    ret = mems->ht_sensor->GetHumidity(&humidity_percent);
-    if (ret)
-        logError("reading humidity failed");
+    //Output Data into UART
+//    printf("BH1745 COLOR Sensor Data:\r\n");
+//    printf(" Red   = %d ADC Counts\r\n",BH1745[0]);
+//    printf(" Green = %d ADC Counts\r\n",BH1745[1]);
+//    printf(" Blue  = %d ADC Counts\r\n",BH1745[2]);
+
 }
+#endif
 
-void read_pressure() {
-    int ret;
-    
-    ret = mems->pt_sensor->GetPressure(&pressure_mbar);
-    if (ret)
-        logError("reading pressure failed");
+#ifdef RPR0521       //als digital
+void ReadRPR0521_ALS ()
+{
+    i2c.write(RPR0521_addr_w, &RPR0521_Addr_ReadData, 1, RepStart);
+    i2c.read(RPR0521_addr_r, &RPR0521_Content_ReadData[0], 6, NoRepStart);
+
+    RPR0521_ALS[1] = (RPR0521_Content_ReadData[1]<<8) | (RPR0521_Content_ReadData[0]);
+    RPR0521_ALS_D0_RAWOUT = (RPR0521_Content_ReadData[3]<<8) | (RPR0521_Content_ReadData[2]);
+    RPR0521_ALS_D1_RAWOUT = (RPR0521_Content_ReadData[5]<<8) | (RPR0521_Content_ReadData[4]);
+    RPR0521_ALS_DataRatio = (float)RPR0521_ALS_D1_RAWOUT / (float)RPR0521_ALS_D0_RAWOUT;
+
+    if(RPR0521_ALS_DataRatio < (float)0.595) {
+        RPR0521_ALS[0] = ((float)1.682*(float)RPR0521_ALS_D0_RAWOUT - (float)1.877*(float)RPR0521_ALS_D1_RAWOUT);
+    } else if(RPR0521_ALS_DataRatio < (float)1.015) {
+        RPR0521_ALS[0] = ((float)0.644*(float)RPR0521_ALS_D0_RAWOUT - (float)0.132*(float)RPR0521_ALS_D1_RAWOUT);
+    } else if(RPR0521_ALS_DataRatio < (float)1.352) {
+        RPR0521_ALS[0] = ((float)0.756*(float)RPR0521_ALS_D0_RAWOUT - (float)0.243*(float)RPR0521_ALS_D1_RAWOUT);
+    } else if(RPR0521_ALS_DataRatio < (float)3.053) {
+        RPR0521_ALS[0] = ((float)0.766*(float)RPR0521_ALS_D0_RAWOUT - (float)0.25*(float)RPR0521_ALS_D1_RAWOUT);
+    } else {
+        RPR0521_ALS[0] = 0;
+    }
+//    printf("RPR-0521 ALS/PROX Sensor Data:\r\n");
+//    printf(" ALS = %0.2f lx\r\n", RPR0521_ALS[0]);
+//    printf(" PROX= %0.2f ADC Counts\r\n", RPR0521_ALS[1]);     //defined as a float but is an unsigned.
+
+}
+#endif
+
+#ifdef KMX62
+void ReadKMX62_Accel ()
+{
+    //Read Accel Portion from the IC
+    i2c.write(KMX62_addr_w, &KMX62_Addr_Accel_ReadData, 1, RepStart);
+    i2c.read(KMX62_addr_r, &KMX62_Content_Accel_ReadData[0], 6, NoRepStart);
+
+    //Note: The highbyte and low byte return a 14bit value, dropping the two LSB in the Low byte.
+    //      However, because we need the signed value, we will adjust the value when converting to "g"
+    MEMS_Accel_Xout = (KMX62_Content_Accel_ReadData[1]<<8) | (KMX62_Content_Accel_ReadData[0]);
+    MEMS_Accel_Yout = (KMX62_Content_Accel_ReadData[3]<<8) | (KMX62_Content_Accel_ReadData[2]);
+    MEMS_Accel_Zout = (KMX62_Content_Accel_ReadData[5]<<8) | (KMX62_Content_Accel_ReadData[4]);
+
+    //Note: Conversion to G is as follows:
+    //      Axis_ValueInG = MEMS_Accel_axis / 1024
+    //      However, since we did not remove the LSB previously, we need to divide by 4 again
+    //      Thus, we will divide the output by 4096 (1024*4) to convert and cancel out the LSB
+    MEMS_Accel[0] = ((float)MEMS_Accel_Xout/4096/2);
+    MEMS_Accel[1] = ((float)MEMS_Accel_Yout/4096/2);
+    MEMS_Accel[2] = ((float)MEMS_Accel_Zout/4096/2);
+
+    // Return Data to UART
+//    printf("KMX62 Accel+Mag Sensor Data:\r\n");
+//    printf(" AccX= %0.2f g\r\n", MEMS_Accel[0]);
+//    printf(" AccY= %0.2f g\r\n", MEMS_Accel[1]);
+//    printf(" AccZ= %0.2f g\r\n", MEMS_Accel[2]);
+
 }
 
-void read_moisture() {
-    moisture_percent = moisture_sensor * 100.0;
-}
+void ReadKMX62_Mag ()
+{
+
+    //Read Mag portion from the IC
+    i2c.write(KMX62_addr_w, &KMX62_Addr_Mag_ReadData, 1, RepStart);
+    i2c.read(KMX62_addr_r, &KMX62_Content_Mag_ReadData[0], 6, NoRepStart);
+
+    //Note: The highbyte and low byte return a 14bit value, dropping the two LSB in the Low byte.
+    //      However, because we need the signed value, we will adjust the value when converting to "g"
+    MEMS_Mag_Xout = (KMX62_Content_Mag_ReadData[1]<<8) | (KMX62_Content_Mag_ReadData[0]);
+    MEMS_Mag_Yout = (KMX62_Content_Mag_ReadData[3]<<8) | (KMX62_Content_Mag_ReadData[2]);
+    MEMS_Mag_Zout = (KMX62_Content_Mag_ReadData[5]<<8) | (KMX62_Content_Mag_ReadData[4]);
 
-void read_magnetometer() {
-    int ret;
-    
-    ret = mems->magnetometer->Get_M_Axes(mag_mgauss);
-    if (ret)
-        logError("reading magnetometer failed");
+    //Note: Conversion to G is as follows:
+    //      Axis_ValueInG = MEMS_Accel_axis / 1024
+    //      However, since we did not remove the LSB previously, we need to divide by 4 again
+    //      Thus, we will divide the output by 4095 (1024*4) to convert and cancel out the LSB
+    MEMS_Mag[0] = (float)MEMS_Mag_Xout/4096*(float)0.146;
+    MEMS_Mag[1] = (float)MEMS_Mag_Yout/4096*(float)0.146;
+    MEMS_Mag[2] = (float)MEMS_Mag_Zout/4096*(float)0.146;
+
+    // Return Data to UART
+//    printf(" MagX= %0.2f uT\r\n", MEMS_Mag[0]);
+//    printf(" MagY= %0.2f uT\r\n", MEMS_Mag[1]);
+//    printf(" MagZ= %0.2f uT\r\n", MEMS_Mag[2]);
+
 }
+#endif
 
-void read_accelerometer() {
-    int ret;
+#ifdef KX022
+void ReadKX022 ()
+{
     
-    ret = mems->GetAccelerometer()->Get_X_Axes(acc_mg);
-    if (ret)
-        logError("reading accelerometer failed");
+    //Read KX022 Portion from the IC
+    i2c.write(KX022_addr_w, &KX022_Addr_Accel_ReadData, 1, RepStart);
+    i2c.read(KX022_addr_r, &KX022_Content_ReadData[0], 6, NoRepStart);
+
+    //Format Data
+    KX022_Accel_X_RawOUT = (KX022_Content_ReadData[1]<<8) | (KX022_Content_ReadData[0]);
+    KX022_Accel_Y_RawOUT = (KX022_Content_ReadData[3]<<8) | (KX022_Content_ReadData[2]);
+    KX022_Accel_Z_RawOUT = (KX022_Content_ReadData[5]<<8) | (KX022_Content_ReadData[4]);
+
+    //Scale Data
+    KX022_Accel[0] = (float)KX022_Accel_X_RawOUT / 16384;
+    KX022_Accel[1] = (float)KX022_Accel_Y_RawOUT / 16384;
+    KX022_Accel[2] = (float)KX022_Accel_Z_RawOUT / 16384;
+
+    //Return Data through UART
+//    printf("KX022 Accelerometer Sensor Data: \r\n");
+//    printf(" AccX= %0.2f g\r\n", KX022_Accel[0]);
+//    printf(" AccY= %0.2f g\r\n", KX022_Accel[1]);
+//    printf(" AccZ= %0.2f g\r\n", KX022_Accel[2]);
+
 }
+#endif
+
+
+#ifdef Pressure
+void ReadPressure ()
+{
+
+    i2c.write(Press_addr_w, &Press_Addr_ReadData, 1, RepStart);
+    i2c.read(Press_addr_r, &Press_Content_ReadData[0], 6, NoRepStart);
+
+    BM1383_Temp_Out = (Press_Content_ReadData[0]<<8) | (Press_Content_ReadData[1]);
+    BM1383[0] = (float)BM1383_Temp_Out/32;
+
+    BM1383_Var  = (Press_Content_ReadData[2]<<3) | (Press_Content_ReadData[3] >> 5);
+    BM1383_Deci = ((Press_Content_ReadData[3] & 0x1f) << 6 | ((Press_Content_ReadData[4] >> 2)));
+    BM1383_Deci = (float)BM1383_Deci* (float)0.00048828125;  //0.00048828125 = 2^-11
+    BM1383[1] = (BM1383_Var + BM1383_Deci);   //question pending here...
+
+//    printf("BM1383 Pressure Sensor Data:\r\n");
+//    printf(" Temperature= %0.2f C\r\n", BM1383[0]);
+//    printf(" Pressure   = %0.2f hPa\r\n", BM1383[1]);
 
-void read_gyroscope() {
-    int ret;
-    
-    ret = mems->GetGyroscope()->Get_G_Axes(gyro_mdps);
-    if (ret)
-        logError("reading gyroscope failed");
 }
+#endif
 
-void button_irq() {
-    button_pressed = true;
-}
+
+/************************************************************************************
+//  reference only to remember what the names and fuctions are without finding them above.
+ ************************************************************************************
+    (" Temp = %.2f C\r\n", BDE0600_output);
+    printf(" UV = %.1f mW/cm2\r\n", ML8511_output);
+
+    printf("BH1745 COLOR Sensor Data:\r\n");
+    printf(" Red   = %d ADC Counts\r\n",BH1745[0]);
+    printf(" Green = %d ADC Counts\r\n",BH1745[1]);
+    printf(" Blue  = %d ADC Counts\r\n",BH1745[2]);
+
+    printf(" ALS = %0.2f lx\r\n", RPR0521_ALS[0]);
+    printf(" PROX= %u ADC Counts\r\n", RPR0521_ALS[1]);     //defined as a float but is an unsigned.
+
+    printf("KMX62 Accel+Mag Sensor Data:\r\n");
+    printf(" AccX= %0.2f g\r\n", MEMS_Accel[0]);
+    printf(" AccY= %0.2f g\r\n", MEMS_Accel[1]);
+    printf(" AccZ= %0.2f g\r\n", MEMS_Accel[2]);
+
+    printf(" MagX= %0.2f uT\r\n", MEMS_Mag[0]);
+    printf(" MagY= %0.2f uT\r\n", MEMS_Mag[1]);
+    printf(" MagZ= %0.2f uT\r\n", MEMS_Mag[2]);
+
+    printf("KX022 Accelerometer Sensor Data: \r\n");
+    printf(" AccX= %0.2f g\r\n", KX022_Accel[0]);
+    printf(" AccY= %0.2f g\r\n", KX022_Accel[1]);
+    printf(" AccZ= %0.2f g\r\n", KX022_Accel[2]);
+
+    printf("BM1383 Pressure Sensor Data:\r\n");
+    printf(" Temperature= %0.2f C\r\n", BM1383[0]);
+    printf(" Pressure   = %0.2f hPa\r\n", BM1383[1]);
+
+ **********************************************************************************/
+
+
+
+
+
+
+